模板的特化与偏特化

最新推荐文章于 2025-03-15 17:37:20 发布

转载最新推荐文章于 2025-03-15 17:37:20 发布 · 63 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/c007136/archive/2012/05/31/2529073.html

本文详细解释了类模板和函数模板的特化概念，包括模板特化的多种形式，如指针、引用、特定类型等特化，以及特化在实际编程中的应用。通过实例展示了特化如何增强代码的灵活性和效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

实话实说，模板用得特别少，语法上的使用都相当生疏。

#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;
}

转载于:https://www.cnblogs.com/c007136/archive/2012/05/31/2529073.html