02: 类与对象 (Classes and Objects)¶

class ClassName {
private:
    // 私有成员（属性）
    type member1;
    type member2;

public:
    // 公有成员函数（方法）
    returnType func1() {
        // 函数体
    }
};  // 末尾必须有分号！

class Student {
private:
    string _name;   // 加下划线前缀表示私有成员变量
    int _id;
    double _score;
};

class Student {
private:
    string _name;
public:
    // 内联函数（定义在类内）
    string getName() const { return _name; }
    void setName(string n) { _name = n; }

    // 外联函数（类内声明，类外实现）
    void showInfo();
};

// 类外定义：使用 类名:: 作用域解析符
void Student::showInfo() {
    cout << "Name: " << _name << endl;
}

// 栈上创建（自动管理）
Student stu1;

// 堆上创建（需手动释放）
Student* pStu2 = new Student();
// ... 使用 pStu2
delete pStu2;

// 栈对象：使用点操作符 .
stu1.setName("张三");
cout << stu1.getName() << endl;

// 指针对象：使用箭头操作符 ->
Student* p = new Student();
p->setName("李四");
cout << p->getName() << endl;
delete p;

class Clock {
private:
    int _hour, _minute, _second;

public:
    void setTime(int h, int m, int s) {
        if (h >= 0 && h < 24 && m >= 0 && m < 60 && s >= 0 && s < 60) {
            _hour = h; _minute = m; _second = s;
        } // 进行合法性检查，防止非法时间设置
    }
    void showTime() const {
        cout << _hour << ":" << _minute << ":" << _second << endl;
    }
};

// myClock._hour = 12;  // 编译错误！_hour 是 private，不能直接访问

// BAD case: 直接使用 public 暴露数据成员
class BadClock { public: int hour, minute, second; };

// GREAT case: 使用 private + Getter/Setter 封装数据成员
class GoodClock {
private:
    int _hour;
public:
    int getHour() const { return _hour; }
    void setHour(int h) {
        if (h >= 0 && h < 24) _hour = h;  // 数据验证
    }
};

class Account {
private:            // 1. 数据区
    string _accountNumber;
    double _balance;
public:             // 2. 接口区
    Account(string accNo, double initBal);   // 构造/析构
    string getAccountNumber() const;         // 访问器
    double getBalance() const;
    void deposit(double amount);             // 业务方法
    bool withdraw(double amount);
};

class BankAccount {
private:
    string _accountNumber, _ownerName;
    double _balance;
public:
    BankAccount(string accNo, string owner, double initBal)
        : _accountNumber(accNo), _ownerName(owner), _balance(initBal) {}

    string getAccountNumber() const { return _accountNumber; }
    string getOwnerName() const { return _ownerName; }
    double getBalance() const { return _balance; }

    void deposit(double amount) {
        if (amount > 0) _balance += amount;
    }

    bool withdraw(double amount) {
        if (amount <= 0 || amount > _balance) return false;
        _balance -= amount;
        return true;
    }

    void display() const {
        cout << "账号: " << _accountNumber
             << ", 户主: " << _ownerName
             << ", 余额: " << _balance << endl;
    }
};

class Counter {
private:
    mutable int _accessCount = 0;
    int _value;
public:
    int getValue() const {
        _accessCount++;   // const 函数中可以修改 mutable 变量
        return _value;
    }
};

// 匿名命名空间：文件内部可见，对外不可见
namespace {
    void helperFunc() { /* 仅当前文件可使用 */ }
}

class Point {
private:
    int _x, _y;
public:
    Point& setX(int x) {
        this->_x = x;
        return *this;   // 支持链式调用
    }

    void setY(int y) { this->_y = y; }
};

// 链式调用
Point p;
p.setX(10).setY(20);

class Array {
private:
    int _data[10];
public:
    int& operator[](int index) { return _data[index]; }         // 读写版本
    const int& operator[](int index) const { return _data[index]; } // 只读版本
};

class Demo {
public:
    void normalFunc() { cout << "普通函数" << endl; }
    void constFunc() const { cout << "const 函数" << endl; }
};

const Demo cd;
// cd.normalFunc();   // WRONG! const 对象不能调用非 const 函数
cd.constFunc();       // CORRECT!

class Student {
private:
    string _name;
    static int _totalCount;      // 声明
public:
    Student(string name) : _name(name) { _totalCount++; }
    ~Student() { _totalCount--; }
    static int getTotalCount() { return _totalCount; }
};

int Student::_totalCount = 0;    // 必须在类外定义！

Student s1("Alice");
Student s2("Bob");
cout << Student::getTotalCount();

class Point {
private:
    int _x, _y;
public:
    Point(int x, int y) : _x(x), _y(y) {}
    friend Point add1(const Point& a, const Point& b);
    Point add2(const Point& a, const Point& b) {
        return Point(a._x + b._x, a._y + b._y);  // 成员函数可以访问私有成员
    }
};

Point add1(const Point& a, const Point& b) {
    return Point(a._x + b._x, a._y + b._y);
}

/*
Point add3(const Point& a, const Point& b) {
    return Point(a._x + b._x, a._y + b._y);
}
add3 不是 Point 的友元函数，无法访问私有成员 _x 和 _y，会编译报错
*/

class A {
private:
    int _secret;
    friend class B;    // B 是 A 的友元类
};

class Math {
public:
    int square(int x) { return x * x; }    // 自动 inline
    int cube(int x) { return x * x * x; }
};

class Date {
    int _day, _month, _year;
public:
    Date(int d, int m, int y) : _day(d), _month(m), _year(y) {}
};

class Person {
    string _name;
    Date _birthDate;     // 组合关系：Person has a Date
public:
    Person(string n, int d, int m, int y)
        : _name(n), _birthDate(d, m, y) {}  // 必须用初始化列表
};

class ClassB;  // 前向声明

class ClassA {
public:
    void func(ClassB& b);  // 仅需声明
};

┌─────────────────────┐
│      Rectangle      │  <- 类名
├─────────────────────┤
│ - length: double    │  <- 属性
│ - width: double     │
├─────────────────────┤
│ + setDimensions()   │  <- 方法
│ + getArea(): double │
└─────────────────────┘