C++11 使用模板化返回类型实例化虚拟成员函数

我有一个基类（我想用它来模拟接口）

模板
阶级基础
{
公众：
虚拟SomeTemplatedClass GetTheObject（）=0；
}

显然是一个派生类

template<typename TType>
class Derived : public Base<TType>
{
public:
    virtual SomeTemplatedClass<TType> GetTheObject() = 0;
}

模板
派生类：公共基
{
公众：
虚拟SomeTemplatedClass GetTheObject（）=0；
}

但是对于某些特定类型，我打算专门化“GetTheObject”

template<> 
SomeTemplatedClass<int> Derived<int>::GetTheObject()
{
    return 5;
}

模板
SomeTemplatedClass派生：：GetTheObject（）
{
返回5；
}

Visual Studio 2015抱怨在我尝试使用时无法实例化抽象类

Derived<int>

派生

甚至为模板版本提供抛出行为

class Derived : public Base<TType>
{
public:
    virtual SomeTemplatedClass<TType> GetTheObject() override
    {
        throw <something>;
    }
}

派生类：公共基
{
公众：
虚拟SomeTemplatedClass GetTheObject（）重写
{
投掷；
}
}

让一切都编译。 所以我的问题是：当我有一个特定的并且是唯一需要的行为时，为什么我需要提供一个泛型行为？

您不需要实现泛型GetTheObject，但需要将其声明为非纯行为。否则，您的类是抽象的

template<typename TType>
class Derived : public Base<TType>
{
public:
     virtual SomeTemplatedClass<TType> GetTheObject();
}

模板也不例外

template <int> class A { virtual void f() = 0; }; // A is abstract
template <int k> void A<k>::f() {} // A is still abstract

模板类A{virtual void f（）=0；}；//A是抽象的
模板void A:：f（）{}//A仍然是抽象的

功能专业化不会改变任何东西

template <int> class A { virtual void f() = 0; }; // A is abstract
template <int k> void A<k>::f() {} // A is still abstract
template <> void A<42>::f() {} // srsly are you kidding?

模板类A{virtual void f（）=0；}；//A是抽象的
模板void A:：f（）{}//A仍然是抽象的
模板无效A:：f（）{}//srly你在开玩笑吗？

---

如果您希望泛型案例是抽象的，而专门化案例是具体的，那么您需要专门化整个类，而不仅仅是纯粹的函数实现。

但是如果这是唯一的函数，它不应该工作吗？或者你的意思是我需要专门化整个类，而不仅仅是这个成员？是的，整个类，我想是我写的。从

派生的
中的
GetTheObject（）
声明中删除
=0
说明符。这迫使函数是纯虚拟的。定义函数不会改变这一点。
template <int> class A { virtual void f() = 0; }; // A is abstract
template <int k> void A<k>::f() {} // A is still abstract

template <int> class A { virtual void f() = 0; }; // A is abstract
template <int k> void A<k>::f() {} // A is still abstract
template <> void A<42>::f() {} // srsly are you kidding?