C++学习（4）函数部分

auto 和 typedef 关键词的用法：

#include <iostream>
using namespace std;
int main()
{
	auto x = "xxx";//代替几乎所有类型
	typedef double x2;
	x2 xx;
    cin>>xx;
	cout << "inputs:" <<xx<<endl<<"auto:"<<x<< endl;
}

引用：&

#include <iostream>
using namespace std;
int main()
{
	int k1 = 1;
	int & k2 = k1;//定义k2引用k1,
	cout << "k1:"<<k1<<endl;
	cout << "k2:" << k2 << endl;
	k2 = k2 - 1;
	cout << "k1:" << k1 << endl;
	k1 = k1 + 1;
	cout << "k2:" << k2 << endl;
}

注：这里采用了引用&，即 k2 引用 k1 类型，相对于 k2 与 k1 进行了绑定，k2变化会引起 k1发送同样的变化，k1变化 k2也会变化；

函数中的知识

函数默认值：

• 有默认参数出现，则左边往后的参数都必须增加默认值
• 声明和实现只能出现一次默认值，要么声明，要么实现

//有默认参数出现，则左边往后的参数都必须增加默认值
int fun(int a, int b=10,int c =11)
{
	return a+b+c;
}
//声明和实现只能出现一次默认值，要么声明，要么实现
int fun1(int a,int b);
int fun1(int a=10,int b=10)
{
}
int main()
{
	fun(10,10,10);//在调用时，优先采用用户的出入参数
	return 0;
}

占位参数

• 只使用类型进行占位；
• 占位也能有默认值；

int fun(int a, int)
{
}
int fun(int a, int = 10)
{
}

函数重载

• 函数重载使用同名函数，提高函数复用性
• 同一作用域下
• 函数名字相同
• 函数的参数类型不同 或者 个数不同 或者顺序不同
• 但是函数的 返回类型 不能作为重载的条件 即：int fun(){}和 void fun(){}不能同时存在于一个作用域
• 特殊的情况：
  （1）使用const 后，系统认为以下这种情况属于 参数类型不同

void fun(int &a)
{
}
void fun(const int &a)
{
}
int main()
{
	int a = 10;
	fun(a); //调用第一个，因为第一个的函数参数有读写权利，而第二个const限定后只有只读权利，优先读权利大的
	fun(10);//调用第二个，因为第一个&a=10这是不合法的，但是 const 为 a创建了一个合法的临时空间，&a =10 就合法了
}

（2）函数重载出现有默认参数的情况
这种情况出现了二义性，定义没问题，但是调用会出错，编译器不知道调用哪一个

void fun(int a,int b=10)
{}
void fun(int a)
{}
int main()
{
	fun(10);//这是错误的
}

函数模板

——template<typename T> 或者 template<class T>

#include <iostream>
using namespace std;
//模板函数定义
template<typename T>
void Swap(T &a,T &b);

int main()
{
	int x1 = 10;
	int x2 = 20;
	Swap(x1, x2);
	cout << x1 << " " << x2;

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

这个方法多用于方便长名字类型的函数参数类型时的定义，简化需要写的内容
这种函数模板的存在的局限是：T 不能用于定义 数组类型 和 结构类型
T所代表的必须是同样的类型

显式具体化

该方法便可以用于结构体类型的参数定义了

#include <iostream>
#include <string>
using namespace std;

struct job
{
	string name ;
	int age;
};
//模板化
template<class T>
void Swap(T &a,T &b);
//具体化
template <> void Swap<job>(job &j1, job &j2);

void show(job &j);

int main()
{
	job x1 = { "xx",20 };
	job x2 = { "yy",21 };

	Swap(x1, x2);
	show(x1);
	show(x2);

}

template <> void Swap<job>(job &j1, job &j2)
{
	string na;
	int n;
	na = j1.name;
	n = j1.age;

	j1.name = j2.name;
	j1.age = j2.age;

	j2.name = na;
	j2.age = n;

}

void show(job &j)
{
	cout << "信息:" << endl;
	cout << j.name << ":" << j.age << endl;
}

输出：
信息:
yy:21
信息:
xx:20
注：在进行 显式具体化 时，必须先进行对函数进行模板化，再对该函数进行具体化

显式实例化

同一类型的 显式实例化 和 显式具体化 不能在一个文件中使用
显式实例化：

#include <iostream>
#include<string>

using namespace std;

template <class T>
T lesser(T &a, T &b);//模板实例化函数

int lesser(int &a, int &b);//标准函数

int main()
{
	int a = 10;
	int b = 20;
	double x1 = 12.2;
	double x2 = 13.4;
	cout << lesser(a, b) << endl;//此时会调用标准函数
	cout << lesser(x1, x2) << endl;//此时会调用实例化函数
	cout << lesser<>(a, b) << endl;//此时会调用实例化函数，因为<> 符号
	cout << lesser<double>(x1, x2) << endl;//此时会调用实例化函数，这里采用<double>进行强制T转为double类型
}

。。。。

lesser(x1, x2) ;//标准 与 实例化 根据实际调用
lesser<>(a, b) ; 实例化函数模板
lesser(x1, x2) ; 强制类型并，实例化函数模板

多类型参数的模板函数

//多类型参数的模板函数
template<class T1,class T2>
void ffftt(T1 &a, T2 &b)
{
	decltype(a + b) xpy = x + y;
}

T1类型 和 T2 类型不一定时一种类型，所以在对两不同参数类型进行操作时，集合后的结果会是什么类型的一般是大于或等于这两参数类型的类型，为了保证不出现类型错误，所以使用decltype关键字来确保变量类型符合要求。