In C++, a class definition automatically receives several special member functions when they are not explicitly declared by the programmer. These compiler-generated routines handle object lifecycle management and initialization. The primary functions include the default constructor, destructor, copy constructor, and copy assignment operator. While C++11 introduced move semantics, the foundational four remain critical for understanding object behavior.

Default Constructors

A constructor initializes an object upon creation. Key properties include:

• The identifier matches the class name exactly.
• It specifies no return type, not even void.
• The compiler invokes it automatically during instantiation.
• Overloading is permitted.
• If no constructor is declared, the compiler synthesizes a default constructor. Defining any constructor explicitly suppresses this automatic generation.

A default constructor is any constructor callable without arguments. This encompasses constructors with no parameters and those with default arguments for all parameters. Only one such callable variant may exist with in a class scope to prevent ambiguity.

class CalendarDate {
public:
    // Parameterless version
    CalendarDate() : m_year(2000), m_month(1), m_day(1) {}

    // Parameterized version with defaults
    explicit CalendarDate(int year, int month = 1, int day = 1)
        : m_year(year), m_month(month), m_day(day) {}
private:
    int m_year;
    int m_month;
    int m_day;
};

int main() {
    CalendarDate today;           // Calls parameterless constructor
    CalendarDate future(2025);    // Calls parameterized constructor
    return 0;
}

Note: The compiler-generated default constructor performs trivial initialization for primitive types but recursively invokes default constructors for class-type members.

Destructors

The destructor cleans up resources acquired during an object's lifetime. It does not deallocate the object's own memory but rather releases external resources like heap allocations or file handles.

• Named as the class name prefixed with a tilde (~).
• Accepts zero parameters and yields no return value.
• Cannot be overloaded; exactly one is permitted per class.
• Executes automatically when an object exits its scope.
• The synthesized destructor trivially handles primitive members and invokes detsructors for embedded class types.
• Explicit definition is mandatory when dynamic resources are managed to prevent leaks. If no resources require cleanup, relying on the compiler-generated version is safe.

#include <iostream>
#include <cstdlib>

class DynamicBuffer {
public:
    explicit DynamicBuffer(size_t initialSize = 16)
        : m_data(static_cast<int*>(std::malloc(initialSize * sizeof(int)))),
          m_capacity(initialSize),
          m_usedCount(0) {
        if (!m_data) {
            std::perror("Memory allocation failed");
        }
    }

    ~DynamicBuffer() {
        std::free(m_data);
        m_data = nullptr;
        m_capacity = m_usedCount = 0;
    }
private:
    int* m_data;
    size_t m_capacity;
    size_t m_usedCount;
};

// Composition triggers automatic cleanup
class DoubleEndedQueue {
private:
    DynamicBuffer frontBuffer;
    DynamicBuffer backBuffer;
    // Explicit destructor is optional here; compiler-generated version
    // correctly invokes DynamicBuffer's destructor for both members.
};

Copy Constructors

A copy constructor initializes a new instance using an existing object of the same type. Its signature requires the first parameter to be a reference to the class. Passing by value is illegal because it would recursive invoke the same constructor to copy the argument, causing infinite compilation recursion or runtime stack overflow.

• It is a specialized form of a constructor.
• The compiler generates one if omitted, performing a member-wise copy (shallow copy) for primitives and invoking the respective copy constructors for nested objects.
• Shallow copying is problematic for classes managing dynamic memory, as multiple instances will share the same pointer. Subsequent destruction attempts result in double-free errors. Deep copying, which allocates independent memory, is required in such cases.

class Timestamp {
public:
    Timestamp(int yr = 1970, int mo = 1, int dy = 1)
        : year(yr), month(mo), day(dy) {}

    // Copy constructor: reference parameter avoids infinite recursion
    Timestamp(const Timestamp& source)
        : year(source.year), month(source.month), day(source.day) {}

    void display() const {
        std::cout << year << '-' << month << '-' << day << '\n';
    }
private:
    int year, month, day;
};

// Pass-by-value or return-by-value implicitly triggers copy construction.
// Returning by const reference avoids this overhead but requires the
// referenced object to outlive the current scope.

Operator Overloading and Assignment

C++ permits redefining operator behavior for user-defined types via functions named operator<symbol>. Overloads must involve at least one class-type operand; built-in type semantics cannot be altered. Overloaded operators preserve standard precedence and associativity rules. When defined as member functions, the left-hand operand is passed implicitly via the this pointer, reducing the explicit parameter count by one.

The copy assignment operator manages copying between two fully constructed objects. Unlike the copy constructor, which initializes new memory, the assignment operator replaces existing state.

• Must be a member function.
• Conventionally takes a const reference to avoid unnecessary copies.
• Returns a reference to the current object (*this) to enable chained assignments.
• The compiler-generated version performs shallow member-wise assignment.

class Measurement {
public:
    Measurement(double v = 0.0) : value(v) {}

    bool operator==(const Measurement& other) const {
        return value == other.value;
    }

    Measurement& operator=(const Measurement& rhs) {
        if (this != &rhs) {
            value = rhs.value;
        }
        return *this;
    }

private:
    double value;
};

int main() {
    Measurement m1(10.5);
    Measurement m2(20.3);

    // Direct call vs. syntactic sugar
    m1.operator==(m2);
    bool areEqual = (m1 == m2);

    // Chained assignment relies on the reference return type
    Measurement m3(0.0);
    m3 = m2 = m1;
    return 0;
}

const Member Functions

Appending const to a member function declaration guarantees that the method will not modify the object's state. This qualifier effectively marks the implicit this pointer as a pointer to constant data (const ClassName* const this).

Rules governing const correctness:

• Data members can be read but not altered.
• const methods cannot invoke non-const methods on the same object, as the latter could mutate state.
• Non-const methods can freely call const methods.
• Declaration and definition must both include the const qualifier.

class Vector2D {
private:
    double xCoord;
    double yCoord;

public:
    Vector2D(double x, double y) : xCoord(x), yCoord(y) {}

    // Read-only accessor
    void output() const {
        // xCoord = 5.0; // Error: cannot modify member in const function
        std::cout << "(" << xCoord << ", " << yCoord << ")\n";
    }

    // Mutator method
    void translate(double dx, double dy) {
        xCoord += dx;
        yCoord += dy;
    }
};

int main() {
    const Vector2D origin(0.0, 0.0);
    origin.output();          // Valid
    // origin.translate(1, 1); // Invalid: mutate const object
    return 0;
}