=0
,运算符(, operator)
*和**
++，增量运算符(incremental operator)
++，前缀和后缀(prefix and postfix)
--，减量运算符(decremental operator)
--，前缀和后缀(prefix and postfix)
->和委托(delegation and)
->运算符(operator)
->*运算符
.和::
.运算符
.*运算符
...，省略(ellipsis)
//和C兼容性(and C comparibility)
::显式量化(explicit qualification)
::和.
<...>语法(syntax)
<<运算符
=运算符
>>与template语法的问题(problem with template syntex)
0，NULL
0，flase
0，空指针
=0语法
1，true

抽象class(abstract class)
抽象class和库(abstract class and library)
抽象template和class(abstract template and class)
抽象类型(abstract type)
抽象，C++和数据(abstraction, C++ and data)
接受的扩充(accepted extensions)
接受的特征(accepted features)
接受的建议(accepted proposals)
访问控制(access control)
访问控制和static成员(access control and static member)
访问控制，对建构函数(access control for constructor)
访问控制，对名字(access control for names)
访问，对基类(access to base class)
访问，通过使用声明调整(access using-declaration adjusting)
访问声明(access-declaration)
访问声明和使用声明(access-declaration and using declaration)
Ada语言
可负担的特征(affordable features)
目标，带类的C(aims of C with Class)
目标，异常处理(aims for exception handling)
目标，标准化(aims for standardization)
目标，C++
目标，早期库(aims of early libraries)
目标，namespace设计目标(aims of namespace design)
Algol68语言
Algol68的声明(Algol68 declaration)
Algol68运算符(Algol68 operators)
Algol68引用(Algol68 references)
Algol68引用重载(Algol68 references overloading)
标准算法(standard algorithms)
别名，名字空间(alias, namespace)
别名问题(alias, problems with)
分配的建构函数，new(allocation and constructor, new)
分配和初始化(allocation and initialization)
分配和实时，动态(allocation and real-time, dynamic)
分配场地(allocation arena)
分配，数组(allocation, array)
分配和new(allocation and new)
分配，禁止auto(allocation, prohibit auto)
分配，禁止自由空间(allocation, prohibit free store)
分配，禁止全局量(allocation, prohibit globe)
分配，禁止static(allocation, prohibit static)
分配程序，按类(allocator, per-class)
歧义性(ambiguity)
歧义性控制(ambiguity, control)
歧义性，模板(ambiguity, in template)
歧义性，和多重继承(ambiguity, multiple inheritance and)
ANSI C 语法(ANSI C grammar)
ANSI C 局部静态数组
ANSI C volatile
ANSI C++ 标准(ANSI C++ standard)
ANSI C 标准库(ANSI C standard library)
ANSI/ISO名字查找(ANSI/ISO name lookup)
面向特定系统结构的扩充(architecture-specific extension)
参数检查，运行时(argument check, run time)
参数约束，对模板(argument constraint on template)
参数的推断，模板(argument deducing， template)
参数，默认(argument, default)
参数，依赖于template(argument, depend on template)
参数，显式template参数(argument, explicit template)
参数，函数template(argument, function template)
参数，关键字(argument, keyword)
参数匹配规则(argument matching rules)
参数，命名(argument, named)
参数名(argument names)
参数，名字空间作为template参数(argument, namespace as template)
参数，非类型template参数(argument, non-type template)
参数，过分约束(argument, over-constrained)
参数规则，放松(argument rules, relaxation of)
参数，template作为template参数(argument, template as template)
参数的平均数目(arguments, average number of)
参数的值(argument, value of)
算术，混合模式(arithmetic, mixed mode)
ARM特征(ARM features)
ARM名字查找(ARM name lookup)
ARM参考手册(ARM reference manual)
数组分配(array allocation)
数组，关联数组(array, associative)
数组释放(array, deallocating)
数组，标准关联数组(array, standard associative)
数组template(array template)
Assert()
assert()
赋值(assignment)
赋值的重载(assignment, overloading of)
赋值，对this的赋值(assignment to this)
赋值，对void*的赋值(assignment, void*)
假设，对异常处理(assumptions for exception handling)
关联数组(associative array)
关联数组，标准(associative array, standard)
非同步事件(asynchronous events)
自动废料收集(automatic garbage collection)
自动存储(automatic storage)
自动template实例化(automatic template instantiation)
自动原型(autoprototyping)

bad_cast
基和导出(base and derived)
基和导出，重载(base and derived, overloading)
基，由virtual基强制(base, cast from virtual)
基，强制导private基(base, cast to private)
基class(base class)
基class，访问(base class, access to)
基class，常规(base class, ordinary)
基class，virtual(base class, virtual)
基，导出遮蔽(base, derived hiding)
基，初始构造(base, first construction)
基，初始式(base, initializer)
基布局，virtual(base layout, virtual)
基成员的遮蔽(base member, hiding of)
basic_string
更好的匹配(better match)
约束，引用(binding of reference)
约束规则，名字(binding rule, name)
bit<N>
bitstring
按位复制(bitwise copy)
Booch组件(Booch components)
Booch组件库(Booch components library)
书籍和杂志(books and journals)
bool，布尔类型(bool, Boolean type)
Buffer
错误，多重继承(bugs, multiple inheritance)
内部类型的建构函数(build-in type, constructor for)
内部类型导出(build-in type, derivation from)
内部类型的析构函数(build-in type, distructor for)
内部类型的定义(build-in type, definition for)
内部类型和template(build-in type, and template)
内部类型，和用户定义类型(build-in type, user-defined types)

C和C++
C I/O
C优点和缺点(C, advantages and disadvantages)
C与C++兼容性(C and C++ compatibility)
C和C++连接(C and C++ linkage)
C代码，生成的(C code generated)
C兼容性(C compatibility)
C兼容性和//(C compatibility, and //)
C兼容性，100%(C compatibility, 100%)
C兼容性和转换(C compatibility and conversion)
C兼容性和名字空间(C compatibility and namespace)
C声明的语法(C declaration syntax)
C enum
C错误处理(C error handling)
C语言，和异常(C, and exceptions)
C扩充(C extensions)
C特征，危险的(C features, dangerous)
C特征，肮脏的(C features, ugly)
C连接(C linkage)
C数值(C numerical)
C预处理器(C preprocessor)
C预处理器Cpp(C preprocessor Cpp)
C语言的问题(problems with C)
C语义(C semantics)
C变量(C variables)
带类的C(C with Classes)
带类的C的C兼容性(C with Classes C compatibility)
带类的C文档(C with Classes documentation)
带类的C特征(C with Classes features)
带类的C实现(C with Classes implementation)
带类的C布局兼容性(C with Classes layout compatibility)
带类的C低级特征(C with Classes low-level features)
带类的C对象布局(C with Classes object layout)
带类的C预处理器，Cpre(C with Classes 预处理器, Cpre)
带类的C运行时支持(C with Classes run-time support)
带类的C静态类型检查(C with Classes static type checking)
带类的C没有虚函数(C with Classes without virtual function)
建构函数里的virtual调用(virtual call in constructor)
建构函数的调用写法(constructor call notation)
virtual的调用优化(call optimization of virtual)
回调(callback)
引用调用(call-by-reference)
值调用(call-by-value)
调用Fortran(calling Fortran)
调用规则(calling conventions)
调用序列，标准(calling sequences, standard)
强制(cast)
强制，和RTTI(cast and RTTI)
强制和const(cast and const)
强制和不完全类型(cast and incomplete type)
强制和界面(cast and interface)
强制和指向函数的指针(cast and pointer to function)
强制去掉const(cast away const)
强制删除(cast eliminate)
强制，从virtual基(cast from virtual base)
强制，从void*(cast from void*)
强制，隐式(cast, implicit)
强制，新风格(cast, new-style cast)
强制新记法(cast notation, new)
强制记法，老风格(cast notation, old-style)
强制的过度使用(overuse of cast)
强制的问题(problem with cast)
强制，安全(cast, safe)
强制的语法(cast, syntax)
强制到private基(cast to private base)
catch
cerr
Cfront
Cfront代码质量(Cfront code quality)
Cfront编译时代价(Cfront compile-time overhead)
Cfront，new的实现(Cfront implementation of new)
Cfront存储使用(Cfront memory use)
Cfront资源需求(Cfront resource requirements)
Cfront的规模(size of Cfront)
Cfront结构(structure of Cfront)
Cfront的符号表(Cfront symbol tables)
Cfront template
Cfront template实现(Cfront template implementation)
Cfront虚表的布局(Cfront virtual table layout)
C++ Release 1.0特征(C++ Release 1.0 features)
C++和Simula
C++和Smalltalk
C++和Ada
C++和C
C++和Fortran
C++和汇编语言(C++ and assembler)
C++和数据抽象(C++ and data abstraction)
C++和类属程序设计(C++ and generic programming)
C++和面向对象的程序设计(C++ and object-oriented programming)
C++和其他语言(C++ and other languages)
C++作为目标语言(C++ as a target language)
C++作为实现语言(C++ as an implementation language)
C++的较好的C子集(better C subset of C++)
C++设计(design of C++)
C++和C的兼容性(compatibility, C and)
C++ const，和C
C++异常处理的想法(exception handling, ideals of)
C++特征(C++ features)
C++作为通用程序设计语言(C++, general-purpose programming language)
C++的逐步途径(C++ gradual definition)
C++库(C++ libraries)
C++连接(C++ linkage)
C++保护模型(C++ model of protection)
C++名字(C++ name)
对C++的影响，操作系统(C++, operating system influence on)
C++程序设计环境(C++ programming environment)
C++静态类型检查(C++ static type checking)
C++流I/O(C++ stream I/O)
C++语法类型系统(C++ syntax type-system)
C++类型检查(C++ type checking)
char类型的常量(constant, type of char)
char类型的文字(literal, type of char)
char和int
char和重载(char and overloading)
字符集(character set)
字符集，8位(character set, 8-bit)
字符集，unicode(character set, unicode)
字符集，I/O扩充(character set, I/O extended)
字符集，扩充(character set, extended)
字符集，国家(character set, national)
char_ref
扩充时的检查表(check list, extension)
检查，运行时(check, run-time)
检查，运行时参数检查(check, run-time argument)
检查，静态检查的界面(checked interface, statically)
检查和错误(checking and error)
检查异常，动态(checking of exceptions, dynamic)
异常检查，静态(checking of exceptions, static)
静态检查和多重继承(static checking and multiple inheritance)
检查template的错误(checking of template, error)
cin的初始化(cin, initialization of)
辅助类(class helper)
类分层结构，异常(class hierarchy, and exception)
类的布局，导出(class layout, derived)
类成员的向前引用(class member, forward reference of)
string类(string class)
class, Simula
class, Simula风格(class, Simula style)
class和宏，容器(class and macro, container)
class和template，容器(class and template, container)
class作为namespace(class as namespace)
class概念(class concept)
class，导出(class, derived)
嵌套class的先行声明(forward declaration of nested class)
class分层结构的合并(class hierarchies, merging of)
class分层结构(class hierarchy)
class分层结构和重载(class hierarchy and overloading)
class是用户定义类型(class is user-defined type)
class，局部嵌套(class, locality nested)
class成员(class member)
class成员顺序依赖性(class member order dependencies)
class和namespace
class，嵌套(class, nested)
class，常规基(class, ordinary base)
class根(class root)
class和struct
class，template
class和template
抽象class和template(abstract class, and template)
class, 保护的单位(class, unit of protection)
class, 统一的根(class, universal root)
class，virtual基(class, virtual base)
clone()
CLOS
Clu
Clu风格的容器(Clu-style container)
CMP
代码肿胀的抑制(code bloat, curbing)
代码生成(code generation)
代码重复(code replication)
编码，低级(coding, low-level)
一致性维护(coherence maintaining)
一致的观点(coherent view)
组合方法(combination method)
通讯，兄弟类之间(communication between siblings)
兼容性，连接(compatibility, link)
兼容性和安全性(compatibility vs. safety)
编译模型，template(compilation model, template)
编译，分别(compilation, separate)
编译程序复杂性(compiler complexity)
编译时间和template(compile-time and template)
编译时间开销(compile-time overhead)
编译时间保护(compile-time protection)
编译时间类型检查(compile-time type checking)
编译时间类型查询(compile-time type inquiry)
complex
complex库(complex library)
complex template
软件部件产业(component industry, software)
复合运算符(composite operator)
复合，界面的复合(composition, interface)
复合技术，template(composition techniques, template)
计算，工程(computing, engineering)
计算，数值(computing, numeric, numerical)
计算，科学(computing, scientific)
并行性(concurrency)
并行性和异常(concurrency and exceptions)
并行性支持(concurrency, supporting)
条件中的声明(condition, declarations in)
条件，在模板中(conditionals in template)
保守性废料收集(conservative garbage collection)
const和Cpp
const作为符号常量(const as symbolic constant)
const，为描述界面使用(const for specifying interface)
const的初始化(initialization of const)
const成员函数(const member function)
const成员初始式(const member initializer)
const和重载(const and overloading)
const_cast
约束和错误检查(constraint and error detection)
约束和可读性(constraint and readability)
约束，对template参数(constraint on template argument)
约束，通过导出(constraint through derivation)
约束，通过继承(constraint through inheritance)
约束，通过使用(constraint through use)
constraints
建构，基类在先(construction, base first)
建构函数，访问控制(constructor, access control for)
建构函数和库(constructor and library)
建构函数，复制(constructor, copy)
建构函数，默认(constructor, default)
建构函数和异常(constructor and exception)
建构函数，对内部类型(constructor, for build-in type)
建构函数，和new分配(constructor, and new allocation)
建构函数，和new(constructor, and new)
建构函数，new()(constructor, new())
建构函数记法(constructor notation)
建构函数和template(constructor and template)
建构函数，其中的virtual调用(constructor, virtual call in)
容器，Clu风格(container, Clu style)
容器，Smalltalk风格(container, Smalltalk style)
容器，class和宏(container, class and macro)
容器，class和template(container, class and template)
Container模板(Container template)
容器，标准(container, standard)
上下文，template定义的(context of template definition)
上下文，template实例化的(context of template instantiation)
控制，访问(control, access)
控制，手工(control, manual)
控制，复制控制(control of copy)
控制，存储耗尽(control of memory exhaustion)
控制，存储管理，细粒度(control of memory management, fine-grain)
Controlled_container
转换(conversion)
转换和C兼容性(conversion and C compatibility)
转换和template(conversion and template)
转换，浮点数到整数(conversion, floating to integral)
转换函数(conversion function)
转换图(conversion graph)
转换，隐式(conversion, implicit)
转换，隐式窄转换(conversion, implicit narrowing)
转换格(conversion lattice)
转换，窄转换(conversion, narrowing)
转换和重载(conversion, overloading and)
转换，安全(conversion, safe)
转换，标准(conversion, standard)
转换，static_cast和隐式(conversion, static_cast and implicit)
转换到void*(conversion to void*)
复制，按位(copy, bitwise)
复制建构函数(copy constructor)
复制控制(copy, control of)
复制，深(copy, deep)
复制，按成员(copy, memberwise)
复制，对象(copy of object)
复制，指针(copy of pointer)
复制，禁止(copy, prohibit)
复制，浅(copy, shallow)
复制，virtual(copy, virtual)
copy()
异常的代价(cost of exception)
cout
cout的初始化(cout, initialization of)
Cpp
评价准则(criteria)
评价准则，扩充(criteria, extension)
评价准则，接受的特征(criteria, feature acceptance)
评价准则，对于模板设计(criteria, for template design)

DAG，支配(DAG, dominance)
危险的C特征(dangerous C features)
危险的特征(dangerous features)
数据抽象，C++(data abstraction, C++)
数据成员，指针指向(data member, pointer to)
数据，virtual(data, virtual)
释放数组(deallocating array)
释放和清除(deallocation and cleanup)
释放，delete和(deallocation, delete and)
释放问题(deallocation problem)
声明(declaration)
声明，Algol68(declaration, Algol68)
声明，实现(declaration, implementation)
声明，在条件里(declaration, in condition)
声明，在for-语句里(declaration, in for-statement)
声明，在嵌套class里，前向(declaration, of nested class, forward)
声明重载(declaration overloading)
声明，特殊化(declaration, specialization)
声明的语法，C(declaration syntax, C)
减量运算符 --(decrement operator --)
推断template参数(deducing template argument)
深复制(deep copy)
默认(default)
默认参数(default argument)
默认参数和重载(default argument, overloading and)
默认建构函数(default constructor)
默认，局部(default, local)
默认，嵌套(default, nested)
默认运算符(default operator)
默认，私用(default, private)
默认，类型检查(default, type checked)
#define
委托(delegation)
委托和->(delegation and ->)
委托，经验(delegation, experiment)
委托，多重继承(delegation, multiple inheritance)
delete
delete和释放(delete and deallocation)
delete和析构函数(delete and destructor)
delete, free()
delete运算符(delete operator)
对template参数的依赖(depend on template argument)
导出(derivation)
导出，通过导出约束(derivation, constraint through)
导出，由内部类型(derivation from build-in type)
导出，由int导出(derivation from int)
导出，禁止(derivation, prohibit)
导出的(derived)
导出类和基(derived and base)
导出class(derived class)
导出类的布局(derived class layout)
导出遮蔽基类(derived hiding base)
导出类和重载的基(derived, overload base)
导出类重载和基类(derived overloading, base and)
设计(design)
设计，namespace的设计目标(design aims of namespace)
设计，RTTI的替代设计(design alternative RTTI)
设计和类型检查(design and type checking)
设计，template的清理(design cleanup of template)
设计，template的设计准则(design criteria for template)
设计，namespace的设计思想(design ideal for namespace)
设计，语言(design language)
设计，库(design library)
设计，面向对象的(design, object-oriented)
设计，葱头式(design, onion)
设计规则，语言(design rules, language)
设计和静态类型检查(design and static type checking)
设计，template和库(design, template and library)
设计者和实现者(designer and implementer)
析构函数(destructor)
析构函数和废料收集(destructor and garbage collection)
析构函数和delete(destructor, delete and)
析构函数，delete()(destructor, delete())
析构函数和异常(destructor, exception and)
析构函数，显式调用(destructor, explicit call of)
析构函数，对于内部类型(destructor, for build-in type)
析构函数，virtual(destructor, virtual)
dialog_box
指示符，template实例化(directive, template instantiation)
发送(dispatch)
发送，双重(dispatch, double)
发送，template双重发送(dispatch, template, double)
displayed
double和float
动态(dynamic)
动态分配和实时(dynamic allocation and real-time)
动态检查异常(dynamic checking of exception)
动态初始化(dynamic initialization)
动态连接(dynamic linking)
动态存储(dynamic storage)
动态和静态类型检查(dynamic type checking, static and)
dynamic_cast
dynamic_cast和static_cast
dynamic_cast的语法
dynamic_cast的使用
dynarray

效率，带类的C(efficiency, C With Classes)
效率和重载(efficiency and overloading)78,84
效率和异常(efficiency, exception and)
效率和灵活性(efficiency, flexibility and)
效率，运行时(efficiency, run-time)
效率，virtual(efficiency, virtual)
幽雅和简单(elegance and simplicity)
删除强制(eliminate cast)
删除临时量(elimination of temporaries)
省略号...(ellipsis ...)
嵌入式系统(embedded system)
employee
封装和friend(encapsulation and friend)
enum, C
enum，基于enum的重载(enum, overloading based on)
enum类型
环境(environment)
环境，C++程序设计环境(environment, C++ programming)
环境，未来的C++程序设计环境(environment, future C++ programming)
环境，理想的程序开发环境(environment, ideal program development)
等价(equivalence)
等价，名字(equivalence, name)
等价，运算符(equivalence, operator)
等价，结构(equivalence, structural)
错误和检查(error, checking and)
错误，template的错误检查(error checking of template)
错误，多重定义(error, double definition)
错误处理(error handling)
错误处理，C(error handling, C)
错误处理，多层(error handling, multi-level)
错误，可能的(error, potential)
事件，非同步(event, asynchronous)
例子，成员template(example, member template)
例子，RTTI(example of RTTI)
例子，对象I/O(example of object I/O)
例子，作业(example, task)
异常和建构函数(exception and constructor)
异常和析构函数(exception and destructor)
异常和库(exception and library)
异常处理(exception handling)
异常处理的目标(exception handling, aims for)
异常处理和可靠性(exception handling and reliability)
异常处理，假设(exception handling, assumptions for)
异常处理，C++的理想(exception handling, ideals for C++)
异常处理和多重继承(exception handling, multiple inheritance and)
异常处理的语法(exception handling syntax)
异常描述(exception specification)
异常和C(exceptions and C)
异常和类层次(exceptions and class hierarchy)
异常和效率(exceptions and efficiency)
异常和布局(exceptions and layout)
异常和抽象的层次(exceptions and levels of abstraction)
异常和老代码(exceptions and old code)
异常和其他语言(exceptions and other languages)
异常和重新编译(exceptions and recompilation)
异常和资源管理(exceptions and resource management)
异常和并行性(exceptions, concurrency and)
异常的动态检查(exceptions, dynamic checking of)
异常的经验(exceptions, experience with)
异常结组(exceptions, grouping of)
异常，捕捉的保证(exceptions, guaranteed catching of)
异常和大系统(exceptions, large system and)
异常和存储耗尽(exceptions, memory exhaustion and)
异常的多层传播(exceptions, multi-level propagation of)
异常和溢出(exceptions, overflow and)
异常的静态检查(exceptions, static checking of)
异常和template(exceptions, template and)
异常和类型安全性(exceptions, type safety and)
显式调用析构函数(explicit call of destructor)
显式量化(explicit qualification)
显式量化::(explicit qualification ::)
显式template参数(explicit template argument)
显式template实例化(explicit template instantiation)
显式类型域(explicit type field)
explicit
指数运算符**(exponentiation operator **)
指数运算符*^(exponentiation operator *^)
扩充的字符集(extended character set)
扩充的I/O字符集(extended character set, I/O of)
扩充的类型信息(extended type information)
可扩充I/O(extensible I/O)

false 0
特征，ARM(features, ARM)
特征，带类的C(features, C With Classes)
特征，C++(features, C++)
特征，C++ Release 1.0(features, C++ Release 1.0)
特征，C++ Release 2.0(features, C++ Release 2.0)
特征，新的(features, new)
Fig
文件和template，.c(file and template, .c)
文件和template，.h(file and template, .h)
文件和template，源文件(file and template, source)
文件，头文件(file, header)34,207,235
文件，源文件(file, source)
FilePtr
找到template定义(finding template definition)
细粒度存储管理的控制(fine-grain control of memory management)
细粒度重载解析(fine-grain overload resolution)
灵活性和效率(flexibility and efficiency)
灵活性与简单性(flexibility vs. simplicity)
float和double
float和重载(float, overloading and)
浮点数到整数的转换(floating to integral conversion)
fopen()
外国语接口(foreign language interface)
for语句中的声明(for-statement, declaration in)
嵌套class的向前声明(forward declaration of nested class)
类成员的向前引用(forward reference of class member)
前向函数(forwarding function)
基础库(foundation libraries)
基础库，水平的(foundation libraries, horizontal)
基础库，垂直的(foundation libraries, vertical)
碎片(fragmentation)
自由存储(free store)32,56
自由存储分配，禁止(free store allocation, prohibit)
free(), delete
friend和成员(friend and member)
friend和封装(friend, encapsulation and)
friend，错误使用(friend, misuse)
函数，虚函数和多重继承(function, and multiple inheritance, virtual)
函数，调用无定义函数(function call of undeclared)
函数，强制和指针指向(function, cast and pointer to)
函数，const成员(function, const member)
函数，转换函数(function, conversion)
函数定义(function definition)
函数，virtual函数的效率(function efficiency, virtual)
函数，前向(function, forwarding)
函数，成员的实现(function, implementation of member)
函数，virtual函数的实现(function implementation, virtual)
函数，在线inline(function, inline)
函数，inline成员(function, inline member)
函数，布局和virtual函数(function, layout and virtual)
函数成员(function member)
函数new()(function new())
函数，只实例化用的函数(function, only, instantiate used)
函数，运算符(function, operator)
函数优化，virtual(function optimization, virtual)
函数，指针指向(function, pointer to)
函数指针，virtual(function pointer, virtual)
函数，不用virtual的多态性(function, polymorphism without virtual)
函数，纯virtual(function, pure virtual)
函数，virtual函数的重新编译(function recompilation, virtual)
函数，static成员(function, static member)
函数，virtual函数表(function table, virtual)
函数，template函数(function, template)
函数，template和virtual(function, template and virtual)
函数，template参数(function, template argument)
函数，template重载(function, template overloading)
函数，virtual(function, virtual)

废料收集(garbage collection)
废料收集，自动(garbage collection, automatic)
废料收集，保守式(garbage collection, conservative)
废料收集和析构函数(garbage collection, destructor and)
废料收集与多重继承(garbage collection, multiple inheritance)
废料收集，可选的(garbage collection, optional)
废料收集，反对的理由(garbage collection, reasons against)
废料收集，支持的理由(garbage collection, reasons for)
废料收集，标准(garbage collection, standard)
GDB_root
类属程序设计，C++(generic programming, C++ and)
类属类型，宏(generic types, macro for)
全局分配(global allocation, prohibit)
全局名字(global names)
全局namespace(global namespace)
全局优化(global optimization)
全局作用域(global scope)
全局作用域名字冲突(global scope name clashes)
全局变量(global variable)
grab_X()

.h文件和template
句柄(handle)
处理器，new(handler, new)
Hchar
头文件(header file)34,207,235
头文件，预编译(header, precompiled)
堆存储(heap storage)
遮蔽基，导出类(hiding base, derived)
遮蔽基成员(hiding of base member)
遮蔽名字(hiding of name)
遮蔽表示(hiding of representation)
遮蔽template实现(hiding of template implementation)
遮蔽，和重载(hiding, overloading and)
层次结构，class(hierarchy, class)
层次结构，异常和class(hierarchy, exception and class)
层次结构，单根的(hierarchy, single-rooted)
template里的名字劫持(hijacking of names in template)
histogram
水平的基础库(horizontal foundation library)

相同，类型(identity, type)
if替代#ifdef(if alternative to #ifdef)
#ifdef
实现，带类的C(implementation C With Classes)
实现Cfront template(implementation Cfront template)
实现和界面(implementation and interface)
实现和界面，template(implementation and interface, template)
实现复杂性，RTTI(implementation complexity, RTTI)
实现template遮蔽(implementation hiding of template)
实现private继承(implementation, inheritance private)
实现语言，C++作为(implementation language, C++ as an)
实现多重继承(implementation multiple inheritance)
实现成员函数(implementation of member function)
实现问题，template(implementation problem, template)
实现virtual函数(implementation virtual function)
与实现有关的行为(implementation-dependent behavior)
隐式强制(implicit cast)
隐式转换(implicit conversion)
隐式转换和static_cast(implicit conversion, static_cast and)
隐式实例化(implicit instantiation)
隐式窄转换(implicit narrowing conversion)
隐式，template里的隐式使用(implicit use in template)
#include
include替代#include(include alternative to #include)
不完全类型和强制(incomplete type, cast and)
增量运算符++(increment operator ++)
增量连接(incremental linking)
独立的多重继承(independent multiple inheritance)
间接(indirection)
继承和template(inheritance and template)
继承，通过继承约束(inheritance, constraint through)
继承，多重(inheritance, multiple)
继承operator delete()(inheritance operator delete())
继承operator new()(inheritance operator new())
继承和重载(inheritance, overloading and)
继承，过度使用(inheritance, overuse)
继承private，实现(inheritance private, implementation)
继承public，界面(inheritance public, interface)
inherited
初始化，Simula(initialization, Simula)
初始化和分配(initialization, allocation and)
初始化和赋值(initialization and assignment)
初始化和换页(initialization and paging)
初始化和虚拟存储(initialization and virtual memory)
初始化，动态(initialization, dynamic)
初始化，库(initialization, library)
初始化cin(initialization of cin)
初始化const(initialization of const)
初始化cout(initialization of cout)
初始化stdin(initialization of stdin)
初始化stdout(initialization of stdout)
初始化顺序(initialization, order of)
初始化，成员初始化的顺序(initialization, order of member)
初始化，运行时的问题(initialization, problem with run-time)
初始化，资源请求(initialization, resource acquisition)
初始化，运行时(initialization, run-time)
初始化，运行时检查的(initialization, run-time checked)
初始化，静态(initialization, static)
仅做初始化的风格(initialize-only style)
初始式(initializer)
初始式，基类(initializer, base)
初始式，const成员(initializer, const member)
初始式，成员(initializer, member)
初始式，语法(initializer, syntax)
inline和Cpp
inline函数(inline function)
inline关键字(inline keyword)
inline成员函数(inline member function)
inline和template(inline, template and)
查询，编译时类型信息(inquiry, compile-time type)
实例化(instantiation)
实例化#pragma，template(instantiation #pragma, template)
实例化，自动template实例化(instantiation, automatic template)
实例化上下文，template(instantiation context of template)
实例化指示符，template(instantiation directive, template)
实例化，显式template(instantiation, explicit template)
实例化，隐式(instantiation, implicit)
实例化，推迟(instantiation, late)
实例化，手工优化(instantiation, manual optimization)
实例化，多次(instantiation, multiple)
实例化点(instantiation, point of)
int和char
整数提升(integral promotions)
界面(interface)
界面和强制(interface, cast and)
界面复合(interface composition)
界面，const描述(interface, const for specifying)
界面，外国语(interface, foreign language)
界面和实现(interface, implementation and)
界面，public继承(interface, inheritance public)
界面，template实现和界面(interface, template implementation and)
界面，静态检查(interfaces, static checking)
跨语言连接(inter-language linkage)
中断(interrupts)
交叉规则(intersect rule)
intersect Shape
I/O, Ada
I/O, C
I/O, C++流(I/O, C++ stream)
I/O流(I/O stream)
I/O，对象I/O的实例(I/O, example of objects)
I/O，可扩充(I/O, extensible)
I/O库，流(I/O library, stream)
I/O，对象(I/O, object)
I/O，扩展字符集(I/O of extended character set)
I/O, printf, C
I/O，简洁(I/O, terse)
I/O，类型安全(I/O, type-safe)
io
iocircle
io_counter
io_obj
iostream

关键字参数(keyword argument)

语言，C++作为目标语言(language, C++ as a target)
语言，C++作为实现语言(language, C++ as an implementation)
语言和环境，分离(language and environment, separation)
语言和实现(language and implementation)
语言设计规则(language design rules)
语言特征和库(language feature, library and)
语言特征和技术(language and techniques)
大程序中的命名(large program, naming in a)
大系统和异常(large system and exception)
推迟实例化(late instantiation)
布局，带类的C对象(layout, C With Classes object)
布局，Cfront虚表(layout, Cfront virtual table)
布局兼容性，带类的C(layout compatibility, C With Classes)
布局，导出类(layout, derived class)
布局和异常(layout, exception and)
布局，多重继承(layout, multiple inheritance)
布局，对象(layout, object)
布局，标准virtual表(layout, standard virtual table)
布局和template(layout, template and)
布局，virtual基类(layout, virtual base)
库，C++(library, C++)
库和静态类型检查(library and static type checking)
库和类型系统(library and type system)
库的多重使用(library, use of multiple)
库，ANSI标准(library, ANSI standard)
库，Booch组件(library, Booch components)
库，ISO标准(library, ISO standard)
库，标准组件库(library, standard components)
库和抽象class(library, abstract class and)
库，complex(library, complex)
库和建构函数(library, constructor and)
库设计(library design)
库设计和template(library design, template and)
库设计折中(library design tradeoff)
库和异常(library, exception and)
库，水平基础库(library, horizontal foundation)
库初始化(library initialization)
库，语言支持(library, language support for)
库和多重继承(library, multiple inheritance)
库和namespace(library, namespace and)
库，标准库名字空间(library, namespace in standard)
库，标准库中的命名(library, naming in standard)
库和运行时类型信息(library, run-time type information and)
库，标准库(library, standard)
库，标准数值库(library, standard numeric)
库，流I/O库(library, stream I/O)
库，作业(library, task)
库，垂直基础库(library, vertical foundation)
库和语言特征(library vs. language feature)
临时量的生存期(lifetime of temporaries)
声明的线性记法(linear notation of declarations)
连接兼容性(link compatibility)
link
连接，C(linkage, C)
连接，C和C++(linkage, C and C++)
连接和重载(linkage and overloading)232,233
连接，跨语言(linkage, inter-language)
连接模型(linkage model)
连接名(linkage name)
连接，函数指针(linkage, pointer to function)
连接，类型安全(linkage, typw-safe)34,232,234,236,399
连接，动态(linking, dynamic)
连接，增量(linking, incremental)
连接程序(linker)
连接程序的问题(linker problem)98,303
连接时间和template(link-time and template)
list
局部，默认(local, default)
局部静态数组，ANSI C(local static array, ANSI C)
局部变量(local variable)
局部性(locality)
局部性，嵌套的class(locality, nested class)
查找ANSI/ISO名字(lookup ANSI/ISO name)
查找ARM名字(lookup ARM name)
查找名字(lookup name)
查找template名字(lookup template name)
低级编码(low-level coding)
低级特征，带类的C(low-level feature, C With Classes)
低级程序设计(low-level programming)
低级程序设计规则(low-level programming rules)
左值与右值(lvalue vs. rvalue)
宏用于类属类型(macro for generic type)
主要和次要扩充(major and minor extension)
malloc(), new
手工实例化优化(manual optimization of instantiation)
Map
匹配，更好(match, better)
匹配，重载(matching, overloading)
匹配规则，参数(matching rules, argument)
Matherr
Matrix，有效性(Matrix, efficient)
成员，访问控制和static成员(member, access control and static)
成员，class(member, class)
成员，类成员的向前引用(member, forward reference of class)
成员和friend(member, friend and)
成员函数(member, function)
成员函数，const(member function, const)
成员函数，实现(member function, implementation)
成员函数，inline(member function, inline)
成员函数，方法(member function, method)
成员函数，static(member function, static)
成员，遮蔽基(member, hiding base)
成员初始化顺序(member initialization, order of)
成员初始式(member initializer)
成员初始式, const(member initializer, const)
成员顺序依赖性，class(member order dependencies, class)
成员，指针指向(member, pointer to)
成员，指针指向数据成员(member, pointer to data)
成员，protected(member, protected)
成员，template(member, template)
成员，template例子(member, template example)
成员，template，virtual(member, template, virtual)
按成员复制(memberwise copy)
存储分配场地(memory arena)
存储耗尽和异常(memory exhaustion and exception)
存储耗尽控制(memory exhaustion, control of)
存储，初始化和虚存(memory, initialization and virtual)
存储管理(memory management)
存储管理，细粒度控制(memory management, fine-grain control in)
存储，原始(memory, raw)
存储，只读(memory, read-only)
误用RTTI(misuse of RTTI)
误用friend(misuse of friend)
误用typeid(misuse of typeid)
混合模式算术(mixed-mode arithmetic)
混合子(mixin)
模型，连接模型(model, linkage)
模型，C++保护模型(model of protection, C++)
模型，保护模型(model, protection)
模型，template编译模型(model, template compilation)
模块化(modularity)
模块结构(module structure)
monitor
多参数重载(multi-argument overloading)
多层错误处理(multi-level error handling)
多层异常传播(multi-level, propagation of exception)
多重方法(multi-method)
多重继承(multiple inheritance)
多重继承，C++(multiple inheritance, C++)
多重继承和Simula(multiple inheritance and Simula)
多重继承和Smalltalk(multiple inheritance and Smalltalk)
多重继承和歧义性(multiple inheritance and ambiguity)
多重继承和异常处理(multiple inheritance and exception handling)
多重继承错误(multiple inheritance bugs)
多重继承的复杂性(multiple inheritance complexity)
多重继承与废料收集(multiple inheritance, garbage collection)
多重继承实现(multiple inheritance implementation)
多重继承的独立性(multiple inheritance, independent)
多重继承的布局(multiple inheritance, layout)
多重继承和名字冲突(multiple inheritance, name clash and)
多重继承的开销(multiple inheritance, overhead)
多重继承和单继承(multiple inheritance, single and)
多重继承的静态检查(multiple inheritance, static checking of)
多重继承工具(multiple inheritance tools)
多重继承的使用(multiple inheritance, use of)
多重继承和虚函数(multiple inheritance, virtual function and)
多重实例化(multiple instantiation)
多重，库的多重使用(multiple, libraries, use of)
多处理器系统(multi-processor system)
多线程(multi-threading)
mutable

名字，C++(name, C++)
名字约束规则(name binding rule)
名字冲突和多重继承(name clashing and multiple inheritance)
名字冲突，全局作用域(name clashes, global scope)
名字编码和名字空间(name encoding, namespace and)
名字编码，标准(name encoding, standard)
名字等价(name equivalence)
名字，全局(name, global)
名字遮蔽(name, hiding of)
名字连接(name linkage)
名字查找(name lookup)
名字查找，ANSI/ISO(name lookup, ANSI/ISO)
名字查找，ARM(name lookup, ARM)
名字查找，template(name lookup, template)
名字压延(name mangling)
名字压延和名字空间(name mangling and namespace)
名字前缀(name prefix)
名字空间污染(name space pollution)
name()
命名参数(named argument)
名字的访问控制(names, access control of)
名字劫持(names hijack)
名字劫持，在template里(names, in template, hijacking of)
名字空间作为template参数(namespace as template argument)
namespace
namespace和Cpp
namespace别名(namespace alias)
namespace和class
namespace和库
namespace，class作为namespace
namespace设计目标(design aims)
namespace，全局(global)
namespace语法(syntax)
namespace，template
namespace，无名的(unnamed)
namespace，using
名字空间和C兼容性(namespaces and C compatibility)
名字空间和名字编码(namespaces and name encoding)
名字空间和名字压延(namespaces and name mangling)
名字空间和版本(namespaces and versioning)
名字空间与标准库(namespaces, in standard library)
名字空间，嵌套(namespaces, nested)
名字空间，开放性(namespaces, open)
名字空间和重载(namespaces, overloading and)
名字空间，转变(namespaces, transition)
命名，在大程序里(naming, in a large program)
命名，在标准库(naming, in standard library)
narrow()
窄转换(narrowing conversion)
窄转换，隐式(narrowing conversion, implicit)
NDEBUG
嵌套class(nested class)
嵌套class，局部化(nested class, locality)
嵌套的名字空间(nested namespace)
嵌套template(nested template)
network_file_error
new，分配和建构函数(allocation and constructor)
new和分配(allocation)
new和建构函数(constructor)
new和malloc()
new处理器(handler)
new运算符(operator)
new()，建构函数(constructor)
new()函数
new[]运算符
new_handler
新风格强制(new-style cast)
noalias
No_free_store
非类型template参数(non-type template argument)
空指针0
NULL 0
Num

对象I/O(object I/O)
对象I/O，实例(object I/O, example of)
对象复制(object, copy of)
对象布局(object layout)
对象布局，带类的C(object layout, C With Classes)
对象，部分构造的(object, partial constructed)
对象，堆栈(object, stack)
对象，静态(object, static)
Object
老代码和异常(old code, exception and)
老风格强制的记法(old style cast notation)
唯一定义规则(one-definition rule)
唯一定义规则和template(one-definition rule and template)
一遍分析(one-pass analysis)
一遍编译(one-pass compilation)
Onfreestore
葱头式设计(onion design)
OOD
OOP
开放的名字空间(open namespace)
操作，不安全的(operations, unsafe)
运算符,(operator ,)
运算符**，指数(operator **, exponentiation)
运算符*^，指数(operator *^, exponentiation)
运算符++，增量(operator ++, increment)
运算符--，减量(operator --, decrement)
运算符->(operator ->)
运算符->*(operator ->*)
运算符.(operator .)
运算符.*(operator .^)
运算符<<(operator <<)
运算符<<，输出(operator <<, output)
运算符=(operator)
运算符复合(operator composite)
运算符默认(operator default)
运算符delete(operator delete)
运算符delete[](operator delete[])
运算符等价(operator equivalence)
运算符函数(operator function)
运算符new(operator new)
运算符new[](operator new[])
运算符重载(operator overloading)
运算符，用户定义优先级(operator, precedence of user-defined)
运算符，private(operator, private)
运算符，禁止(operator, prohibit)
运算符，类型获取(operator, type inquiry)
运算符，类型关系(operator, type relation)
运算符，用户定义(operator, user-defined)
operator delete()
operator delete()，继承(inheritance of)
operator new()
operator new()，继承(inheritance of)
operator new()，返回值(return value)
优化，全局(optimization, global)
优化，手工(optimization, hand)
优化，手工实例化(optimization of instantiation, manual)
优化virtual调用(optimization of virtual call)
优化return值(optimization return value)
优化virtual函数(optimization virtual function)
优化虚表(optimization virtual table)
可选的废料收集(optional garbage collection)
顺序依赖性(order dependence)
顺序依赖性，class成员(order dependencies, class member)
顺序依赖性，迂回处理(order dependence, workaround for)
顺序依赖性和重载(order dependency and overloading)
顺序，初始化(order of initialization)
顺序，成员初始化(order of member initialization)
常规基class(ordinary base class)
正交性(orthogonality)
输出运算符，<<(output operator, <<)
过分约束的参数(over-constrained argument)
溢出和异常(overflow and exception)
开销，Cfront编译时间(overhead, Cfront compile-time)
开销，编译时间(overhead, compile-time)
开销，连接时间(overhead, link-time)
开销，多重继承(overhead, multiple inheritance)
开销，零开销规则(overhead rule, zero)
开销，运行时间(overhead, run-time)
重载，基类和导出(overload, base and derived)77,417
重载，基于enum(overload based on enum)
重载匹配(overload match)
重载解析(overload resolution)
重载解析，细粒度(overload resolution, fine grain)
overload声明(declaration)
重载(overloading)
重载，Algol68引用(overloading, Algol68 references)
重载和Release 2.0(overloading, Release 2.0 and)
重载和char(overloading and char)
重载和class层次结构(overloading and class hierarchy)
重载和const(overloading and const)
重载和转换(overloading and conversion)
重载和默认参数(overloading and default argument)
重载和效率(overloading and efficiency)78,84
重载和float(overloading and float)
重载和继承(overloading and inheritance)
重载和连接(overloading and linkage)232,233
重载和名字空间(overloading and namespace)
重载和转变(overloading and transition)
重载，函数template(overloading, function template)
重载，多参数(overloading, multi-argument)
重载，赋值(overloading of assignment)
重载运算符(overloading operator)
重载和顺序依赖性(overloading, order dependency and)
重载，反对的理由(overloading, reason against)
重载，支持的理由(overloading, reason for)
覆盖和遮蔽(overriding and hiding)
覆盖，放松规则(overriding, relaxation)
过度使用，强制(overuse of cast)
过度使用，继承(overuse of inheritance)

换页和初始化(paging, initialization and)
参数化类型(parameterized type)
参数化类型模板(parameterized type template)
分析C++(parsing C++)
部分构造的对象(partial constructed object)
引用传递(pass-by-reference)
值传递(pass-by-value)
按类分配程序(per-class allocator)
性能(performance)
性能，new(performance, new)
性能，启动(performance, startup)
持续性库(persistence libraries)
持续性符号表(persistence symbol table)
放置(placement)
放置的重要性(placement, importance of)
插入式废料收集(plug-in garbage collection)
指针0，空(pointer 0, null)
指针复制(pointer, copy of)
指针，取代常规(pointer, replace ordinary)
指针语义(pointer semantics)
指针，灵巧(pointer, smart)
指针语法(pointer syntax)
指针this(pointer this)
指针，到数据成员(pointer to data member)
指针，到函数(pointer to function)
指针，到函数的指针和强制(pointer to function, cast and)
指针，到函数的指针和连接(pointer to function linkage)
指针，到成员(pointer to member)
指针和非指针(pointers and non-pointers)
指针和引用(pointers and references)
指针，受限的(pointer restricted)
临时量的析构点，选择(points of destruction of temporary, alternative)
污染名字空间(pollution, name space)
多态类型(polymorphic type)
可移植性(portability)
移植问题(porting problems)
#pragma
#pragma，template实例化(instantiation)
用户定义类型的优先级(precedence of user-defined operator)
printf, C I/O
私用，默认(private, default)
private
private，强制到基类(base, cast to)
private，继承的实现(implementation inheritance)
private运算符(operator)
private，public
特权(privileges)
程序，可维护性(program, maintainable))
程序组织(program organization)
程序可靠性(program, reliable)
程序设计，C++和类属(programming, C++ and generic)
程序设计，C++和面向对象(programming, C++ and object-oriented)
程序设计语言(programming language)
程序设计，低级(programming, low-level)
程序设计规则，低级(programming rules, low-level)
禁止auto分配(prohibit auto allocation)
禁止复制(prohibit copy)
禁止导出(prohibit derivation)
禁止自由存储分配(prohibit free store allocation)
禁止全局分配(prohibit global allocation)
禁止运算符(prohibit operator)
禁止static分配(prohibit static allocation)
提升，整数(promotions, integral)
protected
protected成员(member)
保护，C++保护模型(protection, C++ model of)
保护界限，越过(protection barrier, crossing)
保护，class，单位(protection, class unit of)
保护模型(protection model)
Ptr
public
public，继承的界面(interface inheritance)
public，private
public:
纯virtual函数(pure virtual function)
pvector

量化(qualification)
量化::，显式(qualification ::, explicit)
量化，显式(qualification, explicit)
queue

raise
原始存储(raw memory)
只读存储器(read-only memory)
重新编译(recompilation)
重新编译和异常(recompilation, exception and)
重新编译，virtual函数(recompilation, virtual function)
递归下降分析器(recursive descent parser)
重定义规则(redefinition rule)
语法中的冗余(redundancy in syntax)
引用(reference)
引用，约束(reference, binding of)
引用，return类型(reference, return type)
引用语义(reference semantics)
引用，this(reference, this)
引用，const(reference, const)
引用和指针(reference, pointer and)
引用，灵巧(reference, smart)
RefNum
reinterpret_cast
reinterpret_cast和static_cast
关系运算符，类型(relation operator, type)
模板间的关系(relationships between template)
放松参数规则(relaxation of argument rules)
放松重载(relaxation of overloading)
Release 1.0
Release 1.0缺陷，C++
Release 1.0特征，C++
Release 1.1
Release 1.2
Release 1.3
Release 2.0
Release 2.0 =
Release 2.0和存储管理(and memory management)
Release 2.0和重载(and overloading)
Release 2.0事件(events)
Release 2.0特征(features)
Release 2.1
Release 3.0
Release E
可靠性和异常(reliability, exception and)
重新命名(renaming)
重排规则(reordering rule)
取代常规指针(replace ordinary pointer)
重复的虚函数表(replicated virtual function table)
重复代码(replication, code)
陈列台，template(repository, template)
表示，遮蔽的表示(representation, hiding of)
表示，对象的表示(representation of object)
解析，重载(resolution, overloading)
资源获取，初始化(resource acquisition, initialization)
资源管理(resource management)
资源管理和异常(resource management, exception and)
资源需求，Cfront(resource requirement, Cfront)
restrict
受限指针(restricted pointer)
限制，特殊化(restriction, specialization)
唤醒，论据(resumption, arguments)
唤醒语义(resumption semantics)
唤醒和终止(resumption, termination vs.)
唤醒，迂回方法(resumption, workaround for)
返回值优化(return value optimization)
return类型(type)
return类型，引用(type, reference)
return值，operator new()
return值优化(value optimization)
ROM
根class(root class)
根class，统一的(root class, universal)
RTTI和强制
RTTI和库(library)
RTTI和标准化(standardization)
RTTI设计选择(design, alternative)
RTTI例子(example of)
RTTI实现复杂性(implementation complexity)
RTTI，布局(layout)
RTTI误用(misuse)
RTTI问题(problem)
RTTI的使用(use of)
规则，交叉(rule, intersect)
规则，名字约束(rule, name binding)
规则，唯一定义(rule, one definition)
规则，重新考虑(rule, reconsideration)
规则，重新定义(rule, redefinition)
规则，重新排序(rule, reordering)
规则，重写(rule, rewrite)
规则，特殊化(rule, specialization)
规则，两周(rule, two weeks)
规则，零开销(rule, zero overhead)
规则，设计支持(rules, design support)
规则，一般(rules, general)
规则，语言设计(rules, language design)
规则，语言技术(rule, language-technical)
规则，低级程序设计(rule, low-level programming)
运行时参数检查(run-time argument checking)
运行时检查(run-time checking)29,42
运行时，检查的初始化(run-time, checked initialization)
运行时效率(run-time efficiency)
运行时保证(run-time guarantees)
运行时初始化(run-time initialization)
运行时初始化，问题(run-time initialization, problems with)
运行时开销(run-time overhead)
运行时支持，带类的C(run-time support, C With Classes)
运行时支持，最小化(run-time, minimal)
运行时类型信息(run-time type information)
运行时类型信息和库(run-time type information and library)
运行时类型获取(run-time type inquire)
右值和左值(rvalue, lvalue vs.)

安全强制(safe cast)
安全转换(safe conversion)
安全性和异常，类型(safety and exception, type)
安全性和类型安全性(safety and type safety)
安全性和兼容性(safety, compatibility vs.)
安全性和方便性(safety, convenience vs.)
科学计算(scientific computing)
作用域和Cpp(scope, Cpp and)
作用域，全局(scope, global)
作用域，名字冲突，全局(scope, name clashes, global)
作用域，半透明(scope, semi-transparent)
Season
自赋值(self-assignment)
语义，C(semantics, C)
语义，指针(semantics, pointer)
语义，引用(semantics, reference)
语义，唤醒(semantics, resumption)
语义，终止(semantics, termination)
语义，值(semantics, value)
半透明作用域(semi-transparent scope)
分别编译(separate compilation)
事件序列(sequence of events)
Shape*的Set
set
set_new_handler
set_new_handler()
浅复制(shallow copy)
Shape, intersect
shape
Shape*
短namespace名字(short namespace name)
兄弟class(sibling)
兄弟类间的通讯(siblings, communication between)
signal
信号(signals)
单和多重继承(single and multiple inheritance)
单精度浮点数(single precision floating point)
单根层次结构(single-rooted hierarchy)
size_t
切片(slicing)
slist_set
灵巧指针(smart pointer)
灵巧引用(smart reference)
sort()
排序(sorting)
源程序，C++(source, C++)
源代码里的名字(source code names)
源程序，控制和template(source, control and template)
源程序文件(source file)
源程序文件和template(source file and template)
源程序正文，合法(source text, legal)
特殊地址(special address)
特殊存储器(special memory)
特殊化声明(specialization declaration)
特殊化，模板(specialization of template)
特殊化限制(specialization restriction)
特殊化规则(specialization rule)
描述，异常(specification, exception)
stack
标准组件库(Standard components library)
标准，ANSI C++(standard, ANSI C++)
标准关联数组(standard associative array)
标准调用序列(standard calling sequences)
标准容器(standard containers)
标准废料收集(standard garbage collection)
标准指令集合(standard instruction set)
标准遍历器(standard iterators)
标准库(standard library)
标准库，ANSI(standard library, ANSI)
标准库，ISO(standard library, ISO)
标准库，缺乏(standard library, missing)
标准库中的名字空间(standard library, namespace in)
标准库中的名字(standard library, names in)
标准链表(standard list)
标准映射(standard map)
标准名字编码(standard name encoding)
标准数值库(standard numerical library)
标准向量(standard vector)
标准virtual表布局(standard virtual table layout)
标准是什么(standard, what is a)
标准化，ISO C++(standardization, ISO C++)
标准化和RTTI(standardization, RTTI and)
标准化的目标(standardization, aims of)130,135
静态和动态类型检查(static and dynamic type checking)
静态异常检查(static checking of exceptions)
静态检查多重继承(static checking of multiple inheritance)
静态初始化(static initialization)
静态对象(static object)
静态存储(static storage)32,56
静态类型检查(static type checking)
静态类型检查，带类的C(static type checking, C With Classes)
静态类型检查，C++(static type checking, C++)
静态类型检查和设计(static type checking and design)
静态类型检查和库(static type checking, libraries and)
静态类型系统(static type system)
static分配，禁止(allocation, prohibit)
static，贬低全局(deprecated global)
static成员和访问控制(member, access control and)
static成员函数(member function)
静态检查的界面(statically checked interfaces)
static_cast
static_cast和const
static_cast和dynamic_cast
static_cast和隐式转换(and implicit conversion)
static_cast和reinterpret_cast
stdin，初始化(initialization of)
stdio.h
stdout，初始化(initialization of)
STL
存储，自动(storage, automatic)
存储，类(storage, class)
存储，动态(storage, dynamic)32,56
存储，自由(storage, free)32,56
存储，堆(storage, heap)
存储，栈(storage, stack)
存储，静态(storage, static)32,56
流I/O(stream I/O)
流I/O，C++(stream I/O, C++)
流I/O库(stream I/O library)
String
string
string类(class)
strtok()
struct和class
结构等价(structure equivalence)
结构标志(structure tag)
风格，仅初始化(style, initialize-only)
风格，混合(style, hybrid)
风格，设计风格(style of design)
sum()
支持并行性(support concurrency)
支持，对库的支持(support for libraries)
支持，语言对库的支持(support for libraries, language)
支持库(support library)
支持，设计支持规则(support rules, design)
开关，基于类型(switch on type)
开关，基于类型域(switch on type field)
符号表，持续性(symbol table, persistent)
符号表，Cfront(symbol table, Cfront)
同义词(synonym)
同义词问题(synonym, problem with)
语法(syntax)
语法，<...>(syntax, <...>)
语法，=0(syntax, =0)
语法，template的>>问题(syntax, >> problem with template)
语法，C声明(syntax, C declaration)
语法，template的选择(syntax, alternative template)
语法，强制(syntax, cast)
语法，异常处理(syntax, exception handling)
语法的重要性(syntax, important of)
语法，初始式(syntax, initializer)
语法，namespace(syntax, namespace)
语法，dynamic_cast(syntax of dynamic_cast)
语法，指针(syntax, pointer)
语法，template(syntax, template)
语法，类型安全的连接(syntax, type-safe linkage)
语法，类型系统，C++(syntax, type system, C++)
系统，大系统和异常(system, and exception, large)
系统和语言实现(system and language implementation)
系统，容错系统设计(system, design of fault-tolerant)
系统，嵌入式(system, embedded)
系统和语言(system, language and)
系统，大系统(system, large)
系统，库和类型系统(system, libraries and type)
系统，混合(system, mixed)

标志，结构(tag, structure)
目标语言，C++作为(target language, C++ as a)
作业的例子(task example)
作业库(task library)
技术和语言特征(techniques, language features and)
技术，template复合(techniques, template composition)
模板，Container(template, Container)
模板，条件里的模板(template, conditional in)
模板的使用(template, use of)
template和.c文件(.c file and)
template和.h文件(.h file and)
template中的歧义性(ambiguity in)
template和抽象class(and abstract class)
template和内部类型(and built-in type)
template和class
template和建构函数(and constructor)
template和异常(and exceptions)
template和inline
template和布局(and layout)
template和库设计(and library design)
template和virtual函数(and virtual function)
template参数，约束(argument, constraint on)
template参数推断(argument, deducing)
template参数，依赖于(argument, depend on)
template参数，显式(argument, explicit)
template参数，函数(argument, function)
template参数，名字空间作为(argument, namespace as)
template参数，非类型(argument, non-type)
template数组(array)
template作为template参数(as template argument)
template class
template，编译模型(compilation model)
template和编译时间(compile-time and)
template complex
template，组合技术
template和容器类(container class and)
template和转换(conversion and)
template定义的上下文(definition, context of)
template定义，查寻(definition, finding)
template，双重发送(double dispatch)
template的错误检查(error checking of)
template例子，成员模板(example, member)
template函数(function)
template实现，Cfront(implementation, Cfront)
template实现和继承(implementation and inheritance)
template实现经验(implementation experience)
template实现的遮蔽(implementation, hiding of)
template实现问题(implementation problem)
template里的隐式使用(implicit use in)
template实例化#pragma(instantiation #pragma)
template实例化，自动(instantiation, automatic)
template实例化的上下文(instantiation, context of)
template实例化指示符(instantiation directive)
template实例化，显式(instantiation, explicit)
template关键字(keyword)
template和连接时间(link-time and)
template成员(member)
template名字查寻(name lookup)
template namespace
template嵌套(nested)
template和唯一定义规则(one-definition rule and)
template重载，函数(overloading, function)
template，参数化类型(parameterized type)
template展示台(repository)
template和源代码控制(source control and)
template语法(syntax)
template语法，>>问题(syntax, >> problem with)
template语法，选择(syntax, alternative)
template typedef
template使用经验(use experience)
template vector
template，virtual函数(virtual function)
模板设计准则(templates, design criteria for)
模板之间的关系(template, relationship between)
临时量删除(temporaries, elimination of)
临时量的生存期(temporaries, lifetime of)
临时量其他可能的析构点(temporaries, alternative points of destruction of)
terminate()
终止的论据(termination, argument)
终止语义(termination semantics)
终止和唤醒(termination vs. resumption)
this和块(and trunk)
this赋值(assignment to)
this指针(pointer)
this引用(reference)
throw
转变(transition)
转变和使用指示(transition and using directive)
转变和重载(transition, overloading and)
转变路径(transition path)
转变到名字空间(transition to namespace)
转变到新强制(transition to new cast)
翻译限制(translation limits)
翻译单元(translation, unit of)
真正的局部变量(true local variable)
true 1
try
存储管理的调整(tuning of memory management)
两周规则(two week rule)
类型，抽象(type, abstract)
类型bool，布尔(type bool, Boolean)
类型，强制和不完全(type, cast and incomplete)
类型检查，默认(type checked, default)
类型检查，带类的C，静态(type checking, C With Classes static)
类型检查，C++(type checking, C++)
类型检查，C++静态(type checking, C++ static)
类型检查和设计，静态(type checking and design, static)
类型检查，编译时间(type checking, compile-time)
类型检查和设计(type checking, design and)
类型检查，库和静态检查(type checking, libraries and static)
类型检查，静态(type checking, static)
类型检查，静态和动态(type checking, static and dynamic)
类型，class作为用户定义类型(type, class as user-defined)
类型，内部类型的建构函数(type, constructor for build-in)
类型，由内部类型导出(type, derivation from build-in)
类型，内部类型的析构函数(type, destructor for build-in)
类型编码(type encoding)
类型enum(type enum)
类型域，显式(type field, field)
类型域，基于类型域的开关(type field, switch on)
类型标识(type identity)
类型信息和库，运行时(type information and library, run-time)
类型信息，扩充的(type information, extended)
类型信息，运行时(type information, run-time)
类型查询，编译时(type inquiry, compile-time)
类型查询运算符(type inquiry operator)
类型查询，运行时(type inquiry, run-time)
类型，char常量的类型(type of char constant)
类型，char字面量的类型(type of char literal)
类型，参数化类型(type, parameterized)
类型，多态(type, polymorphic)
类型，返回引用(type, reference return)
类型，return(type, return)
类型安全性和异常(type safety and exceptions)
类型安全性(type safety)
类型，基于类型的开关(type, switch on)
类型系统(type system)
类型系统和库(type system, library)
类型系统，静态(type system, static)
类型，template，参数化(type, template, parameterized)
类型违背(type violation)
typedef
typedef, template
typeid
typeid的误用(misuse of)
typeid的使用(use of)
type_info
类型安全的I/O(type-safe I/O)
类型安全的连接(type-safe linkage)
类型安全连接的问题(type-safe linkage problem)
类型安全连接的语法(type-safe linkage syntax)
类型系统，C++语法(type system, C++ syntax)

丑陋的C特征(ugly C features)
无约束的方法(unconstrained method)
无定义函数，调用(undefined function, call of)
unexpected()
unicode字符集(character set)
未初始化变量(uninitialized variables)
union
统一的根class(universal root class)
无名的namespace(unnamed namespace)
不安全运算符(unsafe operators)
Usable
Usable_lock
使用和误用(use and misuse)
使用的复杂性(use, complexity of)
使用，通过使用约束(use, constraint through)
使用RTTI(use of RTTI)
使用dynamic_cast(use of dynamic_cast)
使用多重继承(use multiple inheritance)
使用模板(use template)
使用typeid(use typeid)
用户定义类型和内部类型(user-defined and build-in type)
用户定义运算符(user-defined operator)
用户定义运算符的优先级(user-defined operator, precedence of)
用户定义类型，class是(user-defined type, class is)
using namespace 404,407,411
使用声明(using-declaration)
使用声明和访问指示(using-declaration, access declaration and)
使用声明调整访问(using-declaration adjusting access)
使用声明和使用指示(using-declaration vs. using-directive)
使用指示(using-directive)
使用指示和转变(using-directive, transition and)
使用指示和使用声明(using-directive, using declaration vs.)

值，赋值的值(value of assignment)
值语义(value semantics)
变量，全局(variable, global)
变量，局部(variable, local)
变量，真正局部的变量(variables, true local)
变量，未初始化的(variables, uninitialized)
vec
向量，标准(vector, standard)
向量，template(vector, template)
vector
虚基，从虚基强制(virtual base, cast from)
虚基class(virtual base class)
虚基布局(virtual base layout)
虚，在建构函数里调用(virtual call in constructor)
虚复制(virtual copy)
虚数据(virtual data)
虚析构函数(virtual distructor)
虚函数(virtual function)
虚函数效率(virtual function efficiency)
虚函数实现(virtual function implementation)
虚函数和布局(virtual function, layout and)
虚函数优化(virtual function optimization)
虚函数指针(virtual function pointer)
虚函数，纯(virtual function, pure)
虚函数重新编译(virtual function recompilation)
虚函数表(virtual function table)
虚函数和template(virtual function, template and)
虚成员template(virtual member template)
虚表布局(virtual table layout)
可见性和访问(visibility, access vs.)
void*
void*赋值(assignment)
void*，由void*强制(cast from)
void*，转换到(conversion to)
volatile, ANSI C
vptr
vtbl

警告(warning)
包装性的设计(warped design)
wchar_t
window
迂回做法，对多重方法(workaround for multi-method)
迂回做法，对唤醒(workaround for resumption)
迂回做法，对关键词参数(workaround keyword argument)
迂回做法，对顺序依赖性(workaround for order dependencies)
包装类(wrappers)
writeonly
wstring

零开销规则(zero overhead rule)