Special Member Functions in C++

Special member functions are implicitly declared by the compiler when not explicitly defined by the user. For a typical class, the compiler generates six such functions: default constructor, destructor, copy constructor, copy assignment operator, address-of operator overloads (non-const and const), and — since C++11 — move constructor and move assignment operator. Of these, the first four are most critical for resource management and object semantics.

The key considerations are:

• What behavior does the compiler-generated version provide?
• When does that behavior fall short — and how do we implement a custom version correctly?

1. Default Constructor

A constructor initializes an object’s state upon creation. It is not responsible for memory allocation (which occurs during stack frame setup or heap allocation), but rather for establishing valid initial values.

Key properties:

• Name matches the class name.
• No return type — not even void.
• Invoked automatically during object instantiation.
• Supports overloading.
• If no user-defined constructor exists, the compiler synthesizes a parameterless default constructor.
• A constructor with no parameters or one where all parameters have defaults qualifies as a default constructor. Only one such constructor may be present to avoid ambiguity.
• Compiler-generated constructors leave built-in types uninitialized (indeterminate value), while invoking the default constructor of each member of user-defined type.

#include <iostream>

class CalendarDate {
public:
    // Default constructor
    CalendarDate() : year_(2024), month_(1), day_(1) {}

    // Parameterized constructor
    CalendarDate(int y, int m, int d) : year_(y), month_(m), day_(d) {}

    void display() const {
        std::cout << year_ << '-' << month_ << '-' << day_ << '\n';
    }

private:
    int year_, month_, day_;
};

int main() {
    CalendarDate today;           // Uses default constructor
    CalendarDate tomorrow(2024, 1, 2);
    today.display();
    tomorrow.display();
}

Note: Built-in types (e.g., int, double, pointers) are language-provided primitives; user-defined types include any class, struct, or union.

2. Destructor

The destructor cleans up resources held by an object before its storage is reclaimed. It does not destroy the object’s memory — that is handled automatically (e.g., stack unwinding or delete). Its role mirrors manual cleanup logic like Destroy() in C-style implementations.

Key properties:

• Named ~ClassName().
• Takes no arguments and returns nothing.
• Exactly one per class; compiler provides a trivial version if omitted.
• Called automatically at end of scope (for automatic objects) or after delete (for dynamic objects).
• Compiler-generated destructors perform no action on built-in members, but invoke the destructor of each user-defined member.
• Explicit definition is required only when managing external resources (e.g., heap memory, file handles). Classes composed solely of RAII types (like std::vector) usually need no custom destructor.

class DynamicStack {
public:
    explicit DynamicStack(size_t cap = 8)
        : capacity_(cap), size_(0) {
        data_ = new int[capacity_];
    }

    ~DynamicStack() {
        delete[] data_;
        data_ = nullptr;
        size_ = capacity_ = 0;
    }

private:
    int* data_;
    size_t capacity_, size_;
};

// Composition example: no custom destructor needed
struct QueueWrapper {
    DynamicStack input_, output_;
    // Compiler-generated destructor safely calls both members' destructors
};

3. Copy Constructor

A copy constructor creates a new object as a copy of an existing one. It must accept a const lvalue reference to its own type.

Key properties:

• Signature: ClassName(const ClassName& other).
• Passing by value would cause infinite recursion (copying triggers another copy construction).
• Required for copy-initialization (T obj = other;), pass-by-value parameters, and return-by-value.
• Compiler generates a memberwise bitwise copy (shallow copy) if none is provided.
• Shallow copy suffices for classes with no external resources. If raw pointers or handles exist (e.g., data_ in DynamicStack), a deep copy implementation is mandatory.

class TimeStamp {
public:
    TimeStamp(int h = 0, int m = 0, int s = 0)
        : hour_(h), minute_(m), second_(s) {}

    // Custom copy constructor
    TimeStamp(const TimeStamp& rhs)
        : hour_(rhs.hour_), minute_(rhs.minute_), second_(rhs.second_) {
        std::cout << "Copy constructed\n";
    }

private:
    int hour_, minute_, second_;
};

class EventLog {
    int id_;
    TimeStamp timestamp_;
    // No user-defined copy constructor → compiler generates one
    // which invokes TimeStamp's copy constructor
};

4. Copy Assignment Operator

This operator assigns the contents of one existing object to another existing object (a = b). It differs from copy construction, which initializes a new object.

Key properties:

• Must be a non-static member function.
• Typically takes const ClassName& and returns ClassName& (to support chaining: a = b = c).
• Compiler generates a memberwise assignment: shallow copy for built-ins, assignment operator calls for user-defined members.
• Self-assignment protection (if (this != &rhs)) is essential when managing resources.

class CalendarDate {
public:
    CalendarDate& operator=(const CalendarDate& rhs) {
        if (this == &rhs) return *this;
        year_ = rhs.year_;
        month_ = rhs.month_;
        day_ = rhs.day_;
        return *this;
    }

private:
    int year_, month_, day_;
};

Rule of Zero/Three/Five: If you define any of destructor, copy constructor, or copy assignment, consider whether move operations are also needed — especially in modern C++.

5. Increment/Decrement Operators

Overloading ++ and -- requires distinguishing prefix and postfix forms. The compiler uses an unused int parameter in the postfix version to enable overload resolution.

class CalendarDate {
public:
    CalendarDate& operator++() { // prefix
        ++day_;
        normalize();
        return *this;
    }

    CalendarDate operator++(int) { // postfix
        CalendarDate old = *this;
        ++(*this);
        return old;
    }

    CalendarDate& operator--() {
        --day_;
        normalize();
        return *this;
    }

    CalendarDate operator--(int) {
        CalendarDate old = *this;
        --(*this);
        return old;
    }

private:
    void normalize() {
        // Adjust month/year if day exceeds current month's days
        // …
    }

    int year_, month_, day_;
};

6. operator<< and operator>> Overloading

These stream operators are best implemented as non-member functions to preserve left-hand operand flexibility. Friendship grants access to private members.

#include <iostream>

class CalendarDate {
    friend std::ostream& operator<<(std::ostream& os, const CalendarDate& d);
    friend std::istream& operator>>(std::istream& is, CalendarDate& d);

    // …
};

std::ostream& operator<<(std::ostream& os, const CalendarDate& d) {
    return os << d.year_ << '-' << d.month_ << '-' << d.day_;
}

std::istream& operator>>(std::istream& is, CalendarDate& d) {
    char dash;
    return is >> d.year_ >> dash >> d.month_ >> dash >> d.day_;
}

7. const Member Functions

Declaring a member function const means it promises not to modify the object’s logical state. The implicit this pointer becomes const ClassName* const.

class CalendarDate {
public:
    void print() const { // 'this' is const CalendarDate* const
        std::cout << year_ << '-' << month_ << '-' << day_ << '\n';
        // year_ = 2025; // ❌ compilation error
    }

private:
    int year_, month_, day_;
};

int main() {
    const CalendarDate cd(2024, 1, 1);
    cd.print(); // ✅ allowed
}

8. Practical Date Class Interface

A production-ready date class typically supports comparison, arithmetic, and I/O. Below is a minimal header outlining core functionality:

#pragma once
#include <iostream>

class CalendarDate {
    friend std::ostream& operator<<(std::ostream&, const CalendarDate&);
    friend std::istream& operator>>(std::istream&, CalendarDate&);

public:
    CalendarDate(int y = 2024, int m = 1, int d = 1);

    bool is_valid() const;
    int days_in_month() const;

    // Comparison
    bool operator<(const CalendarDate&) const;
    bool operator==(const CalendarDate&) const;

    // Arithmetic
    CalendarDate operator+(int days) const;
    CalendarDate& operator+=(int days);
    CalendarDate operator-(int days) const;
    CalendarDate& operator-=(int days);

    // Increment/decrement
    CalendarDate& operator++();
    CalendarDate operator++(int);
    CalendarDate& operator--();
    CalendarDate operator--(int);

    // Difference in days
    int operator-(const CalendarDate&) const;

private:
    int year_, month_, day_;
};

std::ostream& operator<<(std::ostream&, const CalendarDate&);
std::istream& operator>>(std::istream&, CalendarDate&);