How to implement overloading of assignment operators in C++? - oop

Question

I am trying to use assignment operator overloading to perform deep copy but not able to figure out the right way to do it. I have a Class Computer and need to use it to copy its object to that of class Laptop.

Answer 1

It should look something like this:
#include <algorithm>
class SomeClass {};
class AnotherClass {};
class Computer
{
public:
Computer() :
m_someclass(new SomeClass()),
m_double(0.0)
{
}
virtual ~Computer()
{
delete m_someclass;
}
Computer(const Computer& other) :
m_someclass(new SomeClass(*other.m_someclass)),
m_double(other.m_double)
{
}
Computer& operator=(const Computer& other)
{
if (this != &other)
{
Computer tmp(other);
swap(tmp);
}
return *this;
}
void swap(Computer& other) noexcept // or throw() for before c++11
{
std::swap(m_someclass, other.m_someclass);
std::swap(m_double, other.m_double);
}
private:
SomeClass* m_someclass;
double m_double;
};
class Laptop : public Computer
{
public:
Laptop() :
m_anotherclass(new AnotherClass()),
m_int(0)
{
}
virtual ~Laptop()
{
delete m_anotherclass;
}
Laptop(const Laptop& other) :
Computer(other),
m_anotherclass(new AnotherClass(*other.m_anotherclass)),
m_int(other.m_int)
{
}
// Create a Laptop object from a Computer object
explicit Laptop(const Computer& other) :
Computer(other),
m_anotherclass(new AnotherClass()),
m_int(0)
{
}
Laptop& operator=(const Laptop& other)
{
if (this != &other)
{
Laptop tmp(other);
swap(tmp);
}
return *this;
}
// Assign a laptop object from a computer object.
Laptop& operator=(const Computer& other)
{
if (this != &other)
{
Laptop tmp(other);
swap(tmp);
}
return *this;
}
void swap(Laptop& other) noexcept // or throw() for before c++11
{
Computer::swap(other);
std::swap(m_anotherclass, other.m_anotherclass);
std::swap(m_int, other.m_int);
}
private:
AnotherClass* m_anotherclass;
int m_int;
};
int main()
{
Computer computer;
// Construct a new Laptop object by copying data from a Computer object
Laptop laptop1(computer);
// Assign Computer data in Laptop to that of a Computer object
Laptop laptop2;
laptop2 = computer;
}
For non-pointer member variables, you just perform a standard copy with operator=. For pointer member variables (that the object owns), you use the new operator and construct it with the pointer that the other object has.