《C++程序设计教程》课件第3章

3.1函数重载

3.2内联函数

3.3引用

3.4友元

3.5名空间

本章要点

练习

3.1.1重载的概念

在C中，在同一个程序中声明两个同名函数是一种语法错误。而在C++中只要函数命名了不同的参数集，就允许用同一名字定义多个函数。C++的这种能力称为函数重载。下面就用C++中提供的重载机制来实现本章开始时提出的求绝对值问题。

【例3-1】演示通过重载求x的绝对值。3.1函数重载通过重载的方法只用了一个函数名Fun，分别实现了求long、double和int类型数的绝对值。重载的优点包括：对于不同的数据类型完成类似的操作；对于函数名的取名，可以见名知义，消除了在同一操作中使用不同函数名称的情况；有助于轻松理解和调试代码；使代码维护变得更加容易。3.1.2匹配重载函数的顺序

匹配重载函数是由编译器完成的。编译器通过函数名和其参数类型识别重载函数。编译器在识别时，通过参数个数、参数类型和参数的次序确定被匹配的函数，并对每一个函数的标识符进行特别编码，以便实现匹配的唯一性。这一过程有教材称为“名字改编”或“名字修饰”。在匹配重载函数时按优先级进行，具体步骤为：先寻找是否有严格匹配(所谓严格匹配，就是同类型的匹配)，然后通过内部数据转换寻找是否有匹配。

对于两个内部数据，系统能自动寻找匹配。如若有long和double形参，那么0、char和shortint等的实参，都是经内部数据转换后可匹配的参数类型。

【例3-2】演示重载函数的内部转换匹配，通过用户定义的转换寻找是否有匹配。其中要注意，对于带有const修饰的内部转换，只适用char*转换为constchar*；对于其他非指针类型的情况，就认为是严格匹配。如在下面的代码中，由于存在两个严格匹配函数而出错，去掉任何一个都可以。3.1.3对重载函数的要求

1．重载函数具有不同参数

重载函数至少在参数类型、参数个数或者参数顺序上有所不同。C++的函数如果在参数类型、参数个数、参数顺序上有所不同，则认为是不同的匹配，可以进行重载。如果仅仅只有函数的返回类型不同是不够的，重载将不能实现。

在C++中这样规定的理由就是要保证对重载的匹配只是针对单独的运算符或函数调用，而与调用环境无关。下面是不合要求的重载函数的例子。

2．函数重载要在同一作用域内

函数重载要在同一个作用域内才能实现。对于几个不同作用域中的函数是无法实现重载的。

【例3-3】函数重载与作用域的关系。

#include<iostream.h>

voidFun(intx)

{cout<<"int:"<<x<<endl;}运行结果：

double:100

显然Fun(100)最好的匹配应当是Fun(intx)，但是Fun(doubley)在main函数的局部作用域里，所以就优先匹配Fun(doublex)。若去掉函数声明，则两个函数在同一作用域中，可实现重载，于是输出int:100。

3．不要让重载执行不同的功能

重载的目的是：有助于轻松理解和调试代码，使代码维护变得更加容易，增加可读性。因此让重载执行不同的功能不是好的编程风格。同名函数应该具有相同的功能。3.1.4重载的实现

重载可以发生在非成员函数之间，也可以发生在同一类的成员函数之间或构造函数之间。总之，只要函数在同一作用域内，满足重载的要求就可以进行重载。

【例3-4】通过建一个表格类来演示在构造函数之间进行重载。

【例3-5】有两个类：Student和Tdate类，在这两个类中都有两个Set，其中一个是非成员函数Set。由于作用域的不同，Student类中的Set、Tdate类中的Set和非成员函数Set之间不能重载。在同一个类中的两个Set是重载函数。运行结果：

Thedateis2007/08/24

generalfunction

4

上面演示了重载成员函数的执行情况。重载成员函数既可以用对象名加分量运算符来访问，也可以用指针加分量运算符来访问。由于类名是成员函数名的一部分，因此一个类的成员函数与另一个类的成员函数或者普通函数即使同名，也不能实现重载。3.1.5重载的二义性

重载无需人工参与，在重载时由系统自动进行参数转换并寻找匹配。若同时出现多个可匹配重载函数，使得系统无法确定匹配哪个重载函数，我们将这种现象称为二义性。

要注意转换的二义性。对于内部自动转换是没有优先级的。假如实参是int，而形参同时有long和double，int既可以自动转换为long，也可以自动转换为double，这就出现了二义性。解决方法是进行显式转换。在Fun(1);的调用中出现了错误。数字1可以自动转换为double型，也可以自动转换为long型，没有优先级。若要明确匹配long，可用1L明示。较好的方法是进行显式转换。显式转换的方法：Fun(long(1));或Fun(double(1));。

函数可以带默认参数，同样，重载函数也可以带默认参数。有了带默认参数的函数，在给我们带来方便的同时也带来了二义性。如果有一组重载函数，由于它们都带有默认参数，那么即使是有不同参数个数的函数，也有可能出现二义性。函数调用需要使用栈，这些工作就需要一些时间开销。当函数体比较短小，功能简单，又需要频繁调用时，这种调用的系统开销相对而言就较大。如果不用调用函数的方式，而直接将代码写入，使其按顺序执行，这样就可以节省频繁调用时所需的时间和空间。

3.2内联函数在C中常用的方法是用预处理命令通过宏定义来实现。宏定义是命令，编译器并不作语法检查，它可能隐藏着危险，有时会得到错误的结果。例如，若有#definemultiply(x)x*x，则用y=multiply(5);可以得到y的值为25。若用z=multiply(2+3);，经过宏展开为2+3*2+3，z的值为11，这就出错了。解决方法是加上括号：#definemultiply(x)(x)*(x)。在C++中，既要提高程序执行的效率，又要减少麻烦，于是引入了内联函数。内联函数也称内嵌函数，它可以提高程序的运行效率，克服宏定义所带来的弊端。所谓内联或内嵌，就是将一段小程序经编译后放到程序中使其成为一体。

引入内联函数，优点是安全可靠、可读性好、效率高，缺点是程序代码比较长。3.2.1内联函数的实现

1．一般内联函数

内联函数既可作为成员函数，也可作为非成员函数。对于非成员的内联函数，我们称它为一般内联函数。例如：

inlineintFun(intx){returnx*x;} //定义内联函数Fun

voidmain()

{inty;y=Fun(2+3); } //y的值为25当编译器在编译时每遇到标有inline关键字的Fun函数后，就自动为它创建一段代码，以便每次碰到该函数的调用都用相同的一段代码来替换，提高效率与可读性。

对于main中的y=Fun(2+3);语句，括号中的参数会强制完成正确的运算，同时对传递的参数将作类型检查。若出现y=Fun(2.1+3.2f);或者y=Fun(2.1f+3.2f);的调用，马上给出警告。因此，内联函数既安全又可靠。要说明的一点是，内联函数不同于其他函数，在编译时，凡是出现调用内联函数处，总是用一段代码取代它。本例中内联函数的使用y=Fun(2+3);等价于{intx,y;y=(x=2+3,x*x);},这样程序运行时就可顺序执行，免去了函数调用的一切步骤，既省略了函数调用的时间开销，又避免了错误。内联函数实际上是用代码的空间来换取时间的。过多地使用内联函数会增加程序长度，因此不宜多用。2．内联成员函数

在C++中要使某一成员函数成为内联函数，有两种方法实现。方法一，直接将该函数的实现放在类的定义中。对于只有几行的函数，可以在类的定义体内部定义。如果一个成员函数在类定义的内部定义，那么该成员函数将自动成为内联函数。方法二，用inline声明。在类定义体外部的成员函数要想成为内联函数，则必须明确地使用关键字inline。若要将某函数声明为inline(内联函数)，则可在声明或定义中加入inline，或者两者都加入inline也可。

【例3-7】演示内联函数的实现。3.2.2内联函数的限制

内联函数也是函数，所以要遵循函数的规则，如，内联函数必须在被调用之前声明或定义，且仅声明一次。

内联函数是为提高程序运行效率而引入的，所以内联函数中不能含有复杂的结构控制语句。程序员若将含有复杂的结构控制语句的函数声明为内联函数，编译器会自动拒绝，编译时系统自动将该函数视同普通函数那样生成函数调用代码。也就是说，是否能真正成为内联函数，由程序员申请，编译器决定。内联函数中不能定义任何静态变量，不能说明数组。递归函数不能作为内联函数。一般来说，内联函数是1～5行的短函数，若语句较多也不要用内联函数。语句较多编译器不报错，只是自动将它视为非内联函数。3.3.1引用的概念

引用的概念就是给变量或对象取一个别名。我们现实生活中的人可以有别名，程序设计中的对象也可以有别名。在C++中给变量或对象取一个别名的方法称为引用。建立引用的方法：

类型&别名=目标名;

例如：intx;int&n=x;先定义了一个整型变量x，接着给变量x取了一个别名n。

引用不是值，不占存储空间。声明引用时，目标的存储状态不会改变。因此引用只有声明没有定义。3.3引用3.3.2引用的操作

由于引用仅仅是对象的别名或化身，因此引用必须在声明时初始化。这意味着从引用诞生起，它就是其他目标的别名，为别名而存在。从中也就告诉我们，若引用一个不存在的对象将是一个错误。

【例3-8】通过本例体会引用是别名，别名的行为就是目标的行为。#include<iostream.h>

voidmain()

{intx=3;int&a=x;

cout<<“x=”<<x<<“a=”<<a<<endl;

//引用作为目标的别名而使用

a=8;cout<<“x=”<<x<<“a=”<<a<<endl;

//对引用的改动就是对目标的改动

cout<<“&x=”<<&x<<“\t”<<“&a=”<<&a<<endl;

//引用的地址就是目标的地址

}

运行结果显示x和a的值相同，地址也相同。3.3.3引用的利弊

也许我们正在思考这样一个问题，好端端地为什么要多出一个引用，一个别名，别名做的事也算到原目标名的帐上，是否有点多此一举。

1．引用的优点

在C中，函数调用都是传值调用，函数不能访问调用程序中的原始变量，而只能访问为它而创建的副本。由于引用是某一对象的别名，因此在函数调用中，引用传递的就是原来的变量或对象，而不是函数作用域内建立的变量或对象副本。引用作为参数传递时具有指针作为函数参数的效果。下面我们将对C++中引入引用的一些优点作一介绍。

(1)引用具有指针的威力。引用传递的是原来的变量或对象，所以说引用具有指针的威力。引用具有传值方式函数调用语法的简单性与可读性，但威力却比传值方式强。

(2)引用可以避免对象拷贝。在对象的传递中，为避免拷贝对象的开销，可用引用的方式来传递对象。因为它仅是一个别名，不是另一个对象，不占有空间。因此引用作参数既节省空间，又节约时间。它随目标而产生，随目标的消亡而消亡。

(3)引用可以避免原始数据被修改。为了防止调用函数修改调用者的原始数据，可以用传递常量引用的方式传递这些数据。在C++中通常用指针传递要修改的参数，用引用常量的方法传递不要修改的参数。要想说明对常量的引用，只要把const限定符放在参数声明的类型说明前即可。

【例3-9】演示引用的威力。#include<iostream.h>

voidmain()

{voidswap(int&,int&);

intx=5,y=6;

cout<<"beforeswap:\t"<<"x="<<x<<""<<"y="<<y<<endl;

swap(x,y);

cout<<"afterswap:\t"<<"x="<<x<<""<<"y="<<y<<endl;

}voidswap(int&u,int&v)

{inttemp;

temp=u;u=v;v=temp;

}

运行结果：

beforeswap: x=5y=6

afterswap: x=6y=5从运行结果可知，x、y的值被交换了。在voidswap(int&u,int&v)中用引用作函数参数，这就意味着只要有参数传过来，它就是该参数的别名。因为u是x的别名，v是y的别名，对u、v的改变就是对x、y的改变。

2．引用存在的问题

任何事物都是一分为二的。在引用给我们带来方便的同时也带来了新的问题。下面就对可能出现的错误进行分析，以便在采用引用时权衡利弊。

(1)可能隐藏错误。在函数调用时，我们曾说过是拷贝调用，不用担心参数被修改的问题。然而有了引用后问题就出来了。现通过下面的代码来体会一下危险性。

intx=6;inty=8;

swap(x,y);对于swap(x,y);调用，没有看到被调函数原型之前，就不能确定实参x和y是否会在被调函数中被修改。请看下面的两个函数。

若被调函数是：

voidswap(intu,intv){intt=u;u=v;v=t;}

在函数调用时，通过参数拷贝，在swap中没有能力改变实参x和y的值，即x和y不会被交换。

若被调函数是：

voidswap(int&u,int&v) //x和y被交换

{intt=u;u=v;v=t;}在被调函数中的参数是引用，一旦接收到实参x和y，形参u和v就分别成为x和y的别名。那么对别名的改变就是对目标名的改变，实参x和y的值就可以被改变。

综合上面的分析可知引用的危险性，即在被调函数中可能隐藏着主调函数中参数被修改的可能性。

(2)可能引起编译错误。使用引用后，重载函数时可能引起编译错误。从上面的分析可知，同一函数swap的调用有两种可能的匹配方式，若两个被调函数同时出现，系统就不知道该匹配哪一个，这就引起了编译错误。voidswap(intx,inty){/*………*/}

voidswap(int&a,int&b){/*………*/}

voidmain()

{intx=6;inty=8;

swap(x,y);

}

对于swap(x,y)的函数调用，上面两个swap函数的参数虽然一个是变量，一个是引用，但都是整型参数，是同一类型。由于不能从函数调用中判断是值传递还是引用传递，因此无法确定swap(x,y);匹配哪一个函数。3.3.4引用规则

在建立引用时，是对同类数据类型的变量或对象的引用，不是对数据类型的引用。若一个变量声明为Type&，引用时它必须用Type类型的变量或对象初始化，或用能转换成Type类型的(变量或)对象初始化。例如，若有inta[8];int&b=a;则出错，因为对整型的引用，只能用整型变量初始化，不能用数组名。数组名是地址，是常量。

(1)在引用变量或对象时可以引用一个相同数据类型的变量或对象。例如：doublex,temp;floaty;

double&t=temp; //ok

double&t=x; //error，引用不能重名

double&z=y;

//error，引用了不同类型的变量

inta;int*&q=&a; //error，不能取一个地址的别名

float&w=float; //error，不能对类型引用

float&v=8.8f; //error，变量不能作为数据的别名

若是对常量的引用，则可以用constfloat&v=8.8f，即v就是8.8的别名。

(2)在引用指针变量时可以引用一个同类型的指针变量。例如：

int*p;inta;p=&a;

int*&q=p; //ok

即使p还没有指向也可以引用。例如：

int*p;int*&q=p; //ok

该句的语义是将int*的引用q初始化为p。虽然此时p还无指向，但也是引用的初始化。

inta=8;q=&a; //ok，对于指针变量的引用，可改变指向

由于q是p的别名，因此它们是同一个指针，现在q指向a，当然p也就指向a。

(3)不能建立引用数组。数组是某个数据类型元素的集合，数组名表示该集合空间的起始地址，而不是某个数据类型的变量或对象。如果有inta[8];int&b[8]=a;，则出错。

(4)若将引用作为类的数据成员，则必须初始化。例如：3.3.5指针和引用的区别

指针和引用有相同点，同时也存在着差别，主要表现在如下几个方面。第一，操作方式不同。指针是间接访问，而引用是直接访问。例如：int*p,a;p=&a;*p=8;通过p间接访问a空间。intb;int&q=b;q=9;由q直接访问b空间。第二，指针本身是一个变量，可以不初试化，而引用是别名，必须初试化；指针可以再指向其他变量，而引用一旦确立，就不能再作为其他变量的别名。3.4.1友元函数

在C++中提供了一个称为友元的函数，该函数就是类的朋友。友元函数不是类的成员函数，而是普通的C++函数，但它可以访问类的保护或私有成员，方便编程，提高效率。

一个普通函数可以是某类的友元，一个类的成员函数也可以是另一个类的友元，该函数就称为友元函数。3.4友元

1．友元函数声明

友元要在类中声明。因为友元不是类的成员，所以它不受其所在类的声明区域的影响，声明时既可以放在public区，也可以放在private区或protected区，结果是一样的。友元函数的定义必须放在类的外部，可以与该类成员函数的定义放在一起。

2．应用场合

普通函数需要访问类的保护或私有成员时，若没有友元机制，则只能将类的数据成员声明为公有的，那么任何函数都可以无约束地访问它。友元函数就是为了能在类之外访问类的保护或私有成员，而与类建立朋友关系的函数。一般在下列三种情况下要用到友元函数：

(1)要通过重载运算符实现某些类型对象的运算(将在第5章中介绍)。

(2)要简化创建某些类型的I/O函数的过程(将在第8章中介绍)。

(3)要将某些类型的特征进行互相关联或比较时。

3．使用方法

首先进行友元函数声明，然后在该类之外完成友元函数的实现。声明方法是在类中按声明一个普通函数的方法声明函数，并在该函数的类型前标上关键字friend，这时函数就成了该类的友元。在友元函数的实现部分，函数头不再需要加关键字friend，在函数体内完成所需功能。

【例3-10】若有凳子和桌子类，现要求比较颜色是否一样。本例中定义有两个全局对象，用来演示普通函数作为类的友元是如何访问对象的保护成员的。运行结果：

DeskandBencharedifferentcolor

在本例的两个类中，友元函数的声明位置不同，效果是一样的。本例实现了在一个普通函数中，将两个类的颜色特征进行相互比较的功能。将普通函数Check同时声明为Desk和Bench类的友元，那么在Check中就可以访问这两个类的所有成员。访问方法如同访问公有成员一样，即对象名.成员。

【例3-11】教师类中的成员函数Check和Display是学生类的友元函数，它们能访问学生的学号和课程，而教师类中的Test函数无此特权。通过本例演示一个类的成员函数作为另一个类的友元函数的实现方法。

#include<iostream.h>

classStudent; //Teacher用到Student类作参数，故作声明

classTeacher

{public:运行结果：

num=203course=4.5

本例演示了声明和定义友元函数的方法。因为教师类中有成员函数是学生类的友元函数，所以必须将Teacher类的定义放在Student类的定义之前。

在本例中又有学生类的引用作函数参数，如Teacher::Check(Student&)，因此就要在教师类的定义前加上学生类的声明。声明方法是：关键字class加上类名，如上面的classStudent;所示。

【例3-12】该例的描述中，将Teacher类的成员函数Fun声明为Student友元，又将普通函数Display和Show声明为Student友元。

#include<iostream.h>

classStudent; //类声明

classTeacher

{public:

voidassignGreads(int);

voidFun(Student&a);//以Student类的引用作为形参

private:

intnoofstudent;

};运行结果：

score=78

Newscore=88

Newscoreis:88

Thescoreis:0

该例同时演示了成员函数和普通函数作为友元函数，访问类中保护或私有成员的方法。从中也进一步得知友元函数的使用要慎重，因为它会破坏类的封装性。

4．关于友元的说明

在声明A类的成员函数为B类的友元时，要将A类的定义放在B类的定义之前。若A类的成员函数的参数中有C类的类型，则在A类的定义之前加上C类的声明或C类的定义，即要实现可知性。友元不是成员函数，它是类的朋友。既然是朋友，它就能访问类的全部成员。友元是单向的。如仅仅A是B的友元，则A能访问B类的全部成员，而B却不能访问A类的成员。即友元关系是“给予”，而不是“索取”。

友元机制在给我们带来好处的同时也产生了新的不足。正因为它可以访问类的保护或私有成员，而破坏了类的封装性。因此我们说，友元破坏了类的封装，在使用它时，要权衡利弊。3.4.2友元类

可以将整个类声明为另一个类的友元，该类就称为友元类或友类。友类中的每个成员函数都可以访问另一类中的保护或私有成员，这就减少了将所有成员函数都声明为友元的麻烦。

【例3-13】有Leader、Teacher和Student三个类，要求实现Leader中的object是Teacher的友元函数，可访问Teacher，Teacher是Student类的友类。运行结果：

score=78 //调用Student类的成员函数后得

Newscore=88 //调用Teacher类的成员函数后得

Numberofstudent35 //调用Leader类的成员函数后得

从运行结果来看，该例实现了有效访问。如最后一行的输出结果是调用Leader类的成员函数，在该成员函数中访问了Teacher类中的private成员noofstudent。

在上面的例子中，Teacher类是Student类的友类，Teacher类中的所有成员函数都可以访问Student类中的私有或保护成员；反之，Student类中的成员函数却不可以访问Teacher类中的私有或保护成员。3.4.3互为友类

若两个类之间需要相互访问，可以声明互为友类。这样两个类中的所有成员函数就都可以互访。这如同我们生活中的从个人朋友关系，发展到家庭之间的友谊而相互友好往来一样。

【例3-14】教师类与学生类互为友类。教师可修改学生的成绩，也可调整学时数。学生也可访问在校生总数。运行结果：

15000

score=87

hours=110

Numberofstudent:150003.5.1概念与作用

在C++中，可以将一些对象名限制在以某一标识符命名的空间内，该被命名的空间称为名空间。使用名空间是为了解决代码名的重复和排斥问题。名空间机制允许我们封装名字，否则名字可能会污染全局名空间(pollutetheglobalnamespace)。一般来说，当程序员希望自己的代码被外部软件开发部门使用时，才使用名空间。C++提供了一种机制，可以把相关数据、函数等组织到一个独立的名空间里。3.5名空间3.5.2实现方法

名空间的实现方法是：

namespace标识符{所有被封装在以该标识符命名的名空间内的名字声明}

例如，模块My_Newspace和You_Newspace的用户界面可以用下面的方法声明和使用：

//My_Newspace.h

//头文件名

#include<iostream.h>

namespaceMy_Newspace

{classArray关键字namespace后面的名字My_Newspace标识了一个名空间，它独立于全局名空间，我们可以在里面放一些希望在函数或类之外声明(定义)的实体。名空间不改变其中声明的意义，只改变它们的可见性。

若要定义一个对象，可以用：My_Newspace::Arrayma;You_Newspace::Arrayia;。这样一来，ma是我公司类的对象，ia是你公司类的对象。这样就避免了都使用相同名字Array而引发的名字冲突。

程序员希望访问名空间内声明的名字时不加限定修饰符，这时可以使用using指示符，使名空间内的所有声明都可见。

using与namespace都是关键字。usingnamespaceMy_Newspace;的语义是将模块My_Newspace中的所有名字统统放入全局名空间内。也就是说，所有在该名空间里声明的名字都成为本文件的全局名字。其中要注意两个问题：第一，被使用的名空间必须已经被声明了，否则会引起编译错误；第二，不要再声明与已可见名字相同的全局变量。为避免冲突，using声明还可以实现有选择的可见性。3.5.3嵌套名空间

用户声明的名空间允许嵌套，从而成为嵌套名空间。例如：

namespaceMy_NameA

{constdoublepi=3.1416;

namespaceMy_NameB若要声明类名字，可以用：My_NameA::My_NameB::Array。若要声明类成员名字，可以用：voidMy_NameA::My_NameB::Array::Set。3.5.4std名空间

为了防止标准C++库的组件污染用户的全局名空间，所有C++库的组件都封装在一个被称为std的名空间内。使用时可以先用#include<iostream>，再用using指示符，使得C++库内在名空间std中声明的组件对于我们的程序可见。在本例中endl已可见，可以直接使用，而cout并未可见，所以要加上空间名。若去掉usingstd::endl;声明，要实现同样的效果就得声明如下：

#include<iostream>

voidmain()

{std::cout<<“namespace”<<std::endl;

}本例中用到了#include<iostream>。<iostream.h>与<iostream>的区别是：iostream.h是早期C++中的使用方式，这些老式的头文件只是将标准库定义的功能引入全局名空间，而不是把名字引入名空间std。若用户的系统还不支持新方式，仍可以用老方式，只要加上 .h，同时去掉对名空间std的使用即可。3.5.5匿名名空间

在C++中可以使用不给出名字的名空间，使得在该空间内声明的变量或函数，在其他文件中不可以访问。例如：

//头文件，fun.h

voidShow();

doubleFun(intc);

//实现文件，fun.cpp

#include“fun.h”

#include<iostream.h>intk; //定义该文件中的全局变量

namespace //匿名名空间

{doublen; //成员只能在本文件中使用，或称文件

数据

intm=0; //文件数据

voidSet(){n=8;} //文件函数

}

voidShow(){cout<<k<<endl;}//全局函数

doubleFun(intc)

{Set(); //它只能在本文件中使用

returnn+c;对于某一文件的全局变量，在另一文件中只要对其进行扩展声明，便可使用该变量。而若将某名字放在未命名的名空间内，那么其他文件就不能访问它了。上例中，函数Fun()在未命名的名空间内，它只能在本文件中被访问，不能被其他文件访问。将某一名字的使用范围限制在一个文件中，优点是其他文件就可以再一次使用这个相同的名字，两个文件相互不干扰。● 重载适用于在不同类型的函数上作不同运算而用相同名的情况。

● C++的函数如果在参数类型、参数个数、参数顺序上有所不同，则认为是不同的匹配，可以进行重载。

● 重载的目的是：更方便理解和调试代码，使代码维护变得更加容易，增加可读性。

● 不要让重载执行不同的功能，同名函数应该具有相同的功能。

● 函数重载时要考虑到实现匹配的唯一性。本章要点● 内联函数主要用来提高程序的运行效率，克服宏定义使用#define所带来的弊端。

● 将函数的实现放在类的定义中，那么该成员函数将自动成为内联函数。

● 内联函数实际上是用空间换取时间。

● 内联函数是1～5行的小函数，若语句较多就不要用内联函数。

● 在C++中给变量或对象取一个别名的方法称为引用。

● 引用不是值，不占用存储空间，因此引用只有声明没有定义。● 在建立引用时，只能对同类数据类型的变量或对象进行引用。

● 引用传递的是原来的变量或对象，所以说引用具有指针的作用。

●引用与指针有很大的差别，指针是个变量，可以把它再指向其他地址，然而建立引用时必须初始化且不能再把它取为另一对象的别名。

● 传递引用不生成副本，返回引用时也不生成值的副本，可见引用对空间无要求。

● 引用可能隐藏错误，在使用中要引起注意。