C++ 入门教程（八）：面向对象（上）——类与封装

1
class BankAccount {
2
private:                 // 私有：只有类自己的成员函数能访问
3
    std::string owner;
4
    double balance;
5

6
public:                  // 公开：外部的接口
7
    // 构造函数
8
    BankAccount(const std::string& name, double init_balance = 0)
9
        : owner(name), balance(init_balance) {    // 初始化列表
10
    }
11

12
    // 成员函数（方法）
13
    void deposit(double amount) {
14
        if (amount <= 0) return;
15
        balance += amount;
16
    }
17

18
    bool withdraw(double amount) {
19
        if (amount > balance) return false;
20
        balance -= amount;
21
        return true;
22
    }
23

24
    double get_balance() const { return balance; }   // const：承诺不修改成员
25
};
26

27
int main() {
28
    BankAccount acc("小明", 100);
29
    acc.deposit(50);
30
    acc.withdraw(30);
31
    std::cout << acc.get_balance() << "\n";    // 120
32

33
    // acc.balance = -999;      // ❌ private，外部禁止直接改——封装的意义！
34
}

1
#include <iostream>
2

3
class FileLogger {
4
    FILE* fp;
5
public:
6
    FileLogger(const char* path) {
7
        fp = fopen(path, "a");
8
        std::cout << "[打开日志]\n";
9
    }
10

11
    void log(const char* msg) {
12
        if (fp) fprintf(fp, "%s\n", msg);
13
    }
14

15
    ~FileLogger() {                     // 析构：对象生命周期结束时自动调用
16
        if (fp) fclose(fp);
17
        std::cout << "[关闭日志]\n";
18
    }
19
};
20

21
void demo() {
22
    FileLogger logger("app.log");       // 栈对象：demo 结束自动析构
23
    logger.log("hello");
24
}                                       // 打印 [关闭日志]——这就是 RAII！
25

26
int main() { demo(); std::cout << "demo 之后\n"; }
27
// 输出顺序：[打开日志] [关闭日志] demo 之后

1
#include <vector>
2
#include <stdexcept>
3
#include <iomanip>
4
#include <iostream>
5

6
class Matrix {
7
public:
8
    Matrix(size_t rows, size_t cols, double init = 0)
9
        : rows_(rows), cols_(cols), data_(rows * cols, init) {}
10

11
    double& at(size_t r, size_t c) {            // 可写访问（带越界检查）
12
        check(r, c);
13
        return data_[r * cols_ + c];
14
    }
15
    double at(size_t r, size_t c) const {       // 只读访问（重载）
16
        check(r, c);
17
        return data_[r * cols_ + c];
18
    }
19

20
    size_t rows() const { return rows_; }
21
    size_t cols() const { return cols_; }
22

23
    Matrix operator*(const Matrix& rhs) const { // 运算符重载：矩阵乘法
24
        if (cols_ != rhs.rows_)
25
            throw std::invalid_argument("尺寸不匹配");
26
        Matrix result(rows_, rhs.cols_);
27
        for (size_t i = 0; i < rows_; ++i)
28
            for (size_t k = 0; k < cols_; ++k)
29
                for (size_t j = 0; j < rhs.cols_; ++j)
30
                    result.at(i, j) += at(i, k) * rhs.at(k, j);
31
        return result;
32
    }
33

34
    void print() const {
35
        for (size_t i = 0; i < rows_; ++i) {
36
            for (size_t j = 0; j < cols_; ++j)
37
                std::cout << std::setw(8) << at(i, j);
38
            std::cout << "\n";
39
        }
40
    }
41

42
private:
43
    void check(size_t r, size_t c) const {
44
        if (r >= rows_ || c >= cols_)
45
            throw std::out_of_range("矩阵下标越界");
46
    }
47
    size_t rows_, cols_;
48
    std::vector<double> data_;
49
};
50

51
int main() {
52
    Matrix a(2, 3, 1.0);
53
    Matrix b(3, 2, 2.0);
54
    Matrix c = a * b;        // 6 = 全1×全2
55
    c.print();
56
}