Overview of Default Member Functions

In C++, if a developer does not explicitly define certain member functions within a class, the compiler automatically generates them. These are known as default member functions. Historically, there are six primary functions generated by default, though modern C++ (C++11 and later) introduces move semantics which add two more. The core six include the constructor, destructor, copy constructor, copy assignment operator, and two address-of operators. Understanding when the compiler generates these and when manual implementation is required is critical for resource management.

Construction and Destruction

Constructors

A constructor is a special member function responsible for initializing an object upon instantiation. It does not allocate memory for the object itself (stack or heap allocation happens before the constructor runs); rather, it initializes the memory space.

Key characteristics include:

1. The function name must match the class name exactly.
2. There is no return type, not even void.
3. It is invoked automatically when an object is created.
4. Constructors support overloading.
5. If no constructor is defined, the compiler generates a parameterless default constructor. If any constructor is defined explicitly, the compiler stops generating the default parameterless one.

A "default constructor" refers to any constructor that can be called without arguments. This includes a no-argument constructor or a constructor where all parameters have default values. Only one such constructor can exist per class to avoid ambiguity.

class Timestamp
{
public:
    // All parameters have defaults, making this a default constructor
    Timestamp(int y = 2000, int m = 1, int d = 1)
    {
        m_year = y;
        m_month = m;
        m_day = d;
    }

private:
    int m_year;
    int m_month;
    int m_day;
};

Regarding initialization behavior: If the compiler generates the constructor, built-in types (like int, float) may remain uninitialized depending on the context, while custom type members will have their own default constructors called. If a custom member lacks a default constructor, an initialization list must be used in the user-defined constructor.

Destructors

The destructor performs cleanup tasks before an object's memory is reclaimed. It does not destroy the object's storage itself (e.g., stack frames are managed by the scope), but rather releases resources held by the object, such as dynamic memory or file handles.

Rules for destructors:

1. The name is the class name preceded by a tilde (~).
2. No parameters and no return type.
3. A class can have only one destructor.
4. It is called automatically when the object's lifecycle ends.
5. Compiler-generated destructors do not release resources for built-in types but will call destructors for custom type members.

If a class manages resources (e.g., via malloc or new), a custom destructor is mandatory to prevent leaks. For classes composed entirely of built-in types or custom types that manage their own resources, the default destructor is usually sufficient.

class DynamicArray
{
public:
    ~DynamicArray()
    {
        std::free(m_buffer);
        m_buffer = nullptr;
        m_capacity = 0;
        m_size = 0;
    }

private:
    int* m_buffer;
    size_t m_capacity;
    size_t m_size;
};

Copy Semantics

Copy Constructor

The copy constructor creates a new object as a copy of an existing one. Its signature must take a reference to the same class type as the first parameter.

// Incorrect: Causes infinite recursion due to pass-by-value
// Timestamp(Timestamp ts) { ... }

// Correct: Uses reference
Timestamp(const Timestamp& other)
{
    m_year = other.m_year;
    m_month = other.m_month;
    m_day = other.m_day;
}

If not defined, the compiler generates a default copy constructor that performs a shallow copy (member-wise copy). For built-in types, this is usually fine. However, if the class holds pointers to dynamically allocated memory, a shallow copy results in two objects pointing to the same memory, leading to double-free errors. In such cases, a deep copy must be implemented manually.

Assignment Operator Overloading

The assignment operator handles copying data between two existing objects. It must be implemented as a member functon.

Timestamp& operator=(const Timestamp& other)
{
    if (this != &other)
    {
        m_year = other.m_year;
        m_month = other.m_month;
        m_day = other.m_day;
    }
    return *this;
}

Key points:

1. Return type should be a reference to the class (Class&) to support chained assignments.
2. Check for self-assignment to avoid unnecessary work or errors.
3. Like the copy constructor, the default compiler-generated version performs a shalllow copy. Classes managing resources require a custom implementation to handle deep copying and release old resources before assigning new ones.

Operator Overloading

C++ allows redefining the behavior of operators for custom types. The function name is operator followed by the symbol.

General Rules

• Cannot create new operators (e.g., operator@).
• Cannot change precedence or associativity.
• Cannot change the number of operands (unless using default arguments carefully, but generally fixed).
• At least one operand must be a custom class type.
• Five operators cannot be overloaded: .*, ::, sizeof, ?:, ..

Specific Operators

Increment (++): Distinguishing prefix and postfix requires a dummy int parameter for the postfix version.

// Prefix
Timestamp& operator++()
{
    // Modify state
    return *this;
}

// Postfix
Timestamp operator++(int)
{
    Timestamp temp = *this;
    // Modify state
    return temp;
}

Stream Insertion (<<): Typically overloaded as a global function to allow the stream object (std::ostream) to be the left-hand operand. The class must declare the function as a friend to access private members.

class Timestamp
{
    friend std::ostream& operator<<(std::ostream& out, const Timestamp& t);
private:
    int m_year, m_month, m_day;
};

std::ostream& operator<<(std::ostream& out, const Timestamp& t)
{
    out << t.m_year << "/" << t.m_month << "/" << t.m_day;
    return out;
}

Const Member Functions and Address Operators

Const Member Functions

Appending const after the parameter list indicates that the member function will not modify the object's state. Technically, this modifies the implicit this pointer from Class* const to const Class* const.

void Display() const
{
    // m_year = 2023; // Error: Cannot modify members in const function
    std::cout << m_year << std::endl;
}

Address-of Operator Overloading

The address-of operator (&) can be overloaded, though this is rarely necessary. Both non-const and const versions can be defined.

class Timestamp
{
public:
    Timestamp* operator&() { return this; }
    const Timestamp* operator&() const { return this; }
private:
    int m_year, m_month, m_day;
};

In most scenarios, the compiler-generated version are sufficient. Custom implementation is only needed for specific design constraints, such as restricting access to an object's memory address.