1. Constructor Initialization Lists Revisited

Traditional constructors initialize member variables through assignment within the function body. C++ offers an alternative approach using initialization lists, which begin with a colon followed by comma-separated member initializasions. Each member is followed by its initial value or expression in parentheses.

Person(int years, int identifier, int secret)
    : _age(years)
    , _id(identifier)
    , _code(secret)
{}

Each member variable appears exactly once in the initialization list. Conceptually, this list represents where each member is defined and initialized.

Certain member types must be initialized in the initialization list:

• Reference members
• const members
• Class-type members without default constructors

Otherwise, compilation fails.

// demonstration.cpp
#include <iostream>

class Person {
public:
    Person(int& externalRef, int years, int identifier, int secret)
        : _age(years)
        , _id(identifier)
        , _code(secret)
        , _status(1)           // const member
        , _alias(externalRef)  // reference member
    {}

private:
    int _age;
    int _id;
    int _code;
    const int _status;
    int& _alias;
};

int main() {
    int value = 10;
    Person individual(value, 25, 1001, 42);
    return 0;
}

C++11 permits default values at the point of member declaration. These defaults apply to members not explicitly listed in the initialization list.

// demonstration.cpp
#include <iostream>

class Timestamp {
public:
    Timestamp(int h) : _hours(h) {}
private:
    int _hours;
};

class Person {
public:
    Person(int& externalRef, int years, int identifier)
        : _age(years)
        , _id(identifier)
    {}

    void display() {
        std::cout << _age << " " << _id << " " << _code << std::endl;
    }

private:
    int _age = 1;        // default values
    int _id = 1;
    int _code = 1;       // will use this default
    Timestamp _t = 5;    // default for class member
};

int main() {
    int value = 10;
    Person individual(value, 30, 2001);
    individual.display(); // Shows: 30 2001 1
    return 0;
}

Initialization proceeds as follows:

1. Members explicitly in the initialization list use those values
2. Other members use defaults from declarations if provided
3. For built-in types without defaults, values are indeterminate (likely random)
4. For custom types without defaults, the default constructor is called; if none exists, compilation fails

Critical: Initialization order follows member declaration order, not initialization list order. Keep these sequences consistent.

// demonstration.cpp
#include <iostream>

class Entity {
public:
    Entity(int value)
        : _primary(value)
        , _secondary(_primary)  // Problem: _secondary declared first
    {}
    
    void show() {
        std::cout << _primary << " " << _secondary << std::endl;
    }

private:
    int _primary = 2;
    int _secondary = 2;  // Declared first, initialized first
};

int main() {
    Entity item(100);
    item.show();  // Output: 100 [random_value]
    return 0;
}

Since _secondary is declared before _primary, it gets initialized first using an uninitialized _primary, resulting in undefined behavior.

2. Static Members

Static member variables belong to the class itself, not to any specific instance. They reside in the static storage area, not within object memory.

// demonstration.cpp
#include <iostream>

class Configuration {
public:
    Configuration(int val) {}
    ~Configuration() {}
private:
    static int _sharedCounter;
};

int main() {
    std::cout << sizeof(Configuration) << std::endl; // Does not include static member
    return 0;
}

Static member variables require explicit definition and initialization outside the class:

// Out-of-class definition
int Configuration::_sharedCounter = 0;

Static member functions, marked with the static keyword, lack a this pointer. Consequently:

• They can only access static members
• Non-static member functions can access both static and non-static members

class Configuration {
public:
    static int retrieveValue() {
        // Cannot access _instanceData here - no this pointer
        return _sharedCounter;
    }
private:
    int _instanceData;
    static int _sharedCounter;
};

Access static members using the scope resolution operator (ClassName::member) or through an object instance. Like all members, they respect public, protected, and private access specifiers.

Static members cannot have default values in their declarations because such values serve the constructor's initialization list, and static members bypass this process antirely.

3. Friend Declarations

class Module;

class Component {
    // Forward declaration required
    friend void bridgeFunction(const Component& c, const Module& m);
    friend class Module;  // Friend class declaration
private:
    int _privateData;
    static int _staticData;
};

class Module {
    // Can access Component's private members
};

Friend declarations grant external functions or classes access to private and protected members. Key characteristics:

• Friend functions are not member functions; they're ordinary functions with special access privileges
• Friend declarations can appear anywhere within a class, unaffected by access specifiers
• A single function can be a friend of multiple classes
• All member functions of a friend class become friend functions of the original class
• Friend relationships are unidirectional (if A is a friend of B, B is not automatically a friend of A)
• Friend relationships are non-transitive (A→B and B→C does not imply A→C)

While convenient, friend declarations increase coupling and weaken encapsulation. Use sparingly.

4. Nested Classes

// demonstration.cpp
#include <iostream>

class Container {
public:
    class Nested {  // Nested class has automatic friendship
    public:
        void inspect(const Container& parent) {
            std::cout << _sharedSecret << std::endl;      // OK: static member
            std::cout << parent._hiddenValue << std::endl; // OK: private member
        }
    private:
        int _nestedValue = 1;
    };

private:
    int _hiddenValue = 1;
    static int _sharedSecret;
};

int Container::_sharedSecret = 42;

int main() {
    std::cout << sizeof(Container) << std::endl; // Nested class does not affect size
    return 0;
}

A class defined within another class is a nested class. Important properties:

• Nested classes are independent types, merely scoped within the outer class
• Outer class objects do not contain nested class instances
• Nested classes automatically become friends of their outer class
• Nested classes represent a strong design relationship; placing them in private or protected sections makes them exclusive to the outer class

5. Temporary Objects

// Named objects
Processor p1;
Processor p2(8);

// Anonymous (temporary) objects
Processor();
Processor(16);

Temporary objects are created without names using Type(arguments). Their lifetime extends only to the end of the current statement, making them ideal for one-time operations.

// demonstration.cpp
#include <iostream>

class TemporaryString {
public:
    TemporaryString(int version = 0) {}
    ~TemporaryString() {}
    
    std::string generate() {
        return "2024-07-15";
    }
};

int main() {
    // Named object usage
    TemporaryString generator;
    std::cout << generator.generate() << std::endl;
    
    // Temporary object usage
    std::cout << TemporaryString().generate() << std::endl;
    
    return 0;
}

6. Compiler Copy Elision

Modern compilers aggressively optimize by eliminating unnecessary object copies when correctness is preserved.

// demonstration.cpp
#include <iostream>

class SimpleData {
public:
    SimpleData(int x = 0, int y = 0) {
        std::cout << "Constructor called" << std::endl;
    }
    ~SimpleData() {
        std::cout << "Destructor called" << std::endl;
    }
    
    int _value1 = 1;
    int _value2 = 2;
};

int main() {
    // Copy initialization - optimized to single construction
    SimpleData item1 = 5;
    std::cout << "****************" << std::endl;
    
    // Reference binding - creates temporary, no extra copy
    const SimpleData& item2 = 10;
    std::cout << "****************" << std::endl;
    
    return 0;
}

In the item1 initialization, two constructor calls might be expected (one for the temporary, one for item1), but the compiler elides the temporary, performing only a single construction. The item2 reference binds directly to a temporary object.

C++ standards don't mandate specific optimizations; compilers make independent decisions. Contemporary compilers merge consecutive copy operations within a single expression, and some perform even more aggressive cross-statement optimizations.