My effective C++

class Widget{
public:
    Widget& operator=(int rhs){return *this;}
}
a = b = c;

class Font; class FontHandle;
void changeFontSize(FontHandle f, int newSize){    }//需要调用的API

Font f(getFont());
int newFontSize = 3;
changeFontSize(f.get(), newFontSize);//显式的将Font转换成FontHandle

class Font{
    operator FontHandle()const { return f; }//隐式转换定义
}
changeFontSize(f, newFontSize)//隐式的将Font转换成FontHandle
但是容易出错，例如
Font f1(getFont());
FontHandle f2 = f1;就会把Font对象换成了FontHandle才能复制

int priority();
void processWidget(shared_ptr<Widget> pw, int priority);
processWidget(new Widget, priority());// 错误，这里函数是explicit的，不允许隐式转换（shared_ptr需要给他一个普通的原始指针
processWidget(shared_ptr<Widget>(new Widget), priority()) // 可能会造成内存泄漏

内存泄漏的原因为：先执行new Widget，再调用priority， 最后执行shared_ptr构造函数，那么当priority的调用发生异常的时候，new Widget返回的指针就会丢失了。当然不同编译器对上面这个代码的执行顺序不一样。所以安全的做法是：

shared_ptr<Widget> pw(new Widget)
processWidget(pw, priority())

inline const Rational operator * (const Rational &lhs, const Rational &rhs){
    return Rational(lhs.n * rhs.n, lhs.d * rhs.d);
} 当然这样写的代价就是成本太高，效率会比较低

class WebBrowser{
    public:
    void clearCache();
    void clearHistory();
    void removeCookies();
}

member 函数：
class WebBrowser{
    public:
    ......
    void clearEverything(){ clearCache(); clearHistory();removeCookies();}
}

non-member non-friend函数：
void clearBrowser(WebBrowser& wb){
    wb.clearCache();
    wb.clearHistory();
    wb.removeCookies();
}

"webbrowser.h"
namespace WebBrowserStuff{
    class WebBrowser{...};
    //所有用户需要的non-member函数
}

"webbrowserbookmarks.h"
namespace WebBrowserStuff{
    //所有与书签相关的便利函数
}

修改前代码：
class Widget{
    public:
    Widget& operator=(const Widget& rhs){
        *pImpl = *(rhs.pImpl);//低效
    }
    private:
    WidgetImpl* pImpl;
}

修改后代码：
namespace WidgetStuff{
    template<typename T>
    class Widget{
        void swap(Widget& other){
            using std::swap;      //此声明是std::swap的一个特例化，
            swap(pImpl, other.pImpl);
        }
    };
    ...
    template<typename T>           //non-member swap函数
    void swap(Widget<T>& a, Widget<T>& b){//这里并不属于 std命名空间
        a.swap(b);
    }    
}

修改前代码：
class Rectangle{
    public:
    Point& upperLeft() const { return pData->ulhc; }
    Point& lowerRight() const { return pData->lrhc; }
}
如果修改成：
class Rectangle{
    public:
    const Point& upperLeft() const { return pData->ulhc; }
    const Point& lowerRight() const { return pData->lrhc; }
}
则仍然会出现悬吊的变量，例如：
const Point* pUpperLeft = &(boundingBox(*pgo).upperLeft()); boundingBox会返回一个temp的新的，暂时的Rectangle对象，在这一整行语句执行完以后，temp就变成空的了，就成了悬吊的变量

原代码：
class Person{
private
    Dates m_data;
    Addresses m_addr;
}

添加一个Person的实现类，定义为PersonImpl，修改后的代码：
class PersonImpl;
class Person{
    private:
    shared_ptr<PersonImpl> pImpl;
}

class Person{
    public:
    virtual ~Person();
    virtual std::string name() const = 0;
    virtual std::string birthDate() const = 0;
} 然后通过继承的子类来实现相关的方法

class Student : public Person{...};

class Bird{
    virtual void fly();
}
class Penguin:public Bird{...};//企鹅是不会飞的

using Base::mf1;
或者
virtual void mf1(){//转交函数
    Base::mf1();
}
来解决，但是尽量不要出现这种遮蔽的行为

class Shape{
    virtual void draw() const = 0;
}
ps->Shape::draw(); 总结： + 接口继承和实现继承不同，在public继承下，derived classes总是继承base的接口 + pure virtual函数只具体指定接口继承 + 简朴的（非纯）impure virtual函数具体指定接口继承以及缺省实现继承 + non-virtual函数具体指定接口继承以及强制性的实现继承

class GameCharacter{
public:
    int healthValue() const{
        //做一些事前工作
        int retVal = doHealthValue();
        //做一些事后工作
        return retVal;
    }
private:
    virtual int doHealthValue() const{
        ...                   //缺省算法，计算健康函数
    }
} 这种方法的优点在于事前工作和事后工作，这些工作能够保证virtual函数在真正工作之前之后被单独调用

class GameCharacter; // 前置声明
int defaultHealthCalc(const GameCharacter& gc);
class GameCharacter{
public:
    typedef int (*HealthCalcFunc)(const GameCharacter&);//函数指针
    explicit GameCHaracter(HealthCalcFunc hcf = defaultHealthCalc):healthFunc(hcf){}//可以换一个函数的
    int healthValue()const{return healthFunc(*this);}
private:
    HealthCalcFunc healthFunc;
}

如果将函数指针换成函数对象的话，会有更具有弹性的效果：

typedef std::tr1::function<int (const GameCharacter&)> HealthCalcFunc;
在这种情况下，HealthCalcFunc是一个typedef，他的行为更像一个函数指针，表示“接受一个reference指向const GameCharacter，并且返回int*”，

D x;

B *pB = &x; pB->mf(); //调用B版本的mf
D *pD = &x; pD->mf(); // 调用D版本的mf

class Shape{
public:
    enum ShapeColor {Red, Green, Blue};
    virtual void draw(ShapeColor color=Red)const = 0;
};
class Rectangle : public Shape{
public:
    virtual void draw(ShapeColor color=Green)const;//和父类的默认参数不同
}
Shape* pr = new Rectangle; // 注意此时pr的静态类型是Shape，但是他的动态类型是Rectangle
pr->draw(); //virtual函数是动态绑定，而缺省参数值是静态绑定，所以会调用Red

template<class T>
class Set{
public: 
    void insert();
    //.......
private:
    std::list<T> rep;
}

class BorrowableItem{
    public:
    void checkOut();
};
class ElectronicGadget{
    bool checkOut()const;
};
class MP3Player:public BorrowableItem, public ElectronicGadget{...};
MP3Player mp;
mp.checkOut();//歧义，到底是哪个类的函数
只能使用：
mp.BorrowableItem::checkOut();

class Parent{...};
class First : public Parent(...);
class Second : public Parent{...};
class last:public First, public Second{...}; 当然，多重继承也有他合理的用途，例如一个类刚好继承自两个类的实现。

class Widget {
public:
    Widget();
    virtual ~Widget();
    virtual std::size_t size() const;
    void swap(Widget& other); //第25条
}

void doProcessing(Widget& w){
    if(w.size()>10){...}
}

template<typename T>
void doProcessing(T& w)
{
    if(w.size()>10){...}
} + 在上面这段代码中，w必须支持哪一种接口，由template中执行于w身上的操作来决定，例如T必须支持size等函数。这叫做隐式接口 + 凡涉及到w的任何函数调用，例如operator>，都有可能造成template具现化，使得调用成功，根据不同的T调用具现化出来不同的函数，这叫做编译期多态

template<typename C>
void print2nd(const C& container){
    if(container.size() >=2)
        typename C::const_iterator iter(container.begin());//这里的typename表示C::const_iterator是一个类型名称，
                                                           //因为有可能会出现C这个类型里面没有const_iterator这个类型
                                                           //或者C这个类型里面有一个名为const_iterator的变量
} 所以，在任何时候想要在template中指定一个嵌套从属类型名称（dependent names，依赖于C的类型名称），前面必须添加typename

class CompanyA{
public:
    void sendCleartext(const std::string& msg);
    ....
}
class CompanyB{....}

template <typename Company>
class MsgSender{
public:
    void sendClear(const MsgInfo& info){
        std::string msg;
        Company c;
        c.sendCleartext(msg);
    }
}
template<typename Company>//想要在发送消息的时候同时写入log，因此有了这个类
class LoggingMsgSender:public MsgSender<Company>{
    public:
    void sendClearMsg(const MsgInfo& info){
        //记录log
        sendClear(info);//无法通过编译，因为找不到一个特例化的MsgSender<company>
    }
}

template <> // 生成一个全特例化的模板
class MsgSender<CompanyZ>{  //和一般的template，但是没有sendClear,当Company==CompanyZ的时候就没有sendClear了
public:
    void sendSecret(const MsgInfo& info){....}
}

template<typename Company>
class LoggingMsgSender:public MsgSender<Company>{
    public:
    void sendClearMsg(const MsgInfo& info){
        //记录log
        this->sendClear(info);//假设sendClear将被继承
    }
}

template<typename Company>
class LoggingMsgSender:public MsgSender<Company>{
    public:

    using MsgSender<Company>::sendClear; //告诉编译器，请他假设sendClear位于base class里面

    void sendClearMsg(const MsgInfo& info){
        //记录log
        sendClear(info);//假设sendClear将被继承
    }
}

template<typename Company>
class LoggingMsgSender:public MsgSender<Company>{
    public:
    void sendClearMsg(const MsgInfo& info){
        //记录log
        MsgSender<Company>::sendClear(info);//假设sendClear将被继承
    }
}

template<typename T, std::size_t n>
class SquareMatrix{
    public:
    void invert();    //求逆矩阵
}

SquareMatrix<double, 5> sm1;
SquareMatrix<double, 10> sm2;
sm1.invert(); 
sm2.invert(); //会具现出两个invert并且基本完全相同

template<typename T>
class SquareMatrixBase{
    protected:
    void invert(std::size_t matrixSize);
}

template<typename T, std::size_t n>
class SquareMatrix:private SquareMatrixBase<T>{
    private:
    using SquareMatrixBase<T>::invert;  //避免遮掩base版的invert
    public:
    void invert(){ this->invert(n); }   //一个inline调用，调用base class版的invert
}

template<typename T, std::size_t n>
class SquareMatrix:: private SquareMatrixBase<T>{
    public:
    SquareMatrix():SquareMatrixBase<T>(n, 0), pData(new T[n*n]){
        this->setDataPtr(pData.get());
    }
    private:
    boost::scoped_array<T> pData; //存在heap里面
};

Top* pt2 = new Bottom; //将Bottom*转换为Top*是很容易的
template<typename T>
class SmartPtr{
    public:
    explicit SmartPtr(T* realPtr);
};
SmartPtr<Top> pt2 = SmartPtr<Bottom>(new Bottom);//将SmartPtr<Bottom>转换成SmartPtr<Top>是有些麻烦的

template<typename T>
class SmartPtr{
public:
    template<typename U>
    SmartPtr(const SmartPtr<U>& other)  //为了生成copy构造函数
        :heldPtr(other.get()){....}
    T* get() const { return heldPtr; }
private:
    T* heldPtr;                        //这个SmartPtr持有的内置原始指针
};

template<typename T>
const Rational<T> operator* (const Rational<T>& lhs, const Rational<T>& rhs){....}

Rational<int> oneHalf(1, 2);
Rational<int> result = oneHalf * 2; //错误，无法通过编译

template<typename T>
class Rational{
    public:
    friend const Rational operator*(const Rational& lhs, const Rational& rhs){
        return Rational(lhs.numerator()*rhs.numerator(), lhs.denominator() * rhs.denominator());
    }
};
template<typename T>
const Rational<T> operator*(const Rational<T>& lhs, const Rational<T>&rhs){....}

template<typename T>
struct iterator_traits;  //迭代器分类的相关信息
                         //iterator_traits的运作方式是，针对某一个类型IterT，在struct iterator_traits<IterT>内一定声明//某个typedef名为iterator_category。这个typedef 用来确认IterT的迭代器分类
一个针对deque迭代器而设计的class大概是这样的
template<....>
class deque{
    public:
    class iterator{
        public:
        typedef random_access_iterator_tag iterator_category;
    }
}
对于用户自定义的iterator_traits，就是有一种“IterT说它自己是什么”的意思
template<typename IterT>
struct iterator_traits{
    typedef typename IterT::iterator_category iterator_category;
}
//iterator_traits为指针指定的迭代器类型是：
template<typename IterT>
struct iterator_traits<IterT*>{
    typedef random_access_iterator_tag iterator_category;
}

template<typename IterT, typename DistT>
void doAdvance(IterT& iter, DistT d, std::random_access_iterator_tag){ iter += d; }//用于实现random access迭代器
template<typename IterT, typename DistT>
void doAdvance(IterT& iter, DistT d, std::bidirectional_iterator_tag){ //用于实现bidirectional迭代器
    if(d >=0){
        while(d--)
            ++iter;
    }
    else{
        while(d++)
            --iter;
    }
}

template<typename IterT, typename DistT>
void advance(IterT& iter, DistT d){
    doAdvance(iter, d, typename std::iterator_traits<IterT>::iterator_category());
} 使用一个traits class: + 建立一组重载函数（像劳工）或者函数模板（例如doAdvance），彼此间的差异只在于各自的traits参数，令每个函数实现码与其接受traits信息相应 + 建立一个控制函数（像工头）或者函数模板（例如advance），用于调用上述重载函数并且传递traits class所提供的信息

template<unsigned n>
struct Factorial{
    enum{
        value = n * Factorial<n-1>::value
    };
};
template<>
struct Factorial<0>{
    enum{ value = 1 };
};                       //这就是一个计算阶乘的元编程

void* Widget::operator new(std::size_t size) throw(std::bad_alloc){
    NewHandlerHolder h(std::set_new_handler(currentHandler));      // 安装Widget的new-handler
    return ::operator new(size);                                   //分配内存或者抛出异常，恢复global new-handler
}

char* pc = 0;  //设置指针为空值
char& rc = *pc;//让引用指向空值，很危险！！！

class BST{...}
class BalancedBST : public BST{...}

void printBSTArray(const BST array[]){
    for(auto i : array){
        std::cout << *i;
    }
}

BalancedBST bBSTArray[10];
printBSTArray(bBSTArray);

class EP{
public:
    EP(int ID);
}

EP bestP[] = {
    EP(ID1),
    EP(ID2),
    ......
} 函数数组的方法，或者是指针：

typedef EP* PEP;
PEP bestPieces[10];
PEP *bestPieces = new PEP[10];然后使用的时候再重新new来进行初始化

// 有理数类
class Rational{
public:
    Rational(int numerator = 0, int denominator = 1)
    operator double() const;
}

Rational r(1, 2);
double d = 0.5 * r; //将r转换成了double进行计算

cout << r; //会调用最接近的类型转换函数double，将r转换成double打印出来，而不是想要的1/2，

double asDouble() const;这样就可以直接用了

template<class T>
class Array{
public:
    Array(int size);
    T& operator[](int index);
};

bool operator==(const Array<int> &lhs, const Array<int> & rhs);
Array<int> a(10), b(10);
if(a == b[3]) //想要写 a[3] == b[3]，但是这时候编译器并不会报错，解决方法是使用explicit关键字

explicit Array(int size); 
if(a == b[3]) // 错误，无法进行隐式转换

class Array { 
public:  
    class ArraySize {                    // 这个类是新的 
        public: 
        ArraySize(int numElements):theSize(numElements){}
        int size() const { return theSize;}
    private: 
        int theSize;
    };
    Array(int lowBound, int highBound); 
    Array(ArraySize size);                  // 注意新的声明
    ... 
}; 

string *ps = new string("Memory Management"); //使用的是new操作符，这个操作符像sizeof一样是内置的，无法改变

void* operator new(size_t size); // new操作，可以重写这个函数来改变如何分配内存

void* rawMemory = operator new(sizeof(String));

class Widget{
    public:
        Widget(int widgetSize);
    ....
};

Widget* constructWidgetInBuffer(void *buffer, int widgetSize){
    return new(buffer) Widget(widgetSize);
}

BookEntry::BookEntry(){
    theImage     = new Image(imageFileName);
    theAudioClip = new AudioClip(audioClipFileName);
}
BookEntry::~BookEntry(){
    delete theImage;
}

BookEntry::BookEntry(){
    try{
        theImage     = new Image(imageFileName);
        theAudioClip = new AudioClip(audioClipFileName);
    }
    catch(...){
        delete theImage;
        delete theAudioClip;
        //上面一段代码和析构函数里面的一样，所以可以直接封装成一个成员函数cleanup：
        cleanup();
        throw;
    }
}

class BookEntry{
public:......
private:
    const auto_ptr<Image> theImage;
    const auto_ptr<AudioClip> theAudioClip;
}

Session::~Session(){
    logDestruction(this);
    endTransaction(); //结束database transaction,如果上面一句失败的话，下面这句就没办法正确执行了
}

void f1(Widget w); catch子句：    

catch(widget w)... 

catch(Widget w);
catch(Widget& w);
catch(const Widget& w);

void f(int value){
    try{
        throw value; //value可以是int也可以是double等其他类型的值
    }
    catch(double d){
        ....         //这里只处理double类型的异常，如果遇到int或者其他类型的异常则不予理会
    }
}

void someFunction(){
    static exception ex;
    throw &ex;
}
void doSomething(){
    try{
        someFunction();
    }
    catch(exception *ex){...}
} 创建堆对象抛出异常：new exception 不会出现异常失效的问题，但是会出现在捕捉以后是否应该删除他们接受的指针，在哪一个层级删除指针的问题 通过值捕获异常：不会出现上述问题，但是会在被抛出时系统将异常对象拷贝两次，而且会出现派生类和基类的slicing problem，即派生类的异常对象被作为基类异常对象捕获时，会把派生类的一部分切掉，例如：

class exception{
public:
    virtual const char *what() throw();
};
class runtime_error : public exception{...};
void someFunction(){
    if(true){
        throw runtime_error();
    }
}
void doSomething(){
    try{
        someFunction();
    }
    catch(exception ex){
        cerr << ex.what(); //这个时候调用的就是基类的what而不是runtime_error里面的what了，而这个并不是我们想要的
    }
}

void someFunction(){...} //和上面一样
void doSomething(){
    try{...}             //和上面一样
    catch(exception& ex){
        cerr << ex.what(); //这个时候就是调用的runtime_error而不是基类的exception::what()了，其他和上面其实是一样的
    }
}

extern void f1();    //f1可以抛出任意类型的异常
void f2() throw(int);//f2只能抛出int类型的异常
void f2() throw(int){ 
     f1();           //编译器会因为f1和f2的异常规格不同而在发出异常的时候调用unexpected
}

template<class T>
bool operator==(const T& lhs, const T&rhs) throw(){
    return &lhs == &rhs;
} 这个模板为所有的类型定义了一个操作符函数operator==对于任意一对相同类型的对象，如果有一样的地址，则返回true，否则返回false，单单这么一个函数可能不会抛出异常，但是如果有operator&重载时，operator&可能会抛出异常，这样就违反了异常规则，让程序跳转到unexpected

class UnexpectedException{}; //所有的unexpected异常对象都被替换成这种对象
void convertUnexpected(){       //如果一个unexpected异常被抛出，这个函数就会被调用
    throw UnexpectedException();
}
set_unexpected(convertUnexpected); 替换unexpected函数：

void convertUnexpected(){ //如果一个unexpected异常被抛出，这个函数被调用
    throw;                //只是重新抛出当前的异常
}
set_unexpected(convertUnexpected);//安装convertUnexpected作为unexpected的替代品，此方法应该在所有的异常规格里面包含bad_exception

class String{....}
String s1 = "Hello";
String s2 = s1;  //在正常的情况下，这一句需要调用new操作符分配堆内存，然后调用strcpy将s1内的数据拷贝到s2里面。但是我们此时s2并没有被使用，所以我们不需要s2，这个时候如果让s2和s1共享一个值，就可以减小这些开销

String s = "Homer's Iliad";
cout << s[3];
s[3] = 'x'; 首先调用operator[] 用来读取string的部分值，但是第二次调用该函数式为了完成写操作。读取效率较高，写入因为需要拷贝，所以效率较低，这个时候可以推迟作出是读操作还是写操作的决定。

Matrix<int> m1(1000, 1000), m2(1000, 1000);
m3 = m1 + m2;
因为矩阵的加法计算量太大（1000*1000）次计算，所以可以先用表达式表示m3是m1和m2的和，然后真正需要计算出值的时候再真的进行计算（甚至计算的时候也只计算m3[3][2]这样某一个位置的值）

size_t countChar(const string& str, char ch);
char buffer[MAX_STRING_LEN];
cout << countChar(buffer, c);

inline const Rational operator*(const Rational& lhs, const Rational& rhs{
    return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
}

class UPInt{
    public:
    UPInt();
    UPInt(int value);
}
const UPInt operator+(const UPInt& lhs, const UPInt& rhs);
upi3 = upi1 + upi2;
upi3 = 10 + upi1;  // 会产生隐式类型转换，转换过程中会出现临时对象
upi3 = upi1 + 10;

const UPInt operator+(const UPInt& lhs, const UPInt& rhs);
const UPInt operator+(const UPInt& lhs, int rhs);
const UPInt operator+(int lhs, const UPInt& rhs);

template<class T>
const T operator+(const T& lhs, const T& rhs)
{
    return T(lhs) += rhs;
}
template<class T>
const T operator-(const T& lhs, const T& rhs){
    return T(lhs) -= rhs; 
}

class C1{
public:
    C1();
    virtual ~C1();
    virtual void f1();
    virtual int f2(char c)const;
    virtual void f3(const string& s);
    void f4()const
}

 ___
|___| → ~C1()
|___| → f1()
|___| → f2()
|___| → f3()

 __________
|__________| → 存放类的数据
|__________| → 存放vptr

pC1->f1(); 他的本质是：

(*pC1->vptr[i])(pC1);

class NewsLetter{
private:
    static NLComponent *readComponent(istream& str);
    virtual NLComponent *clone() const = 0;
};
NewsLetter::NewsLetter(istream& str){
    while(str){
        components.push_back(readComponent(str));
    }
}
class TextBlock: public NLComponent{
public:
    virtual TextBlock*clone()const{
        return new TextBlock(*this);
    }
} 在上面那段代码当中，readComponent就是一个具有构造函数行为（因为能够创建出新的对象）的函数，我们叫做虚拟构造函数

NewsLetter::NewsLetter(const NewsLetter& rhs){
    while(str){
        for(list<NLComponent*>::const_iterator it=rhs.component.begin(); it!=rhs.component.end();it++){
            components.push_back((*it)->clone());
        }
    }
} 这样每一个TextBlock都可以调用他自己的clone，其他的子类也可以调用他们自己对应的clone()

class Printer{
public:
    friend Printer& thePrinter();或者static Printer& thePrinter();
private:
    Printer();
    Printer(const Printer& rhs);
};
Printer& thePrinter(){
    static Printer p;
    return p;
} 上面这段代码中，Printer类的构造函数是private，可以阻止建立对象，全局函数thePrinter被声明为类的友元，让thePrinter避免私有构造函数引起的限制

template <class BeingCounted>
class Counted{
public:
    class TooManyObjects{};
    static int objectCount(){return numObjects;}
protected:
    Counted();
    Counted(const Counted& rhs);
    ~Counted(){ --numObjects; }
private:
    static int numObjects;
    static const size_t maxObjects;
    void init();                 //避免构造函数的代码重复
};

template<class BeingCounted>
Counted<BeingCounted>::Counted(){init();}

template<class BeingCounted>
Counted<BeingCounted>::Counted(const Counted<BeingCounted>&){init();}

template<class BeingCounted>
void Counted<BeingCounted>::init(){
    if(numObjects >= maxObjects)throw TooManyObjects();
    ++numObjects;
}

class Printer:private Counted<Printer>{
public:
    static Printer* makePrinter(); // 伪构造函数
    using Counted<Printer>::objectCount;
    using Counted<Printer>::TooManyObjects;
} **27. 要求或禁止对象分配在堆上**

class UPNumber{
public:
    class HeapConstraintViolation{};
    static void* operator new(size_t size);
    UPNumber();
private:
    static bool onTheHeap;
}; 实际上上面这段代码是跑不了的，因为如果使用new[]创造数组的话就没有办法用了

bool onHeap(const void *address) { 
    char onTheStack; // 局部栈变量，因为他是新的变量，所以比他小的都在堆或者静态空间里面，比他大的都在栈里面
    return address < &onTheStack; 
}

template<class T>
T* SmartPtr<T>::operator->()const{
    return pointee;
}

SmartPtr<TreeNode> ptn;
if(ptn == 0)... //error
if(ptn)... //error
if(!ptn)... //error 所以需要进行隐式类型转换操作符，才能够进行上面的操作

template<class T>
class SmartPtr{
public:
    operator void*();
};
SmartPtr<TreeNode> ptn;
if(ptn == 0) //现在正确
if(ptn) //现在正确
if(!ptn) //现在正确

class MusicProduct{....};
class Cassette:public MusicProduct{....};
class CD:public MusicProduct{....};
displayAndPlay(const SmartPtr<MusicProduct>& pmp, int numTimes);

SmartPtr<Cassette> funMusic(new Cassette("1234"));
SmartPtr<CD> nightmareMusic(new CD("143"));
displayAndPlay(funMusic, 10); // 错误!
displayAndPlay(nightmareMusic, 0); // 错误! 我们可以看到的是，如果没有隐式转换操作符的话，是没有办法进行转换的，那么解决方法就是添加一个操作符,：

class SmartPtr<Cassette>{//或者用模板来代替
public:
    operator SmartPtr<MusicProduct>(){
        return SmartPtr<MusicProduct>(pointee);
    }
}; smart pointer 和 const：

SmartPtr<CD> p; //non-const 对象 non-const 指针
SmartPtr<const CD> p; //const 对象 non-const 指针
const SmartPtr<CD> p = &goodCD; //non-const 对象 const 指针
const SmartPtr<const CD> p = &goodCD; //const 对象 const 指针

template<class T>      // 指向const对象的
class SmartPtrToConst{ //灵巧指针
    ...                // 灵巧指针通常的成员函数
protected:
    union {
        const T* constPointee; // 让 SmartPtrToConst 访问
        T* pointee; // 让 SmartPtr 访问
    };
};

template<class T> // 指向 non-const 对象的灵巧指针
class SmartPtr: public SmartPtrToConst<T> {
    ... // 没有数据成员
};

template<class T>
class Array2D{
public:
    Array2D(int dim1, int dim2);
    class Array1D{
    public:
        T& operator[](int index);
        const T& operator[](int index) const;
    };
    Array1D operator[](int index);
    const Array1D operator[](int index) const;
};
Array2D<int> data(10, 20);
cout << data[3][6] //这里面的[][]运算符是通过两次重载实现的

class String{
public:
    class CharProxy{
    public:
        CharProxy(String& str, int index);
        CharProxy& operator=(const CharProxy& rhs);
        CharProxy& operator=(char c);
        operator char() const;
    private:
        String& theString;
        int charIndex;
    };
    const CharProxy operator[](int index) const;//对于const的Strings
    CharProxy operator[](int index);            //对于non-const的Strings

    friend class CharProxy;
private:
    RCPtr<StringValue> value;
};

class GameObject{....};
class SpaceShip : public GameObject{....};
class SpaceStation : public GameObject{....};
class Asteroid : public GameObject{....};

void checkForCollision(GameObject& object1, GameObject& object2){
    processCollision(object1, object2);
}

class GameObject{
public:
    virtual void collide(GameObject& otherObject) = 0;
};
class SpaceShip:public GameObject{
public:
    virtual void collide(GameObject& otherObject);
};

void SpaceShip:collide(GameObject& otherObject){
    const type_info& objectType = typeid(otherObject);
    if(objectType == typeid(SpaceShip)){
        SpaceShip& ss = static_cast<SpaceShip&>(otherObject);
    }
    else if(objectType == typeid(SpaceStation)).......
} 只使用虚函数：

class SpaceShip; // forward declaration
class SpaceStation;
class Asteroid;
class GameObject { 
public:
    virtual void collide(GameObject&   otherObject) = 0;
    virtual void collide(SpaceShip&    otherObject) = 0;
    virtual void collide(SpaceStation& otherObject) = 0;
    virtual void collide(Asteroid&     otherObject) = 0;
    ...
}; 模拟虚函数表（对继承体系中的函数做一些修改）：

class SpaceShip : public GameObject { 
public:
    virtual void collide(GameObject&   otherObject);
    virtual void hitSpaceShip(SpaceShip&    otherObject);
    virtual void hitSpaceStation(SpaceStation& otherObject);
    virtual void hitAsteroid(Asteroid&     otherObject);
    ...
}; 初始化模拟虚函数表：

class GameObject { // this is unchanged 
public: 
    virtual void collide(GameObject& otherObject) = 0;
    ...
};

class SpaceShip: public GameObject {
public:
    virtual void collide(GameObject& otherObject);
    // these functions now all take a GameObject parameter
    virtual void hitSpaceShip(GameObject& spaceShip);
    virtual void hitSpaceStation(GameObject& spaceStation);
    virtual void hitAsteroid(GameObject& asteroid);
    ...
};

SpaceShip::HitMap * SpaceShip::initializeCollisionMap(){
    HitMap *phm = new HitMap;
    (*phm)["SpaceShip"] = &hitSpaceShip;
    (*phm)["SpaceStation"]= &hitSpaceStation;
    (*phm)["Asteroid"] = &hitAsteroid;
    return phm; 
}

class Animal{
public:
    virtual Animal& operator=(const Animal& rhs);
    ....
};
class Lizard:public Animal{
public:
    virtual Lizard& operator=(const Animal& rhs);
};
class Chicken:public Animal{
public:
    virtual Chicken& operator=(const Animal& rhs);
} 则会出现我们不愿意出现的类型转换和赋值：

Animal *pAnimal1 = &liz;
Animal *pAnimal2 = &chick;
*pAnimal1 = *pAnimal2;      //把一个chick赋值给了一个lizard

class AbstractAnimal{
protected:
    AbstractAnimal& operator=(const AbstractAnimal& rhs);
public:
    virtual ~AbstractAnimal() = 0;
};

class Animal: public AbstractAnimal{
public:
    Animal& operator=(const Animal& rhs);
};
class Lizard:public AbstractAnimal{
public:
    virtual Lizard& operator=(const Animal& rhs);
};
class Chicken:public AbstractAnimal{
public:
    virtual Chicken& operator=(const Animal& rhs);
}

extern 'C'
void drawLine(int x1, int y1, int x2, int y2);

int main(int argc, char *argv[]){
    performStaticInitialization();

    realmain();

    performStaticDestruction();
} 动态内存分配：C++时候new和delete，C是malloc和free

auto x = 27; // 情况3（x既不是指针也不是引用）
const auto cx = x; // 情况3（cx二者都不是）
const auto& rx = x; // 情况1（rx是一个非通用的引用）

auto&& uref1 = x; // x是int并且是左值，所以uref1的类型是int&
auto&& uref2 = cx; // cx是int并且是左值，所以uref2的类型是const int&
auto&& uref3 = 27; // 27是int并且是右值， 所以uref3的类型是int&& 在花括号初始化的时候，推倒的类型是std::initializer_list的一个实例，但是如果把相同的类型初始化给模板，则是失败的，

auto x = { 11, 23, 9 }; // x的类型是std::initializer_list<int>
template<typename T> void f(T param); // 和x的声明等价的模板
f({ 11, 23, 9 }); // 错误的！没办法推导T的类型

template<typename T> void f(std::initializer_list<T> initList);
f({ 11, 23, 9 }); // T被推导成int，initList的类型是std::initializer_list<int>

template<typename Container, typename Index> // works, but requires refinements
auto authAndAccess(Container& c, Index i) -> decltype(c[i])
{
    authenticateUser();
    return c[i];
}
在上面的这段代码里面，C++14可以把后面的->decltype(c[i])删掉，但是auto实际推倒的类型是container而不带引用。因为 authAndAccess(d, 5) = 10这样是编译器不允许的情况。 如果想要返回引用的话，需要将上面的那一段代码重写成下面的样子：

template<typename Container, typename Index> // works, but still requires refinements
decltype(auto) authAndAccess(Container& c, Index i)
{
    authenticateUser();
    return c[i];
} 如果想要这个函数既返回左值（可以修改）又可以返回右值（不能修改）的话，可以用下面的写法：

template<typename Container, typename Index>
decltype(auto) authAndAccess(Container&& c, Index i){//C++14
    authenticateUser();
    return std::forward<Container>(c)[i];
} decltype的一些让人意外的应用：

decltype(auto) f2(){
    int x = 0 ;
    return x;     // 返回的是int;
}
decltype(auto) f2(){
    int x = 0;
    return (x);   //返回的是int&
}

std::vector<bool> features(const Widget& w);
Widget w;
auto highPriority = features(w)[5]

processWidget(w, highPriority); // 未定义的行为，因为这个时候highPriority已经不是bool类型的了，这个时候返回的是一个std::vector<bool>::reference对象（内嵌在std::vector<bool>中的对象） 如果用：

bool highPriority = features(w)[5];的时候，因为编译器看到bool，所以会发生隐式转换，将reference转换成bool类型 当然也有强制变成bool 的方法：

auto highPriority = static_cast<bool>(features(w)[5]);

double x, y, z;
int sum1{x+y+z}; //错误，因为double之和可能无法用int表达（超出int范围）

class Widget{
    int x{0}; //right
    int y = 0;//right
    int z(0); //错！
};

std::atomic<int> ai2(0); //right
std::atomic<int> ai3 = 0; //错！

Widget w1(10); //调用w1的构造函数

class Widget{
public:
    Widget(int i, bool b);
    Widget(std::initializer_list<long double> il);
};

Widget w1(10, true); //调用第一个构造函数
Widget w2{10, true}; //调用第二个构造函数

// FP等价于一个函数指针，这个函数的参数是一个int类型和
// std::string常量类型，没有返回值
typedef void (*FP)(int, const std::string&); // typedef
// 同上
using FP = void (*)(int, const std::string&); // 声明别名 并且类型别名可以实现别名模板，而typedef不行：

template<typname T> // MyAllocList<T>
using MyAllocList = std::list<T, MyAlloc<T>>; // 等同于std::list<T,MyAlloc<T>>
MyAllocList<Widget> lw; // 终端代码 模板别名还避免了::type的后缀，在模板中，typedef还经常要求使用typename前缀：

template<class T>
using remove_const_t = typename remove_const<T>::type

constexpr auto arraySize = 10;
std::array<int, arraySize> data2;

class Polynomial{
public:
    using RootsType = std::vector<double>;
    RootsType roots() const{
        if(!rootAreValid){
            rootsAreValid = true;
        }
        return rootVals;
    }
private:
    mutable bool rootsAreValid{false};
    mutable RootsType rootVals{};
}

class Point{
public:
    double distanceFromOrigin() const noexcept{
        ++callCount;
        return std::sqrt((x*x) + (y * y));
    }    
private:
    mutable std::atomic<unsigned> callCount{0};
    double x, y;
};

auto spw = std::make_shared<Widget>();//spw 被构造之后被指向的Widget对象的引用计数为1(欲了解std::make_shared详情，请看Item21)
std::weak_ptr<Widget> wpw(spw);//wpw和spw指向了同一个Widget,但是RC(这里指引用计数，下同)仍旧是1
spw = nullptr;//RC变成了0，Widget也被析构，wpw现在处于悬挂状态
if(wpw.expired())... //如果wpw悬挂... 那么虽然weak_ptr看起来没什么用，但是他其实也有一个应用场合（用来做缓存）：

std::unique_ptr<const Widget> loadWidget(WidgetID id); //假设loadWidget是一个很繁重的方法，需要对这个方法进行缓存的话，就需要用到weak_ptr了：

std::shared_ptr<const Widget> fastLoadWidget(WidgetId id){
    static std::unordered_map<WidgetID,
    std::weak_ptr<const Widget>> cache;
    auto objPtr = cache[id].lock();//objPtr是std::shared_ptr类型指向了被缓存的对象(如果对象不在缓存中则是null)
    if(!objPtr){
        objPtr = loadWidget(id);
        cache[id] = objPtr;
    }   //如果不在缓存中，载入并且缓存它
    return objPtr;
} + std::weak_ptr 用来模仿类似std::shared_ptr的可悬挂指针 + 潜在的使用 std::weak_ptr 的场景包括缓存，观察者列表，以及阻止 std::shared_ptr 形成的环

class Widget{ //still in header "widget.h"
public:
    Widget();
    ~Widget(); //dtor is needed-see below
private:
    struct Impl; //declare implementation struct and pointer to it
    std::unique_ptr<Impl> pImpl;
}

#include "widget.h" //in impl,file "widget.cpp"
#include "gadget.h"
#include <string>
#include <vector>
struct Widget::Impl{
    std::string name; //definition of Widget::Impl with data members formerly in Widget
    std::vector<double> data;
    Gadget g1,g2,g3;
}
Widget::Widget():pImpl(std::make_unique<Impl>())
Widget::~Widget(){} //~Widget definition，必须要定义，如果不定义的话会报错误，因为在执行Widget w的时候，会调用析构，而我们并没有声明，所以unique_ptr会有问题

template<typename T>
typename remove_reference<T>::type&& move(T&& param){
    using ReturnType = typename remove_reference<T>::type&&; //see Item 9
    return static_cast<ReturnType>(param);
}

void f(Widget&& param);       //rvalue reference
Widget&& var1 = Widget();     //rvalue reference
auto&& var2 = var1;           //not rvalue reference
template<typename T>
void f(std::vector<T>&& param) //rvalue reference
template<typename T>
void f(T&& param);             //not rvalue reference

Widget MakeWidget(){
    Widget w;
    return w; //复制，需要调用一次拷贝构造函数
}

Widget MakeWidget(){
    Widget w;
    return std::move(w);//错误！！！！！！！会造成负优化
}

template<typename T>
void log(T&& name){}

void log(int name){}

short a;
log(a);

class Person{
public:
    template<typename T> explicit Person(T&& n): name(std::forward<T>(n)){} //完美转发构造函数
    explicit Person(int idx); //形参为int的构造函数

    Person(const Person& rhs) //默认拷贝构造函数（编译器自动生成）
    Person(Person&& rhs); //默认移动构造函数（编译器生成）
};

Person p("Nancy");
auto cloneOfP(p);  //会编译失败，因为p并不是const的，所以在和拷贝构造函数匹配的时候，并不是最优解，而会调用完美转发的构造函数

template<typename T>
void func(T&& param);

Widget WidgetFactory() //返回右值
Widget w;

func(w);               //T的推到结果是左值引用类型，T的结果推倒为Widget&
func(WidgetFactory);   //T的推到结果是非引用类型（注意这个时候不是右值），T的结果推到为Widget C++中，“引用的引用”是违法的，但是上面T的推到结果是Widget&时，就会出现 void func(Widget& && param);左值引用+右值引用

template<typename T>
void fwd(T&& param){           //接受任意实参
    f(std::forward<T>(param)); //转发该实参到f
}

template<typename... Ts>
void fwd(Ts&&... param){        //接受任意变长实参
    f(std::forward<Ts>(param)...);
}

（大括号初始化物）
f({1, 2, 3}); //没问题，{1, 2, 3}会隐式转换成std::vector<int>
fwd({1, 2, 3}) //错误，因为向为生命为std::initializer_list类型的函数模板形参传递了大括号初始化变量，但是之前说如果是auto的话，会推到为std::initializer_list,就没问题了。。。

（0和NULL空指针）
（仅仅有声明的整形static const 成员变量）：
class Widget{
public:
    static const std::size_t MinVals = 28; //仅仅给出了声明没有给出定义
};
fwd(Widget::MinVals);      //错误，应该无法链接，因为通常引用是当成指针处理的，而也需要指定某一块内存来让指针指涉

（重载的函数名字和模板名字）
void f(int (*fp)(int));
int processValue(int value);
int processValue(int value, int priority);
fwd(processVal); //错误，光秃秃的processVal并没有类型型别

（位域）
struct IPv4Header{
    std::uint32_t version:4,
    IHL:4,
    DSCP:6,
    ECN:2,
    totalLength:16;
};

void f(std::size_t sz); IPv4Header h;
fwd(h.totalLength); //错误 + 最后，所有的失败情形实际上都归结于模板类型推到失败，或者推到结果是错误的。

 _____           ___返回值___  std::promise _______
|调用方|<--------|被调用方结果|<------------|被调用方|

while(!flag){}

bool flag(false);
std::lock_guard<std::mutex> g(m);
flag = true;

std::promise<void> p;
void react();    //反应任务
void detect(){  //检测任务
    std::thread t([]{
        p.get_future().wait();
        react();           //在调用react之前t是暂停状态
    });
    p.set_value();  //取消暂停t
    t.join();       //把t置为unjoinable状态
}