C programming ( Declaration of structs )

First up array here is an array with space allocated within the struct to contain all the elements of that array. It's not a pointer to space outside the struct. With regards to how much space everything takes up the easiest way to see what's going on here is just to run some sizeof checks here:

#include <stdio.h>
typedef struct x 
{
    int y;
    int array[2];
};

int main(void) {
    struct x test1;
    printf("sizeof(int) %zu \n", sizeof(int));
    printf("sizeof(test1) %zu \n", sizeof(test1));
    printf("sizeof(test1.array) %zu", sizeof(test1.array));
    return 0;
}

When run on ideone you get the 4, 12 and 8 here. http://ideone.com/pKBe1X On other systems I've run this I get similar results which leads me to believe that on your machine with your particular compiler options some padding has been added to your structs.

If sizeof(test1.y) + sizeof(test1.array) != sizeof(test1) then you have some padding added in. Adding something such as #pragma pack (ms compiler) or __attribute__((__packed__)) (gcc) will likely change this.

The reason padding would be added by your compiler is because on your particular system there is likely some benefit in terms of access to data speed from having data structures with this particular alignment (multiples of 16 bytes) in memory. For more on that I'd recommend having a look at the Wikipedia page on data structure alignment.

When we declare say :

int array[2];

array = " Holds the address of the first 32 bits" i.e it holds &array[0].

Nope. Not at all. When you declare a 2-element array, what you get is something like the following:

     +---+
arr: |   | arr[0]
     +---+ 
     |   | arr[1]
     +---+

The object associated with the identifier arr is a 2-element array of int, not a pointer. Under most circumstances, the expression arr will be converted ("decay") to an expression of type "pointer to int".

An instance of your struct type would look like:

       +---+
    y: |   | 
       +---+
array: |   | array[0]
       +---+
       |   | array[1]
       +---+

The sum of the sizes of the members is only 12 bytes, so there must be some padding after array to meet an 8- or 16-byte alignment restriction.

An array has some characteristics of a pointer, but it is not a pointer itself. Namely, you can't make it point somewhere else. It always points to its allocated elements.

So a struct containing an array doesn't contain a pointer. It contains, in your case, two ints plus the non-array int. Evidently your CPU is 32-bit, so it contains 12 bytes of data (three 4-byte ints). But some structure padding is added to make each item fall on an 8-byte boundary (for CPU access efficiency). That makes it 16 bytes long. There are compiler options to "pack" the structures so that no padding takes place. Typically #pragma pack(0) on a line by itself in the file, or a compiler command line option.

this gives an idea on the effect of packing on int and char

#include <stdio.h>

#pragma  pack (push, 1)
typedef struct {
    int a;
    int b[2];
}TEST1;

typedef struct {
    int a;
    int b[2];
    char c;
}TEST2;
#pragma pack(pop)

typedef struct {
    int a;
    int b[2];
}TEST3;

typedef struct {
    int a;
    int b[2];
    char c;
}TEST4;

int main(){
    printf(" ==== PAKED =====\t==== DEFAULT =====\n");
    printf("sizeof(TEST1)=%d \tsizeof(TEST3)=%d\n",sizeof(TEST1),sizeof(TEST3));
    printf("sizeof(TEST2)=%d \tsizeof(TEST4)=%d\n\n",sizeof(TEST2),sizeof(TEST4));

   return 0;
}

the output on my system (AMD 64 for most curious ;) )

 ==== PAKED =====       ==== DEFAULT =====
sizeof(TEST1)=12        sizeof(TEST3)=12
sizeof(TEST2)=13        sizeof(TEST4)=16

Press any key to continue...