【effective c++读书笔记】【第5章】实现(1)

条款26：尽可能延后变量定义式的出现时间

1、只要你定义了一个变量而其类型带有一个构造函数或析构函数，那么当程序的控制流到达这个变量定义式时，你便得承受构造成本；当这个变量离开其作用域时，你便得承受析构成本。即使这个变量最终并为被使用，仍需耗费这些成本，所以应该尽量避免这种情形。

例子：

std::string encryptPassword(const std::string& password){
	using namespace std;
	string encrypted;
	if (password.length() < MinimumPasswordLength){
		throw logic_error("Password is too short");    
	}
	...
	return encrypted;
}

如果有个异常被丢出，对象encrypted就没有被使用，但仍得付出encrypted的构造成本和析构成本。所以最好延后encrypted的定义式，直到确实需要它。

std::string encryptPassword(const std::string& password){
	using namespace std;
	if (password.length() < MinimumPasswordLength){
		throw logic_error("Password is too short");    
	}
	string encrypted;
	...
	return encrypted;
}

有一点要注意：“通过默认构造函数构造出一个对象然后对它赋值”比“直接在构造函数时制定初值”效率差。

2、“尽可能延后”的真正意义是：你不只应该延后变量的定义，直到非得使用该变量的前一刻为止，甚至应该尝试延后这份定义直到能够给它初值实参为止。这样不仅能够避免构造和析构非必要对象，还可以避免无意义的default构造函数。

3、对于循环

例子：

//方法A:定义循环外
Widget w;
for (int i = 0; i < n; ++i){
	w = 取决于i的某个值;
	...
}     //1个构造函数+1个析构函数+n个赋值操作；
//方法B：定义循环内
for (int i = 0; i < n; ++i)
{
	Widget w(取决于i的某个值);
	...
}     //n个构造函数+n个析构函数

方法A的成本是1个构造函数+1个析构函数+n个赋值操作，方法B的成本是n个构造函数+n个析构函数。除非（1）你知道赋值成本比“构造+析构”成本低，（2）你正在处理代码中效率高度敏感的部分，否则应该使用方法B。

请记住：

• 尽可能延后变量定义式的出现。这样做可增加程序的清晰度并改善程序效率。

条款27：尽量少做转型动作

1、C++规则的设计目标之一是，保证“类型错误”绝不可能发生。不幸的是，转型（casts）破坏了类型系统。那可能导致任何种类的麻烦，有些容易辨识，有些非常隐晦。

2、C风格的转型动作看起来像这样：

(T)expression    //将expression转型为T

 函数风格的转型动作看起来像这样：

T(expression)    //将expression转型为T

C++还提供四种新式转型：

const_cast 通常被用来将对象的常量性转除。

dynamic_cast 要用来执行“安全向下转型”，也就是用来决定某对象是否归属继承体系中的某个类型。

reinterpret_cast 图执行低级转型，实际动作可能取决于编译器，这也就表示它不可移植。

static_cast 来强迫隐式转换，例如将non-const转型为const，int转型为double等等。

3、任何一个类型转换（不论是通过转型操作而进行的显式转换，或通过编译器完成的隐式转换）往往真的令编译器编译出运行期间执行的码。

4、例子：

class Base{ ... };
class Derived :public Base{ ... };
Derived d;
Base* pb = &d;

上述例子建立一个base class指针指向一个derived class对象，但有时候上述两个指针值并不相同。这种情况下会有个偏移量在运行期被施行与Derived*指针身上，用以取得正确的Base*指针值。

一个对象可能拥有一个以上地址，一个是Base*指向的地址，一个是Derive*指向的地址。

5、例子

#include<iostream>
using namespace std;

class Base{
public:
	Base(int i = 0) :bVal(i){}
	virtual void plusOne(){
		cout << ++bVal << endl;
	}
	int bVal;
};
class Derived :public Base{
public:
	Derived(int i = 10, int j = 5) :Base(i), dVal(j){}
	void plusOne(){
		cout << "基类值为:";
		//static_cast<Base>(*this).plusOne();		//错误做法
		Base::plusOne();			        //正确做法	      
		cout << "派生类值为:";
		cout << dVal << endl;
	}
private:
	int dVal;
};

int main(){
	Derived d;
	d.plusOne();
	cout << "基类值为:"<< d.bVal << endl;

	system("pause");
	return 0;
}

上述derived类中的plusOne函数中的错误做法的运行结果：

上述derived类中的plusOne函数中的正确做法的运行结果：

使用强制类型转化后，d.bVal的还是10；而调用基类函数时，d.bVal的值就变成了11，为什么结果会不一样呢？因为就是static_cast<Base>(*this).plusOne()调用的并不是当前对象上的plusOne函数，而是稍早转型动作所建立的一个“*this对象之base class成分”的暂时副本身上的plusOne函数。当在派生类中调用基类的某些成分时，直接通过作用域操作符告诉使用的是基类的成员，而不是通过类型转换。

6、之所以需要dynamic_cast，通常是因为你想在一个认定为derived class对象身上执行derived class操作函数，但你却只有一个“指向base”的pointer或reference。

例子：

#include<iostream>
using namespace std;

class Base{
public:
	Base(int i = 0) :bVal(i){}
	int getBaseVal() const{ return bVal; }
	virtual ~Base(){}
private:
	int bVal;
};
class Derived :public Base{
public:
	Derived(int i = 10, int j = 5) :Base(i), dVal(j){}
	void plusOne(){
		cout << "基类值为:" << Base::getBaseVal() << endl;
		cout << "派生类值为:" << dVal << endl;
	}
private:
	int dVal;
};

int main(){
	Base* pb=new Derived;
	Derived* pd = dynamic_cast<Derived*>(pb);
	pd->plusOne();

	system("pause");
	return 0;
}

有两个一般性做法可以避免这个问题。

a、使用容器存储并在其中存储直接指向派生类的对象的指针（通常是智能指针），便消除了“通过base class接口处理对象“的需要。

#include<iostream>
#include<vector>
#include<memory>
using namespace std;

class Base{
public:
	Base(int i = 0) :bVal(i){}
	int getBaseVal() const{ return bVal; }
	virtual ~Base(){}
private:
	int bVal;
};
class Derived :public Base{
public:
	Derived(int i = 10, int j = 5) :Base(i), dVal(j){}
	void plusOne(){
		cout << "基类值为:" << Base::getBaseVal() << endl;
		cout << "派生类值为:" << dVal << endl;
	}
private:
	int dVal;
};

int main(){
	typedef vector<shared_ptr<Derived>> VSD;
	VSD vec;
	vec.push_back(shared_ptr<Derived>(new Derived));
	for (VSD::iterator it = vec.begin(); it != vec.end(); ++it)
		(*it)->plusOne();

	system("pause");
	return 0;
}

b、在baseclass内提供虚函数做你想对各个派生类做的事。

#include<iostream>
#include<vector>
#include<memory>
using namespace std;

class Base{
public:
	Base(int i = 0) :bVal(i){}
	int getBaseVal() const{ return bVal; }
	virtual void plusOne(){}
	virtual ~Base(){}
private:
	int bVal;
};
class Derived :public Base{
public:
	Derived(int i = 10, int j = 5) :Base(i), dVal(j){}
	void plusOne(){
		cout << "基类值为:" << Base::getBaseVal() << endl;
		cout << "派生类值为:" << dVal << endl;
	}
private:
	int dVal;
};

int main(){
	Base* pb=new Derived;
	pb->plusOne();

	system("pause");
	return 0;
}

请记住：

• 如果可以，尽量避免转型，特别是在注重效率的代码中避免dynamic_casts。如果有个设计需要转型动作，试着发展无需转型的替代设计。
• 如果转型是必要的，试着将它隐藏于某个函数背后。客户随后可以调用该函数，而不需要将转型放进他们自己的代码内。
• 宁可使用C++-style（新式）转型，不要使用旧式转型。前者很容易辨识出来，而且也比较有着分们别类的职掌。

条款28：避免返回handles指向对象内部成分

1、例子：

#include<iostream>
#include<memory>
using namespace std;

class Point{ //用来描述“点”
public:
	Point(int xVal, int yVal) :x(xVal), y(yVal){}
	void setX(int newVal){ x = newVal; }
	void setY(int newVal){ y = newVal; }
	int getX()const{ return x; }
	int getY()const{ return y; }
private:
	int x;
	int y;
};
struct RectData{ //用来描述“矩形”
	RectData(const Point& p1, const Point& p2) :ulhc(p1), lrhc(p2){}
	Point ulhc;//坐上
	Point lrhc;//右下
};
class Rectangle{  //矩形类
public:
	Rectangle(RectData data) :pData(new RectData(data)){}
	Point& upperLeft()const{ return pData->ulhc; }
	Point& lowerRight()const{ return pData->lrhc; }
private:
	shared_ptr<RectData> pData;
};

int main(){
	Point coord1(0, 0);
	Point coord2(100, 100);
	RectData data(coord1, coord2);
	const Rectangle rec(data);
	rec.upperLeft().setX(50);
	cout << rec.upperLeft().getX() << " " << rec.upperLeft().getY() << endl;//左上角坐标从(0,0)变为了(50,0)

	system("pause");
	return 0;
}

上述例子中upperLeft的调用者能够使用被返回的reference（指向rec内部的Point成员变量）来更改成员，但rec应该是不可变的（const）。我们可以得到以下两个结论：

a、变量的封装性最多等于“返回其引用”的函数的访问级别。

b、如果const成员函数传出一个reference，后者所指数据与对象自身有关联，而它又被储存于对象之外，那么这个函数的调用者可以修改那笔数据。

2、对象的引用、指针、迭代器都是所谓的handles，而返回一个“代表对象内部数据”的handle，会降低对象的封装性。在上述例子中，只要在upperLeft和lowerRight函数的返回类型加上const即可：

const Point& upperLeft()const{ return pData->ulhc; }
const Point& lowerRight()const{ return pData->lrhc; }

即便如此，upperLeft和lowerRight函数还是返回了代表对象内部的handles，有可能在其他场合带来问题，如它可能导致dangling handles，即这种handles所指东西不复存在。

例子：

class GUIObject {...};
const Rectangle boundingBox(const GUIObject& obj);

GUIObject* pgo;
const Point* pUpperLeft = &(boundingBox(*pgo).upperLeft());

上述例子中boudingBox返回了一个临时对象，也就是我们说的temp，upperLeft返回的是temp对象内部数据的引用,那么现在pUpperLeft就指向该temp对象的内部数据的地址。该语句结束以后temp对象被销毁，间接导致temp内的Points析构，最终导致pUpperLeft指向的就是一个不存在的对象，pUpperLeft也就是变成空悬、虚吊(dangling)！

请记住:

• 避免返回handles(包括引用，指针，迭代器)指向内部对象。遵守这个条款可增加封装性，帮助const成员函数的行为像个const，并将发生“虚吊号码牌”(dangling handles)的可能性降至最低。