initializer_lists

Concept: initializer lists in class constructors

An initializer list in C++ is a mechanism used in constructors to initialize class members before the constructor body executes. It provides a way to directly initialize members, potentially improving performance and allowing initialization of const members and references.

Key Characteristics

• Appears after the constructor's parameter list, preceded by a colon
• Initializes members in the order they are declared in the class, not the order in the initializer list
• Can call other constructors (delegating constructors in C++11 and later)
• Necessary for initializing const members, reference members, and base classes
• Often more efficient than assigning values in the constructor body

Example 1: Basic Usage of Initializer List

#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    int age;
    const double height;

public:
    // Constructor using initializer list
    Person(const std::string& n, int a, double h)
        : name(n), age(a), height(h) {
        std::cout << "Person constructed" << std::endl;
    }

    void display() const {
        std::cout << name << " is " << age << " years old and " 
                  << height << "m tall." << std::endl;
    }
};

int main() {
    Person person("Alice", 30, 1.65);
    person.display();

    return 0;
}

Explanation:

• The constructor uses an initializer list to initialize name, age, and height.
• This is especially important for height, which is a const member and must be initialized in the initializer list.

Example 2: Initializer List with Default Member Initializers

#include <iostream>
#include <string>

class Car {
private:
    std::string brand;
    std::string model;
    int year = 2023;  // Default member initializer
    double price;

public:
    // Constructor using initializer list and default member initializer
    Car(const std::string& b, const std::string& m, double p)
        : brand(b), model(m), price(p) {
        std::cout << "Car constructed" << std::endl;
    }

    // Constructor that overrides the default year
    Car(const std::string& b, const std::string& m, int y, double p)
        : brand(b), model(m), year(y), price(p) {
        std::cout << "Car constructed with specified year" << std::endl;
    }

    void display() const {
        std::cout << year << " " << brand << " " << model 
                  << " priced at $" << price << std::endl;
    }
};

int main() {
    Car car1("Toyota", "Corolla", 25000.0);
    car1.display();

    Car car2("Honda", "Civic", 2022, 23000.0);
    car2.display();

    return 0;
}

Explanation:

• year has a default member initializer of 2023.
• The first constructor doesn't initialize year in its initializer list, so the default value is used.
• The second constructor overrides the default value in its initializer list.

Example 3: Initializer List with Delegating Constructors (C++11)

#include <iostream>
#include <string>

class Employee {
private:
    std::string name;
    int id;
    double salary;

public:
    // Primary constructor
    Employee(const std::string& n, int i, double s)
        : name(n), id(i), salary(s) {
        std::cout << "Primary constructor called" << std::endl;
    }

    // Delegating constructor
    Employee(const std::string& n, int i)
        : Employee(n, i, 50000.0) {  // Calls the primary constructor
        std::cout << "Delegating constructor called" << std::endl;
    }

    void display() const {
        std::cout << name << " (ID: " << id << ") earns $" << salary << std::endl;
    }
};

int main() {
    Employee emp1("Bob", 1001, 60000.0);
    emp1.display();

    Employee emp2("Alice", 1002);
    emp2.display();

    return 0;
}

Explanation:

• The second constructor delegates to the first constructor using an initializer list.
• This allows for code reuse and maintains a single point of initialization.

Example 4: Initializer List with Inheritance

#include <iostream>
#include <string>

class Animal {
protected:
    std::string species;
    int age;

public:
    Animal(const std::string& s, int a) : species(s), age(a) {
        std::cout << "Animal constructed" << std::endl;
    }

    virtual void makeSound() const = 0;
};

class Dog : public Animal {
private:
    std::string breed;

public:
    Dog(const std::string& b, int a)
        : Animal("Canis lupus familiaris", a), breed(b) {
        std::cout << "Dog constructed" << std::endl;
    }

    void makeSound() const override {
        std::cout << "Woof!" << std::endl;
    }

    void display() const {
        std::cout << breed << " dog, age " << age << std::endl;
    }
};

int main() {
    Dog myDog("Labrador", 5);
    myDog.display();
    myDog.makeSound();

    return 0;
}

Explanation:

• The Dog constructor uses an initializer list to call the base class Animal constructor.
• It also initializes its own breed member.
• This demonstrates how initializer lists are used in inheritance scenarios.

Additional Considerations

1. Order of Initialization: Members are initialized in the order they are declared in the class, not the order in the initializer list.

2. Performance: Initializer lists can be more efficient than assigning values in the constructor body, especially for complex types.

3. Const and Reference Members: These must be initialized in the initializer list as they cannot be assigned to after construction.

4. Default Member Initializers: C++11 introduced default member initializers, which can be overridden in the constructor's initializer list.

5. Delegating Constructors: C++11 allows constructors to delegate to other constructors of the same class using initializer lists.

Summary

Initializer lists in C++ constructors are a powerful feature for member initialization:

1. They allow direct initialization of members before the constructor body executes.
2. Essential for initializing const members, reference members, and base classes.
3. Can improve performance compared to assignments in the constructor body.
4. Support delegating constructors and work well with inheritance.

Key points to remember:

• Use initializer lists for all member initializations when possible.
• The order of initialization follows the order of member declaration in the class, not the order in the initializer list.
• Initializer lists are the only way to initialize const and reference members.
• They can be used in conjunction with default member initializers.

Best practices:

• Always use initializer lists for const, reference members, and base class initialization.
• Prefer initializer lists over assignments in the constructor body for better performance.
• Use delegating constructors to reduce code duplication.
• Be aware of the initialization order to avoid potential bugs.

Initializer lists are a fundamental feature in C++ that contribute to writing more efficient and maintainable code, especially when dealing with complex class hierarchies and const correctness.

Related

• How does an initializer list improve the efficiency of constructor initialization
• What are the benefits of using an initializer list over assigning members within the constructor body
• Can you provide examples of when not to use an initializer list in constructors
• How does the order of initialization in an initializer list affect member variables
• Are there any performance implications of using an initializer list in large objects