類的轉換

C++的內部數據類型遵循隱式類型轉換規則。假設某個表達市中使用了一個短整型變量，而編譯器根據上下文認為這兒需要是的長整型，則編譯器就會根據類型轉換規則自動把它轉換成長整型，這種隱式轉換出現在賦值、參數傳遞、返回值、初始化和表達式中。我們也可以為類提供相應的轉換規則。

對一個類建立隱式轉換規則需要構造一個轉換函數，該函數作為類的成員，可以把該類的對象和其他數據類型的對象進行相互轉換。聲明了轉換函數，就告訴了編譯器，當根據句法判定需要類型轉換時，就調用函數。

有兩種轉換函數。一種是轉換構造函數;另一種是成員轉換函數。需要采用哪種轉換函數取決于轉換的方向。

一、轉換構造函數

當一個構造函數僅有一個參數，且該參數是不同于該類的一個數據類型，這樣的構造函數就叫轉換構造函數。轉換構造函數把別的數據類型的對象轉換為該類的一個對象。和其他構造函數一樣，如果聲明類的對象的初始化表同轉換構造函數的參數表相匹配，該函數就會被調用。當在需要使用該類的地方使用了別的數據類型，便宜器就會調用轉換構造函數進行轉換。

#include iostream.h

#include time.h

#include stdio.h

class Date

{

int mo, da, yr;

public:

Date(time_t);

void display();

};

void Date::display()

{

char year[5];

if(yr<10)

sprintf(year,0%d,yr);

else

sprintf(year,%d,yr);

cout< }

Date::Date(time_t now)

{

tm* tim=localtime(&now);

da=tim->tm_mday;

mo=tim->tm_mon+1;

yr=tim->tm_year;

if(yr>=100) yr-=100;

}

int main()

{

time_t now=time(0);

Date dt(now);

dt.display();

return 0;

}

本程序先調用time()函數來獲取當前時間，并把它賦給time_t對象;然后程序通過調用Date類的轉換構造函數來創建一個Date對象，該對象由time_t對象轉換而來。time_t對象先傳遞給localtime()函數，然后返回一個指向tm結構(time.h文件中聲明)的指針，然后構造函數把結構中的日月年的數值拷貝給Date對象的數據成員，這就完成了從time_t對象到Date對象的轉換。

二、成員轉換函數

成員轉換函數把該類的對象轉換為其他數據類型的對象。在成員轉換函數的聲明中要用到關鍵字operator。這樣聲明一個成員轉換函數：

operator aaa();

在這個例子中，aaa就是要轉換成的數據類型的說明符。這里的類型說明符可以是任何合法的C++類型，包括其他的類。如下來定義成員轉換函數;

Classname::operator aaa()

類名標識符是聲明了該函數的類的類型說明符。上面定義的Date類并不能把該類的對象轉換回time_t型變量，但可以把它轉換成一個長整型值，計算從2000年1月1日到現在的天數。

#include iostream.h

class Date

{

int mo,da,yr;

public:

Date(int m,int d,int y) {mo=m; da=d; yr=y;}

operator int(); //聲明

};

Date::operator int() //定義

{

static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31};

int days=yr-2000;

days*=365;

days+=(yr-2000)/4;

for(int i=0;i days+=dys[i];

days+=da;

return days;

}

int main()

{

Date now(12,24,2003);

int since=now;

cout< return 0;

}

三、類的轉換

上面兩個例子都是C++類對象和內部數據對象之間的相互轉換。也可以定義轉換函數來實現兩個類對象之間的相互轉換。

#include iostream.h

class CustomDate

{

public:

int da, yr;

CustomDate(int d=0,int y=0) {da=d; yr=y;}

void display()

{

cout< }

};

class Date

{

int mo, da, yr;

public:

Date(int m=0,int d=0,int y=0) {mo=m; da=d; yr=y;}

Date(const CustomDate&); //轉換構造函數

operator CustomDate(); //成員轉換函數

void display()

{

cout< }

};

static int dys[] = {31,28,31,30,31,30,31,31,30,31,30,31};

Date::Date(const CustomDate& jd)

{

yr=jd.yr;

da=jd.da;

for(mo=0;mo<11;mo++)

if(da>dys[mo]) da-=dys[mo];

else break;

mo++;

}

Date::operator CustomDate()

{

CustomDate cd(0,yr);

for(int i=0;i cd.da+=da;

return cd;

}

int main()

{

Date dt(12,24,3);

CustomDate cd;

cd = dt; //調用成員轉換函數

cd.display();

dt = cd; //調用轉換構造函數

dt.display();

return 0;

}

這個例子中有兩個類CustomDate和Date，CustomDate型日期包含年份和天數。

這個例子沒有考慮閏年情況。但是在實際構造一個類時，應該考慮到所有問題的可能性。

在Date里中具有兩種轉換函數，這樣，當需要從Date型變為CustomDate型十，可以調用成員轉換函數;反之可以調用轉換構造函數。

不能既在Date類中定義成員轉換函數，又在CustomDate類里定義轉換構造函數。那樣編譯器在進行轉換時就不知道該調用哪一個函數，從而出錯.

四、轉換函數的調用

C++里調用轉換函數有三種形式：第一種是隱式轉換，例如編譯器需要一個Date對象，而程序提供的是CustomDate對象，編譯器會自動調用合適的轉換函數。另外兩種都是需要在程序代碼中明確給出的顯式轉換。C++強制類型轉換是一種，還有一種是顯式調用轉換構造函數和成員轉換函數。下面的程序給出了三中轉換形式：

#include iostream.h

class CustomDate

{

public:

int da, yr;

CustomDate(int d=0,int y=0) {da=d; yr=y;}

void display()

{

cout< }

};

class Date

{

int mo, da, yr;

public:

Date(int m,int d,int y)

{

mo=m; da=d; yr=y;

}

operator CustomDate();

};

Date::operator CustomDate()

{

static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31};

CustomDate cd(0,yr);

for(int i=0;i cd.da+=da;

return cd;

}

int main()

{

Date dt(11,17,89);

CustomDate cd;

cd = dt;

cd.display();

cd = (CustomDate) dt;

cd.display();

cd = CustomDate(dt);

cd.display();

return 0;

}

五、轉換發生的情形

上面的幾個例子都是通過不能類型對象之間的相互賦值來調用轉換函數，還有幾種調用的可能：

參數傳遞

初始化

返回值

表達式語句

這些情況下，都有可能調用轉換函數。

下面的程序不難理解，就不分析了。

#include iostream.h

class CustomDate

{

public:

int da, yr;

CustomDate() {}

CustomDate(int d,int y) { da=d; yr=y;}

void display()

{

cout< }

};

class Date

{

int mo, da, yr;

public:

Date(int m,int d,int y) { mo=m; da=d; yr=y; }

operator CustomDate();

};

Date::operator CustomDate()

{

static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31};

CustomDate cd(0,yr);

for (int i=0;i cd.da+=da;

return cd;

}

class Tester

{

CustomDate cd;

public:

explicit Tester(CustomDate c) { cd=c; }

void display() { cd.display(); }

};

void dispdate(CustomDate cd)

{

cd.display();

}

CustomDate rtndate()

{

Date dt(9,11,1);

return dt;

}

int main()

{

Date dt(12,24,3);

CustomDate cd;

cd = dt;

cd.display();

dispdate(dt);

Tester ts(dt);

ts.display();

cd = rtndate();

cd.display();

return 0;

}

六、顯式構造函數

注意上面Tester類的構造函數前面有一個explicit修飾符。如果不加上這個關鍵字，那么在需要把CustomDate對象轉換成Tester對象時，編譯器會把該函數當作轉換構造函數來調用。但是有時候，并不想把這種只有一個參數的構造函數用于轉換目的，而僅僅希望用它來顯式地初始化對象，此時，就需要在構造函數前加explicit。如果在聲明了Tester對象以后使用了下面的語句將導致一個錯誤：

ts=jd; //error

這個錯誤說明，雖然Tester類中有一個以Date型變量為參數的構造函數，編譯器卻不會把它看作是從Date到Tester的轉換構造函數，因為它的聲明中包含了explicit修飾符。

七、表達式內部的轉換

在表達式內部，如果發現某個類型和需要的不一致，就會發生錯誤。數字類型的轉換是很簡單，這里就不舉例了。下面的程序是把Date對象轉換成長整型值。

#include iostream.h

class Date

{

int mo, da, yr;

public:

Date(int m,int d,int y)

{

mo=m; da=d; yr=y;

}

operator long();

};

Date::operator long()

{

static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31};

long days=yr;

days*=365;

days+=(yr-1900)/4; //從1900年1月1日開始計算

for(int i=0;i days+=da;

return days;

}

int main()

{

Date today(12,24,2003);

const long ott=123;

long sum=ott+today;

cout< return 0;

}

在表達式中，當需要轉換的對象可以轉換成某個數字類型，或者表達式調用了作用于某個類的重載運算符時，就會發生隱式轉換。