条款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)的可能性降至最低。
版权声明：本文为博主原创文章，未经博主允许不得转载。