c++ 成員函數(shù)與非成員函數(shù)的抉擇

更新時間：2013年01月02日 16:34:22 投稿：mdxy-dxy

盡量用類的非成員函數(shù)以及友元函數(shù)替換類的成員函數(shù) 例如一個類來模擬人People

1.盡量用類的非成員函數(shù)以及友元函數(shù)替換類的成員函數(shù) 例如一個類來模擬人People

class People{
public:
...
void Getup( );
void Washing( );
void eating( );
...
}

其實上面三個動作是早上“起床”、“洗簌”、“吃飯”三個常見的動作，如果現(xiàn)在用一個函數(shù)來表示使用成員函數(shù)即為

復(fù)制代碼代碼如下:

class People
{
...
void morningAction( )
{
Getup( );
Washing( );
eating( );
}
}

如果寫一個非成員函數(shù)即為

復(fù)制代碼代碼如下:

void moringAction(People& p)
{
p.Getup( );
p.Washing( );
p.eating( );
}

那么是選擇類的成員函數(shù)還是類的非成員函數(shù)呢？

面向?qū)ο髣t要求是，將操作數(shù)據(jù)的函數(shù)與數(shù)據(jù)放在一起。但這不意味著要選擇成員函數(shù)。從封裝的角度看，成員函數(shù)的moringAction封裝性比非成員函數(shù)要低。如果某些東西被封裝，它就不再可見。越多東西被封裝，越少人可以看到它。所以使用非成員函數(shù)的類，封裝性較低。而越少人看到它，我們就有越大彈性去變化它，因為我們的改變僅僅直接影響看到改變的那些人事物。因此，越多東西被封裝，改變哪些東西能力越大。

在考慮對象內(nèi)的數(shù)據(jù)。越少的代碼可以看到數(shù)據(jù)（訪問它），越多的數(shù)據(jù)可以被封裝，而我們也就越能自由改變對象數(shù)據(jù)?，F(xiàn)在如果一個成員函數(shù)、非成員函數(shù)都能提供相同的機能，我們選擇非成員函數(shù)。

在說下面內(nèi)容之前我們先談?wù)凜++中的類型轉(zhuǎn)換分顯示類型轉(zhuǎn)換和隱式類型轉(zhuǎn)換。

2.顯示類型轉(zhuǎn)換

C++有顯示類型轉(zhuǎn)換操作符分別為：static_cast,const_cast,dynamic_cast和reinterpret_cast

2.1static_cast
轉(zhuǎn)換功能與C風(fēng)格類型轉(zhuǎn)換一樣，含義也一樣。通過使用static_cast可以使沒有繼承關(guān)系的類型進行轉(zhuǎn)換。但是要注意不能將內(nèi)置類型轉(zhuǎn)化為自定義類型，或者將自定義類型轉(zhuǎn)化為內(nèi)置類型，并且不能將cosnt類型去掉，但能將non-cosnt類型轉(zhuǎn)換為const類型。例如：
char a='a';

int b=static_cast<int>(a);
兩個類型之間的轉(zhuǎn)換，其實也是要自己實現(xiàn)支持，原理和內(nèi)置類型之間轉(zhuǎn)換相似。

復(fù)制代碼代碼如下:

#include <iostream>
class Car;
3
class People
{
public:
People(int a,int h)
:age(a),height(h)
{}
10
inline int getAge() const
{
return age;
}
15
inline int getHeight() const
{
return height;
}
20
People & operator=(const Car& c);
private:
int age;
int height;
};
26
class Car
{
public:
Car(double c, double w)
:cost(c),weight(w)
{}
33
inline double getCost() const
{
return cost;
}
38
inline double getWeight() const
{
return weight;
}
43
Car & operator=(const People& c);
private:
double cost;
double weight;
};
49
People & People::operator=(const Car& c)
{
age = static_cast<int>(c.getCost());
height = static_cast<int>(c.getWeight());
return *this;
}
56
Car & Car::operator=(const People& c)
{
cost = static_cast<double>(c.getAge());
weight = static_cast<double>(c.getHeight());
return *this;
}
63
int main(int argc,char * argv[])
{
Car c(1000.87,287.65);
People p(20,66);
People p2(0,0);
Car c2(0.00,0.00);
p2=c;
c2=p;
std::cout<< "car'info: cost is " << c2.getCost() << ". weight is " << c2.getWeight() <<std::endl;
std::cout<< "people'info: age is " << p2.getAge() <<". height is " << p2.getHeight() <<std::endl;
return 0;
}

運行結(jié)果為
car'info: cost is 20. weight is 66
people'info: age is 1000. height is 287

2.2const_cast
主要用來去掉const和volatileness屬性，大多數(shù)情況下是用來去掉const限制。

2.3dynamic_cast
它用于安全地沿著繼承關(guān)系向下進行類型轉(zhuǎn)換。一般使用dynamic_cast把指向基類指針或者引用轉(zhuǎn)換成其派生類的指針或者引用，并且當轉(zhuǎn)換失敗時候，會返回空指針。

2.4reinterprit_cast
該轉(zhuǎn)換最普通用途就是在函數(shù)指針類型之間進行轉(zhuǎn)換。

復(fù)制代碼代碼如下:

typedef void (*fun) ( ) //一個指向空函數(shù)的指針
fun funArray[10]; //含有10個函數(shù)指針的數(shù)據(jù)。
int function( ); //一個返回值為int類型函數(shù)
funArray[0] = &function( ) //錯誤！類型不匹配
funArray[0] = reinterpret_cast<fun>(&function); //ok注意轉(zhuǎn)換函數(shù)指針的代碼是不可移植的。

一般應(yīng)該避免去轉(zhuǎn)換函數(shù)指針類型。

3.使用非成員函數(shù)可以發(fā)生隱式轉(zhuǎn)換
C++是支持隱式類型轉(zhuǎn)換的，例如在做運算的時候，或者傳遞參數(shù)給函數(shù)的時候常常會發(fā)生隱式類型轉(zhuǎn)換。
假設(shè)你設(shè)計一個class用來表現(xiàn)有理數(shù)。其實令類支持隱式類型轉(zhuǎn)換是一個槽糕的決定。當然在建立數(shù)值類型時就是例外。下面定義一個有理數(shù)類型：

復(fù)制代碼代碼如下:

class Rational {
public:
Rational( int numerator = 0,int denominator =1 );
int numerator( ) const;
int denominator ( ) const ;
private:
...
}

有理數(shù)類型想當然支持算數(shù)運算，但是不確定是否聲明為成員函數(shù)或非成員函數(shù)或者是友元函數(shù)來實現(xiàn)它們。

首先是考慮成員函數(shù)寫法：

復(fù)制代碼代碼如下:

class Rational {
public:
...
const Rational operator* (const Rational& rhs) const;
...
}
Rational testOne(1,4);
Rational testTwo(1,1);
//做算術(shù)運算
Rational result = testOne * testTwo;
//與常量做運算
result = 2 * testOne //error!!

那么為什么將常量提前就錯誤了呢？這里我們換一種寫法

復(fù)制代碼代碼如下:

1 result = testOne.operator*(2); //ok
2 result =2.operator*(oneHalf); //error

這里發(fā)生了什么？其實在第一行式子里發(fā)生了所謂隱式類型轉(zhuǎn)換。哪里發(fā)生了隱式類型轉(zhuǎn)換呢？看上面的代碼operator*函數(shù)參數(shù)是const Rational類型，而2是一個cosnt int類型，。編譯器發(fā)現(xiàn)有non-explicit型的單參數(shù)類為int類型的構(gòu)造函數(shù)，可以造出Rational類型。所以編譯器那樣做了，發(fā)生了隱式類型轉(zhuǎn)換。所以第一個式子可以正常運行，但是第二個是沒有將Rational類型轉(zhuǎn)換為int類型的。
設(shè)計出上面兩個式子正常運行才算合理的運行。

復(fù)制代碼代碼如下:

class Rational{
...
};
const Rational operator*(const Rational & lhs, const Rational & rhs)
{
return Rational(lhs.numerator() * rhs.numerator(),lhs.denominator() * rhs.denominator() );
}
Rational testOne(1, 4);
Rational result;
result = oneFourth *2;
result = 2 * oneFourth; 通過
}

按上面代碼設(shè)計成非成員函數(shù)，那么在調(diào)用int類型整數(shù)的時候會發(fā)生隱式類型轉(zhuǎn)換。
operaotr* 是否應(yīng)該稱為Rational class的一個友元函數(shù)呢？對本例子而言，完全沒有必要。

如果你需要為某個函數(shù)所有參數(shù)進行類型轉(zhuǎn)換，那么這個函數(shù)必須是個非成員函數(shù)。

4.謹慎使用隱式類型轉(zhuǎn)換
我們對一些類型隱式轉(zhuǎn)換無能為力，因為它們是語言本身的特性。不過當編寫自定義類時，我們可以選擇是否提供函數(shù)讓編譯器進行隱式類型轉(zhuǎn)換。
有兩種函數(shù)允許編譯器進行隱式類型轉(zhuǎn)換：單參數(shù)構(gòu)造函數(shù)與隱式類型轉(zhuǎn)換運算符。

復(fù)制代碼代碼如下:

public Name{
public:
Name(const string& s); //轉(zhuǎn)換string到Name
4
...
};
7
class Rational { //有理數(shù)類
public:
//轉(zhuǎn)換從int到有理數(shù)類
Rational(int numerator=0,int denominatior =1);
...
}

C++是支持隱式類型轉(zhuǎn)換的，例如在做運算的時候，或者傳遞參數(shù)給函數(shù)的時候常常會發(fā)生隱式類型轉(zhuǎn)換。有兩種函數(shù)允許編譯器進行隱式轉(zhuǎn)換。單參數(shù)構(gòu)造函數(shù)和隱式類型轉(zhuǎn)換運算符。

也許前面說道了一些隱式類型轉(zhuǎn)換帶來的方便之處，下面說說一些麻煩之處。

復(fù)制代碼代碼如下:

template<class T>
class Array{
Array(int lowBound,int highBound);
Array(int size);
T& operator[](int index);
...
};
bool oerpator==(const Array<int>& lhs,const Array<int>& rhs);
Array<int> a(10);
Array<int> b(10);
...
for(int i=0;i < 10; ++i)
if(a == b[i]) {
... }
else
{
...
}

如果這里不小心將數(shù)組a的下標忘記寫了，這里編譯器應(yīng)該報出警告信息，但是其實是沒有的。因為編譯器將a看成Array<int>類型，b為 int，根據(jù)上面的經(jīng)驗，編譯器看到一個non-explicit單參數(shù)構(gòu)造函數(shù)其參數(shù)類型為int，而且operator需要一個Array<int>類型，那么編譯器就這樣做了，發(fā)生了隱式類型轉(zhuǎn)換。相信如果真的發(fā)生這樣，會很麻煩。
怎么樣避免呢？將構(gòu)造函數(shù)聲明為explicit。避免隱式類型轉(zhuǎn)換。