第二节 · 高级容器 · 类类型

在上一节中，我们学习了如何定义类。现在让我们更深入地了解类类型的一些特性——类作为一种自定义类型，可以像 int、double 这样的内置类型一样使用。

---

类对象的创建

创建类对象有多种方式：

class Point
{
public:
    double x;
    double y;
};

int main()
{
    // 默认初始化
    Point p1;               // x 和 y 是未定义的值
    
    // 值初始化
    Point p2{};             // x 和 y 都是 0
    Point p3 = {};          // 同上
    
    // 列表初始化
    Point p4{1.0, 2.0};     // x = 1.0, y = 2.0
    Point p5 = {3.0, 4.0};  // x = 3.0, y = 4.0
    
    // 动态创建
    Point* p6 = new Point;          // 堆上创建
    Point* p7 = new Point{5.0, 6.0};
    
    delete p6;
    delete p7;
    
    return 0;
}

---

类的成员初始化

C++11 允许在类定义中直接为成员指定默认值：

class Rectangle
{
public:
    double width = 1.0;   // 默认值
    double height = 1.0;  // 默认值
    
    double area() const
    {
        return width * height;
    }
};

int main()
{
    Rectangle r1;          // width = 1.0, height = 1.0
    Rectangle r2{5.0};     // width = 5.0, height = 1.0
    Rectangle r3{3.0, 4.0};// width = 3.0, height = 4.0
    
    cout << r1.area() << endl;  // 1
    cout << r3.area() << endl;  // 12
    
    return 0;
}

---

类对象的赋值与复制

类对象可以像普通变量一样赋值和复制：

class Point
{
public:
    double x = 0;
    double y = 0;
};

int main()
{
    Point p1{1.0, 2.0};
    
    Point p2 = p1;       // 复制初始化
    Point p3;
    p3 = p1;             // 赋值
    
    cout << p2.x << ", " << p2.y << endl;  // 1, 2
    cout << p3.x << ", " << p3.y << endl;  // 1, 2
    
    // 修改 p1 不影响 p2 和 p3
    p1.x = 100;
    cout << p2.x << endl;  // 仍然是 1
    
    return 0;
}

默认情况下，复制和赋值会逐成员复制。这种行为称为浅复制。如果类中有指针成员，可能需要自定义复制行为（深复制），我们将在后续章节学习。

---

类对象的比较

默认情况下，类对象不能直接用 == 比较：

Point p1{1.0, 2.0};
Point p2{1.0, 2.0};

// if (p1 == p2)  // 错误！没有定义 == 运算符

// 需要手动比较成员
if (p1.x == p2.x && p1.y == p2.y)
    cout << "相等" << endl;

可以通过重载运算符来支持比较，我们将在后续章节学习。

---

类作为函数参数和返回值

类对象可以作为函数的参数和返回值：

class Point
{
public:
    double x = 0;
    double y = 0;
};

// 值传递（会复制整个对象）
void printPoint(Point p)
{
    cout << "(" << p.x << ", " << p.y << ")" << endl;
}

// 引用传递（推荐，避免复制）
void movePoint(Point& p, double dx, double dy)
{
    p.x += dx;
    p.y += dy;
}

// 常量引用传递（只读，避免复制）
double distance(const Point& p1, const Point& p2)
{
    double dx = p2.x - p1.x;
    double dy = p2.y - p1.y;
    return sqrt(dx * dx + dy * dy);
}

// 返回类对象
Point midpoint(const Point& p1, const Point& p2)
{
    Point mid;
    mid.x = (p1.x + p2.x) / 2;
    mid.y = (p1.y + p2.y) / 2;
    return mid;
}

int main()
{
    Point p1{0, 0};
    Point p2{3, 4};
    
    printPoint(p1);                          // (0, 0)
    movePoint(p1, 1, 1);
    printPoint(p1);                          // (1, 1)
    
    cout << "距离: " << distance(p1, p2) << endl;
    
    Point mid = midpoint(p1, p2);
    printPoint(mid);                         // (2, 2.5)
    
    return 0;
}

---

类数组和容器

类对象可以存储在数组和容器中：

#include <vector>
#include <array>

class Point
{
public:
    double x = 0;
    double y = 0;
};

int main()
{
    // 原生数组
    Point points1[3] = {{0, 0}, {1, 1}, {2, 2}};
    
    // std::array
    array<Point, 3> points2 = {{{0, 0}, {1, 1}, {2, 2}}};
    
    // vector
    vector<Point> points3;
    points3.push_back({0, 0});
    points3.push_back({1, 1});
    points3.push_back({2, 2});
    
    // 遍历
    for (const Point& p : points3)
    {
        cout << "(" << p.x << ", " << p.y << ")" << endl;
    }
    
    return 0;
}

---

嵌套类型

类可以作为另一个类的成员：

class Point
{
public:
    double x = 0;
    double y = 0;
};

class Rectangle
{
public:
    Point topLeft;
    Point bottomRight;
    
    double width() const
    {
        return bottomRight.x - topLeft.x;
    }
    
    double height() const
    {
        return bottomRight.y - topLeft.y;
    }
    
    double area() const
    {
        return width() * height();
    }
};

int main()
{
    Rectangle rect;
    rect.topLeft = {0, 0};
    rect.bottomRight = {10, 5};
    
    cout << "面积: " << rect.area() << endl;  // 50
    
    return 0;
}

---

类类型的别名

可以使用 typedef 或 using 为类类型创建别名：

class VeryLongClassName
{
public:
    int value;
};

// 使用 typedef
typedef VeryLongClassName ShortName1;

// 使用 using（C++11，推荐）
using ShortName2 = VeryLongClassName;

int main()
{
    ShortName1 obj1;
    ShortName2 obj2;
    obj1.value = 10;
    obj2.value = 20;
    return 0;
}

---

前向声明

有时我们需要在完整定义类之前就引用它，这时可以使用前向声明：

class B;  // 前向声明

class A
{
public:
    B* b;  // 只能使用指针或引用
    // B member;  // 错误！此时不知道 B 的大小
};

class B
{
public:
    A* a;
    int value;
};

int main()
{
    A a;
    B b;
    a.b = &b;
    b.a = &a;
    b.value = 42;
    
    cout << a.b->value << endl;  // 42
    
    return 0;
}

前向声明常用于解决循环引用的问题。

---

实例：学生成绩管理

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

class Student
{
public:
    string name;
    int score;
};

class GradeBook
{
private:
    vector<Student> students;
    
public:
    void addStudent(const string& name, int score)
    {
        students.push_back({name, score});
    }
    
    void printAll() const
    {
        cout << "学生名单：" << endl;
        for (const Student& s : students)
        {
            cout << s.name << ": " << s.score << endl;
        }
    }
    
    double average() const
    {
        if (students.empty()) return 0;
        int sum = 0;
        for (const Student& s : students)
        {
            sum += s.score;
        }
        return static_cast<double>(sum) / students.size();
    }
};

int main()
{
    GradeBook book;
    book.addStudent("Alice", 95);
    book.addStudent("Bob", 87);
    book.addStudent("Carol", 92);
    
    book.printAll();
    cout << "平均分: " << book.average() << endl;
    
    return 0;
}

---

类类型让我们能够创建更加复杂、更加贴近现实世界的数据模型。随着学习的深入，你会发现类是 C++ 最强大的特性之一。

习题

• 设计一个 Time 类，包含时、分、秒，并编写一个函数计算两个时间之间的秒数差。

• 设计一个 Book 类，包含书名、作者、价格。再设计一个 Library 类，使用 vector 存储多本书，提供添加书籍、查找书籍和显示所有书籍的功能。