C++面向对象编程<十二>转换函数、explicit、class几种表现形式

conservation function,转换函数

一个class类型转换为另外一个类型，如下例子

#include <iostream>

using namespace std;

class Fraction
{
    public:
        Fraction(int num, int den=1)
        : m_num(num), m_den(den) {}

        operator double() const 
        {
            return (double)m_num / m_den;
        } 
    private:
        int m_num;  //分子
        int m_den;  //分母 
};

{
    Fraction f(3,5);
    double d = 4 + f;
}

//编译器先寻找有没有一个全局的operator + 函数，结果没有，然后去找double类型转换，

返回类型呢？按道理说转换完后就是double，因此不用写，没有返回类型，也可以转换个string，写写看！

non-explicit-one-argument ctor

只要一个实参就够了，non-explicit的构造函数。
见下程序

#include <iostream>

using namespace std;

class Fraction
{
    public:
        Fraction(int num, int den=1)
        : m_num(num), m_den(den) {}

    Fraction operator + (const Fraction& f)
    {
        return Fraction(...);
    }
    private:
        int m_num;  //分子
        int m_den;  //分母 
};

{
    Fraction f(3,5);
    Fraction d2 = f + 4; // 调用non-explicit ctor将4转为Fraction(4,1), 然后调用operator+ 
}

下面的程序就会出错

#include <iostream>

using namespace std;

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

{
    Fraction f(3,5);
    Fraction d2 = f + 4; // error ambiguous
}

如果使用explicit-one-argument-ctor,见下程序

#include <iostream>

using namespace std;

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


{
    Fraction f(3,5);
    Fraction d2 = f + 4; // error conversion from 'double' to 'Fraction' requested
}

pointer-like classes,关于智能指针

就是class做的像pointer,但又希望它比pointer多些东西，这就是智能指针。首先，class里面一定有个真正的指针；其次，它得能代表一般的指针，因此就必须有指针的基本使用*和->,这需要操作符重载来实现。

pointer-like classes,关于迭代器

通过下面两张图来了解学习

function-like classes，所谓仿函数(functor)

设计一个class让它的行为像一个函数。函数是怎么样的呢？有个()（小括号），所做出的对象可以接受()。
标准库里有很多的仿函数，其实都是些class，里面有重载(),这样就称为仿函数了。如下图所示

图中打阴影部分的其实都有继承一些类，这里仅简单了解。