CPP-Week1

(This picture comes from: VTuberized Logos)

参考教程：01 程序的内存模型 - 内存四区 - 代码区 - 哔哩哔哩 bilibili（黑马程序员）

Lesson25 内存分区

25.1 C++ 内存分区简介

C 语言的内存分配参见 Lesson20 4.2 和 10

C++ 的内存分区与 C 语言的大体相同，只是一些分区有所调整：

1. 代码区 (Code Segment)
   存放函数体的二进制代码。内存由操作系统进行管理。
2. 全局 / 静态区 (Global/Static Storage)
   存放全局变量、静态变量以及常量，C 语言中常量区、data 段和 bss 段的综合
3. 栈区 (Stack)
   存放函数的参数值、局部变量等。内存由编译器自动分配与释放。
4. 堆区 (Heap)
   内存由程序员分配与释放。若程序员没有释放，程序结束时由操作系统自动回收。

不同区域存放的数据具有不同的生命周期和处理方式，有助于提高编程的灵活性。同时减少读取时的操作开销，提高效率。

25.2 程序运行前的内存分区

代码编译后生成了 .exe 可执行文件。在执行前，该程序的内存分为两个区域：

• 代码区

  • 存放 CPU 执行的机器指令

  • 代码区的内存是共享的。一个体现是对于频繁被执行的程序，在内存中只需要存一份代码。

    Note

    程序需要有限度地共享数据。比如：所有进程应使用同一个编译器；两个进程间可能想要共享一些数据。

    ——Operating Systems Lecture Notes Lecture 15 Segments

  • 代码区的数据是只读的，以防止程序意外修改了自己的指令。

• 全局区

  • 存放全局变量和静态变量

    Note

    全局变量在所有函数（包括 main 函数）之外声明，通常在代码的开始处。它们在整个程序的执行期间都存在，并且在程序的任何地方都可以被访问和修改。

    ——【新手解答 4】深入探索 C 语言：全局变量声明、全局函数声明 + 宏定义 - 阿里云开发者社区）

    ---

    静态变量使用 static 关键字修饰，在程序刚开始运行时就完成初始化，也是唯一的一次初始化。

    ——c++ 静态变量（static） - USTC 丶 ZCC - 博客园

    C 语言中的静态变量在函数多次调用时仍能保留它的值。它保留了上一次函数执行时的值，这个值在下一次函数执行时不会被初始化掉。

    ——Static Variables in C - GeeksforGeeks

  • 还包含常量区，存放字符串常量和其他常量（如全局常量）

  • 该区域的内存在程序结束后由操作系统释放

演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <cstdio>

int a_g = 10;
const int b_g = 10;
static int c_g = 10;

int main(void) {
	int a_l = 10;
	const int b_l = 10;
	static int c_l = 10;
	printf("全局变量a_g的地址是：%p\n", & a_g);
	printf("全局常量b_g的地址是：%p\n", & b_g);
	printf("全局静态变量c_g的地址是：%p\n", & c_g);
	printf("字符串常量'Hello'的地址是：%p\n", & "Hello");
	printf("局部变量a_l的地址是：%p\n", & a_l);
	printf("局部常量b_l的地址是：%p\n", & b_l);
	printf("局部静态变量c_l的地址是：%p\n", & c_l);
}

1
2
3
4
5
6
7

全局变量a_g的地址是：00007FF6C32BD000
全局常量b_g的地址是：00007FF6C32BABB0
全局静态变量c_g的地址是：00007FF6C32BD004
字符串常量'Hello'的地址是：00007FF6C32BAD4C
局部变量a_l的地址是：000000A11A51F644
局部常量b_l的地址是：000000A11A51F664
局部静态变量c_l的地址是：00007FF6C32BD008

由该演示可知，全局变 / 常量、静态变量和字符串常量存储在同一个内存段，而局部变 / 常量存储在另一个内存段。

25.3 程序运行时的内存分区

执行时，程序还有以下两个内存分区：

• 栈区

  • 存放函数的参数值、局部变量等。
  • 内存由编译器自动分配释放。

  利用指针访问存储在栈区的变量时，需要注意变量的作用域。比如：

  1 2 3 4 5 6 7 8 9 10 11 12

  #include <cstdio> int* func(void) { int a = 10; return &a; } int main(void) { int* p = func(); printf("%d\n", *p); printf("%d\n", *p); }

  1 2 3

  10 -858993460

  func 所占用的内存在函数执行完毕后即被释放，也就是说，赋值时 func 返回的地址指向的内存位置上不是 10，而是一个随机数了，因此第二个 printf 输出了一个非常奇怪的数。

  在 VS2022 上，编译器会提示 warning：

  1	警告 C4172 返回局部变量的地址或临时 : a

  “临时” 是什么东西

  临时变量是在程序执行过程中临时存储数据的变量。它们在程序中被创建并用于存储临时的数据，一旦不再需要，它们就会被销毁。临时变量通常用于在程序中进行一些计算、操作或存储中间结果。（C++ 中产生临时变量的常见场景总结与建议 - CSDN 博客）

  临时变量大多数情况下是算数表达式的结果。（C++ 临时变量）

  那第一个 printf 确实输出了正确的数值，为什么？这其实是编译器的功劳。编译器认为你可能误用了局部变量，所以会为你保留一次 a 的初始值。

  另外，函数的形参也存储在栈区。

• 堆区

  • 内存由程序员分配释放。若程序员不释放，程序结束时由操作系统回收。

  • C++ 使用 new 操作符在堆区开辟动态内存。开辟的内存需要用指针接收并访问。

  演示：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  #include <cstdio> int* func() { int* p = new int(10); return p; } int main(void) { int* p = func(); int a = 20; printf("%p\n", &a); printf("%d %p %p\n", *p, p, &p); printf("%d %p %p\n", *p, p, &p); printf("%d\n", *p); }

  1 2 3 4

  00000070928FF604 10 0000026005F44A00 00000070928FF5E8 10 0000026005F44A00 00000070928FF5E8 10

  我们使用 new 申请了一块大小为 int 宽度的内存，并将其初始化为 10。如果这部分内存放在栈上，那我们第二次通过指针访问这个值时应该不会输出 10，但是它输出了 10，说明操作系统是不会动这块内存的。

  另外，指针接收到的地址是存储在栈区的。

25.3.SP 对象

什么是对象 (Object)？

以下是一些关于对象的表述：

总的来讲，对象就是一块可以存储值的内存区域。

对于一个对象，我们主要看它的四个要素：

• 类型

  类型决定了对象在内存中存储的字节大小与二进制的判读方式

• 标识符

  标识符是数字、下划线、大小写拉丁字母（和以 \u 及 \U 转义字符）指定的。

  程序员通过标识符访问标识符代表的内存对象。

  在 C++ 中，直接访问内存是很难受的，所以我们需要通过对象来间接访问内存。我们只需要专注于怎么存储并检索对象，而不需要关心这些对象放在内存的哪个具体位置，因为编译器代劳了。

  虽然 C++ 中的对象可以没有名字，但我们大多仍会使用标识符来命名对象。有名字的对象叫作变量。为对象命名可以让我们再次使用它们。

  ——1.3 — Introduction to objects and variables – Learn C++

• 地址

  对象按照语言标准和 ABI (Application Binary Interface) 存储在内存中，我们可以通过 & 运算符来获取对象的内存存储地址。

• 值

  值用来初始化对象。

  值的本质

  A single piece of data is called a value. Some instances of useful concept that can be represented as data. Common examples of values include letters (e.g. a), numbers (e.g. 5), and text (e.g. Hello).

  ——1.3 — Introduction to objects and variables – Learn C++

  简单说， 值 是一个纯粹的数学抽象概念，比如数字 10 ，或者字符 'a' , 或者布尔值 false ，等等。它们完全不需要依赖于计算机或者内存而存在，就只是一个纯粹的值：不需要存储到内存，当然也就不可修改。

  那么 1+2 呢？这是一个表达式，但这个表达式的求值结果也是一个 值 。因而，这是一个值类别的表达式 。 而数字 10 同样是一个表达式，其求值的结果毫无疑问也是一个 值 —— 它自身。 因而，在这个角度， 1+2 和数字 10 ，从性质上没有任何区别，都是 值 类别的表达式。

  ——3. 值与对象 — Understanding Modern C++ 1 文档

25.4 new 操作符和 delete 操作符

new 操作符用于在堆上动态分配内存。

new 操作符在 <new> 头文件中定义，不过，通常情况下，标准库已经包含了这个头文件，所以你不需要显式地包含它。但是，为了确保代码的可读性和规范性，建议显式地包含 <new> 头文件。

new 操作符的语法为：

1

new type[size](initializer)

这里的一些参数是可选的。下面介绍分情况下 new 操作符的用法：

• 只分配一个对象的内存：

  1	type* pointer = new type;

• 分配一个对象的内存，并将其初始化为 initializer：

  1	type* pointer = new type(initializer);

• 分配包含 size 个对象的数组的内存：

  1	type* pointer = new type[size];

参考：new 运算符 (C++) | Microsoft Learn；

C++ 内存管理库 | 菜鸟教程

动态分配的内存会一直保持分配状态，直到它被显式释放或直到程序结束。

delete 操作符用于释放之前使用 new 分配的内存。

delete 和 new 一样在 <new> 头文件中定义，也包含在标准库中，不需要再引用 <new>。

接下来介绍 delete 的用法：

• 释放单个对象的内存：

  1	delete pointer;

• 释放数组的内存：

  1	delete pointer[];

动态内存释放完后，就不能再访问，否则程序无法正常退出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <cstdio>

int* func() {
	int* p = new int(10);
	return p;
}


int main(void) {
	int* p = func();
	printf("%d\n", *p);
	delete p;
	printf("%d\n", *p);
}

1

警告	C6001	使用未初始化的内存“p”。	行13

1
2
3

10

(进程 28332)已退出，代码为 -1073741819 (0xc0000005)。

Lesson26 引用

26.1 引用的定义

引用变量 (Reference) 是一个别名 (Alias, or alternate name)，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

你可以把别名看作一个人的绰号。只要人们接受了这个绰号，那么你就可以用这个绰号指代对应的那个人了。

引用变量的声明：

1
2
3

type& ref = var_name;
//或
type &ref = var_name;

我们可以通过引用来访问并修改变量的内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <cstdio>

int main (void)
{
   // 声明简单的变量
   int i;
   double d;

   // 声明引用变量
   int& r = i;
   double& s = d;

   i = 5;
   printf("Value of i : %d", i);
   printf("Value of i reference : %d", r);
   printf("Value of i reference plus 1 : %d", r + 1);

   d = 11.7;
   printf("Value of d : %f", d);
   printf("Value of d reference : %f", s);
   printf("Value of d reference plus 1 : %d", s + 1);

   return 0;
}

1
2
3
4
5
6

Value of i : 5
Value of i reference : 5
Value of i reference plus 1 : 6
Value of d : 11.700000
Value of d reference : 11.700000
Value of d reference plus 1 : 12.700000

26.2 引用声明的注意事项

• 引用必须在创建时被初始化。

  Note

  引用必须被初始化为指向一个合法的对象或函数。

  ——Reference declaration - cppreference.com

  因为引用具有 对象别名 的语义，因而没有 绑定 到任何对象的引用，从语义上就不成立。

  由于必须通过初始化将引用绑定到某一个对象，因而从语义上，不存在 空引用 的概念。

  ——1. 引用 — Understanding Modern C++ 1 文档

• 一旦创建了一个引用，就不能再让它引用另一个对象。

  You can’t separate (分离) the reference from the referent.

  Unlike a pointer, once a reference is bound (绑定) to an object, it can not be “reseated”(重定向) to another object. The reference isn’t a separate object. It has no identity. Taking the address of a reference gives you the address of the referent. Remember: the reference is its referent (指示对象).

  ——References, C++ FAQ

  引用必须依附于它初始指向的对象。引用不是对象。对引用取地址，得到的仍是其指向的对象的地址。

  记住：引用就是其指向的对象。

  注意不要将赋值误认为是更改引用，比如：

  1 2 3 4

  int a = 10; int& b = a; int c = 20; b = c;//这是赋值

  a = c 和 b = c 是等效的。好比给舍友带饭，不论叫绰号还是叫全名都可以把饭交给对方。

  Remember: the reference is the referent, so changing the reference changes the state of the referent.

  ——References, C++ FAQ

  改变引用的状态，也会改变被引用对象的状态。

  ---

  1	&b = c;//这是更改引用

  VS2022 的 IntelliSense 会告诉你：

  1	错误(活动) E0137 表达式必须是可修改的左值

  这段代码也不能通过编译。

• 在大多数情况下，引用只会绑定到与引用类型匹配的对象。如果你将引用绑定到与其引用类型不匹配的对象，编译器将尝试隐式地将对象转换为引用类型，然后将引用绑定到该对象。

• 引用必须指向一个合法的内存（在栈区和堆区的内存）。指向一个不再存在的对象的引用被称为悬空引用 (Dangling Reference)。访问悬空引用会导致未定义的行为。

• 引用本身不是对象，因此引用本身一般不占存储单元。例如，对引用求地址，就是对目标变量求地址。

  Warning

  引用不是对象。引用不占用内存，除非编译器认为有必要，例如非静态的引用类型数据成员会增加类的大小，因为类要存储地址。

  由于引用不是对象，所以没有引用数组、引用指针和引用的引用：

  1 2 3

  int& a[3]; // error int&* p; // error int& &r; // error

  ——Reference declaration - cppreference.com

  ---

  不能建立引用数组（数组中的元素不能是引用），但是可以建立数组的引用和数组元素的引用：

  1 2 3 4 5

  int& arr[3] = {2,3,4};//声明"引用数组"是错误的，arr并没有自己的空间来存放后面的值 //-------------------------------- int arr[3] = {2,3,4};//arr是数组变量名，int[3]是类型 int (&ref)[3] = arr;//正确，&ref是引用名，int[3]是类型 int& p = arr[3];//可行

  —— 不能建立引用数组，数组中的元素不能是引用_c++ 不能建立引用的数组 - CSDN 博客

26.3 引用作为函数参数

在 C 语言中，我们介绍了按值传递和按地址传递两种传参方式。下面我们介绍 C++ 提供的第三种传参方式：按引用传递 (Pass by Reference, or Call by Reference)。

「call by reference」是 C++ 才有的「更方便」的東西，但也因為這個「方便」，導致觀念如果不穩，就會像我一樣把這個「方便」的功能，變成「符號意義大混亂」。因此，如果這三個你現在很混亂，建議先從「call by value, call by address (pointer)」搞清楚再說！！！

——【C++ 觀念理解 #1】C++ call by value, call by address (pointer), call by reference 總和比較整理，不想要再搞不懂了！！！(updated: 2022/8/19) - 嗡嗡的隨手筆記

在按引用传递方法中，实际参数的内存地址（引用）被传递给函数，允许直接访问和修改原始值。实际参数和形式参数指向相同的内存地址。在函数中对参数所做的任何更改都会直接反映在函数外的原始值中。这和按地址传递的作用相似，但相比指针作为参数，引用作为参数要更加 “自然”。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <cstdio>

void swap(int& a, int& b);

int main(void){
    int a, b;
    scanf("%d %d", &a, &b);
    swap(a, b);// 引用作为函数参数
    printf("%d %d", a, b);
}

void swap(int& a, int& b){
    int t = a;
    a = b;
    b = t;
}

input:

1

2 3

output:

1

3 2

26.4 引用作为函数返回值

C++ 的函数可以返回一个引用，方式与返回一个指针 (Lesson20 4.3) 类似。

1
2
3
4
5
6
7
8
9
10
11
12

#include <cstdio>

int& test() {
    static int a = 10;//静态变量
    return a;
}

int main(void) {
    int& q = test();
    printf("%d\n", q);
    printf("%d\n", q);
}

1
2
3

10
10

这里有几个注意事项：

• 不要返回局部变量的引用，或者说，不要返回一个内存已被释放的变量的引用。

  1 2 3 4 5 6 7 8 9 10 11 12

  #include <cstdio> int& test() { int a = 10;//局部变量 return a; } int main(void) { int& q = test(); printf("%d\n", q);//第一次读取，编译器进行保留 printf("%d\n", q);//第二次读取，保留失效，程序试图读取引用指向的内存区域 }

  1 2 3

  10 -858993460

  这和我们 [24.3](#24.3 程序运行时的内存分区) 讲的错误原因是一样的，引用指向了一个本不存在的、混沌的内存位置。

  本节开头的示例使用 static 修饰局部变量，扩大了变量的作用域，使得变量的内存不会在函数执行完成后被释放。

  Warning

  虽然一个返回一个局部 static 的设计的例子是合理的，至少在单线程的环境中是这样。但就像所有使用了 static 对象的设计一样，这个也会立即引起我们的线程安全（Thread-safety）的混乱。

  ——Item 21: 当你必须返回一个对象时不要试图返回一个引用 | Effective C++

  请记住一个引用仅仅是一个名字，一个实际存在的对象的名字。无论何时只要你看到一个引用的声明，你应该立刻问自己它是什么东西的另一个名字，因为它必定是某物的另一个名字。

  ——Item 21: 当你必须返回一个对象时不要试图返回一个引用 | Effective C++

  绝不要返回指向栈中的局部对象的指针或引用，或返回指向堆中对象的引用 ^[3]，或返回指向静态局部变量对象的指针或引用

  —— 笔记 - 关于《Effective C++》 中的 55 个做法 | GuKaifeng’s Blog

  使用引用返回的对象，其生存期必须大于函数的作用域，否则会造成垂悬引用。永远不要使用引用返回非静态的本地变量或者临时变量。

  ——12.12 — Return by reference and return by address – Learn C++

• 若函数返回引用，则函数的调用可以作为左值，进行赋值操作。

  1 2 3 4 5 6 7 8 9 10 11 12 13

  #include <cstdio> int& test() { static int a = 10;//静态变量 return a; } int main(void) { int& q = test(); printf("%d\n", q); test() = 20; printf("%d\n", q); }

  1 2 3

  10 20

  函数 test 实际上是返回了 a 本身，我们是对变量原名进行操作。

  Tip

  若函数返回了一个非静态的引用，调用者可以通过引用修改返回值。

  ——12.12 — Return by reference and return by address – Learn C++

26.5 引用的本质

引用在 C++ 内部的实现就是一个指针常量。下面结合实例讲解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <cstdio>

//发现是引用，转换为int* const ref = &var
void func(int& ref) {
    ref = 100;//ref是引用，转换为*ref = 100
}

int main() {
    int a = 10;

    //自动转换为int* const ref = &a; 指针常量的指向不可更改，所以引用也不可更改
    int& ref = a;
    ref = 20;//发现是引用，自动转换为*ref = 20

    printf("a: %d\n", a);
    printf("ref: %d\n", ref);

    func(a);

    printf("a: %d\n", a);
    printf("ref: %d\n", ref);
}

1
2
3
4
5

a: 20
ref: 20
a: 100
ref: 100

既然引用和指针在底层上是相同的，那我们是不是可以用引用来替代指针呢？答案是：很多情况下，可行！

以下的论述展示了引用与指针的差别。

（来源：Pointers vs References in C++ - GeeksforGeeks）

（来源：Reference vs Pointer in C++: 6 Key Differences to Know）

或者看看这个 Stack Overflow 问题：c++ - What are the differences between a pointer variable and a reference variable? - Stack Overflow 以及它的相关问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

>>在C++中，什么时候使用引用更好，什么时候使用指针更好？

在C++中，引用和指针都是用于间接访问对象的方式，但它们在使用场景和语义上有所不同。以下是一些关于何时使用引用和指针的指导：

## 使用引用的情况：
1. 简洁性：引用语法更简洁，使用起来更像普通变量。例如，`int& ref = var;`，而指针需要使用解引用操作符（`*`）和地址操作符（`&`）。
2. 不允许为空：引用必须绑定到一个有效的对象，不能为`nullptr`，这使得引用在某些情况下更安全。
3. 函数参数：当你希望在函数中修改传入的参数时，使用引用可以避免复制开销。
4. 重载运算符：在重载运算符时，通常使用引用来避免不必要的复制。
5. 返回值：当你希望返回一个对象的引用时，使用引用可以避免复制。

## 总结
- 使用引用：当你希望提供一个对象的别名，并且不需要处理空值时，引用是更好的选择。
- 使用指针：当你需要处理动态内存、可能为空的情况，或者需要改变指针的指向时，指针是更合适的选择。
在实际编程中，选择引用还是指针通常取决于具体的需求和上下文。

## 使用指针的情况：
1. 可为空：指针可以指向`nullptr`，这在某些情况下是有用的，例如表示“无对象”或“未初始化”的状态。
2. 动态内存管理：当你需要动态分配内存时，指针是必需的。例如，使用`new`和`delete`来管理动态分配的对象。
3. 数组和指针的关系：在处理数组时，指针可以更灵活地进行算术运算。例如，指针可以通过加法和减法来遍历数组。
4. 多态性：在使用基类指针指向派生类对象时，指针是必要的，尤其是在实现多态时。
5. 需要改变指向的对象：如果你需要在函数中改变指针的指向，使用指针更合适。

>>那么大部分情况下，引用可以取代指针吗？

在许多情况下，引用确实可以取代指针，尤其是在需要传递对象的别名或修改对象时。引用提供了更简洁的语法和更安全的使用方式，因为它们不能为`nullptr`，并且在使用时不需要解引用操作符。以下是一些具体的情况：

1. 函数参数：当你希望在函数中修改传入的参数时，引用可以替代指针。使用引用比使用指针更简洁。
2. 返回值：当你希望返回一个对象的引用时，引用可以替代指针。返回引用比返回指针更安全，因为引用不能为`nullptr`。
3. 重载运算符：在重载运算符时，通常使用引用来避免不必要的复制。

>## 但引用不能完全取代指针的情况：
1. 动态内存管理：当需要动态分配内存时，指针是必需的。引用不能用于new和delete。
2. 可为空的情况：如果需要表示“无对象”或“未初始化”的状态，指针是唯一的选择，因为引用必须绑定到一个有效的对象。
3. 改变指向的对象：如果需要在函数中改变指针的指向，指针是必要的。
4. 多态性：在使用基类指针指向派生类对象时，指针是必要的，尤其是在实现多态时。

## 总结
虽然在许多情况下引用可以取代指针，但在某些特定场景下，指针仍然是不可或缺的。因此，选择使用引用还是指针应根据具体的需求和上下文来决定。在设计时，**优先考虑使用引用，只有在需要指针特有的功能时才使用指针**。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

>>在C++中，什么时候使用引用更好，什么时候使用指针更好？

在C++中,使用引用还是指针,主要取决于具体的使用场景和需求。以下是一些建议:

1. 引用:
   - 当你需要修改函数参数的值时,使用引用通常更好。这样可以避免复制对象,提高效率。
   - 当你需要返回多个值时,使用引用可以更方便地实现。
   - 当你需要创建一个变量,它只是另一个变量的别名时,使用引用更合适。

2. 指针:
   - 当你需要指向动态分配的内存时,使用指针是必要的。
   - 当你需要实现链表、树等动态数据结构时,指针是不可或缺的。
   - 当你需要实现间接寻址或者操作内存地址时,指针更加合适。

>总的来说,引用提供了更简洁和安全的语法,但在某些情况下,指针仍然是必要的。在编程时,需要根据具体需求权衡使用引用还是指针。良好的编程习惯和代码风格也很重要,可以提高代码的可读性和可维护性。

>>那么大部分情况下，引用可以取代指针吗？

不,大部分情况下引用并不能完全取代指针。虽然引用和指针在某些方面可以互换使用,但它们还是有一些重要的区别:

1. 内存管理:
   - 指针可以指向动态分配的内存,引用则不行。动态内存分配需要使用指针。

2. 空值表示:
   - 指针可以指向空值(NULL),而引用不能。这使得指针更加灵活,可以表示不存在的对象。

3. 间接访问:
   - 指针可以通过解引用操作符(*)间接访问内存地址,引用则没有这种能力。这使得指针更适合于实现复杂的数据结构。

4. 赋值和初始化:
   - 引用必须在声明时初始化,而指针可以在任何时候赋值。这使得引用的使用更加受限。

因此,虽然在某些情况下引用可以取代指针,但指针仍然是C++中不可或缺的一部分。它们各有优缺点,开发者需要根据具体需求选择合适的使用方式。良好的编程实践是掌握两者的特点,并在适当的场景中灵活运用。

总的来讲，C++ 的引用比指针少了灵活性，多了安全性。写起来，引用也比指针更简洁。

ISO CPP 也倾向于使用引用：

Use references when you can, and pointers when you have to.

Note: Old line C programmers sometimes don’t like references since they provide reference semantics (语义) that isn’t explicit in the caller’s code. After some C++ experience, however, one quickly realizes this is a form of information hiding, which is an asset (资产) rather than a liability (负债).

——References, C++ FAQ

能用引用就用引用，得用指针就用指针。

不喜欢写引用的程序员，你们好呀。ldx 什么时候爆金币？

从更基础的计算机科学角度来看，“引用” 这一概念还有更深层次的意义。这一部分仅作扩展。

26.6 常量引用

常量引用主要用于修饰形参，防止误操作。

1
2
3
4
5
6
7

#include <cstdio>

int main(void){
    //int& ref = 10; // 引用指向常数区，不是一块合法的内存
    const int& ref = 10; // 加上const，编译器将其转换为int temp = 10; const int& ref = temp;
    //ref = 20; // 加入const之后变为只读，不可修改
}

如果我们用 const 修饰一个引用变量，那么这个引用将能够绑定到任何类型的参数。

——12.6 — Pass by const lvalue reference – Learn C++

大部分情况下，我们都不希望函数修改参数，因此优先按 const 引用传参而不是按 non-const 引用传参。

——12.6 — Pass by const lvalue reference – Learn C++

例如接下来的程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <cstdio>

//print data
void showValue(int& val){

    val = 1000;//assign a value by mistake
    printf("val = %d\n", val);
}
int main(void){
    int a;

    /*Some code...*/

    a = 100;
    showValue(a);
    printf("a = %d\n", a);
}

函数 showValue 的用途本来只是打印数据，但是有人粗心地给本地变量 val 指定了初始值。

如果我们不使用 const 修饰形参呢？

1
2
3

val = 1000
a = 1000

好嘛，原来的数据也被污染成函数中指定的初始值了。这可不行，我们不能让函数修改我们的数据。

为函数形参加上 const 试试：

1
2
3
4
5

void showValue(const int& val){

    //val = 1000;cannot assign a value
    printf("val = %d\n", val);
}

1
2
3

val = 100
a = 100

很好！函数正确执行了我们的预期操作。

ISO CPP 给出了三种参数传递方式的选择建议：

如果你需要改变传进来的对象，那么按引用传递和按指针传递都是可以的。如果允许传入 “非对象”（如一个空指针），那么按指针传递更容易理解。

如果你不希望改变传进来的对象，并且这个对象很大，按常量引用传递。

其他情况，建议按值传递。

——References, C++ FAQ