C++结构体初始化列表技巧解析

优先使用初始化列表初始化成员变量，特别是const成员、引用成员、无默认构造函数的类类型成员及基类对象，以确保正确性并提升效率。

使用C++结构体初始化列表能提高代码效率，避免不必要的拷贝构造，并且对于const成员和引用成员，初始化列表是唯一的方式。它让代码更清晰，直接表明成员变量的初始化方式。

使用C++结构体初始化列表，可以更高效、更清晰地初始化类的成员变量。

什么时候应该使用初始化列表？

优先使用初始化列表。特别是对于以下情况：

• const成员变量： const修饰的成员变量必须在初始化列表中初始化，因为它们在构造函数体执行前就已经被创建，且不可修改。
• 引用成员变量： 引用也必须在初始化列表中初始化，原因与const成员类似，引用在构造函数体执行前必须绑定到某个对象。
• 没有默认构造函数的类类型成员： 如果一个类类型的成员变量没有默认构造函数，或者你希望使用一个特定的构造函数来初始化它，那么必须使用初始化列表。
• 性能考虑： 对于类类型的成员变量，在构造函数体中使用赋值操作，会先调用默认构造函数，然后再调用赋值运算符。而使用初始化列表直接调用对应的构造函数，避免了不必要的默认构造和赋值操作，提高效率。

例如：

#include 
#include 

class MyString {
public:
    std::string data;
    MyString(const std::string& str) : data(str) {
        std::cout << "MyString constructor called with: " << str << std::endl;
    }
    MyString() : data("") {
        std::cout << "MyString default constructor called" << std::endl;
    }
    MyString& operator=(const MyString& other) {
        std::cout << "MyString assignment operator called" << std::endl;
        data = other.data;
        return *this;
    }
};

struct Example {
    const int const_member;
    std::string& ref_member;
    MyString my_string;

    // 正确的初始化列表
    Example(int val, std::string& ref, const std::string& str)
        : const_member(val), ref_member(ref), my_string(str) {
        std::cout << "Example constructor called" << std::endl;
    }

    // 错误的初始化方式（在构造函数体中赋值）
    // Example(int val, std::string& ref, const std::string& str) {
    //     const_member = val; // 错误：const成员必须在初始化列表中初始化
    //     ref_member = ref;   // 错误：引用成员必须在初始化列表中初始化
    //     my_string = str;     // 虽然可以编译，但效率较低，先调用默认构造函数，再调用赋值运算符
    //     std::cout << "Example constructor called" << std::endl;
    // }
};

int main() {
    std::string external_string = "Hello";
    Example example(10, external_string, "World");

    return 0;
}

在这个例子中，const_member和ref_member必须在初始化列表中初始化。如果MyString没有默认构造函数，也必须在初始化列表中显式调用它的构造函数。如果MyString有默认构造函数，但在构造函数体中使用赋值操作，会导致先调用默认构造函数，然后再调用赋值运算符，效率较低。

初始化列表的顺序重要吗？

非常重要！ 初始化列表中成员变量的初始化顺序，取决于它们在类中声明的顺序，而不是在初始化列表中出现的顺序。 这是一个常见的陷阱。

例如：

#include 

struct Foo {
    int a;
    int b;

    Foo(int x) : b(x), a(b) { // 顺序错误！
        std::cout << "a: " << a << ", b: " << b << std::endl;
    }
};

int main() {
    Foo foo(5); // a 的值是未定义的！
    return 0;
}

在这个例子中，a在b之前声明，所以a会先于b初始化。即使在初始化列表中b出现在a之前，a仍然会使用b未初始化的值进行初始化，导致a的值是不确定的。正确的写法应该是：

Foo(int x) : a(x), b(x) { // 正确的顺序
    std::cout << "a: " << a << ", b: " << b << std::endl;
}

如何使用初始化列表初始化基类？

使用初始化列表也可以初始化基类。这对于确保基类正确初始化非常重要。

#include 

class Base {
public:
    int base_value;
    Base(int val) : base_value(val) {
        std::cout << "Base constructor called with: " << val << std::endl;
    }
};

class Derived : public Base {
public:
    int derived_value;
    Derived(int base_val, int derived_val) : Base(base_val), derived_value(derived_val) {
        std::cout << "Derived constructor called with: " << base_val << ", " << derived_val << std::endl;
    }
};

int main() {
    Derived derived(10, 20);
    std::cout << "derived.base_value: " << derived.base_value << ", derived.derived_value: " << derived.derived_value << std::endl;
    return 0;
}

在这个例子中，Derived类的构造函数使用初始化列表调用Base类的构造函数，确保基类Base在派生类Derived之前被正确初始化。 如果没有在初始化列表中调用基类的构造函数，且基类没有默认构造函数，则会编译错误。 如果基类有默认构造函数，则会先调用基类的默认构造函数，然后再执行派生类的构造函数体。 优先在初始化列表中显式调用基类的构造函数，可以提高代码效率和可读性。