为什么指向结构的指针表现得像一个结构数组

Question

I have the following code

typedef struct{
    int fildes;
    char key[MAX_KEYLEN];
} item_t;

static int nitems;
static item_t *items;
FILE *filelist;
    int capacity = 16;
    char *path, *ptr;

    if( NULL == (filelist = fopen(filename, "r"))){
        fprintf(stderr, "Unable to open file in content_init.\n");
        exit(EXIT_FAILURE);
    }

    items = (item_t*) malloc(capacity * sizeof(item_t));
    nitems = 0;
    while(fgets(items[nitems].key, MAX_KEYLEN, filelist)){
        /*Taking out EOL character*/
        items[nitems].key[strlen(items[nitems].key)-1] = '\0';
// and there's more code below which is not relevant to the question

In the above code, Item_t is a struct defined as below

typedef struct{
    int fildes;
    char key[MAX_KEYLEN];
} item_t;

Then, items is defined as
static item_t *items;

items is initialized using the following code
items = (item_t*) malloc(capacity * sizeof(item_t));

Then, the following is done with items
fgets(items[nitems].key, MAX_KEYLEN, filelist)

items is supposed to be a struct. How did it become an array? I said array because, items[nitems] is being done which made me feel that items is an array of item_t structs

Answer 1

Pointers and arrays can (for the most part) be used interchangeably.
array[i] is just syntatic sugar for *(array+i) .

Answer 2

Answer to your question "why is pointer to struct behaving like an array of structs ?" (The answer below is applicable to any data type regardless of it being structure or some other data type)

When you initialize an array (of any data type) with 'N' elements you are simply asking for memory of size equal to (N * sizeof(data-type)) whose base address is the address of 1st element in the array (ie element at index zero).

So when you access any element in an array what you are effectively doing is de-referencing a value stored at particular address in memory.

Example:

#define N 3
int32_t array[N] = {11, 22, 33};

Suppose now I want to print the last element in the array (ie element at index 2). Since I know the base address of array, I can access the elements in the array in following ways:

printf("%d \n", array[2]);
/***** OR *****/
printf("%d \n", *(array + 2));

NOTE:

In second printf() from machine's perspective what is happening is this:

*( base-address + index * sizeof(data-type) )

since from machine's perspective the concept of data-type, array, etc doesn't exist. (Simplified explanation without touching the assembly level code)

NOTE:

array[i] is just a syntactic-sugar for *(array + i)