When defining a class in C++, the compiler automatically generates six special member functions if the user does not explicitly declare them. These functions handle object lifecycle management—from creation and initialization to copying, assignment, and destruction. Understanding their behavior is crucial for proper resource management and semantic correctness.

Constructor Mechanics

A constructor initializes an object immediately upon allocation. Unlike regular member functions, constructors share the class identifier and lack an explicit return type.

Consider manual initialization via member functions:

class Calendar {
public:
    void setup(int y, int m, int d) {
        _yr = y;
        _mon = m;
        _dom = d;
    }
private:
    int _yr;
    int _mon;
    int _dom;
};

This approach risks uninitialized objects if setup is never invoked. Constructors eliminate this risk by guaranteeing initialization during instantiation:

class Calendar {
public:
    Calendar(int y, int m, int d) 
        : _yr(y), _mon(m), _dom(d) {}
    
    Calendar() 
        : _yr(2024), _mon(1), _dom(1) {}
private:
    int _yr;
    int _mon;
    int _dom;
};

Key characteristics include:

• Automatic invocation by the compiler during object creation
• Support for overloading to provide multiple initialization paths
• Absence of return types (including void)

If no constructor is defined, the compiler synthesizes a default constructor. This generated constructor performs member-wise initialization: built-in types remain uninitialized (indeterminate values), while user-defined types invoke their respective default constructors.

C++11 introduced default member initializers to address uninitialized built-in types:

class Timestamp {
private:
    int _hrs = 0;    // Default value
    int _mins = 0;
    int _secs = 0;
    ClockTime _clk;  // Calls ClockTime's constructor
};

Initializer Lists vs. Assignment

True initialization occurs in the initializer list (preceded by a colon), not within the constructor body. The body performs assignment, which differs semantically from initialization—particular for constants and references:

class Identifier {
public:
    Identifier(int id, std::string& label) 
        : _id(id)          // Required: const member
        , _ref(label)      // Required: reference member
        , _cache()         // Explicit default construction
    {}
private:
    const int _id;
    std::string& _ref;
    std::vector<int> _cache;
};

Members initialize strictly in their declaration order within the class, regardless of the initializer list sequence.

Destructor Fundamentals

Destructors handle resource deallocation when an object's lifetime terminates. Named with a tilde prefix (~), they accept no parameters and return no value.

class MemoryBuffer {
public:
    MemoryBuffer(size_t cap = 10) 
        : _data(new ElementType[cap])
        , _capacity(cap)
        , _count(0) 
    {}
    
    ~MemoryBuffer() {
        delete[] _data;
        _data = nullptr;
    }
    
private:
    ElementType* _data;
    size_t _capacity;
    size_t _count;
};

The compiler generates a destructor automatically if omitted. This default version invokes destructors for member objects (custom types) but performs no action for built-in types holding resources. Consequently, classes managing dynamic memory, file handles, or network connections require explicit destructor implementation to prevent leaks.

Destruction proceeds in reverse order of construction: member destructors execute before the containing object's destructor.

Copy Construction

Copy constructors create objects as duplicates of existing instances. Their signature requires a const reference parameter—passing by value triggers infinite recursion since parameter passing itself invokes copy construction.

class Employee {
public:
    Employee(const Employee& other) 
        : _name(other._name)
        , _badge(other._badge)
        , _department(other._department) 
    {}
private:
    std::string _name;
    int _badge;
    std::string _department;
};

Compiler-generated copy constructors perform shallow (member-wise) copying—sufficient for classes without pointer members. However, classes containing heap-allocated resources require deep copying:

class StringHolder {
public:
    StringHolder(const char* str) {
        _length = strlen(str);
        _buffer = new char[_length + 1];
        strcpy(_buffer, str);
    }
    
    // Deep copy required
    StringHolder(const StringHolder& other) 
        : _length(other._length)
        , _buffer(new char[other._length + 1]) 
    {
        strcpy(_buffer, other._buffer);
    }
    
    ~StringHolder() { delete[] _buffer; }
    
private:
    char* _buffer;
    size_t _length;
};

Copy elision and move semantics (C++11) optimize return-by-value operations, though copy constructors remain essential for explicit duplication.

Operator Overloading

Operator overloading extends built-in syntax to user-defined types through specially named functions: operator followed by the operator symbol.

Assignment Operator Specifics

The assignment operator (=) demands particular attention due to its role in resource management. Proper implementation requires:

1. Reference parameter (avoiding copy overhead)
2. Reference return (enabling chained assignment: a = b = c)
3. Self-assignment guard (correctness and efficiency)
4. Release of existing resources before acquiring new ones

class Task {
public:
    Task& operator=(const Task& rhs) {
        if (this != &rhs) {          // Self-assignment check
            _priority = rhs._priority;
            _description = rhs._description;
            // For pointer members: delete existing before copying
        }
        return *this;                // Enable chaining
    }
private:
    int _priority;
    std::string _description;
};

Assignment operators must be member functions; global overloads conflict with compiler-generated versions.

Increment Operators

Distinguishing prefix and postfix increment relies on a dummy integer parameter (unused) for the postfix variant:

class Counter {
public:
    // Prefix: return reference to modified object
    Counter& operator++() {
        ++_value;
        return *this;
    }
    
    // Postfix: return copy of original state
    Counter operator++(int) {
        Counter temp(*this);
        ++_value;
        return temp;
    }
    
private:
    int _value;
};

Prefix returns by reference (the object persists); postfix returns by value (the temporary copy expires).

Compiler-Generated Behavior Summary

Function	Built-in Types	Custom Types
Default Constructor	Uninitialized	Default constructed
Destructor	No action	Destructor invoked
Copy Constructor	Bitwise copy	Copy constructor invoked
Assignment Operator	Bitwise copy	Assignment operator invoked

Rule of Thumb: Classes managing resources (memory, files, locks) require explicit implementation of destructor, copy constructor, and assignment operator (the Rule of Three). Modern C++ extends this to include move constructor and move assignment (Rule of Five).

Complete Class Implementation: Calendar

The following demonstrates a complete date class with arithmetic and comparison operations:

class Calendar {
public:
    Calendar(int y = 2000, int m = 1, int d = 1) {
        if (validate(y, m, d)) {
            _yr = y;
            _mon = m;
            _dom = d;
        }
    }
    
    Calendar(const Calendar& c) 
        : _yr(c._yr), _mon(c._mon), _dom(c._dom) {}
    
    Calendar& operator=(const Calendar& rhs) {
        if (this != &rhs) {
            _yr = rhs._yr;
            _mon = rhs._mon;
            _dom = rhs._dom;
        }
        return *this;
    }
    
    Calendar& operator+=(int days) {
        if (days < 0) return *this -= -days;
        _dom += days;
        while (_dom > daysInMonth(_yr, _mon)) {
            _dom -= daysInMonth(_yr, _mon);
            ++_mon;
            if (_mon > 12) {
                _mon = 1;
                ++_yr;
            }
        }
        return *this;
    }
    
    Calendar operator+(int days) const {
        Calendar result(*this);
        result += days;
        return result;
    }
    
    Calendar& operator-=(int days) {
        if (days < 0) return *this += -days;
        _dom -= days;
        while (_dom < 1) {
            --_mon;
            if (_mon < 1) {
                _mon = 12;
                --_yr;
            }
            _dom += daysInMonth(_yr, _mon);
        }
        return *this;
    }
    
    Calendar operator-(int days) const {
        Calendar result(*this);
        result -= days;
        return result;
    }
    
    int operator-(const Calendar& other) const {
        Calendar early = *this < other ? *this : other;
        Calendar late = *this < other ? other : *this;
        int span = 0;
        while (early != late) {
            ++early;
            ++span;
        }
        return (*this < other) ? -span : span;
    }
    
    Calendar& operator++() { return *this += 1; }
    Calendar operator++(int) { 
        Calendar prev(*this); 
        *this += 1; 
        return prev; 
    }
    Calendar& operator--() { return *this -= 1; }
    Calendar operator--(int) { 
        Calendar prev(*this); 
        *this -= 1; 
        return prev; 
    }
    
    bool operator==(const Calendar& rhs) const {
        return _yr == rhs._yr && _mon == rhs._mon && _dom == rhs._dom;
    }
    
    bool operator!=(const Calendar& rhs) const { return !(*this == rhs); }
    bool operator<(const Calendar& rhs) const {
        if (_yr != rhs._yr) return _yr < rhs._yr;
        if (_mon != rhs._mon) return _mon < rhs._mon;
        return _dom < rhs._dom;
    }
    bool operator>(const Calendar& rhs) const { return rhs < *this; }
    bool operator<=(const Calendar& rhs) const { return !(rhs < *this); }
    bool operator>=(const Calendar& rhs) const { return !(*this < rhs); }
    
private:
    int _yr;
    int _mon;
    int _dom;
    
    static int daysInMonth(int y, int m) {
        static const int table[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        if (m == 2 && isLeap(y)) return 29;
        return table[m];
    }
    
    static bool isLeap(int y) {
        return (y % 4 == 0 && y % 100 != 0) || (y % 400 == 0);
    }
    
    static bool validate(int y, int m, int d) {
        return m > 0 && m < 13 && d > 0 && d <= daysInMonth(y, m);
    }
};

This implementation demonstrates value semantics, const-correctness, and efficient operator implementation through reuse (implementing + via +=, comparisons via < and ==).