类

是什么，为什么存在

C++ 的类（class）是用户定义类型。类定义列出数据成员、成员函数、嵌套类型和访问规则；对象（object）则是该类型在运行时的一个实例。每个对象各有自己的非静态数据成员，并通过同一组成员函数提供的接口工作。

类把一个概念的表示和合法操作放在一起。例如，恒温器对象可以保存当前温度，同时只允许调用者设置设备支持的范围。这样，调用者不必记住每次写入前都重复验证，类型本身负责维护规则。

对象在所有可观察操作之间都应满足的规则称为 类不变量（class invariant） 。构造函数先建立它，公开成员函数在修改状态后继续保持它。private 不能自动保证正确性，但它能减少绕过这些检查的入口。

你会在值对象、配置、资源句柄、容器和服务接口中遇到类。类并不等于继承层次，也不要求使用虚函数。很多好用的 C++ 类只包含几个值类型成员和一小组直接操作。

工作原理

类定义引入一个类型名，并在花括号中声明成员。以对象表达式调用非静态成员函数时，函数会操作那个对象；在函数体中，this 指向当前对象。通常直接写 width_，等价于通过当前对象访问 this->width_。

访问说明符（access specifier） 控制名称可从哪里使用。public 成员构成调用者可见的接口，private 成员只允许该类的成员与友元访问，protected 还向派生类开放。访问控制在编译期检查，它不改变对象是否占有某段内存。

class 中没有显式说明的成员默认是 private。同样的定义若使用 struct，默认则是 public。除此之外，两者都能拥有构造函数、成员函数、模板、基类和访问说明符。

构造函数负责创建可用对象。它没有返回类型，而且其名称由类类型决定。创建对象时，编译器根据实参选择可用构造函数，然后先初始化基类和成员，最后才进入构造函数体。

成员初始化器列表（member initializer list） 写在构造函数参数列表与函数体之间。它是初始化成员的地方，不是简写的赋值语句。引用成员、const 成员，以及没有默认构造函数的成员都必须在进入函数体前得到合适的初始化。

非静态数据成员按照类定义中的声明顺序初始化，而不是按照初始化器列表的书写顺序。让初始化器列表采用同一顺序，可以让依赖关系一眼可见，也能避免读到尚未初始化的成员。析构时，这些成员按相反顺序销毁。

成员函数末尾的 const 限定当前对象。例如，double area() const 可以在 const Rectangle 上调用，并且不能通过普通成员访问修改对象的数据。只读取状态的观察函数通常都应带有这个限定。

一次普通对象创建经历以下步骤：

1. 编译器根据对象定义和实参选择构造函数。
2. 虚基类与直接基类先按语言规定的顺序初始化。
3. 非静态数据成员按声明顺序初始化。
4. 构造函数体执行，处理需要多个已初始化成员参与的检查或工作。
5. 对象在作用域内通过公开接口使用。
6. 生命周期结束时，析构函数体先执行，成员和基类随后按构造的逆序销毁。

这套顺序让成员对象自行管理生命周期。把 std::string、std::vector 或智能指针作为成员时，外层对象通常无需手写释放代码。编译器生成的操作会组合这些成员已有的行为。

示例

下面四个程序逐步加入访问控制、验证、复制行为和生命周期跟踪。它们都以 C++23 模式用本地 g++ 编译并执行，输出来自实际运行。

一个最小的值类型

Rectangle 把表示放在 private 区域，只公开计算面积和缩放操作。调用者可以改变尺寸，但不能直接让其中一个成员绕过类接口单独变化。

花括号中的 4.0 与 2.5 选择双参数构造函数。两个成员在构造函数体执行前由初始化器列表写入。area() 带有 const，因为计算面积不需要改变对象。

这个小例子尚未拒绝负尺寸。如果领域规则要求尺寸为正，构造函数和 scale() 都必须验证输入。仅仅把数据设为 private 不会凭空建立这条规则。

在构造时建立不变量

Thermostat 只接受 5 到 30 摄氏度。默认构造函数委托给接收温度的构造函数，因此两个创建入口共享同一份验证逻辑。

#include <iostream>
#include <stdexcept>

class Thermostat {
public:
    Thermostat() : Thermostat(20) {}

    explicit Thermostat(int celsius) : celsius_(celsius) {
        validate(celsius_);
    }

    void set_temperature(int celsius) {
        validate(celsius);
        celsius_ = celsius;
    }

    [[nodiscard]] int temperature() const { return celsius_; }

private:
    static void validate(int celsius) {
        if (celsius < 5 || celsius > 30) {
            throw std::out_of_range{"temperature must be 5..30"};
        }
    }

    int celsius_;
};

int main() {
    Thermostat office;
    Thermostat lab{18};
    office.set_temperature(22);
    std::cout << "office: " << office.temperature() << '\n';
    std::cout << "lab: " << lab.temperature() << '\n';

    try {
        lab.set_temperature(2);
    } catch (const std::out_of_range& error) {
        std::cout << "rejected: " << error.what() << '\n';
    }
}

office: 22
lab: 18
rejected: temperature must be 5..30

单参数构造函数使用 explicit，所以整数不会在函数调用中悄悄转换成 Thermostat。直接初始化 Thermostat lab{18} 仍然有效。explicit 禁止的是隐式转换，不是正常的显式构造。

validate() 不依赖具体对象，因此声明为 static 私有成员。创建和修改都通过它检查同一范围。非法修改先抛出异常，原来的温度不会改变。

让成员组合出值语义

ReadingLog 使用 std::string 和 std::vector 保存所有状态。类没有直接管理裸资源，因此不声明析构、复制或移动操作。

#include <iostream>
#include <string>
#include <utility>
#include <vector>

class ReadingLog {
public:
    explicit ReadingLog(std::string owner)
        : owner_(std::move(owner)) {}

    void add(std::string title) {
        titles_.push_back(std::move(title));
    }

    [[nodiscard]] const std::string& owner() const { return owner_; }
    [[nodiscard]] std::size_t size() const { return titles_.size(); }

private:
    std::string owner_;
    std::vector<std::string> titles_;
};

int main() {
    ReadingLog original{"Mina"};
    original.add("The Left Hand of Darkness");

    ReadingLog copy = original;
    copy.add("Kindred");

    std::cout << original.owner() << ": " << original.size() << '\n';
    std::cout << copy.owner() << ": " << copy.size() << '\n';
}

Mina: 1
Mina: 2

编译器生成的复制构造函数逐个复制成员。std::vector 的复制拥有独立元素存储，所以向 copy 添加书名不会改变 original。这种由成员组合行为的设计通常称为零法则。

owner() 返回 const 引用，避免每次观察时复制字符串，同时阻止调用者通过该接口修改名称。返回引用也带来生命周期约束：引用只在对应 ReadingLog 对象及其 owner_ 成员仍然存活时有效。

观察成员的构造与析构顺序

Report 由两个 Trace 成员组成。输出直接展示声明顺序如何决定构造顺序，以及析构如何反向进行。

#include <iostream>
#include <string>
#include <utility>

class Trace {
public:
    explicit Trace(std::string name) : name_(std::move(name)) {
        std::cout << "construct " << name_ << '\n';
    }

    ~Trace() {
        std::cout << "destroy " << name_ << '\n';
    }

private:
    std::string name_;
};

class Report {
public:
    Report() : header_{"header"}, body_{"body"} {
        std::cout << "report ready\n";
    }

    ~Report() {
        std::cout << "report done\n";
    }

private:
    Trace header_;
    Trace body_;
};

int main() {
    Report report;
    std::cout << "using report\n";
}

construct header
construct body
report ready
using report
report done
destroy body
destroy header

header_ 在 body_ 之前声明，所以它先构造。离开 main() 时，Report 的析构函数体先运行，随后 body_ 与 header_ 依次销毁。成员对象的析构函数不需要由 Report 手工调用。

这个跟踪类型为了教学而输出生命周期事件。生产类通常不在析构函数中写日志，因为输出可能抛错、争用锁或发生在日志系统已经关闭之后；真正应依赖的是语言规定的顺序。

陷阱

公开表示破坏不变量

修复： 按领域操作设计接口，例如一次设置整个范围，并在提交状态前检查参数。没有需要保护的关系时，公开数据的简单 struct 反而更诚实，不必强行写一圈 getter 和 setter。

初始化器列表不能重排成员

修复： 先声明被依赖的成员，再声明依赖它的成员，并让初始化器列表保持同样顺序。启用编译器警告，-Wall -Wextra 通常能指出列表顺序与声明顺序不一致。

在构造函数体内赋值

修复： 用成员初始化器列表建立成员的初始值。函数体留给必须等多个成员都初始化后才能执行的验证或副作用，并尽量在产生外部副作用前完成可能失败的检查。

意外的隐式转换

修复： 除非转换本身就是接口设计的一部分，否则把这类构造函数声明为 explicit。在调用点使用花括号直接构造，明确表示要创建该类型。

裸拥有指针被逐成员复制

修复： 优先用 std::vector、std::string 或智能指针表达所有权，并遵循零法则。确实需要自定义资源所有者时，要整体设计复制、移动与析构，相关细节见 cpp/raii、cpp/smart-pointers 和 cpp/move-semantics。

观察函数缺少 const

修复： 对不修改逻辑状态的观察函数加 const，并用 const 引用编译调用测试。缓存等实现细节若确实需要在观察函数中变化，要谨慎使用 mutable，不能借它绕过公开的不变量。

延伸阅读

• C++ 工作草案：类
• C++ 工作草案：构造函数
• C++ 工作草案：成员访问控制
• cppreference：类