Allocating Array of Pointers on Heap

Question

Does the following create x new objects, or simply allocate space for x objects?:

Vector3D* binArray = new Vector3D[size];

I need to build an array with space for x Vector3D objects on the heap. However, a Vector3D object can only be created when an "add" function is called - this will take the parameters, construct the object on the heap and add its address to the array of Vector3D pointers.

Answer 1

This does create an array of Vector3D objects on the heap.

Each vector is created by calling the Vector3D constructor.

Put a little debugging print statement in the default constructor for Vector3D, and watch the constructor get called the same number of times as you have vectors in your array.

Example:

#include <iostream>
using namespace std;

class C {
public:
  C() { cout << "Hello default constructor here\n"; }
};

int main() {
  C* cs = new C[5];
}

Output is:

Hello default constructor here
Hello default constructor here
Hello default constructor here
Hello default constructor here
Hello default constructor here

If your class does not have a default constructor, you cannot allocate the array in one shot (thank you for the comment @Everyone), so in this case consider using a std::vector or a std::array and adding your Vector3D objects dynamically --- or even "statically"! Example:

#include <iostream>
#include <vector>
using namespace std;

class Vector3D {
  double i, j, k;
public:
  Vector3D(double i, double j, double k): i(i), j(j), k(k) {}
};

int main() {
  vector<Vector3D> v = {
    Vector3D(3, 4, 5),
    Vector3D(6, 8, 10),
    Vector3D(7, 24, 25)
  };
  v.push_back(Vector3D(1, 2, 3));
  cout << v.size() << '\n';
}

This outputs 4.

You can also make your vector contain pointers to Vector3D objects.

Answer 2

Just to add based on the asker's comments on RayToal's excellent answer. If you don't know the size of the binArray prior to runtime then you must use std::vector. If you want to allocate each item alone, I would recommend using std::vector<Vector3D*>.

This way you can resize the std::vector at runtime and when you do, it will hold a bunch of nullptrs that are not allocated. Then you can allocate each one of them separately.

std::vector<Vector3D*> binArray;
binArray.resize(x);  // now you have binArray of size x and no allocated elements
binArray[0] = new Vector3D(...);

Please keep in mind that you need to delete them after you're not using them in order to not have a memory leak:

for(size_t i=0;i<binArray.size(); i++)
  if(binArray[i]!=nullptr) delete binArray[i];