1. 多态性：从概念到实战

第一次听说C++多态性时，我正盯着屏幕上一堆几何图形类发愁。当时项目需要计算不同形状的面积和体积，我写了十几个if-else判断类型，代码臃肿得像个臃肿的胖子。直到导师拍着我肩膀说："小伙子，该用多态了！" 这才打开了新世界的大门。

多态性就像变形金刚，同一个接口能根据对象类型自动切换不同形态。在C++中主要通过两种方式实现：运算符重载（静态多态）和虚函数机制（动态多态）。静态多态在编译期就确定行为，好比快餐店的固定套餐；动态多态则在运行时才决定调用哪个函数，更像私人订制的主厨料理。

举个生活中的例子：计算器APP的"+"按钮。对整数执行加法，对字符串执行拼接，这就是典型的多态行为。在几何计算器项目中，我们同样需要这种灵活性——计算立方体用边长³，计算球体用4/3πr³，但调用方式应该统一。

2. 运算符重载：让对象学会算术

2.1 基础运算符重载

先看个Point类的例子。要让两个点坐标相加，常规写法是pt3.x=pt1.x+pt2.x，这太不优雅了。通过重载+运算符，我们可以直接写pt3=pt1+pt2：

class Point { public: double x, y; Point operator+(const Point& other) const { return Point(x + other.x, y + other.y); } };

注意这里的const修饰符：第一个const保护参数不被修改，第二个const承诺不改变当前对象。我刚开始常忘记加这些const，直到有次误改了输入参数导致诡异bug...

2.2 友元函数重载

当运算符左右类型不同时，比如Point+double，就需要友元函数：

friend Point operator+(const Point& p, double d) { return Point(p.x + d, p.y + d); }

有次我试图用成员函数重载Point+double，结果编译器报错。原来成员函数默认左操作数是当前类对象，而double不是类类型。这个坑让我明白：对称运算符（如+、-）适合用友元，不对称运算符（如+=）适合用成员函数。

2.3 流运算符重载

让Point对象支持cout输出是个实用技巧：

friend ostream& operator<<(ostream& os, const Point& p) { return os << "(" << p.x << "," << p.y << ")"; }

记得返回ostream引用以便链式调用。我曾因为漏写return导致连续输出时报错，调试了两小时才找到原因。

3. 虚函数与抽象类：动态多态实战

3.1 虚函数机制

当我们需要统一处理几何图形时，虚函数就派上用场了。先定义抽象基类：

class Shape { public: virtual double volume() const = 0; // 纯虚函数 virtual ~Shape() {} // 虚析构函数 };

这里有两个关键点：一是纯虚函数强制子类实现，二是虚析构函数确保正确释放资源。曾经我漏写虚析构，导致通过基类指针删除子类对象时内存泄漏。

3.2 具体子类实现

立方体类的实现示例：

class Cube : public Shape { double side; public: Cube(double s) : side(s) {} double volume() const override { return side * side * side; } };

override关键字是C++11引入的，它能防止函数签名写错导致的意外重载。我就曾把volume()误写成volumn()，没有override时编译器不会报错，导致多态失效。

3.3 多态调用

使用基类指针容器管理所有图形：

vector<Shape*> shapes; shapes.push_back(new Cube(2)); shapes.push_back(new Sphere(3)); for (auto shape : shapes) { cout << shape->volume() << endl; // 自动调用对应实现 }

注意这里要用指针或引用才能触发多态。有次我直接传值，结果始终调用基类方法，这就是著名的"对象切片"问题。

4. 几何计算器完整实现

4.1 类体系设计

完整的几何计算器类结构如下：

Shape (抽象基类) ├─ Cube ├─ Sphere └─ Cylinder

每个子类需要实现三个虚函数：

• area() 表面积
• volume() 体积
• print() 打印信息

4.2 工厂模式应用

为方便创建对象，可以加入工厂方法：

Shape* createShape(const string& type, double param1, double param2 = 0) { if (type == "cube") return new Cube(param1); if (type == "sphere") return new Sphere(param1); if (type == "cylinder") return new Cylinder(param1, param2); return nullptr; }

这个技巧让客户端代码与具体类解耦。后来我们新增锥体类时，只需修改工厂函数，调用方代码完全不用变。

4.3 性能优化考虑

虚函数调用有额外开销（查虚表）。对性能敏感的场景可以用CRTP模式：

template <typename T> class Shape { public: double volume() const { return static_cast<const T*>(this)->volumeImpl(); } }; class Cube : public Shape<Cube> { double volumeImpl() const { /*...*/ } };

这种编译期多态避免了运行时开销，但会增大代码体积。需要根据实际情况权衡。

5. 常见陷阱与调试技巧

5.1 对象切片问题

这是新手最容易踩的坑：

vector<Shape> shapes; // 错误！应该用指针或引用 shapes.push_back(Cube(2)); // 子类信息被"切片"

编译器不会报错，但运行时只会调用Shape的方法。解决方法很简单：改用vector<Shape*>或vector<reference_wrapper<Shape>>。

5.2 虚函数签名不一致

子类虚函数如果参数列表与基类不一致，会变成重载而非覆盖：

class Shape { public: virtual void print() const; }; class Cube : public Shape { public: void print() override; // 正确 void print(string format) override; // 错误！不是覆盖 };

使用override关键字能及早发现这类错误。

5.3 多继承的钻石问题

当多个父类有相同虚函数时：

class A { virtual void foo(); }; class B : public A {}; class C : public A {}; class D : public B, public C {}; // 两个foo副本

解决方法是用虚继承：

class B : virtual public A {}; class C : virtual public A {};

这个技巧在开发UI组件库时特别有用，但过度使用会让类关系复杂化。

6. 现代C++中的多态演进

6.1 override和final

C++11引入的这两个关键字让代码更安全：

• override：显式标记重写虚函数
• final：禁止进一步重写

class Cube : public Shape { public: double volume() const override final; // 禁止子类再修改 };

6.2 使用unique_ptr管理多态对象

传统多态要用原始指针和手动delete，现代C++推荐：

vector<unique_ptr<Shape>> shapes; shapes.emplace_back(make_unique<Cube>(2));

这样完全不用操心内存释放，还能保持多态特性。

6.3 variant替代方案

C++17的variant可以实现"安全联合体"：

using ShapeVariant = variant<Cube, Sphere, Cylinder>; vector<ShapeVariant> shapes; shapes.push_back(Cube(2)); visit([](auto&& shape) { cout << shape.volume() << endl; }, shapes[0]);

这种方式在性能敏感场景比虚函数更有优势。