Class private data - on stack or heap

Question

In the following code:

class Array {
   public:
      int& operator[] (unsigned i) { if (i > 99) error(); return data[i]; }
   private:
      int data[100];
};

int main()
{
   Array a;
   a[10] = 42;
   a[12] += a[13];
   ...
}

(Correct me if I'm wrong) The variable a of type Array is on the stack since new was not used to allocate it. The Array class has int data[100], and the operator overload returns reference to particular index in data.

Referring question.

My question is whether int data[100] is on the stack or heap ? I think it shouldn't be the stack, otherwise how can a reference return like the one above still work.

Thanks.

Cameron · Accepted Answer · 2012-11-29T01:39:19.917

It's on the stack, since as you've noted a was allocated on the stack.

The stack is memory just like the heap; you can return a reference to part of it just like memory allocated on the heap. The only difference is in how the memory is managed.

The only thing you need to be careful of is not to access memory that's been deallocated; in the case of the stack, this happens at the end of a's scope, while heap-allocated data has to be explicitly deleted.

In the question you refer to, a reference to a variable declared on the stack is returned from a function; in that case, the variable is destroyed when the function exits, which is why that code is wrong. In your case, however, you're returning a reference to part of data whose lifetime matches that of the Array object; so as long as a has not been destroyed, it's safe to access it's data in this manner.

score 1 · Answer 2 · answered Nov 29 '12 at 01:32

As you say, "The variable a of type Array is on the stack". Technically, the object named a is on the stack. This means that all of the member variables of the object a are on the stack.

This means that return a reference to an element in the member array named data is very dangerous. The compiler will allow it, but if you try to access this reference when the variable a is out of scope, then you will encounter undefined behavior.

In the case of your example, all calls to operator[]() are within the same method, so everything is fine.

Technically, the object named a is alloacted with automatic storage duration. The language does not require a stack structure for implementing this kind of storage. Just being "technical" :D — Ed S., Nov 29 '12 at 01:35

score 0 · Answer 3 · answered Nov 29 '12 at 01:32

0

It's on the stack. Why would the reference return be a problem? You can create and use references to things on the stack without a problem.

void foo(void)
{
 int i;
 int& j = i; // reference to variable on the stack
 j = 2;
}

What issue do you think there might be here?

answered Nov 29 '12 at 01:32

David Schwartz

179,497
17
214
278

The concern is dangling references – Mooing Duck Jun 15 '21 at 16:15

score 0 · Answer 4 · answered Nov 29 '12 at 01:32

My question is whether int data[100] is on the stack or heap ? I think it shouldn't be the stack, otherwise how can a reference return like the one above still work.

It is allocated with automatic storage duration, i.e., the stack, not the heap. You have not allocated anything dynamically, so no dynamic (heap) allocation occurs. That would be a horrible thing to allow and C++ is all about not paying for what you don't use.

A reference to an element of data or to data itself will be invalid if data has left its declaring scope, i.e., the scope of the instance of Array. Now, should an Array type use dynamic allocation? Almost certainly, yes, for a general purpose container. It's your responsibility to make sure you're not keeping references or pointers to bad data.

score -1 · Answer 5 · answered Nov 29 '12 at 01:32

-1

It will be on the stack. If you try to use that reference after "a" has gone out of scope, you will get undefined behaviour. Hopefully it will crash soon.

answered Nov 29 '12 at 01:32

DrC

7,528
1
22
37

Class private data - on stack or heap

5 Answers5