在c中使用malloc进行多个单行分配

Question

Suppose the below statement:

int *numbers, *inverse;
numbers = inverse = (int *)malloc(n * sizeof(int));

I am curious to know what is going on here - I know it is right to left, so first the memory for inverse is being allocated. Then I set numbers equal to inverse , will that mean that the memory location of numbers will be the same as inverse ? Or does it allocate the same amount of memory at locations &numbers and &inverse ?

For example, if I do something like inverse[i] = 5 will that mean that numbers[i] == 5 ?

Answer 1

You have:

int *numbers, *inverse;
numbers = inverse = (int *)malloc(n * sizeof(int));

That's the same as writing:

int *inverse = (int *)malloc(n * sizeof(int));
int *numbers = inverse;

The variable numbers simply has a copy of the pointer that is in inverse — it points to the same place. However, you might be about to iterate through the array with one pointer while returning the other from the function, which could be a good reason for having the two copies.

There's a single memory allocation; there will need to be a single call to free() to release the allocated memory. The value passed to free() will be the same as the original value assigned to either inverse or numbers .

You also ask:

If I do something like inverse[i] = 5 will that mean that numbers[i] == 5 ?

If you've not changed the value stored in either inverse or numbers , and if i is in the range 0 .. (n-1) , then after the assignment, the equality will hold. The pointers are the same (same type, same value), so indexing them produces the same result. It also means inverse[i] == numbers[i] of course.

Answer 2

The first job is to drop the (int*) cast which is superfluous (and such a scheme can even be harmful if the type is not built-in). This is one of the differences between C and C++.

malloc(n * sizeof(int)); returns a pointer of type void* .

That pointer is assigned to inverse .

But the expression inverse = malloc(n * sizeof(int)) has type int* . This therefore can then be validly assigned to numbers .

To be very clear, malloc is called exactly once, and therefore you should call free exactly once.

Answer 3

TL;DR, yes, both inverse and numbers point to same memory.

---

Long answer: On why part, quoting C11 , chapter §6.5.16, Assignment operators ^{(emphasis mine)}

[...] An assignment expression has the value of the left operand after the assignment , but is not an lvalue. The type of an assignment expression is the type the left operand would have after lvalue conversion .

So, as you have mentioned correctly, for right-to-left associativity of the assignment operator = , the evaluation looks like

numbers = ( inverse = (int *)malloc(n * sizeof(int)) );

so, once inverse = (int *)malloc(n * sizeof(int)) is evaluated,

• The value of this expression is the value of inverse after the assignment
• Also, the type is as of the same type of inverse

( and both are valid ) thus, the next evaluation is the same as

 numbers = inverse;

So, ( if you want ), you can break down the statements like

if ( (inverse = malloc(n * sizeof*inverse )) )  //error check, just saying
      numbers = inverse;

and finally, if you're wondering why I removed the cast, see this discussion for more info on this.

Answer 4

Only one chunk of memory has been allocated, and both inverse and numbers point to the same chunk.

We can verify this experimentally.

#include <assert>

int main() {
    int n = 100;
    int *numbers, *inverse;
    numbers = inverse = (int *)malloc(n * sizeof(int));

    numbers[0] = 10;
    inverse[0] = 20;

    // If numbers and inverse point to the same memory, then we would expect
    // that numbers[0] is now 20.
    assert(inverse[0] == 20);
    assert(numbers[0] == 20);
}

Answer 5

Yes, you are allocating a single block of memory. That's the magic of pointers!

Answer 6

Here you are allocating a single block of memory And storing the address in two pointers. So both the pointers will point to the same address

Answer 7

In C, an assignment ( = , += , ...) is an operator like + , - , etc. It yields the value of the left hand side of the operator. See the standard 6.5.16p3 They are right associative, evaluation order is:

numbers = ( inverse = malloc(n * sizeof(int)) );

(Don't cast the result of malloc & friends or void * in general to pointers. It is not required in C and potentially harmful.)

So number gets the same value as inverse . Which is whatever the malloc returned for the right assignment.

To emphasise: this is no way related to pointers:

int i, k;
i = k = 4;

is exactly the same principle.

Edit:

To state it clear (once more): The right hand side of an assignment as for every operator is evaluated exactly once . You would not expect f(x) + g(x) + h(x) to have h called twice either.

For the pointers: malloc returns a pointer to a memory block, both pointers have the same value, thus they point to the same memory block. As both have the same type, you may use both to access the memory block.