C++模板

最新推荐文章于 2025-06-19 15:48:38 发布

michael_dingtao

最新推荐文章于 2025-06-19 15:48:38 发布

阅读量676

点赞数

分类专栏： C/C++ 文章标签： c++ class float delete c

C/C++ 专栏收录该内容

18 篇文章

订阅专栏

若一个程序的功能是对某种特定的数据类型进行处理，则将所处理的数据类型说明为参数，就可以把这个程序改写为模板。 C++ 程序由类和函数组成，所以 C++ 的模板也分为类模板和函数模板。

1、函数模板的定义：

• 函数模板的一般定义形式：

template < 类型形式参数表 > 返回类型 FunctionName( 形式参数表 )

{

// 函数定义体

}

• 说明：⒈ < 类型形式参数表 > 可以包含基本数据类型，也可以包含类类型。若是类类型，则须加前缀 class 。

⒉这样的函数模板定义不是一个实实在在的函数，编译系统不为其产生任何执行代码。该定义只是对函数的描述，表示它每次能单独处理在类型形式参数表中说明的数据类型。

⒊当编译系统发现有一个函数调用： FunctionName( 实在参数表 ); 将根据实在参数表中的类型，确认是否匹配函数模板中对应的形式参数表，然后生成一个重载函数。该重载函数的定义体和函数模板的函数定义体相同，而形式参数表的类型则以实在参数表的实际类型为依据。该重载函数称为模板函数。

• 函数模板与模板函数的区别：

函数模板是模板的定义，定义中用到通用类型参数。

模板函数是实实在在的函数定义，它由编译系统在碰见具体的函数调用时所生成，具有程序代码。

例 1 ：

#include <iostream.h>

template <class T>

T Max(T a,T b)

{

return a>b?a:b;

}

void main()

{

cout<<"Max(3,5) is "<<Max(3,5)<<endl;

cout<<"Max('3','5')is "<<Max('3','5')<<endl;

}

运行结果为： Max(3,5) is 5

Max(‘ 3' ,' 5' ) is 5

分析：当编译程序发现 Max(3,5) 调用时，它就产生一个如下一个函数定义，生成其程序代码：

int Max(int a,int b)

{

return a>b?a:b;

}

当发现 Max(‘ 3' ,' 5' ) 调用时，它又产生另一个如下的函数定义，也生成其程序代码：

char Max(char a,char b)

{

return a>b?a:b;

}

这样实参是什么数据类型，返回值也是什么类型，避免了相同操作的重载定义。

另外可以象重载普通函数那样重载模板函数。

例 2 ：

#include <iostream.h>

template <class>T

T max(T a,T b)

{

return a>b?a:b;

}

char *max(char *a,char *b)

{

return (strcmp(a,b)?a:b);

}

void main()

{

cout<<”Max(/”hello/”,/"gold/” is “<<Max(/”hello/”,/"gold/”)<<endl;

}

函数 char *max(char *,char *) 中的名字 max 与函数模板的名字相同，但操作不同，这种情况就是重载模板函数。编译程序在处理这种情况时，首先匹配重载函数，然后再寻求模板的匹配。该程序中， max(“hello”,”gold”) 调用，匹配了非模板函数 char *(char *,char *) 。

2、类模板的定义：

• 类模板的一般定义形式：

template< 类型形式参数表 > class classname

{

// 类声明体

}

template < 类型形式参数表 > 返回类型 classname< 类型名表 >:: :MemberFunctionname1( 形式参数表 )

{

// 成员函数定义体

}

template < 类型形式参数表 > 返回类型 classname< 类型名表 >::MemberFunctionname2( 形式参数表 )

{

// 成员函数定义体

}

template < 类型形式参数表 > 返回类型 classname< 类型名表 >::MemberFunctionnamen( 形式参数表 )

{

// 成员函数定义体

}

• 说明：⒈其中的类型形式参数表与函数模板中的意义一样。后面的成员函数定义中， classname< 类型名表 > 中的类型名表是类型形式参数的使用。

⒉这种类模板的定义其实只是对类的描述，不是具体的类。

⒊建立类模板后，可以通过创建类模板的实例来使用该类模板。

Classname < 类型实在参数表 > object;

• 类模板与模板类的区别：

类模板是模板的定义，不是一个实在的类，定义中用到通用类型参数。

模板类是实在的类定义，是类模板的实例化。类定义中参数被实际类型所代替。

例 3

#include <iostream.h>
#include <stdio.h>
template <typename T>
class AType
{
public:
AType(T a = T(0)) :a_(a){}
operator T(){ return T(a_); };
AType& operator++(){ a_++; return *this;}
AType operator++(int){ AType t(*this); ++a_; return t; }
int operator > (const AType &t)
{
if( a_ > t.a_) return 1;
else if(a_ < t.a_) return -1;
else return 0;
}
AType operator+(const AType &t)
{
AType a(*this);
a.a_ += t.a_;
return a;
}
AType operator-(const AType &t)
{
AType a(*this);
a.a_ -= t.a_;
return a;
}

private:
T a_;
};
int main(int argc,char *argv[])
{
AType<int> i1=10,i2;
AType<double> d1(1.5),d2=1,d3=0.5;
printf("i1+i2=%d/n", int(i1+i2)); //10
printf("d1-d2=%0.1f/n",double(d1-d2)); //0.5
printf("i2++=%d/n", int(i2++)); //0
printf("i2=%d/n", int(i2)); //1
printf("i1>i2=%d/n", i1>i2); //0
printf("d1>d2=%d/n", d1>d2); //1
printf("d3>d2=%d/n", d3>d2); //-1
return 0;
}

例4

/*-------------------
设计
   template<模板形参表>
   class<类名>
   {
    <类模板体定义>
   };

使用
显示方式给类模板传递实例化参数

--------------------*/

//C++类模板

#include <iostream>
using namespace std;

template<class numtype>

class Compare
{
public:
Compare(numtype a,numtype b)
{
   x=a;
   y=b;
}
numtype max()
{
return (x>y)?x:y;
}
numtype min()
{
   return (x<y)?x:y;
}
private:
numtype x,y;
};

int main()
{
Compare<int> cmp1(3,7);
cout<<cmp1.max()<<"/tis the Maximum of two inteder numbers."<<endl;
cout<<cmp1.min()<<"/tis the Minimum of two inteder numbers."<<endl<<endl;
Compare<float> cmp2(45.78,93.6);
cout<<cmp2.max()<<"/tis the Maximum of two float numbers."<<endl;
cout<<cmp2.min()<<"/tis the Minimum of two float numbers."<<endl<<endl;
Compare<char> cmp3('a','A');
cout<<cmp3.max()<<"/tis the Maximum of two characters."<<endl;
cout<<cmp3.min()<<"/tis the Minimum of two characters."<<endl;
return 0;
}

例5

#include<iostream.h>
template<class C>
C square(C num,C &result)
{
result = num *num;
return result;
}

template<class T>
class Array
{
public:
    int getlength()
    {
        return length;
    }
    T & operator[](int i)
    {
        return array[i];
    }

    Array(int l)
    {
        length=l;
        array=new T [length];
    }
    ~Array()
    {
        delete [] array;
    }
private:
    int length;
    T * array;
};