C++ 结构体教程：把相关数据组合成一个类型

为什么要把数据组合在一起

到目前为止，每个变量都是独立的：这里一个 int，那里一个 string。但真实的程序处理的是由多个部分组成的东西：一个点有 x 和 y，一个学生有姓名、年龄和 GPA。把它们当作零散的独立变量传来传去很容易出错：没有任何东西把它们联系在一起，需要这三项的函数就必须接收三个参数。

结构体解决了这个问题。它定义一个新类型，把相关的变量（也就是它的成员）打包成一个整体。定义好之后，你就可以把整个包当作一个值来存储、拷贝和传给函数。

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

struct Student {
    string name;
    int age;
    double gpa;
};   // <- don't forget the semicolon after the closing brace

int main() {
    Student s;          // one object holding all three members
    s.name = "Ada";
    s.age = 19;
    s.gpa = 3.9;

    cout << s.name << " is " << s.age << " (GPA " << s.gpa << ")\n";
}

用点运算符访问每个成员（s.name、s.age）。结构体定义的右花括号 } 后面的分号是必需的：漏掉它是 C++ 初学者最常见的编译错误之一。

初始化结构体

逐个给字段赋值可行，但很啰嗦，也容易漏掉某个成员。更简洁的做法是聚合初始化：在花括号里按成员声明的顺序列出各个值。

#include <iostream>
using namespace std;

struct Point {
    int x;
    int y;
};

int main() {
    Point a{3, 4};        // x = 3, y = 4 (brace init, preferred)
    Point origin{};       // both members value-initialized to 0
    Point b = {10, 20};   // older = {} form, identical effect

    cout << a.x << "," << a.y << "\n";          // 3,4
    cout << origin.x << "," << origin.y << "\n"; // 0,0
    cout << b.x << "," << b.y << "\n";           // 10,20
}

小心空的默认写法：Point p;（没有花括号）会让 x 和 y 保存垃圾值，因为内置类型的成员不会自动清零。Point p{}; 则会把它们值初始化为 0。优先使用花括号。你也可以直接在定义里写好默认值，这样即使是 Point p; 也能干净地开始：

#include <iostream>
using namespace std;

struct Config {
    int width  = 800;     // default member initializers
    int height = 600;
    bool fullscreen = false;
};

int main() {
    Config c;             // uses every default
    Config wide{1920};    // width overridden, others keep defaults

    cout << c.width << "x" << c.height << "\n";        // 800x600
    cout << wide.width << "x" << wide.height << "\n";  // 1920x600
}

把结构体作为函数参数

结构体是一个值，所以函数可以只接收一个参数，而不是三个。只是要记住，按值传递结构体会拷贝每一个成员。对于比几个 int 更大的东西，按 const 引用传递来省掉拷贝，这和你在引用一页看到的规则相同。

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

struct Student {
    string name;
    double gpa;
};

// const& avoids copying the string, and promises not to modify s
void printStudent(const Student& s) {
    cout << s.name << ": " << s.gpa << "\n";
}

// returning a struct is fine - the compiler optimizes the copy away
Student makeStudent(string name, double gpa) {
    return Student{name, gpa};
}

int main() {
    Student top = makeStudent("Grace", 4.0);
    printStudent(top);
}

从函数返回整个结构体，是一次交回多个值的惯用方式，比来回摆弄多个输出引用清楚得多。

添加成员函数和构造函数

结构体不只能装数据。它还可以包含操作自身成员的成员函数，以及在对象创建时就完成初始化的构造函数。到这里，结构体开始像一个带有行为的小对象了。

#include <iostream>
using namespace std;

struct Rectangle {
    double width;
    double height;

    // constructor: runs when a Rectangle is created
    Rectangle(double w, double h) : width(w), height(h) {}

    // member function: uses the object's own members
    double area() const {        // const = "I don't modify the object"
        return width * height;
    }
};

int main() {
    Rectangle r(4.0, 5.0);
    cout << "area = " << r.area() << "\n";   // area = 20
}

在成员函数内部，直接用名字访问成员（width、height），它们指的是这个对象自己的那一份。写成 area() const，是告诉编译器这个函数只读取对象，这样你也能在 const Rectangle 值上调用它。构造函数本身就是一个独立的主题，包括 : width(w) 这种初始化列表语法，构造函数那一页会深入讲解。

struct 与 class：真正的区别

你可能听说过“结构体用来装数据，类用来做对象”。这只是一种惯例，并不是语言规则。在 C++ 中，struct 和 class 几乎是同一个东西，唯一内置的区别是默认访问级别。

struct S {
    int x;        // public by default
};

class C {
    int x;        // private by default
};

struct 的成员除非另行标注，否则是 public 的；class 的成员一开始是 private 的。仅此而已：两者都可以有构造函数、成员函数、继承以及其他一切。你甚至可以给结构体加上显式的访问说明符来隐藏成员：

#include <iostream>
using namespace std;

struct Counter {
    int value() const { return count; }   // public
    void bump() { count++; }

private:
    int count = 0;                          // now hidden
};

int main() {
    Counter c;
    c.bump();
    c.bump();
    cout << c.value() << "\n";   // 2
    // c.count = 99;   // compile error - count is private
}

实际的结论：对于每个字段都可以随意访问的透明数据集合（一个 Point、一个 Color、一条配置记录），用 struct；当你想把内部状态藏在公共接口后面加以保护时，用 class。编译器对它们一视同仁，关键字只是表明你的意图。

结构体数组和结构体 vector

因为结构体是普通的类型，你可以把许多个结构体放进数组或 vector 中，像对待其他值一样遍历它们。

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

struct Product {
    string name;
    double price;
};

int main() {
    vector<Product> cart = {
        {"Keyboard", 49.99},
        {"Mouse", 19.99},
        {"Monitor", 199.00},
    };

    double total = 0;
    for (const Product& p : cart) {   // const& - no copy per item
        cout << p.name << ": $" << p.price << "\n";
        total += p.price;
    }
    cout << "Total: $" << total << "\n";
}

注意嵌套的花括号：每个 {"Keyboard", 49.99} 聚合初始化一个 Product，外层花括号则构造整个 vector。在范围循环中使用 const Product&，可以避免每次迭代都拷贝一个结构体：去掉 &，你就会毫无必要地复制每个元素。

下一节：枚举

结构体让你用多个打包在一起的值构建一个类型。下一章则反其道而行：枚举定义的类型只能从一个小的、有名字的集合中取一个值，非常适合 Color::Red、Direction::North 或状态机的状态这类东西。你会看到 enum class 如何提供可读且类型安全的常量，并与你正在构建的结构体和类自然地配合使用。