转换函数 conversion function

转出去

 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_m_denominator;  //分母 
};

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

• Fraction f(3,5);会调用构造函数

• double d = 4 + f;会调用 operator double() ，将f转换为0.6，此为转出去

---

转回来

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

• 调用non-explicit ctor将4转为Fraction(4,1),因为整数分母都可以是1 然后调用operator+ 此为转回来

---

                 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
      }

• 上面程序是错误的，因为有俩条路可走，编译器无法识别

---

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
}

• 使用explicit 时，4不会被调用成4/1，在只有单个参数的函数中考虑添加explicit

---

智能指针 pointer-like classes

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

迭代器 pointer-like classes

利用了操作符重载

---

仿函数 function-like classes

• 他们对操作符（）进行重载，至于小括号里面做什么要看设计
• 标准库中的其他仿函数都继承了binary_function和unary_function

---

namespace 经验谈

• 多个工程师之间共同研发为了防止命名冲突

---

成员模板 member template

• class就是个模板，而成员里还有个模板。T1、T2可以变化，U1、U2也可以变化。

• 指针是指向下面的，这是合理的，如有个指向动物的指针，你让它指向猪、猫都行。既然指针可以，智能指针也必须可以。有点多态的意思。

---

模板特化 specialization

• 泛化就是模板，特化的意思就是指你作为一个设计者，你可能要面对一些特殊的类型要单独处理。
  解释：上面的是泛化，下面的是特化。且下面的都对()进行重载。

---

模板偏特化 partial specialization

要从左到右，不能跳着来

• 个数的偏

---

• 范围上的偏特化，如下，T是任意类型，现在把它范围缩小成指针

---

模板模板参数 template template parameter

• 本身是一个模板参数，在模板里面又有模板，关于 typename和class的共通问题，只有在template<typename> 里面两个关键字才共通，模板模板参数一般用在模板里面需要传入一个容器，那容器本身也需要是一个模板，就会有两个模板的嵌套。

---

数量不定的模板参数 variadic templates

QQ图片20161021235444.png

• 把输入的模板和输入的变量分为一个和一包，然后利用迭代把所有不同类型的数据同时处理。从左到右一个一个放

---

auto

• 编译器自动推到类型，要有右值，不能依赖

---

range-base for

• 有点类似 for each遍历容器元素并赋值给一个变量

---

reference

• 之前讲过，含义是一个数据的别名，可以视作是漂亮的指针，通常在传参和函数返回值中使用，编译器实际上处理它是四个字节

---