第6章运算符重载(1)

1、C+程序设计实例教程程序设计实例教程第第6章章 运算符重载运算符重载 运算符重载是函数调用的另外一种方式，通过运算符重载可以使关于自定义类型对象的一些函数（全局函数或自定义类型的成员函数）采用运算符表达式的形式调用。 本章介绍运算符重载的基本概念、使用全局函数和成员函数为自定义类型重载运算符的方法以及“=”、“ ”、“( )”等特殊运算符的重载方法。 为使举例更加贴切，本章的内容通过自编类型Fraction、String和和TimeList展开。在这些类型中，我们重载了一些常用的运算符，并介绍重载它们的方法和注意事项。C+程序设计实例教程程序设计实例教程知识体系知识体系: 本章要点：本章要点：

2、6.1运算符重载概述运算符重载概述 6.2程序实例程序实例分数类分数类Fraction 6.3使用非使用非static成员函数重载运算符成员函数重载运算符 6.4使用全局函数重载运算符使用全局函数重载运算符 6.5重载流插入重载流插入“” 6.6与类型转换相关的运算符重载与类型转换相关的运算符重载 6.7重载重载“+”和和“-”运算符运算符 6.8程序实例程序实例字符串类字符串类String C+程序设计实例教程程序设计实例教程知识体系知识体系:6.9重载赋值运算符重载赋值运算符“=” 6.10重载下标运算符重载下标运算符“ ” 6.11重载重载“( )”运算符运算符 6.12函数对象函数对象

3、 6.13程序实例程序实例链表类链表类TimeList 6.14重载重载“*”运算符运算符 6.15重载重载“-”运算符运算符 6.16重载重载“-*”运算符运算符 6.17重载全局重载全局new,new和和delete,delete运算运算符符 C+程序设计实例教程程序设计实例教程知识体系知识体系:6.18为自定义类型重载为自定义类型重载new、new 和和delete、delete 运算符运算符 6.19定位的定位的new和和new 运算符运算符 6.20程序实例程序实例简单的内存管理简单的内存管理 C+程序设计实例教程程序设计实例教程6.1 运算符重载概述运算符重载概述 运算符重载是C+

4、语言吸引编程者的特点之一。运算符重载可以使自定义类型对象与C+语言中的运算符一起使用，这样会使自定义类型的使用者像操作基础类型变量一样操作自定义类型对象。 C+语言允许在自定义类型中把其它类型的名字当作运算符进行重载，以此来提供该类型数据到被重载类型的隐式转换方法。为自定义类型提供向其它类型隐式转换方法也可以算作运算符重载的作用之一。 为自定义类型重载运算符，可以使用全局函数，也可以使用该类型的成员函数。 C+程序设计实例教程程序设计实例教程虽然运算符重载的语法规则比较简单，但是运算符重载需要遵循如下一些原则： 为自定义类型重载运算符时，不能创造新的运算符，也无法改变现有运算符的优先级，例如，

5、C+语言中没有“*”运算符，自定义类型就不能重载它。 不能为基础数据类型重载运算符，例如，我们不能通过重载“+”运算符来改变int型数据的加法行为。 “.”、“.*”、“:”、“?:”以及sizeof运算符不能重载。 “=”、“( )”、“ ”、“-”、“-*”以及类型转换运算符必须使用成员函数重载，而不能使用全局函数重载。 系统为自定义类型默认提供“=”、“&”和“,”运算符，不用重载即可使用，但如果重载了它们中的某个，使用时将按照自定义的运算符重载函数执行。1. 重载某两个运算符，不等于重载它们的复合运算符。 C+程序设计实例教程程序设计实例教程除了上述的原则以外，我们还给出一些运

6、算符重载的建议：运算符重载时，尽量保持运算符本身的含义。使用全局函数为自定义类型重载流插入运算符“”。如果使用成员函数重载流插入运算符“”，调用时自定义类型对象是左操作数，流对象是右操作数，这与平常的使用习惯相反。最好不要为自定义类型重载逻辑与“&”和逻辑或“|”运算符，因为无法完全模拟它们的行为。 1. 总体的方针：使用成员函数重载一元运算符；使用成员函数重载“+=”、“-=”、“*=”、“/=”、“%=”等与赋值运算有关的运算符；使用全局函数重载与赋值无关的且不是必须使用成员函数重载的二元运算符。C+程序设计实例教程程序设计实例教程6.2 程序实例程序实例分数类分数类Fractio

7、n 本节的程序本节的程序6.1定义了类型定义了类型Fraction（分数），该类包（分数），该类包含含2个个int型成员变量型成员变量molecular和和denominator，分别，分别表示分子和分母。我们为表示分子和分母。我们为Fraction类型重载了一些运算类型重载了一些运算符，使其符，使其“行为行为”更像一个基础数据类型。本例中的每更像一个基础数据类型。本例中的每一个运算符重载函数对应一个知识点，这些知识点将在一个运算符重载函数对应一个知识点，这些知识点将在6.3至至6.7节中逐一讲解，本节的后半部分只讲解非运算节中逐一讲解，本节的后半部分只讲解非运算符重载的函数，读者阅读本程序时

8、，可以暂时把与运算符重载的函数，读者阅读本程序时，可以暂时把与运算符重载函数略过，等到学习符重载函数略过，等到学习6.3至至6.7节时再重新阅读。节时再重新阅读。C+程序设计实例教程程序设计实例教程6.3 使用非使用非static成员函数重载运算符成员函数重载运算符 C+语言允许使用自定义类型的非static成员函数为该自定义类型重载运算符，非static成员函数需要使用对象来调用，调用者算作运算符的一个操作数。因此，使用非static成员函数重载一元运算符时，函数没有参数，调用者就是一元运算唯一的操作数；重载二元运算符时，函数有1个参数并作为操作数，调用者就是二元运算的左操作数，参数是二元运

9、算的右操作数。C+程序设计实例教程程序设计实例教程6.4 使用全局函数重载运算符 C+语言允许使用全局函数为自定义类型重载运算符（除了那些必须使用成员函数重载的运算符）。使用全局函数为自定义类型重载一元运算符时，函数有1个参数，这个参数就是一元运算唯一的操作数；使用全局函数为自定义类型重载二元运算符时，函数有参数2个操作数，第1个参数是二元运算的左操作数，第2个参数是二元运算的右操作数。由于使用全局函数为自定义类型重载运算符时，经常访问该自定义类型的private或protected成员，因此，许多编程者习惯将这些实现运算符重载的全局函数声明为该自定义类型的友元函数。C+程序设计实例教程程序设

10、计实例教程6.5 重载流插入重载流插入“” 为自定义类型重载流插入“”，是为了让自定义类型对象能够向基础数据类型变量一样使用运算符“”进行输出和输入。 流插入“”所表示的运算都是二元运算，左操作数是流对象，右操作数是要输出或输入的数据。 另外，为了能够链式的使用运算符“”，在为自定义类型重载这两个运算符时，需要返回流对象的引用（参见第1章和3.17节）。C+程序设计实例教程程序设计实例教程6.6 与类型转换相关的运算符重载与类型转换相关的运算符重载 在本书的4.9节中，我们讲述了自定义类型中，需要提供一个参数的构造函数有类型转换的功能，这种转换可以是隐式的，也可以是显式的。例如： class

11、A public: A(B); ; 节要讨论的是与上述问题相反的事情，即如何把A类型的数据转换为B类型的数据。 程序6.2为Fraction重新编写了测试程序，用来说明重载double运算符的成员函数。 C+程序设计实例教程程序设计实例教程8 void f1(double d) 9 cout我的参数是我的参数是double型，型，d=dendl;11 12 void f2(Fraction f)13 cout我的参数是我的参数是Fraction型，型，f=fendl;15 17 int main()18 19 Fraction a(1,4);20 f1(a);21 f2(1.5);23 Fra

12、ction c;24 c=1.5-a;25 coutc=cendl;27 /c=a-1.5;编译错误编译错误28 c=a.operator -(1.5);29 coutc=cendl;31 /c=a+1.5;编译错误编译错误32 c=a+Fraction(1.5);33 coutc=cendl;35 /c=1.5+a;编译错误编译错误36 c=double(a)+1.5;37 coutc=cendl;39 return 0;40 显示结果：显示结果：我的参数是我的参数是double型，型，d=0.25我的参数是我的参数是Fraction型，型，f=3/2c=5/4c=-5/4c=7/4c=7/

13、4 C+程序设计实例教程程序设计实例教程6.7 重载重载“+”和和“-”运算符运算符 “+”和“-”运算符都是一元运算符，并且各分为前缀和后缀两种情况。前缀和后缀的“+”和“-”运算符都可以使用全局函数或自定义类型的成员函数来重载。 在讨论如何重载它们之前，我们先通过程序6.3来分析基础类型int前缀与后缀“+”运算的各自行为以及它们之间的区别，前缀与后缀“-”运算与之类似。C+程序设计实例教程程序设计实例教程1 /6.3 int型的前缀型的前缀+与后缀与后缀+ 2 #include4 using std:cout; 5 using std:endl;7 int main() 8 9 int

14、i=0,j=0;10 int x=+i;11 int y=j+;12 couti=iendl;13 coutj=jendl;14 coutx=xendl;15 couty=yendl;17 int k=0;18 +k;19 coutk=kendl;20 /k+;编译错误编译错误21 +k=9;22 coutk=kendl;23 /k+=9;编译错误编译错误25 return 0;26 显式结果：显式结果：i=1j=1x=1y=0k=2k=9C+程序设计实例教程程序设计实例教程我们使用程序6.4中的两个函数pre和post分别模仿int型变量的前缀和后缀“+”运算。 1 /6.4 全局函数模仿全

15、局函数模仿int型的前缀型的前缀+与后缀与后缀+ 2 #include 3 4 using std:cout; 5 using std:endl; 6 7 int& pre(int & a) 8 9 a=a+1;10 return a;11 12 int post(int & a)13 14 int t=a;15 a=a+1;16 return t;17 C+程序设计实例教程程序设计实例教程19 int main()20 21 int i=0,j=0;22 int x=pre(i);23 int y=post(j);24 couti=iendl;25 coutj=jen

16、dl;26 coutx=xendl;27 couty=yendl;29 int k=0;30 pre(pre(k);31 coutk=kendl;32 /post(post(k);编译错误编译错误33 pre(k)=9;34 coutk=kendl;35 /post(k)=9;编译错误编译错误37 return 0;38 显示结果：显示结果：i=1j=1x=1y=0k=2k=9C+程序设计实例教程程序设计实例教程6.8 程序实例字符串类String 在C+/C语言的基础数据类型中，没有用于表示字符串的数据类型。C语言程序一般使用char型数组表示字符串。C+语言程序可以使用C语言程序所采用的方

17、法，也可以使用标准库中提供的类型string。标准库中的类型string封装了关于字符串的基本操作。 为介绍“=”、“ ”等运算符的重载方法，本节的程序6.5中定义了类型String，自定义类型String实现与标准库中的类型string相似的功能。C+程序设计实例教程程序设计实例教程6.9 重载赋值运算符重载赋值运算符“=” 为了避免用户改变基础数据类型内置赋值运算符“=”的行为，C+语言要求为自定义类型重载赋值运算符“=”时，必须使用该类型的成员函数。赋值运算是二元运算，调用赋值函数为自定义类型对象赋值时，该自定义类型对象必然出现在“=”的左侧，也就是说，赋值运算符“=”的第1个操作数必然

18、是该自定义类型的对象。 因此，使用成员函数为自定义类型A重载二元运算符“=”的一般形式如下： C A:operator=(B); C是该函数的返回值类型，表示包括void在内的任意数据类型，即该函数可以有或没有返回值；B是赋值表达式右值的数据类型，表示包括A在内，但不包括void在内的任意数据类型。 C+程序设计实例教程程序设计实例教程6.10 重载下标运算符重载下标运算符“ ” “ ”称为下标运算符，与赋值运算符类似，该运算符必须使用成员函数重载。下标运算属于二元运算，左操作数是重载该运算符自定义类型的对象，返回值类型和参数类型（右操作数类型）没有特殊要求。 C+程序设计实例教程程序设计实例

19、教程6.11重载重载“( )”运算符运算符 C+语言中，允许重载的运算符几乎都是一元或二元运算符，如果要以运算符重载的形式为自定义类型提供二元以上的运算时，可以重载“( )”运算符。“( )”称为函数调用运算符，与赋值运算符类似，该运算符必须使用成员函数重载。为自定义类型重载该运算符时，参数的类型和个数以及返回值类型都是任意的。C+程序设计实例教程程序设计实例教程6.12 函数对象函数对象 重载了“( )”运算符的自定义类型生成的对象可以像函数名一样调用该类的“( )”运算符函数，所以该对象称为函数对象。函数对象一般被用于代替函数指针。在2.12节我们说明了函数指针作为另外一个函数的参数，可以

20、使该函数更具通用性，使程序更具可扩展性。 本节通过程序6.6（使用函数指针）和程序6.7（使用函数对象）的比较，来说明函数对象相对于函数指针的优势。 C+程序设计实例教程程序设计实例教程6 void print_if(const int * arr,int len,bool (*con)(int) 7 for(int i=0;ilen;+i) 9 if(con(arri)10 coutarri ;11 coutendl;12 13 bool less_5(int n)14 return n10; 21 bool not_equal_0(int n)22 return n!=0; 25 int

21、main()26 27 int a10=0,1,2,35,46,4,8,0,6,0;28 29 print_if(a,10,less_5);30 print_if(a,10,greater_10);31 print_if(a,10,not_equal_0);33 return 0;34 显式结果：显式结果：0 1 2 4 0 035 461 2 35 46 4 8 6C+程序设计实例教程程序设计实例教程6.13 程序实例程序实例链表类链表类TimeList 在本节的程序6.8中，我们模仿ListStack类定义TimeList类，TimeList类是一个Time类对象的单向链表。在TimeLi

22、st类中，我们去掉了ListStack类中的push、pop等关于栈操作的成员函数，新加入的insert、remove和erase成员函数，负责在链表中的任意位置插入或删除元素，使TimeList类看起来像一个“真正”的链表。同时，为了方便遍历链表中的元素，我们在TimeList类中定义了Iterator类。 程序6.8一共涉及4个类，分别是Time（时间类）、TimeList（存放Time对象的单向链表类）、ListNode（链表节点类）以及Iterator（链表的迭代器类）。C+程序设计实例教程程序设计实例教程6.14 重载“*”运算符 一元的“*”运算符用于指针变量的解引用，即“*”运算

23、返回操作数所代表地址处存放对象的引用。在程序6.8中，TimeList类表示存放Time类对象的单向链表，链表中的每个节点都是ListNode类的对象，ListNode类对象的成员变量data存放Time类对象，Iterator类是为了方便遍历链表而编写的类，该类使用一个指向ListNode类型对象的指针p作为成员变量。在不考虑private成员不能被其外部函数访问的情况下，通过一个指向链表节点的Iterator对象iterator，访问到链表节点数据域data表示的Time类型对象的表达式为： (*(iterator.p).data; C+程序设计实例教程程序设计实例教程6.15 重载重载“

24、-”运算符运算符 在C+语言中，圆点运算符“.”用于自定义类型对象名对该对象成员的访问，箭头运算符“-”用于对象指针（地址）对该对象成员的访问，例如：Time t;Time *p=&t;t.set_hour(10);p-set_minute(10);(&t)-set_second(10);C+程序设计实例教程程序设计实例教程 为自定义类型重载箭头运算符“-”必须使用该类型的成员函数。箭头运算符“-”看起来像二元运算符，左操作数是对象的指针（地址），右操作数是对象的成员（成员变量或成员函数）。但实际上，为自定义类型重载箭头运算符“-”要把该运算符当作一元运算符来重载，即运算符函数

25、的调用者是其唯一的操作数，并且出现在运算符的左侧。为自定义类型重载箭头运算符“-”是为了让该类型对象的行为像另外一个类型的指针，所以，在为自定义类型重载箭头运算符“-”时，使用没有参数的成员函数（一元运算符），返回值是其要模仿的指针就可以了。 C+程序设计实例教程程序设计实例教程6.16 重载“-*”运算符 运算符“.*”和“-*”是C+语言中很少被用到的二元运算符。它们有什么作用呢？ 运算符“.*”是二元运算符，左操作数是某个自定义类型的对象，右操作数是指向该类型非static成员函数的指针，该操作返回了对象与非static成员函数组合的函数调用。运算符“-*”与“.*”不同的是，运算符“-

26、*”的左操作数是自定义类型的对象的指针（地址）。运算符“.*”和“-*”是将调用者（对象）与成员函数指针组合在一起调用成员函数的运算符。 程序6.9利用程序6.8中的Time类型，演示了非static成员函数指针的使用。 C+程序设计实例教程程序设计实例教程1 /6.9 运算符运算符“.*”和和“-*”的使用的使用6 void reference_set(Time& t,int value,void (Time:*f)(int) 7 (t.*f)(value); 9 10 void pointer_set(Time* tp,int value,void (Time:*f)(int)11

27、 12 (tp-*f)(value);13 15 void print_list(const TimeList& L,const char* const str)16 17 coutstrendl;18 for(TimeList:Iterator p=L.begin();p!=L.end();+p)19 20 cout*pendl;21 22 cout-endl;23 25 int main()26 C+程序设计实例教程程序设计实例教程27 Time t1(1,2,3);28 Time t2(4,5,6);29 Time t3(7,8,9);30 TimeList L;31 L.ins

28、ert(L.begin(),t1);32 L.insert(L.begin(),t2);33 L.insert(L.begin(),t3);35 void (Time:*p)(int)=Time:set_hour;37 cout原始的原始的t1和和t2：nt1endlt2*p)(0);40 cout修改后的修改后的t1和和t2：nt1endlt2()-*p)(0);47 print_list(L,将前面的两个将前面的两个Time对象的小时设为对象的小时设为0之后：之后：);49 reference_set(t1,11,Time:set_hour);50 reference_set(t1,12,

29、Time:set_minute);51 reference_set(t1,13,Time:set_second);52 cout使用使用t1做参数调用做参数调用reference_set之后：之后：nt1endl; C+程序设计实例教程程序设计实例教程54 pointer_set(&t1,21,Time:set_hour);55 pointer_set(&t1,22,Time:set_minute);56 pointer_set(&t1,23,Time:set_second);57 cout使用使用t1的地址做参数调用的地址做参数调用pointer_set之后：之后：n

30、t1(),21,Time:set_hour);70 pointer_set(iterator.operator -(),22,Time:set_minute);71 pointer_set(iterator.operator -(),23,Time:set_second);72 73 print_list(L,链表的每一个元素调用链表的每一个元素调用pointer_set之后：之后：);75 return 0;76 显示结果：显示结果：原始的原始的t1和和t2：1：2：34：5：6修改后的修改后的t1和和t2：0：2：30：5：6原始的链表原始的链表7：8：94：5：61：2：3-将前面的两个

31、将前面的两个Time对象的小时设为对象的小时设为0之后：之后：0：8：90：5：61：2：3-使用使用t1做参数调用做参数调用reference_set之后：之后：11：12：13使用使用t1的地址做参数调用的地址做参数调用pointer_set之后：之后：21：22：23链表的每一个元素调用链表的每一个元素调用reference_set之后：之后：11：12：1311：12：1311：12：13-链表的每一个元素调用链表的每一个元素调用pointer_set之后：之后：21：22：2321：22：2321：22：23-C+程序设计实例教程程序设计实例教程程序6.10为程序6.8的Iterat

32、or类型补充运算符“-*”的重载，对其做了简单的测试。1 /6.10 重载运算符重载运算符“-*” 2 /将下面代码补充到程序将下面代码补充到程序6.8的第的第107行之后行之后 3 class FunctionObject 4 public: 6 FunctionObject(Time* tp1,void (Time:* fp1)(int) 7 :tp(tp1),fp(fp1) 8 9 void operator()(int n)const10 11 (tp-*fp)(n);12 13 private:14 Time* tp;15 void (Time:* fp)(int);16 ;17 F

33、unctionObject operator-*(void (Time:* fp1)(int) const18 19 return FunctionObject(operator-(),fp1);20 21 /-22 /test.cpp23 #includeTimeList.h24 using std:cout;25 using std:endl; C+程序设计实例教程程序设计实例教程27 void iterator_set(const TimeList:Iterator& iterator,int value,void (Time:*f)(int)28 (iterator-*f)(v

34、alue);30 32 void print_list(const TimeList& L,const char* const str)33 coutstrendl;35 for(TimeList:Iterator p=L.begin();p!=L.end();+p)36 37 cout*pendl;38 39 cout-*p)(0);57 print_list(L,将首个Time对象的小时设为0之后：);58 59 for(iterator=L.begin();iterator!=L.end();+iterator)60 61 iterator_set(iterator,21,Tim

35、e:set_hour);62 iterator_set(iterator,22,Time:set_minute);63 iterator_set(iterator,23,Time:set_second);64 65 print_list(L,链表的每一个元素调用iterator_set之后：);66 67 return 0;68 显式结果：显式结果：原始的链表原始的链表7：8：94：5：61：2：3-将首个将首个Time对象的小时设为对象的小时设为0之后：之后：0：8：94：5：61：2：3-链表的每一个元素调用链表的每一个元素调用iterator_set之后：之后：21：22：2321：22

36、：2321：22：23-C+程序设计实例教程程序设计实例教程6.17 重载全局new、new 和delete、delete 运算符 在C+语言中，全局的运算符new、new 和delete、delete 负责动态内存的分配和释放，在默认情况下，利用new、delete表达式，为基础数据类型和自定义类型分配或释放动态内存，都使用系统提供的运算符。 C+语言允许用户重载全局的new、new 和delete、delete 运算符。当程序中重载了这些全局运算符时，程序中的new、delete表达式使用用户提供的运算符重载函数来为基础数据类型和自定义类型分配或释放动态内存，而不使用系统提供的版本。 程序

37、6.11演示了对全局运算符new、new 和delete、delete 的重载。C+程序设计实例教程程序设计实例教程1 /6.11 重载全局重载全局new、new 和和delete、delete 运算符运算符 2 #includestdio.h5 void* operator new(size_t n) 6 void* p=malloc(n); 8 printf(new：从：从%x开始开始%d个字节的内存被分配个字节的内存被分配n,p,n); 9 return p;10 11 void* operator new (size_t n)12 void* p=malloc(n);14 printf

38、(new ：从：从%x开始开始%d个字节的内存被分配个字节的内存被分配n,p,n);15 return p;16 17 void operator delete (void* p)18 free(p);20 printf(delete：从：从%x开始的内存被释放开始的内存被释放n,p);21 22 void operator delete (void* p)23 free(p);25 printf(delete ：从：从%x开始的内存被释放开始的内存被释放n,p);26 28 class Point29 0 public:31 double x,y;32 Point()33 C+程序设计实例教

39、程程序设计实例教程34 printf(1个个Point对象被创建对象被创建n);35 36 Point()37 38 printf(1个个Point对象被释放对象被释放n);39 40 ;43 int main()44 int *ip=new int;46 printf(ip=%xn,ip);47 delete ip;48 printf(-n);49 ip=new int10;50 printf(ip=%xn,ip);51 delete ip;52 printf(-n);54 Point *pp=new Point;55 printf(pp=%xn,pp);56 delete pp;57 pr

40、intf(-n);58 pp=new Point3;59 printf(pp=%xn,pp);60 delete pp;61 printf(-n);63 return 0;64 显式结果：显式结果：new：从：从430070开始开始4个字节的内存被分配个字节的内存被分配ip=430070delete：从：从430070开始的内存被释放开始的内存被释放-new ：从：从430040开始开始40个字节的内存被分配个字节的内存被分配ip=430040delete ：从：从430040开始的内存被释放开始的内存被释放-new：从：从430060开始开始16个字节的内存被分配个字节的内存被分配1个个Po

41、int对象被创建对象被创建pp=4300601个个Point对象被释放对象被释放delete：从：从430060开始的内存被释放开始的内存被释放-new ：从：从430040开始开始52个字节的内存被分配个字节的内存被分配1个个Point对象被创建对象被创建1个个Point对象被创建对象被创建1个个Point对象被创建对象被创建pp=4300441个个Point对象被释放对象被释放1个个Point对象被释放对象被释放1个个Point对象被释放对象被释放delete ：从：从430040开始的内存被释放开始的内存被释放-C+程序设计实例教程程序设计实例教程6.18 为自定义类型重载new、new

42、 和delete、delete 运算符 C+语言除了允许重载全局的new、new 和delete、delete 运算符以外，还允许自定义类型使用其成员函数重载这些运算符。使用自定义类型的成员函数重载这些运算符后，该类型使用这些运算符对应的表达式创建或释放对象时，默认使用自定义版本的运算符，而不是使用全局版本的运算符。由于创建或释放对象与对象的成员变量无关，所以，为自定义类型重载new、new 和delete、delete 运算符要使用该类的static成员函数，即使不显式的使用static关键字，重载的函数仍然被编译器视为该类的static成员。 程序6.12为自定义类型Point重载了new

43、、new 和delete、delete 运算符。 C+程序设计实例教程程序设计实例教程1 /6.12 成员函数重载成员函数重载new、new 和和delete、delete 运算符运算符 2 #includestdio.h 3 #includemalloc.h5 class Point 6 public: 8 double x,y; 9 Point()10 11 printf(1个个Point对象被创建对象被创建n);12 13 Point()14 15 printf(1个个Point对象被释放对象被释放n);16 17 void* operator new(size_t n)18 19 vo

44、id* p=malloc(n);20 printf(new：从：从%x开始开始%d个字节的内存被分配个字节的内存被分配n,p,n);21 return p;22 23 void* operator new (size_t n)24 C+程序设计实例教程程序设计实例教程25 void* p=malloc(n);26 printf(new ：从：从%x开始开始%d个字节的内存被分配个字节的内存被分配n,p,n);27 return p;28 29 void operator delete (void* p)30 free(p);32 printf(delete：从：从%x开始的内存被释放开始的内存

45、被释放n,p);33 34 void operator delete (void* p)35 free(p);37 printf(delete ：从：从%x开始的内存被释放开始的内存被释放n,p);38 39 ;40 41 42 int main()43 44 int *ip=new int;45 printf(ip=%xn,ip);46 delete ip;47 printf(-n);48 ip=new int10;C+程序设计实例教程程序设计实例教程49 printf(ip=%xn,ip);50 delete ip;51 printf(-n);53 Point *pp=new Point;54 printf(pp=%xn,pp);55 delete pp;56 printf(-n);57 pp=new Point3;58 printf(pp=%xn,pp);59 delete pp;60 printf(-n);61 62 pp=:new Point;63 printf(pp=%xn,pp);64 :delete pp;65 printf(-n);66 pp=:new Point3;67 printf(pp=%xn,pp);68 :delete pp;69 printf(-n);71 r