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'
- pointer-like classes
典型应用：1. 智能指针
只能指针的基本功能应该重载 * 和 -> 这两个操作符，和相应的构造析构函数
典型应用：2. 迭代器
迭代器提供对一个容器中的对象的访问方法，并且定义了容器中对象的范围
重点注意operator->操作符重载，为了能够实现 ite->mothed(),这样调用，所以ite->要返回数据的指针，所以是先operator*()，获取到数值，然后，然后再&获取指针
- 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
- partial Specialization
偏特化分为两种：个数上的偏特化和范围上的偏特化
8.template template parameter
一个模板定义的template中不是自定义或基础数据类型，而是另一个模板
例如下面例子中，XCLs模板中，有两个typename
其中一个是T的模板，基础类型或者自定义类型
另一个是模板类，这个模板类的只有一个typename，并且他的T和XCLs的第一个typename类型一样
