1 转换函数(cnversion function)

把这种类型转换成别的类型

class Fraction{
    int m_num;    //分子
    int m_den;  //分母
public:
    Fraction(int num, int den=1): m_num(num), m_den(den){ }
    operator double() const { return (double)..;}//转出，const
};
Fraction f(3,5);
double d= 4 + f;//f对象调用operator double() 转成0.6，调用double的+

2 non-explicit-one-argument constructor

non-explicit
one-argument只要一个实参就够了。
explicit(明白的) 写在构造函数前面，以构造函数的形式，需要的时候再调用。

class Fraction{
public:
    Fraction(int num, int den=1): m_num(num), m_den(den){ }  //转出
    operator double() const { return (double)..;}//转出，const
    Fraction operator+(const Fraction& f) {return f;}
};

Fraction f(3,5);
Fraction d= 4 + f;//调用non-explicit constructor将4转成Fraction，再operator+
/*
当转入转出并存时，有两个可行的选择，出现歧义，编译器报错。
*/
explicit Fraction(int num, int den=1){} //该构造函数只做构造函数使用.编译器不要自动去调用它。
Fraction f(3,5);
Fraction d= 4 + f;//报错conversion from ‘double’ to 'Fraction' requests

代理模式

pointer-like classes

智能指针

template<class T>
class shared_ptr{
    T *px;
public:
    T& operator* () const {return *px;}
    T* operator->() const {return px;}
    shared_ptr(T* p): px(p) {}
};//shared_ptr

struct Foo{void method(void) {}}
//call
shared_ptr<Foo> sp(new Foo);
Foo f(*sp);    //*作用在sp上，得到*px，*已经使用掉。
sp->method();    //->作用于sp上，还能继续使用，因此得到px->method()
//传递调用px->method();