6.2传参

传递引用是原变量的别称，所以引用类型的参数与原值绑定。
传递指针类型变量是copy的，但是可以通过指针直接修改指向的变量。
C++一般使用reference。

6.2.2使用reference来传递参数

在参数不希望被函数内改变的时候需要加const。
使用引用可以避免变量被拷贝。
使用引用作为参数可以作为额外的返回值隐含地返回内容。

6.2.3使用`const`修饰词

函数参数为const的时候，可以传递非const的参数。
在函数重载的时候，不能使用const来区分不同的函数。
给非const的参数传参时，不能用字符串直接传递（会被当做const类型），必须定义一个变量，再传递。

string::size_type find_chaar(string &s, char c, string::size_type &occurs);
find_char("Hello", 'o', ctr); // compile fail

string s = "Hello";
find_char(s, 'o', ctr); // compile pass

函数多重嵌套时，要注意 string -> func(const string&) -> inner_func(string &) 的情况，inner_func会报错：也就是const string&不可转换为string&,即使原变量为string。
- 需要定义一个新string为const string&的拷贝。

//函数定义参考上面的
bool is_sentence(const string &s)
{
// if there's a single period at the end of s, then s is a sentence
  string::size_type ctr = 0;
  return find_char(s, '.', ctr) == s.size() - 1 && ctr == 1；
}

//定义一个拷贝
std::string t = std::string(s);

6.2.4传递数组

以下三个表达式等价

void print(const int*);
void print(const int[]); // shows the intent that the function takes an array
void print(const int[10]); // dimension for documentation purposes (at best)

在传参的时候编译器只会检查参数是否为const int*，不会检查数组长度大小。
- 即函数参数定义成arr[10]，传入arr[13]，越界了也不会报错，访问arr[11]和arr[14]均可。
- 因此需要手动限制数组边界。
限定边界的三种方法
- 在数组结尾加flag
- 传递数组起始指针和结尾指针
- 传递数组长度(可以使用std::end(arr)-std::begin(arr)来确定数组长度,但此方法不适用于new int(n)定义的数组)
多维数组

int *matrix[10]; // array of ten pointers
void f(int matrix[][10]); // array of ten pointers
int (*matrix)[10]; // pointer to an array of ten ints

6.2.5 main函数传参

argc: 参数的数量
*argv[]: 指向C数组指针的数组二维char数组
- argv[0]存储的是程序名称，第一个参数从argv[1]开始

6.2.6 可变参数

可变参数函数分为两种情况：
- 如果所有的参数类型都是一样的，可以使用 initializer_list这个库类型来传参(C++11)。
- 如果存在不同类型的参数，我们可以使用“variadic template”，也就是可变参数模板。
- 存在不同类型的参数还可以使用"ellipsis"，但是这个方式本来是用来与C接口函数使用的。因此不建议在C++中使用。

`initializer_list`参数

initializer_list是一个类模板，里面的所有元素都是const类型的，类似于vector。
在传递参数的时候需要用大括号将参数括起来。
变量的生命周期与临时变量相同（就是直接在参数区域写一个字符串）
initializer_list只是一个参数，一个函数可以有多个参数，拿大括号括起来就行了。

void error_msg(initializer_list<string> il)
{
  for (auto beg = il.begin(); beg != il.end(); ++beg) {
    cout << *beg << " " ;
    cout << endl;
  }
}

Ellipsis参数

因为这个参数是用来和C函数做接口的，因此它所适用的数据类型仅限C和C++共同所有的类型，因此多数Class对象都不可用。
Ellipsis参数仅在函数的最后面出现:

void foo(params_list, ...);
void foo(...);

6.3返回值

不能返回局部变量的指针或引用。

List Initializing 返回值

返回值可以装在一个列表里，其初始化和vector的List Initializing以及上面的std::initializer_list相似，即使用大括号，里面装一样类型的数据。
本质就是隐含地构造了一个vector。
可以返回空vecotr。

6.3.3返回指向数组的指针

使用类型化名的声明方法

typedef int arrT[10]; //arrT 等价于 int[10]
using arrtT = int[10]; //arrtT 等价于 int[10]
arrT* func(int i); //函数返回一个指向int[10]数组的指针

直接声明的方法

int arr[10];
int *p1[10]; //10个指针的数组
int (*p2)[10] = &arr; //指向数组的一个指针

Type (*function(parameters))[dim];
int (*func(int i))[10];

尾置声明方法(C++11)

auto func(int i) -> int(*)[10];

使用decltype, decltype(e)使用与e相同类型的类型。

int odd[] = {1,3,5,7,9};
int even[] = {0,2,4,6,8};
// returns a pointer to an array of five int elements
// decltype(odd)返回 int[],因此在此声明后添加“*”来表示指向数组的指针
decltype(odd) *arrPtr(int i){
  return (i % 2) ? &odd : &even; // returns a pointer to the array
}

6.4 函数重载

在同一域(scope)，拥有相同函数名称，不同参数的函数称为重载。

main函数不可被重载。
相同参数，返回值不同的情况下会报错。
当多个名称不同的函数在做类似的事情，可以将他们统一命名并重载；但是如果为了重载，牺牲了函数的易读性，给人造成困扰，就不要重载。

const参数问题

最高级(top-level)指针(本身是否为const)不能用来区分重载函数，他们是等价的。
归纳上一条就是参数本身是否为const是无所谓的。

//下面二者等价
Record lookup(Phone*);
Record lookup(Phone* const);

Record lookup(Phone);
Record lookup(const Phone);

低级(low-level)指针或者引用(指向的类型是否为const)可以用来区分重载函数。

//下面表达式不等价，可以用来重载
Record lookup(Account&); //Account类型的引用
Record lookup(const Account&); //const Account 的reference
Record lookup(Account*); //指向Account的指针
Record lookup(const Account*); //指向const Account的指针

`const_cast`和重载

在通常情况下，程序员写出一个重载函数的参数，编译器就会容易的匹配重载函数集合中最匹配的函数，但是有些情况下存在参数类型转换(conversions)的问题。在编译器匹配过程中，会有三种情况:

找到了最佳匹配(best match)
没找到任何可匹配的，即无匹配(no match)
有多个可以匹配的函数，并且都不是最佳匹配，即模糊调用(ambiguous call)

重载和作用域

由于C++对函数名称的寻找过程中，不检查参数类型。因此即使在外部重载了多个函数，如果在局部定义了一个同名的函数，则编译器在局部搜索到该函数，并确认局部没有同名函数之后就不再搜索了。

6.5一些特殊用法和特性

6.5.1 默认参数

函数定义时可以给参数设定默认值。

有默认值的参数位于无默认值的参数的后面。
一个函数可以被重新定义好几次，并且之前定义过默认值的参数在新定义中不能重新定义默认参数，即使重新定义的默认值相同也不行。

//按照以下顺序定义函数
std::string func_overload(int a, int b, int c); //ok
std::string func_overload(int a, int b, int c=8); //ok
std::string func_overload(int a, int b=4, int c=8); //c被重新定义了，报错
std::string func_overload(int a, int b=4, int c); //ok

局部变量不能用来当做定义函数的默认值，除此之外其他的表达式，只要是能转换为参数定义类型的，都可以。
在调用函数之前，改变默认表达式的值，在调用时改变会生效。
在调用函数之前，重新定义同名的表达式，在调用时使用之前的表达式的值。

int wd = 80;
char def = ' ';
int foo();
void func_overload(int a = foo(), int b = wd, char c = def);
func_overload(); // calls screen(foo(), 80, ' ')
int a_func(){
  def = '*'; //改变值
  int wd = 100; //重新定义变量
  func_overload(); // calls screen(foo(), 80, '*')
}

6.5.2 内联(inline)与`constexpr`函数

有时候我们会为了一个简单的计算来定义一个函数（比如比较两个对象的值），将它封装起来会提高代码可读性，但是为了这一点计算就调用函数会增大无用开销。

内联函数和constexpr函数通常放在header里面定义，为了在编译的时候正常展开代码。

内联函数调用

在编译时，使用inline的函数的地方就会被编译器替换内容。

内联函数通常使用在不存在递归多次被调用并且只有一两行的函数上。

内联函数定义方式如下:

inline const string & shorterString(const string &s1, const string &s2){
  return s1.size() <= s2.size() ? s1 : s2;
}

内联函数在实际使用时:

cout << shorterString(s1,s2) << endl;

//在编译时会转换为如下代码：
cout << (s1.size() < s2.size() ? s1 : s2) << endl;

`constexpr`函数 (C++11)

每个参数以及返回值必须是字面类型(literal type)
函数体中只有一个return
constexpr函数是隐含的内联函数，在编译阶段会替换为字面类型变量。
constexpr函数允许返回一个非const类型的变量

constexpr int new_sz() {return 42;}
constexpr size_t scale(size_t cnt) { return new_sz() * cnt;} //ok

int arr[scale(2)]; //ok, scale(2)是constexpr

int i=2;
int a2[scale(i)]; //error, scale(i)不是constexpr,因此无法返回constexpr。
int j = scale(i); //ok, 原因在下面

constexpr函数不一定非要返回constant expression。

6.5.3 用于调试的函数

assert和NDEBUG可以实现在开发(dev)状态下执行某些代码，开发完成后在发行版中禁止这部分代码运行。

`assert`预处理宏

预处理宏 (preprocessor variables，注意它不是编译器) 类似于内联函数，它有一个参数作为条件 assert(expr)，如果expr为False，则函数输出信息，并终止程序。反之则继续执行。

预处理宏通常用于检查不可能发生的情况。

assert宏在cassert头文件中定义，我们直接用预处理函数，不需要添加任何名字空间。
在头文件包含cassert之后，变量名不能使用assert。

`NDEBUG`预处理变量

assert是否执行取决于NDEBUG是否被定义。如果被定义，则assert不做任何事情。

在默认情况下NDEBUG不被定义。

定义NDEBUG的方法如下

#define DEBUG

大多数编译器提供了命令行定义的功能，方法如下

$ CC -D NDEBUG main.c  # in linux
$ CC /D NDEBUG main.c  # in Windows

我们可以使用#ifndef的特性手动添加开发时使用的代码

void foo(){
  ...
  #ifndef NDEBUG
  cerr << __func__ << endl; // __func__是由编译器定义的static局部变量，存储函数名称。
  #endif
  ...
}

在debug的时候有很多内置变量可供参考使用

__FILE__ string存储文件名 __LINE__ int存储当前行数 __TIME__ string存储编译的时间 __DATE__ string存储编译的日期

6.6 函数匹配

有些情况下，没有可以最佳匹配的函数。

确定候选函数(Candidate func)和可执行函数(viable func)

候选函数：函数名与调用函数名相同的函数集合可执行函数：候选函数的子集，是候选函数中可以被给定的参数成功调用的函数 (函数参数类型匹配或者可以转换成定义的参数类型)。

第一步：找到候选函数集合。
第二步：找到可执行函数集合
第三步：从可执行函数集合中找到最佳匹配。如果没有最佳匹配，那么编译器会报歧义(ambiguous)错误

6.6.1 参数类型匹配

大多数整数字默认转换为int，即使它小于short的范围。
小数默认为double，所以传递给float参数需要类型转换。
指针和引用都可以根据是否为const来匹配相应的函数。

6.7 函数指针

函数指针的类型由函数的参数和返回值决定。

//原始函数
bool lengthCompare(const string&, const string&);

//定义未初始化的函数指针
bool (*pf)(const string &, const string &);

当函数名作为变量时，它会自动转化为指针。取地址符号可加可不加，二者等价。

//等价
pf = lengthCompare;
pf = &lengthCompare;

可以使用指向函数的指针来调用函数，不需要对指针解引用。

//下面三个等价
bool b1 = pf("hello", "goodbye"); // calls lengthCompare
bool b2 = (*pf)("hello", "goodbye"); // equivalent call
bool b3 = lengthCompare("hello", "goodbye"); // equivalent call

函数指针所指向的函数变化的时候不需要convert。
nullptr等价于整型0。
对于重载的函数，赋值时需要完全匹配返回值和参数，否则报错。
当函数指针作为函数参数时，编译器自动把它按照指针看待，是否加*等价。

// third parameter is a function type and is automatically treated as a pointer to function
void useBigger(const string &s1, const string &s2, bool pf(const string &, const string &));

// equivalent declaration: explicitly define the parameter as a pointer to function
void useBigger(const string &s1, const string &s2, bool (*pf)(const string &, const string &));

可以使用typedef或者decltype来简化函数定义

//函数定义
// Func and Func2 have function type
typedef bool Func(const string&, const string&);
typedef decltype(lengthCompare) Func2; // equivalent type

//函数指针定义
// FuncP and FuncP2 have pointer to function type
typedef bool(*FuncP)(const string&, const string&);
typedef decltype(lengthCompare) *FuncP2; // equivalent type

返回函数指针

与返回数组相似，使用类型化名(Type alias)来定义。

using F = int(int*, int); // F is a function type, not a pointer
using PF = int(*)(int*, int); // PF is a pointer type

//用化名将函数指针作为返回值
PF f1(int); // ok: PF is a pointer to function; f1 returns a pointer to function
F f1(int); // error: F is a function type; f1 can't return a function
F *f1(int); // ok: explicitly specify that the return type is a pointer to function

还可以用后置类型定义

auto f1(int) -> int (*)(int*, int);

如果需要返回的函数指针指向的函数已经被定义了，可以使用decltype简化：

string::size_type sumLength(const string&, const string&);
string::size_type largerLength(const string&, const string&);

// depending on the value of its string parameter,
// getFcn returns a pointer to sumLength or to largerLength
decltype(sumLength) *getFcn(const string &);

Functions

6.2传参

6.2.2使用reference来传递参数

6.2.3使用`const`修饰词

6.2.4传递数组

6.2.5 main函数传参

6.2.6 可变参数

`initializer_list`参数

Ellipsis参数

6.3返回值

List Initializing 返回值

6.3.3返回指向数组的指针

6.4 函数重载

const参数问题

`const_cast`和重载

重载和作用域

6.5一些特殊用法和特性

6.5.1 默认参数

6.5.2 内联(inline)与`constexpr`函数

内联函数调用

`constexpr`函数 (C++11)

6.5.3 用于调试的函数

`assert`预处理宏

`NDEBUG`预处理变量

6.6 函数匹配

确定候选函数(Candidate func)和可执行函数(viable func)

6.6.1 参数类型匹配

6.7 函数指针

返回函数指针

results matching ""

No results matching ""

6.2传参

6.2.2使用reference来传递参数

6.2.3使用const修饰词

6.2.4传递数组

6.2.5 main函数传参

6.2.6 可变参数

initializer_list参数

Ellipsis参数

6.3返回值

List Initializing 返回值

6.3.3返回指向数组的指针

6.4 函数重载

const参数问题

const_cast和重载

重载和作用域

6.5一些特殊用法和特性

6.5.1 默认参数

6.5.2 内联(inline)与constexpr函数

内联函数调用

constexpr函数 (C++11)

6.5.3 用于调试的函数

assert预处理宏

NDEBUG预处理变量

6.6 函数匹配

确定候选函数(Candidate func)和可执行函数(viable func)

6.6.1 参数类型匹配

6.7 函数指针

返回函数指针

results matching ""

No results matching ""

6.2.3使用`const`修饰词

`initializer_list`参数

`const_cast`和重载

6.5.2 内联(inline)与`constexpr`函数

`constexpr`函数 (C++11)

`assert`预处理宏

`NDEBUG`预处理变量