一 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);
} //转换函数，需要将Fraction转换为double时候调用，函数名为需要转换的类型，不可以有参数
private:
int m_numerator; //分子
int m_denominator; //分母
{
Fraction f(3,5)
double d=4+f; //调用operator double（）将 f 转为0.6
}
使用的时候，当编译器运行到double=4+f时会先看看有没有一个全局函数作了+的重载操作并且参数为整数和Fraction类型，如果没有就调用operator double（）将f转换为double类型，使得编译能通过。
转换函数标准库一个应用（代理）：
二 non-explicit-one-argument（实参） ctor
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)
double d=f+4; //调用non-explicit ctor将 4 转为Fraction（4，1）
//然后调用operator+
}
Fraction叫做non-explicit-one argument。它有两个parameter，只要一个argument就够了。它可以将别的东西转换为Fraction。
conversion function vs non-explicit-one-argument ctor
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){
return Fraction(......);
}
private:
int m_numerator;
int m_denominator;
{
Fraction f(3,5)
double d=f+4; //ERROR ambiguous
}
如上代码所示同时写conversion function和non-explicit-one-argument ctor，运行到double d=f+4将会产生歧义，编译器报错。
explicit-one-argument ctor
class Fraction
{
public:
explict 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){
return Fraction(......);
}
private:
int m_numerator;
int m_denominator;
{
Fraction f(3,5)
double d=f+4; //ERROR conversion from 'double' to 'Fraction' requested
}
explict一般只有用在构造函数前面。表示明确，不允许编译器将4看作是4/1，所以运行到double d=f+4时报错，无法将4转换成Fraction。
三 pointer-like-classes，关于智能指针
一个c++的class可能像两种东西：
（1）像指针；
（2）像函数。
像指针，要比指针多做一点东西，叫智能指针（C++ 2.0之前有个auto pointer，之后又出现很多）。
智能指针一定含有一般的指针，一定要写*和—>重载，写法一定如图所示。
迭代器（一种智能指针）主要用来遍历容器：
四 function-like classes，所谓仿函数
（1）设计一个class让它的行为像一个函数，函数有一个函数名称，用一个括号作用，小括号叫做function call operator,任何一个东西能够接受小括号这个操作符，我们叫这个东西为函数或者像函数的东西。
（2）标准库有很多仿函数，都是小小的class，里面有重载小括号。这些仿函数都继承一些大小为0的父类，作用不作详述，比较复杂。
五 namespace经验谈
避免不同单位使用相同函数名，导致混乱。
六 class template
为了不限制类的成员变量的类型，采用模板的形式定义成员变量，等以后需要的用的时候再定义数据类型。
七 Function Template
关键字class和typename是相通的。函数模板用的时候，编译器会对它进行实参推导，不用加尖括号。函数模板里面<的重载由设计stone类的人去设计，这是合理的，编译器是不知道如何比大小的。
八 Member Template
既是模板的成员，自己本身又是template。
把鲫鱼和麻雀构成的pair当成初值塞到鱼类和鸟类构成的pair，反之不行。
在标准库大量的类的构造函数应用，使得构造函数更有弹性。
new一个鲫鱼，指针指向鱼类，这个叫做up-cast。
九 specialization
面对独特的类型而设计叫做特化（全特化）。
template<class Key>
struct hash { }; //泛化，指定任意类型都跑到这里，除了特化的几个类型
template<> //被绑定，括号里面为空，指定类型char会跑到这段代码，int、long雷同
struct hash<char>{
size_t operator() (char x) const { return x;}
};
template<>
struct hash<int>{
size_t operator() (int x) const { return x;}
};
template<>
struct hash<long>{
size_t operator() (int x) const { return x;}
};
{
cout<<hash<long>()(1000);
//空的小括号表示浅绿色的是一个临时对象，带有参数的小括号表示启动operator（）函数。
}
十 模板偏特化
局部特化（偏特化）：
（1）个数偏：
如图例，两个模板参数，其中一个T被绑定为bool（bool比int节约8倍空间），绑定顺序从左边到右边，不能跳数。
（2）范围偏：
任意类型T缩小范围成指针（指向任何类型）。
十一 模板模板参数
模板参数本身又是一个模板，下图黄色部分。
模板模板参数：容器list里面的模板参数是外面模板的参数。图示用法XCl<string,list> mylst1;过不了语法因为容器有好几个参数，只不过平时用的时候有默认值没有写。
解决方法：如图Lst代码。
unique_ptr和weak_ptr有好几参数。
list已经被绑定，不是模板参数，所以该段代码（deque<T>)不是模板模板参数。
十二 关于C++标准库
C++标准库，C++ Standard Library，是类库和函数的集合，其使用核心语言写成，在C++开发中，要尽可能地利用标准库完成。
十三 三个主题
1 variadic templates （since C++11）
（1）数量不定的模板参数，...表示包，图示代码print打印出第一个参数，剩下的再调用print，如此递归直到最后一个打印出来，包数量为0，无任何参数输入，则调用上方无参数的print。
（2）sizeof...（args）可以知道包的数量。
2 auto （since C++11）
3 ranged-base for （since C++11）
要使elem*3影响原来的值，则要传引用。用auto可以不知道elem什么类型，偷懒。
十四 Reference
int x=0;
int* p=&x; //一个变量p，它的类型是指向整型的指针
int& r=x; //一个变量r，它的类型是指向整型的引用。r代表x。现在r，x都是0
int x2=5;
r=x2; //r不能重新代表物体。现在r，x都是5
int& r2=r; //现在r2是5（r2代表r；亦相当于代表x）
（1）引用常用来作传递参数类型和返回类型，它和直接传参数写法相同，调用接口相同，但是更加快。
（2）signature叫做“签名”。
（3）灰色部分const是函数签名的一部分。
十五 复合&继承关系下的构造和析构
第三周笔记有写，这里不再赘述。
链接：http://www.jianshu.com/p/ca6613dd4c8d
