Function overloading enables multiple functions to share the same name within a scope, distinguished by their parameter types or count. This allows compile-time polymorphism where the correct function is selected based on the arguments provided during the call.

Default arguments allow functions to be called with fewer parameters than defined, using specified values for the omitted ones. These defaults are defined in the function declaration.

#include <iostream>

class Config {
public:
    void setDimensions(int width = 100, int height = 50);
    void calculateArea(bool useFull = false);
private:
    int w;
    int h;
};

void Config::setDimensions(int width, int height) {
    w = width;
    h = height;
}

void Config::calculateArea(bool useFull) {
    if (useFull) {
        std::cout << "Full Area: " << w * h << std::endl;
    } else {
        std::cout << "Half Area: " << (w * h) / 2 << std::endl;
    }
}

int main() {
    Config cfg;
    cfg.setDimensions(); // Uses defaults
    cfg.calculateArea(); // Uses default false
    return 0;
}

Default arguments are resolved at compile time based on the function declaration visible at the call site. This mechanism is native to C++ and differs from languages that require method overloading to simulate default values.

When a class contains const members or references, they cannot be assigned values within the constructor body because they must be initialized at the moment of creation. The member initializer list is required for this purpose.

class Box {
public:
    // Initializer list syntax
    Box() : length(10), width(20) {} 
private:
    const int length;
    const int width;
};

The colon following the constructor signature introduces the initialization list. Members are separated by commas. This approach is mandatory for const members and references, as assignment after initialization is illegal for these types.

Copy constructors are used to create a new object as a copy of an existing one. If not explicitly defined, the compiler generates a default version that performs a member-wise copy.

class Data {
public:
    Data() {}
    Data(const Data& other) {
        val = other.val;
    }
    Data(int v) { val = v; }
    void display() { std::cout << val << std::endl; }
private:
    int val;
};

int main() {
    Data original(42);
    Data copy = original; // Invokes copy constructor
    return 0;
}

In C++, dynamic object instantiation requires explicit memory management using pointers and the new operator, unlike garbage-collected environments.

Data* ptr = new Data(10);
ptr->display();
delete ptr;

The explicit keyword prevents implicit conversions and copy initialization for constructors that take a single argument. This safeguards against unintended type coercion.

class Identity {
public:
    explicit Identity(int id) {
        value = id;
    }
    int getValue() const { return value; }
private:
    int value;
};

int main() {
    Identity obj(5); 
    // Identity obj2 = 5; // Error: implicit conversion blocked
    return 0;
}

Without explicit, the compiler might interpret Identity obj = 5 as Identity obj = Identity(5), invoking the constructor implicitly.

A critical issue arises when classes manage dynamic memory. The default copy constructor performs a shallow copy, meaning pointer members are copied by value. This results in two objects pointing to the same memory address. When one object is destroyed, it frees the memory, leaving the other with a dangling pointer.

To prevent this, implement a deep copy constructor that allocates new memory for the copy.

class Resource {
public:
    Resource() {
        buffer = new int(42);
    }
    ~Resource() {
        delete buffer;
        buffer = nullptr;
    }
    // Deep copy constructor
    Resource(const Resource& other) {
        buffer = new int;
        *buffer = *(other.buffer);
    }
    void print() const {
        std::cout << *buffer << std::endl;
    }
private:
    int* buffer;
};

By allocating distinct memory for the buffer pointer in the copy constructor, each object maintains ownership of its own resources, preventing double-free errors and data corruption during destruction.