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

c++编程规范 C++语言之父Bjarne Stroustrup C++ Core Guidelines (Bjarne Stroustrup Herb Sutter) P: Philosophy 见名思意 尽量使用标准库 可以编译时检查的尽量编译时检查 比如使用static_assert等等 资源一定要释放 const的合理使用 使用合适的工具以及一些工具库避免重复造轮子 P.1: Express ideas directly in code 所见即所得... 阅读详情

第11章:选择运算(Selection Operations)

目录

11.1  各种运算符(Etc. Operators)

11.1.1  逻辑运算符(Logical Operators)

11.1.2  按位逻辑运算符(Bitwise Logical Operators)

11.1.3  条件表达式(Conditional Expressions)

11.1.4  递加和递减(Increment and Decrement)

11.2  自由存储(Free Store)

11.2.1  内存管理(Memory Management)

11.2.2  数组 (Arrays)

11.2.3  获得内存空间

11.2.4  重载new

11.2.4.1  nothrow new

11.3  花括号({})列表

11.3.1  实现模式

11.3.2  限定列表(Qualified Lists)(译注:有类型限定)

11.3.3 非限定初始化列表(Unqualified Lists)

11.4  Lambda表达式

11.4.1  实现模式

11.4.2  Lambda 的替代方案(Alternatives to Lambdas)

11.4.3  捕捉(Caputure)

11.4.3.1  Lambda和生命周期

11.4.3.2  命名空间名称

11.4.3.3  Lambda 和 this指针

11.4.3.4  mutable Lambda

11.4.4  调用和返回(Call and Return)

11.4.5  Lambda 的类型(The Type of a Lambda)

11.5  显式类型转换(Explicit Type Conversion)

11.5.1  构造器类型转换(Construction)

11.5.2  命名类型转换(Named Casts)

11.5.3  C风格类型转换

11.5.4  函数风格类型转换

11.6  建议


11.1  各种运算符(Etc. Operators)

         本节将介绍一些简单的运算符:逻辑运算符(&&,|| 和 !),位逻辑运算符(&,|,˜,<< 和 >>),条件表达式(?:)以及递增和递减运算符(++ 和 −−)。除了它们的细节不适合在运算符的其他地方讨论之外,它们几乎没有共同之处。

11.1.1  逻辑运算符(Logical Operators)

    逻辑运算符 &&(与),||(或)和 !(非)接受算术和指针类型的操作数,将它们转换为bool值,并返回bool结果。&& 和 || 运算符仅在必要时才估算其第二个参数,因此它们可用于控制估算顺序(§10.3.2)。例如:

while (p && !whitespace(∗p)) ++p;

在此,若 p 是 nullptr 则它不进行解引用操作。

11.1.2  按位逻辑运算符(Bitwise Logical Operators)

    按位逻辑运算符 &(与),|(或),ˆ(异或,xor),˜(求补),>>(右移)和 <<(左移)适用于整型对象,即 char,short,int,long,long long 及其无符号对应项,以及 bool,wchar_t,char16_t 和 char32_t。普通枚举(但不是枚举类)可以隐式转换为整数类型,并用作按位逻辑运算的操作数。惯用算术转换(§10.5.3)决定结果的类型。

    按位逻辑运算符的典型用途是实现小集合(位向量)的概念。在这种情况下,无符号整数的每个位代表集合的一个成员,位数限制成员的数量。二元运算符 & 被解释为交集,| 被解释为并集,ˆ 被解释为对称差集,˜ 被解释为补集。枚举可用于命名此类集合的成员。下面是一个从 ostream 的实现中借用的小示例:

enum ios_base::iostate {

goodbit=0, eofbit=1, failbit=2, badbit=4

};

流的实现可以像这样设置和测试其状态:

state = goodbit;

// ...

if (state&(badbit|failbit)) // stream not good

额外的括号是必要的,因为 & 的优先级高于 | (§10.3)。

到达输入结束的函数可能会像这样报告:

state |= eofbit;

|= 运算符用于添加状态。简单的赋值,state=eofbit,会清除所有其他位。

    这些流状态标志可以从流实现外部观察到。例如,我们可以看到两个流的状态如何不同,如下所示:

int old = cin.rdstate(); // rdstate() 返回state

// ... use cin ...

if (cin.rdstate()ˆold) { // 改变了什么吗?

// ...

}

    计算流状态的差并不常见。对于其他类似类型,计算差异至关重要。例如,考虑将表示正在处理的一组中断的位向量与表示等待处理的一组中断的另一个位向量进行比较。

    请注意,此位操作取自 iostreams 的实现,而不是用户界面。方便的位操作可能非常重要,但出于可靠性、可维护性、可移植性等考虑,它应保持在系统的底层。有关集合的更多一般概念,请参阅标准库set(§31.4.3)和bitset(§34.2.2)。

    按位逻辑运算可用于从字(word)(译注:两个字节为一个字)中提取位域(bit-fields)。例如,可以像这样提取 32 位 int 的中间 16 位:

constexpr unsigned short middle(int a)

{

static_assert(sizeof(int)==4,"unexpected int size");

static_assert(sizeof(shor t)==2,"unexpected short siz e");

return (a>>8)&0xFFFF;

}

int x = 0xFF00FF00; // 假设 sizeof(int)==4

short y = middle(x); // y = 0x00FF

使用位域(§8.2.7)是进行此类移位和屏蔽的便捷简写。

    不要将按位逻辑运算符与逻辑运算符混淆:&&,|| 和 !。后者返回 true 或 false,它们主要用于在 if-,while- 或 for- 语句中编写测试(§9.4、§9.5)。例如,!0(非零)是值 true,转换为 1,而 ˜0(零的补码)是位模式全 1,在二进制补码表示中为值 −1(译注:整数在计算机存储中用补码表示)。

11.1.3  条件表达式(Conditional Expressions)

    一些 if 语句可以方便地用条件表达式替换。例如:

if (a <= b)

max = b;

else

max = a;

更直接的表达如下:

max = (a<=b) ? b : a;

条件周围的括号不是必需的,但我发现使用它们会使代码更易于阅读。

    条件表达式很重要,因为它们可用于常量表达式(§10.4)。如果一对表达式 e1 和 e2 属于同一类型,或者存在一个共同类型 T,并且它们都可以隐式转换为该类型,则它们可以用作条件表达式 c?e1:e2 中的替代项。对于算术类型,通常的算术转换(§10.5.3)用于查找该共同类型。对于其他类型,e1 必须可以隐式转换为 e2 的类型,反之亦然。此外,一个分支可以是 throw 表达式(§13.5.1)。例如:

void fct(int∗ p)

{

int i = (p) ? ∗p : std::runtime_error{"unexpected nullptr};

// ...

}

11.1.4  递加和递减(Increment and Decrement)

    ++ 运算符用于直接表示递加,而不是使用加法和赋值的组合来间接表示。假设左值没有副作用,++lvalue 表示 lvalue+=1,这又表示 lvalue=lvalue+1。表示要递加的对象的表达式只被估算一次。递减同样由 −− 运算符表示。

    运算符 ++ 和 −− 既可用作前缀运算符,又可用作后缀运算符。++x 的值是 x 的新值(即增加的值)。例如,y=++x 等同于 y=(x=x+1)。而 x++ 的值是 x 的旧值。例如,y=x++ 等同于 y=(t=x,x=x+1,t),其中 t 是与 x 类型相同的变量。

    就像将一个 int 加到指针上或减去它一样,指针上的 ++ 和 −− 操作是根据指针指向的数组的元素进行的;p++ 使 p 指向下一个元素(§7.4.1)。

    ++ 和 −− 运算符对于在循环中增加和减少变量特别有用。例如,可以像这样复制以零结尾的 C 风格字符串:

void cpy(char∗ p, const char∗ q)

{

while (∗p++ = ∗q++) ;

}

和 C 一样,C++ 也因其简洁、面向表达式的编码方式而受到人们的喜爱和憎恨。考虑一下:

while (∗p++ = ∗q++) ;

对于非 C 程序员来说,这有点晦涩难懂,但由于这种编码风格并不罕见,因此值得更仔细地研究。首先考虑一种更传统的复制字符数组的方法:

int length = strlen(q);

for (int i = 0; i<=length; i++)

p[i] = q[i];

这很浪费。以零结尾的字符串的长度是通过读取字符串并寻找终止零来求得的。因此,我们读取字符串两次:一次查找其长度,一次复制它。所以,我们尝试这样做:

int i;

for (i = 0; q[i]!=0 ; i++)

p[i] = q[i];

p[i] = 0; // terminating zero

用于索引的变量 i 可以消除,因为 p 和 q 是指针:

while (∗q != 0) {

∗p = ∗q;

p++; // point to next character

q++; // point to next character

}

∗p = 0; // terminating zero

因为后增操作允许我们先使用该值,然后再增加它,所以我们可以像这样重写循环:

while (∗q != 0) {

∗p++ = ∗q++;

}

∗p = 0; // terminating zero

∗p++ = ∗q++ 的值是 ∗q。因此,我们可以将这个例子重写如下:

while ((∗p++ = ∗q++) != 0) { }

    在这种情况下,我们直到将 ∗q 复制到 ∗p 并增加 p 后才注意到 ∗q 为零。因此,我们可以消除终止零的最终分配。最后,我们可以通过观察不需要空块并且 !=0 是多余的来进一步简化示例,因为整数条件的结果无论如何总是与零进行比较。因此,我们得到了我们所欲求的版本:

while (∗p++ = ∗q++) ;

此版本是否比以前的版本更难读?对于经验丰富的 C 或 C++ 程序员来说并非如此。此版本在时间或空间上是否比以前的版本更高效?除了第一个调用 strlen() 的版本外,实际上并非如此;性能将是等效的,并且通常会生成相同的代码。

    复制以零结尾的字符串的最有效方法通常是标准 C风格字符串复制函数:

char∗ strcpy(char∗, const char∗); // from <string.h>

对于更一般的复制,可以使用标准复制算法(§4.5,§32.5)。尽可能使用标准库工具,而不是摆弄指针和字节。标准库函数可以内联(§12.1.3),甚至可以使用专门的机器指令实现(译注:对于字符串操作,处理器有一套单的指令)。因此,在相信某些手工编写的代码优于库函数之前,您应该仔细衡量。即使确实如此,其他一些手工编写的代码+编译器组合可能不存在这种优势,而您的替代方案可能会让维护人员头疼。

11.2  自由存储(Free Store)

    命名对象的生命周期由其作用域决定(§6.3.4)。但是,创建一个独立于其创建作用域而存在的对象通常很有用。例如,创建可以在从创建它们的函数返回后使用的对象是很常见的。运算符 new 创建此类对象,运算符 delete 可用于销毁它们。由 new 分配的对象被称为“位于自由存储区”(也称为“在堆上”或“在动态内存中”)。

    考虑一下我们如何以桌面计算器(§10.2)的风格编写编译器。语法分析函数可能会构建一个表达式树供代码生成器使用:

struct Enode {

Token_value oper;

Enode∗ left;

Enode∗ right;

// ...

};

Enode∗ expr(bool get)

{

Enode∗ left = term(get);

for (;;) {

switch (ts.current().kind) {

case Kind::plus:

case Kind::minus:

left = new Enode {ts.current().kind,left,term(true)};

break;

default:

return left; // return node

}

}

}

在 Kind::plus 和 Kind::minus 的case 中,在自由存储中创建一个新的 Enode,并用值 {ts.current().kind,left,term(true)} 初始化。结果指针被赋值给 left,并最终从 expr() 返回。

    我使用 {} 列表符号来指定参数。或者,我可以使用旧式的 () 列表符号来指定初始化程序。但是,尝试使用 = 符号来初始化使用 new 创建的对象会导致错误:

int∗ p = new int = 7; // error

如果类型有默认构造函数,我们可以省略初始化程序,但内置类型默认未初始化。例如:

auto pc = new complex<double>; // the complex is initialized to {0,0}

auto pi = new int; // int 类型数未初始化

这可能会令人困惑。要确保获得默认初始化,请使用 {}。例如:

auto pc = new complex<double>{}; // the complex is initialized to {0,0}

auto pi = new int{}; // the int is initialized to 0

代码生成器可以使用 expr() 创建的 Enode 并删除它们:

void generate(Enode∗ n)

{

switch (n−>oper) {

case Kind::plus:

// use n

delete n; // 从自由存储区删除一个Enode

}

}

由 new 创建的对象在进程运行期间会一直存在,直到被 delete 明确销毁。然后,它所占用的空间可以被 new 重用。C++ 实现不保证存在“垃圾收集器”,该收集器会查找未引用的对象并让 new 可以重用它们。因此,我将假设由 new 创建的对象是使用 delete 手动释放的。

    delete 运算符只能应用于 new 返回的指针或 nullptr。将 delete 应用于 nullptr 无效。

如果被删除的对象属于具有析构函数的类(§3.2.1.2、§17.2),则在释放对象的内存以供重用之前,delete 会调用该析构函数。

11.2.1  内存管理(Memory Management)

    自由存储的主要问题:

    • 对象泄露:人们使用 new,然后忘记删除已分配的对象。

• 不当删除(Premature deletion):人们删除了带有其他指针的对象,然后使用该其他指针。

• 删除两次:对象被删除两次,调用其析构函数(如果有)两次。

泄漏的对象可能是一个严重的问题,因为它们可能导致程序空间不足。过早删除几乎总是一个严重的问题,因为指向“已删除对象”的指针不再指向有效对象(因此读取它可能会产生不良结果),并且可能确实指向已被另一个对象重用的内存(因此写入它可能会损坏不相关的对象)。考虑这个非常糟糕的代码示例:

int∗ p1 = new int{99};

int∗ p2 = p1; // 潜在麻烦

delete p1; // 现在p2 未指向有效对象

p1 = nullptr; // 给出错误的安全意义

char∗ p3 = new char{'x'}; // p3 现在可能指向由p2指向的内存

∗p2 = 999; //可能引起麻烦

cout << ∗p3 << '\n'; // 可能不会打印 x

删除两次会起发问题,因为资源管理器通常无法跟踪哪些代码拥有资源。考虑:

void sloppy() // 非常糟糕的代码

{

int∗ p = new int[1000]; // 主张内存

// ... use *p ...

delete[] p; // 释放内存

// ... wait a while ...

delete[] p; // 但sloppy()并不拥有 *p

}

在第二个 delete[] 时,∗p 指向的内存可能已被重新分配用于其他用途,并且分配器可能已损坏。在该示例中,将 int 替换为 string ,我们将看到 string 的析构函数尝试读取已重新分配且可能被其他代码覆盖的内存,并使用其读取的内容尝试删除内存。一般而言,删除两次是未定义的行为,结果是不可预测的,并且通常是灾难性的。

    人们犯这些错误的原因通常不是恶意的,甚至通常也不是简单的粗心大意;在大型程序中始终如一地释放每个已分配的对象确实很困难(一次且在计算的正确时间点)。首先,对程序局部部分的分析不会检测到这些问题,因为错误通常涉及多个独立部分。

    作为使用“裸”new和删除的替代方案,我可以推荐两种通用的资源管理方法来避免此类问题:

[1] 如果没有必要,不要将对象放在自由存储中;最好使用有作用域的变量。

[2] 在自由存储中构造对象时,将其指针放入管理器对象(有时称为句柄)中,并使用会销毁它的析构函数。这样做的例子包括字符串、向量和所有其他标准库容器、unique_ptr(§5.2.1,§34.3.1)和 shared_ptr(§5.2.1,§34.3.2)。尽可能让该管理器对象成为有作用域的变量。通过使用移动语义(§3.3,§17.5.2)从函数返回表示为管理器对象的大对象,可以消除许多传统的自由存储用法。

    该规则 [2] 通常被称为 RAII(“资源获取即初始化”;§5.2,§13.3),是避免资源泄漏和使用异常进行错误处理变得简单和安全的基本技术。

标准库vector是这些技术的一个例子:

void f(const string& s)

{

vector<char> v;

for (auto c : s)

v.push_back(c);

// ...

}

向量将其元素保存在自由存储空间中,但它自己处理所有分配和释放。在此示例中,push_back() 执行消息以获取其元素的空间,并删除不再需要的元素以释放空间。但是,vector的用户不需要了解这些实现细节,只需依赖vector不泄漏​​即可。

    计算器示例中的 Token_stream 是一个更简单的例子(§10.2.2)。在那里,用户可以使用 new 并将结果指针交给 Token_stream 进行管理:

Token_stream ts{new istringstream{some_string}};

我们不需要使用自由存储来从函数中获取大对象。例如:

string reverse(const string& s)

{

string ss;

for (int i=s.size()−1; 0<=i; −−i)

ss.push_back(s[i]);

return ss;

}

和vector一样,字符串实际上是其元素的句柄。因此,我们只需将 ss 移出 reverse() 即可,而不是复制任何元素(§3.3.2)。

    资源管理“智能指针”(例如 unique_ptr 和 smart_ptr )是这些思想的另一个例子(§5.2.1,§34.3.1)。例如:

void f(int n)

{

int∗ p1 = new int[n]; // potential trouble

unique_ptr<int[]> p2 {new int[n]}; // ...

if (n%2) throw runtime_error("odd");

delete[] p1; // we may nev er get here

}

对于 f(3),p1 指向的内存被泄漏,但 p2 指向的内存被正确且隐式地释放。

    我对使用 new 和 delete 的经验法则是“无裸new”;也就是说,new 属于构造函数和类似操作,delete 属于析构函数,它们一起提供了一种连贯的内存管理策略。此外,new 经常用于资源句柄的参数中。

    如果所有其他方法都失败了(例如,如果有人拥有大量旧代码,其中大量不规范地使用了 new),则C++ 会为垃圾收集器提供一个标准接口(§34.5)。

11.2.2  数组 (Arrays)

    数组也可以使用new创建。例如:

char∗ save_string(const char∗ p)

{

char∗ s = new char[strlen(p)+1];

strcpy(s,p); // copy from p to s

return s;

}

int main(int argc, char∗ argv[])

{

if (argc < 2) exit(1);

char∗ p = save_string(argv[1]);

// ...

delete[] p;

}

“普通”运算符 delete 用于删除单个对象;delete[] 用于删除数组。

    除非您确实必须直接使用 char∗,否则可以使用标准库字符串来简化 save_string():

string save_string(const char∗ p)

{

return string{p};

}

int main(int argc, char∗ argv[])

{

if (argc < 2) exit(1);

string s = save_string(argv[1]);

// ...

}

特别是,new[] 和 delete[] 消失了。

    要释放 new 分配的空间,delete 和 delete[] 必须能够确定分配的对象的大小。这意味着使用 new 的标准实现分配的对象将比静态对象占用更多的空间。至少需要空间来保存对象的大小。通常每个分配使用两个或更多字来进行自由存储管理。大多数现代机器使用 8 字节字。当我们分配许多对象或大对象时,这种开销并不大,但如果我们在自由存储上分配大量小对象(例如 int 或 Points),则可能会产生影响。

    请注意,vector(§4.4.1,§31.4)是一个真正的对象,因此可以使用普通的 new 和 delete 进行分配和释放。例如:

void f(int n)

{

vector<int>∗ p = new vector<int>(n); // 单个对象

int∗ q = new int[n]; // array

// ...

delete p;

delete[] q;

}

delete[] 运算符只能应用于指向由 new 数组返回的数组的指针或空指针(§7.2.2)。将 delete[] 应用于空指针无效。

    但是,不要使用 new 来创建局部对象。例如:

void f1()

{

X∗ p =new X;

// ... use *p ...

delete p;

}

这很冗长、低效且容易出错(§13.3)。特别是,在删除之前返回或抛出异常将导致内存泄漏(除非添加更多代码)。相反,请使用局部变量:

void f2()

{

X x;

// ... use x ...

}

退出 f2 时局部变量 x 被隐式销毁。

11.2.3  获得内存空间

    自由存储运算符 new、delete、new[] 和 delete[] 是使用 <new> 标头中提供的函数实现的:

void∗ operator new(siz e_t); // 为单个对象分配空间

void operator delete(void∗ p); // if (p) 则释放使用 operator new() 分配的空间

void∗ operator new[](siz e_t); // 为数组分配空间

void operator delete[](void∗ p); // if (p) 则释放使用operator new() 分配的空间

当operator new需要为一个对象分配空间时,它会调用operator new()来分配合适数量的字节。同样,当operator new需要为一个数组分配空间时,它会调用operator new[]()。

    operator new() 和 operator new[]() 的标准实现不会初始化返回的内存。

分配和释放函数处理的是无类型和未初始化的内存(通常称为“原内存(raw memory)”(译注:指没有与编程语言对象关联的内存,保持内存的原样)),而不是类型化对象。因此,它们接受 void∗ 类型的参数或返回值。运算符 new 和 delete 处理此无类型内存层和类型化对象层之间的映射。

当 new 找不到要分配的存储时会发生什么?默认情况下,分配器会抛出标准库 bad_alloc 异常(有关替代方法,请参阅 §11.2.4.1)。例如:

void f()

{

vector<char∗> v;

try {

for (;;) {

char ∗ p = new char[10000]; // acquire some memory

v.push_back(p); //make sure the new memory is referenced

p[0] = 'x'; // use the new memor y

}

}

catch(bad_alloc) {

cerr << "Memory exhausted!\n";

}

}

无论我们有多少可用内存,这最终都会调用 bad_alloc 处理程序。请注意:当物理主内存用尽时,不能保证抛出 new 运算符异常。因此,在具有虚拟内存的系统上,此程序可能会消耗大量磁盘空间,并且需要很长时间才能抛出异常。

    我们可以指定当内存耗尽时 new 应该做什么;参见§30.4.1.3。

    除了 <new> 中定义的函数外,用户还可以为特定类定义运算符 new() 等(§19.2.5)。根据通常的作用域规则,类成员运算符 new() 等优先于 <new> 中的成员。

11.2.4  重载new

    默认情况下,运算符 new 在自由存储中创建其对象。如果我们想将对象分配到其他地方怎么办?考虑一个简单的类:

class X {

public:

X(int);

// ...

};

我们可以通过提供一个带有额外参数的分配器函数(§11.2.3)来将对象置放在任何地方,然后在使用 new 时提供这些额外的参数:

void∗ operator new(siz e_t, void∗ p) { return p; } // 显式置放运算符

void∗ buf = reinterpret_cast<void∗>(0xF00F); // 重要地址

X∗ p2 = new(buf) X; // 在buf处构造一个X;

// 调用: operator new(sizeof(X),buf)

由于这种用法,为运算符 new() 提供额外参数的 new(buf) X 语法被称为置放语法(placement syntax)。请注意,每个运算符 new() 都将大小作为其第一个参数,并且分配的对象的大小是隐式提供的(§19.2.5)。new 运算符使用的运算符 new() 由通常的参数匹配规则(§12.3)选择;每个运算符 new() 都有一个 size_t 作为其第一个参数。

    “置放”运算符 new() 是此类分配器中最简单的一个。它在标准标头 <new> 中定义:

void∗ operator new (siz e_t sz, void∗ p) noexcept; // 将大小为sz的对像置于p

void∗ operator new[](siz e_t sz, void∗ p) noexcept; //将大小为sz的对像置于p

void operator delete (void∗ p, void∗) noexcept; // if (p) 则使 *p 无效

void operator delete[](void∗ p, void∗) noexcept; // if (p) 则使用*p 无效

“置放删除”运算符不执行任何操作(除了可能通知垃圾收集器已删除的指针不再是安全派生的(§34.5))。

    置放 new 构造也可用于从特定区域分配内存:

class Arena {

public:

virtual void∗ alloc(size_t) =0;

virtual void free(void∗) =0;

// ...

};

void∗ operator new(siz e_t sz, Arena∗ a)

{

return a−>alloc(sz);

}

现在,可以根据需要从不同的 Arena分配任意类型的对象。例如:

extern Arena∗ Persistent;

extern Arena∗ Shared;

void g(int i)

{

X∗ p = new(Persistent) X(i); // X in persistent storage

X∗ q = new(Shared) X(i); // X in shared memory

// ...

}

将对象置于不受标准自由存储管理器(直接)控制的区域意味着销毁对象时需要小心谨慎。基本机制是显式调用析构函数:

void destroy(X∗ p, Arena∗ a)

{

p−>˜X(); // call destructor

a−>free(p); // free memory

}

    请注意,除了资源管理类的实现之外,应避免显式调用析构函数。甚至大多数资源句柄都可以使用 new 和 delete 编写。但是,如果不使用显式的析构函数调用,就很难实现一个类似于标准库向量(§4.4.1,§31.3.3)的高效通用容器。新手在显式调用析构函数之前应该三思,也应该在这样做之前咨询更有经验的同事。

    有关置放new 如何与异常处理交互的示例,请参阅 §13.6.1。

    对于数组的放置,没有特殊的语法。也不需要,因为可以通过置放 new 来分配任意类型。但是,可以为数组定义一个运算符 delete()(§11.2.3)。

11.2.4.1  nothrow new

在必须避免异常的程序中(§13.1.5),我们可以使用 new 和 delete 的无抛出版本。例如:

void f(int n)

{

int∗ p = new(nothrow) int[n]; // allocate n ints on the free store

if (p==nullptr) {// 无可用内存

// ...处理分配内存错误 ...

}

// ...

operator delete(nothrow,p); // deallocate *p

}

nothrow 是标准库类型 nothrow_t 的对象的名称,用于消除歧义;nothrow 和 nothrow_t 在 <new> 中声明。

实现此功能的函数位于 <new> 中:

void∗ operator new(siz e_t sz, const nothrow_t&) noexcept; // allocate sz bytes;

// return nullptr if allocation failed

void operator delete(void∗ p, const nothrow_t&) noexcept; // deallocate space allocated by new

void∗ operator new[](siz e_t sz, const nothrow_t&) noexcept; // allocate sz bytes;

// return nullptr if allocation failed

void operator delete[](void∗ p, const nothrow_t&) noexcept; // deallocate space allocated by new

如果没有足够的内存可供分配,这些 operator new 函数将返回 nullptr,而不是抛出 bad_alloc。

11.3  花括号({})列表

    除了用于初始化命名变量(§6.3.5.2)之外,{} 列表还可以在许多(但不是所有)地方用作表达式。它们可以以两种形式出现:

[1] 限定类型花括号 T{...},意思是“创建一个由 T{...} 初始化的类型为 T 的对象”;§11.3.2

[2] 非限类型花括号 {...},其类型必须根据使用上下文确定(译注:而没有明确的类型限定);§11.3.3

例如:

struct S { int a, b; };

struct SS { double a, b; };

void f(S); // f() takes an S

void g(S);

void g(SS); // g() is overloaded

void h()

{

f({1,2}); // OK: call f(S{1,2})

g({1,2}); // 错: 歧义

g(S{1,2}); // OK: call g(S)

g(SS{1,2}); // OK: call g(SS)

}

就像在初始化命名变量时使用列表一样(§6.3.5),列表可以有零个、一个或多个元素。{} 列表用于构造某种类型的对象,因此元素的数量及其类型必须是构造该类型对象所需的数量。

11.3.1  实现模式

    {}列表的实现模式分为三部分:

• 如果将 {} 用作构造函数参数,则实现方式与使用() 时一样。列表元素不会被复制,除非作为按值构​​造函数参数。

• 如果使用 {} 初始化聚合(aggregate)元素(数组或没有构造函数的类),则每个列表元素都会初始化聚合元素。列表元素不会被复制,除非作为聚合元素构造函数的按值参数。

• 如果使用{}构造一个初始化器对象,则每个列表元素都会用于初始化initializer_list底层数组的一个元素。元素通常会从始化器列表复制到我们使用它们的任何地方。

    请注意,这是我们可以用来理解 {} 的语义的通用模式;只要保留含义,编译器就可以应用巧妙的优化。

    考虑:

vector<double> v = {1, 2, 3.14};

标准库向量具有初始化列表构造函数(§17.3.4),因此初始化列表 {1,2,3.14} 被解释为临时构造和使用,如下所示:

const double temp[] = {double{1}, double{2}, 3.14 } ;

const initializer_list<double> tmp(temp,sizeof(temp)/sizeof(double));

vector<double> v(tmp);

也就是说,编译器会构造一个数组,其中包含转换为所需类型(此处为double)的初始化器。此数组作为initializer_list传递给vector initializer_list构造函数。然后,initializer_list构造函数将数组中的值复制到其自己的元素数据结构中。请注意,initializer_list是一个小对象(可能只有两个字),因此按值传递它是有意义的。

    底层数组是不可变的,因此(在标准规则内) {} 列表的含义不可能在两次使用之间发生变化。考虑:

void f()

{

initializer_list<int> lst {1,2,3};

cout << ∗lst.begin() << '\n';

∗lst.begin() = 2; // 错 : lst 是不可变的

cout << ∗lst.begin() << '\n';

}

具体而言,如果 {} 不可变,则意味着从中获取元素的容器必须使用复制操作,而不是移动操作。

    {}(及其底层数组)的生命周期由其使用作用域决定(§6.4.2)。当用于初始化类型为 initializer_list<T> 的变量时,列表的生命周期与变量的生命周期相同。当在表达式中使用时(包括作为其他类型变量的初始化器,例如 vector<T>),列表在其完整表达式的末尾被销毁。

11.3.2  限定列表(Qualified Lists)(译注:有类型限定)

    初始化列表作为表达式的基本思想是,如果你可以使用

               T x {v};

初始化变量 x,那么你就可以使用 T{v} 或 new T{v} 创建与表达式具有相同值的对象。使用 new 会将对象放置在自由存储中并返回指向它的指针,而“普通T{v}”会在局部作用域内创建一个临时对象(§6.4.2)。例如:

struct S { int a, b; };

void f()

{

S v {7,8}; //直接初始化变量,无类型限定

v = S{7,8}; // 用限定列表赋值 (译注:有明确类型限定,但实现上和上一句一样)

S∗ p = new S{7,8}; //使用限定列表在自由存储区构造

}

使用限定列表构造对象的规则是直接初始化的规则(§16.2.6)(译注:也就是说上例中的两种初始化本质一样)。

    查看具有一个元素的限定列表初始化程序列表的一种方法是将其视为从一种类型到另一种类型的转换。例如:

template<class T>

T square(T x)

{

return x∗x;

}

void f(int i)

{

double d = square(double{i});

complex<double> z = square(complex<double>{i});

}

§11.5.1 进一步探讨了这个思想。

11.3.3 非限定初始化列表(Unqualified Lists)

    当预期类型明确已知时,使用非限定初始化列表。它只能用作表达式:

• 函数参数

• 返回值

• 赋值运算符的右侧操作数(=、+=、∗= 等)(译注:非声明时赋值认为是赋值,事实无本质区。)

• 下标

例如:

int f(double d, Matrix& m)

{

int v {7}; // 初始化器 (直接初始化) (译注:非限定,没有类型限定)

//译注:实现方式为(分配栈并移入7):00007FF6A44C288D  mov  dword ptr [v],7

int v2 = {7}; //初始化器(复制初始化),非限定列表

//译注:实现方式为(分配栈并移入7):00007FF6A44C2895  mov  dword ptr [v2],7

//译注:可以看出,上述两种方式初始化没有区别

int v3 = m[{2,3}]; //假设 m 以成对数值作为下标

v = {8}; //右赋值操作数(译注:赋值当然是右侧的)

v += {88}; //右赋值操作数(译注:这一句也是错的,事实这是运算,不是赋值)

{v} = 9; // 错: 不存在左赋值操作数

v = 7+{10}; //错:不是非赋值运算符的操作数(译注:应该用表达式而非赋值)

f({10.0}); // 函数参数

return {11}; // 返回值,非限定

}

赋值语句左侧不允许使用非受限列表的原因主要是 C++ 语法允许在复合语句(块)的该位置使用 { ,因此可读性对人类来说是一个问题,而歧义解决对编译器来说也很棘手。这不是一个无法克服的问题,但决定不朝这个方向扩展 C++。

   当用作命名对象的初始化器而不使用 = (如上文中的 v)时,非限定的{}列表执行直接初始化(§16.2.6)。在所有其他情况下,它执行复制初始化(§16.2.6)。特别是,初始化器中多余的 = 限制了可以使用给定的 {}列执行的初始化集。

    标准库类型 initializer_list<T> 用于处理可变长度的 {} 列表 (§12.2.3)。其最明显的用途是允许用户定义容器的初始化列表 (§3.2.1.3),但它也可以直接使用;例如:

int high_value(initializ er_list<int> val)

{

int high = numeric_traits<int>lowest();

if (val.siz e()==0) return high;

for (auto x : val)

if (x>high) high = x;

return high;

}

int v1 = high_value({1,2,3,4,5,6,7});

int v2 = high_value({−1,2,v1,4,−9,20,v1});

{} 列表是处理不同长度的同类列表的最简单方法。但是,请注意零元素可能是一种特殊情况。如果是这样,这种情况应该由默认构造函数处理(§17.3.3)。

仅当所有元素都属于同一类型时,才可以推断出{}列表的类型。例如:

auto x0 = {}; // 错(无元素类型)

auto x1 = {1}; // initializer_list<int>

auto x2 = {1,2}; // initializer_list<int>

auto x3 = {1,2,3}; // initializer_list<int>

auto x4 = {1,2.0}; // 错: 非齐次列表

不幸的是,我们无法推断普通模板参数的非限定列表的类型。例如:

template<typename T>

void f(T);

f({}); //错: 初始化类型未知

f({1}); //错: 未限定列表与 ‘‘普通过T’’不匹配

f({1,2}); //错: 未限定列表与 ‘‘普通过T’’不匹配

f({1,2,3}); //错: 未限定列表与 ‘‘普通过T’’不匹配

我说“不幸的是”是因为这是语言限制,而不是基本规则。从技术上讲,可以推断出这些 {}列表的类型为initializer_list<int>,就像我们对自动初始化器所做的那样。

    类似地,我们不会推断以模板表示的容器的元素类型。例如:

template<class T>

void f2(const vector<T>&);

f2({1,2,3}); //错:不能推断T

f2({"Kona","Sidney"}); //错:不能推断T

这也是不幸的,但从语言技术的角度来看,它更容易理解:在这些调用中没有任何地方提到vector。要推断 T,编译器首先必须决定用户是否真的想要一个vector,然后查看vector的定义以查看它是否有一个接受 {1,2,3} 的构造函数。一般来说,这需要实例化vector(§26.2)。可以处理这个问题,但编译时成本可能很高,而且如果有许多重载版本的 f2(),可能会出现歧义和混淆,因此需要谨慎处理。要调用 f2(),请更具体:

f2(vector<int>{1,2,3}); // OK

f2(vector<string>{"Kona","Sidney"}); // OK

11.4  Lambda表达式

       lambda 表达式,有时也称为 lambda 函数或(严格地说是错误的,但通俗地说)lambda,是定义和使用匿名函数对象的简化符号。我们可以使用简写,而不是使用operator() 定义命名类,稍后创建该类的对象,最后调用它。当我们想要将操作作为参数传递给算法时,这特别有用。在图形用户界面(和其他地方)的上下文中,此类操作通常称为回调(callbacks)。本节重点介绍 lambda 的技术方面;可以在其他地方求得使用 lambda 的示例和技术(§3.4.3,§32.4,§33.5.2)。

    lambda 表达式由一系列部件组成:

• 可能为空的捕获列表,指定定义环境中的哪些名称可用于 lambda 表达式的主体,以及这些名称是复制的还是通过引用访问的。捕获列表由 [] 分隔(§11.4.3)。

• 可选参数列表,指定 lambda 表达式需要哪些参数。参数列表由 () 分隔(§11.4.4)。

• 可选可变说明符,表示 lambda 表达式的主体可以修改 lambda 的状态(即更改 lambda 的按值捕获的变量副本)(§11.4.3.4)。

• 可选 noexcept 说明符。

• 形式为 −> type 的可选返回类型声明(§11.4.4)。

• 主体,指定要执行的代码。主体由 {} 分隔(§11.4.3)。

    传递参数、返回结果和指定主体的细节属于函数的细节,并将在第 12 章中介绍。函数不提供局部变量的“捕获”概念。这意味着 lambda 可以充当局部函数,即使函数不能。

11.4.1  实现模式

    Lambda 表达式可以以多种方式实现,并且有一些相当有效的优化方法。但是,我发现通过将其视为定义和使用函数对象的简写来理解 lambda 的语义很有用。考虑一个相对简单的例子:

void print_modulo(const vector<int>& v, ostream& os, int m)

// output v[i] to os if v[i]%m==0

{

for_each(begin(v),end(v),

[&os,m](int x) { if (x%m==0) os << x << '\n'; });

}

为了理解这个含义,我们可以定义等价的函数对象:

class Modulo_print {

ostream& os; //存储捕获列表的成员

int m;

public:

Modulo_print(ostream& s, int mm) :os(s), m(mm) {} // 捕获

void operator()(int x) const

{ if (x%m==0) os << x << '\n'; }

};

    捕获列表 [&os,m] 变成两个成员变量和一个用于初始化它们的构造函数。os 之前的 & 表示我们应该存储一个引用,而 m 中没有 & 表示我们应该存储一个副本。这种 & 的使用反映了它在函数参数声明中的使用。

    lambda 的主体只是变成了 operator()() 的主体。由于 lambda 不返回值,因此 operator()() 为 void。默认情况下,operator()() 为 const,因此 lambda 主体不会修改捕获的变量。这是迄今为止最常见的情况。如果您想从其主体修改 lambda 的状态,可以将 lambda 声明为可变的(§11.4.3.4)。这对应于未将 operator()() 声明为 const。

   从 lambda 生成的类的对象称为闭包对象(closure object)(或简称为闭包)。我们现在可以像这样编写原始函数:

void print_modulo(const vector<int>& v, ostream& os, int m)

// output v[i] to os if v[i]%m==0

{

for_each(begin(v),end(v),Modulo_print{os,m});

}

如果 lambda 可能通过引用捕获每个局部变量(使用捕获列表 [&]),则闭包可能会被优化为仅包含指向封闭堆栈框架的指针。

11.4.2  Lambda 的替代方案(Alternatives to Lambdas)

    print_modulo() 的最终版本实际上非常有吸引力,命名非平凡操作通常是一个好主意。单独定义的类也比嵌入在某些参数列表中的 lambda 留下了更多的注释空间。

    但是,许多 lambda 都很小,并且只使用一次。对于此类用途,实际等效方法涉及在其(唯一)使用之前立即定义的本地类。例如:

void print_modulo(const vector<int>& v, ostream& os, int m)

// output v[i] to os if v[i]%m==0

{

class Modulo_print {

ostream& os; // members to hold the capture list

int m;

public:

Modulo_print (ostream& s, int mm) :os(s), m(mm) {} // capture

void operator()(int x) const

{ if (x%m==0) os << x << '\n'; }

};

for_each(begin(v),end(v),Modulo_print{os,m});

}

相比之下,使用 lambda 的版本显然更胜一筹。如果我们真的想要一个名字,我们可以直接给 lambda 命名:

void print_modulo(const vector<int>& v, ostream& os, int m)

// output v[i] to os if v[i]%m==0

{

auto Modulo_print = [&os,m] (int x) { if (x%m==0) os << x << '\n'; };

for_each(begin(v),end(v),Modulo_print);

}

命名 lambda 通常是一个好主意。这样做会迫使我们更仔细地考虑操作的设计。它还简化了代码布局并允许递归(§11.4.5)。

    编写 for 循环是使用带有 for_each() 的 lambda 的替代方法。考虑:

void print_modulo(const vector<int>& v, ostream& os, int m)

// output v[i] to os if v[i]%m==0

{

for (auto x : v)

if (x%m==0) os << x << '\n';

}

    许多人会发现这个版本比任何 lambda 版本都清晰得多。但是,for_each 是一种相当特殊的算法,而 vector<int> 是一种非常具体的容器。考虑将 print_modulo() 泛化以处理任意容器:

template<class C>

void print_modulo(const C& v, ostream& os, int m)

// output v[i] to os if v[i]%m==0

{

for (auto x : v)

if (x%m==0) os << x << '\n';

}

此版本非常适合用于映射。C++ 范围for 语句专门用于从头到尾遍历序列的特殊情况。STL 容器使这种遍历变得简单而通用。例如,使用 for 语句遍历映射可实现深度优先遍历。我们如何进行广度优先遍历?print_modulo() 的 for 循环版本无法更改,因此我们必须将其重写为算法。例如:

template<class C>

void print_modulo(const C& v, ostream& os, int m)

// output v[i] to os if v[i]%m==0

{

breadth_first(begin(v),end(v),

[&os,m](int x) { if (x%m==0) os << x << '\n'; });

}

因此,lambda 可以用作表示为算法的广义循环/遍历构造的“主体”。使用 for_each 而不是 breadth_first 可以实现深度优先遍历。

lambda 作为遍历算法的参数的性能与等效循环的性能相同(通常相同)。我发现这在不同的实现和平台上非常一致。这意味着我们必须根据风格以及对可扩展性和可维护性的评估,在“算法加 lambda”和“带主体的 for 语句”之间做出选择。

11.4.3  捕捉(Caputure)

lambda 的主要用途是指定要作为参数传递的代码。lambda 允许以“内联”方式完成此操作,而无需命名函数(或函数对象)并在其他地方使用它。某些 lambda 不需要访问其局部环境。此类 lambda 使用空 lambda 引入器 [] 定义。例如:

void algo(vector<int>& v)

{

sort(v.begin(),v.end()); // sor t values

// ...

sort(v.begin(),v.end(),[](int x, int y) { return abs(x)<abs(y); }); //排序绝对值

// ...

}

如果我们想要访问局部名称,我们必须这样说,否则会出现错误:

void f(vector<int>& v)

{

bool sensitive = true;

// ...

sort(v.begin(),v.end(),

[](int x, int y) { return sensitive ? x<y : abs(x)<abs(y); } // 错: 不能访问 sensitive);

}

我使用了 lambda 引入符 [。这是最简单的 lambda 引入符,不允许lambda 引用调用环境中的名称。lambda 表达式的第一个字符始终是[。lambda 引入符可以采用多种形式:

• []:空捕获列表。这意味着在 lambda 主体中不能使用周围上下文中的任何本地名称。对于此类 lambda 表达式,数据是从参数或非局部变量中获取的。

• [&]:通过引用隐式捕获。可以使用所有本地名称。所有局部变量都通过引用访问。

• [=]:通过值隐式捕获。可以使用所有本地名称。所有名称都引用在 lambda 表达式调用点获取的局部变量的副本。

• [捕获列表]:显式捕获;捕获列表是要通过引用或值捕获(即存储在对象中)的局部变量名称列表。名称前面带有 & 的变量通过引用捕获。其他变量通过值捕获。捕获列表还可以包含此列表和名称后跟 ... 作为元素。

• [&,捕获列表]:通过引用隐式捕获列表中未提及名称的所有局部变量。捕获列表可以包含此列表。列出的名称前面不能加 &。捕获列表中命名的变量按值捕获。

• [=, 捕获列表]:隐式按值捕获列表中未提及名称的所有局部变量。捕获列表不能包含此内容。列出的名称前面必须加 &。捕获列表中命名的变量按引用捕获。

         请注意,以 & 开头的本地名称始终通过引用捕获,而以 & 开头的局部名称始终通过值捕获。只有通过引用捕获才允许修改调用环境中的变量。

         捕获列表样例(cases)用于对调用环境中的名称的使用方式进行细粒度的控制。例如:

void f(vector<int>& v)

{

bool sensitive = true;

// ...

sort(v.begin(),v.end()

[sensitive](int x, int y) { return sensitive ? x<y : abs(x)<abs(y); });

}

通过在捕获列表中提及sensitive,我们可以从 lambda 内部访问它。通过不另行指定,我们确保sensitive 的捕获是“按值”完成的;就像参数传递一样,传递副本是默认的。如果我们想“按引用”捕获sensitive,我们可以通过在捕获列表中的sensitive 之前添加一个 & 来表示:[&sensitive]。

         按值捕获还是按引用捕获的选择与函数参数的选择基本相同(§12.2)。如果需要写入捕获的对象或对象很大,我们会使用引用。但是,对于 lambda,还有一个额外的担忧,即 lambda 可能会比其调用者存活得更久(§11.4.3.1)。将 lambda 传递给另一个线程时,按值捕获([=])通常是最好的:通过引用或指针访问另一个线程的栈可能最具破坏性(对性能或正确性而言),而尝试访问已终止线程的栈可能会导致极难发现的错误。

    如果需要捕获可变模板(§28.6)参数,请使用...例如:

template<typename... Var>

void algo(int s, Var... v)

{

auto helper = [&s,&v...] { return s∗(h1(v...)+h2(v...)); }

// ...

}

请注意,在捕获方面很容易耍小聪明。通常,可以在捕获和参数传递之间做出选择。在这种情况下,捕获通常是输入最少的,但最容易引起混淆。

11.4.3.1  Lambda和生命周期

    lambda 的寿命可能比其调用者长。如果我们将 lambda 传递给其他线程,或者调用者存储 lambda 以供以后使用,则会发生这种情况。例如:

void setup(Menu& m)

{

// ...

Point p1, p2, p3;

// compute positions of p1, p2, and p3

m.add("draw triangle",[&]{ m.draw(p1,p2,p3); }); // 可能发生灾难

// ...

}

       假设 add() 操作是将 (name,action) 对添加到菜单的操作,并且 draw() 操作有意义,那么我们就剩下一个定时炸弹:setup() 完成,然后——也许几分钟后——用户按下绘制三角形按钮,lambda 尝试访问早已消失的局部变量。在这种情况下,写入通过引用捕获的变量的 lambda 会更糟糕。

    如果 lambda 可能比其调用者存活更久,我们必须确保所有局部信息(如果有)都已复制到闭包对象中,并且通过返回机制(§12.1.4)或通过合适的参数返回值。对于setup() 示例,这很容易做到:

       m.add("draw triangle",[=]{ m.draw(p1,p2,p3); });

将捕获列表视为闭包对象的初始化列表,将 [=] 和 [&] 视为简写符号(§11.4.1)。

11.4.3.2  命名空间名称

    我们不需要“捕获”命名空间变量(包括全局变量),因为它们始终是可访问的(只要它们在作用域内)。例如:

template<typename U, typename V>

ostream& operator<<(ostream& os, const pair<U,V>& p)

{

return os << '{' << p.first << ',' << p.second << '}';

}

void print_all(const map<string,int>& m, const string& label)

{

cout << label << ":\n{\n";

for_each(m.begin(),m.end(),

[](const pair<string,int>& p) { cout << p << '\n'; }

);

cout << "}\n";

}

这里,我们不需要捕获 cout 或 pair 的输出运算符。

11.4.3.3  Lambda 和 this指针

    我们如何从成员函数中使用的 lambda 访问类对象的成员?我们可以通过将其添加到捕获列表中,将类成员包含在可能捕获的名称集合中。当我们想在成员函数的实现中使用 lambda 时,就会使用这种方法。例如,我们可能有一个用于构建请求和检索结果的类:

class Request {

function<map<string,string>(const map<string,string>&)> oper; // operation

map<string,string> values; // arguments

map<string,string> results; // targets

public:

Request(const string& s); // parse and store request

void execute()

{

[this]() { results=oper(values); } // do oper to values yielding results

}

};

成员始终通过引用捕获。也就是说,[this] 意味着通过 this 访问成员,而不是复制到 lambda 中。不幸的是,[this] 和 [=] 不兼容。这意味着不谨慎使用可能会导致多线程程序中的竞争条件(§42.4.6)。

11.4.3.4  mutable Lambda

    通常,我们不想修改函数对象(闭包)的状态,因此默认情况下我们不能这样做。也就是说,生成的函数对象(§11.4.1)的 operator()() 是一个 const 成员函数。如果我们想修改状态(而不是修改通过引用捕获的某些变量的状态;§11.4.3),我们可以将 lambda 声明为可变的。例如:

void algo(vector<int>& v)

{

int count = v.siz e();

std::generate(v.begin(),v.end(),

[count]()mutable{ return −−count; });

}

−−count 减少了闭包中存储的 v 的大小的副本。

11.4.4  调用和返回(Call and Return)

    向 lambda 传递参数的规则与函数的规则相同(§12.2),返回结果的规则也相同(§12.1.4)。事实上,除了捕获规则(§11.4.3)之外,lambda 的大多数规则都借鉴了函数和类的规则。但是,应该注意两个不规则之处:

[1] 如果 lambda 表达式不接受任何参数,则可以省略参数列表。因此,最小的 lambda 表达式是 []{}。

[2] lambda 表达式的返回类型可以从其主体中推导出来。不幸的是,函数也无法做到这一点。

如果 lambda 主体没有返回语句,则 lambda 的返回类型为 void。如果 lambda 主体仅包含一个返回语句,则 lambda 的返回类型为返回表达式的类型。如果两者都不是,我们必须明确提供返回类型。例如:

void g(double y)

{

[&]{ f(y); } // 返回类型是void

auto z1 = [=](int x){ return x+y; } // 返回类型是double

auto z2 = [=,y]{ if (y) return 1; else return 2; } // error : body too complicated

// for retur n type deduction

auto z3 =[y]() { return 1 : 2; } // return type is int

auto z4 = [=,y]()−>int { if (y) return 1; else return 2; } // OK: explicit return type

}

当使用后缀返回类型表示法时,我们不能省略参数列表。

11.4.5  Lambda 的类型(The Type of a Lambda)

为了实现 lambda 表达式的优化版本,lambda 表达式的类型未定义。但是,它被定义为 §11.4.1 中所示的样式中的函数对象类型。此类型称为闭包类型,是 lambda 独有的,因此没有两个 lambda 具有相同的类型。如果两个 lambda 具有相同的类型,模板实例化机制可能会混淆。lambda 是一种局部类类型,具有构造函数和 const 成员函数 operator()()。除了使用 lambda 作为参数之外,我们还可以使用它来初始化声明为 auto 或 std::function<R(AL)> 的变量,其中 R 是 lambda 的返回类型,AL 是其参数类型列表(§33.5.3)。

例如,我可能会尝试编写一个 lambda 来转换 C 样式字符串中的字符:

auto rev = [&rev](char∗ b, char∗ e)

{ if (1<e−b) { swap(∗b,∗−−e); rev(++b,e); } }; // error

但是,这是不可能的,因为在推断出自动变量的类型之前,我无法使用它。相反,我可以引入一个名称,然后使用它:

void f(string& s1, string& s2)

{

function<void(char∗ b, char∗ e)> rev =

[&](char∗ b, char∗ e) { if (1<e−b) { swap(∗b,∗−−e); rev(++b,e); } };

rev(&s1[0],&s1[0]+s1.siz e());

rev(&s2[0],&s2[0]+s2.siz e());

}

现在,在使用之前已经指定了 rev 的类型。

如果我们只想命名一个 lambda,而不是递归地使用它,auto 可以简化事情:

void g(vector<string>& vs1, vector<string>& vs2)

{

auto rev = [&](char∗ b, char∗ e) { while (1<e−b) swap(∗b++,∗−−e); };

rev(&s1[0],&s1[0]+s1.siz e());

rev(&s2[0],&s2[0]+s2.siz e());

}

可以将未捕获任何内容的 lambda 分配给适当类型的函数指针。例如:

double (∗p1)(double) = [](double a) { return sqrt(a); };

double (∗p2)(double) = [&](double a) { return sqrt(a); }; // 错 : lambda captures

double (∗p3)(int) = [](int a) { return sqrt(a); }; // 错:参数类型不匹配

11.5  显式类型转换(Explicit Type Conversion)

       有时,我们必须将一种类型的值转换为另一种类型的值。许多(可能太多了)此类转换都是根据语言规则(§2.2.2,§10.5)隐式完成的。例如:

double d = 1234567890; // 整数转到浮点数

int i = d; //浮点转换到整数

在其他情况下,我们必须显式转换。

    由于逻辑和历史原因,C++ 提供了不同便利性和安全性的显式类型转换操作:

• 构造器,使用 {} 符号,提供类型安全的新值构造 (§11.5.1)

• 命名转换(named conversions),提供各种程度的“变态”转换:

(1) const_cast 用于获取对声明为 const 的内容的写访问权 (§7.5)

(2) static_cast 用于定义明确的隐式转换 (§11.5.2)

(3) reinterpret_cast 用于更改位模式的含义 (§11.5.2)

(4) dynamic_cast 用于动态地检查类层级的导向 (§22.2.1)

• C 风格强制转换,提供任何命名转换及其某些组合(§11.5.3)

• 函数转换法(functional notation),为 C 风格强制转换提供不同的转换函数 (§11.5.4)

    我已经按照我的喜好和使用安全性的顺序排列了这些转换。

    除了 {} 构造符号外,我不能说我喜欢其中任何一个,但至少 dynamic_cast 是运行时检查的。对于两个标量数值类型之间的转换,我倾向于使用自制的(homemade)显式转换函数 narrow_cast,其中被转换的值可能会窄化:

template<class Target, class Source>

Targ et narrow_cast(Source v)

{

auto r = static_cast<Target>(v); // 转换为目标类型

if (static_cast<Source>(r)!=v)

throw runtime_error("narrow_cast<>() failed");

return r;

}

也就是说,如果我可以将值转换为目标类型,将结果转换回源类型,并返回原始值,那么我对结果就很满意。这是语言应用于以 {} 初始化的值的规则的泛化(generalization)(§6.3.5.2)。例如:

void test(double d, int i, char∗ p)

{

auto c1 = narrow_cast<char>(64);

auto c2 = narrow_cast<char>(−64); // 若char是无符号则仍出异常

auto c3 = narrow_cast<char>(264); 若char是8位且有符号则仍出异常

auto d1 = narrow_cast<double>(1/3.0F); // OK

auto f1 = narrow_cast<float>(1/3.0); // 可能扔异常

auto c4 = narrow_cast<char>(i); //可能扔异常

auto f2 = narrow_cast<float>(d); //可能扔异常

auto p1 = narrow_cast<char∗>(i); // 编译时错误

auto i1 = narrow_cast<int>(p); // 编译时错误

auto d2 = narrow_cast<double>(i); //可能扔异常(但也可能不仍)

auto i2 = narrow_cast<int>(d); //可能扔异常

}

    根据您对浮点数的使用情况,使用范围测试进行浮点转换可能是值得的,而不是 !=。使用特化(§25.3.4.1)或类型特征(§35.4.1)可以轻松完成。

11.5.1  构造器类型转换(Construction)

    从一个值 e 构造类型 T 的值可以用符号 T{e} (§iso.8.5.4) 来表示。例如:

auto d1 = double{2}; // d1==2.0

double d2 {double{2}/4}; // d1==0.5

T{v} 符号的吸引力之一在于它只执行“表现良好”的转换。例如:

void f(int);

void f(double);

void g(int i, double d)

{

f(i); //call f(int)

f(double{i}); //错: {}不进行int 至浮点的转换

f(d); //call f(double)

f(int{d}); //error : {} doesn’t truncate

f(static_cast<int>(d)); // call f(int) 且截断值

f(round(d)); //call f(double) 且舍入

f(static_cast<int>(lround(d))); // call f(int) 且舍入

// 若 d 值越过int 范围 ,此调用会产生截断

}

我认为浮点数的截断(例如,将 7.9 截断为 7)“表现不佳”,因此在需要时必须明确说明是一件好事。如果需要舍入,我们可以使用标准库函数 round();它执行“传统的 4/5 舍入”,例如将 7.9 截断为 8 和将 7.4 截断为 7。

    有时,{} 构造不允许将 int 转换为 double,这令人感到惊讶,但如果(这种情况并不罕见)int 的大小与 double 的大小相同,则某些此类转换必定会丢失信息。考虑:

static_assert(sizeof(int)==sizeof(double),"unexpected sizes");

int x = numeric_limits<int>::max(); //最大可能的整数

double d = x;

int y = x;

我们不会得到 x==y。但是,我们仍然可以用可以精确表示的整数文字量初始化double 数(译注:用整数变量初始化double却不可)。例如:

double d { 1234 }; // fine

使用所需类型的显式限定不会引发行为不当的转换。例如:

void g2(char∗ p)

{

int x = int{p}; // error : no char* to int conversion

using Pint = int∗;

int∗ p2 = Pint{p}; // error : no char* to int* conversion

// ...

}

对于 T{v},“合理表现良好”的定义是具有从 v 到 T 的“非窄化”转换(§10.5)或具有适合 T 的构造函数(§17.3)。

     构造器符号 T{} 用于表达类型 T 的默认值。例如:

template<class T> void f(const T&);

void g3()

{

f(int{}); //默认int 值

f(complex<double>{}); // 默认complex 值

// ...

}

显式使用内置类型的构造函数的值是 0,转换为该类型(§6.3.5)。因此,int{} 是 0 的另一种写法。对于用户定义类型 T,T{} 由默认构造函数(§3.2.1.1,§17.6)(如果有)定义,否则由每个成员的默认构造 MT{} 定义。

    显式构造器的未命名对象是临时对象,并且(除非绑定到引用)它们的生命周期仅限于使用它们的完整表达式(§6.4.2)。在这方面,它们不同于使用 new 创建的未命名对象(§11.2)。

11.5.2  命名类型转换(Named Casts)

    有些类型转换表现不佳或不易进行类型检查;它们不是从一组定义明确的参数值中简单地构造值。例如:

IO_device∗ d1 = reinterpret_cast<IO_device∗>(0Xff00); // device at 0Xff00

编译器无法知道整数 0Xff00 是否是有效地址(I/O 设备寄存器的地址)。因此,转换的正确性完全掌握在程序员手中。显式类型转换(通常称为强制类型转换)有时是必不可少的。然而,传统上它被严重滥用,是错误的主要来源。

    需要显式类型转换的另一个典型示例是处理“原内存(raw memory)”,即保存或将保存编译器未知类型的对象的内存。例如,内存分配器(如operator new();§11.2.3)可能返回指向新分配内存的 void∗:

void∗ my_allocator(siz e_t);

void f()

{

int∗ p = static_cast<int∗>(my_allocator(100)); // 用于int 的新分配内存

// ...

}

编译器不知道 void∗ 指向的对象的类型(译注:所以需要程序员告诉编译器,即强制转换之目的)。

    命名强制类型转换背后的基本思想是使类型转换更加明显,并允许程序员表达强制类型转换的意图:

• static_cast 在相关类型之间进行转换,例如将一个指针类型转换为同一类层次结构中的另一个指针类型、将一个整型转换为枚举类型,或将一个浮点类型转换为一个整型类型。它还执行由构造函数(§16.2.6,§18.3.3,§iso.5.2.9)和转换运算符(§18.4)定义的转换。

• reinterpret_cast 处理不相关类型之间的转换,例如将整数转换为指针或将指针转换为不相关的指针类型(§iso.5.2.10)。

• const_cast 在仅在 const 和 volatile 限定符方面不同的类型之间进行转换(§iso.5.2.11)。

• dynamic_cast 对指针和引到类层次的转换做运行时检查(§22.2.1,§iso.5.2.7)。

    这些命名转换之间的区别允许编译器应用一些最小的类型检查,并使程序员更容易找到表示为 reinterpret_cast 的更危险的转换。一些 static_cast 是可移植的,但很少有 reinterpret_cast 是可移植的。reinterpret_cast 几乎没有任何保证,但通常它会生成一个新类型的值,该值具有与其参数相同的位模式。如果目标至少具有与原始值一样多的位数,我们可以将结果用 reinterpret_cast 转回其原始类型并使用它。只有将 reinterpret_cast 的结果转换回精确的原始类型,才能保证其结果可用。请注意,reinterpret_cast 是必须用于指向函数的指针的转换类型(§12.5)。考虑:

char x = 'a';

int∗ p1 = &x; // 错 : 不存在char* 到 int* 的隐式转换

int∗ p2 = static_cast<int∗>(&x); // 错: 不存在char* 到 int* 的隐式转换

int∗ p3 = reinterpret_cast<int∗>(&x); // OK: 但后果果自负

struct B { /* ... */ };

struct D : B { /* ... */ }; // 见 §3.2.2 and §20.5.2

B∗ pb = new D; // OK:从D* 到 B* 的隐式转换

D∗ pd = pb; // 错:不存在从 B* 到 D*的隐式转换

D∗ pd = static_cast<D∗>(pb); //OK

类指针之间的转换和类引用类型之间的转换在§22.2 中讨论。

    如果您想使用显式类型转换,请花点时间考虑一下它是否真的有必要。在 C++ 中,当 C 需要显式类型转换时,大多数情况下都不需要显式类型转换(§1.3.3),而且在早期版本的 C++ 中也有很多需要显式类型转换的情况(§1.3.2、§44.2.3)。在许多程序中,可以完全避免显式类型转换;在其他程序中,可以将其使用局限于少数例程。

11.5.3  C风格类型转换

    C++ 从 C 中继承了符号 (T)e,它执行任何可以表示为static_casts,reinterpret_casts,const_casts 组合的转换,以从表达式 e (§44.2.3) 生成类型 T 的值。不幸的是,C 风格转换还可以从指向类的指针转换为指向该类的私有基的指针。永远不要这样做,如果您不小心这样做了,希望编译器发出警告。这种 C 风格转换比命名转换运算符危险得多,因为在大型程序中这种符号更难发现,并且程序员想要的转换类型并不明确。也就是说,(T)e 可能在相关类型之间进行可移植转换,在无关类型之间进行不可移植转换,或者从指针类型中删除 const 修饰符。如果不知道 T 和 e 的确切类型,您就无法分辨。

11.5.4  函数风格类型转换

从值 e 构造类型 T 的值可以用函数符号 T(e) 来表示。例如:

void f(double d)

{

int i = int(d); // truncate d

complex z = complex(d); // 从d 构造一个 complex 对象

// ...

}

T(e)  构造有时被称为函数式强制类型转换。不幸的是,对于内置类型 T,T(e)  等同于 (T)e (§11.5.3)。这意味着对于许多内置类型来说,T(e) 并不安全。

void f(double d, char∗ p)

{

int a = int(d); // 截断

int b = int(p); // 不可移植

// ...

}

即使将较长的整数类型显式转换为较短的整数类型(例如将 long 转换为 char),也会导致不可移植的实现定义行为。

    对于行为良好的构造器,优先使用 T{v} 转换,对于其他转换,优先使用命名转换(例如,static_cast)。

11.6  建议

[1] 优先使用前缀 ++ 而不是后缀 ++;§11.1.4。

[2] 使用资源句柄来避免泄漏、误删和删两次;§11.2.1。

[3] 如无必要,请勿将对象放在自由存储空间中;优先使用作用域变量;§11.2.1。

[4] 避免使用“裸新建”和“裸删除”;§11.2.1。

[5] 使用 RAII;§11.2.1。

[6] 如果操作需要注释,则优先使用命名函数对象而不是 lambda;§11.4.2。

[7] 如果操作通常有用,则优先使用命名函数对象而不是 lambda;§11.4.2。

[8] 保持 lambda 简短;§11.4.2。

[9] 为了可维护性和正确性,请谨慎使用引用捕获; §11.4.3.1.

[10] 让编译器推断 lambda 的返回类型;§11.4.4.

[11] 使用 T{e} 符号进行构造;§11.5.1.

[12] 避免显式类型转换(强制类型转换);§11.5.

[13] 当需要显式类型转换时,最好使用命名强制类型转换;§11.5.

[14] 考虑使用运行时检查强制类型转换,例如 narrow_cast<>(),用于数值类型之间的转换;§11.5.

内容来源:

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

C++语言之父 Bjarne Stroustrup 简介 图BS先生在他的办公室,这是他的个人网站上的相片 许多重要人物之所以成名,或者是因为其改变了历史或者是因为其创造了历史,Bjarne Stroustup先生,C++之父,属于后者;归结个人成功的原因,理由可能有多种,但他只有浅显的两个一点点:他比多数人天真和理想主义那么一点点;比多数人花在解决问题上的时间多一点点。 BS先生,1950年生于丹麦港口城市奥尔胡斯市,1975年在奥尔胡斯大学毕业,1... 阅读详情

相关推荐

C++创始人Bjarne Stroustrup简介

他在20世纪80年代早期开发了C++,并在之后的几十年中对其进行了不断发展和推进。Bjarne Stroustrup对C++的设计和发展做出了巨大贡献,并通过不断改进语言的标准,使其成为一个广泛使用的编程语言。总结起来,Bjarne Stroustrup是C++编程语言的创始人,他的工作对于现代软件开发和计算机科学领域具有重要意义。C++编程语言最初是作为C语言的扩展而诞生的,旨在提供更多的抽象和更强大的编程工具。它结合了面向过程编程和面向对象编程的特性,并引入了许多新的概念,如类、继承、多态和模板。

HackQuestR的博客 986

C++之父Bjarne Stroustrup:程序员在数学上付出的努力,永远也不会白费

1979年诞生的C++已迈入“不惑之年”,如今却依旧在主流编程语言中占据重要一席。

《程序员》官方BLOG 2万+

探索C++之父Bjarne Stroustrup的编程理念与实践

C++是一种广泛使用的计算机编程语言,它是由贝尔实验室的Bjarne Stroustrup在1979年开发出来的,并在1985年正式发布。C++既保持了C语言的高效率和灵活性,又引入了面向对象编程(OOP)的特性,使得软件开发更加模块化,易于维护。泛型编程是一种编程范式,它侧重于创建可适用于多种数据类型的代码。与面向对象编程(OOP)关注于数据和行为的封装不同,泛型编程更注重在多种数据类型间共享算法和数据结构。

weixin_32999557的博客 1162

C++之父Bjarne Stroustrup的这本不可替代的经典

1982年,贝尔实验室(美国AT&T公司)的Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念,发明了新的程序语言C++。之所以被命名为C++,是为了表达该语言与C语言的渊源关系。Bjarne Stroustrup博士因此被尊称为“C++语言之父”。 20世纪90年代以后,Bjarne Stroustrup步入人生的最辉煌时期。1990年,Bjarne荣获《财富》杂志评选的“美国12位最年轻的科学家”称号。1993年,由于在C++领域的重大贡献,Bjarne.

人邮异步社区 4246

Python邮件自动化实战:基于imaplib和email库的高效邮件管理方案

本文详细介绍了如何使用Python的imaplib和email库实现高效邮件自动化管理。通过实战案例展示自动收取、解析邮件、下载附件等核心功能,帮助开发者快速构建企业级邮件处理系统,大幅提升工作效率。特别适合需要处理大量邮件的金融、数据分析等场景。

weixin_30500105的博客 621

AI驱动Spine骨骼动画生成:从图像拆分到动画自动化的全流程解析

计算机视觉与生成式AI技术正深度赋能传统数字内容生产流程。在2D动画制作领域,骨骼动画技术通过模拟真实生物关节运动,实现了角色动画的高效制作与灵活控制。其核心原理在于将角色拆分为独立部件,通过骨骼层级关系驱动部件变换,结合关键帧插值算法生成流畅动作。这项技术的工程价值在于大幅降低动画制作门槛,提升内容生产效率,尤其适用于游戏开发、影视预演、广告设计等需要快速原型迭代的场景。本文聚焦于如何利用SIFT特征匹配、RANSAC几何验证等CV算法实现部件自动对位,并结合动画12原则的程序化实现,构建从单张角色立绘到

weixin_28696185的博客 1541

Bjarne Stroustrup关于C++的讲座

 想知道细节的,可以直接到wg21的网站上看论文。这里是零散的笔记。今天Bjarne Stroustrup到公司来做关于C++ 0x泛型编程的讲座。秉着不吃鸡蛋也可以看看母鸡的原则,我还是提前20分钟去前排占了个位子 —— 虽 说我们实验室除了编译器部门和数据库部门狂用C++外,主要还是Java作坊,我还是不能低估了这群老大赏鸡的好奇心。虽说有了心理准备,大家热情之高还是吓了俺一跳:讲座开始前

负暄琐话 1万+

统信UOS1070批量整机备份安装标准化方案

Linux整机备份是政企级操作系统交付的核心能力,其本质是将系统状态、硬件适配、安全策略与部署流程在启动阶段原子化固化。基于内核overlayfs与initrd可编程机制,Ventoy实现了ISO镜像与定制配置的解耦部署,显著提升UOS专业版1070在多机型环境下的兼容性、可审计性与复现一致性。该方案规避传统克隆工具的镜像膨胀、硬件绑定和策略注入失效等缺陷,适用于无网、高合规、强管控场景,广泛支撑政务终端、教育机房及金融网点的规模化交付。

weixin_33892359的博客 407

Bjarne Stroustrup博士对C++的看法

Bjarne Stroustrup博士,1950年出生于丹麦,先后毕业于丹麦阿鲁斯大学和英国剑桥大学,AT&T大规模程序设计研究部门负责 人, AT&T、贝尔实验室和ACM成员。1979年,B. S开始开发一种语言,当时称为“C with Class”,后来演化为C++。 1998年,ANSI/ISO C++标准建立,同年,B. S推出了其经典著作The C++ Programming Langu

博客已转到w3er.com 1227

CVE-2025-25249漏洞深度解析:FortiOS认证绕过与实战缓解

远程代码执行(RCE)是网络安全中最危险的漏洞类型之一,其核心往往源于认证机制失效或内存安全缺陷。CVE-2025-25249正属于此类高危漏洞——它不依赖用户凭证,也不需要交互触发,而是通过超长HTTP头(如X-Forwarded-For)引发内存越界写入,直接绕过FortiOS和FortiSwitchManager的完整认证流程。该漏洞影响广泛、CVSS评分高达9.8,凸显了嵌入式设备在HTTP协议栈实现中的深层风险。在企业网络中,FortiGate等设备常作为边界守门人,一旦失陷将导致root级控制权

weixin_33694620的博客 526

图数据库Neo4j面试内容整理-Neo4j的性能

在执行复杂关系查询时,Neo4j 通过图结构的高效存储和查询机制,能够比传统的关系型数据库提供更快的性能,尤其是在涉及深层关系的查询时。通过合理的配置、优化查询和使用合适的硬件,Neo4j 可以处理大规模的数据集和高并发的查询请求,满足企业级应用的需求。Neo4j 在处理图数据时,通过优化图的存储、查询和遍历等方面,提供了高效的性能,特别适合用于需要处理复杂关系和多层次连接的应用场景,如社交网络、推荐系统、知识图谱等。:Neo4j 会根据查询的结构和数据的分布自动选择最优的查询计划。

不务正业的猿 587

C++的背影——C++之父Bjarne Stroustrup印象

C++的背影——C++之父Bjarne Stroustrup印象左轻侯2002.11.4  热爱C++的朋友请不要误会,我并不是在暗示“C++已经日薄西山”,或者任何类似的意思。从语义上来说,C++作为一门编程语言,当然不会有什么背影。事实上,我想说的是一个人的背影。因此这个题目显得有点突兀,甚至哗众取宠。但是我想,在C++社群中,每一个人都会同意,有一个名字就是C++的象征。这个名字当然

qinghou的专栏 5093

VR大空间开发前期,设备选项与流程

欢迎开发者加入 VR 大空间开发之旅!本系列教程将以 Pico 和 HTC 设备为核心,系统拆解从基础搭建到功能实现的全流程,助你快速掌握开发要点。本系列共 12 篇,专为有编程基础但缺乏大空间开发经验的开发者设计。前 7 篇针对 Pico 和 HTC 设备差异分别讲解,后续步骤通用。核心目录如下:​1. 空间环境要求 - 灯光设置 - 场地面积规划 - 识别图案设计2. 网络部署方案3. 客户端体验模式解析 - 一体机模式 - 云渲染模式 - 背包体验模式4. Pico空间录制方法

unitygroup的博客 1357

C++编程语言:基础设施:第10章——表达式(Bjarne Stroustrup)

C++ 表达式和类型转换

ComputerInBook的专栏 1783

[Research Tips] 我的zotero文献管理方案: 云端同步+iPad批注+overleaf笔记

文献管理一直是一个很头疼的事. 最初直接在paper上做笔记, 后来尝试各种各样的文献管理软件, 比如endnote, mendeley等, 再后来直接用excel. 每一种方案都不是很满意. 最近尝试了各种软件, 摸索出一个合适自己的文献管理方案, 分享给大家. 我的需求: 支持PDF内全文搜索. 支持笔记搜索. 支持同步 可以批注PDF. 支持word内引用 支持Tex笔记语法 支持标签化管理 目前的方案除了第二个需求, 其他的都支持. 就目前我的经验来说, 除了知网研学可以搜索笔记外, 其他软件都

落日之城 5318

PINNACLE:PINN自适应配点与实验点选择算法

PINNACLE算法通过引入动态权重机制,实现了PINN训练点选择的自适应优化。该算法基于对训练过程中不同区域学习需求变化的深入理解,设计了平滑过渡的权重函数,确保了模型在不同训练阶段能够优先学习最需要的区域。理论分析和实验结果均表明,PINNACLE不仅能够保证收敛性,而且能够显著提高PINN的性能。这一算法为物理信息神经网络的应用提供了重要支持,尤其适用于复杂PDE问题的求解。

VectorShift的博客 1138

C++编程语言——基础设施:第6章——类型和声明(Bjarne Stroustrup)

C++编程语言:基础设施:类型和声明

ComputerInBook的专栏 1570

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

向C++之父Bjarne Stroustrup致敬

2013-04-25 21:30 (分类:社会人生)     非常好的文章     C ++ 的 背 影                                     ——C++之父Bjarne Stroustrup印象 左轻侯 2002.11.4        热爱C++的朋友请不要误会,我并不是在暗示“C++已经日薄西山”,或者任何类似的意思。从语义上来说,C++作为一门编程语言,当

centos的博客 702

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

C++之父Bjarne Stroustrup亲临现场,2025全球C++及系统软件技术大会重磅官宣

在这个以算力与效率为信仰的时代,C++ 再次被推到聚光灯下——无论是 OpenAI 的推理引擎,还是 NVIDIA 的加速库、DeepSeek 的底层编译框架,C++ 依然是那根隐形的钢梁,支撑着智能世界的底座。他是 C++ Reflection TS 的项目编辑、Boost 基金会的执行董事,也是模式匹配和语言变体等多个 C++ 提案的作者。年,Bjarne 在全球 C++ 大会上的主题是 「原则、问题与解决方案」,他深入剖析了 C++ 社区所面临的核心挑战,同时为未来语言的发展制定了战略方向。

优快云资讯 7578

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

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

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

1204

从丹麦的旧GIER到C++之父Bjarne Stroustrup ,未来属于理想者

Bjarne创造C++的初衷是为了实现高效使用硬件与强大抽象机制的结合。当时,他想用通信系统构建一个多计算机系统,这个通信系统可以是共享内存,也可以是网络。他需要编写底层接近硬件的代码,如内存管理器、进程调度程序和设备驱动程序,同时也需要软件分离组件以便它们以良好方式进行通信。而在当时,没有一种语言能够胜任这样的多计算机系统开发需求,于是他在C语言的基础上引入并扩充了面向对象的概念,发明了C++,这个结果是他付出众多时间与打磨的甘甜果实。

敖行客 Allthinker的博客 1511

C++语言演进与Bjarne Stroustrup的跨世纪思考

从C++11的类型推导到C++20的Concepts,类型系统完成了从隐式规则到显式约束的转变。正如他常说的:"C++不是要变得简单,而是要变得更不容易出错"——这或许就是这门历经45年演进的语言给我们的终极启示。更令人兴奋的是C++20引入的协程,这让异步代码的编写变得像同步代码般直观。从早期的auto_ptr到现在的unique_ptr/shared_ptr,我们经历了所有权语义的不断完善。通过简单的网页操作就能对比C++11到C++20的编译差异,比本地配置开发环境方便太多。类型系统的革命性演进。

QuartzLynx65的博客 749

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

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

ComputerInBook的专栏 2092

C++ 的背影{C++之父Bjarne Stroustrup印象 左轻侯}

           C ++ 的 背 影                   ——C++之父Bjarne Stroustrup印象 左轻侯 2002.11.4  热爱C++的朋友请不要误会,我并不是在暗示“C++已经日薄西山”,或者任何类似的意思。从语义上来说,C++作为一门编程语言,当然不会有什么背影。事实上,我想说的是一个人的背影。因此这个题目显得有点突兀,甚至哗众取宠。但是我想,在

yisong_net的专栏 647

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

指针,数组和引用

ComputerInBook的专栏 2183

C++编程语言:标准库:第30章——标准库概观(Bjarne Stroustrup)

C++ 标准库概观

ComputerInBook的专栏 1133
上一篇: C++编程语言:基础设施:第10章——表达式(Bjarne Stroustrup)
下一篇: C++编程语言:基础设施:第12章——函数(Bjarne Stroustrup)
ComputerInBook
博客等级 码龄19年 1168粉丝 465原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值