如何让内部模板类是外部模板类的类型？

Question

我当前的代码看起来像如下：Code here

我有一个模板ClassOuter和嵌套模板ClassInnerBase，其中TypeD可以是任何类型的TypeA, TypeB, TypeC并没有其他的。此外，ClassInnerDerived应继承ClassInnerBase并实施virtual const int Method(int id) = 0;。

template<typename TypeA, typename TypeB, typename TypeC> 
class ClassOuter { 
public: 

    class ClassInnerBase { 
    public: 
     ClassInnerBase(int x) : 
       m_x(x) { 
     } 

     virtual const int Method(int id) = 0; 

    private: 
     int m_x; 
    }; 

    template<typename TypeD> 
    class ClassInnerDerived : public ClassInnerBase { 
    public: 
     ClassInnerDerived<TypeD>(const TypeD &object, int x) : 
       ClassInnerBase(x), m_object(object) { 

     } 

     // Implementation of ClassInnerBase::Method for type float 
     template<> 
     const int ClassInnerDerived<float>::Method(int id){ 
      return GetLookupID(id); 
     } 

     // Implementation of ClassInnerBase::Method for type double 
     template<> 
     const int ClassInnerDerived<double>::Method(int id){ 
      return GetLookupID(id); 
     } 


    private: 
     TypeD m_object; 
    }; 

    void DoSomething(const std::vector<ClassInnerBase> &inner_vec, int id); 

    const int GetLookupID(int id) const{ 
     return lookup[id]; 
    } 

private: 
    int lookup[100]; 
}; 

template<typename TypeA, typename TypeB, typename TypeC> 
void ClassOuter<TypeA, TypeB, TypeC>::DoSomething(const std::vector<ClassInnerBase> &inner_vec, int id){ 
    for(const auto &inner : inner_vec){ 
     inner.Method(id); 
    } 
} 


int main() 
{ 
    std::vector<typename ClassOuter<int, double, float>::ClassInnerBase> class_base_objects; 
    typename ClassOuter<int, double, float>::template ClassInnerDerived<float> class_inner_derived_object(0.2f, 1); 
    class_base_objects.push_back(class_inner_derived_object); 

    typename ClassOuter<int, double, float>::template DoSomething(class_base_objects, 1); 
} 

我最终得到的错误：

g++ -std=c++14 -O2 -Wall -pedantic -pthread main.cpp && ./a.out 
main.cpp:30:18: error: explicit specialization in non-namespace scope 'class ClassOuter<TypeA, TypeB, TypeC>::ClassInnerDerived<TypeD>' 
     template<> 
       ^

我很卡在这里，不知道如何解决这个错误。 此外，是否有任何关于实施的建议/意见/改进？

Answer 1

由于你的编译器说你不能明确（完全）专门化模板类的内部类。你正在做的更糟，因为你试图从内部类中分离出一个单独的方法，这对于非嵌套的模板类来说是不可能的......你可以做的是通过添加额外的模板参数来默认值到你的内部班级，部分专门化整个内部班级。这实际上可以让你测试模板参数是否是使用sfinae机制的给定类型（我在你的例子中测试过，如果内部模板参数是字面上的double或float，但你可以类似地测试它是否是外部模板类型之一还有），例如：

#include <iostream> 
#include <type_traits> 
#include <vector> 

template<typename TypeA, typename TypeB, typename TypeC> 
class ClassOuter { 
public: 

    class ClassInnerBase { 
    public: 
     ClassInnerBase(int x) : 
       m_x(x) { 
     } 

     virtual const int Method(int id) = 0; 

    private: 
     int m_x; 
    }; 

    template<typename TypeD, typename = void> 
    class ClassInnerDerived; 

    template<typename TypeD> 
    class ClassInnerDerived<TypeD, std::enable_if_t<std::is_same<TypeD, float>::value || std::is_same<TypeD, double>::value> >: public ClassInnerBase { 
    public: 
     // Implementation of ClassInnerBase::Method for type float 
     ClassInnerDerived(const TypeD &object, int x) : 
       ClassInnerBase(x), m_object(object) { 
     } 
     const int Method(int id){ 
      return GetLookupID(id); 
     } 
    private: 
     TypeD m_object; 
    }; 

    public: 

    //static void DoSomething(const std::vector<ClassInnerBase> &inner_vec, int id); 

    static const int GetLookupID(int id) { 
     return lookup[id]; 
    } 

private: 
    static int lookup[100]; 
}; 

template<typename TypeA, typename TypeB, typename TypeC> 
int ClassOuter<TypeA, TypeB, TypeC>::lookup[100]; 

/* 
template<typename TypeA, typename TypeB, typename TypeC> 
void ClassOuter<TypeA, TypeB, TypeC>::DoSomething(const std::vector<ClassInnerBase> &inner_vec, int id){ 
    for(const auto &inner : inner_vec){ 
     inner.Method(id); 
    } 
}*/ 


int main() 
{ 
std::vector<typename ClassOuter<int, double, float>::ClassInnerBase *> class_base_objects; 
    //typename ClassOuter<int, double, float>::template ClassInnerDerived<float> class_inner_derived_object(0.2f, 1); 
    class_base_objects.push_back(new ClassOuter<int, double, float>::ClassInnerDerived<float>(0.2f, 1)); //(class_inner_derived_object); 

    //typename ClassOuter<int, double, float>::template DoSomething(class_base_objects, 1); 
} 

上面的代码可能实际上并没有你想什么，但我认为这是一个很好的起点......