C++编程语言——基础设施:第7章——指针,数组和引用(Bjarne Stroustrup)

The C++ Programming Language 读书笔记 - Bjarne_Stroustrup 1979年,贝尔丝·斯托芬鲁普(Bjarne_Stroustrup)发表了著名的“C++和对象技术”论文,对C++语言的基础语法、数据结构、类和对象等进行了全面系统的阐述。近几十年来,随着C++作为高级编程语言在工程应用中的广泛接受,学习C++的读者越来越多,但是对于那些从事C++开发工作的人来说,了解C++的背景知识仍然是一个重要的前提。本书就是为了帮助读者理解并掌握C++的语言特性及其背后的原理,帮助读者快速熟悉C++语法和各种数据结构、算法的用法。 阅读详情

指针,数组和引用

(Pointers, Arrays, and References)

目录

7.1  引言

7.2  指针

7.2.1  void* 指针

7.2.2  nullptr 指针

7.3  数组

7.3.1  数组初始化

7.3.2  字符串文字量

7.3.2.1  原字符串(Raw Character Strings)

7.3.2.2  大字符集(Larger Character Sets)

7.4  数组中的指针

7.4.1  数组操作导引(Navigating Arrays)

7.4.2  多维数组(Multidimensional Arrays)

7.4.3  传递数组(Passing Arrays)

7.5  指针和const

7.6  指针和属主(Pointers and Ownership)

7.7  引用(References)

7.7.1  左值引用

7.7.2  右值引用

7.7.3  指向引用的引用

7.7.4  指针和引用

7.8  建议


7.1  引言

本章介绍引用内存的基本语言机制。显然,我们可以通过名称引用对象,但在 C++ 中(大多数)对象“具有身份”。也就是说,它们驻留在内存中的特定地址,如果您知道对象的地址和类型,则可以访问该对象。用于保存和使用地址的语言构造是指针和引用。

7.2  指针

对于一个类型T ,T∗ 是“T类型指针”类型。 即,类型 T∗ 是一个可以存储类型T的对象的地址的变量。例如:

char c = 'a';

char∗ p = &c; //p 存储 c 的地址; & 是取地址运算符

或者用图像表示为

指针的基本操作是解引用,即引用指针指向的对象。此操作也称为间接引用。解引用运算符是(前缀)一元 ∗。例如:

char c = 'a';

char∗ p = &c; // p 存储 c 的地址; & 是取地址运算符

char c2 = ∗p; // c2 == ’a’; * 是解引用运算符

p指向的对象为c,c中存储的值为'a',因此赋给c2的∗p的值为'a'。

    可以对指向数组元素的指针执行一些算术运算(§7.4)。

    指针的实现旨在直接映射到程序运行所在机器的寻址机制(译注:即利用指针直接操作地址)。大多数机器可以寻址一个字节。那些不能寻址的机器往往有硬件从字中提取字节。在另一方面,很少有机器可以直接寻址单个位。因此,可以使用内置指针类型独立分配和指向的最小对象是 char(译注:即1个字节)。请注意,bool 占用的空间至少与 char 一样多(§6.2.8)。为了更紧凑地存储较小的值,可以使用按位逻辑运算(§11.1.1)、结构中的位域(bit-fields)(§8.2.7)或位集(bitset)(§34.2.2)。

    ∗ 表示“指向”的指针,用作类型名称的后缀。不幸的是,指向数组的指针和指向函数的指针需要更复杂的符号:

int∗ pi; //int指针

char∗∗ ppc; // char指针的指针

int∗ ap[15]; // 15个 int 指针的数组

int (∗fp)(char∗); // 取一个char* 参数的函数指针(译注:()优于任何类型名); 返回 int

int∗ f(char∗); //取一个char* 参数的函数; 返回int指针

查看 §6.3.1 了解声明语法的解释,并查看 §iso.A 了解完整语法。

    函数指针很有用;在§12.5 中进行了讨论。指向类成员的指针在§20.6中进行介绍。

7.2.1  void* 指针

在底层代码中,我们偶尔需要存储或传递内存位置的地址,而实际上并不知道存储在那里的对象类型,这时void∗ 可用于此目的。您可以将void∗ 理解为“指向未知类型对象的指针”。

指向任意类型对象的指针都可以赋值给 void∗ 类型的变量,但指向函数的指针(§12.5)或指向成员的指针(§20.6)则不能。此外,void∗ 可以赋值给另一个void∗,void∗ 可以比较相等和不相等,并且 void∗ 可以显式转换为其他类型。其他操作是不安全的,因为编译器无法知道实际指向的对象类型。因此,其他操作会导致编译时错误。要使用 void∗,我们必须将其显式转换为指向特定类型的指针。例如:

void f(int∗ pi)

{

void∗ pv = pi; // ok: int* 到 void* 的隐式转换

∗pv; //错 : 不能解引用void*

++pv; //错: 不能递加 void* (指向对象的大小未知)

int∗ pi2 = static_cast<int∗>(pv); //显式转换回 int*

double∗ pd1 = pv; //错

double∗ pd2 = pi; //错

double∗ pd3 = static_cast<double∗>(pv); // 不安全(§11.5.2)

}

一般来说,使用已转换(“强制转换”)为不同于所指向对象类型的指针是不安全的。例如,机器可能假设每个 double 都分配在 8 字节边界上。如果是这样,如果 pi 指向的 int 不是以这种方式分配的,则可能会出现奇怪的行为。这种显式类型转换形式本质上是不安全且丑陋的。因此,所使用的表示法 static_cast(§11.5.2)被设计为丑陋状且易于在代码中找到。

void∗ 的主要用途是将指针传递给不允许对对象类型作出假设的函数,以及从函数返回无类型的对象。要使用这样的对象,我们必须使用显式类型转换。

使用 void∗ 指针的函数通常存在于系统的最低层,在那里操纵真实的硬件资源。例如:

void∗ my_alloc(siz e_t n); // 从我的专用堆分配n字节的空间

系统较上层出现的 void∗ 应引起高度警惕,因为它们很可能是设计错误的征兆。在用于优化时,void∗ 可以隐藏在类型安全接口后面(§27.3.1)。

指向函数的指针(§12.5)和指向成员的指针(§20.6)不能分配给 void∗ 。

7.2.2  nullptr 指针

文字量 nullptr 表示空指针(null pointer),即不指向对象的指针(译注:事实上,其值为0,表示不存储任意地址,也可以称其为0指针)。它可以赋值给任何指针类型,但不能分配给其他内置类型:

int∗ pi = nullptr; //译注:pi == 0

double∗ pd = nullptr;

int i = nullptr; // 错 : i 不是指针

只有一个 nullptr,它可以用于每个指针类型,而不是每个指针类型都有一个空指针。

(译注:实际上,系统在实现的时候,nullptr 就是用 0 替代:

    int* pi = nullptr;

00007FF649EC284D  mov         qword ptr [pi],0 

    double* pd = nullptr;

00007FF649EC2856  mov         qword ptr [pd],0 

)

(译注:因为 nullptr 本质上就是一个 0 值,因此在不考虑意义的情况下,强制转换是可以的,可以看到下式的 i == 0:

int i = (int)nullptr;

)

在引入 nullptr之前,零 (0) 被用作空指针的表示法。例如:

    int∗ x = 0; // x 获得 nullptr 代表的值

没有对象被分配地址 0,并且 0(全零位模式)是 nullptr的最常见表示。零(0)是 int。但是,标准转换(§10.5.2.3)允许将 0 用作指针或指向成员类型的常量。

定义一个宏 NULL 来表示空指针是一种很流行的做法。例如:

int∗ p = NULL; //使用宏 NULL

但是,不同实现中 NULL 的定义存在差异;例如,NULL 可能是 0 或 0L。在 C 中,NULL 通常是 (void∗)0,这使其在 C++ 中不合法(§7.2.1):

int∗ p = NULL; // 错:不能将void*赋给int* (译注:有的编译是可以的,如vs2022)

与其他替代方案相比,使用 nullptr 可使代码更具可读性,并且避免了当函数重载以接受指针或整数时可能产生的混淆(§12.3.1)。

7.3  数组

    对于一个类型T ,T[size] 是“T类型的size个元素的数组”类型。元素按从 0 到 size – 1 的下标进行检索。例如:

float v[3]; // 3个float元素数组: v[0], v[1], v[2]

char∗ a[32]; // 32个指向char的指针数组: a[0] .. a[31]

您可以使用下标运算符 [] 或通过指针(使用运算符 ∗ 或运算符 [];§7.4)访问数组。例如:

void f()

{

int aa[10];

aa[6] = 9; // 对aa的第7个元素赋值

int x = aa[99]; // 未定义行业

}

超出数组范围的访问是未定义的,通常会导致灾难性的后果。特别是,运行时范围检查既没有保证,也不常见。

   数组元素的数量(即数组边界)必须是常量表达式(§10.4)。如果需要可变边界,请使用vector(§4.4.1、§31.4)。例如:

void f(int n)

{

int v1[n]; // 错 : array size not a constant expression

vector<int> v2(n); // OK: 具有n个int元素的vector

}

多维数组表示为数组的数组(§7.4.2)。

数组是 C++ 表示内存中对象序列的基本方式。如果您想要的是内存中给定类型的简单固定长度对象序列,则数组是理想的解决方案。对于其他所有需求,数组都存在严重问题。

    数组可以静态分配在栈上以及在自由存储空间上(§6.4.2)。例如:

int a1[10]; // 10 ints in static storage

void f()

{

int a2 [20]; // 20 ints on the stack

int∗p = new int[40]; // 40 ints on the free store

// ...

}

C++ 内置数组本质上是一种底层工具,主要应用于更高级、性能更好的数据结构(如标准库向量或数组)的实现中。不存在数组赋值,数组名称会在最轻微的触发下隐式转换为指向其第一个元素的指针(§7.4)。特别是,避免在接口中使用数组(例如,作为函数参数;§7.4.3、§12.2.2),因为隐式转换为指针是 C 代码和 C风格C++ 代码中许多常见错误的根源。如果在自由存储区中分配数组,请确保仅在最后一次使用后 delete[] 其指针一次(§11.2.2)。最简单、最可靠的方法是让资源句柄控制自由存储数组的生命周期(例如,string(§19.3、§36.3)、vector(§13.6、§34.2)或unique_ptr(§34.3.1))(译注:类为它们是类,由它们的析构函数去负责释放内存空间)。如果您静态地或在栈上分配数组,请确保永远不要删除它。显然,C 程序员无法遵循这些建议,因为 C 缺乏封装数组的能力,但这并不意味着这些建议在 C++ 环境中是坏的。

    最广泛使用的数组类型之一是以零结尾的 char 数组。这是 C 存储字符串的方式,因此以零结尾的 char 数组通常称为 C 风格字符串。C++ 字符串文字量遵循该约定(§7.3.2),并且一些标准库函数(例如 strcpy() 和 strcmp();§43.4)依赖于它。通常,char∗ 或 const char∗ 被假定指向以零结尾的字符序列。

7.3.1  数组初始化

数组可以通过值列表进行初始化。例如:

int v1[] = { 1, 2, 3, 4 };

char v2[] = { 'a', 'b', 'c', 0 };

当声明数组时没有指定大小,但带有初始化列表,则通过计算初始化列表的元素来计算大小。因此,v1 和 v2 分别为 int[4] 和 char[4] 类型。如果明确指定了大小,则在初始化列表中提供多余的元素是错误的。例如:

char v3[2] = { 'a', 'b', 0 }; // 错 :太多初始化项

char v4[3] = { 'a', 'b', 0 }; // OK

如果初始化器为数组提供的元素太少,则其余元素将使用 0。例如:

int v5[8] = { 1, 2, 3, 4 };

相当于

       int v5[] = { 1, 2, 3, 4 , 0, 0, 0, 0 };

数组没有内置的复制操作。您不能用一个数组初始化另一个数组(即使是完全相同类型的数组),并且没有数组赋值:

int v6[8] = v5; // 错: 不能复制数组 (不能将 int*赋值给数组 )

v6 = v5; //错:  不存在数组赋值

类似地,你不能通过值传递数组。另请参阅 §7.4。

    当你需要对对象集合进行赋值时,请改用vector(§4.4.1、§13.6、§34.2)、数组(§8.2.4)或 valarray(§40.5)。

    可以方便地通过字符串文字量(§7.3.2)初始化字符数组。

7.3.2  字符串文字量

    字符串文字量是一个用双引号(“”)括起来的字符串。

"this is a string"

字符串文字量包含的字符比它实际包含的字符多一个;它以空字符 '\0' 结尾,值为 0(译注:只不过在调试显示时隐藏了这个字符串尾的0,但在内存中是可以看到这个0值的)。例如:

sizeof("Bohr")==5

字符串文字的类型是“适当数量的 const 字符数组”,因此“Bohr”属于const char[5] 类型。

    在 C 和较旧的 C++ 代码中,可以将字符串文字量分配给非常量 char∗:

void f()

{

char∗ p = "Plato"; // 错,但在C++11以下标准中是可接受的

p[4] = 'e'; //错:赋值给常量

}

接受这种赋值显然是不安全的。它曾经(现在也是)是隐晦错误的来源,所以如果某些旧代码由于这个原因无法编译,请不要抱怨太多。让字符串文字量不可变不仅显而易见,而且还允许实现对字符串文字量的存储和访问方式进行重大优化。

如果我们想要一个可以保证能够修改的字符串,我们必须将字符串放在一个非常量数组中:

void f()

{

char p[] = "Zeno"; // p 5个字符的数组

p[0] = 'R'; // OK

}

字符串文字量是静态分配的,因此可以安全地从函数返回一个字符串文字量。例如:

const char∗ error_message(int i)

{

// ...

return "range error";

}

调用 error_message() 之后,保存“range error”的内存不会消失。

(译注:也就是说字符串文字量是系统静态分配并维护的,不需要我们去释放空间,当我们return 的时候,系统首先取得字符串  "range error" 在静态存储区中的地址,存入eax寄存器,然后返回。在vs 2022 中编译后类似下面的样子:

00007FF72D542864  lea         rax,[__xt_z+7D8h (07FF72D6A3C10h)] 

00007FF72D54286B  ret

这时,我们看 rax 的地址内容是多少:0x00007ff72d6a3c10 。然后我们跳到这个内存地址去看看其存储的内容,正好是字符串对应的ASCII码的十六进表示:

两个相同的字符串文字量是否分配为一个数组或两个数组由实现定义(§6.1)。例如:

const char∗ p = "Heraclitus";

const char∗ q = "Heraclitus";

void g()

{

if (p == q) cout << "one!\n"; // 结果由实现定义

// ...

}

请注意,当应用于指针时,== 会比较地址(指针值),而不是指向的值。

    空字符串写为一对相邻的双引号“”,类型为 const char[1]。空字符串的一个字符是终止符 '\0'。

    表示非图形字符的反斜杠约定(§6.2.3.2)也可以在字符串中使用。这样就可以在字符串中表示双引号(“)和转义字符反斜杠(\)。到目前为止,最常见的此类字符是换行符“\n”。例如:

cout<<"beep at end of message\a\n";

转义字符 '\a' 是 ASCII 字符 BEL(也称为 alert),它会发出声音。

    在(非原始)字符串文字量中不可能有“真正的”换行符:

"this is not a string

but a syntax error"

长字符串可以用空格分隔,以使程序文本更整洁。例如:

char alpha[] = "abcdefghijklmnopqrstuvwxyz"

"ABCDEFGHIJKLMNOPQRSTUVWXYZ";

编译器将连接相邻的字符串,因此数组 alpha 可以等效地由单个字符串

"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

初始化。

    字符串中可以包含空字符,但大多数程序不会怀疑其后有字符。例如,字符串“Jens\000Munk”将被标准库函数(如 strcpy() 和 strlen())视为“Jens”;请参阅 §43.4。

7.3.2.1  原字符串(Raw Character Strings)

    要在字符串文字量中表示反斜杠 (\) 或双引号 ("),我们必须在其前面加上反斜杠。这是合乎逻辑的,而且在大多数情况下都很简单。但是,如果我们需要在字符串文字量中使用大量反斜杠和大量引号,这种简单的技术就变得难以管理。特别是,在正则表达式中,反斜杠既用作转义字符,也用于引入表示字符类的字符(§37.1.1)。这是许多编程语言共享的惯例,所以我们不能改变它。因此,当您编写用于标准正则表达式库(第 37 章)的正则表达式时,反斜杠是转义字符这一事实会成为明显的错误来源。考虑如何编写表示由反斜杠 (\) 分隔的两个单词的模式:

string s = "\\w\\\\w"; // 我希望它如预期

原字符串文字量使用 R"(ccc)" 符号表示字符序列 ccc。开头的 R 用来区分原字符串文字和普通字符串文字。括号用来允许使用 (‘‘未转义’’) 双引号(译注:原字符串指其内容中所有符号都表示字符,即使含有转义字符也当成普通字符对待)。例如:

R"("quoted string")" // 字符串是 "quoted string"

那么,我们如何将字符序列 )"  转换为原字符串文字量呢?幸运的是,这是一个罕见的问题,但“( 和 )”只是默认的分隔符对(译注:我们可以添加其这符号对作为分隔符)。我们可以在“(...)”中的 ( 之前和 ) 之后添加分隔符。例如:

R"∗∗∗ ("quoted string containing the usual terminator ("))")∗∗∗"

// "quoted string containing the usual terminator ("))"

(译注,我们添加一对∗∗∗----∗∗∗作为分隔符。)

) 之后的字符序列必须与 ( 之前的字符序列相同。这样我们就可以应对(几乎)任意复杂的模式。

    除非您使用正则表达式,否则原始字符串文字量对你来说可能只是一种好奇心(还有一件事需要学习),但正则表达式很有用并且被广泛使用。考虑一个现实世界的例子:

"('(?:[ˆ\\\\']|\\\\.)∗'|\"(?:[ˆ\\\\\"]|\\\\.)∗\")|" // 这5个反斜线正确与否?

有了这样的例子,即使是专家也很容易感到困惑,而原字符串文字量提供了重要的服务。

与非原字符串文字量相比,原字符串文字量可以包含换行符。例如:

string counts {R"(1

22

333)"};

相当于

string x {"1\n22\n333"};

7.3.2.2  大字符集(Larger Character Sets)

       带有前缀 L 的字符串(例如 L"angst")是宽字符字符串(§6.2.3)。其类型为 const wchar_t[]。类似地,带有前缀 LR 的字符串(例如 LR"(angst)")是类型为 const wchar_t[] 的宽字符原字符串(§7.3.2.1)。此类字符串以 L'\0' 字符结尾(译注:本质上是两个00)。

    支持 Unicode 的字符文字量有六种(Unicode 文字)。这听起来有点多余,但 Unicode 有三种主要编码:UTF-8、UTF-16 和 UTF-32。对于这三种替代方案中的每一种,都支持原字符串和“普通”字符串。所有三种 UTF 编码都支持所有 Unicode 字符,因此使用哪种编码取决于您需要适应的系统。基本上所有互联网应用程序(例如浏览器和电子邮件)都依赖于其中一种或多种编码。

    UTF-8 是一种可变宽度编码:常用字符占用 1 个字节,不常用的字符(根据使用情况估计)占用 2 个字节,而罕见字符占用 3 或 4 个字节。具体而言,ASCII 字符占用 1 个字节,UTF-8 中的编码(整数值)与 ASCII 中的相同。各种拉丁字母、希腊字母、西里尔字母、希伯来字母、阿拉伯字母等占用 2 个字节。

    UTF-8 字符串以 '\0' 结尾,UTF-16 字符串以 u'\0' 结尾,UTF-32 字符串以 U'\0' 结尾。我们可以用多种方式表示普通英文字符串。考虑使用反斜杠作为分隔符的文件名:

"folder\\file" //实现字符集字符串

R"(folder\file)" //实现字符原始集字符串

u8"folder\\file" // UTF-8 string

u8R"(folder\file)" // UTF-8 raw string

u"folder\\file" // UTF-16 string

uR"(folder\file)" //UTF-16 raw string

U"folder\\file" // UTF-32 string

UR"(folder\file)" //UTF-32 raw string

如果打印出来,这些字符串看起来都一样,但除了“纯文本”和 UTF-8 字符串之外,它们的内部表示可能会有所不同。

显然,Unicode 字符串的真正目的是能够将 Unicode 字符放入其中。例如:

u8"The official vowels in Danish are: a, e, i, o, u, \u00E6, \u00F8, \u00E5 and y."

正确打印该字符串可给出

The official vowels in Danish are: a, e, i, o, u, æ, ø, å and y.

\u 后面的十六进制数是 Unicode 编码点(code point) (§iso.2.14.3) [Unicode,1996]。此类编码点与所用的编码无关,实际上在不同的编码中会有不同的表示形式(以字节中的位表示)。例如,u'0430'(西里尔小写字母“a”)在 UTF-8 中是 2 字节十六进制值 D0B0,在 UTF-16 中是 2 字节十六进制值 0403,在 UTF-32 中是 4 字节十六进制值 00000403。这些十六进制值称为通用字符名称。

u 和 R 的顺序及其大小写非常重要:RU 和 Ur 不是有效的字符串前缀。

7.4  数组中的指针

    在 C++ 中,指针和数组密切相关。数组的名称可以视为指向其起始元素的指针(译注:即数组起始地址)。例如:

int v[] = { 1, 2, 3, 4 };

int∗ p1 = v; // 指针指向起始元素(隐式转换)

int∗ p2 = &v[0]; // 指针指向起始元素(同上一行相同)

int∗ p3 = v+4; // 指向最后一个元素尾(译注:指针“+”的意义取决于数据类型的大小)

或用图形表示为:

取数组末尾元素之后的地址有效(译注:指取地址是允许的)。这对于许多算法来说很重要(§4.5、§33.1)。但是,由于这样的指针实际上并不指向数组的元素,因此不能用于读取或写入。获取初始元素之前或最后一个元素之后的元素地址的结果是未定义的,应避免。例如:

int∗ p4 = v−1; // 数组起始地址之前一个元素大小的位置, 未定义:勿做

int∗ p5 = v+7; // 超过元素末尾,未定义:勿做

在 C 风格代码的函数调用中,数组名称被广泛地用作指向数组起始元素的指针的隐式转换。例如:

extern "C" int strlen(const char∗); // from <string.h>

void f()

{

char v[] = "Annemarie";

char∗ p = v; // char[] 到 char* 的隐式转换

strlen(p);

strlen(v); // char[] 到 char*的隐式转换

v = p; // 错 : 不能给数组名赋值

}

在两次调用中,相同的值都会传递给标准库函数 strlen()。问题是无法避免隐式转换。换句话说,没有办法声明一个以便在调用它时复制数组 v 的函数。幸运的是,没有从指针到数组的隐式或显式转换。

    将数组参数隐式转换为指针意味着被调用函数无法获知数组的大小。但是,被调用函数必须以某种方式确定大小才能执行有意义的操作。与其他使用指向字符的指针的 C 标准库函数一样,strlen() 依赖零来指示字符串结尾;strlen(p) 返回直到(不包括)终止 0 的字符数。这都是相当底层的。标准库向量类vector(§4.4.1,§13.6,§31.4)、数组类array(§8.2.4,§34.2.1)和字符串类string(§4.2)都不会遇到此问题。这些库类型将其元素数量作为其 size(),而无需每次都计算元素数量。

7.4.1  数组操作导引(Navigating Arrays)

    高效而优雅地访问数组(和类似的数据结构)是许多算法的关键(参见第32章第4.5节)。可以通过指向数组的指针(译注:数组首地址)加上索引或通过指向元素的指针来实现对数组的访问。例如:

void fi(char v[])

{

for (int i = 0; v[i]!=0; ++i)

use(v[i]);

}

void fp(char v[])

{

for (char∗ p = v; ∗p!=0; ++p)

use(∗p);

}

前缀 ∗ 运算符角引用指针,使得 ∗p 是 p 指向的字符,而 ++ 增加指针,使其指向数组的下一个元素。

    没有内在原因说明为什么一个版本应该比另一个版本更快。使用现代编译器,两个示例应该(通常也是)生成相同的代码。程序员可以根据逻辑和审美选择版本。

    内置数组的下标是根据指针操作 + 和 ∗ 定义的。对于每个内置数组 a 和 a 范围内的整数 j,我们有:

a[j] == ∗(&a[0]+j) == ∗(a+j) == ∗(j+a) == j[a]

人们通常会惊讶地发现 a[j]==j[a]。例如,3["Texas"]=="Texas"[3]=='a'。这种“聪明”的做法在生产代码中是行不通的。这些等价关系非常底层,不适用于标准库容器,例如array和vector 。

       将算术运算符 +、−、++ 或 −− 应用于指针的结果取决于指向的对象的类型。当将算术运算符应用于类型 T∗ 的指针 p 时,假定 p 指向类型 T 的对象数组的一个元素;p+1 指向该数组的下一个元素,而 p−1 指向前一个元素。这意味着 p+1 的整数值将比 p 的整数值 sizeof(T) 大。例如:

template<typename T>

int byte_diff(T∗ p, T∗ q)

{

return reinterpret_cast<char∗>(q)−reinterpret_cast<char∗>(p);

}

void diff_test()

{

int vi[10];

short vs[10];

cout << vi << ' ' << &vi[1] << ' ' << &vi[1]−&vi[0] << ' ' << byte_diff(&vi[0],&vi[1]) << '\n';

cout << vs << ' ' << &vs[1] << ' ' << &vs[1]−&vs[0] << ' ' << byte_diff(&vs[0],&vs[1]) << '\n';

}

产生:

0x7fffaef0 0x7fffaef4 1 4

0x7fffaedc 0x7fffaede 1 2

指针值使用默认的十六进制表示法打印。这表明在我的实现中,sizeof(short) 是 2,sizeof(int) 是 4。

    仅当两个指针都指向同一数组的元素时,指针减法才有定义(尽管语言没有快速确保这种情况的方法)。当从另一个指针 q(q - p)中减去指针 p 时,结果是序列 [p:q) 中的数组元素数(一个整数)。可以将整数添加到指针或从指针中减去整数;在这两种情况下,结果都是指针值。如果该值不指向与原始指针相同或更远的数组的元素,则使用该值的结果是未定义的。例如:

void f()

{

int v1[10];

int v2[10];

int i1 = &v1[5]−&v1[3]; // i1 = 2

int i2 = &v1[5]−&v2[3]; // result undefined

int∗ p1 = v2+2; // p1 = &v2[2]

int∗ p2 = v2−2; // *p2 undefined

}

复杂的指针运算通常是不必要的,最好避免。指针之间相加是没有意义的,也是不允许的。

    数组不是自描述的(self-describing),因为不能保证数组元素的数量与数组一起存储。这意味着,要像 C 风格字符串那样遍历不包含终止符的数组,我们必须以某种方式提供元素的数量。例如:

void fp(char v[], int size)

{

for (int i=0; i!=size; ++i)

use(v[i]); // 希望v至少有size个元素

for (int x : v)

use(x); //错: range-for 不适用于指针

const int N = 7;

char v2[N];

for (int i=0; i!=N; ++i)

use(v2[i]);

for (int x : v2)

use(x); //range-for 对已知大小的数组有效

}

此数组概念本质上是底层的。通过使用标准库容器array(§8.2.4、§34.2.1),可以获得内置数组的大多数优点和少数缺点。一些 C++ 实现为数组提供可选的范围检查。但是,这种检查可能非常昂贵,因此它通常仅用作开发辅助(而不是包含在生产代码中)。如果您没有对单个访问使用范围检查,请尝试保持一致的策略,即仅在明确定义的范围内访问元素。当通过更高级容器类型(例如vector)的接口操作数组时,最好这样做,因为在这种情况下,很难混淆有效元素的范围。

7.4.2  多维数组(Multidimensional Arrays)

多维数组表示为数组的数组;3 × 5 数组声明如下:

int ma[3][5]; // 3个一维数组,且每个一维数组具有 5 个int 元素

我们可以像这样初始化 ma:

void init_ma()

{

for (int i = 0; i!=3; i++)

for (int j = 0; j!=5; j++)

ma[i][j] = 10∗i+j;

}

或用图形表示为:

数组 ma 只是 15 个 int,我们访问它就像访问 3 个 5 int 数组一样。具体来说,内存中没有单个对象是矩阵 ma —— 只存储元素。维数 3 和 5 仅存在于编译器源代码中。当我们编写代码时,我们的工作是以某种方式记住它们并在需要时提供维数。例如,我们可以像这样打印 ma:

void print_ma()

{

for (int i = 0; i!=3; i++) {

for (int j = 0; j!=5; j++)

cout << ma[i][j] << '\t';

cout << '\n';

}

}

某些语言中用于数组边界的逗号表示法不能在 C++ 中使用,因为逗号 (,) 是排序运算符 (§10.3.2)。幸运的是,大多数错误都会被编译器捕获。例如:

int bad[3,5]; // 错: 逗号不允许用在常量表达式中

int good[3][5]; // 3个一维数组,且每个一维数组具有 5 个int 元素

int ouch = good[1,4]; //错:用 int*初始化I nt (good[1,4] 指 good[4], 这是int*

int nice = good[1][4];

7.4.3  传递数组(Passing Arrays)

数组不能直接按值传递。相反,数组作为指向其第一个元素的指针传递。例如:

void comp(double arg[10]) // arg is a double*

{

for (int i=0; i!=10; ++i)

arg[i]+=99;

}

void f()

{

double a1[10];

double a2[5];

double a3[100];

comp(a1);

comp(a2); // disaster!

comp(a3); // uses only the first 10 elements

};

    这段代码看起来合理,但实际上并非如此。代码可以编译,但调用 comp(a2) 会超出 a2 的边界。此外,任何猜测数组是通过值传递的人都会感到失望:对 arg[i] 的写入直接写入 comp() 参数的元素,而不是副本。该函数可以等价地写为

void comp(double∗ arg)

{

for (int i=0; i!=10; ++i)

arg[i]+=99;

}

现在,这种疯狂(希望)显而易见了。当用作函数参数时,数组的第一个维度仅被视为指针。任何指定的数组绑定都将被忽略。这意味着如果您想传递元素序列而不丢失大小信息,则不应传递内置数组。相反,您可以将数组作为成员放在类中(就像对 std::array 所做的那样)或定义一个充当句柄的类(就像对 std::string 和 std::vector 所做的那样)。

    如果你坚持直接使用数组,你将不得不处理错误和混乱,而得不到明显的优势。考虑定义一个函数来操作二维矩阵。如果在编译时知道维数,那就没有问题:

void print_m35(int m[3][5])

{

for (int i = 0; i!=3; i++) {

for (int j = 0; j!=5; j++)

cout << m[i][j] << '\t';

cout << '\n';

}

}

表示为多维数组的矩阵作为指针传递(而不是复制;§7.4)。数组的第一维与查找元素的位置无关;它只是说明有多少个元素(这里是 3)具有适当的类型(这里是 int[5])。例如,查看上面的 ma 的布局,并注意,只要知道第二维是 5,我们就可以求得任何 i 的 ma[i][5]。因此,第一维可以作为参数传递:

void print_mi5(int m[][5], int dim1)

{

for (int i = 0; i!=dim1; i++) {

for (int j = 0; j!=5; j++)

cout << m[i][j] << '\t';

cout << '\n';

}

}

当需要传递两个维度时,“显而易见的解决方案”不起作用:

void print_mij(int m[][], int dim1, int dim2) // 并不会表现得像大多数人认为的那样

{

for (int i = 0; i!=dim1; i++) {

for (int j = 0; j!=dim2; j++)

cout << m[i][j] << '\t'; // 意外!

cout << '\n';

}

}

    幸运的是,参数声明 m[][] 是非法的,因为必须知道多维数组的第二个维数才能求得元素的位置。但是,表达式 m[i][j] 被(正确地)解释为 ∗(∗(m+i)+j),尽管这不太可能是程序员的意图。正确的解决方案是:

void print_mij(int∗ m, int dim1, int dim2)

{

for (int i = 0; i!=dim1; i++) {

for (int j = 0; j!=dim2; j++)

cout << m[i∗dim2+j] << '\t'; // 模糊

cout << '\n';

}

}

用于访问 print_mij () 中成员的表达式相当于编译器在知道最后一个维度时生成的表达式。

    为了调用此函数,我们将矩阵作为普通指针传递:

int test()

{

int v[3][5] = {

{0,1,2,3,4}, {10,11,12,13,14}, {20,21,22,23,24}

};

print_m35(v);

print_mi5(v,3);

print_mij(&v[0][0],3,5);

}

请注意最后一次调用使用了 &v[0][0];v[0] 可以,因为它是等效的,但 v 会出现类型错误。这种微妙而混乱的代码最好隐藏起来。如果您必须直接处理多维数组,请考虑封装依赖它的代码。这样,您可能会减轻下一个接触代码的程序员的任务。为多维数组类型提供适当的下标运算符可以使大多数用户不必担心数组中数据的布局(§29.2.2、§40.5.2)。

    标准vector(§31.4)不会遇到这些问题。

7.5  指针和const

C++ 提供了两种“const”的相关含义:

(1) constexpr: 在编译时计算(§2.2.3, §10.4)。

(2) const: 在其作用域内不可修改(§2.2.3)。

基本上,constexpr的作用是使能和确保编译时计算,而const的主要作用是指定接口中的不变性。本节主要关注第二个作用:接口规范。

    许多对象的值在初始化之后不会改变:

(1) 与直接在代码中使用文字量相比,符号常量可使代码更易于维护。

(2) 许多指针通常被读取但从未被写入。

(3) 大多数函数参数都被读取但从未被写入。

为了表达初始化后的不变性概念,我们可以将 const 添加到对象的定义中。例如:

const int model = 90; // model is a const

const int v[] = { 1, 2, 3, 4 }; // v[i] is a const

const int x; // error : no initializer

由于声明为 const 的对象不能赋值,因此必须对其进行初始化。

    将某个东西声明为 const 可以确保它的值在其作用域内不会改变:

void f()

{

model = 200; // error

v[2] = 3; // error

}

请注意,const 修改类型;它限制对象的使用方式(译注:使用时按照语法规则不能去改变它的值),而不是指定如何分配常量。例如:

void g(const X∗ p)

{

// can’t modify *p here

}

void h()

{

X val; // val can be modified here

g(&val);

// ...

}

使用指针时,涉及两个对象:指针本身和指向的对象。在指针声明前加上 const 会使对象(而不是指针)成为常量。要将指针本身(而不是指向的对象)声明为常量,我们使用声明符运算符 ∗const 而不是普通的 ∗。例如:

void f1(char∗ p)

{

char s[] = "Gorm";

const char∗ pc = s; // 指向常量的指针

pc[3] = 'g'; // error : pc 指向常量

pc = p; // OK

char ∗const cp = s; // 常量指针

cp[3] = 'a'; // OK

cp = p; // error : cp 是常量

const char ∗const cpc = s; // 指向常量的常量指针

cpc[3] = 'a'; // error : cpc 指向常量

cpc = p; // error : cpc 是常量

}

使指针成为常量的声明符运算符是 ∗const。没有 const∗ 声明符运算符,因此出现在 ∗ 之前的 const 被视为基类型的一部分。例如:

char ∗const cp; // const pointer to char

char const∗pc; //pointer to const char

const char∗ pc2; //pointer to const char

有些人发现从右到左阅读此类声明很有帮助,例如,“cp 是指向 char 的 const 指针”和“pc2 是指向 char const 的指针”。

通过一个指针访问时为常量的对象,在以其他方式访问时可能为变量。这对于函数参数特别有用。通过将指针参数声明为 const,函数将无法修改指向的对象。例如:

const char∗ strchr(const char∗ p, char c); // 求c在p中第一次出现位置

char∗ strchr(char∗ p, char c); //求c在p中第一次出现位置

第一个版本用于元素不能被修改的字符串,并返回一个不允许修改的 const 指针。第二个版本用于可变字符串。

您可以将非const变量的地址赋给指向常量的指针,因为这样做不会造成任何损害。但是,不能将常量的地址赋给不受限制的指针,因为这将允许更改对象的值。例如:

void f4()

{

int a = 1;

const int c = 2;

const int∗ p1 = &c; // OK

const int∗ p2 = &a; // OK

int∗ p3 = &c; // 错 :用const int*初始化int*

∗p3 = 7; // 试图改变c的值

}

通过显式类型转换(§16.2.9、§11.5)明确删除对指向 const 的指针的限制是可能的,但通常是不明智的(译注:实际上const只是编译时限制,如果显式取得const指针的地址,则可绕开const限制进行任何操作)。

7.6  指针和属主(Pointers and Ownership)

资源是在需要是必须获取并随后释放的东西(§5.2)。通过 new 获取并通过 delete 释放的内存(§11.2)以及通过 fopen() 打开并通过 fclose() 关闭的文件(§43.2)都是资源的例子,其中资源的最直接句柄是指针。这可能最令人困惑,因为指针很容易在程序中传递,并且类型系统中没有任何东西可以区分拥有资源的指针和不拥有资源的指针。考虑:

void confused(int∗ p)

{

// delete p?

}

int global {7};

void f()

{

X∗ pn = new int{7};

int i {7};

int q = &i;

confused(pn);

confused(q);

confused(&global);

}

如果 confused() 删除了 p,程序在后两次调用时将出现严重错误,因为我们可能无法删除未由 new 分配的对象(§11.2)。如果 confused() 不删除 p,程序内存就会泄漏(§11.2.1)。在这种情况下,显然 f() 必须管理它在自由存储中创建的对象的生命周期,但一般来说,在大型程序中跟踪需要删除的内容需要一种简单而一致的策略。

通常,最好立即将表示属主的指针放置在资源句柄类中,例如 vector,string 和 unique_ptr。这样,我们可以假设不在资源句柄内的每个指针都不是属主,并且不可删除。第 13 章更详细地讨论了资源管理。

7.7  引用(References)

指针使我们能够以低成本传递大量数据:我们无需复制数据,只需将其地址作为指针值传递即可。指针的类型决定了可以通过指针对数据执行哪些操作。使用指针与使用对象名称有以下几点不同:

(1) 我们使用不同的语法,例如,使用 ∗p 而不是 obj,使用 p−>m 而不是 obj.m。

(2) 我们可以让指针在不同时间指向不同的对象。

(3) 使用指针时必须比直接使用对象时更加小心:指针可能为 nullptr,或者指向的不是我们预期的对象。

这些差异可能令人烦恼;例如,一些程序员发现 f(&x) 与f(x)相比很丑陋。更糟糕的是,管理具有不同值的指针变量并保护代码免受 nullptr 的可能性的影响可能是一项沉重的负担。最后,当我们想要重载运算符(例如 + )时,我们希望编写 x+y 而不是 &x+&y。解决这些问题的语言机制称为引用。与指针一样,引用是对象的别名,通常用于保存对象的机器地址,并且与指针相比不会带来性能开销,但它与指针的不同之处在于:

(1) 访问引用的语法与访问对象名称的语法完全相同。

(2) 引用始终指向初始化时所指向的对象。

(3) 不存在“空引用”,我们可以假设引用指向对象(§7.7.4)。

引用是对象的替代名称,即别名。引用的主要用途是为函数指定参数和返回值,特别是为重载运算符(第 18 章)指定参数和返回值。例如:

template<class T>

class vector {

T∗ elem;

// ...

public:

T& operator[](int i) { return elem[i]; } // 返回指向元素的引用

const T& operator[](int i) const { return elem[i]; } //返回指向const元素的引用

void push_back(const T& a); // 用引用传递被加元素

// ...

};

void f(const vector<double>& v)

{

double d1 = v[1]; //将 v.operator[](1) 引用的 double 值复制到 d1 中

v[2] = 7; //将 7 放置在 v.operator[](2) 的结果所引用的双精度数中v.push_back(d1); //给 push_back() 一个对 d1 的引用,以便使用

}

通过引用传递函数参数的想法与高级编程语言一样古老(Fortran 的第一个版本就使用了它)。

为了体现左值/右值和const/非常量的区别,有三种类型的引用:

(1) 左值(lvalue)引用:引用我们想要更改其值的对象。

(2) const 引用:引用我们不想更改其值的对象(例如,常量)。

(3) 右值(rvalue)引用:引用我们在使用后不需要保留其值的对象(例如,临时值)。

它们统称为引用。前两个都称为左值引用。

7.7.1  左值引用

    在类型名称中,符号 X& 表示“对 X 的引用”。它用于对左值的引用,因此通常称为左值引用。例如:

void f()

{

int var = 1;

int& r {var}; // r 和 var 现在指向同一个int

int x = r; // x 成 1

r = 2; // var 成 2

}

为了确保引用是某个事物的名称(即它绑定到某个对象),我们必须初始化该引用。例如:

int var = 1;

int& r1 {var}; // OK: r1已初始化

int& r2; // 错: 无初始化

extern int& r3; // OK: r3 在别处初始化

引用的初始化与赋值完全不同。尽管表面上如此,但没有任何运算符对引用进行操作。例如:

void g()

{

int var = 0;

int& rr {var};

++rr; //var 递增1

int∗ pp = &rr; // pp 指向 var

}

这里,++rr 不会增加引用 rr;相反,++ 应用于 rr 所引用的 int,即 var。因此,引用的值在初始化后不能更改;它始终指向它被初始化为表示的对象。要获取指向引用 rr 所表示的对象的指针,我们可以写 &rr。因此,我们不能拥有指向引用的指针。此外,我们不能定义引用数组。从这个意义上讲,引用不是对象。

    引用的明显实现是作为(常量)指针,每次使用时都会解引用。这样考虑引用不会造成太大的伤害,只需记住引用不是可以像指针那样操纵的对象:

在某些情况下,编译器可以优化掉某个引用,这样运行时就不会有对象代表该引用。

当初始化器是左值(可以获取其地址的对象;参见 §6.4)时,引用的初始化很简单。“普通”T& 的初始化器必须是类型为 T 的左值。

const T& 的初始化器不需要是左值,甚至不需要是 T 类型。在这种情况下:

[1] 首先,如有必要,将隐式类型转换为 T(参见 §10.5)。

[2] 然后,将结果值放在类型 T 的临时变量中。

[3] 最后,将此临时变量用作初始化器的值。

考虑:

double& dr = 1; // 错 :需要左值

const double& cdr {1}; // OK

最后一个初始化的解释可以是:

double temp = double{1}; // 首先创建具有右值的临时对象

const double& cdr {temp}; // 然后用临时对象 y 初努化 cdr

为保存引用初始化器而创建的临时变量会一直存在,直到其引用范围结束。

    对变量的引用和对常量的引用是有区别的,因为为变量引入临时变量很容易出错;对变量的赋值将变成对即将消失的临时变量的赋值。对常量的引用不存在这样的问题,对常量的引用通常作为函数参数很重要(§18.2.4)。

    引用可用于指定函数参数,以便函数可以更改传递给它的对象的值。例如:

void increment(int& aa)

{

++aa;

}

void f()

{

int x = 1;

increment(x); // x = 2

}

参数传递的语义被定义为初始化的语义,因此在调用时,increment 的参数 aa 成为 x 的另一个名称。为了保持程序的可读性,通常最好避免使用修改其参数的函数。相反,您可以明确地从函数返回一个值:

int next(int p) { return p+1; }

void g()

{

int x = 1;

increment(x); // x = 2

x = next(x); // x = 3

}

递增 (x) 符号不会像 x=next(x) 那样向读者提供 x 的值正在被修改的线索。因此,只有当函数名称强烈暗示引用参数已被修改时,才应使用“普通”引用参数。

    引用也可以用作返回类型。这主要用于定义可以在赋值左侧和右侧使用的函数。Map 就是一个很好的例子。例如:

template<class K, class V>

class Map { // a simple map class

public:

V& operator[](const K& v); // 返回键 v 对应的值

pair<K,V>∗ begin() { return &elem[0]; }

pair<K,V>∗ end() { return &elem[0]+elem.size(); }

private:

vector<pair<K,V>> elem; // {key,value} pairs

};

标准库Map(§4.4.3、§31.4.3)通常实现为红黑树,但为了避免分散实现细节,我仅展示基于线性搜索的实现以查找键匹配:

template<class K, class V>

V& Map<K,V>::operator[](const K& k)

{

for (auto& x : elem)

if (k == x.first)

return x.second;

elem.push_back({k,V{}}); // add pair at end (§4.4.2)

return elem.back().second; // 返回新元素的(默认)值

}

我通过引用传递键参数 k,因为它可能属于复制成本高昂的类型。同样,我通过引用返回值,因为它也可能属于复制成本高昂的类型。我对 k 使用 const 引用,因为我不想修改它,而且我可能想使用文字或临时对象作为参数。我通过非const引用返回结果,因为 Map的用户可能非常想修改求得值。例如:

int main() // 基于输入统计每一个单词出现的次数

{

Map<string,int> buf;

for (string s; cin>>s;) ++buf[s];

for (const auto& x : buf)

cout << x.first << ": " << x.second << '\n';

}

每次,输入循环都会从标准输入流 cin 中读出一个单词到字符串 s (§4.3.2) 中,然后更新与之关联的计数器。最后,打印出输入中不同单词的结果表,每个单词都有其出现的次数。例如,给定输入

aa bb bb aa aa bb aa aa

该程序将产生

aa: 5

bb: 3

范围 for 循环适用于此,因为 Map 定义了 begin() 和 end(),就像标准库 map 所做的那样。

7.7.2  右值引用

拥有多种引用的基本思想是为了支持对象的不同用途:

(1) 非 const 左值引用指的是引用的用户可以写入的对象。

(2) const 左值引用指的是常量,从引用的用户的角度来看,它是不可变的。

(3) 右值引用指的是临时对象,引用的用户可以(并且通常会)修改它,假设该对象永远不会再使用。

我们想知道引用是否指向临时对象,因为如果确实如此,我们有时可以将昂贵的复制操作转变为廉价的移动操作(§3.3.2,§17.1,§17.5.2)。如果我们知道源不会再次使用,那么由指向潜在大量信息的小描述符表示的对象(例如字符串或列表)可以简单而廉价地移动。经典示例是返回值,其中编译器知道返回的局部变量永远不会再使用(§3.3.2)。

右值引用可以绑定到右值,但不能绑定到左值。在这方面,右值引用与左值引用完全相反。例如:

string var {"Cambridge"};

string f();

string& r1 {var}; //左值引用,将r1绑定到var (一个左值)

string& r2 {f()}; //左值引用,错 : f() 是一个右值

string& r3 {"Princeton"}; //左值引用, 错 : 不能绑定到临时 y

string&& rr1 {f()}; // 右值引用, 善: 绑定rr1 到右值 (一个临时 y)

string&& rr2 {var}; //右值引用, 错 : var是左值

string&& rr3 {"Oxford"}; // rr3 指向存储"Oxford"的临时y

const string cr1& {"Harvard"}; // OK: 创建临时 y 并绑定到 cr1

&& 声明符表示“右值引用”。我们不使用 const 右值引用;使用右值引用的大多数好处都涉及写入它所引用的对象。const 左值引用和右值引用都可以绑定到右值。但是,目的将根本不同:

(1) 我们使用右值引用来实现“破坏性读取”,以优化原本需要复制的内容。

(2) 我们使用 const 左值引用来防止修改参数。

右值引用所引用的对象与左值引用或普通变量名所引用的对象完全一样。例如:

string f(string&& s)

{

if (s.size())

s[0] = toupper(s[0]);

return s;

}

有时,程序员知道某个对象不会再被使用,但编译器却不知道。考虑一下:

template<class T>

void swap(T& a, T& b) // "旧风格的swap"

{

T tmp {a}; // 现在我们有两个a的副本

a = b; //现在我们有两个b的副本

b = tmp; // 现在我们有两个tmp (aka a) 的副本

}

如果 T 是一种复制元素成本很高的类型,例如字符串和向量,则 swap() 将成为一项成本高昂的操作。请注意一件奇怪的事情:我们根本不想要任何副本;我们只想移动 a,b 和 tmp 的值。我们可以告诉编译器:

template<class T>

void swap(T& a, T& b) // "完美swap" (几乎是)

{

T tmp {static_cast<T&&>(a)}; // 初始化可以写入a

//译注:(tmp的值==a)

a = static_cast<T&&>(b); // 赋值可以写入b

b = static_cast<T&&>(tmp); // 赋值可以写入 tmp

}

static_cast<T&&>(x) 的结果值是 x 的 T&& 类型的右值。针对右值优化的操作现在可以将其优化用于 x。特别是,如果类型 T 具有移动构造函数(§3.3.2、§17.5.2)或移动赋值,则将使用它。考虑向量:

template<class T> class vector {

// ...

vector(const vector& r); // 复制构造函数 (复制 r 的表示)

vector(vector&& r); //移动构造函数(从r"偷走"表示)

};

vector<string> s;

vector<string> s2 {s}; // s是左值, 使用复制构造函数

vector<string> s3 {s+"tail"); // s+"tail"右值因此选移动构造函数

swap() 中使用 static_cast 有点冗长,而且容易出现错误,因此标准库提供了一个 move() 函数:move(x) 表示 static_cast<X&&>(x),其中 X 是 x 的类型。鉴于此,我们可以稍微整理一下 swap() 的定义:

template<class T>

void swap(T& a, T& b) // "perfect swap" (almost)

{

T tmp {move(a)}; // move from a

a = move(b); // move from b

b = move(tmp); // move from tmp

}

与原始 swap() 相比,最新版本不需要进行任何复制;它将尽可能使用移动操作。

    由于 move(x) 不会移动 x(它只是生成一个对 x 的右值引用),所以如果 move() 被称为 rval() 会更好,但现在 move() 已经使用了很多年。

    我认为这个swap()  是“近乎完美的”,因为它只会交换左值。考虑:

void f(vector<int>& v)

{

swap(v,vector<int>{1,2,3}); //用1,2,3替撒v的元素

// ...

}

用某种默认值替换容器的内容并不罕见,但这个特定的 swap() 无法做到这一点。一种解决方案是通过两个重载来增强它:

template<class T> void swap(T&& a, T& b);

template<class T> void swap(T& a, T&& b)

我们的示例将由 swap() 的最后一个版本处理。标准库采用了不同的方法,通过为向量、字符串等定义 shrink_to_fit() 和 clear()(§31.3.3)来处理 swap() 的右值参数的最常见情况:

void f(string& s, vector<int>& v)

{

s.shrink_to_fit(); // 使 s.capacity()==s.size()

swap(s,string{s}); //使s.capacity()==s.size()

v.clear(); //置空 v

swap(v.vector<int>{}); //置空 v

v ={}; //置空 v

}

右值引用也可用于提供完美转发(§23.5.2.1、§35.5.1)。

    所有标准库容器都提供移动构造函数和移动赋值(§31.3.2)。此外,其插入新元素的操作(例如 insert() 和 push_back())都有采用右值引用的版本。

7.7.3  指向引用的引用

    如果您获取对某个类型的引用的引用,您将获得对该类型的引用,而不是某种对引用类型的特殊引用。但哪种引用?左值引用还是右值引用?考虑:

using rr_i = int&&;

using lr_i = int&;

using rr_rr_i = rr_i&&; // ‘‘int && &&’’ is an int&&

using lr_rr_i = rr_i&; // ‘‘int && &’’ is an int&

using rr_lr_i = lr_i&&; // ‘‘int & &&’’ is an int&

using lr_lr_i = lr_i&; // ‘‘int & &’’ is an int&

换句话说,左值引用总是获胜。这是有道理的:我们对类型所做的任何事情都无法改变涉及左值的引的事实。这有时被称为引用崩溃。

    下面的这种语法是不允许的:

    int && & r = i;

对引用的引用只能作为别名(§3.4.5、§6.5)或模板类型参数(§23.5.2.1)的结果而发生。

7.7.4  指针和引用

    指针和引用是两种在程序中引用不同位置的对象而无需复制的机制。我们可以用图形展示这种相似性:

各有其长处和弱点。

如果需要更改要引用的对象,请使用指针。可以使用 =、+=、−=、++ 和 −− 来更改指针变量的值(§11.1.4)。例如:

void fp(char∗ p)

{

while (∗p)

cout << ++∗p;

}

void fr(char& r)

{

while (r)

cout << ++r; // oops: 增加引用的字符,而不是引用

// 几乎无限循环!

}

void fr2(char& r)

{

char∗ p = &r; //获得一个引用所指对象的指针

while (∗p)

cout << ++∗p;

}

反之,如果您想确保名称始终指向同一个对象,请使用引用。例如:

template<class T> class Proxy { // Proxy 指的是用来初始化T& m的对象 ;

public:

Proxy(T& mm) :m{mm} {}

// ...

};

template<class T> class Handle { // Handle 指的是其当前对象 T∗ m;;

public:

Proxy(T∗ mm) :m{mm} {}

void rebind(T∗ mm) { m = mm; }

// ...

};

如果要在引用某个对象的东西上使用用户定义(重载)运算符(§18.1),请使用引用:

Matrix operator+(const Matrix&, const Matrix&); // OK

Matrix operator−(const Matrix∗, const Matrix∗); // 错:非用户定义类型参数

Matrix y, z;

// ...

Matrix x = y+z; // OK

Matrix x2 = &y−&z; // 错误且丑陋

无法为诸如指针之类的一对内置类型(重新)定义运算符(§18.2.3)。

如果你想要一个指向某个对象的集合,那么你必须使用指针:

int x, y;

string& a1[] = {x, y}; // 错: 引用数组

string∗ a2[] = {&x, &y}; // OK

vector<string&> s1 = {x , y}; //错: 引用向量

vector<string∗> s2 = {&x, &y}; // OK

一旦我们摆脱了 C++ 不给程序员选择权的情况,我们就进入了美学领域。在理想情况下,我们会做出选择,以尽量减少出错的可能性,特别是最大限度地提高代码的可读性。

    如果您需要“无值”的概念,指针会提供 nullptr。没有等价的“空引用”,因此如果您需要“无值”,使用指针可能是最合适的。例如:

void fp(X∗ p)

{

if (p == nullptr) {

// 无值

}

else {

// use *p

}

}

void fr(X& r) // 常见风格

{

// 假设r有效并用之

}

如果您确实想要,您可以构造并检查特定类型的“空引用”:

void fr2(X& r)

{

if (&r == &nullX) { // 或可以是  r== nullX

// 无值

}

else {

// use r

}

}

显然,您需要适当定义 nullX。这种风格不符合惯用语,我不推荐它。程序员可以假设引用是有效的。可以创建一个无效的引用,但您必须特意这样做。例如:

char∗ ident(char ∗ p) { return p; }

char& r {∗ident(nullptr)}; // 无效代码

此代码不是有效的 C++ 代码。即使您当前的实现(译注:编译器)无法捕获此问题,也不要编写此类代码。

7.8  建议

[1] 保持指针的使用简单明了;§7.4.1。

[2] 避免非平凡的指针算法;§7.4。

[3] 注意不要超出数组的界限;§7.4.1。

[4] 避免使用多维数组;而是定义合适的容器;§7.4.2。

[5] 使用 nullptr 而不是 0 或 NULL;§7.2.2。

[6] 使用容器(例如,vector,array 和 valarray)而不是内置(C 风格)数组;§7.4.1。

[7] 使用字符串而不是以零结尾的 char 数组;§7.4。

[8] 使用原字符串作为反斜杠复杂用法的字符串文字量;§7.3.2.1。

[9] 优先使用 const 引用参数而不是普通引用参数;§7.7.3。

[10] 仅使用右值引用进行转发和移动语义;§7.7.2。

[11] 将表示所有权的指针保留在句柄类中;§7.6。

[12] 除底层代码外,避免使用 void∗;§7.2.1。

[13] 使用 const 指针和 const 引用来表达接口中的不变性;§7.5。

[14] 优先使用引用而非指针作为参数,除非“无对象”是合理的选择;

§7.7.4。

内容来源:

<<The C++ Programming Language >> 第4版,作者 Bjarne Stroustrup

【华为OD机试真题 新系统】959、 水库溃坝填补 | 机试真题+思路参考+代码解析(C++、Java、Py、C语言、JS) 【华为OD机试真题 2025C卷】959、 水库溃坝填补 | 机试真题+思路参考+代码解析(C++、Java、Py、C语言、JS) 华为od机试,华为od机试真题,华为od机试E卷,华为odE卷,华为od机试真题E卷,华为OD,华为OD机试,华为OD机试真题,华为od机考,华为od机试D卷,华为od机试真题D卷,华为od手撕代码,华为od,华为od机试C卷,华为od e卷,华为2025e卷,od机试,2025E卷,华为OD机试E卷,什么是华为od,华为od介绍,全面了解华为od,2025华为od,如何备战华 阅读详情

相关推荐

基于STM32的PID恒温恒湿控制系统 | 保姆式教程 开源可复刻

本项目基于STM32F103C8T6核心控制器,完整实现了基于双路PID算法的恒温恒湿闭环控制系统,覆盖高精度温湿度采集、双模式控制、参数在线配置、异常安全保护、掉电记忆等全功能,全程采用无跳步保姆式教学,从硬件选型、接线、CubeMX配置、代码开发、调试排坑全流程拆解,跟着步骤一步步操作,就能顺利完成项目复刻

ZhongWeiXiang9的博客 350

【C&C++】 函数参数详解(含指针)

C&amp;C++语言函数参数详解一、C语言函数声明函数声明的格式二、指针三、常用的传参方式传递二维数组的三种方法方法1:在参数声明中指定二维数组的列数方法2:把参数声明为一个指向数组的指针方法3:把参数声明为指向指针的指针C++字符串变量作为函数形参传递(引用方式) 一、C语言函数声明 C语言代码由上到下依次执行,原则上函数定义要出现在函数调用之前,否则就会报错。但在实际开发中,经常会在函数定义之前使用它们,这个时候就需要提前声明。 所谓声明(Declaration),就是告诉编译器我要使用这个函数,你现

haoweixl的博客 3228

Origin软件XRD全峰拟合保姆级教程:从数据导入到弱峰处理技巧

本文提供了一份Origin软件进行XRD全峰拟合的深度实战指南。文章重点解析了从数据导入预处理、基线锚点视觉化设置,到弱峰拟合的锁定策略与手动干预等核心技巧,旨在帮助用户避开常见错误,获得可靠、精确的拟合结果,从而有效服务于材料结构分析。

rgv2345678的博客 709

C++——指针作为参数传递

指针作为参数进行传递是笔试和面试经常会考到的问题,也是我们学习C和C++时应该学会的知识

壹的博客 3392

Kali Linux渗透测试:蚁剑(AntSword)三种安装方法与避坑指南

WebShell管理是渗透测试与网络安全攻防演练中的关键技术环节,它允许安全人员在获得初步访问权限后,对目标系统进行文件管理、命令执行和数据库操作等深度控制。其核心原理是通过在Web服务器上植入特定脚本,建立一条隐蔽的远程管理通道。在实战中,一个高效、稳定的WebShell管理工具能极大提升后渗透阶段的工作效率与成功率。蚁剑(AntSword)作为一款功能强大的国产开源工具,凭借其插件化架构和图形化界面,成为众多安全研究人员的首选。本文将聚焦于如何在渗透测试专用操作系统Kali Linux上部署蚁剑,详细对

weixin_34413103的博客 415

有限时间 vs 固定时间 vs 预定时间滑模:稳定性分析与仿真验证方法对比(中)

有限时间滑模控制(FTSMC)和固定时间滑模控制(FixTSMC)是两种重要的控制策略,旨在实现系统状态的快速收敛。FTSMC通过设计滑模面和控制律,确保系统状态在有限时间内收敛到原点,但其收敛时间与初始状态相关。FixTSMC则进一步优化,使收敛时间与初始状态无关,适用于高动态环境,具有更强的鲁棒性和更平滑的控制信号。两种方法均通过李雅普诺夫函数证明其稳定性,并通过仿真验证其有效性。FixTSMC在工程应用中更为可靠,尤其适合安全关键系统。

Lyajpunov的博客 3226

C++函数指针(函数作为参数)

1.构成: 所指函数的返回类型 + 指针名 + 所指函数的参数列表 double (*pf)(int);// 指针pf指向的函数, 输入参数为int,返回值为double const vector<int>* (*seq_ptr)(int);// 指针seq_ptr指向一个vector类型的指针 2.使用方式: const vector<int> *pseq =...

abyss_miracle的博客 5886

全国职业院校技能大赛-大数据应用赛项-数据挖掘-01

-----------------------推荐Top5结果如下--------------------------------------------第一条数据前10列结果展示为:----------------------------------------相同种类前10的id结果展示为:--------------------相似度top5(商品id:14,平均相似度:0.522356)相似度top1(商品id:1,平均相似度:0.983456)若属于该spu_id,则内容为1否则为0。

Eternity_04的博客 1958

C/C++基础 -- 指针作为函数的参数

C/C++基础 -- 指针与函数1、指针作为函数的参数1.1、指针作为函数的形参1.1、指针作为函数的形参1.2、通过指针形参返回多个运算结果 本博文由 西北工业大学MOOC 总结而来,以备以后回顾。 1、指针作为函数的参数   指针作为函数参数最重要的应用是作为函数参数,它使得被调函数除了返回值以外,能够将更多的运算结果返回到主调函数中。指针是重要的函数参数传递工具。 1.1、指针作为函数的...

不世峰兄 的博客 3951

Ubuntu 20.04 系统备份和还原

最近大家Ubuntu开发环境,经常出现搭着搭着系统就挂了,于是开始琢磨了Ubuntu系统的备份和还原,以备不时之需,Linux环境搭建实在是有点太细,好多情况下,就算曾经搭建过一遍,再次搭建有些包还是忘了安装,做好备份是十分必要的。 经过了一番研究,Ubuntu备份有很多方式:根目录tar、dd、Systemback(1.0版本已经不维护了,2.0版本收费)等等,最终决定使用 —— Timesift, 因为方便一些。 文章参考:小马虎的救星——Timeshift Timeshift Timeshift,是L

Z_Paper的博客 2万+

YOLOv9电力巡检实战:绝缘子破裂/鸟巢识别+无人机自动定位

摘要:本文聚焦电力输电线路巡检的效率与安全痛点,提出基于YOLOv9与无人机的智能巡检解决方案。针对绝缘子破裂、鸟巢等高危缺陷,通过“无人机改装-模型训练-缺陷识别-工单生成”四阶段工程落地流程,实现全自动化巡检。系统采用大疆M300无人机搭载RTK模块与Jetson边缘计算盒,结合改进YOLOv9模型实时识别5类缺陷,通过4G传输将GPS定位与缺陷数据同步至工单系统。实测表明,该方案巡检效率达50公里/天(较人工提升10倍),缺陷发现率95%(提升40%),事故预防率98%。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1514

c++:函数中的指针与引用

c++进阶之路

weixin_44216359的博客 4569

优快云独家首发!万字长文,YOLOv5/v7/v8算法模型yaml文件史上最详细解析与教程!小白也能看懂!掌握了这个就掌握了魔改YOLO的核心!

🍀🍀🍀YOLOv5/v7/v8算法模型yaml文件史上最详细解析与教程,全网最强,学不会算我输!!!

Coding... 1万+

C++编程语言——基础设施:第8章——结构,合并和枚举(Bjarne Stroustrup)

C++: 结构,联合和枚举

ComputerInBook的专栏 2092

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

C++ 之父 Bjarne Stroustrup : 简单的表述方式才是最优的方案

2016 年的最后一天,图灵访谈给各位小伙伴儿献上特大彩蛋!借用 Bjarne 大师的话“趁你还足够年轻的时候,喜欢上某些学科,选择具有挑战性和感兴趣的工作并养成良好的习惯!”,预祝你们在 2017 年找到新的方向! Bjarne Stroustrup(本贾尼·斯特劳斯特卢普) 1982 年,贝尔实验室(美国 AT&amp;T 公司)的 Bjarne Stroustrup 博士在 C 语言的基础...

Harrytsz的博客 1359

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

C++之父Bjarne Stroustrup: 简单的表述方式才是最优的方案(图灵访谈)

2016年的最后一天,图灵访谈给各位小伙伴儿献上特大彩蛋!借用Bjarne大师的话“趁你还足够年轻的时候,喜欢上某些学科,选择具有挑战性和感兴趣的工作并养成良好的习惯!”,预祝你们在2017年找到新的方向!

TuringInterview的博客 915

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

访谈 | C++之父Bjarne Stroustrup: 简单的表述方式才是最优的方案

Bjarne Stroustrup(本贾尼·斯特劳斯特卢普) 1982年,贝尔实验室(美国AT&amp;T公司)的Bjarne Stroustrup博士在c语言的基础上引入并扩充了面向对象的概念,发明了新的程序语言C++。之所以被命名为C++,是为了表达该语言与c语言的渊源关系。Bjarne Stroustrup博士因此被尊称为“C++语言之父”。 之后,面向对象的编程思想开始席卷整个开发领域,标...

韩江雪de 小屋 756

C++编程语言:基础设施:第12章——函数(Bjarne Stroustrup)

C++ 函数

ComputerInBook的专栏 1200

C++之父Bjarne Stroustrup:语言设计是被工程逼出来的

在系统编程领域,语言设计往往源自真实工程挑战而非理论空想。C++的诞生正是为了应对1979年仿真系统开发中的复杂度管理难题,其后续演变也始终围绕零开销原则展开——你不需要为未使用的特性支付运行时成本,而RAII机制则让资源安全成为语言内置的纪律。这种设计哲学使C++在高频交易、游戏引擎等性能敏感场景中保持可预测的极致效率。从C++11的移动语义到C++20的概念与协程,现代C++不断强化表达力,同时坚守控制权优先的底线。理解这些原理,能帮助开发者从“背语法”转向“推设计”,真正掌握面试八股与工程实践背后的共

weixin_33947521的博客 254

Bjarne Stroustrup的FAQ:C++的风格与技巧

Bjarne Stroustrup的FAQ:C++的风格与技巧 翻译:左轻侯   (译注:本文的翻译相当艰苦。Bjarne Stroustrup不愧是创立C++语言的一代大师,不但思想博大精深,而且在遣词造句上,也非常精微深奥。有很多地方,译者反复斟酌,都不能取得理想的效果,只能尽力而为。 Html格式的文档见译者主页:http://www.wushuang.net/ 如果你对这个翻译稿有任何意见

1204

对数组的引用

在Bjarne Stroustrup(C++创始人,他的主页)所写的《The C++ Programming Language, special edition》书中的第5章5.9节的第1题练习题中,要求写一个声明语句并进行初始化,“a reference to an array of 10 integers”,实现如下: //an array of 10 integers int arry

MJN 3129

C++编程语言:标准库:第42章——线程和任务(Bjarne Stroustrup)

C++ : 线程和任务

ComputerInBook的专栏 896

Bjarne Stroustrup的FAQ:C++的风格与技巧(转载)

Bjarne Stroustrup的FAQ:C++的风格与技巧翻译:左轻侯 (译注:本文的翻译相当艰苦。Bjarne Stroustrup不愧是创立C++语言的一代大师,不但思想博大精深,而且在遣词造句上,也非常精微深奥。有很多地方,译者反复斟酌,都不能取得理想的效果,只能尽力而为。Html格式的文档见译者主页:http://www.wushuang

codeHappy'Blog 1352

C++编程语言:基础设施:第11章——选择运算和类型转换(Bjarne Stroustrup)

C++选择运算和类型转换

ComputerInBook的专栏 1780

Bjarne Stroustrup 对C++程序员的忠告

C++之父Bjarne Stroustrup写的《The C++ Programming Language (Special Edition)》中各章后面的忠告。第1章 致读者[1] 在编写程序时,你是在为你针对某个问题的解决方案中的思想建立起一种具体表示。让程序的结构尽可能地直接反映这些思想:    [a] 如果你能把“它”看成一个独立的概念,就把它做成一个类。    [b] 如果你

喂兔子的菜 2197

C++编程语言:抽象机制:第19章——特殊运算符(Bjarne Stroustrup)

C++编程语言:抽象机制:特殊运算符(Special Operators)

ComputerInBook的专栏 1226
上一篇: C++编程:理解左值(lvalue)和右值(rvalue)
下一篇: C++编程语言——基础设施:第8章——结构,合并和枚举(Bjarne Stroustrup)
ComputerInBook
博客等级 码龄19年 1168粉丝 465原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值