类

直觉：你的代码需要一张「零件图纸」

到目前为止，你一直在用 C++ 内置的类型——int、double、string、vector。但真实世界的软件里，数据从来不是孤立的——一本书有书名、销量和单价，一个学生有姓名、学号和成绩。这些数据天然应该捆在一起。

想象一个零件加工厂：你不会每次都手画一张新图纸从头切一块铝——你会先画一张「标准零件图纸」：标好尺寸、材料、公差。之后想要这个零件？对着图纸开工就行。C++ 里你要做的就是这样一张数据图纸——先画清楚这种东西长什么样（有哪些数据、能做哪些操作），之后照着这张图就能造出一个个具体的成品。

不这么做，描述一本书就得用三个零散变量 string bookNo; unsigned sold; double revenue;，每个操作都要手动一个个传进去，参数越列越长。本章教你画第一张自己的零件图——这是从「照着现成的零件图开工」迈向「自己动手画零件图」的关口。

类是什么：一张图纸 + 工厂

类（class）——蓝图，规定了这种类型里有什么数据、能做什么操作。用这张蓝图造出来的每一个实例叫做对象。

看上面的内存布局图——一个对象在内存中只是一块连续的数据区域。成员函数不占对象空间——它们的代码在另一块区域，所有同类的对象共享。

那么成员函数怎么知道它在操作哪一个对象？秘密藏在 this 指针 里——每个非静态成员函数都有一个隐藏的 this 形参：可以把 item.isbn() 在概念上理解为把 &item 交给 isbn，函数内部再通过 this->bookNo 访问数据成员；这不是可直接调用的真实函数签名。

成员函数（member function） 定义在类内部或外部——在外部定义时用 类名::函数名：

// 在类外部定义成员函数——用 Sales_data:: 标明它属于哪个类
double Sales_data::avg_price() const {
    if (units_sold)                    // units_sold 其实是 this->units_sold
        return revenue / units_sold;
    else
        return 0;
}

struct vs class——你可能会问：之前用过 struct，和 class 有什么区别？唯一的区别是默认访问权限：struct 默认 public，class 默认 private。除此之外完全一样——struct 也能有构造函数和成员函数。惯例：纯数据聚合用 struct，需要封装行为的用 class。

访问控制：谁可以碰我的数据？

上一节看到数据存在对象里——那外部代码能不能直接读写这些数据？如果能，调用方就可能绕过你的规则乱改——比如把收入设成负数。C++ 用 访问控制（access control） 解决这个问题。

看上面的分界线图。public: 下面的成员是类的接口——外部调用方可以随意使用。private: 下面的成员是类的实现细节——外部代码碰不到，直接编译报错。

封装（encapsulation）的设计意图：外部只能通过 public 函数间接操作数据，类作者可在函数内部加校验——比如检查 ISBN 是否匹配。改了内部实现（比如换一种存储方式），只要 public 接口不变，调用方一行代码不用改。

一个完整的类骨架：

class Sales_data {
public:   // ← 从这里往下都是公开接口
    std::string isbn() const { return bookNo; }
    Sales_data& combine(const Sales_data&);
    double avg_price() const;
 
private:  // ← 从这里往下都是隐藏实现
    std::string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
};

构造函数：对象诞生的那一刻

定义了一个 Sales_data 变量之后，它的数据成员分别是什么值？谁来初始化它们？答案藏在 构造函数（constructor） 里。

成员初始化列表（member initializer list） 写在参数列表右括号后、函数体左花括号前：

Sales_data(const std::string &s, unsigned n, double p)
    : bookNo(s), units_sold(n), revenue(p) { }
//  ↑ 成员初始化列表（在构造体之前执行）

看上面的构造链图——构造分两阶段：先跑成员初始化列表（各数据成员按声明顺序初始化），再跑构造体。进入 {} 时成员已经初始化好了。

合成默认构造函数——如果你一个构造函数都没写，编译器自动生成一个。但内置类型成员（如 unsigned、double）的初始值未定义。

关键规则：一旦你写了任何一个构造函数，编译器就不再生成默认构造函数：

Sales_data(const std::string &s) : bookNo(s) {}
// 只定义了这一个构造函数
Sales_data item;  // ✗ 编译错误！没有默认构造函数

修法：手动加默认构造函数——Sales_data() = default; 或给全部参数提供默认值：

Sales_data(const std::string &s = "") : bookNo(s) {}
// 有了默认实参，这一个构造函数同时充当默认和带参两种角色

const 成员函数：承诺「我不改这个对象」

有时候你有一个 const 对象——只想读数据、不想改。但编译器怎么知道某个成员函数会不会偷偷改数据？答案：const 成员函数——在参数列表后面加一个 const：

std::string isbn() const { return bookNo; }
//                     ↑ 这个 const——承诺不改 *this

看上面的对比图——非 const 对象什么函数都能调；const 对象只能调标了 const 的函数，没标的被编译拒绝。

const 成员函数的底层机制：把 this 从 T* 变成 const T*——不能通过这个指针修改对象。设计原则：只读的成员函数一律标 const。这既是给编译器的承诺，也是给读代码的人一个信号。

友元：给特定函数开后门

private 成员外部不能访问——但有些函数确实需要碰 private 数据才算合理。比如把对象输出到屏幕的 print 函数——如果它只能通过 isbn()、avg_price() 等公开接口间接凑信息，写出来啰嗦又低效。

友元（friend）——在类内部用 friend 声明外部函数，授权访问 private：

class Sales_data {
    // 友元声明——print/read/add 不是成员函数，但可以碰 private 数据
    friend std::ostream& print(std::ostream&, const Sales_data&);
    friend std::istream& read(std::istream&, Sales_data&);
    friend Sales_data add(const Sales_data&, const Sales_data&);
public:
    // ... public 成员
private:
    std::string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
};
 
// print 是普通函数，但因为 friend 声明可以直接访问 private 成员
std::ostream& print(std::ostream &os, const Sales_data &item) {
    os << item.isbn() << " " << item.units_sold << " "  // 直接读 units_sold
       << item.revenue << " " << item.avg_price();      // 直接读 revenue
    return os;
}

友元不是类的成员——声明在 public 区还是 private 区都一样。友元不具有传递性：A 是 B 的友元、B 是 C 的友元，不意味着 A 能访问 C 的 private。使用原则：只在操作符重载（<<、>>）和紧密关联的非成员函数（如上面的 print/read/add）中用友元——不要为了省事乱开 friend。

官方 Chapter 7 的完整类契约

前面的 Sales_data 已经说明了如何定义类，但原书这一章还要回答更深的问题：一个类怎样形成抽象数据类型，名字在类内怎样查找，构造函数怎样委托与控制转换，以及哪些状态属于整个类型而不是单个对象。

抽象数据类型（abstract data type） 的重点不是把变量装进 class，而是建立稳定接口和表示不变量。以 Sales_data 为例，调用者只看见 isbn、combine、read 和 print；bookNo、units_sold、revenue 如何存储由类自己负责。combine 还应检查 ISBN 是否一致，这种约束不该散落在每个调用点。

类作用域、类成员与不完整类型

类作用域（class scope） 使同名的类成员归属于类型。类外定义成员函数时，函数名后的形参列表和函数体已经处于类作用域；但返回类型写在限定名之前，所以类内类型通常还要显式限定：

class Screen {
public:
    using pos = std::string::size_type;
    pos size() const;
};
 
Screen::pos Screen::size() const { return contents.size(); }
// 返回类型在 Screen::size 之前，因此写成 Screen::pos

名字查找还受声明位置影响：类型名通常要先声明再使用；成员函数体则在整个类定义处理完后再解析成员名。只有前向声明的类是不完整类型，可以声明其指针或引用，却不能创建对象、访问成员或用 sizeof 求大小。类可包含指向自身的指针，却不能直接包含自身对象，否则大小无法确定。

构造委托、类类型转换与特殊类

委托构造函数（delegating constructor） 用初始化列表选择目标构造函数，目标构造完整执行后才回到委托者的函数体：

class Sales_data {
public:
    Sales_data(std::string s, unsigned n, double p)
        : bookNo(std::move(s)), units_sold(n), revenue(n * p) {}
    Sales_data() : Sales_data("", 0, 0.0) {}
    explicit Sales_data(std::string s) : Sales_data(std::move(s), 0, 0.0) {}
};

可用一个实参调用的构造函数同时定义从实参类型到类类型的转换。explicit 会禁止这种隐式转换，但仍允许直接初始化：Sales_data direct("isbn") 合法；若已有 std::string id = "isbn"，则 Sales_data copy = id 被拒绝。这里不用字符串字面量直接做拷贝初始化示例，因为从字面量到 std::string、再到 Sales_data 会要求连续两次用户定义转换，本来就不合法。explicit 只用于构造函数和转换运算符的声明，不能写在类外定义处。

聚合类（aggregate class） 适合简单数据记录；它没有封装边界，成员次序成为调用契约。更高语言版本调整过聚合判定条件，阅读现代代码时应按项目标准版本核对。字面值常量类（literal class） 则服务于编译期计算。二者用途不同，不应把所有业务类都做成聚合。

静态类成员：状态属于类型

静态类成员（static class member） 适合保存类型级配置或计数：

class Account {
public:
    static double rate() { return interestRate; }
    static void rate(double value) { interestRate = value; }
private:
    static double interestRate; // 类内声明
};
 
double Account::interestRate = 0.03; // 一个定义，分配存储
auto r = Account::rate();             // 不需要 Account 对象

静态成员函数没有 this，因此不能标 const，也不能直接读取某个对象的非静态数据。C++11 中普通静态数据成员通常仍需在类外提供一次定义；constexpr 静态成员的规则还取决于是否被取地址以及所用语言版本。

动手：一步步看一个对象是怎么构造出来的

构造一个对象分五个阶段：分析类定义 → 分配内存 → 成员初始化列表 → 构造体执行 → 构造完成。每一步下面用 ConstructorCallDiagram 高亮对应阶段——图上高亮哪一步，正文就在讲哪一步。

猜一猜：定义 Sales_data item; 之后立刻用 cout << item.avg_price()——会输出什么？如果类内部没写任何构造函数，编译器生成的默认构造会把 revenue 初始化成什么？通过下面 Stepper 一步步看。

代码逐段拆解：从零设计并实现一个完整的类

把本章类的定义、构造函数、const 成员函数、访问控制、友元串在一起——设计一个 Sales_data 类，实现所有关键成员。每段一个主题，读完你就能自己写类。

类定义骨架：public 接口 + private 数据

#include <iostream>
#include <string>
 
class Sales_data {
// 友元——普通函数，被授权访问 private 成员
friend Sales_data add(const Sales_data&, const Sales_data&);
friend std::ostream& print(std::ostream&, const Sales_data&);
friend std::istream& read(std::istream&, Sales_data&);
 
public:
    // 构造函数
    Sales_data() = default;                          // ① 默认构造
    Sales_data(const std::string &s) : bookNo(s) {}  // ② 只给书名
    Sales_data(const std::string &s, unsigned n, double p)
        : bookNo(s), units_sold(n), revenue(p) {}    // ③ 全参构造
    Sales_data(std::istream&);                       // ④ 从流构造
 
    // 成员函数——const 表示不修改 *this
    std::string isbn() const { return bookNo; }
    Sales_data& combine(const Sales_data&);
    double avg_price() const;
 
private:
    std::string bookNo;
    unsigned units_sold = 0;      // 类内初始值——给默认构造用
    double revenue = 0.0;
};

设计要点：① 四个构造函数覆盖不同场景——空对象、只给书名、给定全部字段、从流读取。= default 告诉编译器「我要默认行为」——但这里必须显式写，因为后面定义了其他构造函数，编译器不会自动合成。② avg_price() 和 isbn() 标了 const——不修改对象状态。③ combine() 没标 const——它会修改 units_sold 和 revenue。④ 友元声明在类的顶部——位置无所谓，但统一放开头更清晰。

combine：把两笔销售合并

Sales_data& Sales_data::combine(const Sales_data &rhs) {
    units_sold += rhs.units_sold;    // 累加销量
    revenue += rhs.revenue;          // 累加收入
    return *this;                     // 返回当前对象——支持链式调用
}

combine 是典型的需要修改 *this 的成员函数——所以不能标 const。返回 Sales_data&（自身引用）允许链式调用：a.combine(b).combine(c)。rhs 用 const Sales_data& 传——只需要读它、不修改、不需要拷贝。

avg_price：只读、不修改

double Sales_data::avg_price() const {
    if (units_sold)
        return revenue / units_sold;
    else
        return 0;
}

avg_price 是 const 成员函数的典型——只读、不改。revenue / units_sold 实际是 this->revenue / this->units_sold。销量为 0 时没有有意义的均价；在常见的 IEC 60559 浮点实现中，除零可能得到 NaN 或无穷并触发浮点异常状态，但不能把这种平台行为当作业务结果，所以这里显式返回 0。

read / print：友元函数读写对象

// read——从输入流读取一笔交易，填进 item
std::istream& read(std::istream &is, Sales_data &item) {
    double price = 0;       // 单价（用户输入的是单价，不存进对象）
    is >> item.bookNo >> item.units_sold >> price;
    item.revenue = price * item.units_sold;  // 收入 = 单价 × 销量
    return is;
}
 
// print——把 item 的状态输出到流
std::ostream& print(std::ostream &os, const Sales_data &item) {
    os << item.isbn() << " " << item.units_sold << " "
       << item.revenue << " " << item.avg_price();
    return os;
}

两个关键设计决策：① read 的参数 Sales_data &item 不是 const——要修改 item。② print 的参数 const Sales_data &item——只读不拷贝。③ 用户输入的是单价 price 而非收入——price 只是 read 的局部变量，不存进对象。④ 返回 istream& / ostream& 是为了能链式调用。

add：相加两笔交易（ISBN 相同才合法）

Sales_data add(const Sales_data &lhs, const Sales_data &rhs) {
    Sales_data sum = lhs;   // 拷贝 lhs 的数据
    sum.combine(rhs);       // 把 rhs 的数据合进来
    return sum;              // 返回结果；编译器可做 NRVO，否则可移动
}

两个参数都是 const 引用——不修改。以 lhs 为基础构造 sum，然后调 combine 合并 rhs。返回 Sales_data 按值时，编译器通常可做具名返回值优化（NRVO）；若未消除返回对象，满足条件时会移动。这里不能笼统承诺“零拷贝”。

完整的使用示例

int main() {
    Sales_data total;                      // 默认构造——所有成员为默认值
    if (read(std::cin, total)) {           // 读第一笔——read 返回 cin 引用
        Sales_data trans;                  // 当前交易
        while (read(std::cin, trans)) {    // 逐笔读入
            if (total.isbn() == trans.isbn())
                total.combine(trans);       // 同书号——合并
            else {
                print(std::cout, total) << '\n';  // 不同书号——输出上一本
                total = trans;                     // 开始处理新书号
            }
        }
        print(std::cout, total) << '\n';   // 输出最后一本
    } else {
        std::cerr << "没有数据！\n";
    }
    return 0;
}

这段是前面的书店程序用类重写的版本——对比之前用裸变量和函数的版本：total.isbn() 代替了手动传字符串，total.combine(trans) 代替了手动 total_sold += trans_sold; total_revenue += trans_revenue;。数据和行为捆在一起后，代码干净了多少？

容易踩的坑

小结

• 类由数据成员和成员函数组成——数据存对象里，函数代码所有对象共享，通过 this 指针区分操作哪个对象
• 构造函数在对象创建时自动执行——先跑成员初始化列表（按声明顺序）、再跑构造体——一旦自定义构造，编译器不再合成默认构造
• public 是接口（外部可调）、private 是实现（外部碰不到）——封装让修改内部实现不影响调用方
• const 成员函数承诺不修改 *this——const 对象只能调 const 函数，非 const 对象两者都能调
• 友元用 friend 声明授权外部函数或类访问 private——用于操作符重载和紧密关联的非成员函数，不滥用

#include <string>
 
class Person {
    std::string name;
    std::string address;
 
public:
    std::string getName() { return name; }
    std::string getAddress() { return address; }
};

#include <string>
 
class Person {
    std::string name;
    std::string address;
 
public:
    Person() = default;
    Person(const std::string &n, const std::string &a)
        : name(n), address(a) {}
 
    std::string getName() const { return name; }        // ← 加了 const
    std::string getAddress() const { return address; }  // ← 加了 const
};

#include <iostream>
#include <string>
#include <vector>
 
class Student {
    std::string name;
    int id;
    double score;
 
public:
    Student() : name(""), id(0), score(0.0) {}
    Student(const std::string &n, int i, double s)
        : name(n), id(i), score(s) {}
 
    std::string getName() const { return name; }
    int getId() const { return id; }
    double getScore() const { return score; }
    void setScore(double s) { score = s; }
    bool isPassed() const { return score >= 60.0; }
};
 
int main() {
    std::vector<Student> students = {
        {"张三", 1001, 85.5},
        {"李四", 1002, 55.0},
        {"王五", 1003, 92.0}
    };
 
    for (const auto &s : students) {
        std::cout << s.getName() << " (学号 " << s.getId()
                  << "): " << (s.isPassed() ? "及格" : "不及格")
                  << " (" << s.getScore() << "分)\n";
    }
    return 0;
}

名词解释

原版目录概念补充核对

以下条目补齐官方目录中容易被示例主线掩盖的概念。它们不重复罗列目录，而是明确每项概念的机制、适用边界和验收证据。

静态类成员：机制、边界与证据

在《类》的官方单元 cppp-07 中，静态类成员连接本章第 5 组知识约束。学习时要同时说明它接受什么输入、改变什么状态、在何种边界失效；再以本章示例的编译诊断、固定输入输出或失败用例复核结论，不能只记术语名称。