C++Primer学习——函数
编译器能以任意顺序对形参进行求值
函数的返回类型不能是数组类型和函数类型。
函数开始时为形参分配内存，一旦函数结束，形参也就被销毁了。
如果弄成静态局部变量，那么回到程序终止结束时才被销毁。
void fo()
{
static int a ; //只在第一次初始化
a++; //保存了前次被调用后留下的值
return ;
}
//所有的全局变量都是静态变量，而局部变量只有定义时加上类型修饰符static，才为局部静态变量
形参类型决定了形参与实参的交互方式
f(int a,int b) 被调用时可以看成 f(int a = x,int b = y);
f(int &a,int &b) 被调用时可以看成 f(int &a = x,int &b = y);
使用引用避免拷贝：
拷贝大的类类型或者容器的对象比较低效，甚至有的类类型不支持拷贝操作
参数的const:
顶层const会被忽略，所以两个fcn的参数是一样的（顶层const没法区分参数）
void fcn(const int a){}
void fcn(int a){}
尽可能使用常量引用：
void find(string &s){
}
void find_char(const string &s){
}
find("hhh"); //error 普通引用不能引用字面值
find_char("hhh"); //ok
但底层const看成不同的参数（作用于不同的对象 常量or非常量）
编译器可以通过实参是否是常量来判断调用哪一个（而且非常量优先选择非常量版本）
Record look(Account *)
Record look(const Account *)
Record look(Account &)
Record look(const Account &)
含可变参数：
Initializer_list:
initializer_list是C++标准程序库中的一个头文件，定义了C++标准中一个非常轻量级的表示初始化器列表的类模板initializer_list及有关函数。
与vector不同的是，initializer_list对象中的元素永远是常量值，我们无法改变initializer_list对象中元素的值。
initializer_list lis(ls);
initializer_list lis = ls; //原始列表和副本共享元素
C++11允许构造函数和其他函数把初始化列表当做参数
void fcn(initializer_list<int> ls)
{
for(auto i : ls)
{
cout << i <<" ";
}
cout << endl;
}
int main()
{
fcn({1,2,3});
return 0;
}
class node
{
public:
node(int a,int b){}
node(initializer_list<int>) {}
node(){};
};
int main()
{
node a;
node b(1,2);
node c{2,3,4,5,6};
node d = {1,3,4,5,6};
return 0;
}
省略符类型：
只是用与C/C++通用类型，大多数类类型在传递省略符形参时都无法正确拷贝
void foo(int a,...)
void foo(...)
返回值：
返回值的方式和初始化类似，返回值会被拷贝到函数的调用点用于初始化，如果返回引用又是另一回事。
而且别返回局部变量指针或者引用，因为函数结束一会后其所占空间会被释放掉
int& fo(int a)
{
int b = a;
cout << &b <<endl;
return b;
}
int main()
{
int &a = fo(100); //a,b地址相同，说明并没有经过拷贝
cout << &a <<endl;
cout << a <<endl;
}
函数的返回类型决定返回是否为左值：
当函数返回引用的时候所得到的是左值，其它所得到的都是右值。
char &to_Get(string& a,int index)
{
return a[index];
}
int main()
{
string ta("abcd");
cout << ta <<endl;
to_Get(ta,1) = 'B';
cout << ta << endl;
/*
abcd
aBcd
*/
}
返回数组指针：
数组因为不能被拷贝，所以函数不能返回数组。可以返回数组的引用和指针，只是比较麻烦.
①.利用别名简化。
typedef int arr[10];
using arr = int[10];
arr* func(int i);
②.声明一个返回指针的函数(从内往外读)
int (*a)[10];
int (*func(int a,))[10]; //格式相似
③.尾置返回类型
在->符号后面指明函数的真正返回类型
auto func(int a) -> int(*)[10]
{
}
④.使用decltype(但是会返回数组类型，而数组又无法赋值，所以搞成指针)
int odd[] = {1,3,5,7};
decltype(odd)* func()
{
return &odd; //返回数组类型的指
}
int main()
{
auto p = func();
cout << p << " " <<odd <<endl;
}
重载：
函数重载：应该在函数参数个数或者形参类型上面有所不同.
如果在当前作用域中找到了所需的函数名，那么编译器会自动忽略外层作用域的同名实体。(不同作用域不能重载函数名)
void Print(string a);
void Print(double a);
void f(int a)
{
void Print(int);
print("abc"); //error:与int不符
Print(2.5); //输出了int
}
void Print(double a){ cout << "double " << endl;}
void Print(int a){cout << "int" << endl;}
void Print(string a){cout << "string" << endl;}
默认实参：
一旦某个形参被赋予了默认实参，那后面全部都要有默认值。 而且函数调用时，只能省略尾部实参
windows = screen(,,'s'); //error
windows = screen('s');
函数可以被声明多次，但是一个形参只能被赋予一个默认值。
string screen(sz,sz,char = ' ');
string screen(sz,sz,char = '?'); //error,重复声明
string screen(sz=24,sz=80,char); //correct，添加默认实参
(局部变量不能作为默认实参)
int pa = 100;
void fo(int a = pa); //默然实参为pa
void f()
{
int pa = 80; //隐藏了外部的pa
fo(); //没改变默认值
}
int main()
{
f();
}
void fo(int a)
{
cout << a <<endl;
}
内联函数：
调用函数比一般的求表达式的值要慢一点，大多数机器上，一次函数调用包含着很多工作：调用前先保存寄存器，并在返回时恢复；
可能需要拷贝实参；程序转下一个新的位置继续执行。
内联函数（优化规模小，流程直接，调用频繁的函数； 有的编译器不支持）：
cout<<shorterString(s1,s2)<<endl;
//在编译器看来会转换成
cout << (s1.size() <= s2.size() ? s1:s2) <<endl;
constexpr函数：
编译器把对constexpr函数的调用替换成它的结果了，被隐式地指定为内联函数。
允许返回值并非一个常量？
A (non-template) constexpr function must have at least one execution path that returns a constant expression
//必需要能返回至少一个常量表达式
constexpr int f(bool b) { return b ? throw 0 : 0; } // OK
constexpr int f() { return f(true); } // ill-formed, no diagnostic required
template<bool B> constexpr int g() { return f(B); } // OK
constexpr int h() { return g<true>(); } // ill-formed, no diagnostic required
http://stackoverflow.com/questions/31206937/a-constexpr-function-is-not-required-to-return-a-constant-expression\
但如果把函数用在需要常量表达式的上下问时，则编译器会检测函数结果是否符合要求
内联函数和constexpr函数可以在程序中被定义多少，通常被定义在头文件
assert:
一种预处理宏，行为类似内联函数。 assert（expr）//cassert头文件，由预处理器管理，不需要命名空间
assert(word.size() > threshold);
如果定了NDEBUG预处理变量，那么assert什么也不做
参数匹配：
1.与被调用函数同名 2.其声明在调用点可见
3.形参数量相同 4.实参和形参的类型相同，或者能够转换
然后从可行的当中找出最佳匹配
匹配成功：①每个实参的匹配都不劣于其它可行函数的匹配
②至少有一个实参匹配优于其它
否则会产生二义性
void f(int a,int b)
void f(double a,double b)
int main()
{
f(3,2.15);
}
上面这个例子，两个函数中找不到一个脱颖而出的。 所以会产生二义性。
//要避免强制类型转化，出现只能说明我们的形参集合设置的不合理
匹配等级：
①精确匹配：
1.实参和形参的类型相同
2.从数组类型或者函数类型转换它们的对应的指针类型
3.想实参中添加顶层const或者删除顶层const
//2016年11月20日 22:00:24
②通过const转换 （添加底层const:const&什么的）
③通过类型提升 （小类型提升为大类型）
④通过算术类型转换或者指针转换 （运算符的运算对象转换成最宽；0或NULL转换成任意指针，任意非常量对象指针->void，任意对象->const void）
⑤类类型转换
void f(float x);
void f(int x);
f(3.45); //double型，而所有算术转换等级相同，产生二义性
void f(int a);
void f(short b);
f('a'); //类型提升，但是会提升为较大范围的int。只有类型是short时才会调用short版本
函数指针：
函数的类型是由它的返回类型和行参类型决定的。 函数可以自动地转换成指针，指针可以调用该函数
bool lengthCompare(const string&,const string &);
bool (*p)(const string&,const string&);
p = lengthCompare;
p = &lengthCompare; //等效，函数名会转换成指针
bool t = p("hello","bye");
bool t = (*p)("hello","bye"); //等效
对于重载函数，编译器会通过指针类型选哪个函数，指针类型必需与重载函数的某一个精确匹配.
函数指针可以作为一个函数的形参。
简化函数指针代码 decltype and typedef：
typedef bool func(const string&,const string&); //函数
typedef bool (*func)(const string&,const string&); //函数指针
typedef decltype(lengthCompare) func2;
typedef decltype(lengthCompare) *func2;
decltype()会返回一个函数类型而且不会自动转换成指针
返回函数的指针：
using p = int(int*,int );
using tp = int(*)(int*,int );
tp f1(int); //correct tp是指向函数的指针
p f1(int); //error p是函数类型，不能返回一个函数
p* f1(int); //correct
int (*f1(int*,int))(int*,int ); //直接声明一个返回函数指针的函数
首先f1前面*，所以f1返回一个指针；指针类型包含形参列表，所以指针指向一个函数
尾置型：
auto f1(int) -> int (*)(int*,int);
