为什么我们不需要在 malloc 数组的情况下取消引用指针值？

Question

I am coming across hardship trying to understand how C compiler interprets character arrays, strings, integers, and arrays in a shady way. And thanks for helping me out. Even many of reddit users pointed out that the whole pointer thing in C is a bit shady on how exactly it interprets commands. So, I am trying to understand malloc with an example. But before that this is what I understand. Say *p is a variable. Then p holds the address it's pointing towards. and *p references the value that the address holds. In case of dynamic allocation, When I do

int *p = (int *)malloc(sizeof(int)*5); //say we want 5 locations //

And manually loop as the user gives in all 5 values, I put in the values like

scanf("%d", p+i) // as p already holds address, I get that we don't have to provide the & . And i being the iterator.. //

and then print the same with another loop here's what happens and I have not a clue why.

Say the user inputs 55,66,77,88,99

When I print using this code,

printf("%d", *p+i); // De-referencing the values in location p by using asterics, + the value of iteration,i //

I get the values as crazy as 55,56,57,58,59

So from a little help from internet, I tried the printf code like this and it worked like a charm, but I didn't have to even de-reference. Why the heck is this so confusing?

printf("%d", p[i]); // No asterics used. How does the compiler know I want the value and not the address? as p only should hold the addresses, and *p should give us the values in those addresses //

Also, somehow if I do printf("%d", *p++); Then also it works. Why I am not getting how C works?

Also on the same note, if I try to do the same but this time with scanf("%d", p[i]); , then syntax error. I mean why?

Thanks...

Answer 1

Say *p is a variable

No. The variable is p and its type is int* .

---

• *p : the value found at address p
• *p+i parsed as (*p) + 1 : the value at address p then add the value 1 to that value
• p[i] equivalent with *(p + i) : the value at address p + i where p + i is the address of the i th element of an array of ints that starts at p . Aka the i th element in the vector of ints starting at p
• *p++ parsed as *(p++) : increment the pointer p (ie make p point at the next element) and get the value from the old value of p .

Answer 2

int *p = ....

Here, p is a variable of type int * , which means, variable p is a pointer which can hold the address of an int type.

The in memory view of allocated and initialised memory, pointed by p , would be something like this:

p ______
       |
      \|/
     --------------------------
     | 55 | 66 | 77 | 88 | 99 |
     --------------------------

You are correct on statement scanf("%d", p+i);-
// as p already holds address, I get that we don't have to provide the &.....

Question I:

When I print using this code,

printf("%d", *p+i); // De-referencing the values in location p by using asterics, + the value of iteration,i //

I get the values as crazy as 55,56,57,58,59

The precedence of unary * (indirection) operator is higher than binary + operator.
So, the expression *p+i will be evaluated as - (*p)+i .

Note that operator precedence is the priority for grouping different types of operators with their operands.

When you have printf("%d", *p+i); statement in a loop body which is iterating the given allocated array from i = 0 to i < 5 -
In the first iteration: ( i = 0 and pointer p is pointing to first element of array which is 55 ):

(*p) + 0  ->  55 + 0  ->  55

In the second iteration: ( i = 1 and pointer p is pointing to first element of array which is 55 ):

(*p) + 1  ->  55 + 1  ->  56

..... so on
.....

In the fifth iteration: ( i = 4 and pointer p is pointing to first element of array which is 55 ):

(*p) + 1  ->  55 + 4  ->  59

Hence you are getting output - 55,56,57,58,59.

To get the expected output, group the operator with operands explicitely - *(p + i) .

With this, first the value of i will be added to pointer and then the resultant pointer (address) will be dereferenced.

Question II:

I tried the printf code like this and it worked like a charm, but I didn't have to even de-reference. Why the heck is this so confusing?

printf("%d", p[i]); // No asterics used. How does the compiler know I want the value and not the address? as p only should hold the addresses, and *p should give us the values in those addresses //

From C Standard#6.5.2.1:

The definition of the subscript operator [] is that E1[E2] is identical to (*((E1)+(E2))).

By this definition of subscript operator -

p[i] -> *((p) + (i)) -> *(p + i)

That means, p[i] and *(p + i) are equivalent.
I have already showed you above in the answer that - why *(p + i) will give expected output.
Hence, when using p[i] you are getting expected output.

Question III:

Also, somehow if I do printf("%d", *p++); Then also it works. Why I am not getting how C works?

Again, check the operator precedence table and you will find that precedence of ++ (postfix increment) operator is higher than unary * (indirection) operator. So, the expression *p++ will be evalauted as *(p++) .

The post increment operator increase the value of operand by 1 but the value of the expression is the operand's original value prior to the increment operation.

When you have printf("%d", *p++); statement in a loop body which is iterating the given allocated array -
In the first iteration: pointer p is pointing to first element of array which is the element at 0 ^th index.

*(p++) -> p will be incremented but the value of p in the expression will be its value prior to the increment operation which is location of element at `0`th index
       -> *(0th location address) -> 55

In the second iteration: pointer p is pointing to second element of array which is the element at 1 ^st index.

*(p++) -> p will be incremented but the value of p in the expression will be its value prior to the increment operation which is location of element at `1`st index
       -> *(1st location address) -> 66

...... so on
......

In the fifth iteration: pointer p is pointing to fifth element of array which is the element at 4 ^th index.

*(p++) -> p will be incremented but the value of p in the expression will be its value prior to the increment operation which is location of element at `4`th index
       -> *(4th location address) -> 99

and p is now pointing to one element past the end of array.

You will get expected output - 55,66,77,88,99.

Question IV:

Also on the same note, if I try to do the same but this time with scanf("%d", p[i]); , then syntax error. I mean why?

Revisit the definition of subscript operator above in the answer and recall that you are aware of fact that scanf() expect the address of variable (pointer) as argument.

p[i] -> *((p) + (i)) -> *(p + i)

*(p + i) ==> dereferencing the pointer p + i which will give value at that location.
So, p[i] is not the address of i ^th location of array but its the value at i ^th location of array. Hence, you are getting error when passing p[i] as argument to scanf() .

To get the address of i ^th location, just add & operation before p[i] -

scanf("%d", &p[i]);

This will work as expected. Again confused, why??

Check this -

&p[i] -> &(p[i]) -> &(*((p) + (i)) -> ((p) + (i)) -> p + i
          |                |
  Precedence of operator   |
  [] is higher than        |
  & operator               |
                           |
      The operator & is used to get the address and the operator * is used for dereferencing.
      These operators cancel the effect of each other when used one after another. 

Hence, the statement

scanf("%d", &p[i]);

is equivalent to this statement

scanf("%d", p + i);

and you know very well why p + i works fine when given as argument in scanf() .

Let me know if you have any further question or confusion.

Answer 3

The expression p[i] is exactly equivalent to *(p + i) - given a starting address p , compute the address of the i 'th object (not byte.) following that address and dereference the result.

You don't use the * operator because there's an implicit dereference in the subscript operation.

*p + i is equivalent to writing p[0] + i - you dereference p and add the value of i to the result, which is why you got the sequence 55, 56, 57, 58, 59 when you were expecting 55, 66, 77, 88, 99 .

Life is easier when you use array notation - just write p[i] when you want the i 'th object in the sequence.

Answer 4

I think a small runnable code will help you better understand than me explaining.

#include <stdlib.h>
#include <stdio.h>

int main() {
    int *p = (int *)malloc(sizeof(int)*5);
    int *q = (int *)malloc(sizeof(int)*5);
    int i = 0;
    int test_val = 100;

    for(i = 0; i < 5; i++) {
        *(p + i) = test_val;
        q[i] = test_val;
        test_val = test_val + 10;
    }

    for(i = 0; i < 5; i++)
        printf("p[%d] = %d\n", i, p[i]);

    printf("p[i] gives the value in array p at index i \n\n");

    for(i = 0; i < 5; i++)
        printf("q[%d] = %d\n", i, q[i]);
    
    printf("Note that the values in p and q are equal which means that *(x + 1) and x[i] are 2 ways to access the same values \n\n");

    for(i = 0; i < 5; i++)
        printf("*p + %d = %d\n", i, *p + i);

    printf("*p + i gets value pointed by p and adds i to it in each iteration \n\n");

    for(i = 0; i < 5; i++)
        printf("*(p + %d) = %d\n", i, *(p + i));

    printf("*(p + i) gets value pointed by p + i \n\n");

    int *j = (int *)malloc(sizeof(int)*5);
    int *k = (int *)malloc(sizeof(int)*5);
    int *l = (int *)malloc(sizeof(int)*5);

    for(i = 0; i < 5; i++) {
         j[i] = test_val;
         k[i] = test_val;
         l[i] = test_val;
    }
    printf("(*j)++ = %d\n\n", (*j)++);
    printf("*(k++) = %d\n\n", *(k++));
    printf("*l++ = %d\n\n", *l++);
    
    for(i = 0; i < 5; i++) {
         j[i] = test_val;
         k[i] = test_val;
         l[i] = test_val;
    }
    printf("test_val = %d\n\n", test_val);
    printf("++(*j) = %d\n\n", ++(*j));
    printf("*(++k) = %d\n\n", *(++k));
    printf("*++l = %d\n\n", *++l);
    return 0;
}

Following is the output:

p[0] = 100
p[1] = 110
p[2] = 120
p[3] = 130
p[4] = 140
p[i] gives the value in array p at index i 

q[0] = 100
q[1] = 110
q[2] = 120
q[3] = 130
q[4] = 140
Note that the values in p and q are equal which means that *(x + 1) and x[i] are 2 ways to access the same values 

*p + 0 = 100
*p + 1 = 101
*p + 2 = 102
*p + 3 = 103
*p + 4 = 104
*p + i gets value pointed by p and adds i to it in each iteration 

*(p + 0) = 100
*(p + 1) = 110
*(p + 2) = 120
*(p + 3) = 130
*(p + 4) = 140
*(p + i) gets value pointed by p + i 

test_val = 150

(*j)++ = 150

*(k++) = 150

*l++ = 150

test_val = 150

++(*j) = 151

*(++k) = 150

*++l = 150

For the scanf question, scanf always needs a pointer as a parameter. p[I] is the value at (p + i) and thus is incorrect. Ideally, you should use scanf("%d", &(p[i]))

Answer 5

" When I print using this code printf("%d", *p+i); ... I get the values as crazy as 55 , 56 , 57 , 58 , 59 "

When you use *p + i , p is dereferenced first (which gains the value of the first array element, which is 55 ) and then i is added to the value 55 . *p + i is equal to (*p) + i .

This is why you get the output of: 55 , 56 , 57 , 58 , 59 and not 55 , 66 , 77 , 88 , 99

You just add i to the value of the first element in each iteration and never access the following 4 array elements.

" I tried the printf code like this and it worked like a charm, but I didn't have to even de-reference. .... printf("%d", p[i]); "

When you use p[i] , you get the value at the i th element of the array as it offsets the pointer itself before dereferencing. It is equal to *(p + i) .

" Also, somehow if I do printf("%d", *p++); Then also it works. "

When you use *p++ , p is actual dereferenced and the value at *p is gained but thereafter p is incremented. Means at the next iteration p points to the next array element.

After the loop has been completed, p points one past the array.

---

" If I try to do the same but this time with scanf("%d", p[i]); , then syntax error. I mean why? "

For scanf() the things are a little bit different.

When you use scanf("%d", p[i]); , p[i] is equal to *(p + i) as it is also in the printf() calls but as you try to dereference and gain an int object and not a pointer to int , which is needed for %d at scanf() , it is a syntax error.

In scanf() , %d requires an argument of type int * , not int .

---

For your main question:

" Why we don't need to de-reference pointer value in case of malloc array? "

It has nothing to do with malloc() ed or dynamic memory allocation in particular. It has something to do with pointer arithmetic syntax allowed in C.