C++模板函数继承后多态失效问题求解

你遇到的是C++中模板与虚函数的核心冲突问题：模板函数不能被声明为虚函数，而你尝试用子类模板函数"覆盖"基类模板函数的做法，本质上不是虚函数重写（override），而是函数名字隐藏（hide），因此通过基类指针调用时，编译器只会绑定基类的模板实例，不会触发动态多态。

为什么会这样？ #

虚函数依赖运行时虚表机制实现动态绑定，但模板函数是编译期根据参数类型实例化的——编译器无法提前为所有可能的模板参数生成虚表条目，因此C++标准直接禁止模板虚函数。子类的template <typename T> void print和基类的同名模板是两个完全独立的函数模板，不存在继承关系中的重写逻辑。当你用HumanPrinterBase*指针调用print(person)时，编译器在编译阶段就确定了要调用基类实例化的print<Person>，不会走虚函数的动态绑定流程。

解决方案 #

根据你的需求（既要模板的通用性，又要动态多态），可以采用以下几种方案：

方案1：类型擦除（Type Erasure）

将模板逻辑与虚函数接口分离，基类提供非模板的虚函数接口，子类通过模板适配不同的打印逻辑。

#include <iostream>
#include <memory>
#include <string>

class Person {
protected:
    std::string _first_name;
    std::string _last_name;

public:
    Person(std::string first_name, std::string last_name)
        : _first_name(first_name), _last_name(last_name) {}

    const std::string& first_name() const { return _first_name; }
    const std::string& last_name() const { return _last_name; }
};

// 非模板基类，提供虚函数接口
class HumanPrinterBase {
public:
    virtual ~HumanPrinterBase() = default;
    virtual void print(const Person& person) const = 0;
    // 如需支持其他类型，添加对应的虚函数
    // virtual void print(const OtherType&) const = 0;
};

// 模板子类，负责转发调用到具体实现
template <typename Derived>
class HumanPrinter : public HumanPrinterBase {
public:
    void print(const Person& person) const override {
        static_cast<const Derived*>(this)->do_print(person);
    }
};

// 具体打印类，实现自定义逻辑
class HumanFirstNamePrinter : public HumanPrinter<HumanFirstNamePrinter> {
public:
    void do_print(const Person& person) const {
        std::cout << person.first_name() << std::endl;
    }
};

// 另一个示例：打印全名
class HumanFullNamePrinter : public HumanPrinter<HumanFullNamePrinter> {
public:
    void do_print(const Person& person) const {
        std::cout << person.first_name() << " " << person.last_name() << std::endl;
    }
};

int main() {
    Person person("John", "Doe");

    std::unique_ptr<HumanPrinterBase> hp = std::make_unique<HumanFirstNamePrinter>();
    hp->print(person); // 输出 "John"

    hp = std::make_unique<HumanFullNamePrinter>();
    hp->print(person); // 输出 "John Doe"

    return 0;
}

原理：基类HumanPrinterBase定义了与类型无关的虚函数接口，模板子类HumanPrinter将调用转发给具体子类的do_print方法，既保留了动态多态的能力，又通过模板复用了代码结构。

方案2：CRTP（奇异递归模板模式）

利用编译期静态多态替代运行时虚函数，适合不需要动态多态（即编译期就能确定具体类型）的场景。

#include <iostream>
#include <memory>
#include <string>

class Person {
protected:
    std::string _first_name;
    std::string _last_name;

public:
    Person(std::string first_name, std::string last_name)
        : _first_name(first_name), _last_name(last_name) {}

    const std::string& first_name() const { return _first_name; }
    const std::string& last_name() const { return _last_name; }
};

// CRTP基类，静态绑定调用
template <typename Derived>
class HumanPrinterBase {
public:
    template <typename T>
    void print(const T& person) const {
        static_cast<const Derived*>(this)->print(person);
    }
};

class HumanFirstNamePrinter : public HumanPrinterBase<HumanFirstNamePrinter> {
public:
    template <typename T>
    void print(const T& person) const {
        std::cout << person.first_name() << std::endl;
    }
};

int main() {
    Person person("John", "Doe");

    HumanFirstNamePrinter hp;
    hp.print(person); // 输出 "John"

    // 注意：CRTP不支持基类指针的动态多态，以下写法会导致无限递归
    // HumanPrinterBase<HumanFirstNamePrinter>* base_ptr = &hp;
    // base_ptr->print(person);
    return 0;
}

原理：通过编译期的static_cast将基类调用转发给子类实现，无需虚表，性能更高，但无法实现运行时的动态类型切换。

方案3：特定类型虚函数+模板转发

如果只需要支持有限的几种类型，可以在基类为每种类型定义虚函数，模板函数作为转发层。

#include <iostream>
#include <memory>
#include <string>

class Person {
protected:
    std::string _first_name;
    std::string _last_name;

public:
    Person(std::string first_name, std::string last_name)
        : _first_name(first_name), _last_name(last_name) {}

    const std::string& first_name() const { return _first_name; }
    const std::string& last_name() const { return _last_name; }
};

class HumanPrinterBase {
public:
    virtual ~HumanPrinterBase() = default;
    
    // 模板函数作为统一入口，转发给对应的虚函数实现
    template <typename T>
    void print(const T& person) const {
        print_impl(person);
    }

protected:
    // 针对Person类型的虚函数
    virtual void print_impl(const Person& person) const = 0;
    // 如需支持其他类型，添加对应的虚函数
    // virtual void print_impl(const OtherType&) const = 0;
};

class HumanFirstNamePrinter : public HumanPrinterBase {
protected:
    void print_impl(const Person& person) const override {
        std::cout << person.first_name() << std::endl;
    }
};

int main() {
    Person person("John", "Doe");

    std::unique_ptr<HumanPrinterBase> hp = std::make_unique<HumanFirstNamePrinter>();
    hp->print(person); // 输出 "John"

    return 0;
}

原理：模板函数print作为对外的统一接口，内部调用针对具体类型的虚函数print_impl，子类重写对应的print_impl实现自定义逻辑，兼顾了模板的通用性和虚函数的动态多态。

内容的提问来源于stack exchange，提问作者duncan