C++ 入门教程（九）：面向对象（下）——继承与多态

1
class Shape {                        // 抽象类：含纯虚函数，不能实例化
2
public:
3
    virtual double area() const = 0;     // = 0 纯虚：子类必须实现
4
    virtual ~Shape() = default;
5

6
    // 可以有普通成员与实现
7
    void describe() const {
8
        std::cout << "面积 = " << area() << "\n";   // 调用延迟到子类
9
    }
10
};
11

12
class Circle : public Shape {
13
    double r;
14
public:
15
    explicit Circle(double r) : r(r) {}
16
    double area() const override { return 3.14159 * r * r; }
17
};
18

19
class Rect : public Shape {
20
    double w, h;
21
public:
22
    Rect(double w, double h) : w(w), h(h) {}
23
    double area() const override { return w * h; }
24
};
25

26
// Shape s;              // ❌ 抽象类不能造对象
27
// Shape* p = new Shape; // ❌ 同上
28

29
int main() {
30
    Shape* shapes[] = {new Circle(2), new Rect(3, 4)};
31
    double total = 0;
32
    for (auto* s : shapes) {
33
        s->describe();           // 多态：各算各的面积
34
        total += s->area();
35
    }
36
    std::cout << "总面积 " << total << "\n";
37
}

1
class BadBase {
2
public:
3
    ~BadBase() { std::cout << "~BadBase\n"; }    // ❌ 非虚析构
4
};
5
class BadDerived : public BadBase {
6
    int* big_;
7
public:
8
    BadDerived() : big_(new int[1000]) {}
9
    ~BadDerived() { delete[] big_; std::cout << "~BadDerived\n"; }
10
};
11

12
int main() {
13
    BadBase* p = new BadDerived();
14
    delete p;      // ⚠ 只输出 ~BadBase！子类析构没执行 → big_ 泄漏 4000 字节
15
}

1
class Locked : public Base {
2
public:
3
    void speak() const final;      // final：禁止后代再重写
4
};
5
// class Sub : public Locked {};  // 也可 final 整个类：禁止再继承
6

7
// 运行期类型识别 dynamic_cast（向下转型，需多态类型）
8
Animal* a = new Dog("旺财");
9
if (Dog* d = dynamic_cast<Dog*>(a)) {   // 成功返回指针，失败返回 nullptr
10
    d->fetch();
11
}
12

13
// typeid 拿到真实类型名
14
#include <typeinfo>
15
std::cout << typeid(*a).name();         // 3Dog（名字修饰因编译器而异）

1
#include <iostream>
2
#include <memory>
3
#include <vector>
4
#include <string>
5
#include <random>
6

7
class Character {                          // 抽象基类
8
public:
9
    Character(std::string name, int hp, int atk)
10
        : name_(std::move(name)), hp_(hp), atk_(atk) {}
11
    virtual ~Character() = default;
12

13
    virtual void attack(Character& target) const = 0;   // 纯虚：每种角色攻击方式不同
14
    virtual void take_damage(int dmg) {
15
        hp_ -= dmg;
16
        std::cout << "  " << name_ << " 受到 " << dmg
17
                  << " 伤害（剩 " << (hp_ > 0 ? hp_ : 0) << "）\n";
18
    }
19

20
    bool alive() const { return hp_ > 0; }
21
    const std::string& name() const { return name_; }
22
    int atk() const { return atk_; }
23

24
protected:
25
    std::string name_;
26
    int hp_, atk_;
27
};
28

29
class Warrior : public Character {         // 战士：稳定输出
30
public:
31
    Warrior(const std::string& n) : Character(n, 120, 15) {}
32
    void attack(Character& t) const override {
33
        std::cout << name_ << " 挥剑攻击 " << t.name() << "！\n";
34
        t.take_damage(atk());
35
    }
36
};
37

38
class Mage : public Character {            // 法师：30% 概率暴击
39
public:
40
    Mage(const std::string& n) : Character(n, 80, 25) {}
41
    void attack(Character& t) const override {
42
        static std::mt19937 rng{std::random_device{}()};
43
        bool crit = std::uniform_int_distribution<>(1, 10)(rng) <= 3;
44
        int dmg = atk() * (crit ? 2 : 1);
45
        std::cout << name_ << (crit ? " 释放暴击火球！" : " 释放火球") << "\n";
46
        t.take_damage(dmg);
47
    }
48
};
49

50
int main() {
51
    // 智能指针数组管理多态对象
52
    std::vector<std::unique_ptr<Character>> team = {
53
        std::make_unique<Warrior>("勇者"),
54
        std::make_unique<Mage>("大法师"),
55
    };
56
    Character* monster = new Warrior("哥布林王");
57

58
    int round = 1;
59
    while (monster->alive() &&
60
           std::any_of(team.begin(), team.end(),
61
                       [](auto& c) { return c->alive(); })) {
62
        std::cout << "—— 回合 " << round++ << " ——\n";
63
        for (auto& c : team)
64
            if (c->alive() && monster->alive())
65
                c->attack(*monster);        // 多态调用
66
        if (monster->alive())
67
            monster->attack(*team[0]);
68
    }
69
    std::cout << (monster->alive() ? "团灭……" : "胜利！") << "\n";
70
    delete monster;
71
}