Skip to content

Latest commit

 

History

History
306 lines (223 loc) · 11 KB

C++基础：C++的引用详解.md

File metadata and controls

306 lines (223 loc) · 11 KB
title categories tags
C++的引用详解
开发
cpp
c++
cpp
c++基础

C++的引用详解

1. 引言

概述

在C++中，引用是一种强大的工具，它允许我们创建一个变量的别名。引用本质上是一个变量的另一个名字，但它与指针不同，引用在声明时必须初始化，并且一旦初始化后就不能再绑定到另一个对象。引用在C++中广泛用于函数参数传递和返回值，以提高代码的效率和可读性。

目的

引用在C++中是一个强大的工具，主要用于以下几个方面：

  • 提高代码的可读性：通过使用引用，我们可以避免使用指针的复杂语法，使代码更加简洁和易读。
  • 提高代码的效率：通过引用传递参数，可以避免复制大型对象，从而提高程序的执行效率。
  • 支持高级特性：引用是C++中许多高级特性的基础，如常量引用、右值引用和移动语义。

2. 引用的基本概念

定义

引用是变量的别名，它与指针不同，引用在声明时必须初始化，并且一旦初始化后就不能再绑定到另一个对象。引用本身并不占用额外的内存空间，它只是对现有变量的一个别名。

代码示例和代码解析
#include <iostream>

int main() {
    int a = 10;  // 定义一个整型变量a，并初始化为10
    int& ref = a;  // 定义一个引用ref，它是a的别名

    std::cout << "a = " << a << std::endl;  // 输出a的值
    std::cout << "ref = " << ref << std::endl;  // 输出ref的值，它与a的值相同

    ref = 20;  // 通过引用修改a的值
    std::cout << "a = " << a << std::endl;  // 输出a的值，此时a的值已被修改为20
    std::cout << "ref = " << ref << std::endl;  // 输出ref的值，它与a的值相同

    return 0;
}

代码解析：

  • int a = 10;：定义一个整型变量a，并初始化为10。
  • int& ref = a;：定义一个引用ref，它是a的别名。此时，ref和a指向同一块内存地址，修改ref的值实际上就是修改a的值。
  • ref = 20;：通过引用ref修改a的值，此时a的值被修改为20。

3. 引用的声明与初始化

声明语法

引用的声明语法如下：

类型& 引用名 = 变量名;

其中，类型是引用的基础类型，引用名是引用的名称，变量名是引用所绑定的变量。

代码示例和代码解析
#include <iostream>

int main() {
    int a = 10;  // 定义一个整型变量a，并初始化为10
    int& ref = a;  // 定义一个引用ref，它是a的别名

    std::cout << "a = " << a << std::endl;  // 输出a的值
    std::cout << "ref = " << ref << std::endl;  // 输出ref的值，它与a的值相同

    return 0;
}

代码解析：

  • int a = 10;：定义一个整型变量a，并初始化为10。
  • int& ref = a;：定义一个引用ref，它是a的别名。此时，ref和a指向同一块内存地址，修改ref的值实际上就是修改a的值。

4. 引用的使用场景

函数参数传递

引用在函数参数传递中的应用非常广泛，通过引用传递参数可以避免复制大型对象，从而提高程序的执行效率。

代码示例和代码解析
#include <iostream>

void modifyValue(int& val) {
    val = 20;  // 通过引用修改传入的参数值
}

int main() {
    int a = 10;  // 定义一个整型变量a，并初始化为10
    std::cout << "Before modification: a = " << a << std::endl;

    modifyValue(a);  // 调用函数，通过引用修改a的值
    std::cout << "After modification: a = " << a << std::endl;

    return 0;
}

代码解析：

  • void modifyValue(int& val)：定义一个函数modifyValue，它接受一个引用参数val，并通过引用修改传入的参数值。
  • modifyValue(a);：调用函数modifyValue，通过引用修改a的值，此时a的值被修改为20。
返回值

引用作为函数返回值的使用场景较少，但在某些情况下，它可以提高代码的效率和可读性。

代码示例和代码解析
#include <iostream>

int& getReference(int& val) {
    return val;  // 返回传入参数的引用
}

int main() {
    int a = 10;  // 定义一个整型变量a，并初始化为10
    std::cout << "Before modification: a = " << a << std::endl;

    getReference(a) = 20;  // 通过返回的引用修改a的值
    std::cout << "After modification: a = " << a << std::endl;

    return 0;
}

代码解析：

  • int& getReference(int& val)：定义一个函数getReference，它接受一个引用参数val，并返回该参数的引用。
  • getReference(a) = 20;：通过返回的引用修改a的值，此时a的值被修改为20。

5. 引用的限制与注意事项

不可空引用

引用不能为空，因为它必须绑定到一个有效的对象。如果尝试创建一个空引用，编译器会报错。

不可重新绑定

引用一旦初始化后就不能重新绑定到另一个对象。如果尝试重新绑定引用，编译器会报错。

代码示例和代码解析
#include <iostream>

int main() {
    int a = 10;  // 定义一个整型变量a，并初始化为10
    int b = 20;  // 定义一个整型变量b，并初始化为20

    int& ref = a;  // 定义一个引用ref，它是a的别名
    std::cout << "ref = " << ref << std::endl;  // 输出ref的值，它与a的值相同

    // ref = b;  // 错误：引用不能重新绑定到另一个对象
    // int& nullRef = nullptr;  // 错误：引用不能为空

    return 0;
}

代码解析：

  • int& ref = a;：定义一个引用ref，它是a的别名。
  • // ref = b;：尝试重新绑定引用ref到变量b，这是不允许的，编译器会报错。
  • // int& nullRef = nullptr;：尝试创建一个空引用，这是不允许的，编译器会报错。

6. 引用与指针的比较

相似点

引用和指针都用于间接访问变量，它们都可以用来修改原始变量的值。

不同点
  • 语法：引用使用&符号，指针使用*符号。
  • 初始化：引用在声明时必须初始化，指针可以在声明时不初始化。
  • 重新绑定：引用一旦初始化后不能重新绑定到另一个对象，指针可以随时重新指向另一个对象。
  • 空值：引用不能为空，指针可以为空。
代码示例和代码解析
#include <iostream>

int main() {
    int a = 10;  // 定义一个整型变量a，并初始化为10
    int b = 20;  // 定义一个整型变量b，并初始化为20

    int& ref = a;  // 定义一个引用ref，它是a的别名
    int* ptr = &a;  // 定义一个指针ptr，它指向a

    std::cout << "ref = " << ref << std::endl;  // 输出ref的值，它与a的值相同
    std::cout << "ptr = " << *ptr << std::endl;  // 输出ptr指向的值，它与a的值相同

    ref = b;  // 错误：引用不能重新绑定到另一个对象
    ptr = &b;  // 指针可以重新指向另一个对象

    std::cout << "ref = " << ref << std::endl;  // 输出ref的值，它仍然是a的值
    std::cout << "ptr = " << *ptr << std::endl;  // 输出ptr指向的值，它现在是b的值

    return 0;
}

代码解析：

  • int& ref = a;：定义一个引用ref，它是a的别名。
  • int* ptr = &a;：定义一个指针ptr，它指向a。
  • ref = b;：尝试重新绑定引用ref到变量b，这是不允许的，编译器会报错。
  • ptr = &b;：指针ptr可以重新指向变量b。

7. 高级引用技巧

常量引用

常量引用是指在引用声明时使用const关键字，它表示引用的值不能被修改。常量引用在函数参数传递中非常有用，可以避免意外修改传入的参数。

代码示例和代码解析
#include <iostream>

void printValue(const int& val) {
    // val = 20;  // 错误：常量引用不能被修改
    std::cout << "val = " << val << std::endl;
}

int main() {
    int a = 10;  // 定义一个整型变量a，并初始化为10
    printValue(a);  // 调用函数，传入常量引用

    return 0;
}

代码解析：

  • void printValue(const int& val)：定义一个函数printValue，它接受一个常量引用参数val，并输出该参数的值。
  • // val = 20;：尝试修改常量引用val的值，这是不允许的，编译器会报错。
右值引用

右值引用是C++11引入的一个新特性，它用于支持移动语义。右值引用使用&&符号声明，它可以绑定到右值（如临时对象）。

代码示例和代码解析
#include <iostream>

void printRValue(int&& val) {
    std::cout << "val = " << val << std::endl;
}

int main() {
    int a = 10;  // 定义一个整型变量a，并初始化为10
    printRValue(std::move(a));  // 调用函数，传入右值引用

    return 0;
}

代码解析：

  • void printRValue(int&& val)：定义一个函数printRValue，它接受一个右值引用参数val，并输出该参数的值。
  • printRValue(std::move(a));：调用函数printRValue，传入右值引用，使用std::move将a转换为右值。

8. 引用在实际项目中的应用

案例分析

在实际项目中，引用通常用于以下场景：

  • 避免复制大型对象：通过引用传递参数，可以避免复制大型对象，从而提高程序的执行效率。
  • 实现链式调用：通过返回引用，可以实现链式调用，使代码更加简洁和易读。
代码示例和代码解析
#include <iostream>

class MyClass {
public:
    MyClass& setValue(int val) {
        this->value = val;
        return *this;  // 返回当前对象的引用，实现链式调用
    }

    void printValue() const {
        std::cout << "value = " << value << std::endl;
    }

private:
    int value;
};

int main() {
    MyClass obj;
    obj.setValue(10).setValue(20).printValue();  // 链式调用

    return 0;
}

代码解析：

  • MyClass& setValue(int val)：定义一个成员函数setValue，它接受一个整型参数val，并返回当前对象的引用，实现链式调用。
  • obj.setValue(10).setValue(20).printValue();：通过链式调用设置对象的值，并输出最终的值。

9. 总结

引用是C++中一个强大的工具，它允许我们创建一个变量的别名。引用在函数参数传递和返回值中非常有用，可以提高代码的效率和可读性。引用与指针不同，引用在声明时必须初始化，并且一旦初始化后就不能再绑定到另一个对象。

建议读者进一步学习C++的高级特性，如智能指针、模板和移动语义，这些特性在实际项目中非常有用。

文章合集：chongzicbo/ReadWriteThink: 博学而笃志，切问而近思 (github.com)

个人博客：程博仕

微信公众号：

微信公众号