點擊查看：2015年國家計算機二級C 考試復習資料匯總

　　二級C++輔導筆記：私有數據成員的使用

　　一、私有數據成員的使用

　　1.取值和賦值成員函數

　　面向對象的約定就是保證所有數據成員的私有性。一般我們都是通過公有成員函數來作為公共接口來讀取私有數據成員的。某些時候，我們稱這樣的函數為取值和賦值函數。

　　取值函數的返回值和傳遞給賦值函數的參數不必一一匹配所有數據成員的類型。

　　#include iostream.h

　　class Date

　　{

　　int mo, da, yr;

　　public:

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

　　int getyear() const { return yr; }

　　void setyear(int y) { yr = y; }

　　};

　　int main()

　　{

　　Date dt(4,1,89);

　　cout< dt.setyear(97);

　　cout< return 0;

　　}

　　上面的例子很簡單，不分析了。要養成這樣的習慣，通過成員函數來訪問和改變類中的數據。這樣有利于軟件的設計和維護。比如，改變Date類內部數據的形式，但仍然用修改過的getyear()和setyear()來提供訪問接口，那么使用該類就不必修改他們的代碼，僅需要重新編譯程序即可。

　　2.常量成員函數

　　注意上面的程序中getyear()被聲明為常量型，這樣可以保證該成員函數不會修改調用他的對象。通過加上const修飾符，可以使訪問對象數據的成員函數僅僅完成不會引起數據變動的那些操作。

　　如果程序聲明某個Date對象為常量的話，那么該對象不得調用任何非常量型成員函數，不論這些函數是否真的試圖修改對象的數據。只有把那些不會引起數據改變的函數都聲明為常量型，才可以讓常量對象來調用。

　　3.改進的成員轉換函數

　　下面的程序改進了從Date對象到CustomDate對象的成員轉換函數，用取值和賦值函數取代了使用公有數據成員的做法。(以前的程序代碼在上一帖中)

　　#include iostream.h

　　class CustomDate

　　{

　　int da,yr;

　　public:

　　CustomDate() {}

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

　　void display() const {cout< int getday() const { return da; }

　　void setday(int d) { da=d; }

　　};

　　class Date

　　{

　　int mo,da,yr;

　　public:

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

　　operator CustomDate() const;

　　};

　　Date::operator CustomDate() const

　　{

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

　　CustomDate cd(0,yr);

　　int day=da;

　　for(int i=0;i cd.setday(day);

　　return cd;

　　}

　　int main()

　　{

　　Date dt(11,17,89);

　　CustomDate cd;

　　cd=dt;

　　cd.display();

　　return 0;

　　}

　　注意上面的程序中Date::operator CustomDate()聲明為常量型，因為這個函數沒有改變調用它對象的數據，盡管它修改了一個臨時CustomDate對象并將其作為函數返回值。

　　二、友元

　　前面已經說過了，私有數據成員不能被類外的其他函數讀取，但是有時候類會允許一些特殊的函數直接讀寫其私有數據成員。

　　關鍵字friend可以讓特定的函數或者別的類的所有成員函數對私有數據成員進行讀寫。這既可以維護數據的私有性，有可以保證讓特定的類或函數能夠直接訪問私有數據。

　　1.友元類

　　一個類可以聲明另一個類為其友元，這個友元的所有成員函數都可以讀寫它的私有數據。

　　#include iostream.h

　　class Date;

　　class CustomDate

　　{

　　int da,yr;

　　public:

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

　　void display() const {cout< friend Date; //這兒

　　};

　　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(dt);

　　cd.display();

　　return 0;

　　}

　　在上面的程序中，有這樣一句 friend Date; 該語句告訴編譯器，Date類的所有成員函數有權訪問CustomDate類的私有成員。因為Date類的轉換函數需要知道CustomDate類的每個數據成員，所以真個Date類都被聲明為CustomDate類的友元。

　　2.隱式構造函數

　　上面程序對CustomDate的構造函數的調用私有顯示該類需要如下的一個轉換構造函數:

　　CustomDate(Date& dt);

　　但是唯一的一個構造函數是：CustomDate(int d=0;int y=0);

　　這就出現了問題，編譯器要從Date對象構造一個CustomDate對象，但是CustomDate類中并沒有定義這樣的轉換構造函數。不過Date類中定義了一個成員轉換函數，它可以把Date對象轉換成CustomDate對象。于是編譯器開始搜索CustomDate類，看其是否有一個構造函數，能從一個已存在的CustomDate的對象創建新的CustomDate對象。這種構造函數叫拷貝構造函數。拷貝構造函數也只有一個參數，該參數是它所屬的類的一個對象，由于CustomDate類中沒有拷貝構造函數，于是編譯器就會產生一個默認的拷貝構造函數，該函數簡單地把已存在的對象的每個成員拷貝給新對象。現在我們已經知道，編譯器可以把Date對象轉換成CustomDate對象，也可以從已存在的CustomDate對象生成一個新的CustomDate對象。那么上面提出的問題，編譯器就是這樣做的：它首先調用轉換函數，從Date對象創建一個隱藏的、臨時的、匿名的CustomDate對象，然后用該臨時對象作為參數調用默認拷貝構造函數，這就生成了一個新的CustomDate對象。

　　3.預引用

　　上面的例子中還有這樣一句 class Date;

　　這個語句叫做預引用。它告訴編譯器，類Date將在后面定義。編譯器必須知道這個信號，因為CustomDate類中引用了Date類，而Date里也引用了CustomDate類，必須首先聲明其中之一。

　　使用了預引用后，就可以聲明未定義的類的友元、指針和引用。但是不可以使用那些需要知道預引用的類的定義細節的語句，如聲明該類的一個實例或者任何對該類成員的引用。

　　4.顯式友元預引用

　　也可以不使用預引用，這只要在聲明友元的時候加上關鍵自class就行了。

　　#include iostream.h

　　class CustomDate

　　{

　　int da,yr;

　　public:

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

　　void display() const {cout< friend class Date; //這兒，去掉前面的預引用

　　};

　　class Date

　　{

　　... ...

　　};

　　Date::operator CustomDate()

　　{

　　... ...

　　}

　　int main()

　　{

　　... ...

　　}

　　5.友元函數

　　通常，除非真的需要，否則并不需要把整個類都設為另一個類的友元，只需挑出需要訪問當前類私有數據成員的成員函數，將它們設置為該類的友元即可。這樣的函數稱為友元函數。

　　下面的程序限制了CustomDate類數據成員的訪問，Date類中只有需要這些數據的成員函數才有權讀寫它們。

　　#include iostream.h

　　class CustomDate;

　　class Date

　　{

　　int mo,da,yr;

　　public:

　　Date(const CustomDate&);

　　void display() const {cout< };

　　class CustomDate

　　{

　　int da,yr;

　　public:

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

　　friend Date::Date(const CustomDate&);

　　};

　　Date::Date(const CustomDate& cd)

　　{

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

　　yr=cd.yr;

　　da=cd.da;

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

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

　　else break;

　　mo++;

　　}

　　int main()

　　{

　　Date dt(CustomDate(123, 89));

　　dt.display();

　　return 0;

　　}

　　6.匿名對象

　　上面main()函數中Date對象調用CustomDate類的構造函數創建了一個匿名CustomDate對象，然后用該對象創建了一個Date對象。這種用法在C++中是經常出現的。

　　7.非類成員的友元函數

　　有時候友元函數未必是某個類的成員。這樣的函數擁有類對象私有數據成員的讀寫權，但它并不是任何類的成員函數。這個特性在重載運算符時特別有用。

　　非類成員的友元函數通常被用來做為類之間的紐帶。一個函數如果被兩個類同時聲明為友元，它就可以訪問這兩個類的私有成員。下面的程序說明了一個可以訪問兩個類私有數據成員的友元函數是如何將在兩個類之間架起橋梁的。

　　#include iostream.h

　　class Time;

　　class Date

　　{

　　int mo,da,yr;

　　public:

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

　　friend void display(const Date&, const Time&);

　　};

　　class Time

　　{

　　int hr,min,sec;

　　public:

　　Time(int h,int m,int s) { hr=h; min=m; sec=s;}

　　friend void display(const Date&, const Time&);

　　};

　　void display(const Date& dt, const Time& tm)

　　{

　　cout << dt.mo << '/' << dt.da << '/' << dt.yr;

　　cout << ' ';

　　cout << tm.hr << ':' << tm.min << ':' << tm.sec;

　　}

　　int main()

　　{

　　Date dt(2,16,97);

　　Time tm(10,55,0);

　　display(dt, tm);

　　return 0;

　　}

　　相關推薦：

　　各地2015年計算機等級考試報名時間匯總

　　各地2015年上半年計算機等級考試費用匯總

　　2015年計算機二級C++模擬練習題及答案匯總