如：

void myfun(int i){    ………………}int myfun(int i){  	………………}// 这种重载是错误的

建立一个通用函数，其函数类型和形参类型不具体指定，而是一个虚拟类型。

应用情况：

凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。

一般形式：template < typename T> // 模板头 通用函数定义template <class T> // 模板头 通用函数定义template <class T1,typename T2> // 多个参数 通用函数定义

说明： class与typename可以通用

#include <iostream>using namespace std;template<typename T> // 模板声明，其中T为类型参数T max(T a, T b) // 定义一个通用函数， T作为虚拟的类型名{if(b>a) 		return b;else   	return a;}//template <typename T> T max(T a, T b)//{//…//}int main( ){    int i1=111, i2=222, i;    double d1=12.34, d2=56.78,d;    i=max(i1,i2); // 调用模板函数，此时T被 int 取代    d=max(d1,d2,d3); // 调用模板函数，此时T被 double 取代    cout<<"i_max=" << i <<endl;    cout<<"f_max=" <<f<<endl;      return 0;}

int max(int a,int b){  	if(b>a) a=b;  	if(c>a) a=c;  	return a;}

通常情况下，如果有两个同名变量，一个是全局的，另一个是局部的，那么局部变量在其作用域内具有较高的优先权。

下面的例子说明了这个问题。

#include "iostream.h"int avar=10;main( ){  int avar;  avar=25;  cout<<"avar is"<<avar<<endl;    return 0;}

如果希望在局部变量的作用域内使用同名的全局变量，可以在全局变量加上“::”，此时::avar代表全局变量avar

#include <iostream.h>int avar=10;main(){    int avar;    avar=25;    cout<<"local avar ="<<avar<<endl;    cout<<"global avar="<<::avar<<endl;    	return 0;}

无名联合是C++中的一种特殊联合，可以声明一组无标记名共享同一段内存地址的数据项。如：

union{    int i;    float f;}

在此无名联合中，声明了变量i和f具有相同的存储地址。无名联合可通过使用其中数据项名字直接存取，例如可以直接使用上面的变量i或f，如：i=20;

13. 强制类型转换

在C中数据类型转换的一般形式：（数据类型标识符）表达式

int i=10;float x=(float) i;

C++支持这样的格式，还提供了一种更为方便的函数调用方法，即将类型名作为函数名使用，使得类型转换的执行看起来好像调用了一个函数。形式为：数据类型标识符 （表达式）

int i=10;float x=float(i);

以上两种方法C++都接受，但推荐使用后一种方式。

14. 动态内存分配

作为对C语言中malloc和free的替换，C++引进了new和delete操作符。它们的功能是实现内存的动态分配和释放。

动态分配new的一般形式是：

指针变量=new 数据类型；指针变量=new 数据类型(初始值);

int *a， *b;a=new int;b=new int(10);

释放由new操作动态分配的内存时，用delete操作。

它的一般形式是：delete 指针变量;

delete a;delete b;

#include <iostream.h>main(){    int *p; // 声明一个整型指针变量p    p=new int; // 动态分配一个存放int型数据的内存空间，并将首地址赋给p    *p=10;    cout<<*p;    delete p; // 释放指针变量p指向的内存空间    return 0;}

#include<iostream.h>#include<string.h>struct person {    char name[20];    int age;};main(){    person *p;    p=new person;    strcpy(p->name， "Wang Fun");    p->age=23;    cout<<"\n"<<p->name<<" "<<endl<<p->age;    delete p;      return 0;}

与C的内存动态分配和释放操作（malloc和free）相比，C++提供的动态分配有以下优点

(1) new和delete 操作自动计算需要分配和释放类型的长度。这不但省去了用sizeof计算长度的步骤，更主要的是避免

了内存分配和释放时因长度出错带来的严重后果；(2) new操作自动返回需分配类型的指针， 无需使用强制类型转换；(3) new操作能初始化所分配的类型变量。(4) new和delete都能可以被重载，允许建立自定义的内存管理法。对使用new和delete的几点说明：(1)用new分配的空间，使用结束后应该用delete显示的释放，否则这部分空间将不能回收而变成死空间。(2)使用new动态分配内存时，如果没有足够的内存满足分配要求， new将返回空指针(NULL)。因此通常要对内存的动态分配是否成功进行检查。例1.11 对内存的动态分配是否成功进行检查

#include <iostream.h>main(){    int * p;    p=new int;    if(!p)    {        cout<<"allocation failure\n";        return 1;		}    *p=20;    cout<<*p;    delete p;    return 0;}

(3) 使用new可以为数组动态分配内存空间这是需要在类型后面缀上数组大小。其语法形式为：

指针变量=new 类型名 [下标表达式];

例如： int *pi=new int[10];

这时new为具有10个元素的整型数组分配了内存空间，并将首地址赋给了指针pi。使用new为多维数组分配空间时，必须提供所有维的大小，如： int *pi=new int[2][3][4];其中第一维的界值可以是任何合法的表达式，如：int i=3; int *pi=new int[ i ][2][3];

(4) 释放动态分配的数组存储区时，可使用delete运算符，其语法形式为： delete [ ]指针变量;

无须指出空间的大小，但老版本的Cpp要求在delete的方括号中标出数字，以告诉Cpp要释放多少个元素所占的空间。例如：delete []pi; delete [10]pi;

(5) new可在为简单变量分配内存空间的同时，进行初始化。这时的语法形式为：指针变量=new 类型名(初始值列表)

例 1.12 new为简单变量分配内存空间的同时，进行初始化

#include <iostream.h>int main(){    int *p;    p=new int(99); // 动态分配内存，并将99作为初始值赋给它    if (!p)    {        cout<<"allocation failure\n";        return 1;    }    cout<<*p;    delete p;      return 0;}

#include <iostream.h>main(){    double *s;    s=new double[10];    if(!s){    cout<<"alocation failure\n";    return 1;}    for(int i=0;i<10;i++)        s[i]=100.00+2*i;    for(int i=0;i<10;i++)        cout<<s[i]<<" ";    delete []s;    return 0;}

引用就是某一变量（目标）的一个别名，这样对引用的操作就是对目标的操作。

引用的声明方法： 类型标识符 &引用名=目标变量名;

int a;int &ra=a; //定义引用ra,它是变量a的引用，即别名

说明：（1） &在此不是求地址运算，而是起标识作用。（2） 类型标识符是指目标变量的类型。（3）声明引用时，必须同时对其进行初始化。（4）引用声明完毕后，相当于目标变量名有两个名称。（5）声明一个引用，不是新定义了一个变量，系统并不给引用分配存储单元。例1.15 引用的使用

#include <iostream.h>void main(){    int i;    int &j=i;    i=30;    cout<<"i="<<i<<"j="<<j<<"\n";    j=80;    cout<<"i="<<i<<"j="<<j<<"\n";    cout<<"Address of i"<<&i<<"\n";    cout <<"Address of j"<<&j<<"\n";}

结果：

i=30 j=30i=80 j=80Address of oxfff4Address of oxfff4

例1.16 使用引用可以简化程序

#include<iostream.h>main(){    int i=15;    int* iptr=&i;    int & rptr=i;    cout<<" i is "<<i<<endl;    cout<<" *iptr is "<<*iptr<<endl;    cout<<" rptr is "<<rptr<<endl;    i=29;    cout<<" After changing i to 29： "<<endl;    cout<<" i is "<<i<<endl;    cout<<" *iptr is "<<*iptr<<endl;    cout<<" rptr is "<<rptr<<endl;      return 0;}

运行结果：

i is 15

*iptr is 15

rptr is 15After changing i to 29：

i is 29

*iptr is 29

rptr is 29

(2) 引用的使用（1）引用名可以是任何合法的变量名。除了用作函数的参数或返回类型外，在声明时，必须立即对它进行初始化，不能声明完后再赋值。

int i;int &j;j=i;

int i=5;int &j1=i; int &j2=j1;int num=50;int & ref=num;int *p=&ref;

#include <iostream.h>void main(){    int *a; //定义指针变量a    int *&p=a; //定义引用p，初始化为指针变量a，所以p是a的引用（别名）    int b=10;    p=&b; //等价于a=&b，即将变量b的地址赋给a。    cout<<*a<<endl; //输出变量b的值    cout<<*p<<endl; //等价于cout<<*a;    cout<<a<<endl; //输出a和p的地址    cout<<p<<endl;}

int a;int & & ra=a; //错误int &*p=&ra; //错误

（5）不能建立数组的引用，因为数组是一个由若干个元素所组成的集合，所以就无法建立一个数组的别名。

（6）不能建立空指针的引用

int &rp=NULL; //错误

void &ra=3; //错误

int j=5;int& i=j; // 声明引用i， "&"为引用运算符i=123; // 使用引用i，不带引用运算符int *pi=&i; // 在此， "&"为地址操作符cout<<π // 在此， "&"为地址操作符

void swap(int &p1, int &p2) //形参p1, p2都是引用{    int p;    p=p1;    p1=p2;    p2=p;}

在主调函数的调用点处，直接以变量作为实参进行调用即可，不需要实参变量有任何的特殊要求。

swap(a,b); //直接以a和b作为实参调用swap函数

#include<iostream.h>void swap(int *m， int *n){    int temp;    temp=*m;    *m= *n;    *n=temp;}main(){    int a=5， b=10;    cout<<"a="<<a<<" b="<<b<<endl;    swap(&a， &b);    cout<<"a="<<a<<" b="<<b<<endl;    return 0;}

运行结果：

a=5 b=10a=10 b=5

例1.18 采用“引用参数”传递函数参数

#include <iostream.h>void swap(int& m， int& n){    int temp;    temp=m;    m=n;    n=temp;}main(){    int a=5， b=10;    cout<<"a="<<a<<" b="<<b<<endl;    swap(a， b);    cout<<"a="<<a<<" b="<<b<<endl;    return 0;}

运行结果：

a=5 b=10a=10 b=5

(4) 用引用返回函数值

函数可以返回一个引用，将函数说明为返回一个引用的主要目的是：为了将函数用在赋值运算符的左边。

要以引用返回函数值，则函数定义时要按以下格式：

类型标识符 &函数名（形参列表及类型说明）

{函数体}

说明以引用返回函数值，定义函数时需要在函数名前加&用引用返回一个函数值的最大好处是，在内存中不产生被返回值的副本。例1.19 返回引用的函数

#include <iostream.h>int a[]={1， 3， 5， 7， 9};int& index(int); // 声明返回引用的函数void main(){    cout<<index(2)<<endl;    index(2)=25; // 将a[2]重新赋值为25    cout<<index(2)<<endl;}int& index(int i){    return a[i];}

#include<iostream.h>int A[10];int& array(int i);void main(){    int i， number;    A[0]=0;    A[1]=1;    cin>>number;    for (i=2;i<number;i++)    {        array(i)=array(i-2)+array(i-1);        cout<<"array("<<i<<")="<<array(i)<<endl;    }}int& array(int i){    return A[i];}

运行结果：

array(2)=1array(3)=2array(4)=3array(5)=5array(6)=8array(7)=13array(8)=21array(9)=34

在定义返回引用的函数时，注意不要返回该函数内的自动变量 (局部变量)的引用，由于自动变量的生存期仅限于函数内部，当函数返回时，自动变量就消失了。

int& fun(){    int a;    //...    return a;}

void swap(int *p1, int *p2){    int p;    p=*p1; //必须用“*指针变量名”的形式操作目标变量    p1=*p2;    *p2=p;}main(){    int a,b;    cin>>a>>b;    swap(&a,&b); //必须以变量a和b的地址作为实参    cout<<a<<b;}

由于函数的返回值是通过函数体中的return语句完成的，但一个return语句只能返回一个值，为此，我们可以采用以下方法：

（1）利用全局变量的方法：在函数中把所需数据保存在全局变量中。当被调函数执行完毕后在主调函数中直接读取全局变量的值即可。（2）使用指针或数组的方法：指针作为函数参数的情况下，可将主调函数的某些变量的地址传递给被调函数。（3）利用引用的方法：使用引用传递参数，可以在被调函数中改变主调函数中目标变量的值，这种方法实际上就是可以使被调函数返回多个值。例 使用引用使函数返回多个值

以下定义了可以同时返回10个数中的最大值和最小值的函数max_min。

#include <iostream.h>void max_min(int *p,int n,int &max,int &min);//声明函数max_minvoid main(){    int a[10];    int ma,mi;    int i;    for(i=0;i<10;i++)    cin>>a[i];    max_min(a,10,ma,mi); //调用函数max_min    cout<<ma<<mi;}void max_min(int *p,int n,int &max,int &min)//形参max 和min定义成引用{    int i=0;    max=*(p+i);    min=*(p+i);    for(i=1;i<n;i++)    {        if(max<*(p+i))        		max=*(p+i); //实质上就是对实参变量ma赋值        if(min>*(p+i))    				min=*(p+i); //实质上就是对实参变量mi赋值		}}

#include <iostream.h>float temp; //定义全局变量tempfloat fn1(float r); //声明函数fn1float &fn2(float r); //声明函数fn2float fn1(float r) //定义函数fn1，它以返回值的方法返回函数值{    temp=(float)(r*r*3.14);    return temp;}float &fn2(float r) //定义函数fn2，它以引用方式返回函数值{    temp=(float)(r*r*3.14);    return temp;}void main() //主函数{    float a=fn1(10.0);//第1种情况，系统生成要返回值的副本(即临时变量)    float &b=fn1(10.0);//第2种

情况，可能会出错(不同C++系统有不同规定)    //不能从被调函数中返回一个临时变量或局部变量的引用    float c=fn2(10.0); //第3种情况，系统不生成返回值的副本    //可以从被调函数中返回一个全局变量的引用    float &d=fn2(10.0); //第4种情况，系统不生成返回值的副本    //可以从被调函数中返回一个全局变量的引用    cout<<a<<c<<d;}

一个返回引用的函数值作为赋值表达式的左值

一般情况下，赋值表达式的左边只能是变量名，即被赋

值的对象必须是变量，只有变量才能被赋值，常量或表达式不能被赋值，但如果一个函数的返回值是引用时，赋值号的左边可以是该函数的调用。

例2-26 测试用返回引用的函数值作为赋值表达式的左值。

#include <iostream.h>int &put(int n);int vals[10];int error=-1;void main(){    put(0)=10; //以put(0)函数值作为左值， 等价于vals[0]=10;    put(9)=20; //以put(9)函数值作为左值， 等价于 vals[9]=10;    cout<<vals[0];    cout<<vals[9];}int &put(int n){    if (n>=0 && n<=9 )    		return vals[n];    else{        cout<<”subscript error”;        return error;		}}

声明方式： const 类型标识符 &引用名=目标变量名;

用这种方式声明的引用，不能通过引用对目标变量的值进行修改，从而使引用的目标成为const，达到了引用的安全性。

例2-27

#include “iostream.h”double &fn(const double &pd){    static double ad=32;    ad+=pd;    cout<<pd<<endl;    return ad;}void main(){    double a=100.0;    double &pa=fn(a);    cout<<pa<<endl;    a=200.0;    pa=fn(a);    cout<<pa<<endl;}

程序运行的结果

100

132

200

332

引用总结（1）在引用的使用中，单纯给某个变量取个别名是毫无意义的，引用的目的主要用于在函数参数传递中，解决大对象的传递效率和空间不如意的问题。（2）用引用传递函数的参数，能保证参数传递中不产生副本，提高传递的效率，且通过const的使用，保证了引用传递的安全性。（3）引用与指针的区别是，指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作，程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。课后练习题目

#include<iostream.h>int &max(int &num1,int &num2); // 返回一个较大值int &min(int &num1,int &num2); // 返回一个较小值main(){    int num1， num2;    cout<<"Enter the first number: ";    cin>>num1;    cout<<"Enter the second number: ";    cin>>num2;    max(num1,num2)=0;    cout<<"\nAfter putting zero in largest, the numbers are";    cout<<"\n"<<num1<<" and "<<num2<<"\n";    cout<<"\nNow， please enter two more numbers.\n";    cout<<"Enter the first number :";    cin>>num1;    cout<<"Enter the second number:";    cin>>num2;    min(num1， num2)=0;    cout<<"\nAfter putting zero in smallest the numbers are";    cout<<"\n"<<num1<<" and "<<num2<<"\n";    return 0;}int &max(int &num1,int &num2){		return (num1>num2)?num1:num2;}int &min(int &num1,int &num2){		return (num1<num2)?num1:num2;}

总之，C++对C语言进行了丰富的补充，使得程序开发更加灵活、高效和可靠。