38

I was wondering if it was possible to create an array of objects when the object needs things passed into it for the constructor. I want something like this:

MyClass *myVar;
myVar = new MyClass[num];  // I would like to specify the array size after declaration
int i = 0;
for(i = 0;i < num;i++)
   myVar[i] = new MyClass(0,0);  // I would also like to populate the array with new objects

I know that this works:

MyClass *myVar;
myVar = new MyClass[num];

but this only works when the constructor has nothing passed into it. Is what I am trying to do possible? If so, how do I do it?

EDIT: I found out how to do it with using arrays. Here is how I did it:

MyClass **myVar;
myVar = new MyClass *[num];
for(i = 0;i < num;i++)
   myVar[0] = new MyClass(0,0);

I would use vectors and such but my teacher has told us to use basic arrays whenever possible. The above solution I actually got from some code my teacher wrote. Thank you all for your help!

Improve this question
1
  • Late comment but for anyone coming across this I believe it should be myVar[i] = new myClass(0, 0) not myVar[0] Commented Dec 1, 2021 at 1:25

6 Answers 6

Reset to default
32 
MyClass *myVar;
myVar = new MyClass[num];

Actually in this form you cannot invoke constructor which takes parameter(s). It is not allowed by the language specification.

However, if you use std::vector, which I recommend you to use, then you can create a vector calling non-default constructor as:

#include <vector> //header file where std::vector is defined

std::vector<MyClass>  arr(num, MyClass(10,20));

It creates a vector of num elements, each element is created by calling copy-constructor of the class, passing MyClass(10,20) as argument to it.

The vector is also good because now you dont need to manage memory yourself. Neither manual allocation, nor manual deallocation. Plus, you can know the number of elements by calling arr.size() anytime. You always know how many elements the vector contains. You can also add elements anytime, just by calling .push_back() member function as:

arr.push_back(MyClass(20,30));

And now you can access elements, just like you access array, i.e by using index:

f(arr[i]); // 0 <= i < arr.size();

Additionally, you can use iterators which facilitate idiomatic programming, enabling you to use various algorithmic functions from <algorithm> header as:

#include <algorithm> //header file where std::for_each is defined

std::for_each(arr.begin(), arr.end(), f);

where f is function which takes one argument of type MyClass& (or MyClass const &) depending on what you want to do in f.

In C++11, you can use lambda as:

std::for_each(arr.begin(), arr.end(), [](const MyClass & m)
                                      {
                                           //working with m 
                                      });
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Thank you for you help! I was actually looking for an approach using arrays instead of vectors because my teacher was wanting the class to use arrays instead. I found the answer though.
@user972276: For arrays your first approach is what one can do, if you want to invoke non-default constructor. However, in future, if you ever need array, first consider using std::vector. It is an awesome container, with lots of cool feature.
9

In C++0x, this grammar works, which can call the non-default constructor in new expression:

MyClass *myVar;
myVar = new MyClass[2]{{10, 20},{20, 30}};

But I doubt if it works when the number of elements in available only at run time.

The vector approach would be better, as shown in Nawaz's answer.

Improve this answer

Comments

7

Pointer to pointer is equivalent to:

  • array of pointers.
  • vector<T*> vector of pointers.

One way I've done this in the past is using a double pointer. This approach eliminates the overhead of vector data structure and preferred memory efficient is needed.

MyClass ** myvar;
myvar = new MyClass*[num];
for(int i = 0; i < num; i++){
  *(myvar+i) = new MyClass(i);
}

Works with pretty much any control structure you can imagine.

The drawback is that the allocation of memory is not contiguous and may affect speed for large number of nums.

Improve this answer

1 Comment

This is similar to the vector<MyClass*> approach, just that you manage the detail yourself. Seems to be the best solution if you don't want the overhead cost of vector.
1

You can do something like this too: 

MyClass *myVar[num];

for(int i = 0; i < num; i += 1)
{
    myVar[i] = new MyClass(0, 0);
}
Improve this answer

Comments

0

Actually, you can use a placement new to handle this:

MyClass * myVar;
myVar = reinterpret_cast<MyClass *>(new char[num * sizeof(MyClass)]);
int i = 0;
for (i = 0; i < num; i++) {
    new(&myVar[i]) MyClass(0,0);
}
Improve this answer

2 Comments

You should use std::aligned_storage instead of new char[].
Also it should be mentioned that to free this memory you must loop through and call the destructors of each object and then call delete[] reinterpret_cast<char *>(myVar); .
0

@Nawaz answer is really good about using vectors, but didn't work for me because it create vector of the same objects (all of them reference to the same object)

class Graph
{
 public:
  Graph(long V); // none default Constructor
}
std::vector<Graph>  myGraph;
for (int i = 0; i < T; i++) // read all graphs
    {
        Graph newGraph(N);
        myGraph.push_back(newGraph);
    }
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.