引用&
基本语法
- 给变量起别名
数据类型 & 别名 = 原名
int &b = a
- 下图a,b是同一个东西,当改b=20时,a也会变成了20
注意事项
引用必须要初始化
—>必须要有一个合法的内存空间(数据要么在栈区,要么在堆区)
- int &b = a; 这叫做引用初始化,将他初始化为a (Y)
- int &b ; 这就只定义了一个引用b,没有进行初始化(N)
- int &b = 10; 引用必须绑定到一个对象上,而不能绑定到一个字面量上 (N)—>因为10存在常量区
- const int &b = 10 ; const引用可以绑定到一个字面量,因为 const 保证了引用所绑定的值不会被修改 (Y)
引用一旦初始化后,就不能更改了
int a=10;
int &b; //错,没有初始化
int &c=a;
int &d=a;
int &e=a; //可以,表示cde均为a的别名(a有多个外号)
int a=10;
int &b=a;
int c=20;
b=c; //错,引用类型b已经是a的了(是a的别名、外号),不能再将他改嫁给c(外号哪有说给就给)
引用做函数参数
- 函数传参:
值传递、地址传递、引用传递
- 下面为交换a,b值
// 值传递
void swapByValue(int a, int b) {
int temp = a;
a = b;
b = temp;
}
// 地址传递
void swapByPointer(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
// 引用传递
void swapByReference(int& a, int& b) { //这里的a是main()里a的别名,他代表的就是main的a ...b同理
int temp = a;
a = b;
b = temp;
}
int main() {
int a = 3, b = 5;
// 值传递(形参不会修饰实参)
swapByValue(a, b);
// 地址传递
swapByPointer(&a, &b);//使用了指针来传递参数,因此在调用该函数时,需要将a和b的地址传递给它
// 引用传递
swapByReference(a, b);//使用了引用来传递参数,因此在调用该函数时,只需要直接传递a和b即可
}
引用做函数返回值
1.
不要
返回局部变量的引用
2. 函数的调用可以
作为左值
int global_var = 10; //全局变量
// 不要返回局部变量的引用
// 这里返回的引用实际上指向了已经被销毁的内存空间
int& get_local_reference()
{
int local_var = 20; //局部变量存放在四区中的 栈区
return local_var;
}
// 返回全局变量的引用是安全的
int& get_global_reference()
{
return global_var;
}
//静态变量,存放在全局区,全局区上的数据在程序结束之后系统释放
int& static_local_reference()
{
static int a = 10;
return a;
}
int main() {
int& ref = get_local_reference();
// 因为 get_local_reference() 返回的是一个已经被销毁的内存空间的引用
// 所以这里的操作是未定义的行为
cout << ref << endl ; //segmentation fault (core dumped)
// 函数调用可以作为左值
int& ref2 = get_global_reference();
int& a = static_local_reference();
ref2 = 40;
static_local_reference() = 666;
cout << global_var << endl ;
cout << ref2 << endl ;
cout << a << endl; // 输出 40 40 666
return 0;
}
引用的本质
- 本质:内部实现是一个指针常量
- 一开始定义了变量a ----地址为0x0011
- 然后定义了一个const修饰的
指针常量
ref指向0x0011这块地址- 由于是
const修饰,所以不能更改ref指向的地址
----即让ta指向0x0022是不行的
- 这就是之前学的 “引用一旦初始化,就不可以改变 ”
在后面比如说进行ref的输出时,会在内部进行一个
解引用
,读出ref指向的值为多少,而我们就直接cout << ref 就行了
常量引用
- 修饰形参,防止误操作
- 防止形参改变实参
定义了一个函数 func,该函数的参数使用了常量引用,即
const
int& num。这表示在函数内部,我们不能修改 num 的值。
void func(const int& num) {
// 下面代码尝试修改 num,编译器会报错
// num = 10;
cout << num << endl;
}
int main() {
int num = 5;
func(num);
return 0;
}
函数
函数默认参数
- 如果自己传入数据,就用自己的数据,如果没有,那就用默认值
- 语法:
函数返回类型 函数名( 形参 = 默认值 ){ 函数主体部分 }
- 注:
- 如果一个位置已经有了默认参数,那么从这个位置往后,从左到右都必须有默认值
- 如果函数声明有默认参数,函数实现就不能有默认参数(即声明和实现的默认参数二选一)
- 声明:main()前的函数名;
- 实现:main()后面有函数名+函数主体的
int fun(int a , int b = 20 , int c = 30)
{
return a+b+c;
}
int main()
{
fun(); // 报错:"函数调用中的参数太少",因为函数中int a没有默认参数,那就必须传一个进去
fun(10); //60
fun(10,10); //50 (a和b都被提供了,但c仍然使用默认值)
}
函数占位参数
返回值类型 函数名(数据类型){函数主体}
- 占位参数可以有默认参数 int = 10
void fun(int a, int)
{
...
}
int main()
{
fun(10 ,10);
}
函数重载
- 作用:让函数名相同,提高复用性
- 满足条件:----(缺一不可)
- 同一个作用域下 (指的是这些fun函数都定义在全局作用域内)
- 函数名称相同
- 函数参数类型不同,或者 顺序不同,或者 个数不同
void fun(int x) {
std::cout << "fun(int): " << x << std::endl;
}
void fun(float x) {
std::cout << "fun(float): " << x << std::endl;
}
void fun(int x, float y) {
std::cout << "fun(int, float): " << x << ", " << y << std::endl;
}
void fun(float x, int y) {
std::cout << "fun(float, int): " << x << ", " << y << std::endl;
}
void fun(char c, int x, float y) {
std::cout << "fun(char, int, float): " << c << ", " << x << ", " << y << std::endl;
}
int main() {
fun(10);
fun(3.14f);
fun(20, 4.5f);
fun(2.0f, 30);
fun('a', 10, 3.14f);
}
- 注:函数的返回值不同 不能作为函数重载的条件
int fun (int a) { }
double fun (int a) { }
所以这个不行!!!
函数重载的注意事项(引用&、默认参数)
- 引用作为重载的条件
// 定义一个函数重载,一个使用 int 引用参数,一个使用 const int 引用参数
void func(int& x){
cout << "func(int& x)" << endl;
x++;
}
void func(const int& x){
cout << "func(const int& x)" << endl;
}
int main() {
int a = 10;
const int b = 20;
// 调用 func(int&) 函数
func(a);
// 调用 func(const int&) 函数
func(b);
func(20); //因为int& x = 20 不合法
}
- 函数重载碰到默认参数
- 此时会出现二义性,报错
void func(int& x){
cout << "func(int& x)" << endl;
x++;
}
void func(const int& x){
cout << "func(const int& x)" << endl;
}
// 定义一个带默认参数的函数
void func(int x, int y = 0) {
cout << "func(int x, int y = 0)" << endl;
}
int main() {
int a = 10;
const int b = 20;
// 调用 func(const int&)、func(int x, int y = 0) 函数 ---报错
func(b);
func(10);
// 调用 func(int& x)、func(int x, int y = 0) 函数 ---报错
func(a);
// 调用 func(int x, int y = 0)函数 ---ok
func(a, 1);
}
结论:
- 管他是int a还是const int a还是常数,函数参数是int类型的话,一律接收
- 函数参数有引用&时,就要考虑串传进来的是什么类型的了,有没有const