c++--指针与引用

引用和指针在 C++ 等编程语言中都是用来处理内存地址的概念，但它们之间确实存在一些重要的区别。

目录

1.不存在空引用：

2.不可重新绑定：

3.初始化时机：

4. 指针与引用的区别：

5.函数引用：

5.1 作为参数（会改变原始值）

5.2 返回引用

5.1.1.定义返回引用的函数：

5.2.1 完整代码示例：

5.3 常量引用

5.3.1. 定义和语法

5.3.2. 特性

5.3.3 完整代码示例

1.不存在空引用：

引用：一旦声明，引用必须连接到一个合法的对象。不能创建空引用。例如，如果你有一个引用类型的变量，必须在声明时直接初始化为一个有效的对象。

指针：可以指向 null（空），意味着它可以没有指向任何有效的内存地址。这样可以用来表示"无效"或"未初始化"状态。

2.不可重新绑定：

引用：一旦引用被初始化为某个对象，就无法改变它所引用的对象。这意味着引用的生命期与所引用对象的生命期相同。你不能让一个引用指向另一个对象。
指针：指针可以在任何时候指向不同的对象。这意味着你可以改变指针的指向，使其指向不同的内存地址。

3.初始化时机：

引用：必须在声明时进行初始化。你在创建引用时就必须给它一个有效的对象。
指针：可以在声明后随时进行初始化，甚至可以在之后的代码中随时改变指向的对象。

将变量名称和引用比作内存位置中的标签是一种很好的方式来解释它们之间的关系

#include <iostream>

void demonstrateLabelConcept() {
    int a = 10; // 变量 a
    int& ref = a; // 引用 ref 指向 a

    // 通过变量名称访问
    std::cout << "a: " << a << std::endl; // 输出 10

    // 通过引用访问
    std::cout << "ref: " << ref << std::endl; // 输出 10

    // 修改值
    ref = 20; // 通过引用修改 a 的值
    std::cout << "After modifying ref..." << std::endl;
    std::cout << "a: " << a << std::endl; // 输出 20
    std::cout << "ref: " << ref << std::endl; // 输出 20
}

int main() {
    demonstrateLabelConcept();
    return 0;
}

输出：

a: 10
ref: 10
After modifying ref...
a: 20
ref: 20

4. 指针与引用的区别：

5.函数引用：

5.1 作为参数（会改变原始值）

引用作为参数在C++中非常常见，它允许函数直接操作传入的变量，而不是对其进行拷贝。这不仅提高了性能，尤其是对于大型对象，也使得在函数内部修改参数的值变得更加方便。

#include <iostream>

void updateValue(int& ref) {
    ref += 10; // 直接修改引用所指向的值
}

int main() {
    int number = 5;
    std::cout << "Before: " << number << std::endl; // 输出 5
    
    updateValue(number); // 传递 number 的引用
    std::cout << "After: " << number << std::endl; // 输出 15
    
    return 0;
}

如果函数参数是 int ref（没有 &），那么将是按值传递，这样函数内部的任何修改都不会影响到原始变量。
但在这个例子中，因为使用了引用，updateValue 函数内部的 ref += 10; 实际上是在修改 number 的值。

5.2 返回引用

在 C++ 中，返回引用允许函数返回一个对变量的别名，返回引用：当一个函数返回引用时，它返回的是一个对原始变量的别名，而不是其值。

5.1.1.定义返回引用的函数：

在函数的返回类型前加上 &，表示该函数返回的是一个引用。

int& getReference(int& ref) {
    return ref; // 返回对 ref 的引用
}

5.2.1 完整代码示例：

1. 变量和引用的定义
     number 是一个普通的整型变量，初始值为 5。
     refToNumber 是一个整型引用，使用 int& 定义。引用实际上是一个别名，它并不占用额外的内存空间，而是指向一个已存在的变量。
2. 引用的行为
     当你调用 getReference(number) 时，你实际上传递了 number 的引用。这意味着 ref 在 getReference 函数内部指向的就是 number。
      return ref; 返回的是 ref 的引用，这个引用依然指向 number。因此，refToNumber 成为了 number 的别名。
3. 修改的效果
     当你执行 refToNumber += 10; 时，实际上是修改了 number 的值，因为 refToNumber 是 number 的引用。修改引用的内容就相当于修改原始变量的内容

#include <iostream>

int& getReference(int& ref) {
    return ref; // 返回引用
}

int main() {
    int number = 5; // 初始化变量
    std::cout << "Before: " << number << std::endl; // 输出初始值

    int& refToNumber = getReference(number); // 获取引用
    refToNumber += 10; // 修改原变量的值

    std::cout << "After: " << number << std::endl; // 输出修改后的值
    return 0;
}

5.3 常量引用

常量引用是指引用一个对象但不允许通过该引用修改对象的值。可以使用 const 关键字来定义常量引用。

5.3.1. 定义和语法

常量引用的定义方式如下：

const int& ref = number;

5.3.2. 特性

只读：常量引用不允许通过它来修改所引用的对象。如果尝试这样做，编译器会报错（完整代码示例）。

绑定到临时对象：常量引用可以绑定到临时对象。这对于避免不必要的拷贝非常有用

#include <iostream>
#include <string>

void printString(const std::string& str) {
    std::cout << str << std::endl; // 可以安全使用 str
}

int main() {
    const std::string& myStr = std::string("Hello, World!"); // 绑定临时对象
    printString(myStr); // 临时对象的生命周期被延长
    // myStr 作用域结束，临时对象才会被销毁
    return 0;
}

5.3.3 完整代码示例

#include <iostream>

void printValue(const int& value) {
    std::cout << "Value: " << value << std::endl;
    // value += 10; // 这行会导致编译错误
}

int main() {
    int number = 5;
    const int& refToNumber = number; // 常量引用

    std::cout << "Before: " << refToNumber << std::endl; // 输出: 5

    // 试图通过引用修改值会导致编译错误
    // refToNumber += 10; // 取消注释会报错

    printValue(refToNumber); // 传递常量引用
    return 0;
}