Deep Copy with Copy Constructor - c++

Question

I have a task where I need to do the following.
I have 3 classes with A links to many B association A->*B->*C
A: Contains only -iA_ : int
B: Contains only -iB_ : int
C: Contains only -IC_ : int
The task is:
Implement the necessary codefor all classes so that A contains a copy structure for deep copies. Container type list. Setter and getter are not necessary!
Further constructors and destructors are not necessary!
If you use default implementations you have to justify this.
So I have implemented it is this correct?
class C
{
private:
int iC_;
}
class B
{
private:
int iB_;
std::list<C*> CList_;
public:
B(std::list<C*> CList) : CList_(CList)
{
}
}
class A
{
private:
int iA_;
std::list<B*> BList_;
public:
A(std::list<B*> BList) : BList_(BList)
{
}
A(const A& crA)
{
iA_ = crA.iA_;
}
}

Answer 1

Unfortunately, your code is not correct yet. In order to create deep copies of a class that contains pointers, you need to copy the objects that those pointers point to as well. Here is a simple example with just A and B:
class B
{
private:
int iB_;
public:
// you will not be able to default this in your code
B(const B& other) = default;
};
class A
{
private:
int iA_;
vector<B*> BList_;
public:
A(const A& other) : iA_{other.iA_}, BList_{}
{
// fill up the BList_ with copies of other's BList_ items
for (auto b : other.BList_) {
// call B's copy constructor
B* copyPtr = new B{*b};
BList_.push_back(copyPtr);
}
}
A& operator=(const A& other)
{
iA_ = other.iA_;
// destroy all the current items in BList_
while (!BList_.empty()) { delete BList_.pop_back(); }
// fill up the BList_ with copies of other's BList_ items
for (auto b : other.BList_) {
// call B's copy constructor
B* copyPtr = new B{*b};
BList_.push_back(copyPtr);
}
}
~A()
{
// destroy all the current items in BList_
while (!BList_.empty()) { delete BList_.pop_back(); }
}
};
With your code, you will need to implement a similar thing with B's copy constructor as well to make sure it makes copies of everything in CList_, only then will you have a true deepcopy.
Edit: As #Alan Birtles noted, in such an implementation you should also define the copy assignment operator and destructor to prevent memory leaks.