第一节 · 系统的构造 · 类的定义与封装

到目前为止，我们学习的都是过程式编程——程序由一系列函数组成，数据和操作数据的函数是分离的。

但随着程序规模的增长，这种方式会变得难以管理。想象一下，你有一堆函数，每个函数都可以随意访问和修改全局数据，稍有不慎就可能产生难以追踪的 bug。

面向对象编程（Object-Oriented Programming，OOP）提供了一种更好的组织代码的方式：将数据和操作数据的函数打包在一起，形成一个整体。这个整体就是类（Class）。

---

从结构体到类

我们已经见过结构体（struct）：

struct Student
{
    string name;
    int age;
    int score;
};

Student s;
s.name = "Alice";
s.age = 18;
s.score = 95;

结构体将相关的数据组合在一起，但数据仍然是"裸露"的——任何代码都可以直接访问和修改。

类（class）在此基础上更进一步，不仅可以包含数据，还可以包含函数，而且可以控制访问权限：

class Student
{
private:
    string name;
    int age;
    int score;

public:
    void setName(const string& n)
    {
        name = n;
    }
    
    string getName() const
    {
        return name;
    }
    
    void setScore(int s)
    {
        if (s >= 0 && s <= 100)
            score = s;
    }
    
    int getScore() const
    {
        return score;
    }
};

---

访问控制

类中的成员可以有不同的访问级别：

• private：私有成员，只能在类内部访问

• public：公有成员，可以在任何地方访问

• protected：受保护成员，只能在类内部和派生类中访问（后续章节会学习）

class Example
{
private:
    int privateVar;      // 只有类内部可以访问
    
protected:
    int protectedVar;    // 类内部和派生类可以访问
    
public:
    int publicVar;       // 任何地方都可以访问
    
    void publicFunc()    // 公有成员函数
    {
        privateVar = 10;  // 在类内部，可以访问私有成员
    }
};

int main()
{
    Example e;
    e.publicVar = 1;     // OK，公有成员
    // e.privateVar = 2; // 错误！私有成员不能在类外访问
    e.publicFunc();      // OK
    return 0;
}

class 与 struct 的区别

在 C++ 中，class 和 struct 几乎相同，唯一的区别是默认访问级别：

• class：默认是 private

• struct：默认是 public

class MyClass
{
    int x;  // 默认是 private
};

struct MyStruct
{
    int x;  // 默认是 public
};

---

封装

封装是面向对象的核心概念之一。它意味着：

1. 将数据和操作数据的函数绑定在一起

2. 隐藏实现细节，只暴露必要的接口

为什么要封装？

// 没有封装
struct BankAccount
{
    double balance;
};

BankAccount account;
account.balance = -1000;  // 直接设置为负数，不合理！

// 有封装
class BankAccount
{
private:
    double balance;
    
public:
    BankAccount() : balance(0) {}
    
    void deposit(double amount)
    {
        if (amount > 0)
            balance += amount;
    }
    
    bool withdraw(double amount)
    {
        if (amount > 0 && amount <= balance)
        {
            balance -= amount;
            return true;
        }
        return false;
    }
    
    double getBalance() const
    {
        return balance;
    }
};

BankAccount account;
account.deposit(1000);     // OK
account.withdraw(500);     // OK
// account.balance = -1000; // 错误！不能直接访问

封装的好处：

• 数据完整性：可以在 setter 中验证数据

• 灵活性：可以改变内部实现而不影响外部代码

• 安全性：防止意外修改数据

---

成员函数

类中的函数称为成员函数（或方法）：

class Rectangle
{
private:
    double width;
    double height;
    
public:
    // 设置尺寸
    void setSize(double w, double h)
    {
        width = w;
        height = h;
    }
    
    // 计算面积
    double area() const
    {
        return width * height;
    }
    
    // 计算周长
    double perimeter() const
    {
        return 2 * (width + height);
    }
};

int main()
{
    Rectangle rect;
    rect.setSize(5, 3);
    cout << "面积: " << rect.area() << endl;       // 15
    cout << "周长: " << rect.perimeter() << endl;  // 16
    return 0;
}

注意到 area() 和 perimeter() 后面有 const 吗？这表示这个函数不会修改对象的状态，称为常量成员函数。

---

在类外定义成员函数

成员函数可以在类内声明，在类外定义：

class Rectangle
{
private:
    double width;
    double height;
    
public:
    void setSize(double w, double h);  // 声明
    double area() const;                // 声明
    double perimeter() const;           // 声明
};

// 在类外定义，需要使用 类名::函数名 的形式
void Rectangle::setSize(double w, double h)
{
    width = w;
    height = h;
}

double Rectangle::area() const
{
    return width * height;
}

double Rectangle::perimeter() const
{
    return 2 * (width + height);
}

:: 是作用域解析运算符，Rectangle::area 表示 Rectangle 类的 area 函数。

这种分离声明和定义的方式在实际开发中很常见：

• 声明放在头文件（.h 或 .hpp）中

• 定义放在源文件（.cpp）中

---

一个完整的例子

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

class Person
{
private:
    string name;
    int age;
    
public:
    // 设置姓名
    void setName(const string& n)
    {
        if (!n.empty())
            name = n;
    }
    
    // 获取姓名
    string getName() const
    {
        return name;
    }
    
    // 设置年龄
    void setAge(int a)
    {
        if (a >= 0 && a <= 150)
            age = a;
    }
    
    // 获取年龄
    int getAge() const
    {
        return age;
    }
    
    // 自我介绍
    void introduce() const
    {
        cout << "我是 " << name << "，今年 " << age << " 岁。" << endl;
    }
};

int main()
{
    Person p;
    p.setName("张三");
    p.setAge(25);
    p.introduce();  // 我是 张三，今年 25 岁。
    
    return 0;
}

---

类是 C++ 面向对象编程的基础。通过类，我们可以将相关的数据和操作组织在一起，创建出更加模块化、可维护的代码。

习题

• 设计一个 Circle 类，包含半径属性，以及计算面积和周长的方法。

• 设计一个 Counter 类，包含一个计数器，提供增加、减少、重置和获取当前值的方法。

• 设计一个简单的 Clock 类，包含时、分、秒，提供设置时间和显示时间的方法。