C++构造函数与初始化全面指南：从基础到高级实践

C++构造函数与初始化全面指南：从基础到高级实践

1. 构造函数基础概念

构造函数是C++中一种特殊的成员函数，它在创建类对象时自动调用，用于初始化对象的数据成员。构造函数的核心特点包括：

• 与类同名
• 无返回类型（连void都没有）
• 可以重载（一个类可以有多个构造函数）
• 通常声明为public（除非有特殊需求）

1.1 默认构造函数

默认构造函数是不需要任何参数的构造函数。如果用户没有定义任何构造函数，编译器会自动生成一个默认构造函数。

class MyClass {
public:
    MyClass() { // 默认构造函数
        std::cout << "默认构造函数被调用" << std::endl;
    }
};

// 使用
MyClass obj; // 调用默认构造函数

2. 构造函数初始化方式

2.1 赋值初始化（传统方式）

class Point {
    int x;
    int y;
public:
    Point(int a, int b) {
        x = a; // 赋值初始化
        y = b; // 赋值初始化
    }
};

2.2 初始化列表（推荐方式）

C++更推荐使用成员初始化列表，它在构造函数体执行前完成初始化，效率更高。对于const成员和引用成员，初始化列表是必须使用的唯一方式。

为什么const成员和引用成员必须使用初始化列表？

1. const成员的不可变性：

   • const成员一旦被初始化后，其值不可再修改
   • 如果允许在构造函数体内赋值，这实际上是对const成员的二次赋值（编译器会先默认初始化，再尝试赋值），违反了const语义

2. 引用成员的本质：

   • 引用是别名，必须在创建时绑定到一个已存在的对象
   • 引用一旦绑定后，无法再指向其他对象
   • 在构造函数体内"初始化"引用会导致引用在声明时未绑定（非法）

class ConstRefDemo {
    const int constValue;  // const成员
    int& refValue;         // 引用成员
    int normalValue;       // 普通成员
public:
    // const和引用成员必须使用初始化列表
    ConstRefDemo(int cv, int& rv) : constValue(cv), refValue(rv) {
        normalValue = 0;  // 普通成员可以在构造函数体内赋值
    }
    
    // 错误示例：
    /*
    ConstRefDemo(int cv, int& rv) {
        constValue = cv;  // 错误！const成员不能在构造函数体内赋值
        refValue = rv;    // 错误！引用必须在定义时绑定
        normalValue = 0;
    }
    */
};

初始化列表的优势：

1. 对于const成员和引用成员，必须使用初始化列表
2. 对于类类型成员，避免先默认构造再赋值
3. 初始化顺序更明确（按成员声明顺序而非列表顺序）
4. 效率更高，直接初始化而非先默认构造再赋值

3. 特殊构造函数

3.1 拷贝构造函数

拷贝构造函数用于用一个已存在的对象初始化新对象。

class MyString {
    char* data;
public:
    MyString(const MyString& other) { // 拷贝构造函数
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }
};

3.2 移动构造函数（C++11）

移动构造函数用于"窃取"临时对象的资源，避免不必要的拷贝。

class MyString {
    char* data;
public:
    MyString(MyString&& other) noexcept : data(other.data) { // 移动构造函数
        other.data = nullptr; // 使原对象处于有效但未定义状态
    }
};

4. 委托构造函数（C++11）

一个构造函数可以调用同类的另一个构造函数，避免代码重复。

class Rectangle {
    int width, height;
public:
    Rectangle() : Rectangle(1, 1) {} // 委托给下面的构造函数
    Rectangle(int w, int h) : width(w), height(h) {}
};

5. 初始化顺序问题

成员的初始化顺序取决于它们在类中的声明顺序，而非初始化列表中的顺序。这对const成员和引用成员尤其重要，因为它们必须正确初始化。

class Example {
    int a;
    const int b;  // const成员
    int& c;       // 引用成员
public:
    Example(int val) : c(a), b(val), a(10) {} 
    // 实际初始化顺序：a(10) → b(val) → c(a)
    // 注意：虽然初始化列表中c写在前面，但实际按声明顺序初始化
};

6. 特殊成员的初始化

6.1 const成员初始化

const成员必须在初始化列表中初始化。

class ConstDemo {
    const int value;
public:
    ConstDemo(int v) : value(v) {} // 必须这样初始化
    
    // 错误示例：
    /*
    ConstDemo(int v) {
        value = v; // 错误！const成员不能在构造函数体内赋值
    }
    */
};

6.2 引用成员初始化

引用成员也必须在初始化列表中初始化。

class RefDemo {
    int& ref;
public:
    RefDemo(int& r) : ref(r) {} // 必须这样初始化
    
    // 错误示例：
    /*
    RefDemo(int& r) {
        ref = r; // 错误！引用必须在定义时绑定
    }
    */
};

7. 默认构造函数与=default

C++11允许显式要求编译器生成默认实现：

class DefaultDemo {
    const int value = 42; // C++11允许类内初始化const成员
    std::string& ref;     // 引用仍然必须在构造函数中初始化
public:
    DefaultDemo(std::string& s) : ref(s) {} // 引用必须在这里初始化
    DefaultDemo() = delete; // 禁止默认构造（因为引用必须初始化）
};

8. 构造函数实战建议

1. 优先使用初始化列表：特别是对于类类型成员、const成员和引用成员
2. 注意初始化顺序：按照成员声明顺序编写初始化列表
3. const和引用成员的特殊处理：它们必须在初始化列表中初始化
4. 合理使用explicit：防止单参数构造函数的隐式转换
5. 考虑=default和=delete：明确表达设计意图
6. 移动语义：对于资源管理类，实现移动构造和移动赋值

9. 完整示例代码（包含const和引用成员）

#include <iostream>
#include <string>

class Student {
private:
    const std::string name;  // const成员
    int& ageRef;             // 引用成员
    const int id;            // const成员
    double scores[3];
    
public:
    // 委托构造函数
    Student(std::string n, int& age, int i) 
        : name(std::move(n)), ageRef(age), id(i) { // const和引用成员必须在此初始化
        for (double & score : scores) {
            score = 0.0;
        }
    }
    
    // 不能有默认构造函数，因为引用成员必须初始化
    // Student() = delete; 

    void printInfo() const {
        std::cout << "Name: " << name << "\nID: " << id 
                  << "\nAge: " << ageRef << "\nScores: ";
        for (double score : scores) {
            std::cout << score << " ";
        }
        std::cout << std::endl;
    }
    
    // 不能修改const成员
    // void setName(const std::string& newName) { name = newName; } // 错误！
    
    // 可以通过引用成员修改原变量
    void incrementAge() { ageRef++; }
};

int main() {
    int age = 20;
    Student s1("Alice", age, 1001);
    s1.printInfo();
    
    age = 21;  // 修改age会影响s1中的ageRef
    s1.incrementAge(); // 通过引用成员修改原变量
    s1.printInfo();
    
    return 0;
}

10. 关键总结

1. const成员和引用成员必须在初始化列表中初始化，这是语言强制要求的
2. 初始化列表提供了真正的初始化能力，而构造函数体内只是赋值
3. 这种设计保证了对象构造时的确定性和安全性
4. 现代C++实践中，应该优先使用初始化列表，不仅是为了满足语法要求，更是为了编写更高效、更安全的代码

理解并正确使用构造函数，特别是对const成员和引用成员的正确初始化，是C++面向对象编程的重要基础。这些规则反映了C++对确定性和效率的核心追求。