<<C++ Primer>> 术语表 (总） (待补充)

术语表

目录

第 1 章 开始
第 I 部分 C++基础
第 2 章 变量和基本类型
第 3 章 字符串, 向量和数组
第 4 章 表达式
第 5 章 语句
第 6 章 函数
第 7 章 类
第 II 部分 C++标准库
第 8 章 IO库
第 9 章 顺序容器
第 10 章 泛型算法
第 11 章 关联容器
第 12 章 动态内存
第 III 部分 类设计者的工具
第 13 章 拷贝控制
第 14 章 重载运算与类型转换
第 15 章 面向对象程序设计
第 16 章 模板与泛型编程
第 IV 部分 高级主题
第 17 章 标准库特殊设施
第 18 章 用于大型程序的工具
第 19 章 特殊工具与技术

第 1 章 开始

参数（实参, argument）: 向函数传递值
  
赋值（assignment）: 抹去一个对象当前值一个新值取代之
  
缓冲区（buffer）： 一个存储区域， 用于保存数据。IO 设施通常将输入（或输出）数据保存在一个缓冲区中，读写缓冲区的动作与程序中的动作无关的。我们可以显式地刷新缓存，以便强制将缓冲区中的数据写入输出设备。默认情况下，读cin 会刷新cout ；程序非正常终止时也会刷新cout 。
  
内置类型（built-in type)：由语言定义的类型：如 int。
  
Cerr：一个ostream 对象，关联到标准错误，通常写入与标准输出相同的设备。默认情况下，写到cerr的数据是不缓冲的。cerr 通常用于输出错误信息或其他不属于程序正常逻辑的输出内容
  
类（class）：一种用于定义自己的数据结构及其相关操作的机制。类是C++中最基本的特性之一。标准库类型中，如 istream 和 ostream都是类。
  
类类型（class type)：类定义的类型。类名即为类型名。
  
clog：一个ostream对象，关联到标准错误。默认情况下，写到 clog 的数据是被缓冲的。clog 通常用于报告程序的执行信息， 存如一个日志文件中。
  
注释（comment）：被编译器忽略的程序文本。C++有两种类型的注释：单行注释和界定符对注释。单行注释以 // 开始，从 // 到行尾的所用内容都是注释。 界定符对注释以 /* 开始，其后的所有内容都是注释，直至遇到 */ 为止。
  
条件（condition）：求值结果为真或假的表达式。通常用值 0 表示假，用非零值表示真。
  
cout： 一个 ostream 对象，用于将数据写入标准输出。通常用于程序的正常输出内容。
  
花括号（curly brace）： 花括号用于划定程序块边界。左花括号（ { ）为程序块开始，右花括号（ } ）为结束。
  
数据结构（data structure）： 数据及其上所允许的操作的一种逻辑组合。
  
编辑-编译-调试（edit-compile-debug）：使程序能正确执行的开发过程。
  
文件结束符（end-of-file）：使程序能正确执行的开发过程。
  
表达式 （expression）： 最小的计算单元。一个表示式包含一个或多个运算对象，通常还包含一个或多个运算符。表达式求值会产生一个结果。例如，假设 i 和 j 是 int 对象，则 i + j 是一个表达式，它产生两个 int 值的和。
  
for 语句（for statement)： 迭代语句，提供重复执行能力。通常用来将一个计算反复执行指定次数。
  
函数（function)： 具名的计算单元。
  
函数体（function body)： 语句块，定义了函数所执行的动作。
  
函数名（function body)： 函数为人所知的名字，也用来进行函数调用
  
头文件（header)： 使类或其他名字的定义可被多个程序使用的一种机制。程序通过 #include 指令使用头文件。
  
if 语句（if statement）： 根据一个特定条件的值进行条件执行的语句。如果条件为真，执行 if 语句体。否则，执行 else 语句体（如果存在的话）。
  
初始化（initialize）： 在一个对象创建的时候赋予它一个值。
  
iostream 头文件： 提供了面向流的输入输出的标准库类型。
  
istream ： 提供了面向流的输入的库类型。
  
库类型（library type： 标准库定义的类型，如 istream。
  
main： 操作系统执行一个C++程序时所调用的函数。每个程序必须有且只有一个命名为 main 的函数。
  
操纵符（mainpulator）： 对象，如 std::endl，在读写流的时候用来“操纵”流本身。
  
成员函数（member function)： 类定义的操作。通常通过调用成员函数来操作特定对象。
  
方法（method）： 成员函数的同义术语。
  
命名空间（namespace）： 将库定义的名字放在一个单一位置的机制。命名空间可以帮助避免不经意的名字冲突。C++标准库定义的名字在命名空间 std 中。
  
ostream： 标准库类型，提供面向流的输出。
  
形参列表（parameter list）： 函数定义的一部分，指出调用函数时可以使用什么样的实参，可能为空列表。
  
返回类型（return type）： 函数返回值的类型。
  
源文件（source file）： 包含C++程序的文件。
  
标准错误（standard error）： 输出流，用于报告错误。标准输出和标准错误通常关联到程序执行所在的窗口。
  
标准输入（standard input）： 输入流，通常与程序执行所在窗口相关联。
  
标准库（standard library）： 一个类型和函数的集合，每个C++编译器都必须支持。标准库提供了支持 IO 操作的类型。C++程序员倾向于用“库”指代整个标准库，还倾向于用库类型表示标准库的特定部分，例如用“iostream 库”表示标准库中定义 IO 类的部分。
  
标准输出（standard output）： 输出流，通常与程序执行所在窗口相关联。
  
语句（statement）： 程序的一部分，指定了当程序执行时进行什么动作。一个表达式接一个分号就是一条语句；其他类型的语句包括语句块，if 语句，for 语句和 while 语句，所有这些语句内都包含其他语句。
  
std： 标准库所使用的命名空间。 std::cout 表示我们要使用定义在命名空间 std 中的名字 cout。
  
字符串常量（string literal）： 零或多个字符组成序列，用双引号包围（“a string literal")。
  
未初始化的变量（uninitalized variable）： 未赋于初值的变量。类类型的变量如果未指定初值，则按类定义指定的方式进行初始化。定义在函数内部的内置类型变量默认是不初始化的，除非有显式的初始化语句。试图使用一个未初始化变量的值是错误的。未初始化变量是bug的常见成因。
  
变量（variable）： 具名对象
  
while 语句（while statement）： 迭代语句，提供重复执行直至一个特定对象为假的机制。循环体会执行零次或多次，依赖于循环条件求值结果。
  
（）运算符（ （）operator）： 调用运算符。跟随在函数名之后的一对括号“（）”，起到调用函数的效果。传递给函数的实参放置在括号内。
  
++ 运算符（++ operator）： 递增运算符。将运算对象的值加1， ++i 等价于 i = i + 1.
  
+= 运算符： 复合赋值运算符，将右侧运算对象加到左侧运算对象上； a += b 等价于 a = a + b。
  
. 运算符（. operator）： 点运算符。左侧运算对象必须是一个类类型对象，右侧运算对象必须是此对象的一个成员的名字。运算结果即为该对象的这个成员。
  
:: 运算符（ :: operator）： 作用域运算符。其用处之一是访问命名空间中的名字。例如，std::cout 表示命名空间 std 中的名字 cout。
  
= 运算符（ = operator）： 将右侧运算对象的值赋于左侧运算对象所表示的对象。
  
-- 运算符（ -- operator）： 递减运算符。将运算对象的值减1，--i 等价于 i = i - 1。
  
<< 运算符（ >> operator）： 输出运算符。将右侧运算对象的值写道左侧运算对象表示的输出流：cout << "hi" 表示将 hi 写到标准输出。输出运算符可以连接：cout << "hi" << "bye" 表示将输出 hibye。
  
>> 运算符（ << operator）： 输入运算符。从左侧运算对象所指定的输入流读取数据，存入右侧运算对象中： cin >> i 表示从标准输入读取一个值，存入 i 中。输入运算符可以连接： cin >> i >> j 表示先读取一个值存入i，在读取一个值存入 j 。
  
#inlucde ： 头文件包含指令，使头文件中代码可被程序使用。
  
== 运算符（ == operator）： 相等运算符。检测左侧运算对象是否等于右侧运算对象。
  
!= 运算符（ != operator）： 不等运算符。检测左侧运算对象是否不等于右侧运算对象。
  
<= 运算符（ <= operator）： 小于等于运算符。检测左侧对象是否小于等于右侧运算对象
  
< 运算符 （ < operator）： 小于运算符。检测左侧运算对象是否小于右侧运算对象。
  
>= 运算符（ >= operator）： 大于小于运算符。检测左侧运算对象是否大于等于右侧运算对象
  
> 运算符 ( > operator）： 大于运算符。检测左侧运算对象是否大于右侧运算对象。
  

第 I 部分 C++基础

第 2 章 变量和基本类型

地址（address）： 是一个数字，根据它可以找到内存中的一个字节
  
别名生命（alias declaration）： 为另一种类型定义一个同义词：使用 ”名字 = 类型“ 的格式将名字作为该类型的同义词。
  
算术类型（arithmetic type）： 布尔值，字符，整数，浮点数等内置类型。
  
数组（array）： 是一种数据结果，存放着一组未命名的对象，可以通过索引来访问这些对象。
  
auto： 是一种类型说明符，通过变量的初始值来推断变量的类型。
  
基本类型（base type）： 是类型说明符，可以用 const 来修饰，在声明语句中位于声明符之前。基本类型提供了最常见的数据类型，以此为基础构建声明符。
  
绑定（bind）： 令某个名字与给定的实体关联在一起，使用该名字也就是使用该实体。例如，引用就是将某个名字与某个对象绑定在一起。
  
字节（byte）： 内存中可寻址的最小单位，大多数机器的字节占8位。
  
类成员（class member）： 类的组成部分。
  
复合类型（class member）： 是一种类型，它的定义以其他类型位基础。
  
const： 是一种类型修饰符，用于说明永不改变的对象。const对象一旦定义就无法再赋新值，所以必须初始化。
  
常量指针（const pointer）： 是一种指针，它的值永不改变。
  
常量引用（const reference）： 是一种习惯叫法，含义是指向常量的引用。
  
常量表达式（const expression）： 能在编译时计算并获取结果的表达式。
  
constexpr： 是一种函数，用于代表一条常量表达式。
  
转换（conversion）： 一种类型的值转变成另一种类型值的过程。C++语言支持内置类型之间的转换。
  
数据成员（data member）： 组成对象的数据元素，类的每一个对象都有类的数据成员的一份拷贝。数据成员可以在类内部声明的同时初始化。
  
声明（declaration）： 声称存在一个变量，函数或是别处定义的类型。名字必须在定义或声明之后才能使用。
  
声明符（declarator）： 是声明的一部分，包括被定义的名字和类型修饰符，其中类型修饰符可以有也可以没有。
  
decltype： 是一个类型说明符，从变量或表达式推断得到类型。
  
默认初始化（default initalization）： 当对象没被显式的赋予初始值时执行的初始化行为。由类本身负责执行的类对象的初始化行为。全局作用域的内置类型对象初始化为 0; 局部作用域的对象未被初始化即拥有未定义的值。
  
定义（definition）： 为某一种特定类型的变量申请存储空间，可以选择初始化该变量。名字必须在定义或声明之后才能使用。
  
转义字符（escape sequence）：字符特别时那些不可打印字符的替代形式。转义以反斜线开头，后面紧跟一个字符，或者不多于3个八进制数字，或者字母 x 加上 1 个十六进制数。
  
全局作用域（global scope）： 位于其他所有作用域之外的作用域。
  
头文件保护符（header guard）： 使用预处理变量防止头文件被某个文件重复包含。
  
标识符（identifier）： 组成名字的字符序列，标识符对大小写敏感。
  
类内初始值（in-class initializer）： 在声明类的数据成员时同时提供的初始值，必须置于等号右侧或花括号内。
  
在作用域内（in scope）： 名字在当前作用域内可见。
  
被初始化（initalized）： 变量在定义的同时被赋予初始值，变量一般都应该被初始化。
  
内层作用域（inner scope）： 嵌套在其他作用域之内的作用域。
  
整型（iniegral type）： 参见算术类型。
  
列表初始化（list initialization）： 利用花括号把一个或多个初始值放在一起的初始化形式。
  
字面值（literal）： 是一个不能改变的值，如数字，字符，字符串等。单引号内的是字符字面值，双引号内的是字符串字面值。
  
局部作用域（local scope）： 是块作用域的习惯叫法。
  
底层 const（low-level const）： 一个不属于顶层的const，类型如果由底层常量定义，则不能被忽略。
  
成员（member）： 类的组成部分
  
不可打印字符（nonprintable character）： 不具有可见形式的字符，如控制符，退格，换行符等。
  
空指针（null pointer）： 值为 0 的指针，空指针合法但是不指向任何对象。
  
nullptr： 是表示空指针的字面值常量。
  
对象（object)： 是内存的一块区域，具有某种类型，变量是命名了的对象。
  
外层作用域（outer scope）： 嵌套着倍的作用域的作用域。
  
指针（pointer）： 是一个对象，存放着某个对象的地址，或者某个对象存储区域之后的下一个地址。或者 0。
  
指向常量的指针（pointer to const）： 是一个指针，存放着某个常量对象的地址。指向常量的指针不能用来改变它所指对象的值。
  
预处理器（preprocessor）： 在C++编译过程中执行的一段程序。
  
预处理变量（preprocessor variable）： 由预处理器管理的变量。在程序编译之前，预处理器负责将程序中的预处理量替换成它的真实值。
  
引用（reference）： 某个对象的别名。
  
对常量的引用（reference to const）： 是一个引用，不能用来改变它所绑定对象的值。对常量的引用可以绑定常量对象，或者非常量对象，或者表达式的结果。
  
作用域（scope）： 是程序的一部分，在其中某些名字有意义。C++由几级作用域。
  
全局（global）： 名字定义在所有其他作用域之外。
  
类（class）： 名字定义在类内部。
  
命名空间（namespace)： 名字定义在命名空间内部。
  
块（block）： 名字定义在块内部。名字从声明位置开始直至声明语句所在的作用域末端为止都是可用的。
  
分离式编译（separate compilation）： 把程序分割为多个单独文件的能力。
  
带符号类型（signed）： 保存正数，负数或 0 的整型。
  
字符串（string）：是一种库类型，表示可变长字符序列。
  
struct ** 是一个关键字，用于定义类。
  
临时值（temporary）： 编译器在计算表达式结果时创建了一个临时值，则此临时值将一直存在直到包含该表达式的最大的表达式计算计算完成。
  
顶层 cosnt（top-level const）： 是一个 const，规定某对象的值不能改变。
  
类型别名（type alias)： 是一个名字，是另外一个类型的同义词，通过关键字 typedef 或别名声明语句来定义。
  
类型检查（type checking）： 是一个过程，编译器检查程序使用某给定类型对象的方式与该类型的定义是否一致。
  
类型说明符（type specifier）： 类型的名字。
  
typedef： 为某类型定义一个别名。当前关键字 typedef 作为声明的基本类型出现时，声明中定义的名字就是类型名。
  
未定义（undefined）： 即C++语言没有明确规定的情况。不论是否有意为之，未定义行为可能引发难以跟踪的运行时错误，安全问题和可移植性问题。
  
未初始化（uninitialized）： 变量已定义但未赋予初始值。一般来说，试图访问未初始化变量的值将引发未定义行为。
  
无符号类型（unsigned）： 保存大于等于 0 的整型。
  
变量（variable）： 命名的对象或引用。C++语言要求变量要先声明后使用。
  
void* ： 可以指向任意非常量的指针类型，不能指向解引用操作。
  
void 类型： 是一种有特殊用处的类型，既无操作也无值。不能定义一个 void 类型的变量。
  
字（word）： 在指定及其上进行整数运算的自然单位。一般来说，字的空间足够存放地址。32位机器上的字通常占据 4 个字节。
  
& 运算符（& operator）： 取地址运算符。
  
*** 运算符（* operator）：** 解引用运算符。解引用一个指针将返回该指针所指的对象，为解引用的结果赋值也就是为指针所指的对象赋值。
  
#define： 是一条预处理指令，用于定义一个预处理变量。
  
#endif： 是一条预处理指令，用于结束一个 #ifdef 或 #ifndef区域。
  
#ifdef： 是一台预处理指令，用于判断给定的变量是否已经定义。
  
#ifndef： 是一条预处理指令，用于判断给定的变量是否尚未定义。

第 3 章 字符串, 向量和数组

begin： 是 string 和 vector 的成员，返回指向第一个元素的迭代器。也是一个标准库函数，输入一个数字，返回指向该数字首元素的指针。
  
缓冲区溢出（buffer overflow）： 一种严重的程序故障，主要的原因是试图通过一个越界的索引访问容器内容，容器类型包括 string，vector 和 数组等。
  
C 风格字符串（C-style string）： 以空字符结束的字符数组。字符串字面值是 C 风格字符串，C风格字符串容易出错。
  
类模板（class template）： 用于创建具体类型的模板。要想使用类模板，必须提供关于类型的辅助信息。例如，要定义一个 vector 对象需要指定元素的类型：vector 包含 int 类型的元素。
  
编译器扩展（compiler extension）： 某个特定的编译器为 C++ 语言额外增加的特性。基于编译器扩展编写的程序不易移植到其他的编译器上。
  
容器（container）： 是一种类型，其对象容纳了一组给定类型的对象。 vector 是一种容器类型。
  
拷贝初始化（copy initialization）： 使用赋值号（ = ）的初始化形式。新创建的对象是初始值的一个副本。
  
difference_type： 由 stirng 和 vector 定义的一种带符号整数类型，表示两个迭代器值之间的距离。
  
直接初始化（direct initialization）： 不使用赋值号（ = ）的初始化形式。
  
empty： 是 string 和 vector 的成员，返回一个布尔值。当对象的大小为 0 时返回真，否则返回假。
  
end： 是 string 和 vector 的成员，返回一个尾后迭代器。也是一个标准库函数，输入一个数组，返回指向该数组尾元素的下一个位置的指针。
  
getline： 在 string 头文件中定义的一个函数，以一个 istream 对象和一个 stirng 对象为输入参数。割爱函数首先读取输入流的内容直到遇到换行符停止，然后将读入的数据存入 string 对象，最后返回 istream 对象。其中换行符读入但是不保留。
  
索引（index）： 是下标运算符使用的值。表示要在 string 对象，vector 对象或者数组中访问的一个位置。
  
实例化（instantiation）： 编译器生成一个指定的模板类或函数的过程。
  
迭代器（iterator）：是一种类型，用于访问容器中的元素或者在元素之间移动。
  
迭代器运算（ iterator arithmetic）： 是 string 或 vector 的迭代器的运算：迭代器与整数相加或相减得到一个新的迭代器，与原理的迭代器相比，新迭代器向前或向后移动了若干个位置。两个迭代器相减得到它们之间的距离，此时它们必须指向同一个容器的元素或该容器尾元素的下一位置。
  
以空字符结束的字符串（null-terminated string）： 是一个字符串，它的最后一个字符后面还跟着一个空字符（' \0 '）。
  
尾后迭代器（off-the-end iterator）： end函数返回的迭代器，指向一个并不存在的元素，该元素位于容器尾元素的下一个位置。
  
指针运算（pointer arithmetic）： 是指针类型支持的算术运算。指向数组的指针所支持的运算种类与迭代器运算一样。
  
prtdiff_t： 是cstddef头文件中定义的一种与机器实现有关的带符号整数类型，它的空间足够大，能够表示数组中任意两个指针之间的距离。
  
push_back： 是 vector 的成员，向 vector 对象的末尾添加元素。
  
范围 for 语句（range for）： 一种控制语句，可以在值的一个特定集合内迭代。
  
size ： 是 string 和 vector 的成员，分别返回字符的数量或元素的数量。返回值的类型是size_type。
  
size_t： 是cstddef 头文件中定义的一种与机器实现有关的无符号整数类型，它的空间足够大，能够表示任意数组的大小。
  
string ： 是一种标准库类型，表示字符的序列。
  
using 声明（using declaration）： 令命名空间中的某个名字可悲程序直接使用。
      using 命名空间 :: 名字
上述语句的作用是令程序可以直接使用 名字，而无须写它的前缀部分 命名空间::
  
值初始化（value initialization）： 是一种初始化过程。内置类型初始化为 0，类类型由类的默认构造函数初始化。只有当类包含默认构造函数时，该类的对象才会被值初始化。对于容器的初始化来说，如果只说明了容器的大小而没有指定初始值的话，就会执行值初始化。此时编译器会生成一个值，而容器的元素被初始化为该值。
  
vector： 是一种标准库类型，容纳某指定类型的一组元素。
  
++运算符（++ operator）： 是迭代器和指针定义的递增运算符。执行 ”加 1 “ 操作使得迭代器指向下一个元素。
  
[ ] 运算符（ [ ] operator）： 下标运算符。obj[j]得到容器对象 obj 中位置 j 的那个元素。索引从 0 开始， 第一个元素的索引是 0，尾元素的索引是 obj.size( ) - 1。下标运算符的返回值是一个对象。如果 p 是指针， n 是整数， 则 p[n] 与 (p+n) 等价。
  
-> 运算符（ -> operator）： 箭头运算符，该运算符综合了解引用操作和点操作。a -> b 等价于 (a).b。
  
<< 运算符（<< operator）： 标准库类型 string 定义的输出运算符，负责输出 string 对象中的字符。
  
>> 运算符（>> operator）： 标准库类型 string 定义的输入运算符，负责读入一组字符，遇到空白停止，读入的内容赋给运算符右侧的运算对象，该运算对象应该是一个 string 对象。
  
! 运算符（! operator）： 逻辑非运算符，将它的运算对象的布尔值取反。如果运算对象是假，则结果为真，如果运算对象是真，则结果为假。
  
&& 运算符（&& operator）： 逻辑与运算符，如果两个运算对象都是真，结果为真。只有当左侧运算对象为真时才会检查右侧运算对象。
  
|| 运算符（ || operator）： 逻辑或运算符，任何一个运算对象时真，结果就为真。只有当左侧运算对象为假时才会检查右侧运算对象。

第 4 章 表达式

算术转换（arithmetic conversion)： 从一种算术类型转换成另一种算术类型。在二元运算符的上下文中，为了保留精度，算术转换通常把较小的类型转换成较大的类型（例如整型转换成浮点型）。
  
集合律（associativitay）： 规定具有相同优先级的运算符如何组合在一起。结合律分为左结合律（运算符从左到右组合）和右集合律（运算符从右到左组合）。
  
二元运算符（binary operator）： 有两个运算对象参与运算的运算符。
  
强制类型转换（cast）： 一种显式的类型转换。
  
复合表达式（compound expression)： 含有多于一个运算符的表达式。
  
const_cast： 一种涉及 const 的强制类型转换。将底层 const 对象转换成对应的非常量类型，或者执行相反的转换。
  
转换（conversion）： 一种类型的值改变成另一种类型的值的过程。
  
dynamic_cast： 和继承及运行时类型识别一起使用。
  
表达式（expression）： C++程序中最低级别的计算。表达式将运算符作用于一个或多个运算对象，每个表达式都有对应的求值结果。表达式本身也可以作为运算兑现转换成所需的类型。
  
隐式转换（implicit conversoin）： 由编译器自动执行的类型转换。假如表达式需要某种特定的类型而运算对象是另外一种类型，此时只要规则允许，编译器就会自动地将运算对象转换成所需的类型。
  
整型提升（integral promotion）： 把一种较小的整型类型转换成与之最接近的较大整数类型的过程。不论是否真的需要，小数类型（即 short, char 等）总会得到提升。
  
左值（lvalue）： 是指那些求值结果为对象或函数的表达式。一个表示对象的非常量左值可以作为赋值运算符的左侧运算对象。
  
运算对象（operand）： 表达式在某些值执行运算，这些值就是运算对象。一个运算符由一个或多个相关的运算对象。
  
运算符（operator）： 决定表达式所做操作的符号。C++语言定义了一套运算符并说明了这些运算符作用于内置类型时的含义。C++还定义了运算符的优先级和结合律以及每种运算符处理的运算对象数量。可以重载运算符使其能处理类类型。
  
求值顺序（order of evaluation）： 是某个运算符的运算对象的求值顺序。大多数情况下，编译器可以任意选择运算对象求值的顺序。不过运算对象一定要在运算符之前得到求值结果。只用 &&，|| ，条件和逗号四种运算符明确规定了求值顺序。
  
重载运算符（overloaded operator）： 针对某种运算符重新定义的适用于类类型的版本。
  
优先级（precedence）： 规定了复合表达式中不同运算符的执行顺序。与低优先级的运算符相比，高优先级的运算符组合得更紧密。
  
提升（promoted）： 参见整型提升。
  
reinterpret_cast： 把运算对象的内容解释成另外一种。这种强制类型转换本质上依赖于机器而且非常危险。
  
结果（result）： 计算表达式得到的值或对象。
  
右值（rvalue）： 是指一种表达式，其结果是值而非值所在的位置。
  
短路求值（short-circuit evaluation）： 是一种专有名词，描述逻辑与和逻辑或运算符的执行过程。如果根据运算符的第一个运算对象就能确定整个表达式的结果，求值终止，此时第二个运算对象将不会被求值。
  
sizeof： 是一个运算符，返回存储对象所需的字节数，该对象的类型可能是某个给定的类型名字，也可能由表达式的返回结果确定。
  
static_cast： 显式地执行某种定义明确的类型转换，常用于替换由编译器隐式执行的类型转换。
  
一元运算符（unary operators）： 只用一个运算对象参与对象参与运算的运算符。
  
** ， 运算符（ , operator）：** 逗号运算符，是一种从左到右求值的二元运算符。逗号运算符的结果是右侧运算对象的值，当且仅当右侧运算对象是左值时逗号运算符的结果时左值。
  
** ？ 运算符（ ？operator）：** 条件运算符，以下述形式提供 if-then-else 逻辑的表达式  
             cond ? expr1 : expr2;
如果条件 cond 为真，对exp1求值；否则对 expr2 求值。 expr1 和 expr2 的类型应该相同或者能转换成同一种类型。expr1 和 expr2 中只有一个会被求值。
  
&& 运算符（&& operator）： 逻辑与运算符，如果两个运算对象都是真，结果才为真。只有当左侧运算对象为真时才会检测右侧运算对象。
  
& 运算符（& operator）：位与运算符，由两个运算对象生成的一个新的整型值。如果两个运算对象对应的位都是1，所得结果中该位i二位1；否则所得结果中该位为0。
  
^ 运算符（^ operator）： 位异或运算符，由两个元对象生成一个新的整型值。如果两个运算对象对应的为有且只有一个是1，所得结果中该位为1；否则所得结果中该位为0。
  
|| 运算符（|| operator）： 逻辑或运算符，任何一个运算对象是真，结果就为真。只有当左侧运算对象为假时才会检查右侧运算对象。
  
| 运算符（| operator）： 位或运算符，由两个运算对象生成一个新的整型值。如果两个运算对象对应的位至少由一个是1，所得结果中该位为1；否则所得结果中该位为0。
  
++ 运算符（++ operator）： 递增运算符。包括两种形式：前置版本和后置版本。前置递增运算符得到一个左值，它给运算符加1并得到运算对象改变后的值。后置递增运算符得到一个右值，它给运算符加1并得到运算对象原始的，未改变的值的副本。注意：即使迭代器没有定义 + 运算符，也会有++运算符。
  
-- 运算符（-- operator）： 递减运算符。包括两种形式：前置版本和后置版本。前置递减运算符得到一个左值，它从运算符减1并得到运算对象改变后的值。后置递减运算符得到一个优质，它从运算符减1并得到运算对象元素的，未改变的值或副本。注意：即使迭代器没有定义 --运算符，也会有 --运算符。
  
<< 运算符（<< operator）： 左移运算符，将左侧运算对象的值的（可能是提升后的）副本向左移位，移动的位数有右侧运算对象确定。右侧运算对象必须大于等于0而且小于结果的位数。左侧运算对象应该是无符号类型，如果它是带符号类型，则一旦移动改变了符号位的值就会产生未定义的结果。
  
>> 运算符（>> operator）： 右移运算符，除了移动方向相反，其他性质都和座椅运算符类似。如果左侧运算对象是带符号类型，那么根据实现的不同新移入的内容也不同，新移入的位可能都是0, 也可能都是符号位的副本。
  
~ 运算符（~ operator）： 位求反运算符，生成一个新的整型值。该值的每一位恰好与（可能是提升后的）运算对象的对应位相反。
  
！运算符（！operator）： 逻辑非运算符，将它的运算对象的布尔值取反。如果运算对象是假，则结果位真，如果运算对象是真，则结果为假。
  

第 5 章 语句

块（block）： 包围在花括号内的由 0 条或多条语句组成的序列。块也是一条语句，所以只要是能使用语句的地方，就可以使用块。
  
break语句（break statement）：终止理他最近的循环或switch语句。控制权转移到循环或switch之后的第一条语句。
  
case 标签（case label）： 在switch语句中紧跟在 case 关键字之后的常量表达式（参见2.4.4节，第58页）。在同一个switch语句中任意两个case标签的值不能相同。
  
catch 子句（catch clause）：由三部分组成：catch关键字，括号里的异常声明以及一个语句块。catch子句的代码赋值处理异常声明中定义的异常。
  
复合语句（compound statement）： 和块是同义词。
  
continue 语句（continue statement）： 终止离它最近的循环的当前迭代。控制权转移到while或do wihle语句的条件部分，或者范围for循环的下一次迭代，或者传统for循环头部的表达式。
  
悬垂else（dangling else）： 是一个俗语，指的是如何处理嵌套 if 语句中 if 分钟多于 else 分支的情况。 C++语言规定，else应该与前一个未匹配的 if 匹配在一起。使用花括号可以把位于内层的 if 语句隐藏起来，这样程序员就能更好地控制 else 该与那个 if 匹配。
  
default 标签（default label）： 是一种特殊的case标签，当switch表达式的值与所有case标签都无法匹配时，程序执行default标签下的内容。
  
do while语句（do while statement）： 与while语句类似，区别是do while 语句先执行循环体，在判断条件。循环体代码至少会执行一次。
  
异常类（exception class）： 是标准库定义的一组类，用于表示程序发生的错误。表5.1（第176页）列出了不同用途的异常类。
  
异常声明（exception declaration）： 位于catch子句中的声明，指定了该catch子句能处理的异常类型。
  
异常处理代码（exception handler）： 程序某处引发异常后，用于处理该异常的另一处代码。和catch子句是同义词。
  
异常安全（exception safe）： 是一个术语，表示的含义是当抛出异常后，程序能执行正确的行为。
  
表达式语句（expression statement）： 即一条表达式后面跟上一个分号，令表达式执行求值的过程。
  
控制流（flow of control）： 程序的执行路径。
  
for 语句（for statement）： 提供迭代执行的迭代语句。常常用于遍历一个容器或重复计算若干次。
  
goto 语句（goto statement）： 令控制器无条件转移到同一个函数中一个指定的带标签语句。goto语句容易造成程序的控制流混乱，应禁止使用。
  
if else 语句（if else statement）： 判断条件，根据其结果分别执行if分支或else分支的语句。
  
if 语句（if statement）： 判断条件，根据其结果有选择地执行语句。如果条件为真，执行if分支地代码；如果条件为假，控制权转移到if结构之后的第一条语句。
  
带标签语句（labeled statement）： 前面带有标签的语句。所谓标签是指一个标识符以及紧跟着的一个冒号。对于同一个标识符来说，用作标签的同数还能用于其他目的，互不干扰。
  
空语句（null statement）： 只含有一个分号的语句。
  
引发（raise）：含义类似于 throw。在C++语句中既可以说抛出异常，也可以说引发异常。
  
范围for语句（range for statement）：在一个序列中进行迭代的语句。
  
switch语句（switch statement）： 一种条件语句，首先求switch关键字后面表达式的值，如果某个 case 标签的值与表达式的值相等，程序直接跨过之前的代码从这个case标签开始执行，如果有defalut标签，从default标签继续执行；如果没有，结束switch语句。
  
terminate： 是一个标准库函数，当异常没有被捕捉到时调用。terminate终止程序的执行。
  
throw 表达式(throw expression）： 一种中断当前执行路径的表达式。throw表达式抛出一个异常并把控制权转移到能处理该异常的最近的catch子句。
  
try 语句块（try block）： 跟在try 关键字后面的块，以及一个或多个catch子句。如果try语句块的代码引发异常并且其中一个catch子句匹配该异常类型，则异常被该catch子句处理。否则，异常将有外围try语句块处理，或者程序终止。
  
while 语句（while statement）： 只要指定的条件为真，就一直迭代执行目标语句，随着条件真值的不同，循环可能执行多次，也可能一次也不执行。
  

第 6 章 函数

二义性调用（ambiguous call）： 是一种编译时发生的错误，造成二义性调用的原因时在函数匹配时两个或多个函数提供的匹配一样好，编译器找不到唯一的最佳匹配。
  
实参（argument）： 函数调用时提供的值，用于初始化函数的形参。
  
Assert： 是一个预处理宏，作用于一条表示条件的表达式。当未定义预处理遍历NDEBUG时，assert对条件求值。如果条件为假，输出一条错误信息并终止当前程序的执行。
  
自动对象（automatic object）： 仅存在于函数执行过程中的对象。当程序的控制流经过此类对象的定义语句时，创建该对象；当到达了定义所在的块的末尾时，销毁该对象。
  
最佳匹配（best match）： 从一组重载函数中为调用选出的一个函数。如果存在最佳匹配，则选出的函数与其他所有可行函数相比，至少在一个实参上时更优的匹配，同时在其他实参的匹配上不会更差。
  
传引用调用（call by reference）： 参见引用传递。
  
传值调用（call by value）： 参见值传递。
  
候选函数（candidate function）： 解析某次函数调用时考虑的一组函数。候选函数的名字应该与函数调用使用的名字一致，并且在调用点候选函数的声明在作用域之内。
  
constexpr： 可以返回常量表达式的函数，一个constexpr函数被隐式地声明成内联函数。
  
默认实参（defalut argument）： 当调用缺少了某个实参时，为该实参指定地默认值。
  
可执行文件（executable file）： 是操作系统能够执行的文件，包含着与程序有关的代码。
  
函数（function）： 可调用的计算单元。
  
函数体（function body）： 是一个块，用于定义函数所执行的操作。
  
函数匹配（function matching）： 编译器解析重载函数调用的过程，在此过程中，实参与每个重载函数的形参列表逐一比较。
  
函数原型（function prototype）： 函数的声明，包含函数名字，返回类型和形参类型。要调用某函数，在调用点之前必须声明该函数的原型。
  
隐藏名字（hidden name）： 某个作用域内声明的名字会隐藏掉外层作用域中声明的同名实体。
  
initalizer_list： 是一个标准类，表示的是一组花括号包围的类型相同的对象，对象之间以逗号隔开。
  
内联函数（inline function）： 请求编译器在可能的情况下在调用点展开函数。内联函数可以避免常见的函数调用开销。
  
链接（link）： 是一个编译过程，负责把若干对象文件链接起来形成可执行程序。
  
局部静态对象（local static object）： 它的值在函数调用结束后仍然存在。在第一次使用局部静态对象前创建并初始化它，当程序结束时局部静态对象才会被销毁。
  
无匹配（no match）： 是一种编译时发生的错误，原因时在函数匹配过程中所有函数的形参都不能与调用提供的实参匹配。
  
对象代码（object code）：编译器将我们的源代码转换成对象代码格式。
  
对象文件（object file）： 编译器根据给定的源代码生成保存对象的文件。一个或多个对象文件经过链接生成可执行文件。
  
对象生命周期（object lifetime）： 每个对象都有相应的生命周期。块内定义的非静态对象的生命周期从它的定义开始，到定义所在的块末尾为止。程序启动后创建全局对象，程序控制流经过局部局部静态对象的定义时创建该局部静态对象；当main函数结束时销毁全局对象和局部静态对象。
  
重载确定（overload resolution）： 参见函数匹配。
  
重载函数（overload function）： 函数名与其他函数相同的函数。多个重载函数必须在形参数量或形参类型上有所区别。
  
形参（parameter）： 在函数的形参类别中声明的局部变量。用实参初始化形参。
  
引用传递（pass by reference）： 描述如何将实参床底给引用类型的形参。引用形参和其他形式的引用工作机理类似，形参被绑定到相应实参值的一个副本。
  
值传递（pass by value）： 描述如何将实参传递给非引用类型的形参。非引用类型的形参实际上时相应实参值的一个副本。
  
预处理宏（perprocessor macro）： 类似于内联函数的一种预处理功能。除了assert之外，现代C++程序很少再使用预处理宏了。
  
递归循环（recurision loop）： 描述某个递归寒素没有终止条件，因而不断调用自身直至耗尽程序栈空间的过程。
  
递归函数（recurision function）： 直接或间接调用自身的函数。
  
返回类型（return type）： 是函数声明的一部分，用于指定函数返回值的类型。
  
分离式编译（separate compilation）： 把一个程序分割成多个独立源文件的能力。
  
尾置返回类型（trailing return type）： 在参数类别后边指定的返回类型。
  
可行函数（viable function）： 是候选函数的子集。可行函数能匹配本次调用，他的形参数量于调用提供的实参数量相等，并且每个似乎从类型都能转换成相应的形参类型。
  
（）运算符（ （）operator）： 调用运算符，用于执行某函数。括号前面是函数名或函数指针，括号内是以逗号隔开的实参列表（可能为空）。
  

第 7 章 类

第 II 部分 C++标准库

第 8 章 IO库

第 9 章 顺序容器

第 10 章 泛型算法

第 11 章 关联容器

第 12 章 动态内存

第 III 部分 类设计者的工具

第 13 章 拷贝控制

第 14 章 重载运算与类型转换

第 15 章 面向对象程序设计

第 16 章 模板与泛型编程

第 IV 部分 高级主题

第 17 章 标准库特殊设施

第 18 章 用于大型程序的工具

第 19 章 特殊工具与技术