模板类派生类虚方法重写的二义性问题求解

问题背景 #

需要实现一个模板基类，其中包含两个重载的纯虚方法foo，供派生类实现，分别处理两种场景：

• 输入输出均为模板参数类型T
• 第一个输入为bool，输出为bool类型的容器

当模板参数T=bool时，调用foo会出现重载二义性，导致编译失败。原代码及编译错误如下：

原代码 #

#include <iostream>
#include <vector>

template <template <typename> typename container_t, typename T>
class BaseClass {
public:
    virtual container_t<T> foo(const T& value1, const T& value2) const = 0;
    virtual container_t<bool> foo(bool value1, const T& value2) const = 0;

    container_t<T> bar_t() const {
        return foo(T(0), T(0));
    }
    container_t<bool> bar_bool() const {
        return foo(false, T(0));
    }
};

template <typename T>
class DerivedClass : public BaseClass<std::vector, T> {
public:
    using BaseClass<std::vector, T>::bar_t;
    using BaseClass<std::vector, T>::bar_bool;

    DerivedClass() {}

    std::vector<T> foo(const T& value1, const T& value2) const override {
        return std::vector<T>(8, value1);
    }

    std::vector<bool> foo(bool value1, const T& value2) const override {
        return std::vector<bool>(8, value1);
    }
};

int main() {
    DerivedClass<int> int_instance;
    std::cout << int_instance.bar_t().size() << std::endl;
    std::cout << int_instance.bar_bool().size() << std::endl;

    DerivedClass<bool> bool_instance;
    std::cout << bool_instance.bar_t().size() << std::endl;
    std::cout << bool_instance.bar_bool().size() << std::endl;

    return 0;
}

编译错误 #

1>main.cpp
1>main.cpp(15,1): error C2668: 'BaseClass<std::vector,T>::foo': ambiguous call to overloaded function
1>        with
1>        [
1>            T=bool
1>        ]
1>main.cpp(9,31): message : could be 'std::vector<bool,std::allocator<bool>> BaseClass<std::vector,T>::foo(bool,const T &) const'
1>        with
1>        [
1>            T=bool
1>        ]
1>main.cpp(8,28): message : or 'std::vector<bool,std::allocator<bool>> BaseClass<std::vector,T>::foo(const T &,const T &) const'
1>        with
1>        [
1>            T=bool
1>        ]
1>main.cpp(15,1): message : while trying to match the argument list '(bool, T)'
1>        with
1>        [
1>            T=bool
1>        ]
1>main.cpp(14): message : while compiling class template member function 'std::vector<bool,std::allocator<bool>> BaseClass<std::vector,T>::bar_bool(void) const'
1>        with
1>        [
1>            T=bool
1>        ]
1>main.cpp(45): message : see reference to function template instantiation 'std::vector<bool,std::allocator<bool>> BaseClass<std::vector,T>::bar_bool(void) const' being compiled
1>        with
1>        [
1>            T=bool
1>        ]
1>main.cpp(20): message : see reference to class template instantiation 'BaseClass<std::vector,T>' being compiled
1>        with
1>        [
1>            T=bool
1>        ]
1>main.cpp(43): message : see reference to class template instantiation 'DerivedClass<bool>' being compiled

错误原因 #

当T=bool时，bar_bool方法中调用foo(false, T(0))的参数列表变为(bool, bool)。此时两个重载的foo方法参数类型分别为：

1. (const bool&, const bool&)
2. (bool, const bool&)

编译器无法区分这两个重载——第一个参数false既可以匹配bool，也可以转换为const bool&；第二个参数bool(0)同样可以匹配const bool&。因此出现二义性，导致编译失败。

解决方案 #

方法1：标签分发（Tag Dispatch） #

通过添加不同类型的"标签"参数，从根本上区分两个重载的foo方法，避免参数类型重叠导致的二义性。

修改后的代码如下：

#include <iostream>
#include <vector>

// 定义标签结构体，用于区分重载
struct FooTagT {};
struct FooTagBool {};

template <template <typename> typename container_t, typename T>
class BaseClass {
public:
    // 添加标签参数，明确区分两个重载
    virtual container_t<T> foo(FooTagT, const T& value1, const T& value2) const = 0;
    virtual container_t<bool> foo(FooTagBool, bool value1, const T& value2) const = 0;

    container_t<T> bar_t() const {
        // 传递对应标签调用目标重载
        return foo(FooTagT{}, T(0), T(0));
    }
    container_t<bool> bar_bool() const {
        // 传递对应标签调用目标重载
        return foo(FooTagBool{}, false, T(0));
    }
};

template <typename T>
class DerivedClass : public BaseClass<std::vector, T> {
public:
    using BaseClass<std::vector, T>::bar_t;
    using BaseClass<std::vector, T>::bar_bool;

    DerivedClass() {}

    std::vector<T> foo(FooTagT, const T& value1, const T& value2) const override {
        return std::vector<T>(8, value1);
    }

    std::vector<bool> foo(FooTagBool, bool value1, const T& value2) const override {
        return std::vector<bool>(8, value1);
    }
};

int main() {
    DerivedClass<int> int_instance;
    std::cout << int_instance.bar_t().size() << std::endl;
    std::cout << int_instance.bar_bool().size() << std::endl;

    DerivedClass<bool> bool_instance;
    std::cout << bool_instance.bar_t().size() << std::endl;
    std::cout << bool_instance.bar_bool().size() << std::endl;

    return 0;
}

方法2：显式指定函数指针类型 #

在调用foo时，通过强制转换函数指针的类型，明确告诉编译器要调用哪个重载：

修改BaseClass中的bar_bool方法：

container_t<bool> bar_bool() const {
    // 显式指定要调用的重载函数指针类型
    using FooBoolFunc = container_t<bool>(BaseClass::*)(bool, const T&) const;
    return (this->*static_cast<FooBoolFunc>(&BaseClass::foo))(false, T(0));
}

这种方法不需要修改foo的签名，但代码可读性稍差，不如标签分发直观。

说明 #

标签分发是更优雅的解决方案，它通过类型系统明确区分不同的重载逻辑，避免了后续可能出现的类似问题，同时保持代码的可读性和扩展性。

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