c++（引用、函数）-CSDN博客

本文链接：https://blog.csdn.net/weixin_74056357/article/details/130230081

文章详细介绍了C++中的引用，包括其作为函数参数和返回值的使用，以及引用的本质和注意事项。此外，还讨论了函数的默认参数、占位参数、重载以及在函数重载中引用和默认参数的特殊考虑。特别强调了引用必须初始化，且一旦初始化后不能更改，以及常量引用的作用在于保护实参不被修改。

摘要由CSDN通过智能技术生成

引用&

基本语法

给变量起别名
数据类型 & 别名 = 原名
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);
}