在模板派生类中禁用方法覆盖

Question

是否可以在派生类中禁用Foo() 覆盖（通过std::enable_if 或一些增强魔法），以防T 不是特定类型，而不必为@ 编写模板特化987654323@?

加分项：如果 T 没有定义某个方法，是否可以禁用覆盖？

这是我的 SSCCE：

#include <iostream>
#include <string>

class Base
{
public:
    virtual std::string Foo()
    {
        return "Base";
    }
};

template <typename T>
class Derived : public Base
{
public:
    virtual std::string Foo() override
    {
        return "Derived";
    }
};

int main()
{
    Derived<int> testInt;
    std::cout << testInt.Foo() << std::endl;

    Derived<float> testFloat;
    std::cout << testFloat.Foo() << std::endl;//I would like this to print 'Base'
}

更新：

感谢您提供出色的解决方案，但我无法使它们适应我的真实代码。以下示例应该更好地了解我想要实现的目标：

#include <iostream>
#include <string>

class Object
{
public:
    void Test()
    {
        std::cout << "Test" << std::endl;
    }
};

class EmptyObject
{
};

class Base
{
public:
    virtual std::string Foo()
    {
        return "Base";
    }
};

template <typename T>
class Derived : public Base
{
public:
    virtual std::string Foo() override
    {
        m_object.Test();
        return "Derived";
    }

private:
    T m_object;
};

int main()
{
    Derived<Object> testObject;
    std::cout << testObject.Foo() << std::endl;

    Derived<EmptyObject> testEmpty;
    std::cout << testEmpty.Foo() << std::endl;
}

Answer 1

我将通过创建两个函数来做到这一点，Derived::Foo 可以根据 T = float 是否有条件地委托给它们。一个将包含真正的Derived::Foo 实现，而另一个将调用Base::Foo。

template <typename T>
class Derived : public Base
{
public:
    virtual std::string Foo() override
    {
        return do_Foo(std::is_same<T, float>{});
    }

private:
    std::string do_Foo(std::false_type)
    {
        return "Derived";
    }
    std::string do_Foo(std::true_type)
    {
        return Base::Foo();
    }
};

Live demo

---

看来您真正想要做的是仅当T 定义了某个成员函数时才调用Derived<T>::Foo() 实现，否则应调用Base::Foo()。这可以使用表达式 SFINAE 来完成。

template <typename T>
class Derived : public Base
{
public:
    std::string Foo() override
    {
        return do_Foo(true);
    }
private:
    template<typename U = T>
    auto do_Foo(bool)
        -> decltype(std::declval<U>().test(), void(), std::string())
    {
        return "Derived";
    }
    std::string do_Foo(int)
    {
        return Base::Foo();
    }
};

Live demo

在上面的代码中，如果T 类型没有定义名为test() 的成员函数，则do_Foo(bool) 成员函数模板将不可行。另一方面，如果T::test() 确实存在，则将选择do_Foo(bool)，因为与do_Foo(int) 相比，Foo 传递给do_Foo 的布尔值使其更匹配。

有关尾随返回类型中 decltype 表达式的详细说明，请参见 here。

Answer 2

您可以直接对方法进行模板特化，而不是模板特化类：(https://ideone.com/gYwt5r)

template<> std::string Derived<float>::Foo() { return Base::Foo(); }

而且我只看到一个类的模板专门化，通过将final 添加到虚拟方法来禁用未来覆盖取决于T。

Answer 3

如果您需要在编译时限制某种类型，可以使用std::enable_if和std::is_same：

typename std::enable_if<std::is_same<T, float>::value, std::string>::type 
virtual Foo() override
{
    return "Derived";
}

或者，如果模板类型不是您要查找的类型，您可以轻松地将调用重定向到 Base 方法，仍然使用 std::is_same：

virtual std::string Foo() override
{
    return std::is_same<T, float>::value ? Base::Foo() : "Derived";
}

---

至于 Bonus，你可以从这个SO answer 获得 trait，这里用decltype 改编，用于方法bar()：

template <typename T>
class has_bar
{
    typedef char one;
    typedef long two;

    template <typename C> static one test(decltype(&C::bar) ) ;
    template <typename C> static two test(...);

public:
    enum { value = sizeof(test<T>(0)) == sizeof(char) };
};

限制是您不能对参数或返回类型施加约束。

virtual std::string Foo() override
{
    return has_bar<T>::value ? "Derived" : Base::Foo() ;
}

注意：

您也可以在我的第一个示例中将has_bar 与enable_if 一起使用，以在编译时禁用它。

Answer 4

您可以在层次结构中添加一个中间类：

class Base
{
public:
    virtual std::string Foo()
    {
        return "Base";
    }
};

template <typename T>
class Intermediate : public Base
{
    // common operations with m_object

protected: // not private!
    T m_object;
};

template <typename T, typename = bool>
class Derived : public Intermediate<T> {};

template <typename T>
class Derived<T, decltype(std::declval<T>().Test(), void(), true)>
    : public Intermediate<T>
{
public:
    virtual std::string Foo() override
    {
        this->m_object.Test(); // this-> is necessary here!
        return "Derived";
    }
};

完整的示例使用clang 3.4 和g++ 4.8.2 编译成功。