第一节 · 从原子到宇宙 · 面向对象概述

面向对象编程是 C++ 的核心特性之一。类是用户自定义的类型，对象是类的实例。

---

定义类

class Person
{
public:
    // 成员变量
    string name;
    int age;
    
    // 成员函数
    void introduce()
    {
        cout << "I'm " << name << ", " << age << " years old." << endl;
    }
};

int main()
{
    // 创建对象
    Person p;
    p.name = "Alice";
    p.age = 25;
    p.introduce();  // I'm Alice, 25 years old.
    
    return 0;
}

---

访问控制

修饰符	含义
public	任何地方都可访问
private	只有类内部可访问
protected	类内部和派生类可访问

class BankAccount
{
private:
    double balance;  // 私有：外部不能直接访问
    
public:
    // 通过公有方法访问
    void deposit(double amount)
    {
        if (amount > 0)
            balance += amount;
    }
    
    double getBalance() const
    {
        return balance;
    }
};

int main()
{
    BankAccount account;
    // account.balance = 1000;  // 错误：私有成员
    account.deposit(1000);       // OK
    cout << account.getBalance() << endl;
    
    return 0;
}

---

struct vs class

唯一区别是默认访问权限：

• struct：默认 public

• class：默认 private

struct Point
{
    int x, y;  // 默认 public
};

class Point2
{
    int x, y;  // 默认 private
public:
    // 需要显式声明 public
};

---

构造函数

class Rectangle
{
private:
    double width, height;
    
public:
    // 默认构造函数
    Rectangle() : width(0), height(0) {}
    
    // 带参数的构造函数
    Rectangle(double w, double h) : width(w), height(h) {}
    
    // 委托构造函数（C++11）
    Rectangle(double size) : Rectangle(size, size) {}
    
    double area() const { return width * height; }
};

int main()
{
    Rectangle r1;           // 调用默认构造
    Rectangle r2(3, 4);     // 调用带参构造
    Rectangle r3(5);        // 正方形
    
    cout << r1.area() << endl;  // 0
    cout << r2.area() << endl;  // 12
    cout << r3.area() << endl;  // 25
    
    return 0;
}

---

初始化列表

class Student
{
private:
    const int id;    // const 成员必须在初始化列表中初始化
    string name;
    int& score;      // 引用成员必须在初始化列表中初始化
    
public:
    Student(int i, const string& n, int& s)
        : id(i), name(n), score(s)  // 初始化列表
    {
        // 构造函数体
    }
};

为什么用初始化列表？

• 效率更高（直接构造，而非先默认构造再赋值）

• const 成员和引用成员必须使用

• 可以控制初始化顺序

---

析构函数

class FileHandler
{
private:
    FILE* file;
    
public:
    FileHandler(const char* filename)
    {
        file = fopen(filename, "r");
        cout << "File opened" << endl;
    }
    
    ~FileHandler()  // 析构函数：无参数，无返回值
    {
        if (file) fclose(file);
        cout << "File closed" << endl;
    }
};

void readFile()
{
    FileHandler fh("test.txt");
    // ... 使用文件 ...
}  // fh 离开作用域，自动调用析构函数

---

this 指针

class Counter
{
private:
    int value;
    
public:
    Counter(int value) : value(value) {}
    
    // this 指向当前对象
    Counter& increment()
    {
        this->value++;
        return *this;  // 返回当前对象，支持链式调用
    }
    
    void print() const
    {
        cout << "Value: " << this->value << endl;
    }
};

int main()
{
    Counter c(0);
    c.increment().increment().increment();  // 链式调用
    c.print();  // Value: 3
    
    return 0;
}

---

const 成员函数

class Circle
{
private:
    double radius;
    
public:
    Circle(double r) : radius(r) {}
    
    // const 成员函数：不修改对象状态
    double getArea() const
    {
        // radius = 10;  // 错误：const 函数不能修改成员
        return 3.14159 * radius * radius;
    }
    
    // 非 const 版本
    void setRadius(double r)
    {
        radius = r;
    }
};

void print(const Circle& c)
{
    cout << c.getArea() << endl;  // OK：getArea 是 const
    // c.setRadius(10);  // 错误：c 是 const
}

---

静态成员

class Counter
{
private:
    static int count;  // 静态成员变量：所有对象共享
    int id;
    
public:
    Counter() : id(++count) {}
    
    // 静态成员函数：没有 this 指针
    static int getCount()
    {
        return count;
    }
    
    int getId() const { return id; }
};

// 静态成员变量必须在类外定义
int Counter::count = 0;

int main()
{
    Counter c1, c2, c3;
    
    cout << Counter::getCount() << endl;  // 3
    cout << c1.getId() << endl;  // 1
    cout << c2.getId() << endl;  // 2
    
    return 0;
}

---

习题

• 设计一个 Date 类，包含年月日，并实现日期比较。

• 解释构造函数初始化列表和函数体内赋值的区别。

• 实现一个统计对象数量的类。