【C++】引用以及与指针的对比

2# 什么是引用？
当谈到C++中的引用时，它是一种非常重要的概念。引用允许我们创建别名或别称来操作变量，它提供了一种简洁而有效的方法来处理数据。

1.引用的语法

void TestRef()
{
    int a = 10;
    int& ra = a;//<====定义引用类型
    printf("%p\n", &a);
    printf("%p\n", &ra);
}

引用与指针的语法区别

• 引用

#include <iostream>

int main() {
    int num = 10;
    int& ref = num;  // 引用的声明和初始化

    ref = 20;       // 修改引用所指向的变量
    std::cout << "num: " << num << std::endl;  // 输出：num: 20

    int anotherNum = 30;
    ref = anotherNum;  // 引用不能改变指向其他对象，而是修改所引用对象的值
    std::cout << "num: " << num << std::endl;  // 输出：num: 30

    return 0;
}

• 指针

#include <iostream>

int main() {
    int num = 10;
    int* ptr;       // 指针的声明

    ptr = &num;     // 指针的初始化，指向num的地址

    *ptr = 20;      // 通过指针解引用来修改所指向的变量
    std::cout << "num: " << num << std::endl;  // 输出：num: 20

    int anotherNum = 30;
    ptr = &anotherNum;  // 指针可以重新赋值，指向其他对象的地址

    std::cout << "*ptr: " << *ptr << std::endl;  // 输出：*ptr: 30

    return 0;
}

注意：引用类型必须和引用实体是同种类型的

2.引用的特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

void TestRef()
{
   int a = 10;
   // int& ra;   // 该条语句编译时会出错
   int& ra = a;
   int& rra = a;
   printf("%p %p %p\n", &a, &ra, &rra);  
}

3.常引用

void TestConstRef()
{
	// 权限不能放大
    const int a = 10;
    //int& ra = a;   // 该语句编译时会出错，a为常量
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，b为常量
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d; // 因为类型进行转换，会产生零时变量，零时变量具有常属性

	//但是权限可以缩小
	int c = 20;
	const int& d = c;
}

4.引用的使用场景

4.1.作为函数参数传递：

引用作为函数参数传递可以避免数据的复制，提高性能，并且可以修改原始数据。比如下面的代码示例演示了通过引用修改传入的变量的值：

 #include <iostream>

void doubleValue(int& num) {
    num *= 2;
}

int main() {
    int num = 10;
    std::cout << "Before: " << num << std::endl;   // 输出：Before: 10

    doubleValue(num);

    std::cout << "After: " << num << std::endl;    // 输出：After: 20

    return 0;
}

4.2.返回值类型：

引用也可以作为函数的返回值类型，允许函数返回一个对其他对象的引用。这样可以有效避免拷贝大型对象的开销。例如下面的代码示例演示了返回全局变量的引用：

#include <iostream>

int& getGlobalVariable() {
    static int global = 100;   // 静态全局变量

    return global;
}

int main() {
    int& ref = getGlobalVariable();
    std::cout << "Global variable: " << ref << std::endl;  // 输出：Global variable: 100

    ref = 200;
    std::cout << "Global variable: " << ref << std::endl;  // 输出：Global variable: 200

    return 0;
}

在上述示例中，getGlobalVariable() 函数返回了全局变量 global 的引用，通过修改引用就可以修改全局变量的值。

传引用返回的时候需要注意点

避免返回局部变量的引用：不要返回指向函数内部局部变量的引用。一旦函数执行完毕，该局部变量就会被销毁，而引用则指向了无效的内存地址，可能导致程序错误。

#include <iostream>
//出了函数作用域，返回值就销毁了，不能用引用返回，否则结果不确定
int& Count() {
	int n = 0;
	n++;
	return n;
}
int main() {
	int& ret = Count(); //返回值不能被确定
	std::cout << ret << std::endl;
	return 0;
}

所以只有静态变量可以用引用返回！

4.3.函数返回值的链式调用：

引用还可以用于函数返回值的链式调用。比如下面的代码示例演示了通过链式调用对同一个变量进行多次操作：

#include <iostream>

int& increment(int& num) {
    ++num;
    return num;
}

int main() {
    int num = 0;
    increment(increment(increment(num))) += 10;

    std::cout << "Incremented value: " << num << std::endl;  // 输出：Incremented value: 13

    return 0;
}

在上述示例中，通过链式调用 increment() 函数对 num 变量进行多次递增，并通过引用返回修改后的值。

5. 引用和指针的区别

在语法概念上上引用就是一个别名，没有独立的空间，和其引用实际上共用同一块空间。

int main()
{
int a = 10;
int& ra = a;
cout<<"&a = "<<&a<<endl;
cout<<"&ra = "<<&ra<<endl;
return 0;
}

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何 一个同类型实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全