4.1什么是運算符重載 C++為程序員供應(yīng)了敏捷的手段，讓程序員自己定義類，自己設(shè)計相應(yīng)的運算符（必需在已有的運算符基礎(chǔ)上設(shè)計），使之應(yīng)用于自己定義的類。與函數(shù)重載類似，對已有的運算符賜予新的含義，用一個運算符表示不同功能的運算，這就是運算符重載。 事實上，我們在此之前已經(jīng)運用了運算符重載。如<<是C++的移位運算符，它又與流對象cout協(xié)作作為流插入運算符，這是C++對<<進行了重載處理。運算符重載的實質(zhì)運算符重載是對已有的運算符賜予多重含義。必要性C++中預(yù)定義的運算符其運算對象只能是基本數(shù)據(jù)類型，而不適用于用戶自定義類型（如類）實現(xiàn)機制將指定的運算表達式轉(zhuǎn)化為對運算符函數(shù)的調(diào)用，運算對象轉(zhuǎn)化為運算符函數(shù)的實參。編譯系統(tǒng)對重載運算符的選擇，遵循函數(shù)重載的選擇原則。 例4.1通過成員函數(shù)實現(xiàn)復(fù)數(shù)的加法。

classComplex {private: doublereal; doubleimag;public:

Complex(){real=0;imag=0;} Complex(doubler,doublei){real=r;imag=i;}

Complexcomplex_add(Complex&c2); voiddisplay(); }; ComplexComplex::complex_add(Complex&c2) {Complexc; c.real=real+c2.real;c.imag=imag+c2.image;returnc;}

voidComplex::display() {cout<<"("<<real<<","<<imag<<"i)"<<endl;} intmain() {Complexc1(3,4),c2(5,-10),c3; c3=c1plex_add(c2); cout<<"c1=";c1.display(); cout<<"c2=";c2.display(); cout<<"c1+c2=";c3.display(); return0; } 在Complex類中定義了complex_add函數(shù)做加法，函數(shù)的參數(shù)是引用對象，作為一個加數(shù)。在函數(shù)里定義了臨時對象c，兩個賦值語句相當(dāng)于：

c.real=this->real+c2.real;c.imag=this->imag+c2.imag;

在main函數(shù)中通過對象c1調(diào)用加法函數(shù)，上面的語句相當(dāng)于：

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

能否用+運算符實現(xiàn)復(fù)數(shù)加法？4.2運算符重載的方法 運算符重載的方法是定義一個重載運算符函數(shù)，在須要時系統(tǒng)自動調(diào)用該函數(shù)，完成相應(yīng)的運算。運算符重載實質(zhì)上是函數(shù)的重載。運算符重載函數(shù)的格式是： 數(shù)據(jù)類型operator運算符(形參表) {重載處理} 數(shù)據(jù)類型：是重載函數(shù)值的數(shù)據(jù)類型。 operator是保留字 規(guī)則和限制C++中可以重載除下列運算符外的全部運算符：

..*::?:sizeof()只能重載C++語言中已有的運算符，不行臆造新的。不變更原運算符的優(yōu)先級和結(jié)合性。不能變更操作數(shù)個數(shù)。經(jīng)重載的運算符，其操作數(shù)中至少應(yīng)當(dāng)有一個是自定義類型。兩種形式重載為類成員函數(shù)。重載為友元函數(shù)。運算符函數(shù)聲明形式函數(shù)類型operator運算符（形參）{......}重載為類成員函數(shù)時

參數(shù)個數(shù)=原操作數(shù)個數(shù)-1 （后置++、--除外）重載為友元函數(shù)時參數(shù)個數(shù)=原操作數(shù)個數(shù)，且至少應(yīng)當(dāng)有一個自定義類型的形參。 不能重載的運算符只有5個：

.

成員運算符

.*

成員指針運算符

::

域運算符

sizeof長度運算符

?:

條件運算符 重載函數(shù)名是由operator和運算符聯(lián)合組成。 復(fù)數(shù)加法運算符重載函數(shù)原型可以是：

Complexoperator+(Complex&c2);

例4.2重載運算符+，用于兩個復(fù)數(shù)相加。 分析：定義一個復(fù)數(shù)類，用成員函數(shù)實現(xiàn)加號的重載函數(shù)。兩個復(fù)數(shù)相加結(jié)果仍是復(fù)數(shù)，所以函數(shù)的返回值的類型也是復(fù)數(shù)類。用成員函數(shù)實現(xiàn)運算符重載函數(shù)時，調(diào)用格式是“對象名.成員名”，此時對象就是一個參與運算的操作數(shù)，加法還須要另一個操作數(shù)，這個操作數(shù)用函數(shù)的參數(shù)傳遞，參數(shù)的類型就是復(fù)數(shù)類。而運算結(jié)果用函數(shù)值返回。

classComplex {public: Complex(){real=0;imag=0;} Complex(doubler,doublei){real=r;imag=i;}

Complexoperator+(Complex&c2); voiddisplay(); private: doublereal; doubleimag; };

ComplexComplex::operator+(Complex&c2) { Complexc; c.real=real+c2.real; c.imag=imag+c2.imag; returnc; }

voidComplex::display() { cout<<"("<<real<<","<<imag<<"i)"<<endl;}

intmain() {Complexc1(3,4),c2(5,-10),c3;

c3=c1+c2; cout<<"c1=";c1.display(); cout<<"c2=";c2.display(); cout<<"c1+c2=";c3.display(); return0; } 說明： （1）用運算符重載函數(shù)取代了例4.1中的加法成員函數(shù)，從外觀上看函數(shù)體和函數(shù)返回值都是相同的。 （2）在主函數(shù)中的表達式c3=c2+c1取代了例4.1中的c3=c1plex_add(c2)，編譯系統(tǒng)將表達式c3=c1+c2說明為 c1.operator+(c2) 對象c1調(diào)用的重載函數(shù)operator+，以c2為實參計算兩個復(fù)數(shù)之和。 請考慮在例4.2中能否用一個常量和一個復(fù)數(shù)相加？如 c3=3+c2;//錯誤 應(yīng)當(dāng)定義對象：ComplexC1(3.0,0)： c3=C1+c2; 留意：運算符重載后，其原來的功能仍舊保留，編譯系統(tǒng)依據(jù)運算表達式的上下文確定是否調(diào)用運算符重載函數(shù)。 運算符重載和類結(jié)合起來，可以在C++中定義運用便利的新數(shù)據(jù)類型。4.3重載運算符的規(guī)則 （1）C++只允許已有的部分運算符實施重載。 （2）不能重載的運算符有五個。 （3）重載不變更操作數(shù)的個數(shù)。 （4）重載不變更運算符的優(yōu)先級。 （5）運算符重載函數(shù)不能帶默認(rèn)值參數(shù)。 （6）運算符重載函數(shù)必需與自定義類型的對象聯(lián)合運用，其參數(shù)至少有一個類對象或類對象引用。 （7）C++默認(rèn)供應(yīng)=和&運算符重載。（8）運算符重載函數(shù)可以是類成員函數(shù)也可以是類的友元函數(shù)，還可以是一般函數(shù)。（9）C++規(guī)定賦值運算符、下標(biāo)運算符、函數(shù)調(diào)用運算符必需定義為類的成員函數(shù)；而輸出流插入、輸入流提取、類型轉(zhuǎn)換運算符不能定義為類的成員函數(shù)。4.4運算符重載函數(shù)作為類成員函數(shù)和友元函數(shù) 在例4.2程序中對運算符+進行了重載，該例將運算符重載函數(shù)定義為復(fù)數(shù)類的成員函數(shù)。 從該程序中看到運算符重載為成員函數(shù)時，帶一個類類型的形參，而另一個加數(shù)就是對象自己。 例4.3將加法運算符重載為適用于復(fù)數(shù)加法，重載函數(shù)作為類的友元函數(shù)。#include<iostream.h>

classComplex {public:

Complex(){real=0;imag=0;}

Complex(doubler){real=r;imag=0;}

Complex

(doubler,doublei){real=r;imag=i;}

friendComplexoperator+(Complex&c1,Complex&c2); voiddisplay(); private: doublereal; doubleimag; };

Complexoperator+(Complex&c1,Complex&c2) {returnComplex(c1.real+c2.real,c1.imag+c2.imag);}

//顯式調(diào)用構(gòu)造函數(shù)

voidComplex::display() {cout<<"("<<real<<","<<imag<<"i)"<<endl;}

intmain() {Complexc1(3,4),c2(5,-10),c3; c3=c1+c2; cout<<"c1=";c1.display(); cout<<"c2=";c2.display(); cout<<"c1+c2=";c3.display(); return0; } 加法運算符重載為友元函數(shù)，C++在編譯時將表達式c1+c2說明為 operator+(c1,c2) 即相當(dāng)于執(zhí)行以下函數(shù) Complexoperator+(Complex&c1,Complex&c2) {returnComplex(c1.real+c2.real,c1.imag+c2.imag); } 因為一般函數(shù)是不能干脆訪問對象的私有成員，假如一般函數(shù)必需訪問對象的私有成員，可調(diào)用類的公有成員函數(shù)訪問對象的私有成員。這會降低效率。書上的錯誤 如想將一個復(fù)數(shù)和一個整數(shù)相加，運算符重載函數(shù)作為成員函數(shù)定義如下： ComplexComplex::operator+(int&i) {returnComplex(real+i,imag); } 留意在運算符+的左側(cè)必需是Complex類對象，程序中可以寫成： c3=c2+n 不能寫成： c3=n+c2書上的錯誤 假如要求在運用重載運算符時，運算符左側(cè)操作數(shù)不是對象，就不能運用前面定義的運算符重載函數(shù)，可以將運算符重載函數(shù)定義為友元函數(shù)： friendComplexoperator+(int&i,Complex&c) {returnComplex(c.real+i,c.imag); } 友元函數(shù)不要求第一個參數(shù)必需是類類型，但是要求實參要與形參一一對應(yīng)： c3=n+c2//依次正確 c3=c2+n//依次錯誤 為了實現(xiàn)加法的交換率，必需定義兩個運算符重載函數(shù)，記住成員函數(shù)要求運算符左側(cè)的操作數(shù)必需是自定義類型的對象，而友元函數(shù)沒有這個限制，可以用下面兩個組合中隨意一個： （1）成員函數(shù)（左操作數(shù)是對象，右操作數(shù)是非對象）、友元函數(shù)（左操作數(shù)是非對象，右操作數(shù)是對象） （2）友元函數(shù)（左操作數(shù)是對象，右操作數(shù)是非對象）、友元函數(shù)（左操作數(shù)是非對象，右操作數(shù)是對象） 由于運用友元會破壞類的封裝，要盡量將運算符重載函數(shù)定義為成員函數(shù)。但考慮到各方面的因素，一般將單目運算符重載為成員函數(shù)，將雙目運算符重載為友元函數(shù)。 VC++6.0的不帶后綴h的頭文件不支持把成員函數(shù)重載為友元函數(shù)。但VC++6.0帶后綴h的頭文件支持這項功能，所以要將程序中的語句： #include<iostream> usingnamespacestd; 改成： #include<iostream.h> 即可正常運行。4.5重載雙目運算符雙目的意思是運算符左邊和右邊的操作數(shù)均參與運算。假如要重載B為類成員函數(shù)，使之能夠?qū)崿F(xiàn)表達式oprd1Boprd2，其中oprd1為A類對象，則B應(yīng)被重載為A類的成員函數(shù)，形參類型應(yīng)當(dāng)是oprd2所屬的類型。經(jīng)重載后，表達式oprd1Boprd2相當(dāng)于oprd1.operatorB(oprd2)。例4.4定義一個字符串類String，用來處理不定長的字符串，重載相等、大于、小于關(guān)系運算符，用于兩個字符串的等于、大于、小于的比較運算。操作數(shù):兩個操作數(shù)都是字符串類的對象。規(guī)則:兩個字符串進行比較。將“<”、“=”、“>”運算重載為字符串類的成員函數(shù)。 （1）先建立一個String類

#include<iostream.h> #include<string.h> classString//String是用戶自己指定的類名

{public: String(){p=NULL;} String(char*str); voiddisplay(); private: char*p; };

String::String(char*str) {p=str;} voidString::display() {cout<<p;} intmain() {Stringstring1("Hello"),string2("Book"); string1.display(); cout<<endl; string2.display(); return0; } 先編寫出簡潔的程序框架，編寫和調(diào)試都比較便利。構(gòu)造函數(shù)是把定義對象時的實參的地址賜予數(shù)據(jù)成員p，p是指向?qū)崊⒌闹羔?。程序?qū)崿F(xiàn)了建立對象、輸出字符串對象的功能。程序運行結(jié)果分別輸出 Hello Book （2）有了這個基礎(chǔ)后，再增加所需的其他內(nèi)容，先重載大于運算符。程序如下：

//本程序適用于VC++6.0 #include<iostream.h> #include<string.h> classString {public: String(){p=NULL;} String(char*str); voiddisplay();

friendbooloperator>(String&string1,String&string2);

private: char*p; }; String::String(char*str) {p=str;}

voidString::display() {cout<<p;}

booloperator>(String&string1,String&string2) {if(strcmp(string1.p,string2.p)>0) returntrue; elsereturnfalse; }

intmain() {Stringstring1("Hello"),string2("Book"); cout<<(string1>string2)<<endl; return0; } 運算符重載函數(shù)定義為友元函數(shù)，函數(shù)值是布爾類型，在函數(shù)中調(diào)用了strcmp庫函數(shù)，string1.p指向“Hello”，string2.p指向“Book”，程序運行結(jié)果是1。 （3）擴展到對三個運算符重載 在String類體中聲明三個重載函數(shù)是友元函數(shù)，并編寫相應(yīng)的函數(shù)。

//本程序適用于VC++6.0 #include<iostream.h> #include<string.h> classString {public: String(){p=NULL;} String(char*str);

friendbooloperator>(String&string1,String&string2); friendbooloperator<(String&string1,String&string2); friendbooloperator==(String&string1,String&string2); voiddisplay();

private: char*p; };

String::String(char*str) {p=str;} voidString::display() {cout<<p;} booloperator>(String&string1,String&string2) {if(strcmp(string1.p,string2.p)>0) returntrue; else returnfalse; }

booloperator<(String&string1,String&string2) {if(strcmp(string1.p,string2.p)<0) returntrue; else returnfalse; } booloperator==(String&string1,String&string2) {if(strcmp(string1.p,string2.p)==0) returntrue; else returnfalse; }

intmain() {Stringstring1("Hello"),string2("Book"),string3("Computer"); cout<<(string1>string2)<<endl; cout<<(string1<string3)<<endl; cout<<(string1==string2)<<endl; return0; }

運行結(jié)果為

1 0 04.6重載單目運算符 單目運行符只要一個操作數(shù)，由于只有一個操作數(shù)，重載函數(shù)最多只有一個參數(shù)，假如將運算符重載函數(shù)定義為成員函數(shù)還可以不用參數(shù)。 下面以自增運算符++為例，學(xué)習(xí)單目運算符的重載函數(shù)的編寫方法。 例4.5有一個Time類，數(shù)據(jù)成員有時、分、秒。要求模擬秒表，每次走一秒，滿60秒進位，秒又從零起先計數(shù)。滿60分進位，分又從零起先計數(shù)。輸出時、分和秒的值。

#include<iostream> usingnamespacestd; classTime {public: Time(){hour=0;minute=0;sec=0;} Time(inth,intm,ints):hour(h),minute(m),sec(s){} Timeoperator++(); voiddisplay(){cout<<hour<<":"<<minute<<":"<<sec<<endl;} private: inthour; intminute; intsec; };TimeTime::operator++() //前置單目運算符重載函數(shù){ sec++; if(sec>=60) {sec=sec-60; minute++; if(minute>=60) { minute=minute-60; hour++; hour=hour%24; } }return*this;}42

intmain() {Timetime1(23,59,0); for(inti=0;i<61;i++) {++time1; time1.display();} return0; }

C++中除了有前++外，還有后++。同樣的運算符由于操作數(shù)的位置不同，含義也不同。怎樣區(qū)分前++和后++？C++給了一個方法，在自增或自減運算符重載函數(shù)中，增加一個int形參。程序員可以選擇帶int形參的函數(shù)做后++，也可以選擇不帶int形參的函數(shù)做前++。 例4.6在例4.5的基礎(chǔ)上增加后++運算符重載函數(shù)。

#include<iostream> usingnamespacestd; classTime {public: Time(){hour=0;minute=0;sec=0;} Time(inth,intm,ints):hour(h),minute(m),sec(s){}

Timeoperator++();

Timeoperator++(int);voiddisplay(){cout<<hour<<":"<<minute<<":"<<sec<<endl;} private: inthour;intminute; intsec; };TimeTime::operator++() //前置單目運算符重載函數(shù){ sec++; if(sec>=60) {sec=sec-60; minute++; if(minute>=60) { minute=minute-60; hour++; hour=hour%24; } }return*this;}46 分析：后++運算的含義是操作數(shù)先參與其他運算后再自加。如 m=n++ 先將n的值賜予m，然后n再自加1。設(shè)計后++重載函數(shù)要遵循這個特性。 TimeTime::operator++(int) {Timetemp(*this);//保存修改前的對象做返回值 ++(*this); returntemp; }

intmain() {Timetime1(21,34,59),time2; cout<<"time1:"; time1.display(); ++time1; cout<<"++time1:"; time1.display(); time2=time1++; cout<<"time1++:"; time1.display(); cout<<"time2:"; time2.display(); return0; }程序運行結(jié)果如下：Time1:21:34:59++Time1:21:35:0Time1++:21:35:1Time2:21:35:04.7重載流插入運算符和流提取運算符 cin和cout分別是istream類和ostream類的對象。C++已經(jīng)對>>和<<移位運算符進行了重載，使它們分別成為流提取運算符和流插入運算符。用來輸入或輸出C++的標(biāo)準(zhǔn)類型數(shù)據(jù)，所以要用#include<iostream>usingnamespacestd;把頭文件包含到程序中。 用戶自定義類型的數(shù)據(jù)不能干脆用<<和>>輸出和輸入，如想用它們進行輸入或輸出，程序員必需對它們重載。 重載函數(shù)原型的格式如下：

istream&operator>>(istream&,自定義類&); ostream&operator<<(ostream&,自定義類&);

從格式上看，>>重載函數(shù)和<<重載函數(shù)只能定義為友元函數(shù)，不能定義為成員函數(shù)，因為函數(shù)有兩個形參，并且第一個形參不是自定義類型。4.7.1重載流插入運算符“<<” 例4.7在例4.2的基礎(chǔ)上用<<重載函數(shù)輸出復(fù)數(shù)。 分析：在類中聲明<<重載函數(shù)是友元函數(shù)

friendostream&operator<<(ostream&,Complex&);

在類外定義友元函數(shù)：

ostream&operator<<(ostream&output,Complex&c) {output<<"("<<c.real<<"+"<<c.imag<<"i)"<<endl; returnoutput; }

//本程序適用于VC++6.0 #include<iostream.h> intmain() {Complexc1(2,4),c2(6,10),c3; c3=c1+c2; cout<<c3; return0; } 分析C++怎樣處理”cout<<c3;”語句 運算符的左邊是ostream的對象cout，右邊是程序員自定義類complex的對象c3，語句符合運算符重載友元函數(shù)operator<<的形參類型要求，系統(tǒng)調(diào)用友元函數(shù)，C++把這個語句說明為： operator<<(cout,c3); 通過形參引用傳遞，函數(shù)中的output就是cout，函數(shù)中的c就是c3，函數(shù)就變成： { cout<<"("<<c3.real<<"+"<<c3.imag<<"i)"<<endl;returncout; } returncout是將輸出流現(xiàn)狀返回。C++規(guī)定運算符<<重載函數(shù)第一個參數(shù)和函數(shù)的類型必需是ostream類型的引用，目的是為了返回cout的當(dāng)前值，以便連續(xù)輸出。4.7.2重載流提取運算符“>>” 例4.8在例4.7的基礎(chǔ)上增加流提取運算符>>重載函數(shù)，用cin>>輸入復(fù)數(shù)，用cout<<輸出復(fù)數(shù)。 在類中聲明友元函數(shù)：

friendistream&operator>>(istream&,Complex&);

在類外定義函數(shù)：

istream&operator>>(istream&input,Complex&c) {cout<<"請輸入復(fù)數(shù)的實部和虛部:"; input>>c.real>>c.imag; returninput; } intmain() {Complexc1,c2;

cin>>c1>>c2; cout<<"c1="<<c1<<endl; cout<<"c2="<<c2<<endl; return0; }

運算符>>重載函數(shù)中的形參input是istream類對象引用，在執(zhí)行cin>>c1時，調(diào)用operator>>函數(shù)，將cin引用傳遞給input，input是cin的別名，同樣c是c1的別名。因此，input>>c.real>>c.imag;相當(dāng)于cin>>c1.real>>c1.imag。函數(shù)返回cin的新值。使程序可以用重載函數(shù)連續(xù)從輸入流提取數(shù)據(jù)給complex類對象。 程序邏輯上是正確的，但還有缺陷，假如輸入的虛部是負(fù)數(shù)時，輸出的形式變成： c2=(4+-10i) 在負(fù)數(shù)前多個正號?？梢詫Τ绦蛏宰鲂薷模簅stream&operator<<(ostream&output,Complex&c) {output<<"("<<c.real; if(c.imag>=0)output<<"+"; output<<c.imag<<"i)"<<endl; returnoutput; } 從本章例子中可以留意到，在運算符重載中運用引用參數(shù)的重要性，用引用形參在調(diào)用函數(shù)時，通過傳遞地址方式讓形參成為實參的別名，不用生成臨時變量，削減了時間和空間的開銷。此外，如重載函數(shù)的返回值是對象引用時，返回的是對象，它可以出現(xiàn)在賦值號的左側(cè)而成為左值，可以被賦值或參與其他操作（如保留cout流的當(dāng)前值以便能連續(xù)運用<<輸出）。4.8.1標(biāo)準(zhǔn)類型數(shù)據(jù)間的轉(zhuǎn)換inti=6;i=7.5+i；編譯過程：7.5作為double型數(shù)處理求解表達式時，將6轉(zhuǎn)換陳double，然后再和7.5相加得到的13.5的值向整型變量i賦值時，先轉(zhuǎn)換為13再賦值這種轉(zhuǎn)換是c++編譯系統(tǒng)自動完成的，稱為隱式類型轉(zhuǎn)換。C++的顯式類型轉(zhuǎn)換，是一種人為的強制轉(zhuǎn)換。格式：類型名（數(shù)據(jù)）例如：int（89.5）C語言中的接受形式（類型名）數(shù)據(jù)如：（int）89.5C++保留了c語言的用法，提倡用c++的方法4.8.2用轉(zhuǎn)換構(gòu)造函數(shù)進行類型轉(zhuǎn)換作用：將一個其它類型的數(shù)據(jù)轉(zhuǎn)換成一個指定的類的對象。轉(zhuǎn)換構(gòu)造函數(shù)只有一個形參，如Complex（doubler）{real=r；imag=0；} 其作用就是將double型的參數(shù)r轉(zhuǎn)換成Complex類的對象Complexc1（3.5）；//建立一個對象，調(diào)用構(gòu)造函數(shù) 可以用聲明語句建立一個無名的Complex對象，如 Complex（3.6）//合法，但無法運用 可以在一個表達式中運用無名對象，如 c1=complex（3.6）；//假設(shè)c1已被定義為Complex類的對象轉(zhuǎn)換構(gòu)造函數(shù)也是一種構(gòu)造函數(shù)，它遵循構(gòu)造函數(shù)的一般規(guī)則。通常把有一個參數(shù)的構(gòu)造函數(shù)用作類型轉(zhuǎn)換，所以，稱為轉(zhuǎn)換構(gòu)造函數(shù)。留意： 轉(zhuǎn)換構(gòu)造函數(shù)只能有一個參數(shù)。假如有多個參數(shù)，就不是轉(zhuǎn)換構(gòu)造函數(shù)。緣由是：假如有多個參數(shù)的話，原委是把哪個參數(shù)轉(zhuǎn)換成類的對象呢運用轉(zhuǎn)換構(gòu)造函數(shù)將一個指定的數(shù)據(jù)轉(zhuǎn)換成類的對象的方法如下：（1）先聲明一個類（如上面的Complex）。（2）在這個類中定義一個只有一個參數(shù)的構(gòu)造函數(shù)，參數(shù)的類型是須要轉(zhuǎn)換的類型，在函數(shù)體中指定轉(zhuǎn)換的方法。（3）在該類的作用域內(nèi)可以用以下形式進行類型轉(zhuǎn)換： 類名（指定類型的數(shù)據(jù)） 不僅可以將一個標(biāo)準(zhǔn)類型數(shù)據(jù)轉(zhuǎn)換成類對象，也可以將另一個類的對象轉(zhuǎn)換成轉(zhuǎn)換構(gòu)造函數(shù)所在類的對象。 如：可以將一個學(xué)生類對象轉(zhuǎn)換成老師類對象，可以在Teacher類中寫出下面的構(gòu)造函數(shù)： Teacher(Student&s){num=s.num;strcpy(name,);sex=s.sex;} 留意： 對象s中的num,name,sex必需是公有成員，否則不能被類外引用。4.8.3用類型轉(zhuǎn)換函數(shù)進行類型轉(zhuǎn)換作用：將一個類的對象轉(zhuǎn)換成另一個類型的數(shù)據(jù)格式： operator類型名（）{實現(xiàn)轉(zhuǎn)換的語句} 在函數(shù)名前面不能指定函數(shù)類型，函數(shù)沒有參數(shù) 返回值的類型是由函數(shù)名中指定的類型名來確定的。類型轉(zhuǎn)換函數(shù)只能作為成員函數(shù)，因為轉(zhuǎn)換的主體是本類的對象。不能作為友元函數(shù)或一般函數(shù)。轉(zhuǎn)換構(gòu)造函數(shù)和類型轉(zhuǎn)換運算符的共同功能：當(dāng)須要的時候，編譯系統(tǒng)會自動調(diào)用這些函數(shù)，建立一個無名的臨時對象（或臨時變量）例：doubled1,d2;Complexc1,c2; 假設(shè)類中定義了類型轉(zhuǎn)換函數(shù) 對于表達式：d1=d2+c1； 編譯系統(tǒng)發(fā)覺“+”左側(cè)的d2是double型，而右側(cè)的c1是Complex類對象，假如沒有對運算符“+”進行重載，就會檢查有無類型轉(zhuǎn)換函數(shù)，結(jié)果發(fā)覺有對double的重載函數(shù)，就調(diào)用該函數(shù)，把Complex類對象c1轉(zhuǎn)換為double型數(shù)據(jù)，建立一個臨時的double變量，并與d2相加，最終將一個double型數(shù)據(jù)賦給d1。假如類中已定義轉(zhuǎn)換構(gòu)造函數(shù)并重載了運算符“+”（作為Complex類的友元函數(shù)），但未對double定義類型轉(zhuǎn)換函數(shù)（或者說未對double重載）對于表達式： c2=c1+d2； 編譯系統(tǒng)怎樣處理呢？它發(fā)覺運算符“+”左側(cè)的c1是Complex類對象，右側(cè)的d2是double型。編譯系統(tǒng)找尋有無對“+”的重載，發(fā)覺有operator+函數(shù)，但它是Complex類的友元函數(shù)，要求兩個Complex類的形參，即只能實現(xiàn)兩個Complex類對象相加，而現(xiàn)在d2是double型，不合要求。在類中沒有對double進行重載，因此不行能把c1轉(zhuǎn)換為double型數(shù)據(jù)然后相加。編譯系統(tǒng)就去找有無轉(zhuǎn)換構(gòu)造函數(shù)，發(fā)覺有，就調(diào)用轉(zhuǎn)換構(gòu)造函數(shù)Complex（d2），建立一個臨時的Complex類對象，在調(diào)用operator+函數(shù)，將兩個復(fù)數(shù)相加，然后賦給c2。相當(dāng)于執(zhí)行表達式：c2=c1+Complex(d2)例4.9運用類型轉(zhuǎn)換函數(shù)的簡潔例子#include<iostream>usingnamespacestd;classComplex{public:Complex(){real=0;imag=0;}Complex(doubler,doublei){real=r;imag=i;}operatordouble(){returnreal;}private:doublereal;doubleimag;};

intmain(){Complexc1(3,4),c2(5,-10),c3;doubled;d=2.5+c1;cout<<d<<endl;return0;}5.5分析：（1）假如在Complex類中沒有定義類型轉(zhuǎn)換函數(shù)operatordouble，程序編譯將會出錯。因為不能實現(xiàn)double數(shù)據(jù)類型與Complex類對象的相加。（2）假如在main函數(shù)中加一語句：c3=c2；編譯系統(tǒng)是把c2按Complex類對象處理，因為賦值號兩側(cè)為同一類數(shù)據(jù)，可以合法賦值。（3）假如在Complex類中聲明白重載運算符“+”函數(shù)作為友元函數(shù)，并在類外定義operator+函數(shù)： Complexoperator+（Complexc1，Complexc2） {returnComplex（c1.real+c2.real,c1.imag+c2.imag）;} c3=c1+c2;//有運算符“+”重載，可以實現(xiàn)對象相加 d=c1+c2;//先相加，再通過對double的重載函數(shù)將臨時對象轉(zhuǎn)化為double，再賦值對類型的重載和對運算符的重載的概念和方法相像重載函數(shù)都運用關(guān)鍵字operator，它的意思是“運算符”。因此，通常把類型轉(zhuǎn)換函數(shù)也成為類型轉(zhuǎn)換運算符函數(shù)由于它也是重載函數(shù)，因此也稱為類型轉(zhuǎn)換運算符重載函數(shù)（或稱強制類型轉(zhuǎn)換運算符重載函數(shù)）例4.10包含轉(zhuǎn)換構(gòu)造函數(shù)、運算符重載函數(shù)和類型轉(zhuǎn)換函數(shù)的程序#include<iostream>usingnamespacestd;class