[侯捷]C++面向对象高级编程(下)笔记

自己写的笔记，记录一下为以后复习方便
视频课程地址：【侯捷】C++面向对象高级编程(下)-兼谈对象模型

一、conversion function，转换函数

转换函数是类成员函数，用来将对象类型转换为其他类型。

1、语法

operator type() const {
   }

type：要转换成的类型

const：因为转换函数只是转换对象类型，并不会（也不应该）改变对象内的任何成员，所以设为const

没有参数：转换不需要参数

没有返回类型：返回类型就是转换成的类型 type，编译器已经知道这一点了，所以为了防止程序员手抖写错，干脆规定不需要显示写出返回类型。

2、示例

class Fraction{
   
public:
	Fraction(int num, int den=1)
    : m_numerator(num), m_denominator(den){
   }
    operator double() const{
   
        return (double)m_numerator / m_denominator;
    }
private:
    int m_numerator;	// 分子
    int m_denominator;	// 分母
};

调用：

Fraction f(3, 5);
double d = 4 + f;	// 调用 conversion function

编译器如何编译 double d = 4 + f;

1）首先找有没有全局的 operator+(type, Fraction)函数，找到则编译通过（type 为整型或浮点型都可以）；

2）如果（1）走不通，则看 f 能否转成整型或浮点型（类中是否有相应的 conversion function），可以则编译通过。

二、non-explicit-one-argument constructor

one-argument ：只要一个实参就够了。

non-explicit：构造函数没有加关键字 explicit。

1、示例

class Fraction{
   
public:
	Fraction(int num, int den=1)
    : m_numerator(num), m_denominator(den){
   }
    
    Fraction operator+(const Fraction& f){
   
        return Fraction(...);
    }
private:
    int m_numerator;	// 分子
    int m_denominator;	// 分母
};

Fraction f(3, 5);
Fraction d2 = f + 4;	// 调用 non-explicit ctor 将 4 转为 fraction(4,1)

编译器如何编译 d2 = f + 4;：

1）编译器找到 Fraction 重载的 operator+函数，发现函数参数为 Fraction 类型，于是再看 4 能不能转成 Fraction 类型（隐式转换），由于 Fraction 有一个 non-explicit-one-argument ctor，因此转换成功，该行编译成功。

三、conversion function vs. non-explicit-one-argument ctor

当 以上两种共存时，编译器就懵逼了。

1、示例

class Fraction{
   
public:
	Fraction(int num, int den=1)
    : m_numerator(num), m_denominator(den){
   }
    operator double() const{
   
        return (double)m_numerator / m_denominator;
    }
    Fraction operator+(const Fraction& f){
   	// 测试时发现去掉 const 编译可通过？？
        return Fraction(...);
    }
private:
    int m_numerator;	// 分子
    int m_denominator;	// 分母
};

Fraction f(3, 5);
Fraction d2 = f + 4;	// [Error] ambiguous
						// 注释掉 operator+() 或者 operator double() 都可以编译成功

四、explicit-one-argument constructor

explicit：明白的，明确的。意思是告诉编译器不要再暗戳戳的搞事情了，在构造函数上（一般也只用在构造函数上）加上该关键字便意味着只能以构造函数的形式调用。

class Fraction{
   
public:
	explicit Fraction(int num, int den=1)
    : m_numerator(num), m_denominator(den){
   }
    operator double() const{
   
        return (double)m_numerator / m_denominator;
    }
private:
    int m_numerator;	// 分子
    int m_denominator;	// 分母
};

Fraction f(3, 5);
Fraction d2 = f + 4;	// [Error] conversion from 'double' to 'Fraction' requested

五、pointer-like classes

1、智能指针

这个类产生出的对象的表现像一个指针，但又比指针更聪明，即智能指针。

伪代码：

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