第五节 · 亮相前的准备 · 类的构造函数

当我们创建一个对象时，它应该处于一个合理的初始状态。比如，一个 Counter 对象的计数值应该从 0 开始，一个 Person 对象应该有一个名字。

构造函数（Constructor）就是用来初始化对象的特殊成员函数。它在对象创建时自动调用，确保对象处于有效状态。

---

构造函数的基本形式

class Person
{
private:
    string name;
    int age;
    
public:
    // 构造函数：与类同名，没有返回类型
    Person()
    {
        name = "Unknown";
        age = 0;
        cout << "Person 对象被创建" << endl;
    }
};

int main()
{
    Person p;  // 自动调用构造函数
    // 输出: Person 对象被创建
    return 0;
}

构造函数的特点：

• 与类同名

• 没有返回类型（连 void 都没有）

• 在对象创建时自动调用

• 可以重载

---

带参数的构造函数

class Person
{
private:
    string name;
    int age;
    
public:
    // 默认构造函数
    Person()
    {
        name = "Unknown";
        age = 0;
    }
    
    // 带参数的构造函数
    Person(const string& n, int a)
    {
        name = n;
        age = a;
    }
    
    void introduce() const
    {
        cout << "我是 " << name << "，" << age << " 岁。" << endl;
    }
};

int main()
{
    Person p1;                    // 调用默认构造函数
    Person p2("Alice", 25);       // 调用带参数的构造函数
    Person p3{"Bob", 30};         // C++11 列表初始化
    
    p1.introduce();  // 我是 Unknown，0 岁。
    p2.introduce();  // 我是 Alice，25 岁。
    p3.introduce();  // 我是 Bob，30 岁。
    
    return 0;
}

---

初始化列表

初始化成员变量的更好方式是使用初始化列表：

class Person
{
private:
    string name;
    int age;
    
public:
    // 使用初始化列表
    Person(const string& n, int a) : name(n), age(a)
    {
        // 构造函数体可以为空，或包含其他初始化逻辑
    }
};

初始化列表的优势：

• 效率更高（直接初始化，而不是先默认初始化再赋值）

• 某些成员必须用初始化列表初始化：

  • const 成员

  • 引用成员

  • 没有默认构造函数的类类型成员

class Example
{
private:
    const int id;              // const 成员
    int& ref;                  // 引用成员
    string name;
    
public:
    // 必须使用初始化列表
    Example(int i, int& r, const string& n)
        : id(i), ref(r), name(n)
    {
        // id = i;   // 错误！const 不能赋值
        // ref = r;  // 错误！引用不能重新绑定
    }
};

---

默认构造函数

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

class Simple
{
public:
    int value;  // 未初始化的成员
    // 编译器自动生成默认构造函数
};

Simple s;  // value 的值是未定义的

但如果你定义了任何构造函数，编译器就不会自动生成默认构造函数：

class Person
{
public:
    string name;
    
    Person(const string& n) : name(n) {}
    // 没有默认构造函数
};

Person p;  // 错误！没有默认构造函数
Person p("Alice");  // OK

可以使用 = default 让编译器生成默认构造函数：

class Person
{
public:
    string name;
    
    Person() = default;  // 显式要求编译器生成默认构造函数
    Person(const string& n) : name(n) {}
};

Person p;  // OK

---

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

一个构造函数可以调用同类的另一个构造函数：

class Person
{
private:
    string name;
    int age;
    string address;
    
public:
    // 主构造函数
    Person(const string& n, int a, const string& addr)
        : name(n), age(a), address(addr)
    {
    }
    
    // 委托给主构造函数
    Person(const string& n, int a)
        : Person(n, a, "Unknown")
    {
    }
    
    // 委托构造
    Person()
        : Person("Unknown", 0, "Unknown")
    {
    }
};

---

拷贝构造函数

拷贝构造函数用于创建一个对象的副本：

class Person
{
private:
    string name;
    int age;
    
public:
    Person(const string& n, int a) : name(n), age(a) {}
    
    // 拷贝构造函数
    Person(const Person& other) : name(other.name), age(other.age)
    {
        cout << "拷贝构造函数被调用" << endl;
    }
};

int main()
{
    Person p1("Alice", 25);
    Person p2 = p1;       // 调用拷贝构造函数
    Person p3(p1);        // 调用拷贝构造函数
    
    return 0;
}

如果不定义，编译器会自动生成一个执行浅拷贝的拷贝构造函数。

---

析构函数

与构造函数相对的是析构函数（Destructor），它在对象销毁时自动调用：

class Resource
{
private:
    int* data;
    
public:
    Resource(int size)
    {
        data = new int[size];
        cout << "资源已分配" << endl;
    }
    
    // 析构函数：~类名
    ~Resource()
    {
        delete[] data;
        cout << "资源已释放" << endl;
    }
};

int main()
{
    {
        Resource r(100);  // 资源已分配
    }  // r 在这里被销毁，输出: 资源已释放
    
    return 0;
}

析构函数的特点：

• 名字是 ~ 加类名

• 没有参数，没有返回类型

• 每个类只能有一个析构函数

• 不能重载

---

禁止拷贝

有时我们不希望对象被拷贝，可以删除拷贝构造函数和拷贝赋值运算符：

class NonCopyable
{
public:
    NonCopyable() = default;
    
    // 禁止拷贝
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
};

int main()
{
    NonCopyable a;
    // NonCopyable b = a;  // 错误！拷贝构造被删除
    // NonCopyable c;
    // c = a;              // 错误！拷贝赋值被删除
    return 0;
}

---

完整示例：银行账户

#include <iostream>
#include <string>
using namespace std;

class BankAccount
{
private:
    string owner;
    double balance;
    static int nextAccountNumber;
    int accountNumber;
    
public:
    // 构造函数
    BankAccount(const string& name, double initialBalance = 0)
        : owner(name), balance(initialBalance)
    {
        accountNumber = ++nextAccountNumber;
        cout << "账户 " << accountNumber << " 已创建" << endl;
    }
    
    // 析构函数
    ~BankAccount()
    {
        cout << "账户 " << accountNumber << " 已关闭" << endl;
    }
    
    void deposit(double amount)
    {
        if (amount > 0)
            balance += amount;
    }
    
    bool withdraw(double amount)
    {
        if (amount > 0 && amount <= balance)
        {
            balance -= amount;
            return true;
        }
        return false;
    }
    
    void printInfo() const
    {
        cout << "账户 " << accountNumber << " - "
             << owner << ": $" << balance << endl;
    }
};

int BankAccount::nextAccountNumber = 0;

int main()
{
    BankAccount acc1("Alice", 1000);
    BankAccount acc2("Bob");
    
    acc1.deposit(500);
    acc1.withdraw(200);
    
    acc1.printInfo();  // 账户 1 - Alice: $1300
    acc2.printInfo();  // 账户 2 - Bob: $0
    
    return 0;
}
// 程序结束时，析构函数按创建的逆序调用

---

构造函数和析构函数是类的生命周期管理的核心。正确使用它们，可以确保资源的正确分配和释放，避免内存泄漏等问题。

习题

• 为 Rectangle 类编写构造函数，支持无参构造（默认 1x1）和带参构造。

• 设计一个 Array 类，在构造函数中动态分配数组，在析构函数中释放。

• 实现一个 Logger 类，在构造时打开日志文件，在析构时关闭。