c++ 模板详解

Posted 2023-06-09 孙建钊

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了c++ 模板详解相关的知识，希望对你有一定的参考价值。

模板就是将类型进行参数化

函数模板

//函数模板的定义格式
template<class 形参名,class 形参名...>
返回值类型 函数名(参数列表)
    函数体;

模板形参不能为空，并且函数模板中每一个类型参数在函数参数表中至少使用一次，只有这样才能推断出具体的类型

template <class T>
T Add(T x1, T x2)
    return x1+x2;


int main()
    cout<<Add(2,3)<<endl;//5
    cout<<Add(3.2,1.4)<<endl;//4.6
    return 0;

函数模板实例化

不能直接使用函数模板实现具体操作，必须对模板进行实例化，即将模板参数实例化，就是用具体的类型参数去替换函数模板中的模板参数，生成一个确定的具体类型的真正函数，才能实现运算操作
实例化方式
- 隐式实例化：根据具体的函数调用形式，推演出模板参数类型
- 显式实例化：通过显式声明形式指定模板参数类型
隐式实例化
- 上述代码中调用Add(2,3)的过程
- 编译器根据传入的实参2和3推断出模型形参类型是int
- 会将函数模板实例化出一个int类型的函数
- ```
int Add(int x1,int x2)
    return x1+x2;
```
- 编译器生成具体类型函数的过程称为实例化，生成的函数称为模板函数
- 生成int类型的函数后，再将2和3传入进行计算
- 当调用Add(3.2,1.4)又会生成一个float的函数
- 每次调用都会根据不同的类型实例化出不同类型的函数，所以最终可执行程序的大小和重载方式相比并不会减少，只是提高了程序员对代码的复用
- 问题：隐式实例化不能为同一个模板形参指定两种不同的类型，例如Add(2,3.2)，此时编译器会报错，因为编译器不能推断出T的类型

显式实例化

cout<<Add<int>(2,3.2)<<endl;//5  cout << Add<int>(2, static_cast<int>(3.2)) << endl;最好的方式是进行一个显式转换
cout<<Add<float>(3,2)<<endl;//5

函数模板也可以进行重载

template <class T>
T Add(T x1, T x2)
    return x1+x2;


template <class T>
T Add(T x1, T x2, T x3)
    return x1 + x2 + x3;


int main()
    cout<<Add(2,3)<<endl;//5
    cout<<Add(3.2,1.4)<<endl;//4.6
    cout<<Add<int>(2,3.2)<<endl;//5  cout << Add<int>(2, static_cast<int>(3.2)) << endl;最好的方式是进行一个显式转换
    cout<<Add<float>(3,2)<<endl;//5
    cout<<Add(1,2,3)<<endl;//6
    return 0;

当模板函数和自己写的Add具有具体的int类型的函数而言，此时如果传入的参数是int则会调用具体化的int函数，即C++编译器优先考虑普通函数

类模板

//类模板定义格式
template <class 形参名, class 形参名>
class 类名

由于类模板包含类型参数，因此也称为参数化类，如果说类是对象的抽象，对象是类的实例，则类模板是类的抽象，类是类模板的实例

template <class T1, class T2>
class Add
private:
    T1 x1;
    T2 x2;
public:
    Add(T1 x1, T2 x2):x1(x1),x2(x2)
    T1 get()
        return x1 + x2;
    
;

int main()
    Add<double,int> a(1.2,2);
    cout<<a.get()<<endl;//3.2
    return 0;

类模板实例化

使用类模板创建对象时，必须指明具体的数据类型，这和函数模板不一样，这是因为函数模板中一定会传递实参，可以根据实参推断出所有的数据类型，但是类模板中，构造函数时不一定会同时传递T1 T2,所以不一定会百分百推断出数据类型，因此需要显式传递
可以使用对象指针进行实例化Add<double,int> *p1 = new Add<double,int>(1.2,2);但是需要注意两边的模板参数需要相同

template <class T>
class A
public:
    T Add(T t1, T t2)
        return t1 + t2;
    
;

int main()
    A<int> a;
    cout<<a.Add(1.2,2)<<endl;

在函数模板中，不能进行自动转换，这是因为函数模板中需要根据实参来推断数据类型，而在类模板中，因为已经显式指定了int,所以会创建一个int的类，然后可以自动转换
在类模板外定义成员函数,格式

template <模板形参表>
函数返回类型 类名<模板形参名>::函数名(参数列表)

template <class T>
class A
public:
    T Add(T t1, T t2)
        return t1 + t2;
    
    T sub(T t1, T t2);
;

template<class T>
T A<T>::sub(T t1, T t2)

类模板在实例化时，带有模板形参的成员函数并不对着自动被实例化，只有当它被调用或取地址时才会被实例化。因为不被调用的时候，你根本不知道模板形参表中的数据类型是什么，想实例化就需要把所有的数据类型组合都实例化一遍，这显然是不可接受的

类模板与友元函数

非模板友元函数

在类模板中声明一个普通的友元函数，该函数时类模板所有实例的友元函数，可以访问全局对象，也可以使用全局指针访问非全局对象，可以创建自己的对象，也可以访问独立于对象模板的静态数据成员

#include <iostream>

using namespace std;

template <class T>
class A
private:
    T x1,x2;
    static T x3;
public:
    A(T x1,T x2):x1(x1),x2(x2)
    friend void func();
;
//这里进行特化赋值
template<>
int A<int>::x3 = 10;

template<>
double A<double>::x3 = 100;


void func()
    cout<<A<int>::x3<<endl;//10
    cout<<A<double>::x3<<endl;//100
    A<char> a(\'A\',\'a\');
    cout<<a.x1<<" "<<a.x2<<endl;//A a


int main()
    func();
    return 0;

如果func()中有一个特定类型的参数，则只能访问特定类型的数据

#include <iostream>

using namespace std;

template <class T>
class A
private:
    T x1,x2;
    static T x3;
public:
    A(T x1,T x2):x1(x1),x2(x2)
    friend void func(A<T> a1);
;
//这里进行特化赋值
template<>
int A<int>::x3 = 10;

template<>
double A<double>::x3 = 100;


void func(A<int> b)
    cout<<A<int>::x3<<endl;//10
//    cout<<A<double>::x3<<endl;//100此时就不可以访问double类型了
    A<char> a(\'A\',\'a\');//可以正常创建别的类型的对象，因为这个创建是在任何地方都可以
//    cout<<a.x1<<" "<<a.x2<<endl;//A a 这里也不可以访问了，因为不是char类型的友元函数


int main()
    func(A<int>(1,2));
    return 0;

约束模板友元函数

这样的友元函数本身就是一个函数模板，但其实例化类型取决于类被实例化时的类型（被约束），每个类的实例化都会产生一个与之匹配的具体化的友元函数

#include <iostream>

using namespace std;

template <class T>
void func(T x1, T x2);

template <class T>
class A
private:
    T x1,x2;
public:
    A(T x1, T x2):x1(x1),x2(x2)
    friend void func<T>(T x1,T x2);//这里也可以写成friend void func<>(T x1, T x2);因为可以推断出T的类型来
;

template <class T>
void func(T x1,T x2)
    A<T> a1(x1,x2);
    cout<<a1.x1<<" "<<a1.x2<<endl;
    cout<<sizeof(A<T>)<<endl;


int main()
    func(1,2);//1 2      8
    func<double>(1,2);// 1 2     16

非约束模板友元函数

在类内部声明友元函数模板，友元函数的模板形参与类模板的形参没有关系，此时友元函数为类模板的非约束模板友元函数

#include <iostream>

using namespace std;

template <class T>
void func(T x1, T x2);

template <class T>
class A
private:
    T x1,x2;
public:
    A(T x1, T x2):x1(x1),x2(x2)

    template<class U,class V>
    friend void func(U u, V v);
;

template <class U, class V>
void func(U u, V v)
    cout<<u.x1<<endl;
    cout<<v.x1<<endl;


int main()
    A<int> a1(1,2);
    A<double> a2(2.3,4.5);
    func(a1,a2);//1  2.3

模板的特化

模板特化：在原模板类的基础上，针对特殊类型所进行的特殊化的实现，分为函数模板特化和类模板特化

类模板特化

类模板的特化分为全特化和偏特化
- 全特化：对类模板参数列表的类型全部都确定
- 偏特化：对类模板的参数列表中的部分参数进行确定化。分为部分特化和参数进一步限制

#include <iostream>

using namespace std;


template <class A, class B>
class C
public:
    C()
        cout<<"template<class A, class B> class C"<<endl;
    
;

//全特化
template <>
class C<int,double>
public:
    C()
        cout<<"template<> class C<int,double>"<<endl;
    
;

//偏特化
template <class A>
class C<A,int>
public:
    C()
        cout<<"template<class A> class C<A,int>"<<endl;
    
;

//偏特化不一定指的是特化部分参数，而是对模板类型的进一步限制
template <class A, class B>
class C<A*,B*>
public:
    C()
        cout<<"template<class A,class B> class C<A*,B*>"<<endl;
    
;

int main()
    C<int,int> c1;//template<class A> class C<A,int>
    C<double,double> c2;//template<class A, class B> class C
    C<int,double> c3;//template<> class C<int,double>
    C<int*,double> c4;//template<class A, class B> class C
    C<int*,double*> c5;//template<class A,class B> class C<A*,B*>

函数模板特化

函数模板只支持全特化，不支持偏特化

#include <iostream>

using namespace std;

template <class T1,class T2>
int compare(const T1& v1, const T2& v2)
    cout<<"template <class T>"<<endl;
    return 0;


template <>
int compare<int,int>(const int& v1, const int& v2)
    cout<<"template<>"<<endl;
    return 0;


//不支持偏特化
//template <class T1>
//int compare<T1,int>(const T1& v1, const int& v2)
//    cout<<"template<class T1>"<<endl;
//    return 0;
//

int main()
    compare(1,1);//template<>
    compare(1.2,2.3);//template <class T>

但是函数偏特化的功能也不是不能实现，并且有两种方式进行实现

//方式1
//将第二个参数为int的情况排除掉
//然后再写一个专门的一个参数的模板，这样可以实现函数模板的功能
#include <iostream>
#include <type_traits>

template <typename A, typename B>
typename std::enable_if<!std::is_same<B, int>::value>::type f(A a, B b) 
    std::cout << "template <typename A, typename B>" << std::endl;


template <typename A>
void f(A a, int b) 
    std::cout << "template <typename A>" << std::endl;


int main() 
    f(10, 5);  // template <typename A>
    f(10, 5.5);  // template <typename A, typename B>
    return 0;

//方式2
//使用结构体进行封装
#include <iostream>

using namespace std;

template<class A,class B>
struct C
    C(A a,B b)
    void operator()() 
        std::cout << "template<class A,class B>" << std::endl;
    
;
template <typename A>
struct C<A,int>
    C(A a,int b)
    void operator()() 
        std::cout << "template <typename A>" << std::endl;
    
;

int main()
    C<int,int>(10,5)();//template <typename A>
    C<int,double>(10,5.5)();//template<class A,class B>
    return 0;

C++模板详解

C++模板

　　模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。

　　模板是一种对类型进行参数化的工具；

　　通常有两种形式：函数模板和类模板；

　　函数模板针对仅参数类型不同的函数；

　　类模板针对仅数据成员和成员函数类型不同的类。

　　使用模板的目的就是能够让程序员编写与类型无关的代码。比如编写了一个交换两个整型int 类型的swap函数，这个函数就只能实现int 型，对double，字符这些类型无法实现，要实现这些类型的交换就要重新编写另一个swap函数。使用模板的目的就是要让这程序的实现与类型无关，比如一个swap模板函数，即可以实现int 型，又可以实现double型的交换。模板可以应用于函数和类。下面分别介绍。

　　注意：模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。

函数模板

　　1.注意：对于函数模板而言不存在 h(int,int) 这样的调用，不能在函数调用的参数中指定模板形参的类型，对函数模板的调用应使用实参推演来进行，即只能进行 h(2,3) 这样的调用，或者int a, b; h(a,b)。

　　函数模板的示例演示将在下文中涉及！

类模板

　　2、类模板对象的创建：比如一个模板类A，则使用类模板创建对象的方法为A<int> m;在类A后面跟上一个<>尖括号并在里面填上相应的类型，这样的话类A中凡是用到模板形参的地方都会被int 所代替。当类模板有两个模板形参时创建对象的方法为A<int, double> m;类型之间用逗号隔开。

　　3、对于类模板，模板形参的类型必须在类名后的尖括号中明确指定。比如A<2> m;用这种方法把模板形参设置为int是错误的（编译错误：error C2079: ‘a‘ uses undefined class ‘A<int>‘），类模板形参不存在实参推演的问题。也就是说不能把整型值2推演为int 型传递给模板形参。要把类模板形参调置为int 型必须这样指定A<int> m。

　　4、在类模板外部定义成员函数的方法为：

　　　　template<模板形参列表> 函数返回类型类名<模板形参名>::函数名(参数列表){函数体}，

比如有两个模板形参T1，T2的类A中含有一个void h()函数，则定义该函数的语法为：

　　　　template<class T1,class T2> void A<T1,T2>::h(){}。

注意：当在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致。

　　5、再次提醒注意：模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。

模板形参

　　1.类型形参

- 　　类型模板形参：类型形参由关见字class或typename后接说明符构成，如template<class T> void h(T a){};其中T就是一个类型形参，类型形参的名字由用户自已确定。
- 　　（针对函数模板)不能为同一个类型模板形参指定不同的类型：template<class T>void h(T a, T b){}，语句调用h(2, 3.2)将出错，前一个是int类型，后一个是double
- 　　（针对类模板）：A<int> a，比如template<class T>T g(T a, T b){}，语句调用a.g(2, 3.2)在编译时不会出错，但会有警告。
- 　　示例：
```
#include<iostream>
using namespace std;
template <class T> class A{
public :
    T g(T a,T b);
    A();
};

template <class T> A<T>::A(){};

template <class T> T A<T>::g(T a,T b){
    return a+b;
}
int main()
{
    A <int> a;
    cout<<a.g(2,3.2)<<endl;
}
//此外，这里的输出结果是5.
```
非类型形参

　　2.1 、非类型模板形参：模板的非类型形参也就是内置类型形参，如template<class T, int a> class B{};其中int a就是非类型的模板形参。
　　2.2、非类型形参在模板定义的内部是常量值，也就是说非类型形参在模板的内部是常量。

　　2.3、非类型模板的形参只能是整型，指针和引用，像double，String, String **这样的类型是不允许的。但是double &，double *，对象的引用或指针是正确的。

　　2.4、 调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果。

　　2.5 、注意：任何局部对象，局部变量，局部对象的地址，局部变量的地址都不是一个常量表达式，都不能用作非类型模板形参的实参。全局指针类型，全局变量，全局对象也不是一个常量表达式，不能用作非类型模板形参的实参。

　　2.6、 全局变量的地址或引用，全局对象的地址或引用const类型变量是常量表达式，可以用作非类型模板形参的实参。

　　2.7 、sizeof表达式的结果是一个常量表达式，也能用作非类型模板形参的实参。

　　2.8 、当模板的形参是整型时调用该模板时的实参必须是整型的，且在编译期间是常量，比如template <class T, int a> class A{};如果有int b，这时A<int, b> m;将出错，因为b不是常量，如果const int b，这时A<int, b> m;就是正确的，因为这时b是常量。

　　2.9 、非类型形参一般不应用于函数模板中，比如有函数模板template<class T, int a> void h(T b){}，若使用h(2)调用会出现无法为非类型形参a推演出参数的错误，对这种模板函数可以用显示模板实参来解决，如用h<int, 3>(2)这样就把非类型形参a设置为整数3。显示模板实参在后面介绍。

　　2.10、非类型模板形参的形参和实参间所允许的转换
　　　　　　1、允许从数组到指针，从函数到指针的转换。如：template <int *a> class A{}; int b[1]; A<b> m;即数组到指针的转换
　　　　　　2、const修饰符的转换。如：template<const int *a> class A{}; int b; A<&b> m; 即从int *到const int *的转换。
　　　　　　3、提升转换。如：template<int a> class A{}; const short b=2; A<b> m; 即从short到int 的提升转换
　　　　　　4、整值转换。如：template<unsigned int a> class A{}; A<3> m; 即从int 到unsigned int的转换。
　　　　　　5、常规转换。

　　示例实现：

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

template <class T ,int MAXSIZE>class Stack{
private :
    T elems[MAXSIZE];//包含元素的数组
    int numElems;//元素的当前总个数
public:
    Stack();
    void push(T const&);
    void pop();
    T top()const;
    bool empty()const{
        return numElems==MAXSIZE;
    }
    bool full()const{
        return numElems==MAXSIZE;
    }
};

template <class T ,int MAXSIZE>
Stack<T,MAXSIZE>::Stack():numElems(0){//初始化不含栈元素
}

template <class T ,int MAXSIZE>
void Stack<T,MAXSIZE>::push(T const& elem){
    if(numElems==MAXSIZE){
//        throw std::out_of_range("Stack<>::push(): stack is full");

    }
    elems[numElems]=elem;//附加元素
    ++numElems;//增加元素的个数
}

template <class T ,int MAXSIZE>
void Stack<T,MAXSIZE>::pop(){
    if(numElems<=0){
//        throw std::out_of_range("Stack<>::pop(): empty stack");

    }
    --numElems;//减少元素的个数
}

template <class T ,int MAXSIZE>
T Stack<T,MAXSIZE>::top()const{
    if (numElems <= 0) {
//         throw std::out_of_range("Stack<>::top(): empty stack");
     }
     return elems[numElems-1];  // 返回最后一个元素
}

int main(){
try{
    Stack <int,20> stack_int_20;
    Stack<int ,40> stack_int_40;
    Stack<std::string,40> stack_string_40;

    stack_int_20.push(7);
    cout<<stack_int_20.top()<<endl;
    stack_int_20.pop();

    stack_string_40.push("付志强");
    cout<<stack_string_40.top()<<endl;
    stack_string_40.pop();
    stack_string_40.pop();
    return 0;
}
    catch(std::exception const& ex) {
      std::cerr << "Exception: " << ex.what() << std::endl;
       return EXIT_FAILURE;  // 退出程序且有ERROR标记
    }
}
//输出结果是7，付志强

示例2实现

 1 #include<iostream>
 2 using namespace std;
 3 
 4 template <typename T> class CompareDemo{
 5 public:
 6     int compare(const T&,const T&);
 7 };
 8 template <typename T>
 9 int CompareDemo<T>::compare(const T&a,const T&b){
10     if((a-b)>0)
11         return 1;
12     else if((a-b)<0)
13         return -1;
14     else
15         return 0;
16 }
17 
18 //改动的版本
19 template <typename T> class CompareDemo02{
20 public:
21     int compare( T&, T&);
22 };
23 template <typename T>
24 int CompareDemo02<T>::compare( T&a, T&b){
25     if((a-b)>0)
26         return 1;
27     else if((a-b)<0)
28         return -1;
29     else
30         return 0;
31 }
32 
33 //示例三
34 template <typename T>
35 const T& max(const T &a,const T&b){
36     return a>b?a:b;
37 }
38 
39 int main(){
40     //Demo01
41     CompareDemo<int> cd;
42     //这个因为参数是const，所以必须是常量值传递进去
43     cout<<cd.compare(2,3)<<endl;
44     //输出结果-1；
45 
46     CompareDemo<double> cb;
47     cout<<cb.compare(3.1,3.2)<<endl;
48     //运行结果-1
49 
50     //Demo02
51     CompareDemo02<int >cc;
52     int a=2,b=3;//这个传递进去的必须是常量值，但是a，b都不是const，所以必须先赋值
53     cout<<cc.compare(a,b)<<endl;
54 
55     cout<<max(2.1,2.2)<<endl;//模板实参被隐式的推演成double
56     cout<<max<double>(2.1,2.2)<<endl;//显示的指定模板参数
57     cout<<max<int>(2.1,2.2)<<endl;//显示的指定模板参数，会将函数直接转换为int
58 
59 }

四、类模板的默认模板类型形参

　　1、可以为类模板的类型形参提供默认值，但不能为函数模板的类型形参提供默认值。函数模板和类模板都可以为模板的非类型形参提供默认值。

　　2、类模板的类型形参默认值形式为：template<class T1, class T2=int> class A{};为第二个模板类型形参T2提供int型的默认值。

　　3、类模板类型形参默认值和函数的默认参数一样，如果有多个类型形参则从第一个形参设定了默认值之后的所有模板形参都要设定默认值，比如template<class T1=int, class T2>class A{};就是错误的，因为T1给出了默认值，而T2没有设定。

　　4、在类模板的外部定义类中的成员时template 后的形参表应省略默认的形参类型。比如template<class T1, class T2=int> class A{public: void h();}; 定义方法为template<class T1,class T2> void A<T1,T2>::h(){}。

- 　　示例：

以上是关于c++ 模板详解的主要内容，如果未能解决你的问题，请参考以下文章

C++模板详解：泛型编程模板原理非类型模板参数模板特化分离编译