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

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.