C++模板

来源：互联网发布：linux yum命令有什么用编辑：程序博客网时间：2024/05/01 11:23

（1）什么是类模板

一个类模板（也称为类属类或类生成类）允许用户为类定义一种模式，使得类中的某些数据成员、默写成员函数的参数、某些成员函数的返回值，能够取任意类型（包括系统预定义的和用户自定义的）。

如果一个类中数据成员的数据类型不能确定，或者是某个成员函数的参数或返回值的类型不能确定，就必须将此类声明为模板，它的存在不是代表一个具体的、实际的类，而是代表着一类类。

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

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

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

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

（2）类模板通式

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函数中声明或定义一个模板。

（3）模板的形参

有三种类型的模板形参：类型形参，非类型形参和模板形参。

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

编译结果：

--------------------Configuration: TemplateDemo - Win32 Debug--------------------
Compiling...
TemplateDemo.cpp
G:\C++\CDaima\TemplateDemo\TemplateDemo.cpp(12) : warning C4244: 'argument' : conversion from 'const double' to 'int', possible loss of data

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_HXXtemplate<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：

#ifndef TEMPLATE_DEMO_O1#define TEMPLATE_DEMO_01template<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;}

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

0 0