初始C++之缺省参数 函数重载 引用&
文章目录
- 初始C++之缺省参数 函数重载 引用&
- 一、缺省参数
- 1.1 缺省参数的定义
- 1.2 缺省参数的分类
- 1.3 注意事项
- 二、 函数重载
- 2.1 函数重载的定义
- 2.2 参数个数不同
- 2.3 参数类型不同
- 2.4 类型顺序不同
- 2.5 为什么C语言不支持函数重载
- 三、引用 &
- 3.1 引用的定义
- 3.2 引用的特性
- 3.3 引用的权限
- 3.4 引用和指针的区别
一、缺省参数
1.1 缺省参数的定义
定义：缺省参数是指在声明或定义函数时，给函数参数指定一个缺省值，再调用函数时，如果没有指定实参，则采用形参的缺省值，否则则使用指定的实参
示例：
void Func1(int a = 10)
{
cout << a << endl;
}
int main()
{
Func1();//不指定传参，则打印缺省值
Func1(100);//指定传参，打印指定值
return 0;
}
代码运行结果：
10
100
1.2 缺省参数的分类
• 半缺省参数
半缺省参数：指的是在函数的声明或定义中，只有部分参数指定了缺省值
示例：
void Func2(int a,int b = 20,int c = 30)
{
cout <<"a = " << a << endl;
cout <<"b = " << b << endl;
cout <<"c = " << c << endl;
}
int main()
{
Func2(50);//半缺省参数，指指定a的值
return 0;
}
• 全缺省参数
全缺省参数：指的是在函数的声明或定义中，给所有参数都指定了缺省值
示例：
void Func3(int a = 10, int b = 20, int c = 30)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
int main()
{
Func3();//不指定值，打印缺省值
return 0;
}
1.3 注意事项
1. 缺省参数只能从左往右给，不能间隔的给
2. 缺省参数不能在函数定义或函数声明中同时出现（如果同时出现两个不同的缺省值，编译器不知道该使用哪一个）
3. 缺省值必须是常量或者全局变量
4. C语言不支持缺省参数（编译器不支持）
二、 函数重载
2.1 函数重载的定义
函数重载：是函数的一种特殊情况，在C++中，同一个作用域内，可以声明几个功能类似的同名函数，这些函数的参数列表（参数个数，类型，类型顺序）不同
2.2 参数个数不同
#include <iostream>
using namespace std;
void Func()
{
cout << "Func()" << endl;
}
void Func(int a)
{
cout << "Func(int a)" << endl;
}
int main()
{
Func();
Func(10);
return 0;
}
2.3 参数类型不同
#include <iostream>
using namespace std;
// 1. 参数类型不一样
void Swap(int* px, int* py)
{
int tmp = *px;
*px = *py;
*py = tmp;
cout << "Swap(int* px, int* py)" << endl;
cout << "a = " << *px << "b = " << *py << endl;
}
void Swap(double* px, double* py)
{
double tmp = *px;
*px = *py;
*py = tmp;
cout << "Swap(double* px, double* py)" << endl;
cout << "a = " << *px << "b = " << *py << endl;
}
int main()
{
int a = 10, b = 20;
double c = 10.6,d = 30.5;
Swap(&a,&b);
Swap(&c,&d);
return 0;
}
2.4 类型顺序不同
void f(int a, char b)
{
cout << "f(int a, char b)" << endl;
}
void f(char a, int b)
{
cout << "f(char a, int b)" << endl;
}
int main()
{
f(10, 'a');
f('a', 10);
return 0;
}
2.5 为什么C语言不支持函数重载
在函数定义和声明分离的情况下，在经过编译之后，在链接的时候，编译器会通过函数名来找到函数的地址，而函数的地址，在函数定义中的第一句指令的地址（类似与数组的地址是数组第一个元素的地址），在C语言中，链接时，是直接通过函数名来查找函数的地址的，比如有一个Add(int a,int b)函数，不同的编译器有不同的函数名修饰规则，假设是直接使用Add这个函数名来找到他的定义，所以C语言不支持重载，而在C++中会使用修饰之后的函数名查找，假设是 _Z3Addii 来查找，由于参数列表的不同，可以区分出不同的重载函数，所以C++中支持函数重载
简单来说就是，C语言是直接通过函数名来查找，所以不支持重载
而C++中是通过修饰后的函数名来查找（不同参数列表修饰出来的名字不同），可以区分出来，所以支持重载
三、引用 &
3.1 引用的定义
引用：引用不是定义一个新的变量，是给一个已经存在的变量取一个别名，编译器不会为引用变量开辟空间，它和被引用的变量公用一块内存空间
示例：
#include <iostream>
using namespace std;
int main()
{
int a = 10;
int& b = a;
int& c = a;
int& d = c;
cout << a << " " << b << " " << c << endl;
return 0;
}
代码运行结果：
10 10 10 10
引用的地址和值是和被引用变量一致的
3.2 引用的特性
TIPS：
1. 引用变量必须初始化
2. 一个变量可以有多个引用
3. 引用一旦指定一个变量，就不能改变
4. 引用必须和引用的变量是同一类型的
示例1：引用变量必须初始化
#include <iostream>
using namespace std;
int main()
{
int& a;
return 0;
}
示例2：一个变量可以有多个引用
#include <iostream>
using namespace std;
int main()
{
int a = 10;
int& b = a;
int& c = a;
return 0;
}
示例3：引用一旦指定一个变量，就不能改变
#include <iostream>
using namespace std;
int main()
{
int x = 10;
int y = 20;
int& b = x;
b = y; //不是b变成y的别名 而是y给b赋值，由于b是x的别名，同时x值也改变了
cout << x << endl;
return 0;
}
代码运行结果：
20
示例4：引用必须和引用的变量是同一类型的
#include <iostream>
using namespace std;
int main()
{
int x = 10;
double& y = x;
return 0;
}
3.3 引用的权限
- 权限的平移
#include <iostream>
using namespace std;
int main()
{
int x = 10;
int& y = x;
return 0;
}
- 权限的缩小
#include <iostream>
using namespace std;
int main()
{
int x = 10;
const int& y = x;//从可以修改变成了只读
return 0;
}
- 权限的放大
#include <iostream>
using namespace std;
int main()
{
const int x = 10;
int& y = x; //x只读，y变成x的别名，x变成了可读可写
//权限的放大 不可以
return 0;
}
3.4 引用和指针的区别
- 引用实际上是一个变量的别名，指针是存放一个变量的地址
- 引用必须初始化，指针可以不初始化
- 在语法上，引用不开辟空间，指针有开辟空间（从底层来看，引用实际上是有开空间的）
- 引用在引用了一个变量之后，不能再引用其他变量，指针在指向了一个变量，还可以更改指向，指向其他变量
- 没有NULL引用，但是有NULL指针
- 用sizeof计算大小时，引用占用为引用变量的类型的大小，指针则是固定4个字节（32位平台下）或 8个字节（64位平台下）
- 没有多级引用，有多级指针
- 引用比指针用起来相对安全
