专门研究C++模板中的子类型

Question

我有一个关于C++模板专业化的问题，我希望这里有人能提供帮助。我有一个有3个模板参数类：

template<class A, class B, class C> 
class myClass { 

public: 
    void myFunc(); 
}; 

我想要做的就是写myFunc的几个版本，专门的，比方说，C型，但对于通用类型A和B，所以我不要完全模板函数是这样的：

template<class A, class B, class C> 
void myClass<A, B, C>::myFunc() 
{ 
    // function code here 
} 

，我不希望这样的

void myClass<int, int, int>::myFunc() 
{ 
    // code goes here 
} 

完全专业化的功能相反，我想要做的事，这将是类似于

template<class A, class B> 
void myClass<A, B, int>::myFunc() 
{ 
    // code goes here 
} 

的想法是，如果类C型为int，我会打电话myFunc的（一版），如果类C类是双重的，我会打电话的不同版本在myfunc。我已经尝试了很多不同的模板专业化语法的组合（这里列出了太多），而且似乎没有编译。

有人可能在这里指出我在正确的方向吗？在此先感谢您的帮助。

迈克尔

Answer 1

您可以编写一个函数模板，过载，而工作委托给它：

template<class A, class B, class C> 
class myClass 
{ 
    //resolver doesn't need to define anything in it! 
    template<class> struct resolver {}; //empty, yet powerful! 
public: 
    void myFunc() 
    { 
     doFun(resolver<C>()); 
    } 

    //this is a function template 
    template<typename X> 
    void doFun(const resolver<X> &) 
    { 
     //this function will get executed when C is other than int 
     //so write your code here, for the general case 
    } 

    //this is an overload, not a specialization of the above function template! 
    void doFun(const resolver<int> &) 
    { 
     //this function will get executed when C = int 
     //so write your code here, for the special case when C = int 
    } 
}; 

注意的重要一点：doFun(const resolve<int>&)是一个重载函数，它不是一个专业化函数模板。您不能专门化成员函数模板没有专门化封闭的类模板。

阅读这些文章：

• Template Specialization and Overloading
• Why Not Specialize Function Templates?

Answer 2

在解析式调度为@Nawaz显示恕我直言，是最好的方式。另一种选择是将该功能的实际实现移到类的外部，在其自己的结构中，使其变为静态并部分专用于该结构。在课堂内部，通话。当然，如果它访问的myClass私处，你需要使它friend：

template<class A, class B, class C> 
class myClass; 

template<class A, class B, class C> 
struct myClassFuncs{ 
    typedef myClass<A,B,C> class_type; 

    static void myFunc(class_type* self){ 
    // generic for everything ... 
    } 
}; 

template<class A, class B> 
struct myClassFuncs<A,B,int>{ 
    typedef myClass<A,B,int> class_type; 

    static void myFunc(class_type* self){ 
    // specialized on C == int ... 
    } 
}; 

// and so on ... 

template<class A, class B, class C> 
class myClass{ 
    typedef myClassFuncs<A,B,C> func_holder; 
    friend class func_holder; 
public: 
    void myFunc(){ 
    func_holder::myFunc(this); 
    } 
}; 

虽然这导致了很多的类包装和专业版本的...

另一个想法，这可以说是相当疯狂的，是没有功能的班级，但功能。那些得到专业化，然后叫。这是更详细的，但允许更好地访问你想要专门化的功能。虽然，如果他们想访问私人部分，现在需要让所有人都成为朋友。 ：/

template<class A, class B, class C> 
class myClass; 

template<class A, class B, class C> 
class myClass_myFunc{ 
    typedef myClass<A,B,C> class_type; 
    class_type* const _self; 

public: 
    myClass_myFunc(class_type* self) 
    : _self(self) 
    {} 

    void operator() const{ 
    // generic logic here 
    } 
}; 

template<class A, class B> 
class myClass_myFunc<A,B,int>{ 
    typedef myClass<A,B,int> class_type; 
    class_type* const _self; 

public: 
    myClass_myFunc(class_type* self) 
    : _self(self) 
    {} 

    void operator() const{ 
    // specialized logic here 
    } 
}; 

template<class A, class B, class C> 
class myClass{ 
    friend class myClass_myFunc<A,B,C>; 
public: 
    myClass() 
    : myFunc(this) 
    {} 

    const myClass_myFunc<A,B,C> myFunc; 
};