C++模板

来源：http://www.cnblogs.com/gw811/archive/2012/10/25/2738929.html

来源：http://www.cnblogs.com/L-hq815/archive/2012/08/01/2619135.html

来源：http://blog.csdn.net/qq_28796345/article/details/51288045

        模板并非一个实实在在的类或函数，仅仅是一个类和函数的描述。由于模板可以实现逻辑相同、数据类型不同的程序代码复制，所以使用模板机制可以减轻编程和维护的工作量和难度。模板一般分为模板函数和类模板。

“模板类”是类模板实例化后的一个产物。本质是一个类。
说个形象点的例子吧。我们把类模板比作一个做饼干的模子，而模板类就是用这个模子做出来的饼干，至于这个饼干是什么味道的就要看你自己在实例化时用的是什么材料了，你可以做巧克力饼干，也可以做豆沙饼干，这些饼干的除了材料不一样外，其他的东西都是一样的了。

函数模板：只是声明了一个函数的描述，即模板。本质是一个模板。
不是一个可以直接执行的函数，只有根据实际情况用实参的数据类型代替类型参数标识符之后，才能产生真正的函数。
模板函数：就是将“函数模板”的类型形参“实例化”的过程。本质是一个函数。

C++模板

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

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

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

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

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

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

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

一、函数模板通式


1、函数模板的格式：

　　　　template <class 形参名，class 形参名，......> 返回类型
函数名(参数列表)

　　　{

　　　　　　函数体

　　　}

　　其中template和class是关见字，class可以用typename 关见字代替，在这里typename
和class没区别，<>括号中的参数叫模板形参，模板形参和函数形参很相像，模板形参不能为空。一但声明了模板函数就可以用模板函数的形参名声明类中的成员变量和成员函数，即可以在该函数中使用内置类型的地方都可以使用模板形参名。模板形参需要调用该模板函数时提供的模板实参来初始化模板形参，一旦编译器确定了实际的模板实参类型就称他实例化了函数模板的一个实例。比如swap的模板函数形式为

　　　　　　template <class T> void swap(T& a, T& b){}，

当调用这样的模板函数时类型T就会被被调用时的类型所代替，比如swap(a,b)其中a和b是int 型，这时模板函数swap中的形参T就会被int 所代替，模板函数就变为swap(int
&a, int &b)。而当swap(c,d)其中c和d是double类型时，模板函数会被替换为swap(double
&a, double &b)，这样就实现了函数的实现与类型无关的代码。

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

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

二、类模板通式


　　1、类模板的格式为：

　　　　template<class  形参名，class 形参名，…>   class 类名

　　　　{ ... };

　　类模板和函数模板都是以template开始后接模板形参列表组成，模板形参不能为空，一但声明了类模板就可以用类模板的形参名声明类中的成员变量和成员函数，即可以在类中使用内置类型的地方都可以使用模板形参名来声明。比如

　　　　template<class T> class A{public: T a; T b; T hy(T c, T &d);};

在类A中声明了两个类型为T的成员变量a和b，还声明了一个返回类型为T带两个参数类型为T的函数hy。

　　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、类型形参

　　　　1.1 、类型模板形参：类型形参由关见字class或typename后接说明符构成，如template<class T> void h(T a){};其中T就是一个类型形参，类型形参的名字由用户自已确定。模板形参表示的是一个未知的类型。模板类型形参可作为类型说明符用在模板中的任何地方，与内置类型说明符或类类型说明符的使用方式完全相同，即可以用于指定返回类型，变量声明等。

　　　　作者原版：1.2、 不能为同一个模板类型形参指定两种不同的类型，比如template<class
T>void h(T a, T b){}，语句调用h(2, 3.2)将出错，因为该语句给同一模板形参T指定了两种类型，第一个实参2把模板形参T指定为int，而第二个实参3.2把模板形参指定为double，两种类型的形参不一致，会出错。（针对函数模板）

　　　　作者原版：1.2针对函数模板是正确的，但是忽略了类模板。下面将对类模板的情况进行补充。

　　　　本人添加1.2补充版（针对于类模板）、当我们声明类对象为：A<int> a，比如template<class
T>T g(T a, T b){}，语句调用a.g(2, 3.2)在编译时不会出错，但会有警告，因为在声明类对象的时候已经将T转换为int类型，而第二个实参3.2把模板形参指定为double，在运行时，会对3.2进行强制类型转换为3。当我们声明类的对象为：A<double>
a,此时就不会有上述的警告，因为从int到double是自动类型转换。

演示示例１：

TemplateDemo.h

#ifndef TEMPLATE_DEMO_HXX
#define TEMPLATE_DEMO_HXX

template<class T> class A{
    public:
        T g(T a,T b);
        A();
};

#endif

TemplateDemo.cpp 

#include<iostream.h>
#include "TemplateDemo.h"

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

template<class T> T A<T>::g(T a,T b){
    return a+b;
}

void main(){
    A<int> a;
    cout<<a.g(2,3.2)<<endl;
}

编译结果： 

1 --------------------Configuration: TemplateDemo - Win32 Debug--------------------
2 Compiling...
3 TemplateDemo.cpp
4 G:\C++\CDaima\TemplateDemo\TemplateDemo.cpp(12) : warning C4244: 'argument' : conversion from 'const double' to 'int', possible loss of data
5
6 TemplateDemo.obj - 0 error(s), 1 warning(s)

运行结果：　　　　　　5　　

　　我们从上面的测试示例中可以看出，并非作者原作中的那么严密！此处仅是本人跟人测试结果！请大家本着实事求是的态度，自行验证！

　　2、非类型形参

　　　　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、常规转换。

非类型形参演示示例1：

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

　　TemplateDemo.h

#ifndef TEMPLATE_DEMO_HXX
#define TEMPLATE_DEMO_HXX

template<class T,int MAXSIZE> 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 <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];  // 返回最后一个元素
}

#endif　

TemplateDemo.cpp

#include<iostream.h>
#include <iostream>
#include <string>
#include <cstdlib>
#include "TemplateDemo.h"

int main(){
    try {
        Stack<int,20>  int20Stack;  // 可以存储20个int元素的栈
        Stack<int,40>  int40Stack;  // 可以存储40个int元素的栈
        Stack<std::string,40> 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<typename T> class CompareDemo{
    public:
        int compare(const T&, const T&);
};

template<typename T>
int CompareDemo<T>::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<iostream.h>
#include "TemplateDemo01.h"

void main(){
    CompareDemo<int> cd;
    cout<<cd.compare(2,3)<<endl;
}

运行结果：　　　　　-1　 

#include<iostream.h>
#include "TemplateDemo01.h"

void main(){
    CompareDemo<double> cd;
    cout<<cd.compare(3.2,3.1)<<endl;
}

运行结果：　　　　　　1　　

　　TemplateDemo01.h 改动如下：

#ifndef TEMPLATE_DEMO_O1
#define TEMPLATE_DEMO_01

template<typename T> class CompareDemo{
    public:
        int compare(T&, T&);
};

template<typename T>
int CompareDemo<T>::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<iostream.h>
#include "TemplateDemo01.h"

void main(){
    CompareDemo<int> cd;
    int a=2,b=3;
    cout<<cd.compare(a,b)<<endl;
}

 非类型形参演示示例3：

　　TemplateDemo02.cpp

#include<iostream.h>

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

void main(){
    cout<<max(2.1,2.2)<<endl;//模板实参被隐式推演成double
    cout<<max<double>(2.1,2.2)<<endl;//显示指定模板参数。
    cout<<max<int>(2.1,2.2)<<endl;//显示指定的模板参数，会将函数函数直接转换为int。
}

运行结果：

　　　　　　　

cout<<max<int>(2.1,2.2)<<endl;//显示指定的模板参数，会将函数函数直接转换为int。此语句会出现警告：
1 --------------------Configuration: TemplateDemo02 - Win32 Debug--------------------
2 Compiling...
3 TemplateDemo02.cpp
4 G:\C++\CDaima\TemplateDemo02\TemplateDemo02.cpp(11) : 　　warning C4244: 'argument' : conversion from 'const double' to 'const int', possible loss of data
5 G:\C++\CDaima\TemplateDemo02\TemplateDemo02.cpp(11) : 　　warning C4244: 'argument' : conversion from 'const double' to 'const int', possible loss of data
6
7 TemplateDemo02.obj - 0 error(s), 2 warning(s)

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

　　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(){}。

定义类模板类型形参：

 演示实例1：

　　TemplateDemo.h

#ifndef TEMPLATE_DEMO_HXX
#define TEMPLATE_DEMO_HXX

template<class T> class A{
    public:
        T g(T a,T b);
        A();
};

#endif

TemplateDemo.cpp 

#include<iostream.h>
#include "TemplateDemo.h"

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

template<class T> T A<T>::g(T a,T b){
    return a+b;
}

void main(){
    A<int> a;
    cout<<a.g(2,3)<<endl;
}

　　运行结果：       5

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

　　TemplateDemo03.h

#ifndef TEMPLATE_DEMO_03
#define TEMPLATE_DEMO_03
//定义带默认类型形参的类模板。这里把T2默认设置为int型。
template<class T1,class T2=int> class CeilDemo{
    public:
        int ceil(T1,T2);
};
//在类模板的外部定义类中的成员时template 后的形参表应省略默认的形参类型。
template<class T1,class T2>
int CeilDemo<T1,T2>::ceil(T1 a,T2 b){
    return a>>b;
}

#endif

TemplateDemo03.cpp 

#include<iostream.h>
#include "TemplateDemo03.h"

void main(){
    CeilDemo<int> cd;
    cout<<cd.ceil(8,2)<<endl;
}

　　运行结果：　　　　　　　2　

　　在类模板的外部定义类中的成员时template 后的形参表应省略默认的形参类型，如果没有省略，不会出现编译错误而是提出警告：
1 --------------------Configuration: TemplateDemo03 - Win32 Debug--------------------
2 Compiling...
3 TemplateDemo03.cpp
4 g:\c++\cdaima\templatedemo03\templatedemo03.h(12) :
5 warning C4519: default template arguments are only allowed on a class template; ignored
6
7 TemplateDemo03.obj - 0 error(s), 1 warning(s)

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

实例测试如下：

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

 　　TemplateDemo03.h 

#ifndef TEMPLATE_DEMO_03
#define TEMPLATE_DEMO_03

template<class T1=int,class T2,class T3> class CeilDemo{
    public:
        int ceil(T1,T2,T3);
};

template<class T1,class T2,class T3>
int CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){
    return a+b+c;
}

#endif

TemplateDemo03.cpp  

#include<iostream.h>
#include "TemplateDemo03.h"

void main(){
    CeilDemo<int,int> cd;
    cout<<cd.ceil(2,3,4)<<endl;
}

　　运行结果：　　　　　　　　9　　

　　上例中我们看到，虽然多个类型形参则从第一个形参T1设定了默认值为int类型，但后面的两个并没有设定默认值。我们在声明对象的时候指明了T2和T3的类型都为int类型，编译、运行没有任何警告和错误。但并不能否定原作者是错的，这只是一个特例，看下面的示例：

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

　　TemplateDemo03.h

#ifndef TEMPLATE_DEMO_03
#define TEMPLATE_DEMO_03

template<class T1=int,class T2,class T3> class CeilDemo{
    public:
        double ceil(T1,T2,T3);
};

template<class T1,class T2,class T3>
double CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){
    return a+b+c;
}

#endif

TemplateDemo03.cpp 

#include<iostream.h>
#include "TemplateDemo03.h"

void main(){
    CeilDemo<double,double> cd;
    cout<<cd.ceil(2,3.1,4.1)<<endl;
}

编译错误： 

1 --------------------Configuration: TemplateDemo03 - Win32 Debug--------------------
 2 Compiling...
 3 TemplateDemo03.cpp
 4 g:\c++\cdaima\templatedemo03\templatedemo03.h(12) :
 5 error C2244: 'CeilDemo<T1,T2,T3>::ceil' : unable to resolve function overload
 6 g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) :
 7 error C2065: 'cd' : undeclared identifier
 8 g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) :
 9 error C2228: left of '.ceil' must have class/struct/union type
10 Error executing cl.exe.
11
12 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 T1=int,class T2=double,class T3=double> class CeilDemo{
    public:
        double ceil(T1,T2,T3);
};

template<class T1,class T2,class T3>
double CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){
    return a+b+c;
}

#endif

TemplateDemo03.cpp 

#include<iostream.h>
#include "TemplateDemo03.h"

void main(){
    CeilDemo<int,double,double> cd;
    cout<<cd.ceil(2,3.1,4.1)<<endl;
}

编译错误： 

--------------------Configuration: TemplateDemo03 - Win32 Debug--------------------
Compiling...
TemplateDemo03.cpp
g:\c++\cdaima\templatedemo03\templatedemo03.h(12) :
error C2244: 'CeilDemo<T1,T2,T3>::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<iostream.h>

template<class T1,class T2,class T3>
T1 sum(T1 a,T2 b,T3 c=int){
    return a+b+c;
} 

void main(){
    cout<<sum<double,double>(1.1,2.1,3)<<endl;
}

编译错误： 

1 --------------------Configuration: TemplateDemo04 - Win32 Debug--------------------
2 Compiling...
3 TemplateDemo04.cpp
4 g:\c++\cdaima\templatedemo04\templatedemo04.cpp(4) :
5 error C2062: type 'int' unexpected
6 Error executing cl.exe.
7
8 TemplateDemo04.obj - 1 error(s), 0 warning(s)

更改之后的TemplateDemo.cpp 

#include<iostream.h>

template<class T1,class T2,class T3>
T1 sum(T1 a,T2 b,T3 c){
    return a+b+c;
} 

void main(){
    cout<<sum<double,short,int>(1.1,3,257)<<endl;
}

　运行结果：　　　261.1　　　　　

 原作者演示实例如下：

 1 类模板非类型形参示例
 2 //模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。
 3 //类模板的定义
 4 template<class T>class A{public:T g(T a, T b); A();};  //定义带有一个类模板类型形参T的类A
 5 template<class T1,class T2>class B{public:void g();}; //定义带有两个类模板类型形参T1，T2的类B
 6 //定义类模板的默认类型形参，默认类型形参不适合于函数模板。
 7 template<class T1,class T2=int> class D{public: voidg();}; //定义带默认类型形参的类模板。这里把T2默认设置为int型。
 8 //template<class T1=int, class T2>class E{}; //错误，为T1设了默认类型形参则T1后面的所有形参都必须设置认默值。
 9
10 //以下为非类型形参的定义
11 //非类型形参只能是整型，指针和引用，像double，String, String **这样的类型是不允许的。但是double &，double *对象的引用或指
12 针是正确的。
13 template<class T1,int a> class Ci{public:void g();}; //定义模板的非类型形参，形参为整型
14 template<class T1,int &a>class Cip{public:void g();};
15 template<class T1,A<int>* m> class Cc{public:void g();}; //定义模板的模板类型形参，形参为int型的类A的对象的指针。
16 template<class T1,double*a>class Cd{public:void g();};  //定义模板的非类型形参，形参为double类型的引用。
17 class E{}; template<class T1,E &m> class Ce{}; //非类型模板形参为对象的引用。
18 //以下非类型形参的声明是错误的。
19 //template<class T1,A m>class Cc{}; //错误，对象不能做为非类型形参，非类型模板形参的类型只能是对象的引用或指针。
20 //template<class T1,double a>class Cc{}; //错误，非类型模板的形参不能是double类型，可以是double的引用。
21 //template<class T1,A<int> m>class Cc{}; //错误，非类型模板的形参不能是对象，必须是对象的引用或指针。这条规则对于模板型参
22 也不例外。
23 //在类模板外部定义各种类成员的方法，
24 //typeid(变量名).name()的作用是提取变量名的类型，如int a，则cout<<typeid(a).name()将输出int
25 template<class T>   A<T>::A(){cout<<"class A goucao"<<typeid(T).name()<<endl;} //在类模板外部定义类的构造函数的方法
26 template<class T> T A<T>::g(T a,T b){cout<<"class A g(T a,T b)"<<endl;} //在类模板外部定义类模板的成员
27 template<class T1,class T2>  voidB<T1,T2>::g(){cout<<"class g f()"<<typeid(T1).name()<<typeid(T2).name()<<endl;}
28 //在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致
29 template<class T1,int a>     voidCi<T1,a>::g(){cout<<"class Ci g()"<<typeid(T1).name()<<endl;}
30 template<class T1,int &a>    voidCip<T1,a>::g(){cout<<"class Cip g()"<<typeid(T1).name()<<endl;}
31 //在类外部定义类的成员时，template后的模板形参应与要定义的类的模板形参一致
32 template<class T1,A<int> *m> voidCc<T1,m>::g(){cout<<"class Cc g()"<<typeid(T1).name()<<endl;}
33 template<class T1,double* a> voidCd<T1,a>::g(){cout<<"class Cd g()"<<typeid(T1).name()<<endl;}
34
35 //带有默认类型形参的模板类，在类的外部定义成员的方法。
36 //在类外部定义类的成员时，template的形参表中默认值应省略
37 template<class T1,class T2>  voidD<T1,T2>::g(){cout<<"class D g()"<<endl;}
38 //template<class T1,class T2=int> void D<T1,T2>::g(){cout<<"class D k()"<<endl;} //错误，在类模板外部定义带有默认类型的形
39 参时，在template的形参表中默认值应省略。
40 //定义一些全局变量。
41 int e=2;  doubleed=2.2; double*pe=&ed;
42 A<int> mw; A<int> *pec=&mw; E me;
43
44 //main函数开始
45 int main()
46 { // template<class T>void h(){} //错误，模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行。
47 //A<2> m; //错误，对类模板不存在实参推演问题，类模板必须在尖括号中明确指出其类型。
48 //类模板调用实例
49 A<int> ma; //输出"class A goucao int"创建int型的类模板A的对象ma。
50 B<int,int> mb; mb.g(); //输出"class B g() int int"创建类模板B的对象mb，并把类型形参T1和T2设计为int
51 //非类型形参的调用
52 //调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果。任何局部对象，局部变量，局部对象的地址，局部
53 变量的地址都不是一个常量表达式，都不能用作非类型模板形参的实参。全局指针类型，全局变量，全局对象也不是一个常量表达式，不能
54 用作非类型模板形参的实参。
55 //全局变量的地址或引用，全局对象的地址或引用const类型变量是常量表达式，可以用作非类型模板形参的实参。
56 //调用整型int型非类型形参的方法为名为Ci，声明形式为template<class T1,int a> class Ci
57 Ci<int,3>//正确，数值R是一个int型常量，输出"class Ci g() int"
58 const int a2=3; Ci<int,a2> mci1; mci1.g(); //正确，因为a2在这里是const型的常量。输出"class Ci g() int"
59 //Ci<int,a> mci; //错误，int型变量a是局部变量，不是一个常量表达式。
60 //Ci<int,e> mci; //错误，全局int型变量e也不是一个常量表达式。
61 //调用int&型非类型形参的方法类名为Cip，声明形式为template<class T1,int &a>class Cip
62 Cip<int,e> mcip;  //正确，对全局变量的引用或地址是常量表达式。
63 //Cip<int,a> mcip1; //错误，局部变量的引用或地址不是常量表达式。
64 //调用double*类型的非类形形参类名为Cd，声明形式为template<class T1,double *a>class Cd
65 Cd<int,&ed> mcd; //正确，全局变量的引用或地址是常量表达式。
66 //Cd<int,pe> mcd1; //错误，全局变量指针不是常量表达式。
67 //double dd=3.3; //错误，局部变量的地址不是常量表达式，不能用作非类型形参的实参
68 //Cd<int,&e> mcd;  //错误，非类型形参虽允许一些转换，但这个转换不能实现。
69
70 //调用模板类型形参对象A<int> *的方法类名为Cc，声名形式为template<class T1,A<int>* m> class Cc
71 Cc<int,&mw> mcc; mcc.g(); //正确，全局对象的地址或者引用是常量表达式
72 //Cc<int,&ma> mcc;  //错误，局部变量的地址或引用不是常量表达式。
73 //Cc<int,pec> mcc2;  //错误，全局对象的指针不是常量表达式。
74
75 //调用非类型形参E&对象的引用的方法类名为Ce。声明形式为template<class T1,E &m> class Ce
76 E me1; //Ce<int,me1> mce1; //错误，局部对象不是常量表达式
77 Ce<int,me> mce;  //正确，全局对象的指针或引用是常量表达式。
78 //非类型形参的转换示例，类名为Ci
79 //非类型形参允许从数组到指针，从函数到指针的转换，const修饰符的转换，提升转换，整值转换，常规转换。
80 const short s=3; Ci<int,s> mci4†//正确，虽然short型和int不完全匹配，但这里可以将short型转换为int型
时间： 2024-10-31 21:44:33

C++模板的相关文章

MathType符号模板找不到了怎么办

  MathType符号模板消失示例 具体操作过程如下: 1.打开MathType软件进入到公式编辑状态,打开方式可以根据自己习惯来决定,可以在Word中通过"插入"--"对象"来完成,也可以双击现有的公式来打开,还可以直接双击MathType桌面图标来打开. 2.在MathType编辑窗口后,在MathType菜单栏中点击"视图"--"符号面板",再点击"视图"会发现"符号面板"的左边

PS设计教程之制作WordPress新闻博客模板

通常在第一次制作新闻博客模板,很难把握方向.这篇教程将为你提供如何在Adobe Photoshop中制作WordPress新闻博客主题的参考.该主题包括页眉区,图片轮换区域(包含特色文章,最近消息,按照分类显示,侧边栏,widget).如果你是初学者,跟着本教程一步一步来就可以.如果你有一定基础,亦可从本教程中获得新的收获. 点击图片,进行全屏预览. 本教程需用到的资源 · Search · 社交图标 第1步:创建文档 在PS中创建一个1200像素 x 1700像素的文档 标尺工具在本教程中非常

深入XSL(3)---模板规则和模式（转）

模板   深入XSL(3)---模板规则和模式翻译:孙一中  模板规则 模板规则由xsl:template元素来规定."match"属性标识了规则应用的源节点(集).xsl:template. 例如:一个XML文档可能包含下面的内容: This is an <emph>important</emph> point. 下列的模板规则匹配emph类型的元素,另有一个模板产生一fo:sequence 格式化对象,其font-weight属性为粗体(bold). <

jstl-jxls问题： excel模板中foreach的横向和纵向输出的问题

问题描述 jxls问题: excel模板中foreach的横向和纵向输出的问题 如图: 为什么纵向正常,横向时候index就出问题,而属性都是对的.求解

求数据库设计模板急急急

问题描述 求数据库设计模板急急急 自主选择一种系统,完成需求分析.概念设计.逻辑结构设计.规范化(3NF)及数据库的创建,并设计功能进行编程实现. 根据所选系统,自己设计多个功能,分别用存储过程.触发器完成. 存储过程或触发器的编程至少实现一个. 求好心人帮忙做一个,谢谢了 解决方案 应付作业最好能雇佣一个枪手帮你,像你这种费时不讨好的事情,想张口要现成的怕没人有时间帮你.既然网上找不到,就没办法了. 解决方案二: 好在你这种简单的需求,花个百把块钱在八戒网上发布下,很多人可以帮你做的. 解决方

前端-用php和mysql为我们实验室建立一个小网站，请问有没有合适的模板源码？

问题描述 用php和mysql为我们实验室建立一个小网站,请问有没有合适的模板源码? 自己在chinaz上下载了几个,但是不尽人意,希望有路过的朋友能够提供帮助,只有建立一个链接数据库的小网站,不用线上上运行,所以模板不用太复杂,前端有了就好,谢谢 解决方案 你应该说明网站用途,根据用途可以决定里的要用什么,只链接数据库使用phpadmin就好 解决方案二: 这样谁说你更想要的是前端的页面

用金山WPS模板制作精美简历

  临近年底,正是应届生求职以及职场人士跳槽高峰.一份好的简历虽然不至于点石成金,但是绝对可以成为最好的敲门砖,为您的面试添分加彩.WPS Office在线模板收集了多种多样的精美简历模板以及面试.求职攻略等,无论你是初入职场的毕业生,还是想要另谋高职的职场人士,都可以在这里找到适合你的一份简历! 用户登录WPS Office官网模板下载频道http://www.wps.cn/download/,在搜索框输入"简历"关键词,就可以下载各种类型的"简历"模板,据此打造

金山wps应用模板的使用技巧

  在金山wps文档中,为用户提供了非常多可以节约工作时间.提高工作效率的应用模板,不过,很多金山wps的用户却不知道,因此,小编今天就跟大家分享一下金山wps应用模板的使用技巧吧,让文档的处理变成填字游戏. 应用模板 用好模板 省时省力 模板是一个用来创建文档的原型,许多文字处理软件,都提供很多现成的模板,它们可以分别被用来制作不同类型的文本(备忘录.信件.新闻)稿,用户也可按需要定制模板.充分利用模板不仅可以使你在短时间内制作出相应的文件,而且形式.规格也会统一.美观. 1.选择模板 单击W

养车族必备实用WPS模板推荐

养车族怎样精明消费,用最少的钱跑最多的路,省钱省钱再省钱?要付诸行动的话最好有一张记账表来帮助你.金山WPS Office帮各位找到一些很容易上手使用的省油.交通.驾驶相关的WPS模板,希望各位养车一族少一些烦恼,多一些快乐! 用户登录WPS Office官方论坛(http://bbs.wps.cn/ ),可以看到WPS汽车交通类模板专题 (http://bbs.wps.cn/thread-21931824-1-1.html),上面列举了各种类型的"交通"模板,包括买车合同.油耗登记表

《Programming WPF》翻译 第5章 7.控件模板

如果仔细的看我们当前的TTT游戏,会发现Button对象并没有完全为我们工作 .哪些TTT面板有内圆角? 图5-14 这里,我们真正需要的是能够保持按钮的行为,如支持内容和点击事件,但 是我们想要接管这些按钮的外观.WPF允许这种方式,因为内在的控件创建的时 候是缺少外观性的,例如,他们提供行为,但是外观可以被完全包装在客户端控 件的外面. 还记得我们是如何使用数据模板,来为非可视化对象提供外观的么?我们能 够使用控件模板对控件做同样的事情,这将是一组StoryBoard,触发器,以及大 多数重