第 11 章特殊成员函数

C++ 定义了几种只能作为类成员函数说明的函数 , 它们称为 “ 特殊成员 ” 函数。这些函数影响着给定类对象创建、删除、拷贝以及转换成其它类型对象的方法。这些函数的另一个重要的特性是它们可以由编译器隐含调用。

这些特殊的函数在下表中简要描述 :

构造函数
析构函数
临时对象
转换
new 和 delete 运算符
用特殊成员函数进行初始化
拷贝类对象

所有上面列出的项目在每个类中可以由用户自定义。

特殊成员函数同其它成员函数一样遵循相同的访问规则。这些访问规则在第 10 章 “ 成员访问控制 ” 中描述。表 11.1 总结了成员函数和友元函数的行为。

表 11.1 函数行为总结

函数类型	函否类	数从中	是基继	能否为拟函数	虚	能否有返回值	成员函数还是友元函数
	承						能否生成
构造函数	否	否		否	成员函数		是
拷贝构造函数析构函数	否否	否是		否否	成员函数成员函数		是是
转换	是	是		否	成员函数		否
赋值 (=)	否	是		是	成员函数		是
new delete 其它成员	是是是	否否是		void* void 是	静态成员数静态成员数成员函数	函函	否否否
函数
友元函数	否		否	是	友元函数		否

构造函数

与类名称具有一样名称的成员函数是构造函数。构造函数不能有返回值 , 甚至不能有 return 语句。说明一个有返回值的构造函数是错误的 , 取构造函数的地址也是错误的。

如果一个类有构造函数 , 在程序中每个该类类型的对象在使用之前由此构造函数进行初始化 ( 有关初始化的更多信息参见本章后面的 “ 用特殊成员函数进行初始化 ” ) 。

构造函数是在对象的创建点上被调用的。创建对象可以是 :

全局对象 ( 文件范围或外部链接的 ) 。
在一个函数或者小的封闭块中的局部变量。
用 new 运算符创建的动态对象。 new 操作在程序的堆或自由存储区中分配一个对象。
因显式调用构造函数而创建的临时对象 ( 详见本章后面的 “ 临时对象 ” ) 。
因编译器隐含调用构造函数而创建的临时对象 ( 详见本章后面的 “ 临时对象 ” ) 。
其它类的数据成员。在创建类类型的对象时 , 若此类类型由其它类类型变量组成 , 将会引起该类中每个对象的创建。
一个类的基类子对象。创建派生类类型的对象时会引起基类构件的创建。

构造函数的作用

个构造函数执行各种任务 , 但对于程序员来说，这些任务是不可见的 , 你甚至可以不必为构造函数写任何代码。这些任务都同建立一个完全的、正确的类类型对象实例有关。

在 MS C++ 中 ( 同样也在很多其它 C++ 中 ) 一个构造函数 :

初始化对象的虚拟基指针 (vbptr) 。如果该类是由虚拟基类派生出的 , 则这一步要执行。
按说明的顺序调用基类和成员的构造函数。
初始化对象的虚拟函数指针 (vfptr) 。如果该类有或者继承了虚拟函数 , 则这一步要执行 , 虚拟函数指针指向类的虚拟函数表 (v- table), 并且使虚拟函数的调用同代码正确绑定（ binding ）。
在构造函数体中执行可选的代码。

当构造函数结束以后 , 所分配的存储器就是一个给定类类型的对象。因为构造函数执行这些步骤 , 故虚拟函数的 “ 迟后绑定 ” 形态可以在虚拟函数的调用点得以解决 , 构造函数也要构造基类以及构造组合对象 ( 作为数据成员的对象 ), 迟后绑定是 C++ 实现对象的多态行为的机制。

说明构造函数的规则

构造函数具有同类名相同的名称。只要遵守重载函数的规则 ( 有关详情参见第 12 章 “ 重载 ” ), 可以说明多个构造函数。

语法

类名称 ( 参量说明表 _op _t) cv- 修饰符表 _opt

C++ 定义了两种类型的构造函数 , 缺省的和拷贝的构造函数。如表 11.1 所述。表 11.1 缺省的和拷贝构造函数

构造函数的种类参量目的

缺省构造函数可以无参量调用构造一个类类型的缺省对

象

拷贝构造函数可以接受对同种类类型的

引用作为唯一参量

拷贝类类型的对象

缺省构造函数不要参量即可调用 , 但你可以说明一个带有参量表的缺省构造函数只要让所有的参量有缺省值即可。同样 , 拷贝构造函数必须接受同一类类型的引用作为唯一参量。但可以提供更多的参量 , 只要后续的参量具有缺省值即可。

如果你不提供任何构造函数 , 编译器会试图生成一个缺省的构造函数。同样 , 如果你没有提供拷贝构造函数 , 编译器也会试图产生一个。编译器产生的构造函数视为公有的成员函数。如果你说明一个拷贝构造函数，而其第一个参量是一个对象而不是一个引用 , 则会产生错误。

编译器生成的缺省构造函数建立对象 ( 初始化 vftables 和 vbtables, 如前面所述 ), 并调用基类及成员的缺省构造函数 , 但不会采取其它的行动。基类和成员的构造函数只要存在 , 是可访问的 , 并且是无二义性的就会被调用。

编译器生成的拷贝构造函数建立一个对象，并且采用一个成员方式的拷贝来复制要被拷贝的对象的内容。如果基类或成员的构造函数存在 , 则它们将被调用 , 否则 , 就采取位方式的拷贝。

如果所有的基类和该类类型的成员类具有接受一个常量参量的构造函数 , 则编译器生成的拷贝构造函数接受一个唯一的参量的类型是 const type& ；否则 , 编译器生成的拷贝构造函数接受的唯一参量的类型是 type & 。

你可以用一个构造函数去初始化一个 const 和 volatile 对象 , 但构造函数本身不能说明为 const 和 volatile 的。对于构造函数唯一合法的存储类型 inline, 对于构造函数使用任何其它的存储类修饰符 , 包括 _{__} declspec 关键字都会引起错误。构造函数和析构函数除了 _{__} stdcall 外不能说明为其它的调用约定。

派生类是不能继承基类中的构造函数的。当一个派生类的对象在创建的时候 , 它是从基类构件开始构造的 , 然而才进入派生类构件。编译器使用每个基类的构造函数作为完整对象初始化的一部分 ( 除了虚拟派生有所不同 , 参见本章后面的“ 初始化基类 ” ) 。

显式地调用构造函数

在程序中 , 为创建给定类型的对象 , 可以显式地调用构造函数。例如 : 创建两个Point 型对象的描述一条线段的端点 , 可以写如下代码 : DrawLine(Point(13,22),Point(87,91);

创建了两个 Point 对象 , 传递给 DrawLine 函数 , 并在该表达式 ( 函数调用 ) 结束后拆除。

另外一个显式地调用构造函数的情况是在一个初始化中 : Point pt=Point(7,11);

创建了一个 Point 类型的对象，并用接受两个整形参量的构造函数进行初始化。如前面的两个例子中 , 通过显式地调用构造函数创建的对象是无名的对象 , 并在

它们所创建的表达式中是有生存期的。在本章后面的 “ 临时对象 ” 中将对这一点进行深入的讨论。

在构造函数内调用成员函数和虚拟函数

在构造函数里面调用任何成员函数通常是很安全的 , 因为在执行第一行用户代码之前 , 对象已经完全建立起来了 ( 已经初始化了虚表等等 ) 。但是当成员函数调用了其抽象基类的虚拟成员函数时 , 在构造函数和析构函数调用此成员函数存在着潜在的不安全性。

构造函数可以调用虚拟函数。在调用虚拟函数时 , 被调用的是在构造函数自身的类中定义的函数 ( 或者从其基类中继承的函数 ) 。下面的例子显示了一个虚拟函数在一个构造函数中被调用时发生的情况。

#include <iostream.h> class Base

{

public:

Base();// 缺省构造函数

virtual void f(); // 虚拟成员函数

};

Base::Base()

{

cout<<"Constructing Base sub-object\n ";

void Base::f()

{

cout<<"called Base::f()\n";

}

class Derived:public Base

{

public:

Derived();// 缺省构造函数

void f(); // 该类虚拟函数的实现

};

Derived::Derived()

{

cout<<"constructing Derived object\n";

}

void Derived::f()

{

void main()

{

Derived d;

}

在上面的程序运行的时候 ,Derived d 的说明会引发下列一系列事件 : 1. 类 Derived 的构造函数 (Derived::Derived) 被调用。

在进入到 Derived 类的构造体之前 , 基类 Base 的构造函数被调用。
Base::Base 调用函数 f, 它是一个虚拟函数。通常被调用

的函数会是Derived::f, 因为对象 d 是 Derived 类型的对象。但因为 Base::Base 是一个构造函数 , 此时的对象是一个 Derived 类型的对象，故 Base::f 将会被调用。

构造函数与数组

数组的构造只能使用缺省的构造函数。缺省构造函数要么不接受任何参量 , 要么对于它的所有参量都有缺省的值。数组通常是按升序来构造的 , 该数组的每一个成员的初始化都是使用同一构造函数。

构造的次序

对于派生类或其成员数据是类类型的类 , 构造发生的顺序有助于你理解 , 在任一

构造与继承

个派生类的对象是从基类到派生类通过按次序为每个类调用构造函数来构造的。

每个类的构造函数能仅依赖于被完全构造好的它的基类。

有关初始化的完整描述 , 包括初始化的顺序 , 见本章后面的 “ 初始化基类及成员 ” 。

构造与组合类型

含有类类型数据成员的类称为组合类。当创建一个组合类类型的对象时 , 含有类的构造函数在该类的构造函数之前调用。

有关这种情况的初始化 , 见本章后面的 “ 初始化基类及成员 ”。

析构函数

析构函数是 “ 反向 ” 的构造函数。它们在对象被销毁 ( 回收 ) 时调用。设计一个函数为类的析构函数只要在类名之前加上 (~) 号。例如 , 类 string 的析构函数是

~string() 。

析构函数通常是在一个对象不再需要时 , 完成 “ 清除 ”。考虑一下下面类 string 的说明 :

#include <string.h>

class String

{

public:

String(char *ch); // 说明构造函数

~String(); // 以及析构函数private:

char *_text;

};

// 定义构造函数String::String (char *ch)

{

// 动态分配正确数量的存储器

_text=new char[strlen(ch)+1];

// 如果分配成功 , 则拷贝初始化字符串

if(_text)

strcpy(_text,ch);

}

// 定义析构函数String::~String()

{

// 回收先前为此字符串保留的存储器

delete[] _text;

}

在前面的代码上。析构函数 String::~String 使用 delete 运算符回收

（ deallocate ）动态分配给 text 的存储空间。

说明析构函数

析构函数与类名称有相同的名称 , 并且前缀有 ~ 号。

语法

～类名称 () 或

类名称 :: ～类名称 ()

语法的第一种形式用于析构函数说明或定义于类说明之中 ; 第二种形式用于析构函数定义于类说明之外。

有几条规则约束着析构函数的说明。析构函数 :

不能接受参量
不能说明有任何返回类型 ( 包括 void)
不能用 return 语句返回值
不能说明为 const,volatile 或 static, 但析构函数可以因说明为const,volatile 或 static 的对象的析构而被调用。
可以说明为虚拟的。使用虚析构函数 , 你可以折除对象而不必知道该对象的类型。由于使用虚拟函数机制 , 将调用该对象的正确的析构函数。注意，在一个抽象类中 , 析构函数可以说明为纯虚拟函数。

使用析构函数

当下列事件发生时将调用析构函数 :

一个用 new 运算符分配的对象显式地使用 delete 运算符回收。在用 delete 运算符对一个对象进行回收时 , 释放的存储器是 “ 最外派生对象 ” 的 (most derived object), 或者是一个完整对象的而不是代表基类的子对象。对于 “ 最外派生对象 ” 的回收只是在同虚拟析构函数一起工作时才有保证的。回收可能在多重继承的情形下失败 , 因为在此情形下 , 类类型信息并不同实际对象所信赖的类型相一致。
一个在块范围中的局部 ( 自动 ) 对象超出了其范围。
临时对象生存期的结束。
全局或静态成员还存在 , 但程序已经结束。
用析构函数的全限定名来显式地调用析构函数 ( 详情见本章后面的“ 显式的析构函数的调用 ” ) 。

前面列表中所描述的情况保证了所有的对象可以用用户自定义的方法折除。

如果一个基类或者数据成员有一个可访问的析构函数 , 同时如果一个派生类没有说明析构函数 , 编译器会生成一个。编译器产生的析构函数调用基类的析构函数和派生类成员的析构函数。缺省的析构函数是公有的 ( 有关访问属性的详情见第10 章 “ 成员访问控制 ” 中的 “ 基类访问说明 ” ) 。

析构函数可以自由地调用类成员函数以及访问类成员数据。当在析构函数中调用虚函数时 , 该函数是在当前正被折除的类的函数 ( 有关详情见下一节 , “ 析构的

次序 ” ) 。

使用析构函数有两条原则 , 第一是不能取析构函数的地址。第二是派生类不能继承它的基类的析构函数。相反 , 如前面所解释的 , 它们总是覆盖了基类的析构函数。

析构的次序

当某个对象超出了其范围或被删除时 , 在其完整的析构中会发生如下一些系列的事件 :

调用该类的析构函数 , 执行析构函数体的代码。
非静态成员按它出现在类说明中的反序调用其析构函

数。在构造函数中使用的可选成员初始化表的运用不会影响构造或析构的次序 ( 有关初始化成员的详情见本章后面的 “ 初始化基类和成员 ” ) 。
非虚拟基类的析构函数按其说明的反序调用。
虚拟基类的析构函数按其说明的反序调用。

非虚拟基类的析构函数

非虚拟基类的析构函数是按基类名说明的反序调用的。考虑下面的类说明 : class MultInherit: public Base1,public Base2

...

在上面的例子中 ,Base2 的析构函数在 Base1 的析构函数之前调用。

虚拟基类的析构函数

虚拟基类的析构函数是按它们出现在有向无环图中的反序被调用的 ( 按深度优先从左到右 , 后序遍历 ) 。如图 11.1 所示描绘了一幅继承图。

第 11 章特殊成员函数 - 图1

图 11.1 显示虚拟基类的继承图下面列出了图 11.1 中各类的类头 :

class A class B

class C:virtual public A,virtual public B class D:virtual public A,virtual public B class E:public C,public D,virtual public B

对于类型 E 的对象要确定虚拟基类析构函数的顺序。编译器用如下算法编一个列表 :

从图中的最深点开始 ( 在此例中是 E 点 ) 遍历左子图。
而左一直遍历到所有的结点都被访问 , 记下当前结点的名称。
再次访问前一个结点 ( 向下并向右 ) 去证实正在标记

的结点是否是一个虚拟基类。
如果被标记的结点是一个虚拟基类 , 则搜索该列表看

是否该结点已经在列表之中了。如果被标记的结点不是一个虚拟基类 , 则忽略它。
如果该标记的结点还不在列表中 , 则把它加入到列表的尾部。
返回到图的上一层 , 并沿着右边的下一条路径遍历图。
转向 2 继续。
当本结点所有可能遍历的路径用完后 , 记下该结点。
转向 3 继续。
继续该过程直到底部的结点再次成为当前结点。因此

对于类 E, 析构的顺序是 :

非虚拟基类 E 。
非虚拟基类 D 。
非虚拟基类 C 。
虚拟基类 B 。
虚拟基类 A 。

这一过程产生一个单一条目的有序列表 , 类名不会出现两次。一旦该列表建成以后 , 按反序遍历该列表 , 从最后到最前将调用每个类的析构函数。

当一个类的构造函数和析构函数依赖于其它正在被创建的构件或要长期被保留的构件时 , 例如 ,( 在图 11.1 中 ) 当 A 的析构函数（若其代码的执行）依赖于 B 的

仍然存在时 , 或反过来构造和析构的次序是非常重要的。

在继承图中 , 类之间的这种交互依赖具有固有的危险性 , 因为其后派生的类会改变最后的路径 , 与此相连也改变了构造和析构的次序。

显式的析构函数的调用

显式地调用析构函数通常是不必要的 , 但它们在执行放在绝对地址中的对象是很有用的。这些对象通常是用带有一个位置参量的用户自定义的 new 运算符分配的。 delete 操作不能回收这一存储器 , 因为它不是从自由存储区中分配的 ( 有关详情见本章后面的 “ new 和 delete 运算符 ” ) 。然而一个对析构函数的调用能够完成合适的清除工作。要显式调用类 String 的对象 s 析构函数 , 可采用下列语句之一 :

s.S tring::~String();// 非虚拟的调用

ps->String::~String(); // 非虚拟的调用s.~String();// 虚拟调用

ps->~string(); // 虚拟调用

在上面的代码中显示的显式调用析构函数的符号可以直接使用，而无视是否该类型定义了一个析构函数。这使你能用这种显式的调用，而又不必了解该类型是否定义了一个析构函数。如果一个析构函数未定义 , 则对该析构函数的显式调用不会产生效果。

临时对象

在某些情况下 , 对于编译器来说必须创建临时对象。因以下原因要创建这些临时变量 :

要用一个不同于正被初始化的引用类型的另一类型去初始化一个常量引用。
要保存一个函数返回的用户自定义类型的返回值。如果用户程序没有把返回值拷贝到另一对象中时 , 这一临时对象才会被创建 :

UDT Func1(); // 说明一个返回用户自定义类型的函数

...

Func1(); // 调用 Func1 函数 , 但忽略其返回值

// 创建一个临时对象以保存返回值

因为返回值并未拷贝到其它对象 , 故创建一个临时对象。一个要创建临时对象的更普遍的情形是要调用重载运算符函数的表达式求值中。这些重载的运算符返回用户自定义的类型的值（通常不拷贝到其它对象之中）。考虑表达式 :

ComplexResult=Complex1+Complex2+Complex3

求出表达式 Complex1+Complex2 的值 , 结果存放在临时对象中。接着求表达式temporary+complex3 的值 , 并把结果存放到 complexresult 中 ( 假定赋值运算符没有被重载 ) 。

存一个造型转换为用户自定义类型的转换结果。当一个给定类型的对象显式地转换为用户自定义类型时 , 新的对象是作为临时对象来构造的。

临时对象有一个生存期 , 在其创建点和拆除点之间有定义。任何一个创建了多个临时对象的表达式最后是按创建它们的相反的顺序拆除的。析构的发生点如表

所示。

表 11.2 临时对象的析构点

创建临时对象的原因析构点

表达式求值的结果所有因为表达式求值的结果而创建的临时对

象在表达式求值结束时 ( 也即分号处 ) 或者在控制表达式 (for 、 if 、 while 、 do 和 switch 语句 ) 结束时被拆除。

内置的 ( 非重载的 ) 符 (|| 和

&&)

在右操作数结束之后。在这一析构点 , 所有

因右逻辑运算操作数求值而创建的临时对象被拆除。

初始化常量引用如果一个初始化符并不是同要被初始化的引用有相同的 l 值类型 , 则创建基于此对象类型的临时对象并用此初始化表达式初始化。这一临时对象在同它绑定在一起的引用对象被拆除以后马上拆除。

转换

给定类类型的对象可以转换为其它类型的对象。这可以按以下来完成 : 从源类类

型构造一个目标类类型的对象，并把结果拷贝到目标对象。这一过程称为构造函数式转换。对象也可以由用户提供的转换函数转换。

当标准转换 ( 在第 3 章 “ 标准转换 ” 中描述 ) 不能完成从一个给定类型转换到一个类类型时 , 编译器会选择用户自定义的转换以帮助完成这一工作。除了显式的类型转换 , 转换还发生在 :

一个初始化表达式同被初始化的对象有不同的类型。
在函数调用中使用的参量类型同函数说明中所说明的参量不匹配。
从函数中返回的对象的类型同函数说明中说明的返回类型不匹配。
两个表达式操作数必须有同样的类型。
一个控制复述或选择语句的表达式需要从提供的表达式中得到不同的类型。

用户自定义的转换仅用于它没有二义性时 , 否则会产生一个错误消息。在使用点上将检查二义性，因而 , 如果可以引起二义性的特征未被使用 , 只能标明一个类有潜在的二义性 , 并不会产生任何错误。尽管有很多情形会引起二义性 , 下面两条是最会引起二义性的原因。

一个使用多重继承派生的类 , 没有说清楚从哪一个基类选择此转换( 见第 9 章 “ 派生类 ” 中的 “ 二义性 ” ) 。
一个显式的类型转换运算符和为此同一目的构造函数同时存在 ( 见本章后面 “ 转换函数 ” ) 。
构造函数方式的转换和转换函数方式的转换两者都要遵循第 10 章“ 成员访问控制 ” 中所描述的访问控制规则。访问控制仅在转换发

现无二义性以后才进行检测。

转换构造函数

可以用单一参量调用的构造函数是用于把参量类型转变成类类型的转换。这种构造函数称为转换构造函数。考虑下面的例子 :

class Point

{

public;

Point();

Point(int);

...

};

有时需要一种转换 , 但在类中又不存在转换构造函数。这种转换不能由构造函数完成 , 编译器不会寻找可以完成该转换的中间类型。比如 : 假设存在着一个从Point 类型到 Rect 类型的转换以及一个从 int 到 Point 类型的转换 , 但编译器不会通过构造一个中间的 Point 类型对象来提供一个从 int 到 Rect 类型的转换。

转换和常量

尽管内置类型的常量如 (int,long 和 double) 可以出现在表达式中 , 但类类型的常量是不允许的 ( 部分是因为 , 类通常用来表示复杂的对象 , 用符号不便于表示 ) 。但是如果提供了对内置类型进行转换的转换构造函数 , 这些内置类型的常

量可以用于表达式 , 并且转换会引出正确的行为。如下例子 , 一个 Money 类具有从 long 和 double 类型的转换 :

class Money

{

public;

Money(long)

Money(double)

...

Money operator+(const Money&); // 重载加法运算符

};

因此 , 像下面的表达式可以说明常量值 :

Money AccountBalance=37.89;

Money NewBalance=AccountBalance+14L;

第二个例子引起了重载加法运算符的调用 ( 在下一章中讨论 ) 。两个例子都会令编译器在表达式中使用常量以前把它们转换成 Money 类型。

转换构造函数的缺点

因为编译器会隐含地选择一个转换构造函数 , 故你将放弃对具体调用函数的控制。如果保留全面的控制是很重要的 , 就不要说明任何接受单一参量的构造函数。相反 , 定义一个 “ 帮助 ” 函数以完成这些转换 , 看如下代码 :

#include <stdio.h> #include <stdlib.h>

// 说明 Money 类class Money

{

public;

Money();

// 定义只能显式调用的转换函数

static Money Convert(char * ch) {return Money(ch);};

static Money Convert(double d) {return Money(d);};

void Print (){printf("\n%f",_amount);} private:

Money(char * ch) {_amount=atof(ch);}

Money(double d) {_amount=d;}

double _amount;

};

void main()

{

// 完成一个从 char* 到 Money 的转换

Money Acct=Money::Convert("57.29");

Acct.Print();

// 完成一个从 double 到 Money 的转换

Acct=Money::Convert(33.29);

Acct.Print();

}

在上面的代码中 , 转换构造函数是私有的 , 并且不能在类型转换中使用。但它们可以显式地通过调用 Convert 函数来激活。因为 Convert 函数是静态的 , 它们的访问不需要特别的对象。

转换函数

前一节中介绍，用构造函数进行转换中一种类型的对象可以隐含地转换成特殊的类类型。这一节介绍一种方法 , 通过它可以提供一个显式的转换方法把给定的类类型转换成其它类型。从某种类类型的转换经常是使用转换函数完成的。转换函数使用下面的语法 :

语法

转换函数名称 :

operator 转换类型名称 () 转换类型名称 :

类型指示符表指针运算符 _opt

下面的例子说明了一个转换函数把 Money 类型转换成 double 类型 : class Money

{

public:

Money();

operator double() { return _amount;}

private:

double _amount;

};

旦给出了前面的类说明 , 则可以编写下面的代码 :

Money Account;

...

double CashOnHand=Account;

把 CashOnHand 用 Account 进行初始化会引起从类型 Account 到 double 的转换。转换函数通常被称为 “ 造型运算符 ”。因为它们 ( 如同构造函数的叫法 ) 是在造型类型转换时调用的函数。下面的例子使用了造型或显式的类型转换打印一个Money 型对象的当前值 :

cout <<(double)Account<<endl;

转换函数可以在派生类中被继承。转换运算符仅仅隐藏基类中转换完全相同类型的转换运算符。因此一个用户自定的 operator int 函数不会隐藏一定义于基类中的 operator short 函数。

在进行隐含转换时仅有一个用户自定义的类型转换函数适用。如果没有显式的定义转换函数 , 编译器不会寻找一个中间类型以通过它进行对象的转换。

如果需要的转换引起了二义性 , 则会产生一个错误。在多个用户自定义的转换可以适用，或在用户自定义的转换和内置的转换同时存在时产生二义性。

下面的例子示例了一个存在潜在二义性的类说明 : #include <string.h>

class String

{

// 定义从 char * 类型转换的构造函数

String(char *) {strcpy(_text,s);}

// 定义 char * 的转换

operator char* ( ) {return_text,}

int operator==(const String& s)

{return !strcmp(_text,s._text);} private:

char _text[80];

};

int main()

{

String s("abcd");

char *ch="efg";

// 使编译器选择一个转换

return s==ch;

}

在表达式 s==ch 上 , 编译器有两种选择 , 并且没有办法决定哪一种更好。它可以使用构造函数把 ch 转换为一个 String 类型的对象，然后采用用户自定义的operator== 进行比较。

然而它也可以把 s 转换成一个 char* 型的指针 ( 使用转换函数 ) ，然后采用指针之间的比较。

因为两种方法之中没有哪一个更好一些 , 编译器也不能决定比较表达式的意义 ,

故而产生一个错误。

说明转换函数的规则

下面四条规则适用于说明转换构造函数 ( 参见转换函数语法 ):

类 , 枚举和 typedef 名不能在类型指示符表中说明 , 因而下面的代码会产生错误 :

operator struct String {char string_storage;}(); 相反 , 结构 String 的说明应先于转换函数的说明。

转换函数不能带参量 , 说明参量会引起错误。
转换函数已说明了转换类型名称的返回类型 ; 故为转换函数说明任何返回类会产生错误。
转换函数可以说明为虚拟的。

new 和 delete 运算符

C++ 支持使用 new 和 delete 运算符动态分配和回收对象 , 这些操作从一个称为“ 自由区 ” 的池中为对象分配存储器。 new 运算符调用 operator new 函数 ,delete 运算符调用 operator delete 函数。

operator new 函数

当编译器在程序中碰到如下的一个语句时 , 它就翻译为一个对 operator new 的

调用。

char *pch=new char[BUFFER_SIZE]

对于分配 0 字节存储区的要求 ,operator new 返回一个不同对象的指针 ( 也就是说 , 反复调用 operator new 会返回不同的指针 ) 。如果没有足够的存储器满足分配的要求 , 缺省时，通常 operator new 返回 NULL 。当然你可以通过写一个定制的例外处理例程来改变这种缺省的行为。然后调用 _set_new_handler 运行时间库函数并把你的例外处理例程函数的名称作为其参量。有关恢复机制的细节参见下一节 “ 处理无足够存储器的条件 ”。

operator new 的两种范围在表 11.3 中描述。表 11.3 operator new 函数的范围运算符范围

::operator new 全局的

class_name ::operator new 类的

operator new 函数的第一个参量必须是类型 size_t( 在 STDDEF.H 中定义 ) ，其返回值总是 void* 。

在用 new 运算符分配内部数据类型对象时 , 或者分配不包含用户自定义型operator new 函数的类类型对象时 , 以及分配任意类型的数组时 , 调用的是全局operator new 函数。当 operator new 用在定义 operator new 函数的类类型对象对 , 调用的是类的 operator new 函数。

为类定义的 operator new 函数是一个静态成员函数 ( 因此它不可能是虚拟的 ) 。它对于该类的对象来说隐藏了全局的 operator new 函数。研究下面的情况 , 其

中 new 用于分配存储器 , 并把存储器设为给定的值 :

#include <malloc.h> #include <memory.h> class Blanks

{

public:

Blanks() { }

void* operator new(size_t stAllocateBlock,char chInit);

};

void * Blanks::operator new(size_t stAllocateBlock,char chInit);

{

void * pvTemp=malloc(stAllocateBlock);

if (pvTemp!=0)

memset (pvTemp,chInit,stAllocateBlock),

return pvTemp;

};

对于不同的 Blanks 类型的对象来说 , 全局 operator new 函数被隐藏了。因此下面的代码分配一个 Blanks 型的对象并初始化为 0xa5:

int main()

{

Blanks *a5=new (0Xa5) Blanks;

return a5!=0;

};

在括号中提供给 new 的参量是传递给 Blank::operator new 作为 chInit 参量的。然而全局 operator new 函数是隐藏了的 , 故按如下调用全局 operator new 的代码会引起错误。

Blanks *SomeBlanks=new Blanks:

在以前的编译器版本中 , 非类类型和所有的数组 ( 无论它们是否是类类型数组 ) 使用 new 运算符分配存储器总是使用全局 operator new 函数。

从 Visual C++5.0 开始 , 编译器开始在类说明中支持成员数组 new 和 delete 运算符。

例如 :

class X { public:

void * operator new[](size_t);

void Operator delete[](void*),

};

void f(){

X *pX=new X[5],

delete []pX;

}

处理无足够存储器条件

对于失败的存储器分配可以采用如下的代码 :

int *pi=new int[BIG_NUMBER];

if (pi==0)

{

cerr<<"Insufficient memory"<<endl;

return -1;

}

当然有其它的办法处理失败的存储器分配请求 , 即写一个定制的例程去处理这种失败。然后通过调用 _set_new_handler 运行函数注册你的处理例程。这种方法在下一节介绍。

使用 _set_new_handler

在某些情况下 , 可以在分配存储器中采取一些矫正的办法使分配要求可得以满足。为在全局 operator new 函数失败时获得控制 , 使用 _set_new_handler 函数( 在 NEW.H 中定义 ) 如下 :

#include <stdio.h> #include <new.h>

// 定义一个在 new 分配存储器失败时调用的函数int MyNewHandler(size_t size)

{

clog<<"Allocation failed.Coalescing heap."<<endl;

// 调用一个工具函数以恢复一些堆的空间

return CoalesceHeap();

}

void main()

{

// 把 new 失败处理函数设为 MyNewHandler

_set_new_handler(MyNewHandler);

int *pi=new int[BIG_NUMBER];

}

在上面的例子中 ,main 函数的第一个语句是把 new 的处理函数设为MyNewHandler 。第二条语句是使用 new 运算符分配一大块存储器。当分配失败的时候 , 控制转向 MyNewHandler 。

传递给 MyNewHandler 的参量是要求分配的存储器的字节大小。从 MyNewHandler 返回的是一个标识以表明是否要再进行一次分配操作。非 0 值表示应再进行一次 , 而 0 值则表示分配失败了。

MyNewHandler 打印一条警号消息并采取矫正的步骤。如果 MyNewHandler 返回一个非 0 值 ,new 运算符再试图分配一次 ; 当 MyNewHandler 返回 0 值时 ,new 操作分配企图 , 把一个 0 值返回给程序。

_set_new_handler 返回的是一个老的 new 处理函数的地址。因此如果一个新的new 处理函数只在短时间内使用 , 则老的处理函数可以按如下代码还原 : #include <new.h>

...

_PNH old_handler=_set_new_handler(MyNewHandler);

// 要求使用 MyNewHandler 的代码

...

// 重新安装以前的处理函数

_set_new_handler(old_handler);

用 0 参量调用 _set_new_handler 会引起移去 new 处理函数，也就是没有缺省的处理函数了。

你可以用任何名称说明 new 处理函数 , 但它必须是一个返回 int 型的函数 ( 非 0 表示 new 处理函数继续 ,0 表示失败 ) 。

如果提供了一个用户自定义的 operator new 函数 , 该 new 处理函数不会在失败时自动调用。

_set_new_handler 的函数原型以及 _PNH 在 NEW.H 中定义 :

_PNH_set_new_handler(_PNH);

类型 _PNH 是一个指向函数的指针 , 该函数的类型 size_t 作为唯一的参量并返回int 型。

operator delete 函数

用 new 操作动态分配的存储器可以用 delete 操作释放。 delete 运算符调用operator delete 函数把存储器释放回可用的存储区池中。使用 delete 操作也会引起类的析构函数的调用 ( 如果有的话 ) 。

operator delete 函数也有全局和类范围的两种。对于给定的类只能为其定义

个 operator delete 函数 ; 一旦定义以后 , 它会隐藏全局 operator delete 函数。全局的 operator delete 函数总是可以为任意类型的数组所调用。

全局 operator delete 函数在说明中带一个 void 类型的单一参量 , 它含有要释放对象的指针。它的返回类型是 void(operator delete 函数不能有返回值 ) 。类成员 operator delete 函数有两种形式 :

void operator delete(void *);

void operator delete(void *,size_t);

对于给定的类只能提供上述两种不同形式中的一种 , 第一种形式就像全局operator delete 一样工作 ; 第二种形式有两个参量。第一个参量是要释放存储器块的指针 , 第二个参量是要释放的存储器字节大小。当一个基类中的 operator delete 函数用于释放派生类对象时 , 第二种形式特别有用。

operator delete 函数是静态的 , 因而它不能是虚拟的 ,operator delete 函数必须遵循第 10 章 “ 成员访问控制 ” 中描述的访问控制。

下面的例子显示了用户设计的 operator new 和 operator delete 函数用于记录分配和释放存储器 :

#include <iostream.h> #include <stdlib.h>

int fLogMemory=0;// 是否记录 (0= 否 ; 非 0= 是 ) int cBlocksAllocated=0; // 分配的块数

// 用户自定义的 new 操作

void *operator new(size_t stAllocateBLock)

{

static fInOpNew=0,// 保护标志

if(fLogMemory && !fInOpNew)

{

fInOpNew=1;

clog<<"Memory Block"<<++cBlocksAllocated

<<"allocated for"<<stAllocateBlcok

<<"bytes\n";

fInOpNew=0;

}

return malloc(stAllocateBlock);

}

// 用户定义的 operator_delete

void operator delete(void *pvMem)

{

static fInOpDelete=0; // 保护标志

if (fLogMemory &&!fInOpDelete)

{

fInOpDelete=1;

clog<<"Memory block"<<--cBlocksAllocated

<<"deallocated\n";

fInOpDelete=0;

}

free (pvMem);

}

int main (int argc,char*argv[])

{

fLogMemory=1; // 打开 log 标识

if (argc>1)

for (int i=0; i<atoi(argv[1]);++i )

{

char *pMem=new char[10];

delete [] pMem;

};

return cBlocksAllocated;

}

上面的代码可以用来检查 “ 存储器漏损 ” , 即从自动堆中分配以后就没有释放的存储器。为完成这一检查 , 全局 new 和 delete 操作被重新定义以统计分配和释放的存储器。

从 Visual C++5.0 开始 , 编译器在类说明中支持成员数组 new 和 delete 操作 , 例如 :

class X

{

public:

void * operator new[] (size_t);

void operatot delete[](void*);

};

void f() {

X* pX=new X[5];

delete[] pX;

}

用特殊成员函数初始化

这一节描述使用特殊成员函数的初始化 , 它是下面一些初始化论题的扩展。

第 7 章 “ 说明 ” 中的 “ 初始化集合 ” , 描述了如何初始化非类类型数组以及简单类类型对象。这些简单的类类型不可有私有的及保护的成员 , 它们也不能有基类。
构造函数。它解释了如何使用特殊的构造函数初始化

类类型对象。缺省的初始化方法是执行一个位方式的拷贝 , 把初始化器拷贝给要被初始化的对象。这种技术仅适用于 :
内部类型的对象。例如 : int i=100;
指针。例如 :

int i

int *pi=&i;

引用。例如 :

String sFileName("FILE.DAT"); String &rs=sFileName;

类型对象 , 该类不可有保护的或私有的成员 , 不能有虚拟函数也不能有基类 , 例如 :

struct Point

{

int x,y;

}

Point pt={10,20}; //static storage calss only

通过说明构造函数 ( 有关说明这种函数的详情见本章开始的 “ 构造函数 ” ), 类可以说明更多精确的初始化。如果一个对象的类型是有构造函数的类类型 , 该对象一定会被初始化 , 否则一定存在着缺省的构造函数。没有特别初始化的对象会激活类的缺省构造函数。

显式的初始化

C++ 支持两种形式的显式初始化。

支持在括号中提供初始表 : String sFileName("FILE.DAT);

在括号中的初始化器表的项是作为类构造函数的参量。这种形式的初始化使得对一个对象使用多个值进行初始化成为可能 , 并且也可以同 new 运算符联合使用。如 :

Rect *pRect=new Rect(10,15,24,97);

支持使用等号初始化语法提供单一初始化器 , 例如 :
String sFileName="FILE.DAT";

尽管前面的例子同第一种形式中的 String 例子以同样的方式工作 , 但该语法并不适用于同自由堆中分配的对象一起使用。

在等号右边的单一表达式是作为类的拷贝构造函数的参量，因此它必须是能够转换成类类型的某种类型。

注意因为在初始化的上下文中等号 (=) 同赋值号是不同的 , 故重载 operator= 对于初始化没有影响。

等号初始化语法同函数式语法是不同的 , 尽管在大多数情况下产生的代码是相同的。它们之间的不同在于 : 当使用等号语法 , 编译器的行为就像发生了如下的顺序事件 :

创建一个同要被初始化的对象同一类型的临时对象。
把临时对象拷贝到要被初始化的对象之中。

在编译器执行这些步骤之前 , 构造函数必须是可访问的。尽管编译器在大多数情况下可以忽略临时对象的创建和拷贝步骤，然而一个不可访问的拷贝构造函数会引起等号初始化的失败。考虑下面的例子 :

class anInt

{

anInt (const anInt&); // 私有拷贝构造函数public:

anInt(int); // 公有的 int 构造函数

};

...

anInt myInt=7; // 破坏了访问控制 , 试图引用私有拷贝构造函数anInt myInt(7); // 正确；设有调用拷贝构造函数

在函数调用中 , 传值形式的类型参量以及传值形式的返回对象用下面的代码概念上地进行初始化。

type-name name=value 例如 :

String s="C++";

因此 , 参量类型必须是可以转换为作为参量进行传递的类类型。该类的拷贝构造函数 , 以及自定义转换运算符或接受实际参量的构造函数必须是公有的。

在使用 new 运算符的表达式中 , 从自由堆中分配的对象概念性地用以下形式进行初始化 :

type-name name(initializer 1 ,initializer 2 ,...iniatializer n ) 例如 :

String *ps=new String("C++");

对于基类构件和类成员对象的初始化也是概念性地用这种方法初始化的 ( 详见本章后面的 “ 初始化基类及成员 ” ) 。

初始化数组

如果一个类有一个构造函数 , 此类的数组由一构造函数进行初始化。若初始化器表中的项数小于数组元素的个数 , 则缺省构造函数将用于剩下的数组元素。若此

类并未定义缺省构造函数 , 则初始化器表必须是完全的 , 也就是数组中的每一个元素必须有一个初始化器。

考虑定义了两个构造函数的 Point 类 :

class Point

{

public:

Point();// 缺省构造函数

Point(int,int); // 从两个 int 型的构造函数

...

}

一个 Point 对象数组可以按如下说明 :

Point aPoint[3]={

Point(3,3) // 使用 int,int 构造函数

}

aPoint 数组的第一个元素使用构造函数 Point(int,int) 来构造 , 剩余的两个元素使用缺省构造函数来构造。

静态成员数组 ( 无论是否为 const) 都可以在它们的定义中 ( 在类说明之外 ) 进行初始化。例如 :

class WindowColors

{

public:

static const char *rgszWindowPartList[7];

...

};

const char * WindowColors::rgszWindowPartList[7]={

"Active Title Bar","Inactive Title Bar", "Title Bar Text", "Menu Bar",

"Menu Bar Text", "Window Background", "Frame" };

初始化静态对象

全局静态对象是按它们出现在源代码中的次序进行初始化 , 它们按此相反的次序拆除。然而 , 交叉转换单元中的初始化的次序依赖于连接器如何组织目标文件 , 析构的次序仍然按对象创建次序的相反次序发生。

局部静态对象的初始化发生在当它们第一次出现在程序流中时 , 而且它们在程序结束时也是按此相反的次序被拆除的。局部静态对象的析构仅发生在程序流中发现此对象 , 且此对象被初始化时。

初始化基类及成员

个派生类的对象是由代表每个基类的构件以及对于此特殊类唯一的一个构件组成。含有成员对象的类对象也可包含其它类的实例。这一节描述当这种类型的类对象在创建时 , 这些构件对象是如何初始化的。

为了完成初始化 , 得运用构造函数初始化或 ctor 初始化语法。

语法

ctor- 初始化器

成员初始化器表成员初始化器表 :

成员初始化器

成员初始化器 , 成员初始化器表成员初始化器 :

完整的类名称 ( 表达式表 _opt )

标识符 ( 表达式表 _opt )

用于构造函数中的这一语法 , 在下一节 “ 初始化成员对象 ” 和 “ 初始化基类 ” 中更详尽介绍。

初始化成员对象

类可以含有类类型成员对象 , 但要保证满足对这些成员对象的初始化，并要满足如下之一的条件。

所含对象的类不要求有构造函数。
所含对象的类有一可访问的缺省构造函数。
包容类的构造函数显式初始化所含的对象。下面的例子给出了如何完成这样的初始化 :

// 说明一个 Point 类class Point

{

public:

Point (int x,int y) {_x=x;_y=y;}

private:

int _x,_y;

}

// 说明一个包含有 Point 类型对象的 rectangle 类class Rect

{

public:

Rect (int x1,int y1,int x2,int y2); private:

Point _topleft,_bottomright;

}

// 定义类 Rect 的构造函数 , 这一构造函数显式地初始化类 Point 对象Rect :: Rect(int x1,int y1,int x2, int y2):

_topleft(x1,y1),_bottomright(x2,y2)

{

}

在前面例子中显示的 Rect 类中含有两个 Point 类成员对象。它的构造函数显式地初始化了对象 _topleft 和 _bottomright 。注意跟在构造函数的后括号后面的是冒号。跟在冒号后面的是成员名和参量 , 该参量是用来初始化类对象的。

警告 : 在构造函数中说明的成员初始化顺序不会影响这些成员被构造的次序。成员是按它们在类说明中的说明顺序被构造的。

引用及常量成员对象必须用成员初始化语法 ( 在 “ 初始化基类及成员 ” 中描述 )

来初始化。没有其它的办法来初始化这些对象。

初始化基类

直接基类的初始化同成员对象的初始化以同样的方式进行。考虑下面的代码 :

// 说明类窗口class Window

{

public:

Windodw (Rect rSize);

...

}

// 说明类 DialogBox 直接派生于类 Window class DialogBox:public Window

{

public:

DialogBox(Rect rSize);

...

}

// 定义 DialogBox 构造函数。这一构造函数显式地初始化 Window 子对象DialogBox:: DialogBox(Rect rSize):Window(rSize)

{

}

注意在 DialogBox 的构造函数中 ,Windows 基类是使用参量 rSize 进行初始化的。这一初始化由要初始化的基类名称组成 , 基类名称后跟随的是由圆括号括起来的传递给基类构造函数的参量表。

在基类的初始化中 , 不代表基类构件的子对象的对象称为一个 “ 完整对象 ”。该“ 完整对象 ” 的类视为该对象的 “ 最外派生类 ” (most derived) 。

代表虚拟基类的子对象是由 “ 最外派生类 ” 的构造函数进行初始化的。这意味着只要说明了虚拟基类的派生类 , 则最外派生类必须显式初始化虚拟基类 , 否则虚拟基类必须有一个缺省的构造函数。在最外派生类以外的其它类的构造函数中出现的虚拟基类的初始化将被忽略。

尽管对基类的初始化通常限于直接基类的初始化 , 但一个类的构造函数可以初始化一个非直接的虚拟基类。

基类及成员的初始化次序

基类和成员对象按如下次序进行初始化 :

虚拟基类的初始化按它们出现在有向无环图中的次序。有关使用有向无环图去构造一个唯一子对象列表的详情见第 9 章“ 派生类 ” 中的“ 虚拟基类 ” ( 注意 , 这些子对象的析构是按反序遍历该列表 ) 。有关如何遍历有向无环图的情况见本章前面的 “ 析构的次序 ”。
非虚拟基类按它们在类说明中出现的次序进行初始化
成员对象的初始化是按它们在类中说明的次序进行初

始化。

在构造函数的成员初始化器表中说明的成员初始化器和基类初始化器的次序不会影响到基类及成员对象进行初始化的次序。

初始化的范围

对基类和成员对象的初始化定值在与其说明在一起的构造函数的范围内，因此 , 它们能够隐含地引用类成员。

拷贝类对象

两种操作会引起对象的拷贝 :

赋值。在一个对象的值被赋给另一个对象时 , 第一个对象是被拷贝给第二个对象的。因此 :

Point a,b;

...

a=b;

会引导起 b 的值拷贝给 a 。

初始化。初始化发生在说明一个新对象时 , 发生在给函数传递参量的值时 , 也生在以传值形式从函数返回参量时。

程序员可以为类类型对象定义拷贝的意义。考虑下面的代码 : TextFile a, b;

a.Open("FILE1.DAT");

b.Open("FILE2.DAT");

b=a;

上面的代码可以意味着 : “ 把 FILE1.DAT 的内容拷贝到 FILE2 中 ” ; 或者它也可

意味着 : “ 忽略 FILE2.DAT ，并把 b 作为 FILE1.DAT 的第二个句柄 ”。程序员有责任为每个类赋以合适的拷贝语义。

拷贝由下列两种方法完成 :

赋值 ( 使用赋值运算符 ,operator=)
初始化 ( 使用拷贝构造函数 )( 有关拷贝构函数的详情见本章开头的“ 说明构造函数的规则 ” ) 。

任一给定的类可以实现一种或以上两种拷贝方式。如果两种方法都未实现 , 赋值将作为一个成员方式 (memberwise) 赋值 , 初始化也作为成员方式初始化。在本章后面会讨论有关 “ 成员方式的赋值和初始化 ” 的细节。

拷贝构造函数带有一个类型 class - name& 的参量 , 其中 class - name 是定义拷贝构造函数的类的名称。例如 :

class Window

{

public:

Window (const Window&); // 定义拷贝构造函数

...

};

注意 : 只要可能 , 拷贝构造函数的参量都应该是 const class-name& 。这可以防止拷贝构造函数无意中修改了要拷贝的对象。这也使得拷贝 const 对象成为可能。

编译器生成的拷贝

编译器生成的拷贝构造函数 , 就像用户自定义的拷贝构造函数 , 带有一个 “ 对类类型引用 ” 的参量类型。只有一个例外是 : 当所有的基类及成员类都说明有拷贝构造函数 , 并且该函数带有一个具有 const class -name& 型的参量时。在这种情况下 , 编译器生成的拷贝构造函数的参量是 const 型。

当拷贝构造函数的参量不是 const 型时 , 通过拷贝一个 const 对象进行初始化会产生一个错误。但反过来就不同：如果参量类型是 const 型的 , 通过拷贝一个非const 型对象进行初始化不会产生错误。

关于 const, 编译器产生的赋值运算符也遵循同样的方式。它们带有一个唯一的class - name& 类型的参量 , 除非赋值运算符在所有的基类及成员类中采用的参量类型是 const class_{- name& 。在这种情况下 , 编译器为该类产生
的赋值运算符采用 count 型参量。}

注意 : 当虚拟基类由拷贝构造函数 ( 无论是编译器产生的 , 还是自定义的 ) 进行初始化时 , 它们仅在被构造时初始化一次。

这些含义同拷贝构造函数很相似。当参量类型不是 const 型时 , 从一个 const 型对象赋值会产生一个错误。反之则不同 : 如果一个 const 型值赋给一个非 const 型值 , 赋值可以进行。

有关重载赋值运算符的更多的情况见第 12 章 “ 重载 ” 中的 “ 赋值 ”。

成员方式的赋值与初始化

缺省的赋值和初始化的方法分别是“ 成员方式 ” 的赋值和“ 成员方式的初始化 ”。

“ 成员方式的赋值 ” 由从一个对象到另一个对象的拷贝过程组成。每次赋值一个成员 , 就像每个成员单独赋值一样 , “ 成员方式的初始化 ” 也是由从一个对象拷贝到另一个对象的拷贝过程组成。每次初始化一个对象，就像是每个成员单独被初始化。这两种方式的主要区别是：成员方式赋值激活的是每个成员的赋值运算符 (operator=), 而成员方式初始化激活的是每个成员的拷贝构造函数。成员方式的赋值仅由说明为如下方式的赋值运算符来实现的。

type & type ::operator=([const|volatile] type &)

如果下列任何条件存在，则成员方式赋值的缺省运算符不能出现 :

某成员类中有 const 成员。
某成员类有引用成员。
某成员类或其基类有一个私有的赋值运算符 (operator=) 。
某成员类或其基类没有赋值运算符 (operator=) 。

如果一个类或其基类有一个私有的拷贝构造函数或者是下列任何条件存在 , 则该类的对于成员方式初始化的缺省构造函数不可能生成：

某成员类有 const 成员。
某成员类有引用成员。
某成员类或其基类有一个私有的拷贝构造函数。
某成员类或基类没有拷贝构造函数。

对于一个给定的类缺省的赋值运算符和拷贝函数总是已经说明了的。除非下面的两个条件都得以满足 , 否则它们是未定义的。

该类并没有为这一拷贝提供自定义的函数。
程序要求提供此函数。如果碰到一个要求成员方式拷贝的赋值运算

符或者初始化符 , 或者取了类的 operator= 函数的地址则这一要求是存在的。

若上述两个条件都没有满足 , 则编译器不必为缺省的赋值运算符和拷贝构造函数产生代码 (MSC 的编译器采用优化可以去掉这些代码 ) 。尤其当类说明了一个自定义的 operator= 函数 , 并以一个对类类型的引用为参量 , 则不会产生缺省的赋值运算符函数。若类说明了一个拷贝构造函数 , 则也不会产生缺省的拷贝构造函数。

因此对于给定的类 A, 下面的说明总是存在的。

// 拷贝构造函数和赋值操作的隐含说明A::A(const A&)

A& A::operator=(const A&)

按上面的标准 , 这一定义只是在需要的时候才要提供。上面例子中的拷贝构造函数被认为是类的公有成员函数。

缺省的赋值运算符使得一给定类的对象可以赋值给其公有基类型的对象。考虑下面的代码 :

class Account

{

public:

// 公有成员函数

... private:

double _balance;

};

class Checking:public Account

{

private:

int _fOverdraftProtect;

};

...

Account account; Checking checking; account=checking;

在上面的例子中 , 选用的赋值运算符是 Account:operator= 。因为缺省的operator= 函数带有一个类型 Acconut& 的参量， checking 的 Account 型子对象拷贝给 account; 而 fOverdraftProtect 没有拷贝。

第 12 章重载

这一章阐述如何使用 C++ 的重载函数以及重载运算符。包括下面一些主题 :

重载概述
说明匹配
参量匹配
重载函数的地址
重载运算符

重载概述

有了 C++ 语言 , 你就可以重载函数和运算符。重载是一种应用 , 它在同一范围中为一个给定函数名称提供了多种定义。委托编译器依据调用该函数的参量选择合适的函数或运算符的版本。例如 :

double max(double d1,double d2)

{

return (d1>d2)?d1:d2;

}

int max (int i1, int i2)

{

return (i1>i2)?i1:i2;

}

作为一个重载函数，函数 max 在程序中使用如下 :

main()

{

int i=max(12,8);

double d=max(32.9,17.4);

return i+(int)d;

}

在第一个例子中 , 要求出两个整型变量的最大值 , 故调用函数 (int,int) 。然而 , 在第二种情况下 , 两个参量是浮点型 , 因此调用的函数是 max(double,double)。

参量类型的差异

重载函数之间的区别在于带有不同初始值的参量类型。因而对一个给定类型的参量以及对于该类型的引用 , 在重载的意义上来说是完全相同的。它们被看成是相同的，因为它们采用了相同的初始值。例如 :max(double,double) 和 (double &,double &) 是完全相同的 , 说明两个这样的函数会引起错误。

出于相同的原因 , 用修饰符 const 和 volatile 进行修饰的函数参量类型同基本

类型 , 在重载的意义上看没有什么不同。

然而重载函数的机制可以区分由 const 或 volatile 修饰的引用以及基本类型的引用。这使得可以有下列代码 :

#include<iostream.h>

class Over

{

public:

Over() {cout << "Over default constructor\n"}-->

Over(over &o){cout << "Over &\n";}

Over(const Over &co) {cout << "const Over &\n";}

Over(volatile Over &vo) {cout << "volatile Over &\n";}

};

void main()

{

Over o1; // 调用缺省构造函数

Over o2(o1); // 调用 Over(Over&)

const Over o3;// 调用缺省构造函数

Over o4(o3); // 调用 Over(const Over &)

volatile Over o5; // 调用缺省构造函数

Over o6(o5); // 调用 Over(volatile Over &)

}

指向 const 和 volatile 对象的指针和指向其基本类型的指针在重载意义上是不同的。

重载函数的限制

组重载函数是否是可接受的如下限制 :
- 该组重载函数中任何两个都必须有不同的参量表。
- 具有相同类型参量表、仅在返回值类型上不同的重载函数会引起错误。

Microsoft 特殊处 →

用户可以仅仅基于返回类型不同而重载 new 运算符。尤其在基于说明的存储器模式修饰符不同时。

Microsoft 特殊处结束

成员函数的重载不能仅基于一个说明为静态的 , 另一个说明为非静态的。
typedef 说明并未定义新的类型 , 它们仅为已存在的类型引入了一个同义词。它们不能影响重载机制。考虑下面的代码 :

typedef char * PSTR;

void Print(char * szToPrint); void Print(PSTR szToPrint);

前面的两个函数有相同的参量表 ,PSTR 是类型 char * 的同义词。在成员范围中 ,

这样的代码会产生错误。

枚举类型是一些可区分的类型 , 故可以区分重载函数。
从区分重载函数的意义上说 , 类型 “ 数组 ” 和 “ 指针 ” 是相同的。对于一维数组来说是正确的。因而下面的重载函数出现了冲突，并会产生一条错误消息 :

void Print (char * szToPrint); void Print (char szToPrint[]);

对于多维数组 , 第二和后续维数视为类型的一部分 , 因此它们可以用来区分重载函数 :

void Print (char szToPrint []); void Print (char szToPrint [][7]);

void Print (char szToPrint [][9][42]);

说明匹配

在同一范围中说明具有相同名称的任何两个函数可以指的是同一函数 , 或者指的是重载的两个不同函数。如果说明的参量列表含有相同的参量类型 ( 如前一节描述的 ) ，则此函数说明指的是同一函数；否则它们指的是用重载选择的不同函数。类的范围是严格定义的，因此一个在基类中说明的函数同一个在派生类中说明的函数有不同的范围。如果一个在派生类中说明的函数同一个基类中说明的函数有相同的名称 , 派生类的函数将隐藏基类中的函数 , 而并不会引起函数重载。

块范围也是严格定义的，因此一个在文件范围中说明的函数同一个局部说明的

函数并不在同一范围中。如果一个局部范围中说明的函数同一个文件范围中说明的函数具有相同的名称 , 则局部说明的函数将隐藏文件范围中说明的函数 , 而并不会引起重载。例如 :

#include <iostream.h>

void func(int i)

{

cout << "Called file-scoped func: " << i << endl;

}

void func (char *sz)

{

cout << "Called locally declared func:" << sz << endl;

}

void main()

{

// 说明 main 中的局部 func 函数

extern void func(char *sz);

func(3); // 错误 : 函数 func(int) 被隐藏了

func("s");

}

上面的代码给出了函数 func 的两个定义。以 char * 类型作为参量的函数定义对于 main 函数是局部的 , 因为有 extern 语句。因而以 int 为参量类型的函数定义被隐藏了起来 , 故第一个对 func 函数的调用是错误的。

对于重载的成员函数 , 不同版本的函数可以给于不同的访问权限。它们仍被视为在类的范围中 , 因而它们是重载函数。考虑下面的代码 , 其中成员函数 Deposit 被重载了 ; 一个版本是 public 的 , 另一个版本是 private 的。

class Account

{

public:

Account();

double Deposit(double dAmount,char *szPassword); private:

double Deposit (double dAmount);

intValidate(char * szPassword);

};

上面的代码要提供一个 Account 类 , 其中执行 Deposit 函数 , 要求提供一个正确的口令。这一点是用重载来实现的。下面的代码给出了如何使用该类，以及对于私有成员函数 Deposit 的错误调用 :

void main()

{

// 分配一个新的 Account 类型的对象

Account *pAcct=new Account

// 存 $57.22 错误 : 调用了一个私有的函数

pAcct->Deposit(57.22);

// 存 $57.22 并提供一个口令 , 正确调用一个公有函数

pAcct->Deposit(57.22,"pswd");

}

double Account::Deposit(double dAmount,char *s2Password)

{

if(Validate(szPassword))

return Deposit(dAmount);

else

return 0.0;

}

注意，在 Account::Deposit 中调用了私有成员函数 Deposit, 这一个调用是正确的。因为 Account::Deposit 是一个成员函数 , 因而有权访问该类的私有成员。

参量匹配

重载函数的选择是把调用函数的参量对当前范围中的函数进行最佳匹配。如果

发现了一个合适的函数 , 则调用此函数。“ 合适 ” 在此处的含义是下列之一 :

发现了一个完全匹配。
采用了一个平常转换（ trival conversion ）。
执行了一个整型参量提升。
存在着所需参量类型的标准转换。
存在着所需参量类型的用户自定义型的转换 ( 无论是转换运算符还是构造函数 ) 。
发现了由 (...) 表示的参量。

编译器为每一个参量创建了一个候选函数集。候选函数是那些在该位置上的实参可以转换成形参类型的函数。每一个参量都建立了一个最佳匹配的函数集。被选择的函数就是所有这些集合的交集。如果交集包含有多个函数 , 重载就是有二义性的 , 并产生一个错误。最后选择的函数总是在该组函数中更匹配 , 至少有一个参量更匹配一些。如果情况不是这样 ( 如果没有更加匹配者 ) ，则函数调用会产生错误。

考虑下面的代码中的说明 ( 函数标明了形式 1, 形式 2 和形式 3, 以便于下面的讨

论 ):

Fraction &Add(Fraction &f,long l);// 形式 1

Fraction &Add(long l,Fraction &f); // 形式 2

Fraction &Add(Fraction &f,Fraction &f);// 形式 3

Fraction F1,F2; 考虑下面的语句 :

F1=Add(F2,23);

前面的语句构造了两个集合 :

集合 1: 第一个参量类型为Fraction 的候选函数

集合 2: 可以把第二参量类型转换成整型的候选函数

形式 1 形式 1(int 可用标准转换转换为 long 型 )

形式 3

在集合 2 的函数中 , 对于它们来说存在着从实参类型到形参类型的隐含转换。在这些转换中有一个函数对于此种转换的代价是最小的。

这两个集合的交集是形式 1 。对于有二义性的函数调用的例子如下 : F1=Add(3,6);

上面的函数调用生成下面的集合 :

集合 1: 第一个参量可以有整型参量的候选函数

形式 2(int 可以用标准转换转换成long 型 )

集合 2: 第二个参量可以有整型参量的候选函数

形式 1(int 型可以用标准转换转换成long 型 )

注意这两个集合的交集是空集 , 因此编译器产生错误消息。对于参量匹配 , 一个

有 n 个缺省参量的函数被当作 n+1 个不同的函数 , 每个函数都有不同个数的参量。

(...) 是作为通配符 ; 它可以匹配任何实参。如果你不是极为小心地设计你的重载函数的话 , 则会导致很多有二义性的集合。

注意 : 重载函数的二义性直到碰到函数调用时才会发现。在那时 , 为函数调用的

每个参数都建立了集合 , 并且你可以发现是否有非二义性的重载存在。这意味着二义性会一直保留在你的代码中 , 直到它们被某个特殊的函数调用所发现。

参量匹配和 this 指针

对于类成员函数根据它们是否被说明为 static, 将按不同的方式对待。因为非静态成员函数有一个隐含的参量以支持 this 指针。非静态函数被视为比静态函数多出一个参量。

除此之外 , 它们的说明是等同的。这些非静态的成员函数要求有一个隐含的 this 指针以匹配调用此函数的对象的类型。或者对于重载运算符来说 , 它们要求第一个参量以匹配运算符作用的对象 ( 有关重载操纵符的情况见本章后面的 “ 重载运算符 ” ) 。

同重载函数的其它参量不同 , 在对 this 指针参量进行匹配时 , 不会引入临时对象，也不会试图进行转换 ) 。

当成员选择符 (->) 用于访问成员函数时 ,this 指针的类型是 class _- name *const 型的。如果成员说明为 const 或者 volatile, 则类型相应地是 const class _- name

*const 或 volatile class -name * const 。

除了把一个隐含的 &( 取地址运算符 ) 加在对象名称的前面之外 , 成员选择符 (.) 也以同样的方式工作。下面的例子显示这是如何工作的 :

// 在代码中碰到的表达式obj.name

// 编译器如何对待它

(&obj)->name

在参量匹配上运算符 ->* 和 .*( 指向成员的指针 ) 的左操作数同运算符 . 和 -> 是同样对待的。

参量匹配和转换

当编译器试图按函数说明中的参量进行实参匹配时 , 如果没有找到精确的匹配 , 编译器可以支持标准的或用户自定义的转换以获得正确的类型。转换的应用受如下规则的限制 :

含有多个用户自定义转换的转换序列是不能接受的。
通过移去中间转换即可缩短的转换序列也是不可被接受的。

转换的结果序列 ( 如果有的话 ) 称为最佳匹配序列。使用标准转换 ( 第 3 章 “ 标准转换 ” 中描述 ), 可有几种办法把一个 int 型对象转换成 unsigned long 型 :

把 int 型转换成 long 型然后再转换成 unsig n ed long 型
把 int 型直接转换成 unsigned long 型。

第一种方法 , 尽管达到了所希望的目标 , 但不是一个最佳匹配的序列 , 因为存在着一个更短的匹配序列。

表 12.1 给出了一组转换 ,称为平常转换。它们在对决定哪一个序列是最佳匹配序列中起有限的作用。平常转换影响选择序列的步骤在下面讨论。

表 12.1 平常转换

从类型转换到类型

类型名称类型名称 &

类型名称 & 类型名称

类型名称 [] 类型名称 *

类型名称 ( 参量表 ) (* 类型名称 )( 参量表 )

类型名称 const 类型名称

类型名称 volatile 类型名称

类型名称 * const 类型名称 *

类型名称 * volatile 类型名称 *

转换的顺序按如下进行试探 :

5. 精确匹配。在调用函数的参量类型和函数原型中说明的类型之间的精确匹配总是最好的匹配。平常转换序列归为精确匹配。然而一般认为，不做任何这些转换的序列比做了以下转换的序列更好 :

从指针到指向 const 的指针 (type* 到 const type*) 。
从指针到指向 volatile 的指针 (type * 到 volatle type*) 。
从引用到对 const 的引用 (type & 到 const type &) 。
从引用到对 volatile 的引用 (type & 到 volatile type &) 。

使用参量提升的匹配。任何不归类为精确匹配的序列若仅含有必要的参量提升 ( 从 float 到 double) ，则平常转换的序列将归类为使用参量提升的匹配。尽管这种匹配没有精确匹配好 , 但用参量提升的匹配比用标准转换的匹配好。
使用标准转换的匹配。任何不能归为精确匹配或参量提升的匹配的任何序列若仅含有标准转换，则平常转换被归类为使用标准转换的匹配。在这种匹配中 , 要遵循下面的规则 :
- 把一个派生类的指针转换为一个指向其直接基类或非直接基类的指针比转换为 void * 或 const void* 更合适一些。
- 把一个派生类的指针转换为一个指向基类的指针，由此引出的对更靠近的基类的匹配是转换为直接基类的指针。假设如图 12.1 所示的类层次。

第 11 章特殊成员函数 - 图2

图 12.1 更可接受的转换的示意图

从类型 D* 转换为类型 C* 比从类型 D* 转换为类型 B* 更好。同样 , 从类型 D* 到类型 B* 的转换比从类型 D* 到类型 A* 的转换更好。

同样的规则也适用于引用的转换。从类型 D& 到类型 C& 比从类型 D& 到类型 B& 更好 , 依此类推。

这一规则也适用于指向成员指针的转换。从类型 T D::* 到类型 T C::* 的转换比从类型 T D::* 到类型 T B::* 的转换更好，依此类推 ( 其中 T 是成员的类型 ) 。

上面的规则适用于在同一个给定的派生路径中。考虑图 12.2 中的层次图。

第 11 章特殊成员函数 - 图3

图 12.2 更可接受的转换的多重继承示意图

从类型 C* 到类型 B* 的转换比从类型 C* 到类型 A* 的转换更好。原因是它们处在同一路径之上。但 , 从类型 C* 到类型 D* 的转换并不比从类型 C* 到类型 A* 更好 , 因为转换是沿着不同的路径。

采用自定义型转换的匹配。这种序列不能归类为精确匹配、利用参量提升的匹配或采用标准转换的匹配。归为采用自定义转换的匹配序列必须仅含有用户自定义的转换、标准转换或平常转换。采用自定义转换的匹配比采用省略符的匹配要好些 , 但比用标准转换的匹配要差一些。
采用省略符 ( … ) 的匹配。任何匹配函数说明中省略符的序列都归为采用省略符的匹配。这种匹配是最差的匹配。

用户自定义的转换适用于没有内部的参量提升或存在转换的情况。这种转换的选择基于要被匹配的参量的类型。考虑下面的代码 :

class UDC

{

public:

operator int(); operator long();

};

void Print (int I );

…

UDC udc;

Print(udc);

对于类 UDC 可用的用户自定义的转换是 int 型和 long 型，因而编译器可以接受来自于要被匹配的对象的类型的转换。存在着一个从 UDC 到 int 型的转换 , 故选择了此转换。

在参量匹配过程中 , 标准转换可以用于参量及用户自定义转换的返回值。因而 , 下面的代码是可以工作的 :

void logToFile(long l);

…

UDC udc;

LongToFile(udc);

在上面的例子中 , 将调用用户自定义型转换 operator long 把 UDC 型转换为 long 型。如果没有定义从 UDC 型到 long 型的转换 , 此转换将按如下过程进行 : 先用自定义型转换把 UDC 型转换为 int 型 , 然后将利用从 int 型到 long 型的标准转换来匹配说明中的参量。

如果匹配参量需要自定义型转换 , 则在评价最佳匹配时是不考虑标准转换的。即使有多个候选函数要求用户自定义转换 , 也不对标准转换进行考虑。在这种情况下 , 这些函数是等同的。例如 :

class UDC1;

{

public:

UDC1(int); // 用户自定义的从 int 型的转换

};

class UDC2

{

public:

UDC2(long); // 用户自定义的从 long 型的转换

};

…

void Func(UDC1); void Fuce(UDC2);

…

Func(1);

这两个版本的 Func 都要求用户自定义的转换 : 把 int 型转换为类类型参量。可能的转换如下 :

从 int 型到 UDC1 的转换 ( 用户自定义型转换 ) 。
从 int 型到 long 型的转换 , 然后转换为 UDC2 型 ( 分两步转换 ) 。

尽管第二种转换方式要求有标准转换和用户自定义型转换 , 然而这两种转换是等同的。

注意 : 用户自定义的转换被视为通过构造函数的转换或通过初始化的转换 ( 转换函数 ) 。在考虑最佳匹配时 , 这两种方法视为是等同的。

重载函数的地址

不带参量表使用一个函数的名称会返回该函数的地址 , 例如 : int Func(int I ,int j);

int Func(long l);

…

int (*pFunc)(int,int)=Func;

在前面的例子中将选用第一个 Func 函数，并且它的地址被拷贝到 pFunc 中。通过参量表同目标的完全匹配来搜索函数 , 编译器可以决定选择哪个版本的函数。在重载函数中说明的参数表对照下列之一进行匹配。

一个被初始化的对象 ( 如前面的例子 )
赋值语句的左边
一个函数的形参
一个自定义运算符的形参
函数的返回值

如果没有找到完全的匹配 , 则取函数地址的表达式是有二义性的 , 并产生一个错误。

注意，尽管在上面的例子中使用了一个非成员函数 Func, 然而同样的规则适用于取重载的成员函数的地址。

重载运算符

使用 C++, 你可以重新定义大多数内部运算符的函数 , 这些函数可以基于全局方式下或类方式下进行重定义或重载。重载运算符是用函数来实现的 , 它们可以是成员函数也可以是全局函数。

个重载运算符的名称是 operator x , 其中 x 是出现在表 12.2 中的运算符。例如 : 要重载一个加法运算符 , 你可以定义一个函数叫作 operator+ 。同样地 , 重载

加 / 赋值运算符 (+=), 可以定义一个函数叫作 :operator+= 。

尽管这些运算符函数出现在代码中时通常是由编译器隐含调用的 , 但它们可以按任何成员函数或非成员函数的方式进行显式调用。

Point pt;

pt. operator + (3); // 调用加法运算符向 pt. 加 3

表 12.2 可重定义的运算符

运算符	名称	类型
,	逗号	双目
!	逻辑非	单目
!=	不等	双目
%	取模	双目
%=	取模 / 赋值	双目
&	按位 AND	双目
&	取地址	单目
&&	逻辑和	双目
&=	按位和 / 赋值	双目
()	函数调用	--
*	乘法	双目
*	指针间接引用	单目
*=	乘法 / 赋值	双目
+	加法	双目

+	单目加	单目
++	增 1	单目
+=	加法 / 赋值	双目
-	减法	双目
-	单目取反	单目
--	减	1	单目
-=	减法 / 赋值	双目
->	成员选择	双目
->*	指向成员的指针选择	双目
/	除法	双目
/=	除法 / 赋值	双目
<	小于	双目
<<	左移	双目
<<=	左移 / 赋值	双目
<=	小于等于	双目
=	赋值	双目
==	等于	双目
>	大于	双目
>=	大于 / 赋值	双目
>>	右移	双目
>>=	右移 / 赋值	双目

[]	数组下标	— —
^	异或	双目
^=	异或 / 赋值	双目
\|	按位或	双目
\|=	按位或 / 赋值	双目
\|\|	逻辑或	双目
~	求补	单目
delete	delete	— —
new	new	— —

* 有两种方式的增 1 和减 1 存在 : 前缀方式和后缀方式。

重载运算符的各个分类的约束在本章后面 “ 单目运算符 ”、“ 双目运算符 ”、“ 赋值 ”、“ 函数调用 ”、“ 下标运算 ”、“ 类成员访问 ” 及 “ 增 1 和减 1 ” 中描述。

表 12.3 不能重载的运算符

运算符名称

. 成员选择

.* 指向成员指针的选择

:: 范围分辨符

?: 条件运算符

# 预处理符号

## 预处理符号

运算符重载的一般规则

下面的规则约束着重载运算符如何实现，但它们并不适用于 new 和 delete 运算符。这两个运算符在第 4 章中单独讨论。

运算符必须要么是成员函数，或者带有某个类的参量，或者是枚举类型的参量、或者带有某个类的引用、或某个枚举的类型的引用。例如 :

class Point

{

public:

point operator<(Point &); // 说明一个成员运算符重载

...

// 说明加法运算符

friend Point operator+(Point &,int);

friend Point operator+(int,Point &);

};

上面的例子代码中说明了小于运算符成员函数 ; 然而加法运算符是作为全局函数说明的 , 并具有友元访问属性。注意，对于一个给定的运算符可以提供多个实现。在上面的加法运算符的例子中 , 为了方便加法的交换性 , 提供了两个实现。正如这些运算符一样 , 把 Point 加到 Point, 把 int 加到 Point 的运算符也可以实现。

运算符要遵守它们同内部类型一起使用所指定的优先原则、分组及操作数的个数。因此 , 无法表达把 2 及 3 加到一个 Point 对象中的

含义 , 除了把 2 加到 X 坐标中 , 把 3 加到 Y 坐标中。

单目运算符说明为成员函数不带参量 ; 如果说明为全局函数 , 要带一个参量。
双目运算符说明为成员函数只带一个参量 ; 如果说明为全局函数 , 要带两个参量。
所有的重载运算符除了赋值 (operator=) 外均可被派生类继承。
重载运算符的成员函数的第一个参量总是激活该运算符的对象的类类型参量 ( 运算符被定义的类 , 或者定义了运算符的类的派生类 ) 。对于第一个参量也不支持转换。

注意，任何运算符的意义都可能被完全地改变了 , 这包括取地址 (&) 、赋值 (=) 、函数调用运算符的含义。，同理，内部的类型可由于使用了运算符重载而改变。例如 : 下面四条语句在完成求值以后完全等同 :

var=var+1; var+=1; var++;

++var;

对于重载了运算符的类类型来说 , 这种确信是靠不住的，而且 , 对于在基本类型中使用这些运算符的隐含条件，对于重载的运算符来说是放松了。例如 : 加法 / 赋值操纵符 , 在应用于基本类型时 , 要求其左操作数是 l 值的 ; 但此运算符重载以后就没有这种要求了。

注意 : 出于一致的考虑 , 最好还是遵循内部类型的模式进行运算符重载。如果一个重载的运算符同它在其他上下文中的意义不同 , 则它只会引起迷惑而不是更有

用。

单目运算符

表 12.4 给出了单目运算符。

表 12.4 可重载的单目运算符

运算符名称

! 逻辑非

& 取地址

~ 求补

* 指针间接引用

+ 单目加

++ 增 1

- 单目取反

-- 减 1

在表 12.4 中所给出的运算符中 , 后缀的增 1 和减 1 运算符在 “ 增 1 及减 1 ” 一节讨论。

说明一个单目运算符为一个非静态成员 , 必须按如下形式进行说明 :

ret-type operator op ()

其中 ret-type 是返回类型，而 op 是表 12.4 中的某个运算符。说明一个单目运算符为全局函数 , 必须按如下形式说明 :

ret-type operator op ( arg )

其中 ret-type 和 op 的含义同成员运算符函数中的描述 , 而 arg 是对其操作的类类型参量。

注意：对于单目运算符的返回值没有限制。例如 , 对于一个逻辑非运算符，返回一个必要的值是合适的。但这一点不是必须的。

增 1 和减 1

增 1 和减 1 运算符放入特殊的分类是因为每个运算符都有两种形式 :

前缀型增 1 和后缀型增 1 。
前缀型减 1 和后缀型减 1 。

在你编写重载运算符函数时 , 为这种运算符的前缀和后缀型各自提供一个版本是很有用的。为分清这两个版本 , 要遵循下面一些规则 : 对于前缀型运算符可按其它任何单目操纵符完全相同的方式说明 , 后缀型则要接受一个附加的 int 型参量。

重要 : 当为后缀型增 1 和减 1 运算符说明重载函数时 , 附加的参量必须是 int 型的 , 说明任何其它的类型都会产生错误。

下面的例子显示了如何为类 Point 定义前缀型和后缀型增 1 和减 1 运算符函数 : class Point

{

public:

// 说明前缀和后缀型增 1 运算符

Point& operator++(); // 前缀型增 1 运算符

Point operator++(int); // 后缀型增 1 运算符

// 说明前缀和后缀型减 1 运算符

Point& operator--(); // 前缀型减 1 运算符

Point operator--(int); // 后缀型减 1 运算符

// 说明缺省的构造函数

Point() {_x=_y=0;}

// 说明访问函数

int x() {return _x;}

int y() {return _y;} private:

int _x,_y;

}

// 定义前缀型增 1 运算符Point& Point::operator ++()

{

_x++;

_y++;

return *this;

}

// 定义后缀型增 1 运算符

Point Point:: operator++(int)

{

Point temp =*this;

++*this;

return temp;

}

// 定义前缀型减 1 运算符Point& Point::operator--()

{

_x--;

_y--;

return *this;

}

// 定义后缀型减 1 运算符

Point Point::operator--(int)

{

Point temp= *this;

--*this;

return temp;

}

使用下面的函数头 , 可以在文件范围 ( 全局 ) 定义同样的运算符 : friend Point& operator++(Point&) // 前缀增 1

friend Point& operator++(Point&,int) // 后缀增 1 friend Point& operator--(Point&) // 前缀减 1 friend Point& operator--(Point&,int) // 后缀减 1

表示后缀型增 1 减 1 运算符的 int 型参量并不是普通地用作参量传递。它通常含有 0 值 , 然而可以按如下使用 :

class Int

{

public:

Int& operator++(int n); private:

int _i;

};

Int& Int::operator++(int n);

{

if(n!=0)// 传递了一个参量的处理情况

_i+=n;

else

_i++; // 没有传递参量的处理情况

return *this;

}

...

Int i;

i. operator++(25); // 加 25

如上面所示的 , 除了显式调用之外没有别的语法可以用于使用增 1 减 1 运算符传递函数值。一个更直接地实现这一功能的办法是重载 += 运算符。

双目运算符

表 12.5 给出了可被重载的运算符。

表 12.5 可重定义的双目运算符

运算符名称

, 逗号

!= 不等

% 取模

%= 取模 / 赋值

& 按位和

&& 逻辑和

&= 按位和 / 赋值

* 乘法

*= 乘法 / 赋值

+ 加法

+= 加法 / 赋值

- 减法

-= 减法 / 赋值

-> 成员选择

->* 指向成员的指针选择

/ 除法

/= 除法 / 赋值

< 小于

<< 左移

<<= 左移 / 赋值

<= 小于等于

= 赋值

== 等于

> 大于

>= 于 / 等于

>> 右移

>>= 右移 / 赋值

^ 异或

^= 异或 / 赋值

| 按位或

|= 按位或 / 赋值

|| 逻辑或

说明一个双目运算符函数为非静态成员函数 , 必须按如下形式说明 :

ret-type operator op ( arg )

其中 ret-type 是返回类型 , op 是表 12.5 中列出的某个运算符 , 而 arg 则是一个任意类型的参量。

说明一个双目运算符为全局函数 , 必须按如下形式说明 :

ret-type operator op ( arg1,arg2 )

其中 ret-type 和 op 同成员函数中的描述是一致的 , 而 arg1 和 arg2 是参量。至少其中之一必须是类类型。

注意 : 对于双目运算符的返回类型没有限制 ; 然而大多数用户自定义型双目运算符返回类类型或类类型的引用。

赋值

赋值运算符严格地说是一个双目运算符。它的说明等同于其它双目运算符的说明，但下列情况除外。

它必须是非静态成员函数。没有 operator= 可以说明为非成员函数。
它不能被派生类继承。
如果不存在缺省的 operator= 函数 , 则编译器会为该类生成一个缺省的函数 ( 有关缺省的 operator= 函数见第 11 章 “ 特殊成员函数 ” 中

的 “ 成员方式的赋值和初始化 ” ) 。下面是如何说明赋值运算符的示例 :

class Point

{

public:

Point &operator=(Point &); // 右边是参量

...

}

// 定义赋值运算符

Point &Point::operator=(Point &ptRHS)

{

_x = ptRHS._x;

_y = ptRHS._y;

return *this ; // 赋值运算符返回左边

}

注意，提供的参量是表达式的右边。运算符返回的对象保持了赋值运算符的行为 ( 赋值完成以后 , 赋值运算符将返回的是左边的值 ), 这样，可以写出下面的语句 :

pt1=pt2=pt3;

函数调用

函数调用运算符涉及使用括号，它是双目运算符。函数的语法如下 :

语法

primary-expression ( expression-list _opt )

在这里 , primary-expression 是第一个操作数 , expression-list( 可能是空参量表 ) 是第二个操作数。函数调用运算符用于多参量的运算。这一点可以做到 , 因为expression-list 是一个参量表，而不是一个单一的参量。函数调用运算符必须是一个非静态的成员函数。

在函数调用运算符被重载以后 , 它不会改变函数被调用的行为，而只会影响到该操纵符运用于某给定类类型时如何理解该运算符。例如 : 下面的代码通常是无意义的 :

Point pt; pt(3,2);

给出适当的重载函数调用运算符 , 这一语法就可用来给 X 坐标增加 3 个单位 , 为Y 坐标增加 2 个单位。下面的代码说明上述定义 :

class Point

{ public:

Point(){_x=_y=0;}

Point &operator()(int dx,int dy)

{ _x+=dx;_y+=dy;return *this;} private:

int _x,_y;

};

...

Point pt; pt(3,2);

注意，函数调用运算符适用于对象名 , 而不是函数名称。

下标运算

就像函数调用运算符一样 , 下标运算符 ([]) 也是一个双目运算符。下标运算符必须是一个非静态成员函数，并带有一个参量。这一参量可以是任何类型，并指明所希望的数组下标。

下面的例子显示如何创建一个实现边界检查的 int 型向量 : #include <iostream.h>

class IntVector

{

public:

IntVector(int cElements);

~IntVector(){delete _iElements;}

int& operator[](int nSubscript); private;

int*_iElements;

int_iUpprtBound;

};

// 构造一个 IntVector 对象IntVector::IntVector(int cElements)

{

_iElements = new int[cElements];

_iUpperBound=cElements;

}

//InVetor 的下标运算符

int& IntVector:: operator[] ( int nSubscript)

{

static int iErr=-1;

if(nSubscript>=0 && nSubscript< _iUpperBound)

return _iElements[nSubscript];

else

{

clog<<"Array bound violation."<<endl;

return iErr;

}

/ / 测试 IntVector 类int main()

{

IntVector v(10);

for(int i=0; i<=10;++i)

v[i]=i;

v[3]=v[9];

for (i=0;i<=10;++i)

cout<<"Element:["<<i<<"]="<<v[i]<<endl;

return v[0];

}

在上面的例子中 , 当 i 到 10 时 ,operator[] 检测到使用了一个超过边界的下标 , 并发出一个错误消息。

注意，函数 operator[] 返回的是一个引用类型。这使它是一个 l 值的 , 使得在赋值号的两边可以使用下标表达式。

类成员访问

类成员的访问可以通过重载成员选择符 (->) 加以控制。在使用中 , 这一个运算符视为单目运算符 , 并且重载的运算符函数必须是成员函数 , 因此这一函数的说明是 :

class-type *operator->()

这里 class-type 是该运算符所属的类的名称。成员选择符函数必须作为非静态成员函数。

该运算符 ( 通常同指针间接引用运算符连用 ) 用于实现 “ 灵敏 ” 指针 , 该指针使得指针在间接引用或计数之前生效。

成员选择符 (.) 是不能被重载的。

第 11 章 特 殊 成 员 函 数

第 11 章 特 殊 成 员 函 数

构 造 函 数

析 构 函 数

临 时 对 象

转 换

new 和 delete 运 算 符

用 特 殊 成 员 函 数 初 始 化

拷 贝 类 对 象

重 载 概 述

说 明 匹 配

参 量 匹 配

重 载 函 数 的 地 址

重 载 运 算 符

第 11 章特殊成员函数

第 11 章特殊成员函数

构造函数

析构函数

临时对象

转换

new 和 delete 运算符

用特殊成员函数初始化

拷贝类对象

重载概述

说明匹配

参量匹配

重载函数的地址

重载运算符