c++ 类的构造函数与析构函数

1.构造函数

类的构造函数是类的一种特殊的成员函数,它会在每次创建类的新对象时自动执行。 构造函数的名称与类的名称完全相同 且没有返回类型(连 void 也不能有)。构造函数通常用于为成员变量设置初始值。

示例代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
#include <iostream>
using namespace std;

class Line {
public:
    Line();
    void setLength(double len);
    double getLength() const;
private:
    double length;
};

// 类外定义,类内声明
Line::Line() {
    cout << "Object is being created" << endl;
    length = 0.0; // 显式初始化成员变量
}

当然,构造函数也可以传参。

2.析构函数

与构造函数对应,该函数为类的作用周期结束时自动执行的语句。 析构函数为~+类名称

(ai添加)3. 默认构造函数与初始化语法

基础概念

默认构造函数是能够以零个实参调用的构造函数。它既可以没有参数,也可以为全部参数提供默认值。构造函数的职责是让新对象进入有效状态,不只是随意给几个变量赋值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Counter {
    int value_;
public:
    Counter(int value = 0) : value_(value) {}
};

Counter a;       // 使用默认值 0
Counter b(10);   // 使用 10
Counter c{};     // 使用默认值 0
Counter d();     // 声明函数 d:无参数,返回 Counter,不创建对象

不要同时提供 Counter() 和所有参数均有默认值的 Counter(int value = 0),否则零实参调用会产生歧义。默认实参通常写在类内声明处,类外定义不再重复。

初始化与赋值

1
2
3
4
Counter a(10);
Counter b = a;   // 初始化新对象 b:拷贝构造
Counter c(a);    // 初始化新对象 c:拷贝构造
b = a;          // b 已存在:拷贝赋值

Counter x = 10; 也是初始化,不是先构造再赋值;在上述构造函数没有声明为 explicit 时,可以通过它进行这种转换。给单参数构造函数加上 explicit 可以限制这种隐式转换,此时仍可写 Counter x{10};。

注意事项

  • 没有用户声明的构造函数时,编译器会隐式声明默认构造函数;但成员无法默认构造等原因可能使它被定义为删除。
  • 一旦声明了其他构造函数,编译器不会再自动提供无参构造函数。需要时可以显式写 Counter() = default;,但要保证成员能正确初始化。
  • 不要认为默认构造一定会把内置类型成员清零。可以使用 int value_ = 0; 等类内初始值明确表达初始状态。
  • Counter() = delete; 可以禁止默认构造,使调用者必须提供必要信息。
  • std::vector<T> v(10); 需要创建 10 个元素;std::vector<T> v; 不创建元素,两者对默认构造的要求不同。

(ai添加)4. 成员初始化列表

基础概念与使用方法

构造函数执行时,先初始化成员,再执行函数体。初始化列表位于参数列表后的冒号与函数体之间,用来指定成员的初始值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
#include <string>

class Student {
    std::string name_;
    const int id_;
    int& count_;
public:
    Student(const std::string& name, int id, int& count)
        : name_(name), id_(id), count_(count) {
        ++count_;  // 执行函数体时,各成员已初始化
    }
};

这里 name_ 直接用 name 构造;id_ 获得固定初值;count_ 绑定到外部变量。引用所绑定的外部对象必须活得足够久,避免悬空引用。

如果写成函数体中的 name_ = name;,字符串会先默认构造,再赋值。引用成员、需要指定初值的 const 成员,以及没有默认构造函数的成员对象,都不能靠函数体赋值替代初始化。某些成员也可以通过类内初始值完成初始化;初始化列表中显式提供的值优先于类内初始值。

原文示例中 length = 0.0; 应理解为构造函数体内的赋值;要直接初始化,可以写 Line::Line() : length(0.0) {}。

初始化顺序

成员实际按照在类中的声明顺序初始化,与初始化列表的书写顺序无关。

1
2
3
4
5
6
7
8
9
#include <vector>
#include <cstddef>

class Buffer {
    std::size_t size_;       // 先初始化
    std::vector<int> data_;  // 后初始化,可以使用 size_
public:
    explicit Buffer(std::size_t n) : size_(n), data_(size_) {}
};

如果把 data_ 声明在 size_ 前面,却用 size_ 初始化它,就会读取尚未完成初始化的成员。把依赖项声明在前面,并让初始化列表与声明顺序一致。

(ai添加)5. 析构函数与资源管理

析构函数写成 ~类名(),没有返回类型、没有参数。局部对象正常离开作用域或因异常进行栈展开时,会自动析构;new 创建的对象通常在对应的 delete 时析构。

默认析构函数会销毁成员对象,但销毁裸指针本身,不会自动释放指针指向的动态内存。

1
2
3
4
5
6
7
8
9
class Buffer {
    double* data_;
public:
    explicit Buffer(int n) : data_(new double[n]{}) {} // 假设 n 合法
    ~Buffer() { delete[] data_; }

    Buffer(const Buffer&) = delete;
    Buffer& operator=(const Buffer&) = delete;
};

这里用删除的拷贝操作禁止复制,避免默认复制只复制地址,导致多个对象重复释放同一数组。new[] 对应 delete[],单对象的 new 对应 delete,不能混用。

实际编程优先使用 std::vector<double> 等资源管理类型作为成员,它们会自动释放资源,并提供合适的复制行为。让资源跟随对象生命周期取得和释放的做法称为 RAII(资源获取即初始化)。

注意:一个类如果自己管理资源,不能只考虑析构,还应考虑复制时资源归谁、是否允许共享、是否需要复制内容。不要把“有析构函数”当成资源管理已经完整。

(ai添加)6. 拷贝构造与资源复制

已有笔记区分了初始化与赋值,也说明了裸资源复制的风险。完整的逐成员复制、浅拷贝与深拷贝、拷贝构造实现及三法则、零法则,见 对象复制:拷贝构造与拷贝赋值。拷贝构造是独立的构造过程,不会先执行默认构造函数体。

使用 Hugo 构建
主题 Stack 由 Jimmy 设计