CODEWITHSUNDEEP
carrayssizeof
Amol Sharma
Amol Sharma

Reputation: 1591

size of array of pointers

i have a doubt regarding sizeof operator

Code 1:

int main()
{
    int p[10];
    printf("%d",sizeof(p));   //output -- 40
    return 0;
}

Code 2:

int main()
{
    int *p[10];
    printf("%d",sizeof(*p));   //output -- 4
    return 0;
}

in the first code p points to an array of ints. in the second code p points to an array of pointers. i am not able to understand why the first code o/p is 40 but 2nd code o/p is 4 thought both points to an array of the same size ?

Upvotes: 3

Views: 30039

Answers (6)

abcd
abcd

Reputation: 31

In the first code sizeof(Array) will return you the total number of bytes allocated for that array. You can get the correct size of the array by

int size= sizeof(Array)/sizeof(Array[0]);

where as in the second code it returns the size of pointer.

Upvotes: 2

Keith Thompson
Keith Thompson

Reputation: 263617

In the first code:

int p[10];

p doesn't point to an array of ints; p is an array of ints. In the statement

printf("%d",sizeof(p));

which should be

printf("%d", (int)sizeof(p));

the expression p still refers to the array object, so sizeof(p) yields the size of the array object, which happens to be 40 bytes on your system (10 * sizeof (int)).

In the second:

int *p[10];

again, p is an array of pointers. But in the following statement:

printf("%d", (int)sizeof(*p));

the expression p is converted to a pointer to the first element of the array (not to the entire array). Dereferencing that pointer (with the unary * operator) gives you an int* object, namely the first element of the array. The size of an int* pointer on your system happens to be 4. (sizeof (int) and sizeof (int*) are not necessarily the same; it happens that they are on your system.)

In C, the rule is that any expression of array type (such as the name of an array variable) is automatically converted to a pointer to the array's first element -- most of the time. There are three exceptions:

  • When it's the operand of sizeof (sizeof arr yields the size of the array object, not the size of a pointer)
  • When it's the operand of unary & (&arr yields the address of the whole array object, not the address of its first element; same memory location, different types)
  • When it's a string literal in an initializer used to initialize an array object (int arr[6] = "hello"; doesn't convert "hello" to a pointer, it copies the array).

Strongly recommended reading: section 6 of the comp.lang.c FAQ.

Upvotes: 4

Sangeeth Saravanaraj
Sangeeth Saravanaraj

Reputation: 16627

The output of the following program will give you some hints and understanding about the size of a type and a pointer to a type.

#include <stdio.h>

int main(void)
{
    int p1[10];
    int *p2[10];
    int (*p3)[10];

    printf("sizeof(int)   = %d\n", (int)sizeof(int));
    printf("sizeof(int *) = %d\n", (int)sizeof(int *));
    printf("sizeof(p1)    = %d\n", (int)sizeof(p1));
    printf("sizeof(p2)    = %d\n", (int)sizeof(p2));
    printf("sizeof(p3)    = %d\n", (int)sizeof(p3));

    return 0;
}

int p[10];      => 10 consecutive memory blocks (each can store data of type int) are allocated and named as p

int *p[10];     => 10 consecutive memory blocks (each can store data of type int *) are allocated and named as p

int (*p)[10];   => p is a pointer to an array of 10 consecutive memory blocks (each can store data of type int)

Now coming to your question:

>> in the first code p points to an array of ints.
>> in the second code p points to an array of pointers.

You are correct. In the code:2, to get the size of the array where p points to, you need to pass the base address

printf("%d", (int)sizeof(p));

and not the following

printf("%d", (int)sizeof(*p));   //output -- 4

The following are equivalent:

*p, *(p+0), *(0+p), p[0]

>> what's the difference between p[10] and 
>> (*p)[10]...they appear same to me...plz explain

The following is the answer to your other question:

int p[10];
 _________________________________________
|   0   |   1   |   2   |         |   9   |
| (int) | (int) | (int) |  ...    | (int) |
|_______|_______|_______|_________|_______|


int (*p)[10]
 _____________________
|                     |
| pointer to array of |
|     10 integers     |
|_____________________|

Upvotes: 9

Amit Singh Tomar
Amit Singh Tomar

Reputation: 8610

Look in your first code snippet p is array whose size is 40 bytes.Now how it comes out to be 40 byte is simple, Array p does contain 10 members and each member having size 4 bytes 

   10*4=40

In second code snippet p is nothing but its array of pointer means each member of this array is a pointer to an int value.Now *p denotes value at first subscript of array and this value is nothing but an address which is of 4 bytes.

Hopes things will be clear for you now.

Upvotes: 0

Anil Arya
Anil Arya

Reputation: 3110

check this code:

in this code p points to an array of pointers hence the o/p is 40

In your case it is an array of pointers so the o/p is 4

#include<stdio.h>
int main()
{
       int (*p)[10];
       printf("%d",sizeof(*p));   //output -- 40
       return 0;
}

Upvotes: 2

tangrs
tangrs

Reputation: 9940

Basically, you have an array of pointers. When you did *p, you dereferenced the pointer to the first element of the array. Therefore, the type would be int. sizeof(int*) just happens to be 4 on your machine.

Edit (clarification):

Code snippet 1, you're grabbing the size of the array.

Code snippet 2, you're grabbing the size of the type pointed to by the first element of the array of pointers.

Upvotes: 5

Related Questions