C++类和对象之初始化列表的使用方式

class MyClass {
private:
    int value;
    std::string name;
    const double pi;
    int& ref;

public:
    // 使用初始化列表的构造函数
    MyClass(int val, const std::string& nm, int& r)
        : value(val), name(nm), pi(3.14159), ref(r) {
        // 构造函数体
    }
};

// 使用初始化列表（高效）
class A {
public:
    A(const std::string& str) : data(str) {} // 直接构造
private:
    std::string data;
};

// 使用赋值（低效）
class B {
public:
    B(const std::string& str) { data = str; } // 默认构造 + 赋值
private:
    std::string data;
};

class Config {
private:
    const int maxSize;      // 常量成员
    std::string& filePath;  // 引用成员

public:
    Config(int size, std::string& path) 
        : maxSize(size), filePath(path) {} // 必须在初始化列表中赋值
};

class Base {
public:
    Base(int value) { /* ... */ }
};

class Derived : public Base {
public:
    Derived(int x) : Base(x) { /* ... */ } // 调用基类构造函数
};

class Example {
private:
    int& ref;  // 引用必须初始化
public:
    Example(int& value) : ref(value) {}  // 正确：初始化列表中初始化
};

class Example {
private:
    const int value;  // const成员必须初始化
public:
    Example(int val) : value(val) {}  // 正确：初始化列表中初始化
};

class Inner {
public:
    Inner(int x) {}  // 只有带参构造函数
};

class Example {
private:
    Inner inner;  // Inner没有默认构造函数
public:
    Example(int x) : inner(x) {}  // 正确：显式调用Inner的带参构造函数
};

class Example {
private:
    int a;
    int b;

public:
    // 危险：初始化列表顺序与声明顺序不一致
    Example(int value) : b(value), a(b) {} // a先被初始化，但此时b未初始化
};

class Point {
private:
    int x;
    int y;
    int distance;

public:
    Point(int _x, int _y) 
        : x(_x), y(_y), 
          distance(calculateDistance(_x, _y)) {} // 使用函数返回值初始化

    int calculateDistance(int x, int y) const {
        return std::sqrt(x*x + y*y);
    }
};