The Rule of Five in C++

In this article, you will learn about the Rules of Five in C++ with their syntax and examples.

The Rule of Five states that if your class needs any of the following, it probably needs all of them:

Destructor: It is used to avoid resource leaks when an object goes out of scope.
Copy Constructor: It is used to properly copy class resources when an object is copied.
Copy assignment operator: It is used to copy resources when one object is assigned to another.
Move Constructor: It is used to efficiently move resources, rather than copy when an object is moved.
Move assignment operator: It is used to move resources when one object is moved into another.

In essence, the rule says that if your class manages resources like pointers or file handles, you need to properly implement the constructors, destructor, and assignment operators to avoid issues with cleaning up those resources. Following the rule prevents resource leaks, invalid object states, and unnecessary copying.

The importance of C++'s Rule of Five

The Rule of Five exists in C++ due to the need to properly manage resources like pointers, file handles, and dynamic memory allocations. Here are some key reasons why following the Rule of Five is important:

Prevent resource leaks: The destructor allows objects to free/close resources when they go out of scope. Without a destructor, resources may be leaked.
Avoid invalid states after copying: The copy constructor and assignment operators properly copy resource ownership from one object to another. Without them, copies of an object could end up with broken/invalid pointers.
Improve efficiency through move semantics: Move constructors and move assignment operators transfer resources instead of copying them, which is faster.
Consistency: If a class needs one special method, like a destructor or copy constructor, it likely needs the rest to work correctly. The rule sets consistent expectations.
Encapsulation: The rule encapsulates resource handling neatly inside the class, preventing issues from incorrectly using/copying objects.

It establishes clear best practices for classes that manage resources, leading to correct program behaviour, and avoiding difficult bugs. Following the five standard methods ensures proper resource handling when initializing, destroying, copying, or moving objects.

1. Destructor:

A destructor is a unique function invoked automatically upon an object's destruction or out-of-scope. Its main purpose is to free up resources that the object may have acquired during its lifetime.

Syntax:

It has the following syntax:

    class MyClass {
    public:
        // Constructor
        MyClass() {
            //Initialization code
        }

        // Destructor
        ~MyClass() {
            // Release resources
        }
    };

Here,

Destructors have the same name as the class, prefixed with a tilde (~).
Destructors take no arguments and have no return type.

Example:

Let us take an example to illustrate the destructor in C++.

class File {
  private:
    HANDLE fileHandle;
  
  public:
    File() {
      fileHandle = CreateFile(...);
    }
    
    ~File() {
      CloseHandle(fileHandle); // release resource
    }
}; 

File f1;   // destructor called automatically when
              // f1 goes out of scope to close the file handle

In this example, the destructor closes the file handle that was opened by the class to prevent resource leaks when the object gets destroyed. Resource handling is neatly encapsulated inside the class via the destructor.

2. Copy Constructor:

A copy constructor is a unique type of Constructor that uses an already-existing object of the same class to initialize an object. It is used to initialize new objects from existing ones.

Syntax:

It has the following syntax:

    class MyClass {
    public:
        // Copy Constructor
        MyClass(const MyClass& other) {
            // Copy resources from 'other' to 'this'
        }
    };

It is a constructor that takes a reference to an object of the same class as a parameter.
It has a single parameter that references the same class type.
The parameter must be passed by reference and not by value.
It is generally used to deep copy objects during initialization.

Example:

Let us take an example to illustrate the copy constructor in C++.

class Person {
  string name;
  int age; 

public:
  // regular constructor
  Person(string n, int a) {
    name = n;
    age = a;  
  }

  // copy Constructor  
  Person(const Person &person) {
    name = person.name; 
    age = person.age;  
  }
};

Person p1("John", 22);

// Copy Constructor called
Person p2 = p1; // p2 initialized as copy of p1   

In this example, the copy constructor initializes p2 as a copy of p1 by copying its name and age data members. It prevents shallow copying of objects.

3. Copy Assignment Operator:

The copy assignment operator assigns values of one object to another existing object of the same class. It assigns one object to another object of the same class.

Syntax:

It has the following syntax:

    class MyClass {
    public:
        // Copy Assignment Operator
        MyClass& operator=(const MyClass& other) {
            if (this != &other) {
                // Release resources
                // Copy resources from 'other' to 'this'
            }
            return *this;
        }
    };

It overloads the = operator.
It has a parameter that refers to an object of the same class.
The parameter must be passed by reference.
It assigns the data members of the passed object to the current object.
It returns a reference to the current object (*this).

Example:

Let us take an example to illustrate the copy assignment operator in C++.

class Car {
   string make;
   int year;

public:
  // Copy assignment operator
  Car& operator=(const Car &c) {
    make = c.make;  
    year = c.year;
    return *this;
  }
};

Car c1("Toyota", 2022); 
Car c2("Ford", 2020);

c2 = c1;  // Assign c1 values to c2  
              // Using copy assignment operator

In this example, the copy assignment operator is overloaded to assign c1's values to the existing c2 object. It copies member data and returns the current updated object.

4. Move Constructor:

A move constructor transfers resource ownership from one object to another instead of making a copy. It is used to implement move semantics, which transfers resources faster than copying.

Syntax:

It has the following syntax:

class MyClass {
    public:
        // Move Assignment Operator
        MyClass& operator=(MyClass&& other) noexcept {
            if (this != &other) {
                // Release resources
                // Transfer ownership of resources from 'other' to 'this'
            }
            return *this;
        }
    };

Example:

Let us take an example to illustrate the move constructor in C++.

class Vector {
  int *arr;
  int size;

public:
  // Move Constructor  
  Vector(Vector &&x) {
    arr = x.arr;
    size = x.size;

    x.arr = nullptr; // Leave x in valid state
  }
};

Vector v1(100); 
Vector v2 = std::move(v1); // Move v1 resources to v2

Here, the move constructor efficiently transfers the data pointer from v1 to v2. v1 is left in a valid null state after the move. Therefore, it transfers resources instead of copying them. It enables efficient move semantics.

5. Move Assignment Operator:

The move assignment operator transfers the resources from one object to another instead of copying. It is used to implement move semantics, which transfers resources faster than copying.

Syntax:

It has the following syntax:

ClassName& operator=(ClassName &&old_obj) {
  // Transfer ownership of data from old_obj 
  // to the current object

  // Return *this
}

It overloads the = operator, similar to copy assignment.
It takes an rvalue reference (&&) to the same class type.
Resources and data members are transferred from the old_obj object to the current object.
The old_obj is left in a valid but unspecified state.
It returns a reference to the current object (*this).

Example:

Let us take an example to illustrate the move assignment operator in C++.

class String {
  char *str;
  int len;
  
public:
  // Move assignment    
  String& operator=(String &&s) {
    if (this != &s) { 
      delete [] str;
  
      str = s.str;
      len = s.len;

      s.str = nullptr;
      s.len = 0;
    }
    return *this;
  }  
};

String s1 = "Hello";
String s2 = "World"; 

s2 = std::move(s1);  // Move s1 resources to s2

Here, the move assignment operator efficiently transfers the data pointer from s1 to s2 instead of creating a new copy. The s1 is left in a valid empty state after the move. Therefore, it transfers resources instead of copying them, enabling move semantics.

Example:

Let us take a C++ program that demonstrates the use of all five special member functions: Destructor, Copy Constructor, Copy Assignment Operator, Move Constructor, & Move Assignment Operator.

#include <iostream>
#include <utility>  // for std::move

class ResourceHolder {
public:
    // Constructor
    ResourceHolder(std::size_t size) : size_(size), data_(new int[size]) {
        std::cout << "Constructor - Allocated memory for " << size << " integers.\n";
    }

    // Destructor
    ~ResourceHolder() {
        delete[] data_;
        std::cout << "Destructor - Deallocated memory.\n";
    }

    // Copy Constructor
    ResourceHolder(const ResourceHolder& other) : size_(other.size_), data_(new int[other.size_]) {
        std::cout << "Copy Constructor - Copied " << size_ << " integers.\n";
        std::copy(other.data_, other.data_ + size_, data_);
    }

    // Copy Assignment Operator
    ResourceHolder& operator=(const ResourceHolder& other) {
        if (this != &other) {
            delete[] data_;
            size_ = other.size_;
            data_ = new int[size_];
            std::cout << "Copy Assignment Operator - Copied " << size_ << " integers.\n";
            std::copy(other.data_, other.data_ + size_, data_);
        }
        return *this;
    }

    // Move Constructor
    ResourceHolder(ResourceHolder&& other) noexcept : size_(0), data_(nullptr) {
        swap(*this, other);
        std::cout << "Move Constructor - Moved resources.\n";
    }

    // Move Assignment Operator
    ResourceHolder& operator=(ResourceHolder&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            size_ = 0;
            data_ = nullptr;
            swap(*this, other);
            std::cout << "Move Assignment Operator - Moved resources.\n";
        }
        return *this;
    }

    // Swap function for efficient swapping
    friend void swap(ResourceHolder& first, ResourceHolder& second) noexcept {
        using std::swap;
        swap(first.size_, second.size_);
        swap(first.data_, second.data_);
    }

private:
    std::size_t size_;
    int* data_;
};

int main() {
    // Create an object using the Constructor
    ResourceHolder obj1(5);

    // Copy Constructor
    ResourceHolder obj2 = obj1;

    // Copy Assignment Operator
    ResourceHolder obj3(3);
    obj3 = obj1;

    // Move Constructor
    ResourceHolder obj4 = std::move(obj3);

    // Move Assignment Operator
    ResourceHolder obj5(2);
    obj5 = std::move(obj2);

    return 0;
}

Output:

Constructor - Allocated memory for 5 integers.
Copy Constructor - Copied 5 integers.
Constructor - Allocated memory for 3 integers.
Copy Constructor - Copied 3 integers.
Move Constructor - Moved resources.
Constructor - Allocated memory for 2 integers.
Move Assignment Operator - Moved resources.
Destructor - Deallocated memory.
Destructor - Deallocated memory.
Destructor - Deallocated memory.
Destructor - Deallocated memory.
Destructor - Deallocated memory.

Next Topicunordered_multimap load_factor() function in C++

← prev next →