一、引用的概念
1.什么是引用
通俗的讲,引用就是某个变量或对象的别名,引用不是新的变量。引用只作为某个变量或对象的别名来使用,对引用的改动就是对用来初始化的变量或对象的改动。
引用不是变量或对象,它不占内存空间。引用只是替代某个变量或对象的别名。引用有值,它的值是被引用的变量的值;引用有类型,它的类型也是被引用的变量的类型。
2.引用的基本用法
数据类型& 别名 = 原名
示例
#include<iostream>
using namespace std;
int main()
{
int a = 10;
//通过引用的方式给a取别名b
//数据类型& 别名 = 原名
int& b = a;
//a,b代表同一块内存空间,且a,b的地址都是相同的
cout << "a = " << a << endl; //输出a
cout << "b = " << b << endl; //输出b
}
3.引用的注意事项
1、引用必须初始化
2、引用初始化后,不可以改变
示例
//引用的基本语法与注意事项
#include<iostream>
using namespace std;
int main()
{
//1.引用必须初始化
//int& b; //错误,必须初始化
int a = 10;
int& b = a;
//2.引用初始化后,不可以改变
int c = 20;
b = c;//此为赋值操作,而不是改变引用,可行
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
return 0;
}
运行结果
二、引用的应用
引用在C++程序中通常作为函数参数和函数的返回值
1.引用作函数参数
作用:函数传参时,可以利用引用技术让形参修饰实参
优点:可以简化指针修改实参
示例
//引用做函数参数
#include<iostream>
using namespace std;
//作用:函数传参时,可以利用引用技术让形参修饰实参
//优点:可以简化指针修改实参
//交换函数
//1.值传递
void mySwap01(int a, int b)
{
int temp = a;
a = b;
b = temp;
//cout << "Swap01 a = " << a << endl;//形参确实改变生效了
//cout << "Swap01 b = " << b << endl;
}
//2.地址传递
void mySwap02(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
//3.引用传递
void mySwap03(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
int main()
{
int a = 10;
int b = 20;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
//mySwap01(a,b); //值传递,形参并没有修饰实参
//mySwap02(&a, &b); //地址传递,形参是会修饰实参的
mySwap03(a, b); //引用传递,形参也会修饰实参的
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
mySwap01(a, b)运行结果:通过值传递,形参没有修饰实参,最后结果a与b的值没有交换,但在交换函数内部实现了a与b的值交换。
mySwap02(&a, &b)运行结果:通过地址传递,形参修饰实参,a与b的值互换。
mySwap03(a, b)运行结果:通过引用作为函数参数,形参修饰实参,a与b的值交换 。
2.引用作为函数的返回值
一般函数返回值时都要建立临时变量,即用来拷贝副本。具体实现是:先将返回表达式的值传递给临时变量,返回到主函数后,再将临时变量的值传递给接收函数返回值的变量。但是,返回引用时,并不产生副本,而是将其返回值直接传递给接收函数返回值的变量或对象。这里应该避免返回值为局部变量的情况,否则容易出现问题。
注意1:不要返回局部变量的引用
示例
//引用做函数的返回值
#include<iostream>
using namespace std;
//1.不要返回局部变量的引用
int& test01()
{
int a = 10;//局部变量存放在四区中的栈区
//栈区局部变量的特点就是在这个函数执行完之后就会释放
return a; //返回局部变量的引用
}
int main()
{
int& ref = test01();
cout << "ref = " << ref << endl;//第一次的结果可能正确,正确是因为编译器做了保留
cout << "ref = " << ref << endl;//第二次结果将错误,因为a的内存已经释放
return 0;
}
运行结果
注意2:函数的调用可以作为左值
//引用做函数的返回值
#include<iostream>
using namespace std;
//2.函数的调用可以作为左值
int& test02()
{
static int a = 10;//静态变量,已经不存放在栈区中,存放在全局区,全局区上的数据在程序结束后系统释放
return a;//返回a的引用(别名),相当于把a变量返回
}
int main()
{
int& ref2 = test02(); //ref2是a的别名
cout << "ref2 = " << ref2 << endl;//多输出几行,结果一样。
cout << "ref2 = " << ref2 << endl;
cout << "ref2 = " << ref2 << endl;
//a不会因为test02()执行完就被释放,而是在整个程序都运行完了才会被释放 静态变量a
//如果函数的返回值是引用,这个函数调用可以作为左值(等号的左边)
test02() = 1000; //函数的调用作为左值存在并且给它赋值1000
//相当于a = 1000;
cout << "ref2 = " << ref2 << endl;
cout << "ref2 = " << ref2 << endl;
return 0;
}
运行结果
三、引用的本质
本质:引用的本质在C++内部实现的是一个指针常量。
就是一个指针常量,引用一旦初始化后就不可以更改。
实际操作的时候只需要将其视为别名即可。
示例
#include<iostream>
using namespace std;
//发现是引用,转化为int * const ref = &a;
void func(int& ref)
{
ref = 100; //ref是引用,转化为*ref = 100;
}
int main()
{
int a = 10;
int& ref = a;
//编译器识别到引用自动转化为int* const ref = &a;指针常量是指针指向不可更改,也说明为什么引用不可以更改
ref = 20; //内部发现ref是引用,自动帮我们转化为:*ref = 20;
cout << "a = " << a << endl;
cout << "ref = " << ref << endl;
func(a);
return 0;
}
引用初始化后就不可以发生改变(即ref可以做a的别名就不可以做别的内存块的别名)就是因为 引用的本质里面有一个const,有了const就限定了它只能指向一个地方,不能指向别的地方。
四、常量引用
作用:常量引用主要用来修饰形参,防止误操作
在函数形参列表中,可以加const修饰形参,防止形参改变实参
使用引用作为函数参数,可以在函数调用时实参不产生副本,进而提高运行效率。但是为了保护实参不被修改,需要对引用使用const进行限制。
当一个函数的参数被设定为const类型时,它的值就不允许被改变。这是只有通过返回值和其它方法来进行函数间的数据传递。使用const来限制引用参数,可以保护调用函数的实参不被改变,在某种意义上提高了安全性,又具有传递实参值时不复制副本的特点。
示例 1
#include<iostream>
using namespace std;
int main()
{
/*常量引用
使用场景:用来修饰形参,防止误操作*/
int a = 10;
//int &ref = 10; //引用本身需要一个合法的内存空间,因此这行错误
/*加入const就可以了,编译器优化代码
加上const之后,编译器将代码修改 int temp = 10; const int &ref = temp;*/
const int &ref = 10; //引用必须为一块合法的内存空间,这行正确
/*
ref = 100; //加入const之后不可以修改变量,表达式必须是可修改的左值
ref = 20; //加入const之后变为只读,不可以修改
*/
return 0;
}
示例2. 函数中利用常量引用防止误操作修改实参
#include<iostream>
using namespace std;
//打印数据函数
//引用使用的场景,通常用来修饰形参
void showValue(int& val)
{
val = 1000;
cout << "val = " << val << endl;
}
int main()
{
/*常量引用
使用场景:用来修饰形参,防止误操作*/
//函数中利用常量引用防止误操作修改实参
int a = 100;
showValue(a);
cout << "a = " << a << endl;
return 0;
}
正常打印val值, 此时a值也改变为1000,修改了val的值,函数外边a的值也跟着修改了,为了防止这类误操作,在形参加入const来修饰,改正后代码如下:
#include<iostream>
using namespace std;
//打印数据函数
//引用使用的场景,通常用来修饰形参
void showValue(const int& val)
{
//val = 1000;//加入const之后会报错,不能在函数体内修改数据了,这样函数外部的a就不会发生改变了
cout << "val = " << val << endl;
}
int main()
{
/*常量引用
使用场景:用来修饰形参,防止误操作*/
//函数中利用常量引用防止误操作修改实参
int a = 100;
showValue(a);
cout << "a = " << a << endl;
return 0;
}
五 、函数默认参数
在C++中函数的形参列表是可以有默认值的
语法:返回值类型 函数名 (参数 = 默认值){ }
示例
//C++函数默认参数
//在C++中函数的形参列表是可以有默认值的
//语法:返回值类型 函数名 (参数 = 默认值){}
#include<iostream>
using namespace std;
int func(int a, int b, int c)
{
return a + b + c;
}
int main()
{
cout << func(10, 20, 30) << endl;
return 0;
}
运行结果:正常输出
示例:给b、c默认值
//C++函数默认参数
//在C++中函数的形参列表是可以有默认值的
//语法:返回值类型 函数名 (参数 = 默认值){}
#include<iostream>
using namespace std;
int func(int a, int b = 20, int c = 30)//给b、c一个默认值,就可以省去调用函数的20和30
{
return a + b + c;
}
int main()
{
//cout << func(10, 20, 30) << endl;
cout << func(10) << endl;//省去20和30
return 0;
}
运行结果
示例 :调用函数时给a,b赋值
//C++函数默认参数
//在C++中函数的形参列表是可以有默认值的
//语法:返回值类型 函数名 (参数 = 默认值){}
#include<iostream>
using namespace std;
int func(int a, int b = 20, int c = 30)//给b、c一个默认值,就可以省去调用函数的20和30
{
return a + b + c;
}
int main()
{
//cout << func(10, 20, 30) << endl;
cout << func(10, 30) << endl;//给b赋值30
return 0;
}
运行结果:优先用调用函数所传的值。
如果调用函数传了值就用所传值,若没有传值就用默认值
注意事项
1、 如果某个位置已经有了默认参数,那么从这个位置往后,从左到右都必须有默认值
报错是因为如果某个位置已经有了默认参数,那么从这个位置往后,从左到右都必须有默认值
2.如果函数的声明有了默认参数,函数实现就不能有默认参数
并没有波浪号报错,但是运行后:
若声明和实现的默认参数不一样,编译器会出现歧义,虽然没打波浪号,但运行会错误
声明和实现只能有一个默认参数
将自己传的参数删掉之后,也可以运行成功
把声明的默认值删掉,在实现中给默认值,运行成功
六、 函数占位参数
C++中函数的形参列表里可以有占位参数,用来做占位,调用函数时必须填补该位置。
语法:返回值类型 函数名(数据类型){ }
//函数的占位参数
//C++中函数的形参列表里可以有占位参数,用来做占位,调用函数时必须填补该位置、
//语法:返回值类型 函数名(数据类型){}
#include<iostream>
using namespace std;
//占位参数
//第二个int是占位用的
//占位参数还可以有默认参数
void func(int a, int = 10)
{
cout << "this is func" << endl;
}
int main()
{ //必须有第二个int参数,除非有默认参数
func(10);
return0;
}