What Hidden Functions Does C++ Auto‑Generate for Your Classes?

Special Member Functions Generated by the C++ Compiler

C++ automatically provides seven (or eight in C++11) special member functions for a class when they are not explicitly declared. These functions perform default actions that are sufficient for simple types but can cause resource‑management bugs for classes that own dynamic resources such as memory allocated with new.

1. Default Constructor

If no constructor is declared, the compiler generates a no‑argument constructor that default‑initialises members. Built‑in types are left with indeterminate values.

class MyClass {
public:
    int x;               // uninitialised
    MyClass() { }        // default constructor
};

int main() {
    MyClass obj;                // default constructor called
    std::cout << obj.x << std::endl; // prints an indeterminate value
}

2. Default Destructor

The compiler‑generated destructor runs when an object’s lifetime ends. It does nothing unless the class manages resources. If the class owns memory allocated with new, the default destructor will leak that memory.

class MyClass {
public:
    int *ptr;
    MyClass() { ptr = new int(10); }
    ~MyClass() { } // does not delete ptr → memory leak
};

When a class owns dynamic resources you must provide a destructor that releases them, e.g. delete ptr;.

3. Default Copy Constructor

The implicitly‑declared copy constructor performs a member‑wise (shallow) copy. For pointer members this copies the pointer value, causing multiple objects to share the same allocation.

class MyClass {
public:
    int *ptr;
    MyClass(int v) { ptr = new int(v); }
    // compiler‑generated copy constructor would be:
    // MyClass(const MyClass &other) : ptr(other.ptr) { }
    ~MyClass() { delete ptr; }
};

Shallow copying of a pointer leads to double‑free errors when both objects are destroyed.

Solution – Deep Copy

MyClass(const MyClass &other) {
    ptr = new int(*other.ptr); // allocate separate memory
}

4. Default Copy Assignment Operator

The automatically generated assignment operator also copies members shallowly. With pointer members this produces the same double‑free problem as the copy constructor.

class MyClass {
public:
    int *ptr;
    MyClass(int v) { ptr = new int(v); }
    MyClass &operator=(const MyClass &other) {
        ptr = other.ptr; // shallow copy
        return *this;
    }
    ~MyClass() { delete ptr; }
};

A safe implementation performs a deep copy and guards against self‑assignment:

MyClass &operator=(const MyClass &other) {
    if (this != &other) {
        delete ptr;                     // free existing resource
        ptr = new int(*other.ptr);      // allocate and copy
    }
    return *this;
}

5. Default Address‑of Operator ( & )

If not overloaded, & simply returns the object’s address.

class MyClass {
public:
    MyClass* operator&() { return this; }
};

int main() {
    MyClass obj;
    MyClass* p = &obj; // uses default address‑of
    std::cout << p << std::endl;
}

6. Const Address‑of Operator

For const objects the compiler provides a const‑qualified overload that returns a const MyClass*, preventing modification through the returned pointer.

class MyClass {
public:
    const MyClass* operator&() const { return this; }
};

int main() {
    const MyClass obj;
    const MyClass* p = &obj; // const address‑of
    std::cout << p << std::endl;
}

7. Default Move Constructor (C++11)

The move constructor transfers ownership of resources from an rvalue (temporary) object to a new object, leaving the source in a valid but empty state.

class MyClass {
public:
    int *ptr;
    MyClass(int v) { ptr = new int(v); }
    MyClass(MyClass &&other) {
        ptr = other.ptr;      // take ownership
        other.ptr = nullptr; // source emptied
    }
    ~MyClass() { delete ptr; }
};

int main() {
    MyClass a(10);
    MyClass b = std::move(a); // move constructor invoked
    std::cout << b.ptr << std::endl; // valid pointer
    std::cout << a.ptr << std::endl; // nullptr
}

Moving avoids the costly deep copy of large or complex objects.

8. Default Move Assignment Operator (C++11)

The move assignment operator works like the move constructor but for an already‑existing object. It first releases the current object's resources, then takes ownership from the rvalue.

class MyClass {
public:
    int *ptr;
    MyClass(int v) { ptr = new int(v); }
    MyClass &operator=(MyClass &&other) {
        if (this != &other) {
            delete ptr;          // free current resource
            ptr = other.ptr;     // take ownership
            other.ptr = nullptr; // source emptied
        }
        return *this;
    }
    ~MyClass() { delete ptr; }
};

int main() {
    MyClass a(10);
    MyClass b(20);
    b = std::move(a); // move assignment invoked
    std::cout << b.ptr << std::endl; // points to a's former memory
    std::cout << a.ptr << std::endl; // nullptr
}

Move semantics provide a significant performance boost for temporary objects and prevent double‑free errors.

When to Provide Custom Implementations

Dynamic resources (memory, file handles, sockets, etc.) – implement a destructor, copy constructor, copy assignment, move constructor, and move assignment that correctly manage ownership.

Pointer members – use deep copy in copy operations or disable copying (e.g., MyClass(const MyClass&) = delete;).

Self‑assignment – guard against it in assignment operators to avoid premature resource release.

Understanding the default behaviour and its limitations is essential for writing robust C++ classes that manage resources safely and efficiently.