std::vector with elements allocated on the heap - do I need rule of 5?

Question

If I have a class with members like this:

class MyClass {
public:
    void set_my_vector() {
        for (int ind = 0; ind < 3; ++ind) {
            my_vector.push_back(new MyStruct(i, i*2));
        }
    }
private:
    struct MyStruct {
        int num_a;
        int num_b;
        MyStruct(int i, int j) : num_a(i), num_b(j) {}
    };
    std::vector<MyStruct*> my_vector;
};

Do I need to write the rule-of-five functions, or will std::vector take care of deep copying and deleting the elements allocated on the heap?

EDIT: The following code uses default copy constructor, so I assume that after I copy my_class1 object into my_class2 object, the elements of my_class1.my_vector and my_class2.my_vector will be the same, because the MyStruct pointers were copied, but not the data itself. However, the output shows that they are not the same. You can run the code here: https://onlinegdb.com/S1pK9YE4v

#include <iostream>
#include <vector>

class MyClass {
public:    
    void fill_my_vector(int i, int j) {
        my_vector.clear();
        for (int ind = 0; ind < 3; ++ind) {
            my_vector.push_back(new MyStruct(i, j));
        }
    }

    void print () {
        for (int ind = 0; ind < 3; ++ind) {
            std::cout << my_vector[ind]->int1 << ", " << my_vector[ind]->int2 << std::endl;
        }
        std::cout << std::endl;
    }
private:
    struct MyStruct {
        MyStruct (int i, int j) :
        int1(i), int2(j)
        {}
    
        int int1;
        int int2;
    };

    std::vector<MyStruct*> my_vector;
};

int main()
{
    MyClass my_class1;
    my_class1.fill_my_vector(42, 43);

    std::cout << "my_class1: " << std::endl;
    my_class1.print();

    MyClass my_class2 = my_class1;
    my_class2.fill_my_vector(12, 13);

    std::cout << "my_class2: " << std::endl;
    my_class2.print();

    std::cout << "my_class1: " << std::endl;
    my_class1.print();

}

EDIT2: I know about smart pointers. I am specifically interested what happens if I use raw pointers.

Answer 1

You need to implement the copy constructor, copy assignment and destructor.

Additionally, consider changing your vector declaration from

std::vector<MyStruct*> my_vector;

to

std::vector<std::unique_ptr<MyStruct>> my_vector;

so that it actually owns the heap allocated objects properly. Doing this change will help you not write a destructor.

Answer 2

No, std::vector doesn't take care of deep copying of your objects stored by pointer. You have few possibilities to solve this:

• Store MyStruct by value.
• Store std::unique_ptr<MyStruct>.
• Store std::shared_ptr<MyStruct>.

Note that because MyStruct contains only fields of the primitive types, neither of copy constructor, assignment operator and destructor are needed, otherwise you'd have to implement them, default implementation which compiler will generate automatically will be good enough.