Codecademy Logo

Constructors in C++

Related learning

  • Course

    Learn Advanced C++

    Learn advanced C++ programming with preprocessor directives, operator overloading, streams, and lambda expressions.
    • With Certificate
    • Advanced.
      9 hours

C++ Default Constructor

In C++, a default constructor does not take any arguments and initializes objects automatically when they’re created without passing arguments. This simplifies object creation when no specific initialization is required. Default constructors ensure that an object has a valid state after its creation.

C++ Implicit Constructor

In C++, if you don’t define any constructors in your class, the compiler generates an implicit default constructor for you. This constructor is automatically called when an object is created without parameters. If any constructor is defined, the implicit one won’t be generated.

C++ Copy Constructors

A copy constructor in C++ is essential for creating an object as a copy of another. It takes a const reference of the same class type as its parameter. This ensures the new object is a reliable clone, maintaining integrity.

class Example {
public:
  int number;


  // Copy constructor
  Example(const Example &original) {
    number = original.number;
  }
};


int main() {
  Example obj1; // Original object
  obj1.number = 5;
  Example obj2 = obj1; // Copying obj1 to obj2
  return 0;
}

C++ Deep Copying

In C++, when a class allocates dynamic memory, implementing deep copying in copy constructors is crucial. Avoid shallow copies to ensure each instance manages its own memory, preventing double deletions or memory leaks.

class ArrayWrapper {
private:
  int* data;
  size_t size;


public:
  ArrayWrapper(size_t size) : size(size) {
    data = new int[size];
  }
    
  // Deep copy constructor
  ArrayWrapper(const ArrayWrapper& other) : size(other.size) {
    data = new int[other.size];
    for (size_t i = 0; i < other.size; ++i) {
      data[i] = other.data[i];
    }
  }


  ~ArrayWrapper() {
    delete[] data;
  }
};

C++ Move Constructors

Move constructors in C++ leverage rvalue references Type&& to transfer resources from temporary to new objects efficiently. This reduces unnecessary copying and enhances performance.

#include <iostream>
#include <utility>


class ResourceHolder {
public:
  int* data;
  // Constructor
  ResourceHolder(int size) : data(new int[size]) {}
  // Move Constructor
  ResourceHolder(ResourceHolder&& other) noexcept : data(other.data) {
    other.data = nullptr;
  }
  // Destructor
  ~ResourceHolder() { delete[] data; }
};


int main() {
  ResourceHolder original(10); // Create original
  ResourceHolder moved(std::move(original)); // Move constructor is called
  return 0;
}

C++ Move Semantanics

std::move in C++ helps convert an lvalue into an rvalue reference, thus enabling move semantics. This allows resources to be transferred without copying, optimizing performance. It doesn’t move objects itself but merely mimics an rvalue.

#include <iostream>
#include <utility>  // For std::move
#include <string>


int main() {
  std::string hello = "Hello!";
  std::string movedHello = std::move(hello);


  std::cout << "Moved String: " << movedHello << std::endl;
  std::cout << "Original String (now empty): " << hello << std::endl;


  return 0;
}

Default and Deleted Constructors

In C++, constructors can be explicitly defaulted using = default or deleted using = delete. This provides fine-grained control over how objects are instantiated, ensuring developers only allow desired construction mechanisms for class objects.

class Example {
public:
  Example() = default; // Allows default construction
  Example(const Example&) = delete; // Prevents copy construction
};


int main() {
  Example obj1; // Allowed
  // Example obj2(obj1); // Compilation error: copy construction is deleted
  return 0;
}

C++ Rule Of Three

The Rule of Three in C++ dictates that if a class requires a custom destructor, it typically needs a copy constructor and copy assignment operator as well. This rule helps manage dynamic memory usage and ensure proper resource handling. Not following it may lead to memory leaks or double deletions.

C++ Rule of Five

The Rule of Five in C++ adds two components to the Rule of Three, including the move constructor and move assignment operator. This update, introduced in C++11, aims to enhance performance through move semantics by optimizing resource management.

Learn more on Codecademy

  • Course

    Learn Advanced C++

    Learn advanced C++ programming with preprocessor directives, operator overloading, streams, and lambda expressions.
    • With Certificate
    • Advanced.
      9 hours
Next