一、静态多态：编译期的“多面手”

说到多态，很多人第一反应就是虚函数、继承、动态绑定。但我想说，静态多态才是我们日常写代码时接触最多的。说白了，静态多态就是在编译阶段就确定好调用哪个函数，而不是等到运行时才去查虚表。

我刚开始学C++时，总觉得“多态”这个词很高大上。后来写多了才发现，函数重载、运算符重载、模板这些，其实都是多态的一种体现。只不过它们发生在编译期，所以叫“静态多态”。

1.1 函数重载：同名不同参

函数重载是静态多态最基础的形式。同一个函数名，参数列表不同，编译器根据实参类型和数量自动匹配。

// 函数重载示例
void print(int x) {
    std::cout << "整数: " << x << std::endl;
}

void print(double x) {
    std::cout << "浮点数: " << x << std::endl;
}

void print(const char* str) {
    std::cout << "字符串: " << str << std::endl;
}

int main() {
    print(42);        // 调用 print(int)
    print(3.14);      // 调用 print(double)
    print("hello");   // 调用 print(const char*)
    return 0;
}

这里有个坑，我踩过好几次。函数重载只看参数列表，不看返回值类型。你想想看，如果两个函数只有返回值不同，参数完全一样，编译器会报错。为什么？因为调用时无法区分该用哪个。

另外，我建议你在设计重载函数时，尽量让不同重载版本的行为语义一致。比如上面三个print函数，都是做“打印”这件事，只是处理的数据类型不同。如果你让print(int)去打印，而print(double)去计算平方，那代码就乱套了。

1.2 运算符重载：让自定义类型像内置类型一样自然

运算符重载本质上也是函数重载的一种特殊形式。它允许我们为自定义类型定义运算符的行为。

我记得有一次做数学计算库，需要实现复数类。如果没有运算符重载，写c1.add(c2)还能忍，但要是写c1.add(c2).mul(c3).sub(c4)，那代码可读性就太差了。有了运算符重载，直接写c1 + c2 * c3 - c4，清爽多了。

class Complex {
private:
    double real, imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
    
    // 重载 + 运算符
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }
    
    // 重载 == 运算符
    bool operator==(const Complex& other) const {
        return real == other.real && imag == other.imag;
    }
    
    // 重载 << 运算符（友元函数形式）
    friend std::ostream& operator<<(std::ostream& os, const Complex& c) {
        os << "(" << c.real << ", " << c.imag << "i)";
        return os;
    }
};

运算符重载有两种形式：成员函数形式和友元函数形式。一般来说，单目运算符适合用成员函数，双目运算符如果需要对左操作数进行类型转换，就用友元函数。

1.3 模板：编译期的“代码生成器”

模板是C++静态多态的集大成者。函数模板和类模板让我们可以写出与类型无关的通用代码。

函数模板

// 函数模板：通用的最大值函数
template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// 使用示例
int main() {
    int x = max(3, 5);           // T 推导为 int
    double y = max(3.14, 2.71);  // T 推导为 double
    std::string s = max(std::string("apple"), std::string("banana")); // T 推导为 string
    return 0;
}

函数模板的工作原理，说白了就是编译器根据你传入的实参类型，自动生成对应类型的函数代码。你写一份模板代码，编译器帮你生成N份具体代码。这就是“代码生成器”的由来。

类模板

// 类模板：通用的栈容器
template<typename T, int Capacity = 100>
class Stack {
private:
    T data[Capacity];
    int top;
public:
    Stack() : top(-1) {}
    
    void push(const T& value) {
        if (top < Capacity - 1) {
            data[++top] = value;
        }
    }
    
    T pop() {
        if (top >= 0) {
            return data[top--];
        }
        throw std::out_of_range("Stack is empty");
    }
    
    bool isEmpty() const { return top == -1; }
};

// 使用示例
Stack<int> intStack;          // 存储 int 的栈，容量 100
Stack<double, 50> dblStack;  // 存储 double 的栈，容量 50

类模板比函数模板更灵活，因为它可以包含非类型模板参数（比如上面的int Capacity）。我经常用类模板来实现容器、算法、策略模式等。

1.4 静态多态的优缺点

聊了这么多，我们来总结一下静态多态的优缺点。这部分内容我建议你结合自己的项目经验来理解，光背概念是记不住的。

优点	缺点
性能高：无运行时开销，所有决策在编译期完成	代码膨胀：每个模板实例化都会生成一份独立代码
类型安全：编译期类型检查，错误早发现	编译时间长：模板实例化需要大量编译计算
灵活性高：可以写出通用、可复用的代码	错误信息难读：模板编译错误信息往往又长又晦涩
内联优化：编译器可以轻松内联模板函数	二进制体积大：每个类型都生成一份代码副本
零抽象成本：使用模板不会比手写代码慢	接口隐式：模板的“接口”由使用方式决定，不够明确

我个人的经验是：在性能敏感的场合（比如游戏引擎、高频交易系统），优先考虑静态多态。在需要运行时扩展、插件化架构的场合，动态多态更合适。没有银弹，选对工具才是关键。

1.5 知识体系总览

下面这张图概括了本章的核心内容。你可以把它当作一个思维导图来理解静态多态的各个分支。

这张图把静态多态的三个分支——函数重载、运算符重载、模板——以及它们的核心特征都串起来了。你可以看到，所有分支最终都指向“编译期决议”这个共同特征。这也是静态多态和动态多态最本质的区别。

好了，关于静态多态的内容就聊到这里。记住一句话：静态多态是C++给我们的编译期超能力，用好了能让代码既高效又优雅。下一章我们会深入动态多态，看看虚函数和虚表是怎么工作的。

---

公众号:蓝海资料掘金营，微信deep3321