【Boolan】第四周笔记

1.conversion function
转换函数，用作类型转换，编译器可以自动调用，当然也可以显示调用，C风格的(type)value, C++风格的static_cast<type>value 都是可以的，需要注意的是如果类已经有转换函数，就不需要在写这个类与要转换的类的运算符重载了，因为会出现二义性
2.non-explicit-one-argument ctor
没有指定明确调用的单一参数的构造函数

Fraction的构造函数有两个参数，但是有一个是默认参数，所以可以等同是单一参数的构造函数，
    编译器在执行`f+7`的时候，会先想办法
    首先匹配到重载的`Fraction operator+(const Fraction &f)`，但是只适用于`Fraction`类之间运算，然后编译器就试着把`4`转换位`Fraction`类，
    于是发现`Fraction`有一个`non-explicit-one-argument ctor`，并且参数刚好是`int`类型，所以就进行了隐示转换，把`4`转换成`Fraction`类，
    之后在调用`Fraction operator+(const Fraction &f)`,返回一个新的`Fraction`.

能够把4转换成Fraction类，是因为Fraction的构造函数没有声明explicit，即该构造函数只能显示调用，不能进行隐示调用

    operator double() const {
        return (double)(m_numerator/m_denominator);
    }
此时添加Fraction转double的转化函数， 编译器就不会通过了，因为`f+4`既可以使用操作符重载，也可以使用隐式类型转换，具有二义性ambiguous

如果此时把Fraction的构造声明为explicit，因为Fraction的构造不能隐式调用，还会报错：cannot convert from 'double' to 'class Fraction'

3. pointer-like classes
   典型应用：1. 智能指针

只能指针的基本功能应该重载 * 和 -> 这两个操作符，和相应的构造析构函数

典型应用：2. 迭代器

迭代器提供对一个容器中的对象的访问方法，并且定义了容器中对象的范围
重点注意operator->操作符重载，为了能够实现 ite->mothed(),这样调用，所以ite->要返回数据的指针，所以是先operator*()，获取到数值，然后，然后再&获取指针

4. function-like classes
   仿函数就是类重载了() 操作符
   5.template
   典型应用：1. function template 函数模板

与class template不同，function template在使用的时候并不需要指定类型，而是编译器会对function template进行实参推导argument deduction, 确定类型

#include <iostream>

template <class T>
inline 
const T& MyMin(const T&a, const T&b)
{
    return b < a ? b : a;
}

int main(int argc, char *argv[])
{
    int a = 10, b = 20;
    std::cout << MyMin(a,b) << std::endl;

    return 0;
}

典型应用：2. member template

简单点来说就是类成员某些参数需要模板

#include <iostream>

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

    T* operator-> () const {
        return _px;
    }

    explicit shared_ptr(T* p) : _px(p) { std::cout << "shared_ptr(T* p)" <<std::endl;}

    template <typename _Tp1>
    explicit shared_ptr(_Tp1* p)
    :_px(p)
    {std::cout << "shared_ptr(_Tp1* p)" <<std::endl;    }

    ~shared_ptr(){ delete _px; }
private:
    T*      _px;
};

class A
{
    //..
};

class B : public A 
{
    //..
};

int main(int argc, char *argv[])
{
    B * pa = new B;
    shared_ptr<A> pSA(new B);

    return 0;
}

6.Specialization

就是在一个模板类里面，为某几种已知的类进行单独处理
下面以函数模板举例，对int进行模板特化

template <class T>
inline 
const T& MyMin(const T&a, const T&b)
{
    std::cout << "const T& MyMin(const T&a, const T&b)" <<std::endl;
    return b < a ? b : a;
}

template <>
inline 
const int& MyMin<int>(const int&a, const int&b)
{
    std::cout << "const int& MyMin<int>(const int&a, const int&b)" <<std::endl;
    return b < a ? b : a;
}

int main(int argc, char *argv[])
{
    std::cout << MyMin(10,20) << std::endl;
    std::cout << MyMin(100.2, 200.3) << std::endl;;

    return 0;
}

////////////////////////////////
const int& MyMin<int>(const int&a, const int&b)
10
const T& MyMin(const T&a, const T&b)
100.2    

7. partial Specialization
   偏特化分为两种：个数上的偏特化和范围上的偏特化
   8.template template parameter
   一个模板定义的template中不是自定义或基础数据类型，而是另一个模板
   例如下面例子中，XCLs模板中，有两个typename
   其中一个是T的模板，基础类型或者自定义类型
   另一个是模板类，这个模板类的只有一个typename，并且他的T和XCLs的第一个typename类型一样