c++（引用、函数）

目录

• 引用&
• • 基本语法
  • 注意事项
  • 引用做函数参数
  • 引用做函数返回值
  • 引用的本质
  • 常量引用
• 函数
• • 函数默认参数
  • 函数占位参数
  • 函数重载
  • 函数重载的注意事项（引用&、默认参数）

引用&

基本语法

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

---

---

函数

函数默认参数

1. 如果自己传入数据，就用自己的数据，如果没有，那就用默认值
2. 语法：函数返回类型 函数名（ 形参 = 默认值 ）{ 函数主体部分 }
3. 注：
   • 如果一个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值
   • 如果函数声明有默认参数，函数实现就不能有默认参数（即声明和实现的默认参数二选一）
     • 声明：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);
}

---

函数重载

• 作用：让函数名相同，提高复用性

• 满足条件：----（缺一不可）
  1. 同一个作用域下 （指的是这些fun函数都定义在全局作用域内）
  2. 函数名称相同
  3. 函数参数类型不同，或者 顺序不同，或者 个数不同

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