More Effective C++ 条款28 Smart Pointers(智能指针)

template<class T>
class auto_ptr {
public:
    ...
    auto_ptr(auto_ptr<T>& rhs); 
    auto_ptr<T>&  operator=(auto_ptr<T>& rhs); 
    ...
};
template<class T>
auto_ptr<T>::auto_ptr(auto_ptr<T>& rhs)
{
    pointee = rhs.pointee; 
    rhs.pointee = 0; // 转移对象所有权
} 
template<class T>
auto_ptr<T>& auto_ptr<T>::operator=(auto_ptr<T>& rhs)
{
    if (this == &rhs) // 自我赋值的情况
        return *this; 
    delete pointee; 
    pointee = rhs.pointee; // 转移对象所有权
    rhs.pointee = 0; 
    return *this;
}

void printTreeNode(ostream& s, auto_ptr<TreeNode> p)
{ s << *p; }
int main(){
    auto_ptr<TreeNode> ptn(new TreeNode);
    ...
    printTreeNode(cout, ptn); //通过传值方式传递auto_ptr
    ...
}

template<class T>
SmartPtr<T>::~SmartPtr()
{
    if (*this owns *pointee) {
        delete pointee;
    }
}

template<class T>
T& SmartPtr<T>::operator*() const
{
    perform "smart pointer" processing;
    return *pointee;
}

template<class T>
T& SmartPtr<T>::operator*() const{
    if(number of reference!=1){
        pointee=new T(*pointee);
        --reference number of the old object;
        set the reference number of the new object to 1; 
    }
    return *pointee;
}

if (ptn == 0) ... // 正确
if (ptn) ... // 正确
if (!ptn) ... //正确

SmartPtr<Apple> pa;
SmartPtr<Orange> po;
...
if (pa == po) ...//可以通过编译

SmartPtr<TreeNode> ptn;
...
if (!ptn) { 
    ...
}
else {
    ... 
}

template<class T>
class DBPtr {
public:
    ...
    operator T*() { return pointee; }
    ...
};

class Tuple{...};
void processTuple(DBPtr<Tuple>& pt)
{
    Tuple *rawTuplePtr = pt; // 得到内置指针
    use rawTuplePtr to modify the tuple
}

class TupleAccessors {
public:
    TupleAccessors(const Tuple *pt); // Tuple到TupleAccessor的转换
    ... 
};
TupleAccessors merge(const TupleAccessor& ta1,const TupleAccessors& ta2);
DBPtr<Tuple> pt1, pt2;
...
merge(pt1,pt2);//调用会出错

class DBPtr {
public:
    ...
    T* toPrimary() { return pointee; }
    ...
};

class MusicProduct {
public:
    MusicProduct(const string& title);
    virtual void play() const = 0;
    virtual void displayTitle() const = 0;
    ...
};
class Cassette: public MusicProduct {
public:
    Cassette(const string& title);
    virtual void play() const;
    virtual void displayTitle() const;
    ...
};
class CD: public MusicProduct {
public:
    CD(const string& title);
    virtual void play() const;
    virtual void displayTitle() const;
    ...
}
void displayAndPlay(const MusicProduct* pmp, int numTimes)
{
    for (int i = 1; i <= numTimes; ++i) {
    pmp->displayTitle();
    pmp->play();
}

Cassette *funMusic = new Cassette("Alapalooza");
CD *nightmareMusic = new CD("Disco Hits of the 70s");
displayAndPlay(funMusic, 10);
displayAndPlay(nightmareMusic, 0);

void displayAndPlay(const SmartPtr<MusicProduct>& pmp,int numTimes);
SmartPtr<Cassette> funMusic(new Cassette("Alapalooza"));
SmartPtr<CD> nightmareMusic(new CD("Disco Hits of the 70s"));
displayAndPlay(funMusic, 10); // 错误!
displayAndPlay(nightmareMusic, 0); // 错误!

class SmartPtr<Cassette> {
public:
    operator SmartPtr<MusicProduct>()
    { return SmartPtr<MusicProduct>(pointee); }
    ...
private:
    Cassette *pointee;
};
class SmartPtr<CD> {
public:
    operator SmartPtr<MusicProduct>()
    { return SmartPtr<MusicProduct>(pointee); }
    ...
private:
    CD *pointee;
};

template<class T> 
class SmartPtr { 
public:
    SmartPtr(T* realPtr = 0);
    T* operator->() const;
    T& operator*() const;
    template<class newType> // 模板成员函数
    operator SmartPtr<newType>() 
    {
        return SmartPtr<newType>(pointee);
    }
    ...
};

template<class T>
class SmartPtr { ... }; 
void displayAndPlay(const SmartPtr<MusicProduct>& pmp,
int howMany);
void displayAndPlay(const SmartPtr<Cassette>& pc,
int howMany);
SmartPtr<CasSingle> dumbMusic(new CasSingle("Achy Breaky Heart"));
displayAndPlay(dumbMusic, 1);//错误，隐式类型转换函数的调用具有二义性

CD goodCD("Flood");
const CD *p; // p 是一个non-const 指针,指向 const CD 对象
CD * const p = &goodCD; // p 是一个const 指针,指向non-const CD 对象;因为 p 是const,它必须在定义时就被初始化
const CD * const p = &goodCD; // p 是一个const 指针,指向一个 const CD 对象

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> 
class SmartPtr: public SmartPtrToConst<T> {
public:
    template<class constType>
    operator SmartPtrToConst<constType>();
    ... //没有额外数据成员
};