【C++ Primer Chapter 6 总结】函数

void fcn(const int i); 　　　　　　　　// const is ignored: 既可以接受const的实参，也可以接受非const的实参
void fcn(int i); 　　　　　　　　　　  // error: redefined, 和上面的定义都可以接受非cosnt的实参，重定义了

void reset(int& i);
int i = 0;
const int ci = i;
string::size_type ctr = 0;
reset(i);
reset(ci); 　　　　　　　　  // error: can‘t bind a plain reference to the const object
reset(42); 　　　　　　　　  // error: can‘t bind a plain reference to a literal
reset(ctr); 　　　　　　　　// error: types don‘t match

void print(cosnt int*);
void print(const int[]);
void print(const int[10]);  // same
 
int i = 0, j[2] = {0,1};
print(&i);
print(j);  // ok: 数组名会被隐式转换为指针
 
void print(int (*matrix)[10], int rowSize);  // 二维数组，matrix指向大小为10的一维数组的指针
void print(int matrix[][10], int rowSize);  // 数组名会被转为指针类型

void print(int (&arr)[10]);                //只能接受实参大小为10的数组，arr是绑定到大小为10的数组上的引用

initializer_list<T> lst{a, b, c, ...};
void print(initializer_list<string> il);

return {v1, v2};

int arr[10];
int *p1[10];    　　　　　　　　　　　　　　　　　　　　　　// p1是大小为10的指针数组
int (*p2)[10];  　　　　　　　　　　　　　　　　　　　　   // p2是指向大小为10的数组的指针，数组元素是int
 
int (*func(int i))[10];  　　　　　　　　　　　　　　　　// (*func(int i))必须带括号. 否者int *func(int i)[10]返回的就是大小为10的指针数组。func(int i) 函数 -> *func(int i)函数调用的结果可以解引用，是个指针 -> (*func(int i))[10]该指针指向的是大小为10的数组 -> int (*func(int i))[10]数组元素类型是int
auto func(int i) -> int(*)[10];  　　　　　　　　　　　//trailing return type尾置返回类型

int (*func(int i))[10];         　　　　　　　　　　// 返回指向数组的指针
auto func(int i) -> int(*)[10]; 　　　　　　　　　　// same
 
int odd[] = {1, 3, 5, 7, 9};
int even[] = {2, 4, 6, 8, 10};
decltype(odd) *arrPtr(int i){      　　　　　　　　// 注意decltype不会自动将数组类型转换为指针类型，因此返回类型要显式指出指针类型
    return （i % 2）？ &odd : &even;
}

int lookup(int);
int lookup(const int);  　　　　　　　　　　　　  // 重复声明
int lookup(int*);
int lookup(int const*);  　　　　　　　　　　　　// 重复声明
 
int lookup(int*);
int lookup(const int*);  　　　　　　　　　　　　// ok
int lookup(int&);
int lookup(const int&);  　　　　　　　　　　　　// ok
 
void f();
void f(int);
void f(int, int);       　　　　　　　　　　　　// 3
void f(double, double); 　　　　　　　　　　　　// 4
f(42, 2.56);  　　　　　　　　　　　　　　　　　　// error: 编译器找不到唯一的best match, 无法决定调用3还是4

bool lengthCompare(const string&, const string&);
bool (*pf)(const string&, const string&);  // pf是指向函数的指针，该函数的类型是：bool (const string&, const string&)
bool *pf(const string&, const string&);   // pf是函数，返回类型是指向bool的指针

void useBigger(const string &s1, const string &s2, bool pf(const string &, const string &));   　　　　  // 第三个参数是函数类型，会自动被当做指向函数的指针
void useBigger(const string &s1, const string &s2, bool (*pf)(const string &, const string &));  　　　　// same
 
useBigger(s1, s2, lengthCompare);  　　　　　　　　　　　　　　　　　　　　// 函数作为参数的函数调用
 
// 函数和函数指针类型的别名定义
typedef bool Func(const string &, const string &);
typedef decltype(lengthCompare) Func2;  　　　　　　　　　　　　　　　　// same type. Func和Func2都是函数类型
 
typedef bool (*FuncP)(const string &, const string &); 
typedef decltype(lengthCompare) *FuncP2;    　　　　　　　　　　　　  // same type.  FuncP和FuncP2都是函数指针类型
 
void useBigger(const string &s1, const string &s2, Func f);
void useBigger(const string &s1, const string &s2, FuncP2 f); 

using F = int(int*, int);     　　　　　　   // F是函数类型
using PF = int(*) (int*, int);   　　　　   // PF是指针类型
 
PF f1(int);   　　　　　　　　　　　　　　　　 // f1是函数，返回指向函数的指针类型
F* f1(int);           　　　　　　　　　　   // same
F f1(int);   　　　　　　　　　　　　　　　　 // error: F是函数类型，f1不能返回函数类型
 
int (*f1(int))(int*, int); 　　　　　　   // same, f1(int)是函数 -> (*f1(int))函数调用结果可以解引用，是指针 -> 指针指向的类型 int (int*, int)，是函数
auto f1(int) -> int(*)(int*, int);  　　// same