C++ 模板详解

非类型形参演示示例1：

由用户自己亲自指定栈的大小，并实现栈的相关操作。

TemplateDemo.h

#ifndef TEMPLATE_DEMO_HXX

#define TEMPLATE_DEMO_HXX

template class Stack{//MAXSIZE由用户创建对象时自行设置

private:

T elems[MAXSIZE]; // 包含元素的数组

int numElems; // 元素的当前总个数

public:

Stack(); //构造函数

void push(T const&); //压入元素

void pop(); //弹出元素

T top() const; //返回栈顶元素

bool empty() const{ // 返回栈是否为空

return numElems == 0;

}

bool full() const{ // 返回栈是否已满

return numElems == MAXSIZE;

}

};

template

Stack::Stack():numElems(0){ // 初始时栈不含元素

// 不做任何事情

}

template

void Stack::push(T const& elem){

if(numElems == MAXSIZE){

throw std::out_of_range("Stack<>::push(): stack is full");

}

elems[numElems] = elem; // 附加元素

++numElems; // 增加元素的个数

}

template

void Stack::pop(){

if (numElems <= 0) {

throw std::out_of_range("Stack<>::pop(): empty stack");

}

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

}

template

T Stack::top()const{

if (numElems <= 0) {

throw std::out_of_range("Stack<>::top(): empty stack");

}

return elems[numElems-1]; // 返回最后一个元素

}

#endif

TemplateDemo.cpp

#include

#include

#include

#include

#include "TemplateDemo.h"

int main(){

try {

Stack int20Stack; // 可以存储20个int元素的栈

Stack int40Stack; // 可以存储40个int元素的栈

Stack stringStack; // 可存储40个string元素的栈

// 使用可存储20个int元素的栈

int20Stack.push(7);

std::cout << int20Stack.top() << std::endl; //7

int20Stack.pop();

// 使用可存储40个string的栈

stringStack.push("hello");

std::cout << stringStack.top() << std::endl; //hello

stringStack.pop();

stringStack.pop(); //Exception: Stack<>::pop<>: empty stack

return 0;

}

catch (std::exception const& ex) {

std::cerr << "Exception: " << ex.what() << std::endl;

return EXIT_FAILURE; // 退出程序且有ERROR标记

}

}

非类型形参演示示例2：

TemplateDemo01.h

#ifndef TEMPLATE_DEMO_O1

#define TEMPLATE_DEMO_01

template class CompareDemo{

public:

int compare(const T&, const T&);

};

template

int CompareDemo::compare(const T& a,const T& b){

if((a-b)>0)

return 1;

else if((a-b)<0)

return -1;

else

return 0;

}

#endif

TemplateDemo01.cpp

#include

#include "TemplateDemo01.h"

void main(){

CompareDemo cd;

cout<

}

运行结果：-1

TemplateDemo01.cpp

#include

#include "TemplateDemo01.h"

void main(){

CompareDemo cd;

cout<

}

运行结果： 1

TemplateDemo01.h

#ifndef TEMPLATE_DEMO_O1

#define TEMPLATE_DEMO_01

template class CompareDemo{

public:

int compare(T&, T&);

};

template

int CompareDemo::compare(T& a,T& b){

if((a-b)>0)

return 1;

else if((a-b)<0)

return -1;

else

return 0;

}

#endif

TempalteDemo01.cpp

#include

#include "TemplateDemo01.h"

void main(){

CompareDemo cd;

int a=2,b=3;

cout<

}

非类型形参演示示例3：

TemplateDemo02.cpp

#include

template

const T& max(const T& a,const T& b){

return a>b ? a:b;

}

void main(){

cout<

cout<(2.1,2.2)<

cout<(2.1,2.2)<

}

运行结果：

cout<(2.1,2.2)<

此语句会出现警告：

--------------------Configuration: TemplateDemo02 - Win32 Debug--------------------

Compiling...

TemplateDemo02.cpp

G:\C++\CDaima\TemplateDemo02\TemplateDemo02.cpp(11) :

warning C4244: 'argument' : conversion from 'const double' to 'const int', possible loss of data

G:\C++\CDaima\TemplateDemo02\TemplateDemo02.cpp(11) :

warning C4244: 'argument' : conversion from 'const double' to 'const int', possible loss of data

TemplateDemo02.obj - 0 error(s), 2 warning(s)

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

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

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

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

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

定义类模板类型形参：

演示实例1：

TemplateDemo.h

#ifndef TEMPLATE_DEMO_HXX

#define TEMPLATE_DEMO_HXX

template class A{

public:

T g(T a,T b);

A();

};

#endif

TemplateDemo.cpp

#include

#include "TemplateDemo.h"

template A::A(){}

template T A::g(T a,T b){

return a+b;

}

void main(){

A a;

cout<

}

运行结果： 5

类模板的默认模板类型形参示例1：

TemplateDemo03.h

#ifndef TEMPLATE_DEMO_03

#define TEMPLATE_DEMO_03

//定义带默认类型形参的类模板。这里把T2默认设置为int型。

template class CeilDemo{

public:

int ceil(T1,T2);

};

//在类模板的外部定义类中的成员时template 后的形参表应省略默认的形参类型。

template

int CeilDemo::ceil(T1 a,T2 b){

return a>>b;

}

#endif

TemplateDemo03.cpp

#include

#include "TemplateDemo03.h"

void main(){

CeilDemo cd;

cout<

}

运行结果： 2

在类模板的外部定义类中的成员时template 后的形参表应省略默认的形参类型，如果没有省略，不会出现编译错误而是提出警告：

--------------------Configuration: TemplateDemo03 - Win32 Debug--------------------

Compiling...

TemplateDemo03.cpp

g:\c++\cdaima\templatedemo03\templatedemo03.h(12) :

warning C4519: default template arguments are only allowed on a class template; ignored

TemplateDemo03.obj - 0 error(s), 1 warning(s)

原作者：类模板类型形参默认值和函数的默认参数一样，如果有多个类型形参则从第一个形参设定了默认值之后的所有模板形参都要设定默认值，比如templateclass A{};就是错误的，因为T1给出了默认值，而T2没有设定。

类模板的默认模板类型形参示例2：

TemplateDemo03.h

#ifndef TEMPLATE_DEMO_03

#define TEMPLATE_DEMO_03

template class CeilDemo{

public:

int ceil(T1,T2,T3);

};

template

int CeilDemo::ceil(T1 a,T2 b,T3 c){

return a+b+c;

}

#endif

TemplateDemo03.cpp

#include

#include "TemplateDemo03.h"

void main(){

CeilDemo cd;

cout<

}

运行结果：9

TemplateDemo03.h

#ifndef TEMPLATE_DEMO_03

#define TEMPLATE_DEMO_03

template class CeilDemo{

public:

double ceil(T1,T2,T3);

};

template

double CeilDemo::ceil(T1 a,T2 b,T3 c){

return a+b+c;

}

#endif

TemplateDemo03.cpp

#include

#include "TemplateDemo03.h"

void main(){

CeilDemo cd;

cout<

}

编译错误：

--------------------Configuration: TemplateDemo03 - Win32 Debug--------------------

Compiling...

TemplateDemo03.cpp

g:\c++\cdaima\templatedemo03\templatedemo03.h(12) :

error C2244: 'CeilDemo::ceil' : unable to resolve function overload

g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) :

error C2065: 'cd' : undeclared identifier

g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) :

error C2228: left of '.ceil' must have class/struct/union type

Error executing cl.exe.

TemplateDemo03.obj - 3 error(s), 0 warning(s)

从上面的例子我们可以看出，当我们试图把T2和T3定义为double类型就会出现错误（T1默认定义的是int类型）。那是不是我们按照作者所说把T2和T3也设定为默认值double，是否还会出现错误？看下面的示例：

类模板的默认模板类型形参示例4：

TemplateDemo03.h

#ifndef TEMPLATE_DEMO_03

#define TEMPLATE_DEMO_03

template class CeilDemo{

public:

double ceil(T1,T2,T3);

};

template

double CeilDemo::ceil(T1 a,T2 b,T3 c){

return a+b+c;

}

#endif

TemplateDemo03.cpp

#include

#include "TemplateDemo03.h"

void main(){

CeilDemo cd;

cout<

}

编译错误：

--------------------Configuration: TemplateDemo03 - Win32 Debug--------------------

Compiling...

TemplateDemo03.cpp

g:\c++\cdaima\templatedemo03\templatedemo03.h(12) :

error C2244: 'CeilDemo::ceil' : unable to resolve function overload

g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) :

error C2065: 'cd' : undeclared identifier

g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) :

error C2228: left of '.ceil' must have class/struct/union type

Error executing cl.exe.

TemplateDemo03.obj - 3 error(s), 0 warning(s)

从结果我们可以看出，和上例是一样的错误。从实例中我们可以总结如下：类模板如果有多个类型形参，如果使用类型形参默认值则尽量放在参数列表的末尾，而且默认的参数类型必须相同。如果从第一个形参设定了默认值之后的所有模板形参都要设定和第一个形参同类型的默认值。（声明：本人也是刚接触C++，以上只是我经过实例演示对原作者提出的一些质疑，可能我的示例有不到之处，还望大神们不吝赐教，共同完善此博客，给像我一样的菜鸟提供一个学习的平台！）

接下来验证"不能为函数模板的类型形参提供默认值"：

类模板的默认模板类型形参示例5：

TemplateDemo04.cpp

#include

template

T1 sum(T1 a,T2 b,T3 c=int){

return a+b+c;

}

void main(){

cout<(1.1,2.1,3)<

}

编译错误：

--------------------Configuration: TemplateDemo04 - Win32 Debug--------------------

Compiling...

TemplateDemo04.cpp

g:\c++\cdaima\templatedemo04\templatedemo04.cpp(4) :

error C2062: type 'int' unexpected

Error executing cl.exe.

TemplateDemo04.obj - 1 error(s), 0 warning(s)

更改之后的 TemplateDemo.cpp

TemplateDemo.cpp

#include

template

T1 sum(T1 a,T2 b,T3 c){

return a+b+c;

}

void main(){

cout<(1.1,3,257)<

}

运行结果： 261.1

原作者演示实例如下：

类模板非类型形参示例

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

//类模板的定义

templateclass A{public:T g(T a, T b); A();}; //定义带有一个类模板类型形参T的类A

templateclass B{public:void g();}; //定义带有两个类模板类型形参T1，T2的类B

//定义类模板的默认类型形参，默认类型形参不适合于函数模板。

template class D{public: voidg();}; //定义带默认类型形参的类模板。这里把T2默认设置为int型。

//templateclass E{}; //错误，为T1设了默认类型形参则T1后面的所有形参都必须设置认默值。

//以下为非类型形参的定义

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

针是正确的。

template class Ci{public:void g();}; //定义模板的非类型形参，形参为整型

templateclass Cip{public:void g();};

template* m> class Cc{public:void g();}; //定义模板的模板类型形参，形参为int型的类A的对象的指针。

templateclass Cd{public:void g();}; //定义模板的非类型形参，形参为double类型的引用。

class E{}; template class Ce{}; //非类型模板形参为对象的引用。

//以下非类型形参的声明是错误的。

//templateclass Cc{}; //错误，对象不能做为非类型形参，非类型模板形参的类型只能是对象的引用或指针。

//templateclass Cc{}; //错误，非类型模板的形参不能是double类型，可以是double的引用。

//template m>class Cc{}; //错误，非类型模板的形参不能是对象，必须是对象的引用或指针。这条规则对于模板型参

也不例外。

//在类模板外部定义各种类成员的方法，

//typeid(变量名).name()的作用是提取变量名的类型，如int a，则cout<

template A::A(){cout<<"class A goucao"<

template T A::g(T a,T b){cout<<"class A g(T a,T b)"<

template voidB::g(){cout<<"class g f()"<

//在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致

template voidCi::g(){cout<<"class Ci g()"<

template voidCip::g(){cout<<"class Cip g()"<

//在类外部定义类的成员时，template后的模板形参应与要定义的类的模板形参一致

template *m> voidCc::g(){cout<<"class Cc g()"<

template voidCd::g(){cout<<"class Cd g()"<

//带有默认类型形参的模板类，在类的外部定义成员的方法。

//在类外部定义类的成员时，template的形参表中默认值应省略

template voidD::g(){cout<<"class D g()"<

//template void D::g(){cout<<"class D k()"<

参时，在template的形参表中默认值应省略。

//定义一些全局变量。

int e=2; doubleed=2.2; double*pe=&ed;

A mw; A *pec=&mw; E me;

//main函数开始

int main()

{ // templatevoid h(){} //错误，模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行。

//A<2> m; //错误，对类模板不存在实参推演问题，类模板必须在尖括号中明确指出其类型。

//类模板调用实例

A ma; //输出"class A goucao int"创建int型的类模板A的对象ma。

B mb; mb.g(); //输出"class B g() int int"创建类模板B的对象mb，并把类型形参T1和T2设计为int

//非类型形参的调用

//调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果。任何局部对象，局部变量，局部对象的地址，局部

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

用作非类型模板形参的实参。

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

//调用整型int型非类型形参的方法为名为Ci，声明形式为template class Ci

Ci//正确，数值R是一个int型常量，输出"class Ci g() int"

const int a2=3; Ci mci1; mci1.g(); //正确，因为a2在这里是const型的常量。输出"class Ci g() int"

//Ci mci; //错误，int型变量a是局部变量，不是一个常量表达式。

//Ci mci; //错误，全局int型变量e也不是一个常量表达式。

//调用int&型非类型形参的方法类名为Cip，声明形式为templateclass Cip

Cip mcip; //正确，对全局变量的引用或地址是常量表达式。

//Cip mcip1; //错误，局部变量的引用或地址不是常量表达式。

//调用double*类型的非类形形参类名为Cd，声明形式为templateclass Cd

Cd mcd; //正确，全局变量的引用或地址是常量表达式。

//Cd mcd1; //错误，全局变量指针不是常量表达式。

//double dd=3.3; //错误，局部变量的地址不是常量表达式，不能用作非类型形参的实参

//Cd mcd; //错误，非类型形参虽允许一些转换，但这个转换不能实现。

//调用模板类型形参对象A *的方法类名为Cc，声名形式为template* m> class Cc

Cc mcc; mcc.g(); //正确，全局对象的地址或者引用是常量表达式

//Cc mcc; //错误，局部变量的地址或引用不是常量表达式。

//Cc mcc2; //错误，全局对象的指针不是常量表达式。

//调用非类型形参E&对象的引用的方法类名为Ce。声明形式为template class Ce

E me1; //Ce mce1; //错误，局部对象不是常量表达式

Ce mce; //正确，全局对象的指针或引用是常量表达式。

//非类型形参的转换示例，类名为Ci

//非类型形参允许从数组到指针，从函数到指针的转换，const修饰符的转换，提升转换，整值转换，常规转换。

const short s=3; Ci mci4†//正确，虽然short型和int不完全匹配，但这里可以将short型转换为int型

原文地址：

https://www.cnblogs.com/gw811/archive/2012/10/25/2738929.html

http://www.cnblogs.com/gw811/archive/2012/10/25/2736224.html