模板的特化与偏特化

模板的特化与偏特化

#include <iostream>
using namespace std;
#include <string>
#include <vector>

// 一个简单的加法模板
template<class T>
class Addition
{
public:
    T fun( T a, T b )
    {
        return ( a + b );
    }
};

/*
** 特化1
** 类模板特化（specialization）
** 特化之前需要有类模板的声明
*/
template<>
class Addition<char *>
{
public:
    /*
    ** 对每个函数和变量进行特化
    ** 当然这里只有一个函数，哈
    */
    char * fun( char * a, char * b )
    {
        /*
        ** OMG，正式的代码可不能这样写
        ** 这儿只是个例子，将就，将就
        */
        strcat_s( a, 11, b );
        return a;
    }
};

/*
** 特化2
** 特化为引用，指针类型
** 这样的特化其实是一种“偏特化”
** 偏特化，半特化，局部特化，部分特化……翻译五花八门
** 还是记住英文比较好：partial specialization
** 在编码时，总纠结着是指针好呢，还是引用好呢，要加const乎？
** 有了这样的特化，确实方便甚多。
*/
template<class T>
class Addition<T &>
{
public:
    T & fun( T & a, T & b )
    {
        a = a + b;
        return a;
    }
};

/*
** 特化3
** 还可以这样特化
*/
template<class T>
class Addition< vector<T> >
{
public:
    vector<T> & fun( vector<T> & a, vector<T> & b )
    {
        /*
        ** 假想着两个vector大小一样
        */
        for ( int i = 0; i < (int)a.size(); ++i )
        {
            a[i] += b[i];
        }
        return a;
    }
};

int main()
{
    Addition<int> A;
    cout << A.fun( 10, 20 ) << endl;

    // 将特化1的代码注释会怎么样？
    char str1[11] = "aaaaa";
    char str2[] = "BBBBB";
    Addition<char *> B;
    cout << B.fun( str1, str2 ) << endl;

    // 将特化2的代码注释会怎么样？
    string cs1 = "sssss";
    string cs2 = "ddddd";
    Addition<string &> C;
    cout << C.fun( cs1, cs2 ) << endl;

    // 特化3的例子
    vector<int> v1;
    v1.push_back( 10 );
    v1.push_back( 20 );

    vector<int> v2;
    v2.push_back( 100 );
    v2.push_back( 200 );

    Addition< vector<int> > D;
    D.fun( v1, v2 );

    for ( int i = 0; i < (int)v1.size(); ++i )
    {
        cout << v1[i] << " ";
    }
    cout << endl;


    return 0;
}

 

    甚为有意思的是这样的一个语法：

template<class T1, class T2> 
class A 
{ 
}

/*
** 注意是template<class T1>
** 而不是template<class T1, class T2> 
*/
template<class T1> 
class A<T1, int> 
{ 
}

    讲完类模板的特化，有必要讲讲函数模板的特化。函数模板与类模板的一个区别是：函数模板无法偏特化，只能重载。

#include <iostream>
using namespace std;
#include <string>

// 函数模板
template<class T>
T fun( T a, T b )
{
    return a + b;
}

// 全特化
template<>
string fun( string a, string b )
{
    a = a + b;
    return a;
}

// 函数重载，无法偏特化
template< class T1 >
T1 & fun2( T1 & a, T1 & b )
{
    a = a + b;
    return a;
}

int main()
{
    cout << fun( 10, 20 ) << endl;

    string str1 = "aaa";
    string str2 = "BBB";
    cout << fun( str1, str2 ) << endl;

    cout << fun2( str1, str2 ) << endl;

    return 0;
}