1.尽量以const,enum,inline替换#define
例如：
# define ASPECT_RATIO 1.653
const double AspectRatio=1.653
宏定义在编译前被预处理，编译器看不见
2.尽量使用const
在实际使用中,const对象大多用于passed by pointer-to-const或passed by
reference-to-const的传递结果
const对象调用const方法,non-const对象调用non-const方法，这种效率太低，
需要non-const对象调用const方法(转型)
例：
class TextBlock{
public:/*...*/
const char & operator[](std::size_t position) const//一如既往
{/*...*/ return text[position];}
char & operator[](std::size_t position)//现在只调用const op[]
{
return const_cast<char &>(static_cast<const TextBlock &>(*this)[position]);
}
}
3.确定对象被使用前已先被初始化
c++规定，对象的成员变量的初始化动作发生在进入构造函数本体之前，构造函数的一个
较佳写法是，使用所谓的member initialization list（成员初值列）替换赋值动作。
例：
ABEntry::ABEntry(const std::string &name,const std::string &address,
const std::list<PhoneNumber> & phones)
:theName(name),theAddress(address),thePhones(phones),numTimeConsulted(0)
{}//构造函数本体不必有任何动作，通常效率高
4.如果不想使用编译器提供的函数
为驳回编译器自动提供的机能，可将相应的成员函数声明为private并且不予实现。使用像Uncopyable
这样的base class 也是一种做法。
class Uncopyable{
protected://允许derived对象构造和析构
Uncopyable(){};
~Uncopyable(){};
private:
Uncopyable(const Uncopyable&);//阻止copy
Uncopyable & operator=(const Uncopyable &));
};//只需继承这个类
5.为多态基类声明virtual析构函数
1.当derived class对象经由一个base class指针被删除，而该base class带着一个non-virtual析构函数，
其结果未有定义——实际上执行时通常发生的是对象的derived成分没被销毁。
2.如果class不含virtual函数，通常表示它并不意图被用做一个base class。如果class带有任何virtual
函数，它就应该拥有一个virtual析构函数。
6.析构函数绝对不要吐出异常
1.如果一个被析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后吞下它们（不传播）
或结束程序。
2.如果客户需要对一个操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数
（而非在析构函数中）执行该操作。
7.绝不在构造和析构过程中调用virtual函数
由于base class构造函数的执行更早于derived class构造函数，当base class构造函数执行时，
derived class的成员变量尚未初始化。
8.令operator=返回一个reference to *this
class Widget{
public:
Widget & operator=(const Widget & rhs){
/*...*/
return *this;
}
};
9.在operator=中处理“自我赋值”
class Widget{
/*...*/
public:
void swap(Widget &rhs);//交换*this和rhs是数据
};
Widget &Widget::operator=(const Widget &rhs)
{
Widget temp(rhs);//为rhs数据制作一份副本
swap(temp);//将*this数据和上述副本的数据交换
return *this;
}
10.让接口容易被正确使用，不易被误用
比较安全的写法是预先定义所有有效的Months
class Month{
public:
static Month Jan(){return Month(1);}
/*...*/
static Month Dec(){return Month(12);}
private:
explicit Month(int m);//阻止生成新的月份
/*...*/
};
Date d(Month::Mar(),Day(30),Year(1995));
11.宁以pass-by-reference-to-const替换pass-by-value
减少复制，提高效率
12.必须返回对象时，别妄想返回其reference
错误1：
const Rational & operator*(const Rational &lhs,const Rational &rhs)
{
Rational result(lhs.n*rhs.n,lhs.d*rhs.d);
return result;//引用的是已被销毁的local对象
}
错误2：
const Rational & operator*(const Rational &lhs,const Rational &rhs)
{
Rational *result=new Rational(lhs.n*rhs.n,lhs.d*rhs.d);
return *result;
}//问题：必须付出一个“构造函数调用”代价，同时如何对new出来的对象实施delect?
正确写法：
inline const Rational operator*(const Rational &lhs,const Rational &rhs)
{
return Rational(lhs.n*rhs.n,lhs.d*rhs.d);
}
绝不要返回pointer或reference指向一个local stack对象，或返回reference 指向
一个heap-allocated对象，或返回pointer或reference指向一个local static对象
而有可能同时需要多个这样的对象。
13.将成员变量声明为private,protected并不比public更具有封装性
14.宁以non-member，non-friend替换member函数
15.使用非成员函数（non-member）处理函数的所有参数都需要类型转换
因为成员函数的发起者必须是类，若出现double类型在前的情况，则无法执行乘法，
所以应使用非成员函数。
例：
class Rational{
public:
Rational(double numerator=0,double denominator=1)
:m_n(numerator),m_d(denominator){}
double numerator() const{return m_n;}
double denominator() const{return m_d;}
double value(){return (m_n/m_d);}
private:
double m_n;
double m_d;
};
const Rational operator *(const Rational &lhs,const Rational &rhs)
{
return Rational(lhs.numerator()*rhs.numerator(),lhs.denominator()*rhs.denominator());
}
16.inline函数
inline函数背后的整体观念是，将“对此函数的每一个调用”都以函数本体替换之。
17.绝对不要重新定义继承而来的non-virtual函数
18.如果派生类的函数与基类函数同名，但是参数不同。
此时，无论其有无virtual关键字，基类的函数将被隐藏。
19.如果派生类的函数与基类函数同名，而且参数也相同。
基类没有关键字，此时基类的函数被隐藏。
20.c++纯虚函数
virtual void function()=0;
21.new 和 malloc的区别
(1)new是c++中的操作符，malloc是c中的一个函数
(2)new不止是分配内存，而且会调用类的构造函数，同理delect会调用类的析构函数，
而malloc则只分配内存，不会进行初始化类成员的工作，同样free也不会调用析构函数
(3)new出来的指针是直接带类型信息的，而malloc返回的都是void指针