例：

参数类形不同：

int add(int x,int y);

float add(float x,float y);

参数个数不同：

int add(int x,int y);

int add(int x,int y,int z);

注意：

重载函数的形参必须不同：个数不同或类型不同。

编译程序将根据实参和形参的类型及个数的最佳匹配来选择调用哪个函数。

int add(int x,int y);

int add(int a,int b);

编译器不以形参名来区分

int add(int x,inty);

void add(int x,inty);

编译器不以返回值来区分

不要将不同功能的函数声明为重载函数，以免出现调用结果的误触，混淆。这样不好：

int add(int x,int y) ｛return x+y;}

float add(float x,float y) ｛return x-y;}

例：编写三个名为add的重载函数，分别实现两整数相加，两实数相加和两个重复数相加的功能。

#include<iostream.h>

struct complex

{

double real;

double imag;

}

int add(int m,int n) {return m+n;}

double add(double x,double y) {return x+y;}

complex add(complex c1,complex c2) {

complex c;

c.real=c1.real+c2.real;

c.imag=c1.imag+c2.imag;

return c;

}

void main(void)

{

int m,n;

double x,y;

complex c1, c2, c3;

int add(int m,int n);

double add(double x,double y);

complex add(complex c1,complex c2);

cout<<"Enter two integer:";

cin>>m>>n;

cout<<"integer"<<m<<'+'<<n<<"="<<add(m,n)>>endl;

cout<<"Enter two real number:";

cin>>x>>y;

cout<<"real number"<<x<<'+'<<y<<"="<<add(x,y)<<endl;

cout<<"Enter the first complex number:";

cin>>c1.real>>c1.imag;

cout<<"Enter the second complex number:";

cin>>c2.real>>c2.imag;

c3=add(c1,c2);

cout>>"complex number("<<c1.real<<','<<c1.imag<<")+("<<c2.real<<','<<c2.imag<<")=(<<c3.real<<','<<c3.imag<<")\n";

}

二函数模板

  函数模板可以用来创建一个通用功能的函数，以支持多种不同形参，进一步简化重载函数的函数体设计。

声明方法：

template<typename 标识符>

函数声明

例：

#inclue<iostream.h>

template<typename T>

T abs(T x)

{ return x<0?-x:x; }

void main()

{

int n=-5;

double d=-5.5;

cout<<abs(n)<<endl;

cout<<abs(d)<<endl;

}

分析：

编译器从调用abs()时实参的类型，推导出函数模板的类型参数。例如，对于调用表达式abs(n),由于实参n为int型，所以推导出模板中类型参数T为int.

当类型参数的含义确定后，编译器将以函数模板为样板，生成一个函数：

int abs(int x)

{ return x<0?-x:x; }

三类模板

使用类模板使用户可以为类声明一种模式，使得类中的某些数据成员，某些成员函数的参数，某些成员函数的返回值，能取任意类型（凶手系统定义的和用户自定义的）。

template<模板参数表》

类声明

定义一个类模板与定义函数模板的格式类似，必须以关键字template开始，后面是尖括号括起来的模板参数，然后是类名，其格式如下：

template<class Type>

class类名｛

···

···

｝;

其中template是一个声明模板的关键字，它表示声明一个模板。关键字class表明后面的Type是模板参数。

例：

#include<iostream.h>

#include<math.h>

template<class T>

class complex

{

private:

T real;

T imag;

public:

complex(T r=0.0,T i=0.0) { real=r; imag=i;}

T realcomplex() { return real;}

T imagcomplex() { return imag;}

T abscomplex() { double t;  t=(double)real*real+(double)imag*imag; return sqrt(t); }

注意：

在类定义体外定义成员函数时，若此成员函数中有模板参数存在，则需要在函数体外进行模板声明，并且在函数名前的类名后缀上"<Type>"

例如，成员函数在类外定义为：

template<class T>

T complex<T>::reakcomplex() 

{ return real; }

类模板不代表一个具体的，实际的上，类模板的使用就是将类模板实例化成一个具体的类，它的格式为：

类名《实际的类型》对象名；

例如，使用上面的类模板，创建两个模板参数为double型的对象，语句如下：

complex<double>s1,s2;

创建两个模板参数为int型的对象，语句如下：

complex<int>s1,s2;