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

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();

迭代器

用来遍历容器。

仿函数(function-like classes)

重载operator()

模板

reference

int x = 0;
int* p = &x;
int& r = x;     //r代表x,引用要设初值，且不能变。
sizeof(r) == sizeof(x)
&r == &x

object 和其 reference 的大小相同，地址也相同（全都是假象）。

虚指针（vptr）和虚表（vtbl）

只要类里面虚函数，类里就会有一根指针（虚指针）。
虚指针（vptr）指向一个虚函数表（vtbl），虚函数表里面放的函数指针，指向虚函数的位置。

p = new C;
//通过p调用vfunc1()
(*(p->vptr)[n])(p)
(*p->vptr[n])(p)	

指针指向什么类型，就调用该类型对应的虚函数。调用的时候不用管它是什么类型。
静态绑定
动态绑定：通过指针；虚函数；向上转型

多态

/*关于动态绑定*/
B b;
A a = (A)b;
a.vfunc1; //通过对象调用，静态绑定


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

const

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

	const object	non-const object
const member function	√	√
non-const member function	×	√

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

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

this

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