C++面向对象的程序设计(OOP)(下)

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

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的+

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

代理模式

template
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 sp(new Foo);
Foo f(*sp);    /
B b;
A a = (A)b;
a.vfunc1; //通过对象调用，静态绑定


A* pa = new B;
pa->vfunc1();
pa = &b;
pa->vfunc1();

const 修饰成员函数（放在参数列后面，body前面），不能修饰全局函数。
const属于签名的一部分。

当成员函数dd额const和non-const版本同时存在，const object只能调用const版本，non-const object只能调用non-const版本。

常量字符串一定不会更改内容，共享时不必考虑 copy on write，

通过对象调用函数，对象的地址就是this
所有成员函数都有一个隐藏的this pointer