Creating array of objects on the stack and heap

问题:

Consider the following code:

class myarray
{
    int i;

    public:
            myarray(int a) : i(a){ }

}

How can you create an array of objects of myarray on the stack and how can you create an array of objects on the heap?

回答1:

You can create an array of objects on the stack^† via:

myarray stackArray[100]; // 100 objects

And on the heap^† (or "freestore"):

myarray* heapArray = new myarray[100];
delete [] heapArray; // when you're done

But it's best not manage memory yourself. Instead, use a std::vector:

#include <vector>
std::vector<myarray> bestArray(100);

A vector is a dynamic array, which (by default) allocates elements from the heap.^††

---

Because your class has no default constructor, to create it on the stack you need to let the compiler know what to pass into the constructor:

myarray stackArray[3] = { 1, 2, 3 };

Or with a vector:

// C++11:
std::vector<myarray> bestArray{ 1, 2, 3 };

// C++03:
std::vector<myarray> bestArray;
bestArray.push_back(myarray(1));
bestArray.push_back(myarray(2));
bestArray.push_back(myarray(3));

Of course, you could always give it a default constructor:

class myarray
{
    int i;    
public:
    myarray(int a = 0) :
    i(a)
    {}
};

---

† For the pedants: C++ doesn't really have a "stack" or "heap"/"freestore". What we have is "automatic storage" and "dynamic storage" duration. In practice, this aligns itself with stack allocation and heap allocation.

†† If you want "dynamic" allocation from the stack, you'd need to define a max size (stack storage is known ahead of time), and then give vector a new allocator so it uses the stack instead.

回答2:

Since C++11 std::array<T,size> is available for arrays allocated on the stack. It wraps T[size] providing the interface of std::vector, but the most of the methods are constexpr. The downside here is that you never know when you overflow the stack.

std::array<myarray, 3> stack_array; // Size must be declared explicitly.VLAs

For arrays allocated with heap memory use std::vector<T>. Unless you specify a custom allocator the standard implementation will use heap memory to allocate the array members.

std::vector<myarray> heap_array (3); // Size is optional.

Note that in both cases a default constructor is required to initialize the array, so you must define

myarray::myarray() { ... }

There are also options to use C's VLAs or C++'s new, but you should refrain from using them as much as possible, because their usage makes the code prone to segmentation faults and memory leaks.

回答3:

If you create an array of objects of class myarray ( either on stack or on heap) you would have to define a default constructor.

There is no way to pass arguments to the constructor when creating an array of objects.

回答4:

I know how to create object with out of the default constructor, but only on stack:

Suppose you want to create 10 objects for MyArray class with a = 1..10:

MyArray objArray[] = { MyArray[1], MyArray[2]......MyArray[10]}

No need to call the destructor, because they are created in the stack.

回答5:

#include <stdio.h>
class A
{
public:
  A(int a){ 
       printf("\nConstructor Called : %d\n",a); 
       aM = a;
      }  
  ~A(){ 
    printf("\ndestructor Called : %d\n",aM);
}
private:
  int aM;
};

int main()
{                                                                                                   
  A **a = new A*[10];
  for (int i = 0;i<10;i++)
    a[i] = new A(i+1);
    for (int i = 0;i<10;i++)
      delete a[i];// = new A(i+1);                                                                                    

  delete []a;
}