An empty class containing no explicit members is not truly empty. The compiler silently synthesizes six default member functions: a default constructor, destructor, copy constructor, copy assignment operator, non-const address-of operator, and const address-of operator. When the user provides no explicit definition, these generated operations manage object lifecycle, copying, and basic introspection.

Constructors

Constructors automate object initialization, eliminating manual setup calls that are easily forgotten. Although named "constructor," this function does not allocate the object itself; it initializes the object's members before use.

A constructor shares the class name, has no return type—not even void—and executes automatically during instantiation. Multiple constructors may coexist through overloading.

class CalendarDate {
public:
    CalendarDate() = default;
    
    CalendarDate(int y, int m, int d)
        : yr(y), mon(m), day(d) {}
        
private:
    int yr;
    int mon;
    int day;
};

When declaring an object with the default constructor, omit empty parentheses to avoid declaring a function instead:

CalendarDate d1;            // default construction
CalendarDate d2(2024, 3, 15); // parameterized construction
// CalendarDate d3();       // ERROR: function declaration, not an object

Default Constructor Ambiguity

A default constructor is callable without arguments. This category includes no-argument constructors, fully defaulted constructors, and compiler-generated constructors. Only one default constructor may exist within a class. Providing both a no-argument and a fully defaulted constructor creates an ambiguity during overload resolution:

class CalendarDate {
public:
    CalendarDate() {
        yr = 1; mon = 1; day = 1;
    }
    
    // Ambiguous with the above when called as CalendarDate d;
    CalendarDate(int y = 1, int m = 1, int d = 1) {
        yr = y; mon = m; day = d;
    }
    
private:
    int yr, mon, day;
};

Prefer a single fully defaulted constructor to avoid this conflict.

Compiler-Generated Behavior

If no constructor is declared, the compiler generates a default constructor. This generated constructor leaves built-in types uninitialized—typically holding indeterminate values—while invoking default constructors for user-defined member types.

class ClockTime {
public:
    ClockTime() { hr = min = sec = 0; }
private:
    int hr, min, sec;
};

class CalendarDate {
private:
    int yr;       // built-in: uninitialized
    int mon;      // built-in: uninitialized
    ClockTime tm; // user-defined: calls ClockTime()
};

C++11 permits default member initializers to patch the uninitialized built-in type behavior:

class CalendarDate {
private:
    int yr = 1970;
    int mon = 1;
    int day = 1;
    ClockTime tm;
};

These default values are applied before any user-defined constructor body executes. If a constructor subsequently assigns to these members, that assignment occurs after the in-class defaults are established.

Destructors

Destructors perform resource cleanup when an object reaches the end of its lifetime. The compiler handles the actual reclamation of the object's storage; the destructor releases auxiliary resources such as dynamically allocated memory, file handles, or network connections.

Destructors are named with a tilde prefix (~ClassName), accept no parameters, return nothing, and cannot be overloaded. The compiler invokes them automatically when a scope exits or delete is called.

class IntStack {
public:
    IntStack() {
        pool = new int[64];
        cap = 64;
        sz = 0;
    }
    
    ~IntStack() {
        delete[] pool;
        pool = nullptr;
        sz = 0;
    }
    
private:
    int* pool;
    size_t cap;
    size_t sz;
};

Generated Destructor Behavior

A compiler-generated destructor invokes destructors for user-defined members but performs no action on built-in types. When nesting custom types, this creates an implicit chain of destruction:

class TaskQueue {
private:
    IntStack incoming;
    IntStack outgoing;
    int taskId = 0;
};

The compiler-generated ~TaskQueue() automatically calls ~IntStack() for both member stacks. Manual destructor implementation is only necessary when the class directly manages an external resource.

Destruction Order

Objects with automatic storage duration are destroyed in reverse order of their construction:

int main() {
    IntStack a;
    IntStack b;
} // b destroyed first, then a

Copy Constructors

The copy constructor initializes a new object as a duplicate of an existing object. It is an overload of the constructor bearing a single parameter: a reference to the source object.

Pass-by-Reference Requirement

The parameter must be a reference. Passing by value would require copying the argument into the parameter, which itself invokes the copy constructor, leading to infinite recursion:

class CalendarDate {
public:
    CalendarDate(int y, int m, int d) : yr(y), mon(m), day(d) {}
    
    // Correct: const reference prevents modification and avoids recursion
    CalendarDate(const CalendarDate& src)
        : yr(src.yr), mon(src.mon), day(src.day) {}
        
private:
    int yr, mon, day;
};

Usage patterns:

CalendarDate original(2024, 6, 1);
CalendarDate replica(original);  // explicit copy construction
CalendarDate alias = original;   // copy construction (not assignment)

Note that if you declare any constructor—including a copy constructor—the compiler will not generate a default constructor unless you explicitly request one with = default.

Shallow Copy vs. Deep Copy

The compiler-generated copy constructor performs a memberwise shallow copy. For classes managing heap memory, this creates multiple owners of the same address, causing double-free errors during destruction:

class IntStack {
public:
    IntStack() {
        pool = new int[64];
        cap = 64;
        sz = 0;
    }
    
    // Deep copy required
    IntStack(const IntStack& src) {
        cap = src.cap;
        sz = src.sz;
        pool = new int[cap];
        for (size_t i = 0; i < sz; ++i) {
            pool[i] = src.pool[i];
        }
    }
    
    ~IntStack() { delete[] pool; }
    
private:
    int* pool;
    size_t cap;
    size_t sz;
};

Classes like CalendarDate that hold no dynamic resources typically rely on the generated shallow copy. Classes composed solely of properly behaved custom types—such as TaskQueue above—also need no explicit copy constructor.

Operator Overloading

Operator overloading allows custom types to use intuitive syntax. An overloaded operator is a function named operator<symbol>. At least one operand must be a class type, and the meaning of operators for built-in types cannot be altered. The operators ::, ?:, ., sizeof, and .* cannot be overloaded.

Implementing an operator as a member function reduces the explicit parameter count by one because the left operand becomes the implicit this pointer:

class CalendarDate {
public:
    CalendarDate(int y, int m, int d) : yr(y), mon(m), day(d) {}
    
    bool operator==(const CalendarDate& rhs) const {
        return yr == rhs.yr && mon == rhs.mon && day == rhs.day;
    }
    
private:
    int yr, mon, day;
};

This enables natural syntax:

CalendarDate d1(2024, 1, 1);
CalendarDate d2(2024, 1, 1);
if (d1 == d2) { /* dates match */ }

Assignment Operator Overload

Assignment differs from construction: assignment targets an existing object, whereas construction creates a new one. The assignment operator must be a non-static member function. Defining it outside the class conflicts with the compiler-ganerated version.

A robust assignment operator accepts a const reference, guards against self-assignment, and returns a reference to the current object to support chaining:

class CalendarDate {
public:
    CalendarDate& operator=(const CalendarDate& rhs) {
        if (this != &rhs) {
            yr = rhs.yr;
            mon = rhs.mon;
            day = rhs.day;
        }
        return *this;
    }
private:
    int yr, mon, day;
};

Chaining relies on returning the left-hand operend:

CalendarDate a, b, c;
a = b = c;  // b = c executes first, returning b; then a = b

The compiler-generated assignment operator performs memberwise value copying. Similar to copy construction, a custom implementation is mandatory when the class owns raw pointers or handles to external resources.

Address-of Operator Overloading

The compiler provides default address-of operators—operator& and a const overload—that return this. Explicit definition is rarely necessary, but may restrict acess or return proxy addresses for defensive designs:

class SecureHandle {
public:
    SecureHandle* operator&() { return this; }
    const SecureHandle* operator&() const { return this; }
private:
    int token;
};

To prevent external code from obtaining an object's address, return nullptr or declare the operators as private.