copy-and-swap_idiom.md

struct S {
  size_t m_size = 0;
  int *m_data;

  S(size_t size = 0) : m_size(size) {
    std::cout << "ctor: " << m_size << std::endl;
    m_data = new int[m_size];
  }

  ~S() { delete[] m_data; }

  // copy constructor
  S(const S &rhs) : m_size(rhs.m_size), m_data(new int[m_size]) {
    for (std::size_t i = 0; i < rhs.m_size; i++) {
      m_data[i] = rhs.m_data[i];
    }
  }

  //   Copy assignment operator
  S &operator=(S rhs) // Note: pass by value to handle self-assignment and for
                      // exception safety

  {
    std::swap(m_size, rhs.m_size);
    std::swap(m_data, rhs.m_data);
    return *this;
  }

  // Traditional Copy Assignment Operator
  S &operator=(const S &rhs) {
    std::cout << "Copy assignment operator" << std::endl;
    if (this != &rhs) { // Check for self-assignment
      delete[] m_data;  // Free existing resource

      m_size = rhs.m_size;
      m_data = new int[m_size]; // Allocate new resource
      for (std::size_t i = 0; i < m_size; i++) {
        m_data[i] = rhs.m_data[i]; // Copy the resource data
      }
    }
    return *this; // Return the current object
  }
};

1. Traditional Copy Assignment Signature (S& operator=(const S& rhs)):

   • Signature: S& operator=(const S& rhs)
   • This version takes a constant reference to the source object.
   • This is the conventional form for the copy assignment operator. It takes a constant reference to the source object. This method involves checking for self-assignment, dealing with resource allocation, and ensuring proper copying of the object's contents.

2. Copy-and-Swap Assignment Signature (S& operator=(S rhs)):

   • Signature: S& operator=(S rhs)
   • This version takes the source object by value.
   • This form is part of the copy-and-swap idiom, which is a modern and exception-safe approach to implementing assignment operators in C++. Here, the parameter is passed by value (S rhs), not by constant reference.
   • The key advantage of this approach is its simplicity and exception safety. When you pass by value, the copy constructor of S is called to create the rhs object. If this copy constructor throws an exception (for example, during memory allocation), it will do so before entering the body of the assignment operator, thus preventing any changes to the current object and maintaining strong exception safety.
   • Inside the function, std::swap is used to swap the internals of the current object with those of rhs. When rhs goes out of scope at the end of the function, it automatically cleans up the old resources, as it now holds the old state of the current object.

In the specific implementation I provided, the S& operator=(S rhs) signature is used for the copy-and-swap idiom. This is a deliberate choice to simplify resource management and improve exception safety, but it does differ from the traditional copy assignment signature. Both approaches are valid, but they serve different purposes and have different implications for resource management and exception handling.

The traditional approach is more straightforward and direct, whereas the copy-and-swap idiom provides strong exception safety and simplifies code, especially for classes that manage complex resources. The choice between the two depends on the specific requirements and design goals of your class.

In practice, you would typically choose one of these strategies based on your class's design and resource management needs. For example, if your class manages resources and you want to ensure strong exception safety, you might prefer the copy-and-swap idiom. If your class is simpler or if performance considerations outweigh the benefits of exception safety, you might choose the traditional copy assignment operator.