条款01：视C++为一个语言联邦 ： C， Object-Oriented C++， Template C++， STL
条款02：尽量以const,enum,inline 替换#define：
1.对于单纯常量，最好以const对象或enum替换#define
2.对于形似函数的宏(macros)，最好改用inline函数替换#define。
#define ASPECT_RATIO 1.653
const double AspectRatio = 1.653;
1)用#define定义的名字可能没有进入记号表，编译出错，不方便追踪
2)用const定义常量将得到更精简的目标代码(object code)，因为预处理器处理#define是会盲目的将宏名称替换为1.653导致目标码出现多份1.653若用const则不会出现这种问题。
当用常量替换#define有两种特殊的情况。
1)定义常量指针。由于常量定义式通常放在头文件内（以便被不同源码含入），因此有必要将指针声明为const。
const char* const authorName = “Scott Meyer”；
string对象通常比char*-base合宜，所以authorName往往定义成这样：const std::string authorName(“Scott Meyer”)；
2)class专属常量。为了将常量的作用域限制于class内，和确保此常量至多只有一份实体，必须让它成为一个static成员：
class GamePlayer {
private：
static const int NumTurns = 5;
int scores[NumTurns];
...
}
通常static & const& 整数类型(ints,chars,bools)类型成员如果不取地址，可以声明并使用而无需定义。但如果你取某个class专属常量的地址，或你的编译器却(不正确地)坚持要看到一个定义式就必须提供如下定义式
const int GamePlayer::NumTurns; //放到实现文件，因为在声明时已获得初值，不能再设初值。
我们无法用#define 创建class专属常量，因为#define不重视作用域scope。
旧时编译器也许不支持上述语法，不允许static成员在声明时提供初值。
则将初值放到定义式里，但编译器坚持必须在编译期间知道数组score[]大小,万一你的编译器不允许static 整数型class常量完成 in class初值设定，可改用 the enum hack补偿做法。
class GamePlayer{
private：
enum{ NumTurns=5 }；
int scores[NumTurns];
}
1）取enum和#define地址一样，不合法。如果你不想让别人获得一个pointer或reference指向你的某个整数常量，enum可以帮助你实现这个约束。enums和#defines一样不会导致非必要的内存分配。
2）实用，很多代码用了。 enum hack是 模板元编程template metaprogramming的基础技术。
另一个常见的#define误用情况是用它实现宏。宏看起来像函数，但不会招致函数调用带来的额外开销。
#define MAX(a,b) f((a)>(b)?(a):(b))
int a =5, b = 0;
MAX(++a, b);//a被累加二次
MAX(++a, b+10);//a被累加一次
替换为内联模板函数：宏的效率和类型安全，可预料行为
template<typename T>
inline void MAX(const T&a,const T&b)
{
f(a>b?a:b);
}
条款03: 尽可能实用const
const Rational operator* (const Rational& lhs, const Rational& rhs)；//为什么返回const对象？
Rational a, b, c;
…
(a * b) = c;//
if（a * b = c) … // 其实想做比较操作，返回const可预防此类问题
const成员函数：可被const对象调用。两个函数如果只是常量性不同，是可以被重载。
可用mutable释放掉non-static成员变量的bitwise constness约束（即mutable修饰的成员变量可被const成员函数修改）。
在const和non-const成员函数中避免重复：
class TextBlock {
public: …
const char& operator[] (std::size_t position) const {
…
return text[position];
}
char& operator[] (std::size_t position) { //non-const成员函数调用const成员函数避免代码重复
return
const_cast<char&>(
static_cast<const TextBlock&>(*this)
[position]);
}
private: std::string text';
};
不能令const成员函数调用non-const成员函数，对象有可能被改动。
条款04: 确定对象被使用前已先被初始化。
1.对内置类型手工初始化
2.构造函数最好使用成员初值列 member initialization list，而不要在构造函数体内用赋值操作。初值列中列出的成员变量次序要跟在class中声明次序一致。
3.为免除跨编译单元之初始化次序问题，用local static 对象替换non-local static 对象
class A {
public： A(const string&);
private:
string str;
int num;
}
A::A(const string &s){
str=s; //赋值而非初始化，在初值列中调用一次default构造函数，函数体内一次赋值操作
num=0'; //内置类型不保证。
}
C++规定对象的成员变量初始化动作发生在进入构造函数体之前。如果成员变量是const或引用，则一定要初始化，而不能被赋值。
A::A(const string &s):str(s), //值调用一次copy构造函数
num(0){}
static对象：从被构造到程序结束为止。main()结束时自动析构。
包括global对象，namespace内的对象，在class内、函数内、及在file作用域内被声明为static的对象。
local static对象：函数内的static对象
non-local static对象：其他
如果某个编译单元内的某个non-local static对象的初始化动作使用了另一编译单元内的某个non-local static对象，则可能未被初始化。C++对”定义于不同便一单元内的non-local static对象“的初始化次序无明确定义。
class FileSystem {
public: …
std::size_t numDisks() const;
};
extern FileSystem tfs;
//另一编译单元
class Directory {
public:
Directory(params);
};
Directory::Directory(params) {
std::size_t disks = tfs.numDisks();
}
Directory tempDir (params);
解决方案：singleton模式，用local static对象替换non-local static对象
C++保证，函数内的local static 对象会在该函数被调用期间，首次遇上该对象定义式时被初始化。
class FileSystem {…};
FileSystem& tfs() {
static FileSystem fs;
return fs;}
class Directory {…};
Directory::Directory (params) {
std::size_t disks = tfs().numDisks();
};
Directory& tempDir() {
static Directory td;
return td;}
条款05：了解C++默默编写并调用哪些函数
编译器暗自为class创建default构造函数，copy构造函数，copy assignment操作符，以及析构函数
只有当一个类没有定义构造函数时，编译器才会自动生成一个默认构造函数。
如果没有定义复制构造函数，编译器就会合成一个，即使已经定义了其他的构造函数。
template<class T>
class NamedObject {
public: NamedObject(string &name, const T &value):nameValue(name),objectValue(value){}
private: string &nameValue;
const T objectValue;
};
string newDog(“aaa”);
string oldDod(“bbb”);
NamedObject<int> p(newDog,2);
NamedObject<int> s(oldDog, 36);
p = s; //编译失败
在内含引用或const成员的class内支持赋值操作符，你必须自己定义copy assignm操作符。
如果某个base class将copy assignment操作符声明为private，编译器拒绝为其derived classes生成一个copy assignment操作符。
条款06: 若不想使用编译器自动生成的函数，就该明确拒绝。
方案：将相应成员函数声明为private并不予实现。或使用Uncopyable这样的base class
明确声明一个成员函数，阻止编译器暗自生成，另其为private，阻止外部调用。
但成员函数和friend仍然可以反问，所以只声明而不定义它们，如不慎调用，则会得到一个连接错误。
将连接期错误移到编译器:
class Uncopyable{
protected: Uncopyable(){} //允许derived对象构造和析构
~Uncopyablel(){}
private: Uncopyable(const Uncopyable&); //但阻止copying
Uncopyable& operator=(const Uncopyable&);
};
class HomeForSale:private Uncopyable { …};
当尝试拷贝HomeForSale对象时，自动生成copy构造函数和copy assignment操作符，并尝试调用基类对于版本，但失败。。。
条款07: 为多态基类声明virtual析构函数
1.若果class带有任何virtual函数，它就应该拥有一个virtual析构函数
2.class的设计目的不是作为base class使用或不是为了具备多态性，就不改声明为virtual析构函数
C++明确指出当derived对象经过base class指针被删除，而该base class带有一个non-virtual析构函数，则其结果未定义的：局部销毁。
每一个带有virtual函数的class都有一个相应的由函数指针构成的数组vtbl(virtual table). 当对象调用某一virtual函数，实际被调用的函数取决于该对象的vptr (virtual table pointer)所指的那个vtbl，编译器在其中寻找适当的函数指针。无端声明析构函数为virtual会增加为vptr的付出的空间补偿。
class SpecialString: public std::string{ //馊主意！
};
SpecialString *pss = new SpecialString(“aaa”);
std::string *ps=pss;
delete ps;//未定义！
如果企图继承一标准容器或任何其他带有non-virtual析构函数的class，拒绝诱惑吧！！！
为你希望成为抽象（不能实体化）的那个class声明一个pure virtual析构函数
class AWOV {
public: virtual ~AWOV() = 0;
};
必须提供一份定义 AWOV::AWOV() {}
不然派生类的析构函数调用base class的析构函数时，不然连接器会报错。
条款08:别让异常逃离析构函数
1.析构函数绝对不要吐出异常。如果一个被析构函数调用的函数可能突出异常，析构函数应该捕捉任何异常，然后吞下（不传播）或结束程序。
2.如果客户需要对某个操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数(而非析构函数中)执行该操作。
栈展开期间，释放局部对象所用的内存并运行类类型局部对象的析构函数。在执行析构函数前如果已经有一个异常，析构函数中又抛出一个异常，将会导致调用标准库 terminate 函数强制从程序非正常退出。
class DBConnection {
public : static DBConnection create();
void close();
};
确保DBConnection不忘记调用close()
class DBConn {
public:
~DBConn(){
db.close();}
private: DBConnection db;
};
DBConn dbc(DBConnection::create());
如果析构函数抛出异常：
1) 强迫结束
DBConn::~DBConn(){
try { db.close();}
catch(…) {
制作运转记录，记下对close的调用失败
std::abort();
}
2)吞下异常
DBConn::~DBConn(){
try { db.close();}
catch(…) {
制作运转记录，记下对close的调用失败
}
3）较佳的策略，客户自己调用普通函数
class DBConn {
public:
void close(){
db.close();
closed = true;
}
~DBConn(){
if(!closed) {
try { db.close(); }
catch(…){
制作运转记录，记下对close的调用失败
abort或吞下异常
}
}
private: DBConnection db;
bool closed;
}；
条款09:绝不在构造和析构函数中调用virtual函数
因为这类调用从不下降至derived class (比起当前执行构造函数和析构函数的那层)
class Transaciton {
public:Transaciton();
virtual void logTransaciton() const = 0;
};
Transaciton::Transaciton(){
logTransaciton();
}
class BuyTransaciton:public Transaciton{
public:
virtual void logTransaciton() const;
};
class SellTransaciton:public Transaciton{
public:
virtual void logTransaciton() const;
};
BuyTransaciton b; //基类构造函数调用的是Transaciton::logTransaciton();
BuyTransaciton专属成分还未初始化，最安全的做法就是视而不见，当成Transaciton类。
对象在derived class 构造函数开始执行前不会成为一个derived class。
析构函数类似,在进入base class 析构函数后对象就成为一个base class对象。
解决方案:令derived class 将必要的构造信息上传至base class构造函数，来替换无法使用virtul函数从base class向下调用。
class Transaciton {
public:
explicit Transaciton(const string &loginfo);
void logTransaciton(const string &loginfo) const;
};
Transaciton::Transaciton(const string &loginfo){
logTransaciton(loginfo);
}
class BuyTransaciton:public Transaciton{
public:
BuyTransaciton( parameters): Transaciton( createLogString(parameters)) {…}
private:
static string createLogString(parameters);
};
条款10: 令operator= 返回一个reference to *this
条款11: 在operator= 中处理自我赋值
class Bitmap {…};
class Widget {
private: Bitmap *pb;
};
Widget& Widget::operator=(const Widget &rhs) {
delete pb; //没有进行自我赋值检测
pb = new Bitmap(*rhs.pb);//不具备异常安全,发生异常后，pb指向一块已删除的内存
return *this;
}
解决：证同测试
Widget& Widget::operator=(const Widget &rhs) {//不具备异常安全
if (this == &rhs) return *this;
delete pb;
pb = new Bitmap(*rhs.pb);//不具备异常安全
return *this;
}
Widget& Widget::operator=(const Widget &rhs) {
Bitmap *pOrig = pb; //异常安全，又能处理自我赋值，当自我赋值发生频率较高时，可加入证同测试。
pb = new Bitmap(*rhs.pb);
delete pOrig;
return *this;
}
另一替换方案确保异常安全，又能处理自我赋值：copy and swap技术
class Widget{
void swap(Widget &rhs);
};
Widget& Widget::operator=(const Widget &rhs){
Widget temp(rhs);
swap(temp);
return *this;
}
Widget& Widget::operator=(const Widget rhs){ //另一较高效写法，by-value
swap(rhs);
return *this;
}
条款12: 复制对象时勿忘其每一个成分
1.copying 函数应该确保赋值”对象内所有成员变量”及“所有base class成分”
2.不要尝试以某个copying函数实现另一个copying函数。应该将共同机能放进第三个函数中，并由两个函数共同调用。
为derived class编写copying函数时，必须复制其base class成分。
class Customer {
public:
Customer(const Customer &rhs);
Customer& operator=(const Customer &rhs);
private: string name;
};
class PriorityCustomer: public Customer {
public:
priorityCustomer(const priorityCustomer &rhs);
priorityCustomer& operator=(const priorityCustomer &rhs);
private: int priority;
};
priorityCustomer::priorityCustomer(const priorityCustomer &rhs)
:Customer(rhs), //调用base class的copy构造函数，如省略，则调用默认的构造函数，基类部分为默认值
priority(rhs.priority)
{ }
priorityCustomer& priorityCustomer::operator=(const priorityCustomer &rhs) {
Customer::operator=(rhs); //可先进行证同测试，成员如有指针
priority = rhs.priority;
return *this;
}