C++-模板

已于 2023-08-19 18:31:47 修改
阅读量360 收藏
点赞数
分类专栏： C++ 文章标签： c++ 算法 开发语言
于 2022-08-30 22:27:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/procurar/article/details/126602406
版权

C++提供了模板(template)编程的概念。所谓模板，实际上是建立一个通用函数或类，其类内部的类型和函数的形参类型不具体指定，用一个虚拟的类型来代表。 这种通用的方式称为模板。模板是泛型编程的基础,泛型编程即以一种独立于任何特定类型的方式编写代码。

一、函数模板的使用

1.为什么要有函数模板

比如：实现多个函数用来返回两个数的最大值，要求能支持char类型、int类型、double类型变量。
如果真的用多个函数来进行实现较为繁琐重复，其实一个函数就可以实现，那么就要用到模板。

#include <iostream>
using namespace std;

//template 关键字告诉C++编译器 我要开始泛型编程了,请你不要随意报错
//T - 参数化数据类型
template <typename T>
T Max(T a, T b){
	return a>b ? a:b;
}

/*如果T 使用int 类型调用,相当于调用下面这个函数
int Max(int a, int b)
{
	return a>b ? a:b;
}
*/


void main()
{
	//char a = 'c';
	
	int  x = 1;
	int	 y = 2;
	cout<<"max(1, 2) = "<<Max(x, y)<<endl; //实现参数类型的自动推导
	cout<<"max(1, 2) = "<<Max<int>(x,y)<<endl;//显示类型调用
	//如果参数类型有多个，那么显示类型调用只写一个，后面的会自动推导
	
	float a = 2.0;
	float b = 3.0;
  
	cout<<"max(2.0, 3.0) = "<<Max(a, b)<<endl;

	system("pause");
	return ;
}

2.函数模板语法

所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。 这个通用函数就称为函数模板。凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。

函数模板定义形式

由以下三部分组成： 模板说明 + 函数定义 + 函数模板调用

 template < 类型形式参数表 >
 类型  函数名 (形式参数表)
{
    //语句序列
}

①模板说明

template < 类型形式参数表 >
类型形式参数的形式：
typename T1 , typename T2 , …… , typename Tn
或
class T1 , class T2 , …… , class Tn
(注：typename 和 class 的效果完全等同)
但是多个参数，每定义一个参数就一定要用。

②函数定义

 类型  函数名  (形式参数表)
{
}

注意：模板说明的类属参数必须在函数定义中出现一次
函数参数表中可以使用类属类型参数，也可以使用一般类型参数

③函数模板调用

max(a, b); //显式类型调用
max(a, b); //自动数据类型推导

④模板函数

具体化调用函数模板，编译器会根据类型自动生成对应的模板函数。然后在编译的时候调用生成的对应的模板函数。
在这里插入图片描述

⑤函数模板和函数重载

函数模板和普通函数区别结论：
两者允许并存
函数模板不允许自动类型转化
普通函数能够进行自动类型转换

#include <iostream>
using namespace std;

template <typename T>
void Swap(T &a, T &b){
	T t;
	t = a;
	a = b;
	b = t;
	cout<<"Swap 模板函数被调用了"<<endl;
}

/*
void Swap(char &a, int &b){
	int  t;
	t = a;
	a = b;
	b = t;
	cout<<"Swap 普通函数被调用了"<<endl;
}
*/

void main(void){
	char cNum = 'c';
	int iNum = 65;

	//第一种情况，模板函数和普通函数并存,参数类型和普通重载函数更匹配，调用普通函数
	//Swap(cNum, iNum);

	//第二种情况  不存在普通函数，函数模板会隐式数据类型转换嘛？
	//结论：不提供隐式的数据类型转换,必须是严格的匹配
	//Swap(cNum, iNum);	//报错，不匹配（因为模板类型参数只有一个，说明传入的参数必须要类型一样）

	system("pause");
	return ;
}

函数模板和普通函数在一起，调用规则：
1 函数模板可以像普通函数一样被重载
2 C++编译器优先考虑普通函数
3 如果函数模板可以产生一个更好的匹配，那么选择模板
4 可以通过空模板实参列表的语法限定编译器只通过模板匹配

当两者都匹配，编译器会优先使用普通函数，如果要使用函数模板,则使用<> 类型列表Max<>(a, b);

#include <iostream>

using namespace std;

//第一版
int Max(int a, int b)
{
	cout<<"调用 int Max(int a, int b)"<<endl;
	return a>b ? a:b;
}

template<typename T>
T Max(T a, T b)
{
	cout<<"调用 T Max(T a, T b)"<<endl;
	return a>b ? a:b;
}

template <typename T>
T Max(T a, T b, T c){
	cout<<"调用 T Max(T a, T b, T c)"<<endl;
	return Max(Max(a, b), c);
}

//第二版
int Max1(int a, int b)
{
	cout<<"调用 int Max(int a, int b)"<<endl;
	return a>b ? a:b;
}

template<typename T1, typename T2>
T1 Max1(T1 a, T2 b)
{
	cout<<"调用 T Max1(T1 a, T2 b)"<<endl;
	return a>b ? a:b;
}


void main(void){
	int a = 1;
	int b = 2;

	//当函数模板和普通函数都符合调用时,优先选择普通函数
	//cout<<"Max(a, b)"<<Max(a, b)<<endl;

	//如果显式的使用函数模板,则使用<> 类型列表
	//Max<>(a, b);

	char c = 'a';
	//如果函数模板会产生更好的匹配，使用函数模板（即使普通函数会隐式转换类型）
	//Max1(c, a);
	//Max(1.0, 2.0);

	Max(3.0, 4.0, 5.0);	//这里先调用三个参数的函数模板，然后内部又调用两次两个参数的

	system("pause");
	return ;
}

⑥函数模板调用机制

通过以下代码在编译后生成的汇编语言，看看函数模板的调用机制。
反汇编观察 ：

结论：

  1. 编译器并不是把函数模板处理成能够处理任意类型的函数
  2. 编译器从函数模板通过具体类型产生不同的函数
#include <iostream>
using namespace std;

int Max(int a, int b){
        return a>b ? a:b;
}
int main()
{
        int  x = 1;
        int  y = 2;
        Max(x, y);
        return 0;
}

在linux命令行中查看生成的汇编代码
g++ -S demo.cpp -o demo.S

main函数的汇编代码：调用Max函数

  call    _Z3Maxii

完整的汇编代码：

// demo.S
        .file   "demo.cpp"
        .local  _ZStL8__ioinit
        .comm   _ZStL8__ioinit,1,1
        .text
        .globl  _Z3Maxii
        .type   _Z3Maxii, @function
_Z3Maxii:
.LFB1021:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movl    %edi, -4(%rbp)
        movl    %esi, -8(%rbp)
        movl    -4(%rbp), %eax
        cmpl    -8(%rbp), %eax
        jle     .L2
        movl    -4(%rbp), %eax
        jmp     .L4
.L2:
        movl    -8(%rbp), %eax
.L4:
        popq    %rbp
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1021:
        .size   _Z3Maxii, .-_Z3Maxii
        .globl  main
        .type   main, @function
main:
.LFB1022:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        subq    $16, %rsp
        movl    $1, -8(%rbp)
        movl    $2, -4(%rbp)
        movl    -4(%rbp), %edx
        movl    -8(%rbp), %eax
        movl    %edx, %esi
        movl    %eax, %edi
        
        call    _Z3Maxii
        
        movl    $0, %eax
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1022:
        .size   main, .-main
        .type   _Z41__static_initialization_and_destruction_0ii, @function
_Z41__static_initialization_and_destruction_0ii:
.LFB1023:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        subq    $16, %rsp
        movl    %edi, -4(%rbp)
        movl    %esi, -8(%rbp)
        cmpl    $1, -4(%rbp)
        jne     .L9
        cmpl    $65535, -8(%rbp)
        jne     .L9
        movl    $_ZStL8__ioinit, %edi
        call    _ZNSt8ios_base4InitC1Ev
        movl    $__dso_handle, %edx
        movl    $_ZStL8__ioinit, %esi
        movl    $_ZNSt8ios_base4InitD1Ev, %edi
        call    __cxa_atexit
.L9:
        nop
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1023:
        .size   _Z41__static_initialization_and_destruction_0ii, .-_Z41__static_initialization_and_destruction_0ii
        .type   _GLOBAL__sub_I__Z3Maxii, @function
_GLOBAL__sub_I__Z3Maxii:
.LFB1024:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movl    $65535, %esi
        movl    $1, %edi
        call    _Z41__static_initialization_and_destruction_0ii
        popq    %rbp
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1024:
        .size   _GLOBAL__sub_I__Z3Maxii, .-_GLOBAL__sub_I__Z3Maxii
        .section        .init_array,"aw"
        .align 8
        .quad   _GLOBAL__sub_I__Z3Maxii
        .hidden __dso_handle
        .ident  "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.5) 5.4.0 20160609"
        .section        .note.GNU-stack,"",@progbits

调用两次call的：

#include <iostream>
using namespace std;

template <typename T>
T Max(T a, T b){
	return a>b ? a:b;
}

int main()
{
	int  x = 1;
	int	 y = 2;
    Max(x, y);

	float a = 2.0;
	float b = 3.0;
	Max(a, b);

	return 0;
}

g++ -S demo_06.cpp -o demo.S
main中调用两次call：

        call    _Z3MaxIiET_S0_S0_
        call    _Z3MaxIfET_S0_S0_

完整汇编代码：

        .file   "demo_06.cpp"
        .local  _ZStL8__ioinit
        .comm   _ZStL8__ioinit,1,1
        .text
        .globl  main
        .type   main, @function
main:
.LFB1022:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        subq    $32, %rsp
        movl    $1, -16(%rbp)
        movl    $2, -12(%rbp)
        movl    -12(%rbp), %edx
        movl    -16(%rbp), %eax
        movl    %edx, %esi
        movl    %eax, %edi
        
        call    _Z3MaxIiET_S0_S0_
        
        movss   .LC0(%rip), %xmm0
        movss   %xmm0, -8(%rbp)
        movss   .LC1(%rip), %xmm0
        movss   %xmm0, -4(%rbp)
        movss   -4(%rbp), %xmm0
        movl    -8(%rbp), %eax
        movaps  %xmm0, %xmm1
        movl    %eax, -20(%rbp)
        movss   -20(%rbp), %xmm0
        
        call    _Z3MaxIfET_S0_S0_
        
        movl    $0, %eax
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1022:
        .size   main, .-main
        .section        .text._Z3MaxIiET_S0_S0_,"axG",@progbits,_Z3MaxIiET_S0_S0_,comdat
        .weak   _Z3MaxIiET_S0_S0_
        .type   _Z3MaxIiET_S0_S0_, @function
_Z3MaxIiET_S0_S0_:
.LFB1023:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movl    %edi, -4(%rbp)
        movl    %esi, -8(%rbp)
        movl    -4(%rbp), %eax
        cmpl    -8(%rbp), %eax
        jle     .L4
        movl    -4(%rbp), %eax
        jmp     .L6
.L4:
        movl    -8(%rbp), %eax
.L6:
        popq    %rbp
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1023:
        .size   _Z3MaxIiET_S0_S0_, .-_Z3MaxIiET_S0_S0_
        .section        .text._Z3MaxIfET_S0_S0_,"axG",@progbits,_Z3MaxIfET_S0_S0_,comdat
        .weak   _Z3MaxIfET_S0_S0_
        .type   _Z3MaxIfET_S0_S0_, @function
_Z3MaxIfET_S0_S0_:
.LFB1024:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movss   %xmm0, -4(%rbp)
        movss   %xmm1, -8(%rbp)
        movss   -4(%rbp), %xmm0
        ucomiss -8(%rbp), %xmm0
        jbe     .L13
        movss   -4(%rbp), %xmm0
        jmp     .L11
.L13:
        movss   -8(%rbp), %xmm0
.L11:
        popq    %rbp
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1024:
        .size   _Z3MaxIfET_S0_S0_, .-_Z3MaxIfET_S0_S0_
        .text
        .type   _Z41__static_initialization_and_destruction_0ii, @function
_Z41__static_initialization_and_destruction_0ii:
.LFB1025:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        subq    $16, %rsp
        movl    %edi, -4(%rbp)
        movl    %esi, -8(%rbp)
        cmpl    $1, -4(%rbp)
        jne     .L16
        cmpl    $65535, -8(%rbp)
        jne     .L16
        movl    $_ZStL8__ioinit, %edi
        call    _ZNSt8ios_base4InitC1Ev
        movl    $__dso_handle, %edx
        movl    $_ZStL8__ioinit, %esi
        movl    $_ZNSt8ios_base4InitD1Ev, %edi
        call    __cxa_atexit
.L16:
        nop
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1025:
        .size   _Z41__static_initialization_and_destruction_0ii, .-_Z41__static_initialization_and_destruction_0ii
        .type   _GLOBAL__sub_I_main, @function
_GLOBAL__sub_I_main:
.LFB1026:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movl    $65535, %esi
        movl    $1, %edi
        call    _Z41__static_initialization_and_destruction_0ii
        popq    %rbp
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1026:
        .size   _GLOBAL__sub_I_main, .-_GLOBAL__sub_I_main
        .section        .init_array,"aw"
        .align 8
        .quad   _GLOBAL__sub_I_main
        .section        .rodata
        .align 4
.LC0:
        .long   1073741824
        .align 4
.LC1:
        .long   1077936128
        .hidden __dso_handle
        .ident  "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.5) 5.4.0 20160609"
        .section        .note.GNU-stack,"",@progbits

总结：模板会根据参数的不同，会自动实现相应的模板。

  1. 编译器并不是把函数模板处理成能够处理任意类型的函数
  2. 编译器从函数模板通过具体类型产生不同的函数

二、类模板的使用

1.为什么要有类模板

类模板与函数模板的定义和使用类似，有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同，我们可以通过如下面语句声明了一个类模板：

template <typename T>
class A
{
public:
	A(T t)
	{
		this->t = t;
	}

	T &getT()
	{
		return t;
	}

public:
	T t;
};

类模板用于实现类所需数据的类型参数化
类模板在表示支持多种数据结构显得特别重要，这些数据结构的表示和算法不受所包含的元素类型的影响

2.类模板定义

类模板由模板说明+类说明构成
模板说明+函数模板，如下：
template <类型形式参数表>
类声明

例如：
template
class ClassName
{
//ClassName 的成员函数
private ：
Type DataMember;
}

3.类模板的使用

①单个类模板的使用

1.类模板定义类对象，必须显示指定类型 A< int> a(666);
2.模板中如果使用了构造函数，则遵守以前的类的构造函数的调用规则

#include <iostream>

using namespace std;

template <typename T>
class A
{
public:
	//函数的参数列表使用虚拟类型
	A(T t=0)
	{
		this->t = t;
	}
	//成员函数返回值使用虚拟类型
	T &getT()
	{
		return t;
	}

private:
	//成员变量使用虚拟类型
	T t;
};

//模板类做为函数参数，别忘了引用
void printA(A<int> &a){
	cout<<a.getT()<<endl;
}

int main(void){
	//1.模板类定义类对象，必须显示指定类型
	//2.模板中如果使用了构造函数，则遵守以前的类的构造函数的调用规则
	A<int>  a(666);
	cout<<a.getT()<<endl;

	//模板类做为函数参数
	printA(a);
	system("pause");
	return 0;
}

总结：函数的参数列表使用虚拟类型、成员函数返回值使用虚拟类型、成员变量使用虚拟类型、模板类做为函数参数

②继承中类模板的使用

继承中父子类和模板类的结合情况
1.父类一般类，子类是模板类， 和普通继承的玩法类似
2.子类是一般类，父类是模板类，继承时必须在子类里实例化父类的类型参数，并且一定要具体化参数列表
class B: public A < int >，B(Tb b):A< Tb >(b)
3.父类和子类都时模板类时，子类的虚拟的类型可以传递到父类中

// demo 15-9.c
#include <iostream>

using namespace std;

//普通类
/*class B
{
public:
	B(int b)
	{
		this->b = b;
	}

private:
	int b;
};
*/

//父类
template <typename T>
class A
{
public:
	//函数的参数列表使用虚拟类型
	A(T t)
	{
		this->t = t;
	}
	//成员函数返回值使用虚拟类型
	T &getT()
	{
		return t;
	}

private:
	//成员变量使用虚拟类型
	T t;
};

//子类
template <typename Tb>
class B: public A<int>
{
	public:
	B(Tb b):A<Tb>(b)
	{
		this->b = b;
	}

private:
	Tb b;

};

void printA(A<int> &a){
	cout<<a.getT()<<endl;
}

int main(void){
	//1.模板类定义类对象，必须显示指定类型
	//2.模板种如果使用了构造函数，则遵守以前的类的构造函数的调用规则
	A<int>  a(666);
	cout<<a.getT()<<endl;

	B<int> b(888);
	cout<<"b(888): "<<b.getT()<<endl;

	//模板类做为函数参数
	printA(a);
	system("pause");
	return 0;
}

4.类模板函数的三种表达描述方式

①所有的类模板函数写在类的内部

上面的例子已说明，在类的内部，只需要类上面声明了模板，那么类里面可以直接用

②所有的类模板函数写在类的外部，在一个cpp中

那么每个函数在实现前，都需要声明模板。
并且返回类型是类的，都变成A< T>，包括指明是这个类的函数时，类直接用A< T> ，即除了类和函数的内部，使用到类都要显式指明类型列表。

#include <iostream>

using namespace std;


template <typename T>
class A
{
public:
	A(T t=0);

	T &getT();

	A operator +(const A &other);

	void print();

private:
	T t;
};

/*
class A
{
public:
	A(int t=0);

	int &getT();

	A operator +(const A &other);

	void print();

private:
	int t;
};
*/

template <typename T>
A<T>::A(T t)
{
		this->t = t;
}

template <typename T>
T &A<T>::getT()
	{
		return t;
	}

template <typename T>
A<T> A<T>::operator+(const A<T> &other){
		A<T> tmp; //类的内部类型可以显示声明类型列表也可以不显示
		tmp.t =this->t + other.t;
		return tmp;
	}

template <typename T>
void A<T>::print(){
	cout<<this->t<<endl;
}

int main(void){
	
	A<int>  a(666), b(888);
	//cout<<a.getT()<<endl;

	A<int> tmp = a + b;

	tmp.print();

	system("pause");
	return 0;
}

③所有的类模板函数写在类的外部，在不同的.h和.cpp中

注意：当类模板的声明(.h文件)和实现(.cpp 或.hpp文件)完全分离，并且main也分离，因为类模板的特殊实现，我们应在使用类模板时使用#include包含实现部分的.cpp 或.hpp文件。（.hpp意思是模板类的具体实现）

// demo.h
#pragma once

template <typename T>
class A
{
public:
	A(T t=0);

	T &getT();

	A operator +(const A &other);

	void print();

private:
	T t;
};

// demo.c
#include "demo.h"
#include <iostream>

using namespace std;

template <typename T>
A<T>::A(T t)
{
		this->t = t;
}

template <typename T>
T &A<T>::getT()
	{
		return t;
	}

template <typename T>
A<T> A<T>::operator+(const A<T> &other){
		A<T> tmp; //类的内部类型可以显示声明也可以不显示
		tmp.t =this->t + other.t;
		return tmp;
	}

template <typename T>
void A<T>::print(){
	cout<<this->t<<endl;
}

int main(void){
	
	A<int>  a(666), b(888);
	//cout<<a.getT()<<endl;

	A<int> tmp = a + b;

	tmp.print();

	system("pause");
	return 0;
}

④特殊情况 友元函数

  1. 友元函数不是类内部的成员，所以申明时要模板申明并且加上类型列表
    template < typename T>
    friend A< T> addA(const A< T> &a, const A< T> &b);
    如果不申明模板，那么友元函数将不能访问类的私有成员
  2. 并且调用时，也要申明类型 A< int> tmp1 = addA< int>(a, b);
  3. 在友元函数实现内部也要加上A< T> tmp;
// demo 15-11.c
#include <iostream>

using namespace std;

template <typename T>
class A
{
public:
	A(T t=0);

	//声明一个友元函数，实现对两个A类对象进行加法操作
	template <typename T>
	friend A<T> addA(const A<T> &a, const A<T> &b);

	T &getT();

	A operator +(const A &other);

	void print();

private:
	T t;
};



template <typename T>
A<T>::A(T t)
{
		this->t = t;
}

template <typename T>
T &A<T>::getT()
	{
		return t;
	}

template <typename T>
A<T> A<T>::operator+(const A<T> &other){
		A tmp; //类的内部类型可以显示声明也可以不显示
		tmp.t =this->t + other.t;
		return tmp;
	}

template <typename T>
void A<T>::print(){
	cout<<this->t<<endl;
}


//A 类的友元函数,就是它的好朋友
template <typename T>
A<T> addA(const A<T> &a, const A<T> &b){
	A<T> tmp;
	cout<<"call addA()..."<<endl;
	tmp.t = a.t + b.t;
	return tmp;
}

int main(void){
	
	A<int>  a(666), b(888);
	//cout<<a.getT()<<endl;

	A<int> tmp = a + b;
	A<int> tmp1 = addA<int>(a, b);
	
	tmp.print();
	tmp1.print();

	system("pause");
	return 0;
}

结论:
(1) 类内部声明友元函数，必须写成一下形式
template< typename T>
friend A< T> addA (A< T> &a, A< T> &b);

(2) 友元函数实现 必须写成
template< typename T>
A< T> add(A< T> &a, A< T> &b)
{
//…
}
(3) 友元函数调用 必须写成
A< int> c4 = addA< int>(c1, c2);

⑤模板类和静态成员

静态成员被不同的类型实例化后，会生成不同的静态成员。
template < typename T> int A< T>::count = 666;
即这里如果T是int型和T是float型对应的count不是同一个，而是独立的两个。

#include <iostream>

using namespace std;

template <typename T>
class A
{
public:
	A(T t=0);

	T &getT();

	A operator +(const A &other);

	void print();

public:
	static int count;
private:
	T t;
};

template <typename T> int A<T>::count = 666;

template <typename T>
A<T>::A(T t)
{
	this->t = t;
}

template <typename T>
T &A<T>::getT()
{
	return t;
}

template <typename T>
A<T> A<T>::operator+(const A<T> &other){
	A tmp; //类的内部类型可以显示声明也可以不显示
	tmp.t =this->t + other.t;
	return tmp;
}

template <typename T>
void A<T>::print(){
	cout<<this->t<<endl;
}

int main(void){

	A<int>  a(666), b(888);
	A<int> tmp = a + b;

	A<float> c(777), d(999);

	a.count = 888;

	cout<<"b.count:"<<b.count<<endl;

	cout<<"c.count:"<<c.count<<endl;
	cout<<"d.count:"<<d.count<<endl;
	c.count = 1000;
	cout<<"修改后, d.count:"<<d.count<<endl;

	//tmp.print();

	system("pause");
	return 0;
}

总结：

  1. 从类模板实例化的每个模板类有自己的类模板数据成员，该模板类的所有对象共享一个static数据成员
  2. 和非模板类的static数据成员一样，模板类的static数据成员也应该在文件范围定义和初始化
  3. static 数据成员也可以使用虚拟类型参数T，比如static T count;

5.类模板使用总结

归纳以上的介绍，可以这样声明和使用类模板：
1. 先写出一个实际的类。
2. 将此类中准备改变的类型名(如int要改变为float或char)改用一个自己指定的虚拟类型名(如上例中的T)。
3. 在类声明前面加入一行，格式为：
template <typename 虚拟类型参数>
如：
template < typename numtype>
class A
{…}; //类体
4. 用类模板定义对象时用以下形式：
类模板名<实际类型名> 对象名;
或 类模板名<实际类型名> 对象名(实参表列);
如：
A< int> cmp;
A< int> cmp(3,7);
注意一定要写类型，不然编译器不知道要分配多大的内存。
5) 如果在类模板外定义成员函数，应写成类模板形式：
template <typename 虚拟类型参数>
函数类型 类模板名<虚拟类型参数>::成员函数名(函数形参表列) {…}
关于类模板的几点补充：

  1. 类模板的类型参数可以有一个或多个，每个类型前面都必须加typename 或class，如：
    template <typename T1,typename T2>
    class someclass
    {…};
    在定义对象时分别代入实际的类型名，如：
    someclass<int, char> object;
  2. 和使用类一样，使用类模板时要注意其作用域，只有在它的有效作用域内用使用它定义对象。
  3. 模板类也可以有支持继承，有层次关系，一个类模板可以作为基类，派生出派生模板类。
procurar
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 模板 类 代码 参考
02-25
c++ 泛型编程 参考，里面有注释 ，都是我自己的理解，代码参考c++ 设计新思维 这本书，有需要的可以看一看。
C++补充-模板
05-17
C++补充-模板,针对很多东西进行了解析，相当好的东西，值得参考！希望对你有用！
C++模板
欧尼酱的技术园
06-18 293
文章目录前言一、函数模板1.1函数模板的概念1.2 函数模板类型1.3 函数模板的原理1.4 函数模板的实例化1.4.1隐士实例化1.4.2 显式实例化1.5 模板参数的匹配原则二、类模板2.1 类模板的定义格式2.2 类模板的实例化总结 前言 本节将为大家讲解C++中另一个重要的部分：模板。在这篇文章中，会让大家初步了解什么是模板，模板的基本用法和概念。 一、函数模板 泛型编程：编写与类型无关的通用代码，可以提高代码复用率。模板是泛型编程的基础。 1.1函数模板的概念 函数模板代表了一个函数家族，
C++模板(template)详解教程（很多代码示例）
a6484594的博客
06-04 2713
C++模板快速上手
C++代码模板
qq_40856614的博客
02-27 377
#define _CRT_SECURE_NO_WARNINGS #include<iostream> using namespace std; int main() { system("pause"); return 0; } 直接输入#2就可以直接导入建立好的初始代码，详细建立过程可以参考 ...
c++代码模板
weixin_63300864的博客
02-03 201
【代码】c++代码模板。
基于C++的ACM-ICPC模板
02-22
使用C++模板，可以实现代码复用和泛型编程，这对于解决复杂问题尤其有帮助。ACM-ICPC模板则是在此基础上，结合比赛特点，进一步优化和封装的代码库。 总的来说，这个基于C++的ACM-ICPC模板是参赛者在备赛过程中必不...
c++课设C++-Test-7-29.rar
最新发布
06-21
总的来说，C++-Test-7-29.rar这个压缩包可能涵盖了C++的基础知识、面向对象编程、模板与泛型、标准库的使用以及测试与调试等多个方面，是学习和巩固C++技能的良好实践。通过深入研究和实践，你可以逐步成为一名熟练...
c++文件模板 c++文件模板
02-24
c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件...
C++模板中文版及源代码
05-18
C++模板中文版及源代码，非常经典的书籍。
C++ 模板
代码人生
02-10 334
C++ 模板
数据结构与算法——C++代码模板合集
qq_42887507的博客
07-02 4147
一、线性表 1、顺序表 #include<iostream> #include<stdio.h> using namespace std; //顺序表 class SeqList { private: int* list; //数组 int maxsize; //最大表长 int size; //当前表长 public: SeqList(); ~SeqList(); void list_int(int n); //输入n个数，并依次存入顺序表中从0开始
c++常用代码模板
qq_52930538的博客
07-19 580
(以从小到大排为例) (1)冒泡排序 template<typename T> void BubbleSort(T a[];T n) { T i,j,item; for(i=0;i<n-1;i++) for(j=0;j<n-i-1;j++) if(a[j]>a[j+1]) { item=a[j]; a[j]=a[j+1];
C++ 模板详解附代码
yn_zi的博客
06-27 164
比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对字符类型也是如此。别看这只是简化了两组代码，想想对于stack的实现，我们总不可能写一个int类型的，再写一个double类型，再写一个char类型的吧，使用上模板就大大优化了代码。通过使用类型特化和非类型特化，我们可以为不同的类型参数或非类型参数提供特定的行为，满足特定需求，并在代码中获得更好的性能和效果。类型参数指的是在模板中使用的类型占位符。
c++模板的奇淫技巧代码
yuzepan1的专栏
06-11 1103
c++模板复杂的一个原因就是类型推导参数包装过深，人脑无法记忆那么多位置，在看make_shared的时候遇到这么个代码，外国人少是有原因的。。template&lt;size_t... _Vals&gt; struct _Maximum; template&lt;&gt; struct _Maximum&lt;&gt; { // maximum of nothing is 0 stat...
C++标准模板库STL详解
"C++ PPT第9章 标准模板库STL.ppt" C++标准模板库（STL）是C++编程中一个至关重要的组成部分，它提供了一组高效且可重用的模板类和函数，使得程序员可以便捷地处理数据结构和算法。STL的出现极大地提升了C++的编程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值