C ++-部分专门化模板类成员函数

Question

I have a pair of template classes and I am attempting to create a specialization for one of my member functions for one of the classes. The general form of what I have is:

template <typename T, int K>
class URLListNode {
    // Some other stuff
    void split( class URLListNode<T,K>*, class URLListNode<T,K> );
}

For the general case I have:

template <typename T, int K>
class URLListNode<T,K>::split( URLListNode<T,K>* node1, URLListNode<T,K>* node2 ){
    // Code here
}

And that works. I am now trying to create a specialization for the case of K=1. Here is what I have so far:

template <typename T>
class URLListNode<T,1>::split( URLListNode<T,1>* n1, URLListNode<T,1>* n2 ) {
    // Code here
}

But when I try to compile, I get the following errors:

In file included from ../src/driver.cpp:34:0:
../src/urllist.h:101:80: error: invalid use of incomplete type ‘class URLListNode<T, 1>’
void URLListNode<T,1>::split( URLListNode<T,1>* node1, URLListNode<T,1>* node2 ) {
                                                                            ^
../src/urllist.h:29:7: error: declaration of ‘class URLListNode<T, 1>’
class URLListNode {
   ^
make: *** [src/driver.o] Error 1

This is on g++-4.8.2

Answer 1

Main two syntax fixes:

• Semicolon at end of class definition.

• Replacing the word class with void for the return type of the function definition.

Main problem, that you can't partially specialize a function.

Partially specializing the original class is not a good solution, because then the other original member declarations have to be inherited in or duplicated in the specialization.

General solution: use a static function member of a class, which can be partially specialized.

#include <iostream>
using namespace std;

template <class T, int K>
class URLListNode {
    // Some other stuff
public:
    void split( URLListNode*, URLListNode* );
};

namespace detail {
    template <class T, int K>
    struct Impl
    {
        typedef URLListNode<T, K> Node;
        static void split( Node& self, Node*, Node* )
        { (void) self; cout << "Generic split" << endl; }
    };

    template <class T>
    struct Impl<T, 1>
    {
        typedef URLListNode<T, 1> Node;
        static void split( Node& self, Node*, Node* )
        { (void) self; cout << "Partially specialized split." << endl; }
    };

}  // namespace detail

template <class T, int K>
void URLListNode<T,K>::split( URLListNode* n1, URLListNode* n2 )
{
    detail::Impl<T, K>::split( *this, n1, n2 );
}

int main()
{
    URLListNode<int, 0>().split( 0, 0 );     // Generic.
    URLListNode<int, 1>().split( 0, 0 );     // Partially specialized.
}

Answer 2

#include <iostream>

using namespace std;

template<class T, int K>
class URLListNode
{
public:
    void split(class URLListNode<T,K>*, class URLListNode<T,K>*)
    {
        cout << "split generic" << endl;
    }
};

template<class T>
class URLListNode<T, 1>
{
public:
    void split(class URLListNode<T, 1>*, class URLListNode<T,1>*)
    {
        cout << "split specific" << endl;
    }
};

int main()
{
    URLListNode<int, 1> x;
    x.split(&x, &x);

    cin.get();
}

Is this what you want?

Answer 3

That does what I want it to do, but is there any way of doing this without creating an entire new template class? I only have a couple of functions out of a fairly complex pair of classes that need to be specialized.

You cannot partially specialize member functions. You must specialize the whole class.

14.5.5.3.1.

The template parameter list of a member of a class template partial specialization shall match the template parameter list of the class template partial specialization. The template argument list of a member of a class template partial specialization shall match the template argument list of the class template partial specialization.