C指针（数组）的内存分配（十六进制）

Question

I was playing with memory addressing in C and I encountered a situation I cannot fully explain.

EDIT: the code is compiled by a c++ compiler. (g++)

#include <cstdlib>
#include <cstdio>
int main()
{

    int* array[10]; //array of pointers to integers

    for(int i = 0; i < 10; i++)
        {
            array[i] = (int*)malloc(sizeof(int));
            *(array[i]) = i;
        }


    printf("\n");
    for(int i = 0; i < 10; i++)
       {
            printf("%d:%p\n", *(array[i]), array[i]);
       }
    printf("\n");




    int arr[10]; //array of integers

    int* start = arr; //pointer to the first element (array decay)
    for(int i = 0; i < 10; i++)
        arr[i] = i;

    printf("\n");
    for(int i = 0; i < 10; i++)
    {
        printf("%d:%p\n", *(start + i), start + i);
   }
   printf("\n");

 return 0;
 }

Everything compile and works however I get strange memory addresses. For the first array I get something like:

0:0x23e4010
1:0x23e4030 (32 bits between the addresses which is correct)

but for the second array I get:

0:0x7ffdaf876290
1:0x7ffdaf876294 (only 4 bits? or maybe they are bytes - but why the long addresses???)

Can someone explain this? (also is there a function to transform the hex into decimal without any effort?)

Answer 1

In the first instance, your array is an array of pointers. Each element is a pointer and, when you allocate memory for each pointer to point to, it's completely unrelated to the memory you allocate for other pointers in that array. They are in fact 32 bytes apart in this case, but that's just pure chance.

In the latter case, you are creating an array of integers which are all bunched together, or "contiguous", in memory. They will be adjacent, hence the pattern you see when you print their addresses, which are 4 bytes apart. Evidently, int on your system is 4 bytes wide (which is fairly common still).

The "long addresses" are due to your use of dynamic allocation: that'll be the area in virtual memory where your system happens to hold the heap. Nothing to worry about.

So there's nothing "strange" about it.

Answer 2

Int for Array uses 1byte.

Let address of: - array[0]=5000

Then - array[1]=5001 - array[2]=5002 - array[3]=5003 - array[4]=5004 - array[5]=5005 - array[6]=5006 - array[7]=5007 - array[8]=5008 - array[9]=5009

Now, You're assigning pointer. Then address of Pointer:

• *(array[0])=5010
• *(array[1])=5011
• *(array[2])=5012
• *(array[3])=5013
• *(array[4])=5014
• *(array[5])=5015
• *(array[6])=5016
• *(array[7])=5017
• *(array[8])=5018
• *(array[9])=5019

Here You can easily see that the difference between array[i] and *(array[i]) will be always 10bytes. This is because when any Array is called then only it allocates memory total size at once.

Now addresses of second: Array arr is defined but not called. Hence, no memory will be allocated till you call that arr Here, calling is for defining it

Now, first line says:

int arr[10];

That only defined the base address. Then you gave that base address to *start by:

int* start=arr;

Hence pointer gets that address. Clearly, Let: Address of:

• arr[0]=5020 Then:
• *(start+0)=5020

Since, it is a pointer (not an Array) hence will take 4bytes. Similarly, all addresses range will be:

• arr[0]=5020 - 5023
• arr[1]=5024- 5028 And so on..

Explanation to Allocation:

• Whenever we define an Array, it defines only the Base Address . Ex:

  int a[10];

Will allocate base address, ie, starting address, ie, address for a[0];

• Whenever you define a pointer, it will also allocate base address only.

• Difference lies only in the allocation, ie, array allocates 1byte and pointer allocates 4byte (GCC/ Linux/32bit Compiler) for a Pointer.