c++primer plus阅读笔记（二）

内联函数

内联函数与普通函数不同的是，内联函数直接将原函数拷贝到调用出，从而无须跳转，加快程序的运行速度

缺点是每一个调用处都需要有内联函数的拷贝，内存开销增大

在声明或定义前加上inline即可

inline void fn(a);

引用

引用在声明的时候必须要初始化，更像const指针，一旦与某个变量关联起来就不可改
(2) 可以有const指针，但是没有const引用；

(3) 指针可以有多级，但是引用只能是一级（int **p；合法 而 int &&a是不合法的）

(4) 指针的值可以为空，但是引用的值不能为NULL，并且引用在定义的时候必须初始化；

(5) 指针的值在初始化后可以改变，即指向其它的存储单元，而引用在进行初始化后就不会再改变了，从一而终。

(6)”sizeof引用”得到的是所指向的变量(对象)的大小，而”sizeof指针”得到的是指针本身的大小；

(7)指针和引用的自增(++)运算意义不一样；

模板函数

模板函数和非模板可以同型，选择的时候优先选择非模板函数

//基本类型
template <typename T>
T fn (T&e){ return e}

//类
template <class T>
T fn (T & e){return e}

//typename 和class的区别，大多数情况下，两者都是一样的
//但是在涉及到嵌套依赖类型的时候，typename就有用了
//在如下的代码中，编译器是无法确定T::iterator是一
//个变量还是说一个迭代器类型
template<class T>
void fn(const T &t){
    T::iteratir * a;
}

//这时候使用 typename，就可以说明这是一个类型了，而不是一个变量
template<class T>
void fn(const T &t){
    typename T::iteratir * a;
}

模板的隐式实例化与显示实例化，以及显示具体化

//模板函数本身不是函数定义
//当模板函数被调用的时候是根据运行时的参数确定类型的，
//从而生成一个函数定义又称为函数实例化,这是隐式实例化

template <typename T>
void swap(T& a,T& b){
    T temp=a;
    a=b;
    b=temp;
}

//与隐式实例化相对的是显示实例化，如下swap显示声明了T类型为int，或者调用的时候显示指定
//可以减少类型推测加速编译时的性能
template void swap<int>(int a,int b)；//创建

swap<double>(a,b);//声明

//显示具体化模板
//显示具体化函数是与模板相对的，当使用 job类型调用swap函数的时候,
//直接使用一下的函数定义，这是显示实例化
template<>
void swap(job& a,job& b){
    int temp=a.num;
    a.num=b.num;
    b.num=temp;
}

decltype

根据括号内的表达式确定值

//此时的temp是不知道什么类型的，有可能是T1,T2或者别的
template<class T1,class T2>
void fn(T1 a,T2 b){
    temp=a+b;
}
//C++11引入了新的关键字decltype
decltype(a+b) temp=a+b;//如果是表达式，则为表达式结果的临时表量的类型
decltype(fn2()) temp=a+b;//如果是函数，则为函数的返回变量的类型
decltype((a)) temp=a+b;//()返回的是一个常量值，如果是常量值，则返回的是该值类型的引用

auto与decltype的区别

int  a=8, b=3;
auto c=a+b;  //运行时需要实际执行a+b，哪怕编译时就能推导出类型
decltype(a+b)  d;  //编译期类型推导

//不可以用auto  c; 直接声明变量，必须同时初始化。

后置返回类型

//无法确定返回类型
template<class T1, class T2>
type? gt(T1 x,T2 y){
    ...
    return x+y;
} 

auto gt(T1 x,T2 y)->double{
    ...
    return;
}

auto gt (T1 x,T2 y)->decltype(x+y){
    ...
    return;
}