6.1函数基础
一个典型的函数定义包括：返回类型、函数名字、0个或多个形参组成的列表、函数体。
函数执行的操作在语句块中说明，成为函数体。
通过圆括号()调用运算符来执行。
局部静态对象：定义成static
在函数调用时，只初始化一次，函数结束仍然有效。
函数声明
函数只能定义一次，但是可以声明多次。
函数声明无需函数体，用分号替代。
函数的三要素（返回类型，函数名，形参类型）描述了函数的接口，说明了调用该函数所需的全部信息。函数声明也称函数原型。
建议在头文件中声明，在源文件中定义。
分离式编译
允许把程序分割到几个文件，每个文件独立编译。
factMain调用fact,生产可执行文件
编译的过程如下：
$ CC factMain.cc fact.cc #generates factMain.exe
$ CC factMain.cc fact.cc -o #generates main.exe
如果修改了其中一个源文件，只需要重新编译改动的文件。
分离式编译产生一个.obj或.o文件，含义是该文件包含对象代码。
接下来编译器负责把对象文件链接在一起形成可执行文件
实际编译过程：
$ CC -c factMain.cc #generates factMain.o
$ CC -c fact.cc #generates fact.o
$ CC factMain.o fact.o #generates factMain.exe or a.out
$ CC factMain.o fact.o -o main #geneartes main or main.exe
6.2参数传递
每次调用函数都会重新创建形参，并用传入的实参对形参进行初始化，即拷贝。
如果形参是引用类型，则实参被引用传递，函数被传引用调用。
如果形参是实参的拷贝，则成为值船体，函数被传值调用。
指针形参
执行指针拷贝操作时，拷贝的时指针的值，拷贝之后两个指针时不同的。
void reset(int *ip)
{
*ip = 0; //改变ip所指对象的值
ip = 0; //改变了ip的局部拷贝，实参未改变。
}
int i = 42;
reset(&i); //i = 0;改变的是i的值，不会改变i的地址
传引用参数
void reset(int &i)
{
i = 0; //改变了i所引对象的值
}
int j = 42;
reset (j); // j = 0;
拷贝大的类型或容器比较低效，有的类型（IO）还不支持拷贝，函数只能引用形参访问改类型对象。
如果函数要返回多个值，一个好方法就是给函数一个额外的引用参数，令其保存结果。
const形参和实参
首先要注意顶层const的使用
const int ci = 42; //不能改变ci,const是顶层的
int i = ci; //拷贝时可以忽略顶层const
int * const p = &i; //const是顶层的，p无法再赋值
*p = 0; //通过p改变对象内容是允许的，i = 0
当用实参初始化形参时会忽略顶层const。
如果形参有const,传入的常量对象或者非常量对象都是可以的。
指针或引用参与const
void reset(int &i)
{
i = 0; //改变了i所引对象的值
}
int i = 0;
const int ci = i;
string::size_type ctr = 0;
reset(&i); //可以
reset(&ci); //错误，不能指向const
reset(i); //可以
reset(ci); //错误
reset(42); //错误,不能把普通字面值作为引用
reset(ctr); //错误，类型不匹配
尽量使用常量引用
如果把引用不设置未常量，容易误导人以为可以修改实参。
同时会限制参数，因此如果不需要修改就使用常量引用。
数组形参
数组有两个性质：1、不允许拷贝。2、使用数组时会转换成指针。
因此无法值传递使用数组参数，只能用类似形式。
//三个函数等价，每个函数都有const int*类型的形参
void print(const int*)
void print(const int[]])
void print(const int[10]]) //这里的维度表示期望含有的元素，实际不一定
调用时
int i = 0;
int j[2] = {0, 1}
print(&i); //正确，&i的类型时int*
print(j); //正确，j转换成int*指向j[0]
因此一开始不知道数组的确切尺寸
1、使用标记指定数组长度
管理数组实参的一种方法是要求数组本身包含一个结束标记，如C风格字符串，最后有一个空字符表示结束。
适用于有明显结束标记的数组
void print(const char *cp)
{
if(cp) //CP不是空指针
while(*cp) //只有指针所指不是空字符
count << *cp++ //打印
}
2、使用标准库规范
传递指向数组首元素和伪元素的指针。
void print(const int *beg; const int *end)
{
while(beg != end)
count << *beg << endl;
}
调用时传入两个指针
int j [2] = {0,1};
print(begin(j),end(j));
3、显式传递数组大小的参数
实参专门定义一个数组大小的形参
只要size不超过实际数组大小，就是安全的。
void print(const int ia[]; size_t size)
{
for(size_t i = 0; i != size; ++i)
cout << ia[i] << endl;
}
数组形参和const
当函数不需要对数组读写时，形参应该是指向const的指针。只有函数需要改变元素值时，才把形参定义指向非常量的指针。和指针类似。
数组引用形参
形参可以是数组的引用。（括号不可少）
void print(int (&arr)[10])
{
for (auto elem : arr)
cout << elem << endl;
}
函数体只能作用于大小为10的数组
传递多维数组
处理的是数组的数组，首元素本身是一个数组，指针是一个指向数字的指针。
void print(int (*matrix)[10], int rowSize)
等价定义
void print(int matrix[][10], int rowSize)
main:处理命令行选项
有时需要给main传递实参，一种常见的情况是用户通过设置一组选项来确定函数要执行的操作。
例如：假定main函数位于可执行文件prog内，我们可以向程序传递下面的选项：
prog -d -o ofile data0
命令行通过两个（可选的）形参传递给main函数
int main(int argc, char *argv[])
第一个形参表示数组中字符串的数量。
第二个形参是一个数组，它的元素是指向C风格字符串的指针。
也可以定义成
int main(int argc, char **argv0)
其中argv指向char*
当实参传递给main后，argv的第一个元素指向程序的名字或者一个空字符串。接下来的元素一次传递命令行提供的实参。最后一个指针之后的元素值保证为0.
上述命令行为例
argv[0] = "prog";
argv[1] = "-d";
argv[2] = "-o";
argv[3] = "ofile";
argv[4] = "data";
argv[5] = 0;
含有可变形参的函数
为了编写能处理不同数量实参的函数，C++ 11有两种主要方法：
1、如果所有实参类型相同，可以传递一个名为initializer_list的标准库函数。
2、如果实参类型不同，可以编写一种特殊函数，即可变参数模板。
C++还有一种特殊的形参类型（省略符），可以传递可变数量的实参。
这种功能一般只用于与C函数交互的接口程序。
initializer_list形参
表示某种特定类型的值的数组。
提供的操作有：
initializer_list<T> lst //默认初始化；T类型元素的空列表
initializer_list<T> list{a,b,c}//lst的元素数量和初始值一样多；lst的元素是对应初始值的副本；列表中的元素是const
lst2(lst) ；// 拷贝或赋值一个initializer_list对象不会拷贝列表中的元素；
lst2 = lst； //拷贝后，原始列表和副本共享元素
lst.size(); //数量
lst.begin(); //首元素指针
lst.end(); //尾元素下一个位置的指针。
和vector一样，initializer_list也是模板类型，需要说明所含元素类型。不过initializer_list对象中的元素永远是常量，无法修改。
initializer_list<int> li;
如下编写输出错误信息的函数，使其可以作用于可变函数的实参：
void error_msg(initializer_list<string> il)
{
for (auto beg = li.begin(); beg != il.end(); ++beg)
{
cout << *beg << "";
}
cout << endl
}
如果想向initializer_list形参中传递一个值，要用花括号。
error_msg({"functionX", expected, actual})
含有initializer_list形参的函数也可以同时拥有其他形参。
省略符形参
是为了c++程序访问某些特殊的C代码设置的，这些代码使用了varargs的标准库。
通常省略符形参不应用其他目的。
只能出现在形参列表最后一个位置
void foo(parm_list, ...);
6.3、返回类型和return语句
无返回值函数
只能用在void函数中。void的函数最有一句后面会隐式地执行return。
一般用法是中间位置提前退出，类似break。
有返回值函数
只要函数类型不是void，则必须返回一个对应的值。
函数返回的是一个拷贝的临时对象。
函数也可以返回引用
const string &shorterString(const string &s1. const string &s2)
{
retrun s1.size() <= s2.size() ? s1 : s2;
}
不要返回局部对象的引用
函数完成后，所占用的存储空间就释放了，因此局部变量的引用就不在有效。
引用返回左值
调用一个返回引用的函数得到左值，其他返回类型得到右值。
char &get_val(string &str, string::size_type ix)
{
return str[ix];
}
get_val(s, 0) = 'A';
如果返回的是常量引用就不能赋值。
列表初始化返回值
c++11允许返回花括号包围的值的列表。
vector<string> process()
{
//expected和actual是string
if(expected.empty())
return{};
else if (expected == actual)
return {"functionX", "okay"};
else
return {"functionX", expected, actual}
}
主函数main的返回值
允许main函数没有return（有一个隐藏的retrun 0)
main函数的返回值看作状态指示器，返回0表示成功，其他表示失败。
为了使返回值与机器无关，cstdlib头文件定义了两个预处理变量。
int main()
{
if(some_failure)
return EXIT_FAILURE;
else
return EXIT_SUCCESS;
}
递归
函数调用自身就是递归。
递归函数必须有一个路径是不包含递归调用的，否则就会死循环。
返回数组指针
数组不能拷贝，因此函数不能返回数组，只能返回指针或引用。
声明一个返回数组指针的函数
int (*func(int i))[10];
使用尾置返回类型
c++简化方法，使用尾置返回类型
fun函数返回指针，指针指向了10个整数的数组
auto func(int i) -> int(*)[10]
使用decltype
如果知道函数返回的指针将指向哪个数组，就可以使用decltype来声明返回类型。
int odd[] = {1,3,5,7,9};
int even[] = {0,2,4,6,8};
decltype(odd) *arrPtr(int i)
{
return (i % 2) ? &odd : &even;
}
arrPtr使用decltype表示它的返回类型是指针，并且所指对象与odd类型一致。因为odd是数组，所以arrPtr返回一个指向含有5个整数的数组的指针。
6、4函数重载
统一作用域内的几个函数名字相同但是形参列表不同，称之为重载。
有顶层const的形参和没有的无法区分
Record lookup(Phone);
Record lookup(const Phone); //重复声明错误
如果形参是指针或引用，则通过区分其指向的是常量对象还是非常量对象可以实现重载，此时const是底层的。
Record lookup(Phone*); //函数作于指向Phone的指针
Record lookup(const Phone*); //函数作用于指向常量的指针
const_cast和重载
当函数的实参不是常量时，得到的结果是一个普通的引用，就可以使用const_cast
string &shorterString(string &s1, string &s2)
{
auto &r = shorterString(const_cast<const string&>(s1), const_cast<const string&>(s2));
return const_cast<string&>(r);
}
先把实参强制转成const的引用，然后调用函数，返回对const string的引用，再将其转换回一个普通的string&，是安全的。
调用重载的函数
把函数调用与一组重载函数中的某一个关联起来，叫函数匹配，也叫重载确定。
调用重载函数有3种可能的结果：
1、找到一个最佳匹配的函数
2、找不到任何一个匹配的，编译器发出无匹配的错误
3、有多于一个函数可以匹配也会发生错误，称为二义性调用
重载和作用域
函数只会调用最近的作用域中的重载函数。
6、5特殊用途语言特性
默认实参
定义成如下
string screen(sz ht = 24; sz wid = 80; char backgrnd = ' ')
一旦每个形参被赋予了初值，剩下的都必须有默认值。
实际调用时只能省略尾部的实参。
window = screen(66)
window = screen('?') /实际调用screen('?', 80,' ')
默认实参声明
通常放在头文件，且一个函数只声明一次。
每个形参只能被赋予一次默认值，如果后续声明为了添加默认实参，也是允许的。
默认实参初始值
局部变量不能作为默认实参，除此之外只要表达式的类型能转换成形参所需要的类型，该表达式就能作为默认实参。
sz wd = 80;
char def = '';
sz ht();
string screen(sz = ht(); sz = wd; char = def);
如果：
void f2()
{
def = '*; //更新了传递的值
sz wd = 100; //隐藏了外层的wd,但与传递的wd无关
window = screen(); //调用screen(ht(), 80, '*');
}
内联函数和constexpr
调用函数有一系列工作，会比较慢
内联函数可以避免函数调用的开销
在函数返回类型前加上inline，声明成内联函数
inline const string &shorterString(const string &s1, const string &s2)
{
return s1.size() <= se.size() ? s1 : s2;
}
一般用于优化规模较小，流程直接，频繁调用的函数。很多编译器不支持内联递归函数。
constexpr函数
指能用于常量表达式的函数。
定义时候的约定：
1、函数的返回类型及所有形参类型都是字面值类型
2、函数体中必须有且只有一个return
constexpr int new_sz() {return 42;}
constexpr int foo = new_sz();
在编译中直接替换成结果值，constexpr函数被隐式地指定为内联函数。
constexpr函数体内也可以包含其他语句，只要这些语句在运行时不执行任何操作。
把内联函数和constexpr函数放在头文件
内联函数和constexpr函数可以多次定义，但是它的多个定义必须完全一致。
调试帮助
程序可以包含一下用于调试的代码，在发布时要屏蔽，用到两个预处理功能。assert和NDEBUG
assert
是一种预处理宏，即一个预处理变量。使用一个表达式作为条件
assert(expr);
如果表达式为假，assert输出信息并终止程序；否则什么也不做。
定义在cassert头文件中，名字由预处理器管理，因此不需要提供using声明。
常常用于检查“不能发生”的条件。
NDEBUG
assert的行为依赖于NDEBUG的预处理变量的状态。如果定义了NDEBUG,则assert什么也不做。默认状态下没定义。
可以使用#define定义NDEBUG，从而关闭调试状态。
很多编译器都提供了一个命令行选项是我们可以预处理变量
$ CC -D NDEBUG main.c # use /D with the Microsoft compiler
这条命令等价于在开头写#define NDEBUG
还可以使用NDEBUG编写自己的调试代码，如果NDEBUG没定义，将指向#ifndef和#endif之间的代码
void print(const int io[], sizt_t size)
{
#ifndef NDEBUG
cerr << __func__ << ": array size is" << size << endl;
#endif
}
__func__输出当前函数的名字。
编译器为每个函数都定义了一些名字
__FILE__ //存放文件名的字符串字面值
__LINE__ //存放当前行号的整型字面值
__TIME__ //存放文件编译时间的字符串字面值
__DATE_- //存放文件编译日期的字符串字面值
6、6函数匹配
有时候重载函数太多，不容易选择。
确定候选函数和可行函数
函数匹配第一步是选本次调用对应的重载函数集。
两个特征：1、同名 2、声明在调用点可见。
第二步考察实参，然后选出可行函数。
两个特征：1、形参与调用提供的实参个数相等。2、类型也相同
第三步：寻找最佳匹配。逐一检查提供的实参类型，寻找最匹配的可行函数。
void f(int);
void f(double, double = 3.14);
f(3.14); //调用第二个
含有多个形参的函数匹配
如果有且只有一个函数满足下列条件则匹配成功：
1、函数的每个实参匹配都不劣于其他可行函数需要的匹配。
2、至少有一个实参的匹配优于其他可行函数的匹配。
如果没有函数可以，就是错误的，会报错。
void f(int， int);
void f(double, double = 3.14);
f(3, 3.14) //直接报错，有二义性。
实参类型转换
为了确定最近匹配，编译器将实参类型到形参类型的转换分了几个等级：
1、精确匹配（类型相同、转换成对应指针、添加顶层const或删除顶层const）
2、通过const转换实现的匹配
3、类型提升
4、算数转换或指针转换
5、通过类类型转换
需要算数提升和转换的匹配
如果有两个函数，优先算术提升
void ff(int);
void ff(short);
ff('a'); //提升为int调用int的
算术类型转换的级别都一样
void manip(long);
void manip(float);
manip(3.14); //错误，二义性调用
函数匹配和const实参
如果重载函数的区别在于引用类型的形参是否引用了const，或者指针类型的形参是否指向const，那么就会根据实参是否是变量来决定使用哪个。
如果传入const对象，所以唯一可行的函数是常量引用函数。
如果传入普通对象，两个函数都可调用，优先使用非常量版本的函数。
6、7函数指针
指向的是函数而非对象。
bool (*pf)(const string &, const string &);
pf是一个指向函数的指针，该函数的参数是两个const string引用，返回值是bool。
使用函数指针
把函数名作为一个值使用时，函数自动转换成指针
pf = lengthCompare； //pf指向这个函数
pf = &LengthCompare; //等价的，取地址符时可选的
调用时可以直接使用，不需要解引用
boo1 b1 = pf("Hello", "goodbye");
boo1 b2 = (*pf)("Hello", "goodbye");
bool b3 = lengthCompare("Hello", "goodbye");
//三者等价
函数指针可以赋值为nullptr或者0，表示没有指向函数。
指向时函数的返回类型，形参类型必须精确匹配。
重载函数的指针
使用重载函数时，指针类型必须与重载函数中的某一个精确匹配
void ff(int*);
void ff(unsigned int);
void (*pf1)(unsigned int) = ff;
void (*pf2)(int) = ff;
void (*pf3)(int*) = ff;
函数指针形参
可以直接把函数作为实参使用，自动转换成指针
void useBigger(const string &s1, const string &s2, bool pf(const string &, const string &));
useBigger(s1, s2, lengthCopmare);
直接使用函数指针类型很冗长，用类别别名和decltype可以简化函数指针
typedef bool Func(const string&, const string&);
typedef decltype(lengthCompare) Func2; //等价类型，是函数类型
typedef bool (*Func2)(const string&, const string&);
typedef decltype(lengthCompare) *Func2; //等价类型，是指向函数的指针类型
然后可以如下重新声明函数
void useBigger(const string &s1, const string &s2, Func); //编译器自动将Func表示的函数类型转换成指针。
void useBigger(const string &s1, const string &s2, Func2);
返回指向函数的指针
一种方法是使用别名
using F = int(int*, int); //F是函数
using PF = int(*)(int* ,int); //F是指针
PF fl(int); //正确，PF是指针，fl返回指向函数的指针
F fl(int); //错误，F是函数，不能返回一个函数
F *fl(int); //正确，显式返回
完整的如下：
int (*fl(int))(int*, int);
fl是个函数，fl返回一个指针，指针指向的函数返回int。
使用尾置返回
auto fl(int) -> int (*)(int*, int);
将auto和decltype用于函数指针类型
如果明确知道返回的函数是哪一个，就使用decltype简化。
将decltype作用于某个函数时，本身返回函数类型而非指针，因此要加上*
size_type sumLength(const string&, const string&);
decltype(sumLength) * getFun(const string &);