Wsrtjtyk

Take the following example:

#include <iostream>

#include <stdio.h>

#include <vector>



using namespace std;



class Foo{

    public:

        Foo(){

            cout << "Constructing the default way..." << endl;

            this->num = (int*)malloc(sizeof(int));

        }

        Foo(int a){

            cout << "Using a custom constructor..." << endl;

            this->num = (int*)malloc(sizeof(int) * a);

        }



        ~Foo(){

            cout << "Destructing..." << endl;

            free((void*)num);

        }



        int* num;

};



int main()

{

    vector<Foo> objects(5);

    for(Foo& v : objects) printf("%x0xn", v.num);



    cout << "n---------------n";

    cout << "END OF PROGRAM!n";

    cout << "---------------nn";

    return 0;

}

Creating the vector by passing it an initial count of objects creates every single object individually, hence, all of them have their num at different addresses and their destructors are called at the end of the program.

However, if I want to create the vector by giving it a custom constructor like vector<Foo> objects(5, Foo(5)); (This is only my guess) a temporary object is constructed and then copied to every object in the array. Effectively, this makes every single object in the vector have their num pointer point to the same memory. Plus that memory gets freed when the initialization is finished and then every single object becomes useless.

How do I go around this without making the custom constructor into a new Init(int) function and running it on every single object in the vector? (Of course changing malloc into realloc).

You could solve your problem with a vector of unique_ptr's to the Foo objects.

class Foo

{

public:

    Foo(int i) {}



    // ...

};



#include <algorithm>

#include <vector>



auto main() -> int

{

    std::vector<std::unique_ptr<Foo>> foos(100);

    std::generate(foos.begin(), foos.end(), () { return std::make_unique<Foo>(5); });

}

However, you don't want to do this because otherwise you would have to go the extra indirection with the unique_ptr when calling anything on a vector's Foo object.

As others have already suggested, you should store Foo's int members in a vector. Then you can just reserve the space in the vector and emplace_back (construct) your Foo objects directly in the vector of Foo's.

#include <vector>



class Foo

{

public:

    Foo() {}

    Foo(int i) : ints(i) {}



private:

    std::vector<int> ints;

};



namespace 

{

    constexpr auto NumberOfFoos = 100;

}



auto main() -> int

{

    std::vector<Foo> foos;

    foos.reserve(NumberOfFoos);



    for (auto i = 0; i < NumberOfFoos; ++i) {

        foos.emplace_back(10);

    }

}

Regarding your code, you might want to have a look at these additional sources and answers (as already suggested by other comments):

• Rule of three


• Stop using std::endl


• Why is “using namespace std” considered bad practice?

Two problems preventing a solution.

1) You need to implement your custom copy and assignment operators to do the deep copying since the default shallow copy (as you point out) doesn't do the right thing.

2) You need to let the object remember how large an array you are allocating for the copy/assignment implementations to work.