在读《c++primer》的过程中，遇到一些知识点，做一下简单的备忘
c++中函数接受的参数是引用类型的情况下，传递引用的限制非常的严格：
举个例子：
例如，定义函数swap(),实现两个数字值的交换：
#include <iostream>
#include <cstddef> // inlude ptrdiff_t
#include <vector>
using namespace std;
void swap(int& a, int& b); // 定义函数交换两个数的值
int main(int argc, char *argv[])
{
int a1 = 2;
int a2 = 3;
cout << "Before swap a=" << a1 << " and b=" << a2 << endl;
swap(a1, a2);
cout << "After swap a=" << a1 << " and b=" << a2 << endl;
cout << "-------------------------------" << endl;
long b1 = 5;
long b2 = 6;
cout << "Before swap a=" << b1 << " and b=" << b2 << endl;
swap(b1, b2);
cout << "After swap a=" << b1 << " and b=" << b2 << endl;
return 0;
}
void swap(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}
运行结果：
书中提到，在第二种情况下，早期c++规则比较宽松，这样的操作不能实现两个数值的交换，因为实参和形参的类型不是严格的匹配，所以编译器将创建两个临时的变量，将long类型的变量转化为int,再赋值给临时变量，所以实际上swap()中进行操作的是临时变量，所以并没有实现变量的值交换。
所以总结是： 如果接受引用参数的函数的意图是修改作为参数传递的变量，则创建临时变量将阻止这种意图的实现，所以应该避免这种临时变量的创建
（但是再我的c++编译器下，还是成功实现了数值交换）
将引用用于结构和类：
为了提高程序的效率，在应用结构和类的时候，传递和返回参数的形式一般会使用引用，而不是按值传递，因为按值传递要栈用额外的空间和时间。再返回引用时需要注意一些问题：
例如：
// 定义一个结构
struct free_throw
{
string name;
int age;
int grade;
}
const free_throw& copy(free_throw& ft)
{
free_throw cp; // cp是一个临时变量
cp = ft;
return cp; // 返回一个临时变量的引用
}
上面的函数返回一个临时变量的引用，但是临时变量在函数执行完毕后已经销毁，所以这个引用是不存在的。同理，函数也应该避免返回临时变量的指针。
解决方法：
1. 返回作为参数传递给函数的引用：
const free_throw& copy(free_throw& ft)
{
free_throw *pt; // cp是一个指针变量
*pt = ft; // pt指向ft
return *pt; // 返回传入参数的引用
}
2. 使用new分配新的内存空间，返回内存的地址
但是这种方法隐含了对new()的调用，使得很容易忘记使用delete释放内存
但是可以使用智能指针来解决这种隐含的情况：
函数重载：
函数签名，函数特征标(function signature), 函数参数列表
函数重载中需要注意的条目：
1. 编译器将类型的引用和类型本身视为同一个特征标：
例如：
double cube(double x);
double cube(double& x); // invalid
例如上面的情形就是不合法的函数重载
2. 函数匹配时，将不区分const和非const变量
// const与非const的区别
const char p1[20] = "Hello the piano";
char p2[20] = "Hello the macro";
//函数重载
void dribble(char* p);
void dribble(const char* p); // 函数重载
void dabble(char* bits);
void drive(const char* p);
dribble(p1); // 匹配const参数的函数
dribble(p2); // 匹配非const参数的函数
// 非const赋给const是合法的
// const赋给非const是不合法的
dabble(p1); // invalid 参数不匹配
drive(p2); // 参数匹配
名称修饰：
c++通过名称修饰来跟踪每一个重载函数。他根据函数型原型中指定的形参类型对每个函数名进行加密。
例如：
long myFunc(int, float)被编译器加密为？myFunc@@YAXH
函数模板：
函数模板是通用的函数描述，它使用泛型来定义函数，其中的泛型可以用具体的类型来替代。由于类型是用参数表示的，因此模板特性也被称为参数化类型。
实际上，模板并不创建函数，而只是告诉编译器如何定义函数。在实际使用时只需要按照实际传入的参数创建函数。
重载的模板：
可以向像重载常规函数那样重载模板定义。
模板的局限性:
某一些类型的操作可能没有定义，例如，对于结构体，没有+-*/的操作。
解决方案：
1. c++允许对一些运算符进行重载，重载运算符即可
2. 为特定类型提供具体化的模板定义
具体化机制介绍：
第三代具体化：（c++98 具体化方法)
1. 对于给定的函数名，可以有非模板函数，模板函数，显示具体化模板函数以及他们的重载
2. 显式具体化的原型和定义以template< >开头，并通过名称来指出类型。
3. 具体化优先于常规模板，非模板函数优先于具体化和常规模板， 即 非模板函数 > 显式具体化 > 模板函数
举一个具体的例子：
// no template function prototype
void swap(job& a, job& b);
// template function prototype
template <typename T>
void swap(T& a, T& b);
// explicit speciallization 显式具体化
template <> void swap<job>(job& a, job& b);
例如，要实现swap函数，对两个结构体进行交换操作：
#include <iostream>
using namespace std;
// template function prototype
template <typename T>
void swap(T& a, T& b);
struct job
{
char name[40];
double salary;
int floor;
};
// explicit speciallization 显式具体化
template <> void swap<job>(job& a, job& b);
int main()
{
cout.precision(2); // 设置输出精度
cout.setf(ios::fixed, ios::floatfield);
int n1 = 10;
int n2 = 20;
cout << "n1 =" << n1 << " n2 " << n2 << endl;
swap(n1, n2);
cout << "n1 =" << n1 << " n2 " << n2 << endl;
p1 = {"zhangsna",
45.36,
89
} ;
p2 = {
"wangwu",
45.3,
90
}
swap(p1, p2);
return 0;
}
// function defination
template<typename T>
void swap(T& a, T&b)
{
T temp;
temp = a;
a = b;
b = temp; // 结构体允许这样做
}
template <> void swap<job>(job& a, job& b)
{
double temp1;
int temp2;
temp1 = a.salary;
a.salary = b.salary;
b.salary = temp1;
temp2 = a.floor;
a.floor = b.floor;
b.floor = temp2;
}
函数模板的发展：
模板带来的问题:
1. 在编写模板时，并非总能知道在声明中使用哪种类型：
例如：
template<typename T1, typename T2>
void ft(T1 x, T2 y)
{
...
?type? sum = x+y;
....
}
那么sum因该是什么类型呢，这个与传入的参数的类型是有关的。因此在c++98中没有办法声明sum的类型。
2.decltype关键字
c++11通过decltype关键字来提供解决方案
int x;
decltype(x) y; // 定义y的类型与x相同
所以，上面的函数可以改写为：
template<typename T1, typename T2>
void ft(T1 x, T2 y)
{
...
decltype(x+y) sum;
sum = x+y;
....
}
decltype的实际运作原理：
假设有如下声明：
decltype(expression) var;
为了确定类型，编译器会遍历一个核对表：
第一步: 如果expression是一个没有用括号括起来的标识符，和var的类型和标识符的类型相同，包括const等限定符
例如：
double x = 9.0;
double y = 7.9;
double& rx = x;
const double* pd;
decltype(x) w; // w double
decltype(rx) u = y; // u double&
decltype(pd) v; // v double*
第二步：如果expression是函数调用，则var的类型和函数返回值的类型相同
long indeed(int);
decltype (indeed(3)) y; // y long
这一操作并不会实际调用函数，编译器只是通过查看函数的原型来获取返回值的类型。
第三步：如果expression为一个左值，则var为其引用类型
例如：
double xx = 4.4;
decltype ((xx)) r2 = xx; // r2 double&
decltype (xx) w = xx; // w double
第四步：如果前面的都不满足，则var的类型与expression的类型相同
int j = 4;
int& m = j;
int& n = j;
decltype(j+6) w; // w int
decltype(m+n) u; // u int; 虽然mn都是引用，但是m+n是两个int的和，所以u的类型为int
同时，如果需要多次申明，可结合和typedef使用：
template<typename T1, typename T2>
void ft(T1 x, T2 y)
{
...
typedef decltype(x+y) xytype;
xytype sum;
xytype a1;
sum = x+y;
....
}
decltype无法解决的问题：
具有返回值的模板函数：
例如：
template<typename T1, typename T2>
?type? gt(T1 x, T2 x)
{
...
return x+y;
...
}
无法预先知道参数x,y的类型，所以返回值的类型无法确定，此时还不能使用decltype(x+y)来说明返回值类型，因为此时参数x,y还不再作用域内，必须在声明参数后使用decltype:
C++提供了后置返回类型来解决这种问题：
使用auto：
auto h(int x, float y)->double
{
...
//function body;
...
}
auto在这里相当于一个占位符，表示后置返回类型提供的类型。
所以上述问题的解决方案可以为：
template<typename T1, typename T2>
auto gt(T1 x, T2 x) -> decltype(x+y)
{
...
return x+y;
...
}
现在参数x,y位于作用域内，所以可以使用它们。
----------------------------------------------------------------------------------------------------------