多级指针，堆栈还是堆？

Question

Lets say I have this.

int ***a = new int**;
*a = new int*;
**a = new int;
***a = 18

So we have something like this. [*] -> [*] -> [*]->[18]

Are all of these pointers in the stack and everything they are pointing to in the heap?

Answer 1

assuming your code is inline in a function

int ***a = new int**;

a is on the stack. It points to something (thing1) on the heap

*a = new int*;

a is on the stack. It points to thing1. thing1 now points to something else on the heap (thing2)

**a = new int;

a is on the stack. It points thing1. thing1 on the heap points to thing2 on the heap. thing2 points to an int on the heap

***a = 18

a is on the stack. It points thing1. thing1 on the heap points to thing2 on the heap. thing2 points to an int on the heap. that int now = 18.

Answer 2

The very first pointer is on stack. The rest of them is on heap, since they were allocated using new.

Answer 3

a is on the stack. The rest, created by new is on the heap

Answer 4

To understand what the code does, the concept of the stack is unnecessary. Some implementation that you use might put a on the stack, but that doesn't change the meaning of the code, and this detail is not necessary to understand what the code does.

If you don't believe me: in the C++ standard, the word stack only refers to std::stack and to the abstract stack unwinding concept.

To be specific, we must assume how your code is used. Let's assume that it is in a block of its own:

{
  int ***a = new int**; 
  *a = new int*;        
  **a = new int;
  ***a = 18;
}

What we are concerned with then is what is the storage duration of various pieces of storage.

1. The a has automatic storage duration. The storage exists until the closing brace.

2. a points to storage of type int** of dynamic storage duration. The storage lasts until you explicitly deallocate it - in this case, it outlives a .

3. *a points to storage of type int* of dynamic storage duration. Here too, the storage lasts until you explicitly deallocate it - in this case, it outlives a .

4. **a points to storage of type int of dynamic storage duration. Here too, the storage lasts until you explicitly deallocate it - in this case, it outlives a .

5. ***a is the value int(18) stored in a piece of dynamic storage that **a points to.

What the program does, and how it behaves, has to do with these storage durations. It has nothing to do with whether a is on some stack. For all you know, you've compiled this code using emscripten , and the value lives in a javascript variable.

What is important that the storage duration of a is automatic, and its extent is to the end of the block in this case. The storage duration of everything you allocated with new is dynamic, and fully under your control.

With the code shown, there's no long-term way to access the three pieces of storage with dynamic storage duration: they will outlive a 's storage duration and turn into memory leaks as soon as the block ends. If you pass a out of the block, you'll be able to prevent this and retain the way of accessing all three dynamic storage duration pieces of storage.