函数默认参数
C++允许函数设置默认参数，在调用时可以根据情况省略实参。规则如下:
- 默认参数只能按照右到左的顺序
void print(int a,int b = 100)
{
cout << "a is " << a << endl;
cout << "b is " << b << endl;
}
- 如果函数同时有声明、实现，默认参数只能放在函数声明中
void print(int a,int b = 100);
int main(int argc, const char * argv[]) {
print(10);
return 0;
}
void print(int a,int b)
{
cout << "a is " << a << endl;
cout << "b is " << b << endl;
}
-
默认参数的值可以是常量、全局符号(全局变量、函数名)
常量上面有所举例，这里举一个全局变量和函数名作为参数的列子如下代码所示:
//定义一个全局变量
int number = 10000;
void print(int a,int b = number)
{
cout << "a is " << a << endl;
cout << "b is " << b << endl;
}
int main(int argc, const char * argv[]) {
print(10);
return 0;
}
//定义一个函数指针
typedef void(*FuncBlock)(int a,int b);
void block(int a,int b)
{
cout << "block a is " << a << endl;
cout << "block b is " << b << endl;
}
void print(int a,FuncBlock fun = block)
{
cout << "a is " << a << endl;
//利用函数指针真正调用block函数
block(10, 10);
}
int main(int argc, const char * argv[]) {
//调用函数，函数默认为block
print(100);
return 0;
}
注意：函数默认参数可能会与函数重载会产生冲突，造成调用不明确，需要避免，建议优选选择函数默认参数
void print(int a,int b = 100)
{
cout << "a is " << a << endl;
cout << "b is " << b << endl;
}
void print(int a)
{
cout << "a is " << a << endl;
}
int main(int argc, const char * argv[]) {
//调用错误
//call to 'print' is ambiguous
print(100);
return 0;
}
内联函数
定义:使用inline修饰过的函数的声明或者实现，
建议声明和实现都增加inline修饰。内联函数特点和注意事项如下:
- 编译器会将函数调用直接展开为函数体代码
- 可以减少函数调用的开销
- 会增大代码体积
- 内联函数尽量不要内联超过10行代码的函数
- 有些函数即使声明为inline，也不一定会被编译器内联，比如递归函数
内联函数和宏，都可以减少函数调用的开销相比宏，内联函数多了语法检测和函数特性，宏只是单纯的替换， 注意下以下代码区别:
#define sum(x) (x + x) //结果为21
inline int sum(int x) { return x + x; } //结果为20
int a = 10; sum(a++);
引用
引用相当于是变量的别名，包括基本数据类型、枚举、结构体、类、指针、数组等，都可以有引用。我们先来看下基本类型的引用如下:
int age = 100;
int &rage = age; //rage就是age的引用
rage = 101;//改变引用rage的值，也修改了age的值
cout << rage << endl; //101
cout << age << endl; //101
再来看结构体和指针的引用:
struct Person {
int age;
};
//结构体对象的引用
Person p;
Person &rp = p;
rp.age = 18;
cout << p.age << endl; //18
//指向结构体对象指针的引用
Person *pp = new Person();
Person *&rpp = pp; //pp指针的引用rpp
rpp->age = 19;
cout << pp->age << endl; //19
数组的引用如下:
int array[] = { 10, 20, 30 };
int (&rArray)[3] = array; //这里定义数组的引用，这里必须指明 数组元素个数
cout << rArray[0] << endl; //10
使用引用的注意事项:
- 引用必须初始化，且一旦初始化就不能再改变成其他变量的引用
- 可以用引用初始化另一个引用，即存在一个变量多个别名
- 对变量引用的操作其实就是对变量本身的操作
- 不存在引用的引用，引用数组,指向引用的指针
//一个变量多个引用
int age = 100;
int number = 1000;
int &rage = age; //rage就是age的引用
int &rage1 = rage; //rage1也是age的引用
int &rage2 = age; //rage2也是age的引用
&rage = number; //错误，引用是不能再被改变成其他变量的引用
int &arry[4]; //错误，不存在引用数组
int& *rpage = rage; //错误，没有引用类型的指针
int *page = &rage; //正确，对引用取地址其实就是对变量取地址，再用指针指向这个地址
常引用
我们都知道经过const修饰过的变量会变成常量，跟const的位置也有关，这里我们再来复习下const修饰变量的用法:
int age = 10;
// *p0是常量，p0不是常量(指针指向地址里面存的值不可改，指针指向地址可以改)
const int *p0 = &age;
// *p1是常量，p1不是常量(跟上述一样）
int const *p1 = &age;
// p2是常量，*p2不是常量(指针指向地址里面存的值可以改，指针指向地址不可改)
int * const p2 = &age;
// *p3是常量，p3是常量(指针指向地址里面存的值不可改，指针指向地址不可改)
const int * const p3 = &age;
// *p4是常量，p4是常量（跟上述一样）
int const * const p4 = &age;
通过const修饰的结构体对象，代码如下:
struct Person {
int age;
};
Person per1 = { 10 };
Person per2 = { 20 };
//此时nPer指向不可更改，nPer指向对象里面的内容可以更改
Person * const pPer = &per1;
*pPer = per2; //正确
(*pPer).age = 30;//正确
pPer->age = 40;//正确
pPer = &per2; //错误，不可改
//此时nPer1指向可以更改，但是nPer1指向对象不可更改
const Person * pPer1 = &per1;
*pPer1 = per2; //错误
(*pPer1).age = 30;//错误
pPer1->age = 40;//错误
pPer1 = &per2;//正确
常引用：被const修饰的引用不可更改，称为常引用
int age = 10;
int number = 20;
//定义一个常应用
const int &rage = age;
rage = 20;//无法修改，报错
&rage = number;//无法修改，引用没有这种写法
//定义一个const指针
const int * const page = &age;
*page = 20;//无法修改，报错
page = &number//无法修改，报错
最后补充一个常引用知识点：当常引用指向了不同类型的数据时，会产生临时变量，即引用指向的并不是初始化时的那个变量
int age = 10;
const int &rAge = age;
age = 30;
//age is 30
cout << "age is " << age << endl;
//rAge is 10
cout << "rAge is " << rAge << endl;
细心同学通过上述代码发现了引用和指针达到的效果好像差不多，既然存在了指针，为什么C++还要用引用呢？这就涉及到引用的本质，它存在的价值是什么？我们后面再介绍，敬请期待。
