索引

索引排序:以数字和符号开头的索引项;以拉丁字母开头的索引项;以中文字开头的索引项(按照汉语拼音顺序排列)。由于原书索引太多(近40页),这里做了一些删节整理。
 

数字与符号

--,减量运算符(decrement operator)

--,前缀和后缀(prefix and postfix)

->和委托(delegation and)

->运算符(operator)

->*运算符

.::

.运算符

.*运算符

...,省略(ellipsis)

//C兼容性(and C compatibility)

::显式量化(explicit qualification)

::.

<...>语法(syntax)

<<运算符

=运算符

>>template语法的问题(problem with template syntax)

0NULL

0false

0,空指针

=0语法

1true
 

A

Ada语言

Algol68的声明(Algol68 declaration)

Algol68引用(Algol68 references)

Algol68引用重载(Algol68 references overloading)

Algol68语言

Algol68运算符(Algol68 operators)

ANSI C局部静态数组

ANSI C volatile

ANSI C 标准库(ANSI C standard library)

ANSI C 语法(ANSI C grammar)

ANSI C++ 标准(ANSI C++ standard)

ANSI/ISO名字查找(ANSI/ISO name lookup)

ARM参考手册(ARM reference manual)

ARM名字查找(ARM name lookup)

ARM特征(ARM features)

assert()

Assert()
 

B

bad_cast

basic_string

bit<N>

bitstring

Booch组件(Booch components)

Booch组件库(Booch components library)

bool,布尔类型(Boolean type)

Buffer
 

C

C enum

C I/O

C++ Release 1.0特征(C++ Release 1.0 features)

C++保护模型(C++ model of protection)

C++程序设计环境(C++ programming environment)

C++的较好的C子集(better C subset of C++)

C++的逐步途径(C++ gradual approach to)

C++Ada

C++C

C++ const,和C

C++C的兼容性(compatibility, C and)

C++Fortran

C++Simula

C++Smalltalk

C++和汇编语言(C++ and assembler)

C++和类属程序设计(C++ and generic programming)

C++和面向对象的程序设计(C++ and object-oriented programming)

C++和其他语言(C++ and other languages)

C++和数据抽象(C++ and data abstraction)

C++静态类型检查(C++ static type checking)

C++(C++ libraries)

C++类型检查(C++ type checking)

C++连接(C++ linkage)

C++I/O(C++ stream I/O)

C++名字(C++ name)

C++设计(design of C++)

C++特征(C++ features)

C++语法类型系统(C++ syntax type-system)

C++异常处理的想法(exception handling, ideals of)

C++作为目标语言(C++ as a target language)

C++作为实现语言(C++ as an implementation language)

C++作为通用程序设计语言(C++, general-purpose programming language)

catch

cerr

Cfront

Cfront template

Cfront template实现(Cfront template implementation)

Cfrontnew的实现(Cfront implementation of new)

Cfront编译时代价(Cfront compile-time overhead)

Cfront存储使用(Cfront memory use)

Cfront代码质量(Cfront code quality)

Cfront的符号表(Cfront symbol tables)

Cfront的规模(size of Cfront)

Cfront结构(structure of Cfront)

Cfront虚表的布局(Cfront virtual table layout)

Cfront资源需求(Cfront resource requirements)

char_ref

charint

char和重载(and overloading)

char类型的常量(constant, type of char)

char类型的文字(literal, type of char)

cin的初始化(initialization of)

class, Simula

class, Simula风格(Simula style)

class, 保护的单位(unit of protection)

class, 统一的根(universal root)

classtemplate

classvirtual(virtual base)

class,常规基(ordinary base)

class,派生(derived)

class,局部嵌套(locality nested)

class,嵌套(nested)

class成员(member)

class成员顺序依赖性(member order dependencies)

class分层结构(hierarchy)

class分层结构的合并(merging of hierarchies)

class分层结构和重载(hierarchy and overloading)

class概念(concept)

class(root)

classnamespace

classstruct

classtemplate

classtemplate,容器(and template, container)

class和宏,容器(and macro, container)

class是用户定义类型(is user-defined type)

class作为namespace(as namespace)

clone()

CLOS

Clu

Clu风格的容器(Clu-style container)

CMP

complex

complex template

complex(library)

constCpp

const和重载(and overloading)

const,为描述界面使用(for specifying interface)

const_cast

constraints

const成员初始式(const member initializer)

const成员函数(member function)

const的初始化(initialization of)

const作为符号常量(as symbolic constant)

Container模板(Container template)

Controlled_container

copy()

cout

cout的初始化(initialization of)

Cpp

C变量(C variables)

C错误处理(C error handling)

C代码,生成的(C code generated)

CC++

CC++连接(C and C++ linkage)

C兼容性(C compatibility)

C兼容性,100%(C compatibility, 100%)

C兼容性和//(C compatibility, and //)

C兼容性和名字空间(C compatibility and namespace)

C兼容性和转换(C compatibility and conversion)

C扩充(C extensions)

C连接(C linkage)

C声明的语法(C declaration syntax)

C数值(C numerical)

C特征,肮脏的(C features, ugly)

C特征,危险的(C features, dangerous)

C优点和缺点(C, advantages and disadvantages)

CC++兼容性(C and C++ compatibility)

C语言,和异常(C, and exceptions)

C语言的问题(problems with C)

C语义(C semantics)

C预处理器(C preprocessor)

C预处理器Cpp(C preprocessor Cpp)
 

D

DAG,支配(DAG, dominance)

#define

delete

delete, free()

delete和释放(and deallocation)

delete和析构函数(and destructor)

delete运算符(operator)

dialog_box

displayed

doublefloat

dynamic_cast

dynamic_cast的使用

dynamic_cast的语法

dynamic_caststatic_cast

dynarray
 

E

employee

enum, C

enum,基于enum的重载(overloading based on)

enum类型

explicit
 

F

false 0

Fig

FilePtr

floatdouble

float和重载(overloading and)

fopen()

for语句中的声明(for-statement, declaration in)

free()delete

friend,错误使用(misuse)

friend和成员(and member)

friend和封装(encapsulation and)
 

G

GDB_root

grab_X()
 

H

Hchar

histogram

.h文件和template
 

I

I/O, Ada

I/O, C

I/O, C++(I/O, C++ stream)

I/O, printf, C

I/O,对象(I/O, object)

I/O,对象I/O的实例(I/O, example of objects)

I/O,简洁(I/O, terse)

I/O,可扩充(I/O, extensible)

I/O,扩展字符集(I/O of extended character set)

I/O,类型安全(I/O, type-safe)

I/O库,流(I/O library, stream)

I/O(I/O stream)

if替代#ifdef(if alternative to #ifdef)

#ifdef

include替代#include(alternative to #include)

#include

inherited

inline成员函数(member function)

inline关键字(keyword)

inline函数(function)

inlineCpp

inlinetemplate(inline, template and)

intersect Shape

intchar

io

io_counter

io_obj

iocircle

iostream
 

L

link

list
 

M

malloc()new

Map

Matherr

Matrix,效率(efficient)

monitor

mutable
 

N

name()

namespace

namespaceclass作为namespace

namespacetemplate

namespaceusing

namespace,全局(global)

namespace,无名的(unnamed)

namespace别名(alias)

namespaceclass

namespaceCpp

namespace和库

namespace设计目标(design aims)

namespace语法(syntax)

narrow()

NDEBUG

network_file_error

new(),建构函数(constructor)

new()函数

new,分配和建构函数(allocation and constructor)

new[]运算符

new_handler

new处理器(handler)

newmalloc()

new和分配(allocation)

new和建构函数(constructor)

new运算符(operator)

No_free_store

noalias

NULL 0

Num
 

O

Object

Onfreestore

OOD

OOP

operator delete()

operator delete(),继承(inheritance of)

operator new()

operator new(),返回值(return value)

operator new(),继承(inheritance of)

overload声明(declaration)
 

P

#pragma

#pragmatemplate实例化(instantiation)

printf, C I/O

private

privatepublic

private,继承的实现(implementation inheritance)

private,强制到基类(base, cast to)

private运算符(operator)

protected

protected成员(member)

Ptr

public

publicprivate

public,继承的界面(interface inheritance)

public:

pvector
 

Q

queue
 

R

raise

RefNum

reinterpret_cast

reinterpret_caststatic_cast

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

restrict

return类型(type)

return类型,引用(type, reference)

return值,operator new()

return值优化(value optimization)

ROM

RTTI,布局(layout)

RTTI的使用(use of)

RTTI和强制

RTTI和标准化(standardization)

RTTI和库(library)

RTTI例子(example of)

RTTI设计选择(design, alternative)

RTTI实现复杂性(implementation complexity)

RTTI问题(problem)

RTTI误用(misuse)
 

S

Season

set

set_new_handler

set_new_handler()

shape

Shape*

Shape*Set

Shapeintersect

signal

size_t

slist_set

sort()

stack

static,贬低全局(deprecated global)

static_cast

static_castconst

static_castdynamic_cast

static_castreinterpret_cast

static_cast和隐式转换(and implicit conversion)

static成员函数(member function)

static成员和访问控制(member, access control and)

static分配,禁止(allocation, prohibit)

stdin,初始化(initialization of)

stdio.h

stdout,初始化(initialization of)

STL

string

String

string(class)

string(string class)

strtok()

structclass

sum()
 

T

template class

template complex

template namespace

template typedef

template vector

templatevirtual函数(function)

template,编译模型(compilation model)

template,参数化类型(parameterized type)

template,双重发送(double dispatch)

template,组合技术

template参数,非类型(argument, non-type)

template参数,函数(argument, function)

template参数,名字空间作为(argument, namespace as)

template参数,显式(argument, explicit)

template参数,依赖于(argument, depend on)

template参数,约束(argument, constraint on)

template参数推断(argument, deducing)

template成员(member)

template的错误检查(error checking of)

template定义,查寻(definition, finding)

template定义的上下文(definition, context of)

template关键字(keyword)

template函数(function)

template.c文件(.c file and)

template.h文件(.h file and)

templateclass

templateinline

templatevirtual函数(function)

template和编译时间(compile-time and)

template和布局(and layout)

template和抽象class(and abstract class)

template和建构函数(and constructor)

template和库设计(and library design)

template和连接时间(link-time and)

template和内部类型(and built-in type)

template和容器类(container class and)

template和唯一定义规则(one-definition rule and)

template和异常(and exceptions)

template和源代码控制(source control and)

template和转换(conversion and)

template里的名字劫持(hijacking of name in)

template里的隐式使用(implicit use in)

template例子,成员模板(example, member)

template名字查寻(name lookup)

template嵌套(nested)

template实例化#pragma(instantiation #pragma)

template实例化,显式(instantiation, explicit)

template实例化,自动(instantiation, automatic)

template实例化的上下文(instantiation, context of)

template实例化指示符(instantiation directive)

template实现,Cfront(implementation, Cfront)

template实现的遮蔽(implementation, hiding of)

template实现和继承(implementation and inheritance)

template实现经验(implementation experience)

template实现问题(implementation problem)

template使用经验(use experience)

template数组(array)

template语法(syntax)

template语法,>>问题(syntax, >> problem with)

template语法,选择(syntax, alternative)

template展示台(repository)

template中的歧义性(ambiguity in)

template重载,函数(overloading, function)

template作为template的参数(as template argument)

terminate()

this赋值(assignment to)

this和块(and trunk)

this引用(reference)

this指针(pointer)

throw

true 1

try

type_info

typedef

typedeftemplate

typeid

typeid的误用(misuse of)

typeid的使用(use of)
 

U

unexpected()

unicode字符集(character set)

union

Usable

Usable_lock

using namespace 404,407,411
 

V

vec

vector

virtual的调用优化(call optimization of)

void*

void*,由void*强制(cast from)

void*,转换到void* (conversion to)

void*赋值(assignment)

volatile, ANSI C

vptr

vtbl
 

W

wchar_t

window

writeonly

wstring

汉字开头的索引项
 

A

安全强制(safe cast)

安全性和方便性(safety, convenience vs.)

安全性和兼容性(safety, compatibility vs.)

安全性和类型安全性(safety and type safety)

安全性和异常,类型(safety and exception, type)

安全转换(safe conversion)

按类分配程序(per-class allocator)

按成员复制(memberwise copy)

按位复制(bitwise copy)
 

B

半透明作用域(semi-transparent scope)

包装类(wrappers)

包装性的设计(warped design)

保护,C++保护模型(protection, C++ model of)

保护,class,单位(protection, class unit of)

保护界限,越过(protection barrier, crossing)

保护模型(protection model)

保守性废料收集(conservative garbage collection)

编码,低级(coding, low-level)

编译,分别(compilation, separate)

编译程序复杂性(compiler complexity)

编译模型,template(compilation model, template)

编译时间保护(compile-time protection)

编译时间和template(compile-time and template)

编译时间开销(compile-time overhead)

编译时间类型查询(compile-time type inquiry)

编译时间类型检查(compile-time type checking)

变量,局部(variable, local)

变量,全局(variable, global)

变量,未初始化的(variables, uninitialized)

变量,真正局部的变量(variables, true local)

标志,结构(tag, structure)

标准,ANSI C++(standard, ANSI C++)

标准virtual表布局(standard virtual table layout)

标准遍历器(standard iterators)

标准调用序列(standard calling sequences)

标准废料收集(standard garbage collection)

标准关联数组(standard associative array)

标准化,ISO C++(standardization, ISO C++)

标准化的目标(standardization, aims of)130,135

标准化和RTTI(standardization, RTTI and)

标准库(standard library)

标准库,ANSI(standard library, ANSI)

标准库,ISO(standard library, ISO)

标准库,缺乏(standard library, missing)

标准库中的名字(standard library, names in)

标准库中的名字空间(standard library, namespace in)

标准链表(standard list)

标准名字编码(standard name encoding)

标准容器(standard containers)

标准是什么(standard, what is a)

标准数值库(standard numerical library)

标准算法(standard algorithms)

标准向量(standard vector)

标准映射(standard map)

标准指令集合(standard instruction set)

标准组件库(Standard components library)

表示,对象的表示(representation of object)

表示,遮蔽的表示(representation, hiding of)

别名,名字空间(alias, namespace)

别名问题(alias, problems with)

并行性(concurrency)

并行性和异常(concurrency and exceptions)

并行性支持(concurrency, supporting)

不安全运算符(unsafe operators)

不完全类型和强制(incomplete type, cast and)

布局,Cfront虚表(layout, Cfront virtual table)

布局,virtual基类(layout, virtual base)

布局,标准virtual(layout, standard virtual table)

布局,带类的C对象(layout, C With Classes object)

布局,派生类(layout, derived class)

布局,对象(layout, object)

布局,多重继承(layout, multiple inheritance)

布局和template(layout, template and)

布局和异常(layout, exception and)

布局兼容性,带类的C(layout compatibility, C With Classes)

部分构造的对象(partial constructed object)
 

C

参数,template作为template参数(argument, template as template)

参数,非类型template参数(argument, non-type template)

参数,关键字(argument, keyword)

参数,过分约束(argument, over-constrained)

参数,函数template(argument, function template)

参数,名字空间作为template参数(argument, namespace as template)

参数,命名(argument, named)

参数,默认(argument, default)

参数,显式template参数(argument, explicit template)

参数,依赖于template(argument, depend on template)

参数的平均数目(arguments, average number of)

参数的推断,template(argument deducing, template)

参数的值(argument, value of)

参数规则,放松(argument rules, relaxation of)

参数化类型(parameterized type)

参数化类型模板(parameterized type template)

参数检查,运行时(argument check, run time)

参数名(argument names)

参数匹配规则(argument matching rules)

参数约束,对模板(argument constraint on template)

操作,不安全的(operations, unsafe)

层次结构,class(hierarchy, class)

层次结构,单根的(hierarchy, single-rooted)

层次结构,异常和class(hierarchy, exception and class)

插入式废料收集(plug-in garbage collection)

查询,编译时类型信息(inquiry, compile-time type)

查找ANSI/ISO名字(lookup ANSI/ISO name)

查找ARM名字(lookup ARM name)

查找template名字(lookup template name)

查找名字(lookup name)

常规基class(ordinary base class)

陈列台,template(repository, template)

成员,class(member, class)

成员,protected(member, protected)

成员,template(member, template)

成员,templatevirtual(member, template, virtual)

成员,template例子(member, template example)

成员,访问控制和static成员(member, access control and static)

成员,类成员的向前引用(member, forward reference of class)

成员,遮蔽基(member, hiding base)

成员,指针指向(member, pointer to)

成员,指针指向数据成员(member, pointer to data)

成员初始化顺序(member initialization, order of)

成员初始式(member initializer)

成员初始式, const(member initializer, const)

成员函数(member, function)

成员函数,const(member function, const)

成员函数,inline(member function, inline)

成员函数,static(member function, static)

成员函数,方法(member function, method)

成员函数,实现(member function, implementation)

成员和friend(member, friend and)

成员顺序依赖性,class(member order dependencies, class)

程序,可维护性(program, maintainable)

程序可靠性(program, reliable)

程序设计,C++和类属(programming, C++ and generic)

程序设计,C++和面向对象(programming, C++ and object-oriented)

程序设计,低级(programming, low-level)

程序设计规则,低级(programming rules, low-level)

程序设计语言(programming language)

程序组织(program organization)

持续性符号表(persistence symbol table)

持续性库(persistence libraries)

重复代码(replication, code)

重复的虚函数表(replicated virtual function table)

重排规则(reordering rule)

重新编译(recompilation)

重新编译,virtual函数(recompilation, virtual function)

重新编译和异常(recompilation, exception and)

重新命名(renaming)

重载(overloading)

重载,Algol68引用(overloading, Algol68 references)

重载,多参数(overloading, multi-argument)

重载,反对的理由(overloading, reason against)

重载,赋值(overloading of assignment)

重载,函数template(overloading, function template)

重载,基类和派生(overload, base and derived)77,417

重载,基于enum(overload based on enum)

重载,支持的理由(overloading, reason for)

重载和char(overloading and char)

重载和class层次结构(overloading and class hierarchy)

重载和const(overloading and const)

重载和float(overloading and float)

重载和Release 2.0(overloading, Release 2.0 and)

重载和继承(overloading and inheritance)

重载和连接(overloading and linkage)232,233

重载和名字空间(overloading and namespace)

重载和默认参数(overloading and default argument)

重载和顺序依赖性(overloading, order dependency and)

重载和效率(overloading and efficiency)78,84

重载和转变(overloading and transition)

重载和转换(overloading and conversion)

重载解析(overload resolution)

重载解析,细粒度(overload resolution, fine grain)

重载匹配(overload match)

重载运算符(overloading operator)

抽象,C++和数据(abstraction, C++ and data)

抽象class(abstract class)

抽象classtemplate(abstract class, and template)

抽象class和库(abstract class and library)

抽象templateclass(abstract template and class)

抽象类型(abstract type)

丑陋的C特征(ugly C features)

初始化,Simula(initialization, Simula)

初始化,成员的初始化顺序(initialization, order of member)

初始化,动态(initialization, dynamic)

初始化,静态(initialization, static)

初始化,库(initialization, library)

初始化,运行时(initialization, run-time)

初始化,运行时的问题(initialization, problem with run-time)

初始化,运行时检查的(initialization, run-time checked)

初始化,资源请求(initialization, resource acquisition)

初始化cin(initialization of cin)

初始化const(initialization of const)

初始化cout(initialization of cout)

初始化stdin(initialization of stdin)

初始化stdout(initialization of stdout)

初始化和分配(initialization, allocation and)

初始化和赋值(initialization and assignment)

初始化和换页(initialization and paging)

初始化和虚拟存储(initialization and virtual memory)

初始化顺序(initialization, order of)

初始式(initializer)

初始式,const成员(initializer, const member)

初始式,成员(initializer, member)

初始式,基类(initializer, base)

初始式,语法(initializer, syntax)

处理器,new(handler, new)

virtual函数(pure virtual function)

葱头式设计(onion design)

存储,初始化和虚存(memory, initialization and virtual)

存储,动态(storage, dynamic)32,56

存储,堆(storage, heap)

存储,静态(storage, static)32,56

存储,类(storage, class)

存储,原始(memory, raw)

存储,栈(storage, stack)

存储,只读(memory, read-only)

存储,自动(storage, automatic)

存储,自由(storage, free)32,56

存储分配场地(memory arena)

存储管理(memory management)

存储管理,细粒度控制(memory management, fine-grain control in)

存储管理的调整(tuning of memory management)

存储耗尽和异常(memory exhaustion and exception)

存储耗尽控制(memory exhaustion, control of)

错误,template的错误检查(error checking of template)

错误,多重定义(error, double definition)

错误,多重继承(bugs, multiple inheritance)

错误,可能的(error, potential)

错误处理(error handling)

错误处理,C(error handling, C)

错误处理,多层(error handling, multi-level)

错误和检查(error, checking and)
 

D

大程序中的命名(large program, naming in a)

大系统和异常(large system and exception)

代码生成(code generation)

代码肿胀的抑制(code bloat, curbing)

代码重复(code replication)

带类的C(C with Classes)

带类的C布局兼容性(C with Classes layout compatibility)

带类的CC兼容性(C with Classes C compatibility)

带类的C低级特征(C with Classes low-level features)

带类的C对象布局(C with Classes object layout)

带类的C静态类型检查(C with Classes static type checking)

带类的C没有虚函数(C with Classes without virtual function)

带类的C实现(C with Classes implementation)

带类的C特征(C with Classes features)

带类的C文档(C with Classes documentation)

带类的C预处理器,Cpre(C with Classes 预处理器, Cpre)

带类的C运行时支持(C with Classes run-time support)

单根层次结构(single-rooted hierarchy)

单重和多重继承(single and multiple inheritance)

单精度浮点数(single precision floating point)

派生(derivation)

派生,通过派生约束(derivation, constraint through)

派生,禁止(derivation, prohibit)

派生,由int派生(derivation from int)

派生,由内部类型(derivation from build-in type)

派生的(derived)

派生类和基(derived and base)

派生class(derived class)

派生类,和重载的基(derived, overload base)

派生类的布局(derived class layout)

派生类重载和基类(derived overloading, base and)

派生遮蔽基类(derived hiding base)

等价(equivalence)

等价,结构(equivalence, structural)

等价,名字(equivalence, name)

等价,运算符(equivalence, operator)

低级编码(low-level coding)

低级程序设计(low-level programming)

低级程序设计规则(low-level programming rules)

低级特征,带类的C(low-level feature, C With Classes)

递归下降分析器(recursive descent parser)

调用Fortran(calling Fortran)

调用规则(calling conventions)

调用序列,标准(calling sequences, standard)

动态(dynamic)

动态初始化(dynamic initialization)

动态存储(dynamic storage)

动态分配和实时(dynamic allocation and real-time)

动态和静态类型检查(dynamic type checking, static and)

动态检查异常(dynamic checking of exception)

动态连接(dynamic linking)

独立的多重继承(independent multiple inheritance)

namespace名字(short namespace name)

堆存储(heap storage)

C++的影响,操作系统(C++, operating system influence on)

template参数的依赖(depend on template argument)

对象,部分构造的(object, partial constructed)

对象,堆栈(object, stack)

对象,静态(object, static)

对象I/O(object I/O)

对象I/O,实例(object I/O, example of)

对象布局(object layout)

对象布局,带类的C(object layout, C With Classes)

对象复制(object, copy of)

多参数重载(multi-argument overloading)

多层错误处理(multi-level error handling)

多层异常传播(multi-level, propagation of exception)

多处理器系统(multi-processor system)

多态类型(polymorphic type)

多线程(multi-threading)

多重,库的多重使用(multiple, libraries, use of)

多重方法(multi-method)

多重继承(multiple inheritance)

多重继承,C++(multiple inheritance, C++)

多重继承的布局(multiple inheritance, layout)

多重继承,独立性(multiple inheritance, independent)

多重继承与废料收集(multiple inheritance, garbage collection)

多重继承的静态检查(multiple inheritance, static checking of)

多重继承的开销(multiple inheritance, overhead)

多重继承的使用(multiple inheritance, use of)

多重继承错误(multiple inheritance bugs)

多重继承的复杂 (multiple inheritance complexity)

多重继承工具(multiple inheritance tools)

多重继承和Simula(multiple inheritance and Simula)

多重继承和Smalltalk(multiple inheritance and Smalltalk)

多重继承和单继承(multiple inheritance, single and)

多重继承和名字冲突(multiple inheritance, name clash and)

多重继承和歧义性(multiple inheritance and ambiguity)

多重继承和虚函数(multiple inheritance, virtual function and)

多重继承和异常处理(multiple inheritance and exception handling)

多重继承实现(multiple inheritance implementation)

多重实例化(multiple instantiation)
 

F

发送(dispatch)

发送,template双重发送(dispatch, template, double)

发送,双重(dispatch, double)

翻译单元(translation, unit of)

翻译限制(translation limits)

返回值优化(return value optimization)

访问,对基类(access to base class)

访问,通过使用声明调整(access using-declaration adjusting)

访问控制(access control)

访问控制,对建构函数(access control for constructor)

访问控制,对名字(access control for names)

访问控制和static成员(access control and static member)

访问声明(access-declaration)

访问声明和使用声明(access-declaration and using declaration)

放松参数规则(relaxation of argument rules)

放松重载(relaxation of overloading)

放置(placement)

放置的重要性(placement, importance of)

非类型template参数(non-type template argument)

非同步事件(asynchronous events)

废料收集(garbage collection)

废料收集,保守式(garbage collection, conservative)

废料收集,标准(garbage collection, standard)

废料收集与多重继承(garbage collection, multiple inheritance)

废料收集,反对的理由(garbage collection, reasons against)

废料收集,可选的(garbage collection, optional)

废料收集,支持的理由(garbage collection, reasons for)

废料收集,自动(garbage collection, automatic)

废料收集和析构函数(garbage collection, destructor and)

分别编译(separate compilation)

分配,数组(allocation, array)

分配程序,按类(allocator, per-class)

分配的建构函数,new(allocation and constructor, new)

分配和new(allocation and new)

分配和初始化(allocation and initialization)

分配和实时,动态(allocation and real-time, dynamic)

分配场地(allocation arena)

分配,禁止auto(allocation, prohibit auto)

分配,禁止static(allocation, prohibit static)

分配,禁止全局量(allocation, prohibit globe)

分配,禁止自由空间(allocation, prohibit free store)

分析C++(parsing C++)

风格,混合(style, hybrid)

风格,仅初始化(style, initialize-only)

风格,设计风格(style of design)

封装和friend(encapsulation and friend)

浮点数到整数的转换(floating to integral conversion)

符号表,Cfront(symbol table, Cfront)

符号表,持续性(symbol table, persistent)

辅助类(class helper)

复合,界面的复合(composition, interface)

复合技术,template(composition techniques, template)

复合运算符(composite operator)

复制,virtual(copy, virtual)

复制,按成员(copy, memberwise)

复制,按位(copy, bitwise)

复制,对象(copy of object)

复制,禁止(copy, prohibit)

复制,浅(copy, shallow)

复制,深(copy, deep)

复制,指针(copy of pointer)

复制建构函数(copy constructor)

复制控制(copy, control of)

赋值(assignment)

赋值,对this的赋值(assignment to this)

赋值,对void*的赋值(assignment, void*)

赋值的重载(assignment, overloading of)

覆盖,放松规则(overriding, relaxation)

覆盖和遮蔽(overriding and hiding)
 

G

class(root class)

class,统一的(root class, universal)

更好的匹配(better match)

关键字参数(keyword argument)

关联数组(associative array)

关联数组,标准(associative array, standard)

关系运算符,类型(relation operator, type)

规则,低级程序设计(rule, low-level programming)

规则,交叉(rule, intersect)

规则,两周(rule, two weeks)

规则,零开销(rule, zero overhead)

规则,名字约束(rule, name binding)

规则,设计支持(rules, design support)

规则,特殊化(rule, specialization)

规则,唯一定义(rule, one definition)

规则,一般(rules, general)

规则,语言技术(rule, language-technical)

规则,语言设计(rules, language design)

规则,重写(rule, rewrite)

规则,重新定义(rule, redefinition)

规则,重新考虑(rule, reconsideration)

规则,重新排序(rule, reordering)

过度使用,继承(overuse of inheritance)

过度使用,强制(overuse of cast)

过分约束的参数(over-constrained argument)
 

H

函数,const成员(function, const member)

函数,inline成员(function, inline member)

函数,static成员(function, static member)

函数,template参数(function, template argument)

函数,template函数(function, template)

函数,templatevirtual(function, template and virtual)

函数,template重载(function, template overloading)

函数,virtual(function, virtual)

函数,虚函数表(function table, virtual)

函数,虚函数的实现(function implementation, virtual)

函数,虚函数的效率(function efficiency, virtual)

函数,不用virtual的多态性(function, polymorphism without virtual)

函数,布局和虚函数(function, layout and virtual)

函数,成员的实现(function, implementation of member)

函数,纯虚(function, pure virtual)

函数,调用无定义函数(function call of undeclared)

函数,前向(function, forwarding)

函数,强制和指针指向(function, cast and pointer to)

函数,虚函数和多重继承(function, and multiple inheritance, virtual)

函数,运算符(function, operator)

函数,在线 (function, inline)

函数,只实例化用的函数(function, only, instantiate used)

函数,指针指向(function, pointer to)

函数,转换函数(function, conversion)

函数new()(function new())

函数成员(function member)

函数定义(function definition)

函数优化,virtual(function optimization, virtual)

函数指针,virtual(function pointer, virtual)

函数,virtual函数的重新编译(function recompilation, virtual)

宏用于类属类型(macro for generic type)

环境(environment)

环境,C++程序设计环境(environment, C++ programming)

环境,理想的程序开发环境(environment, ideal program development)

环境,未来的C++程序设计环境(environment, future C++ programming)

唤醒,论据(resumption, arguments)

唤醒,迂回方法(resumption, workaround for)

唤醒和终止(resumption, termination vs.)

唤醒语义(resumption semantics)

换页和初始化(paging, initialization and)

回调(callback)

混合模式算术(mixed-mode arithmetic)

混合子(mixin)
 

J

基,初始构造(base, first construction)

基,初始式(base, initializer)

基,派生遮蔽(base, derived hiding)

基,强制到private(base, cast to private)

基,由virtual基强制(base, cast from virtual)

class(base class)

classvirtual(base class, virtual)

class,常规(base class, ordinary)

class,访问(base class, access to)

基布局,virtual(base layout, virtual)

基成员的遮蔽(base member, hiding of)

基础库(foundation libraries)

基础库,垂直的(foundation libraries, vertical)

基础库,水平的(foundation libraries, horizontal)

基和派生(base and derived)

基和派生,重载(base and derived, overloading)

计算,工程(computing, engineering)

计算,科学(computing, scientific)

计算,数值(computing, numeric, numerical)

技术,template复合(techniques, template composition)

技术和语言特征(techniques, language features and)

继承,多重(inheritance, multiple)

继承,过度使用(inheritance, overuse)

继承,通过继承约束(inheritance, constraint through)

继承operator delete()(inheritance operator delete())

继承operator new()(inheritance operator new())

继承private,实现(inheritance private, implementation)

继承public,界面(inheritance public, interface)

继承和template(inheritance and template)

继承和重载(inheritance, overloading and)

假设,对异常处理(assumptions for exception handling)

间接(indirection)

兼容性,连接(compatibility, link)

兼容性和安全性(compatibility vs. safety)

减量运算符 --(decrement operator --)

检查,静态检查的界面(checked interface, statically)

检查,运行时(check, run-time)

检查,运行时参数检查(check, run-time argument)

检查template的错误(checking of template, error)

检查和错误(checking and error)

检查异常,动态(checking of exceptions, dynamic)

建构,基类在先(construction, base first)

建构函数,new()(constructor, new())

建构函数,对内部类型(constructor, for build-in type)

建构函数,访问控制(constructor, access control for)

建构函数,复制(constructor, copy)

建构函数,和new(constructor, and new)

建构函数,和new分配(constructor, and new allocation)

建构函数,默认(constructor, default)

建构函数,其中的virtual调用(constructor, virtual call in)

建构函数的调用写法(constructor call notation)

建构函数和template(constructor and template)

建构函数和库(constructor and library)

建构函数和异常(constructor and exception)

建构函数记法(constructor notation)

建构函数里的virtual调用(virtual call in constructor)

交叉规则(intersect rule)

接受的建议(accepted proposals)

接受的扩充(accepted extensions)

接受的特征(accepted features)

结构标志(structure tag)

结构等价(structure equivalence)

解析,重载(resolution, overloading)

界面(interface)

界面,const描述(interface, const for specifying)

界面,public继承(interface, inheritance public)

界面,template实现和界面(interface, template implementation and)

界面,静态检查(interfaces, static checking)

界面,外国语(interface, foreign language)

界面复合(interface composition)

界面和强制(interface, cast and)

界面和实现(interface, implementation and)

仅做初始化的风格(initialize-only style)

禁止auto分配(prohibit auto allocation)

禁止static分配(prohibit static allocation)

禁止派生(prohibit derivation)

禁止复制(prohibit copy)

禁止全局分配(prohibit global allocation)

禁止运算符(prohibit operator)

禁止自由存储分配(prohibit free store allocation)

警告(warning)

静态初始化(static initialization)

静态存储(static storage)32,56

静态对象(static object)

静态和动态类型检查(static and dynamic type checking)

静态检查的界面(statically checked interfaces)

静态检查多重继承(static checking of multiple inheritance)

静态检查和多重继承(static checking and multiple inheritance)

静态类型检查(static type checking)

静态类型检查,C++(static type checking, C++)

静态类型检查,带类的C(static type checking, C With Classes)

静态类型检查和库(static type checking, libraries and)

静态类型检查和设计(static type checking and design)

静态类型系统(static type system)

静态异常检查(static checking of exceptions)

局部,默认(local, default)

局部变量(local variable)

局部静态数组,ANSI C(local static array, ANSI C)

局部性(locality)

局部性,嵌套的class(locality, nested class)

句柄(handle)
 

K

开放的名字空间(open namespace)

开关,基于类型(switch on type)

开关,基于类型域(switch on type field)

开销,Cfront编译时间(overhead, Cfront compile-time)

开销,编译时间(overhead, compile-time)

开销,多重继承(overhead, multiple inheritance)

开销,连接时间(overhead, link-time)

开销,零开销规则(overhead rule, zero)

开销,运行时间(overhead, run-time)

科学计算(scientific computing)

可负担的特征(affordable features)

可见性和访问(visibility, access vs.)

可靠性和异常(reliability, exception and)

可扩充I/O(extensible I/O)

可选的废料收集(optional garbage collection)

可移植性(portability)

空指针0

控制,存储管理,细粒度(control of memory management, fine-grain)

控制,存储耗尽(control of memory exhaustion)

控制,访问(control, access)

控制,复制控制(control of copy)

控制,手工(control, manual)

库,ANSI标准(library, ANSI standard)

库,Booch组件(library, Booch components)

库,C++(library, C++)

库,complex(library, complex)

库,ISO标准(library, ISO standard)

库,标准库(library, standard)

库,标准库名字空间(library, namespace in standard)

库,标准库中的命名(library, naming in standard)

库,标准数值库(library, standard numeric)

库,标准组件库(library, standard components)

库,垂直基础库(library, vertical foundation)

库,流I/O(library, stream I/O)

库,水平基础库(library, horizontal foundation)

库,语言支持(library, language support for)

库,作业(library, task)

库初始化(library initialization)

库的多重使用(library, use of multiple)

库和namespace(library, namespace and)

库和抽象class(library, abstract class and)

库和多重继承(library, multiple inheritance)

库和建构函数(library, constructor and)

库和静态类型检查(library and static type checking)

库和类型系统(library and type system)

库和异常(library, exception and)

库和语言特征(library vs. language feature)

库和运行时类型信息(library, run-time type information and)

库设计(library design)

库设计和template(library design, template and)

库设计折中(library design tradeoff)

跨语言连接(inter-language linkage)

扩充的I/O字符集(extended character set, I/O of)

扩充的类型信息(extended type information)

扩充的字符集(extended character set)

扩充时的检查表(check list, extension)
 

L

老代码和异常(old code, exception and)

老风格强制的记法(old style cast notation)

类成员的向前引用(class member, forward reference of)

类的布局,派生(class layout, derived)

类分层结构,异常(class hierarchy, and exception)

类型,char常量的类型(type of char constant)

类型,char字面量的类型(type of char literal)

类型,class作为用户定义类型(type, class as user-defined)

类型,return(type, return)

类型,template,参数化(type, template, parameterized)

类型,参数化类型(type, parameterized)

类型,抽象(type, abstract)

类型,多态(type, polymorphic)

类型,返回引用(type, reference return)

类型,基于类型的开关(type, switch on)

类型,内部类型的建构函数(type, constructor for build-in)

类型,内部类型的析构函数(type, destructor for build-in)

类型,强制和不完全(type, cast and incomplete)

类型,由内部类型派生(type, derivation from build-in)

类型bool,布尔(type bool, Boolean)

类型enum(type enum)

类型安全的I/O(type-safe I/O)

类型安全的连接(type-safe linkage)

类型安全连接的问题(type-safe linkage problem)

类型安全连接的语法(type-safe linkage syntax)

类型安全性(type safety)

类型安全性和异常(type safety and exceptions)

类型编码(type encoding)

类型标识(type identity)

类型查询,编译时(type inquiry, compile-time)

类型查询,运行时(type inquiry, run-time)

类型查询运算符(type inquiry operator)

类型检查,C++(type checking, C++)

类型检查,C++静态(type checking, C++ static)

类型检查,编译时间(type checking, compile-time)

类型检查,带类的C,静态(type checking, C With Classes static)

类型检查,静态(type checking, static)

类型检查,静态和动态(type checking, static and dynamic)

类型检查,库和静态检查(type checking, libraries and static)

类型检查,默认(type checked, default)

类型检查和设计(type checking, design and)

类型检查和设计,静态(type checking and design, static)

类型违背(type violation)

类型系统(type system)

类型系统,C++语法(type system, C++ syntax)

类型系统,静态(type system, static)

类型系统和库(type system, library)

类型信息,扩充的(type information, extended)

类型信息,运行时(type information, run-time)

类型信息和库,运行时(type information and library, run-time)

类型域,基于类型域的开关(type field, switch on)

类型域,显式(type field, field)

类属程序设计,C++(generic programming, C++ and)

类属类型,宏(generic types, macro for)

例子,RTTI(example of RTTI)

例子,成员template(example, member template)

例子,对象I/O(example of object I/O)

例子,作业(example, task)

连接,C(linkage, C)

连接,CC++(linkage, C and C++)

连接,动态(linking, dynamic)

连接,函数指针(linkage, pointer to function)

连接,跨语言(linkage, inter-language)

连接,类型安全(linkage, type-safe)34,232,234,236,399

连接,增量(linking, incremental)

连接程序(linker)

连接程序的问题(linker problem)98,303

连接和重载(linkage and overloading)232,233

连接兼容性(link compatibility)

连接名(linkage name)

连接模型(linkage model)

连接时间和template(link-time and template)

两周规则(two week rule)

量化(qualification)

量化,显式(qualification, explicit)

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

临时量的生存期(lifetime of temporaries)

临时量的生存期(temporaries, lifetime of)

临时量的析构点,选择(points of destruction of temporary, alternative)

临时量其他可能的析构点(temporaries, alternative points of destruction of)

临时量删除(temporaries, elimination of)

灵活性和效率(flexibility and efficiency)

灵活性与简单性(flexibility vs. simplicity)

灵巧引用(smart reference)

灵巧指针(smart pointer)

零开销规则(zero overhead rule)

I/O(stream I/O)

I/OC++(stream I/O, C++)

I/O(stream I/O library)
 

M

面向特定系统结构的扩充(architecture-specific extension)

描述,异常(specification, exception)

名字,C++(name, C++)

名字,全局(name, global)

名字编码,标准(name encoding, standard)

名字编码和名字空间(name encoding, namespace and)

名字查找(name lookup)

名字查找,ANSI/ISO(name lookup, ANSI/ISO)

名字查找,ARM(name lookup, ARM)

名字查找,template(name lookup, template)

名字冲突,全局作用域(name clashes, global scope)

名字冲突和多重继承(name clashing and multiple inheritance)

名字的访问控制(names, access control of)

名字等价(name equivalence)

名字劫持(names hijack)

名字劫持,在template(names, in template, hijacking of)

名字空间,开放性(namespaces, open)

名字空间,嵌套(namespaces, nested)

名字空间,转变(namespaces, transition)

名字空间和C兼容性(namespaces and C compatibility)

名字空间和版本(namespaces and versioning)

名字空间和名字编码(namespaces and name encoding)

名字空间和名字压延(namespaces and name mangling)

名字空间和重载(namespaces, overloading and)

名字空间污染(name space pollution)

名字空间与标准库(namespaces, in standard library)

名字空间作为template参数(namespace as template argument)

名字连接(name linkage)

名字前缀(name prefix)

名字压延(name mangling)

名字压延和名字空间(name mangling and namespace)

名字约束规则(name binding rule)

名字遮蔽(name, hiding of)

命名,在标准库(naming, in standard library)

命名,在大程序里(naming, in a large program)

命名参数(named argument)

模板,Container(template, Container)

模板,条件里的模板(template, conditional in)

模板的使用(template, use of)

模板间的关系(relationships between template)

模板设计准则(templates, design criteria for)

模板之间的关系(template, relationship between)

模块化(modularity)

模块结构(module structure)

模型,C++保护模型(model of protection, C++)

模型,template编译模型(model, template compilation)

模型,保护模型(model, protection)

模型,连接模型(model, linkage)

默认(default)

默认,局部(default, local)

默认,类型检查(default, type checked)

默认,嵌套(default, nested)

默认,私用(default, private)

默认参数(default argument)

默认参数和重载(default argument, overloading and)

默认建构函数(default constructor)

默认运算符(default operator)

目标,C++

目标,namespace设计目标(aims of namespace design)

目标,标准化(aims for standardization)

目标,带类的C(aims of C with Class)

目标,异常处理(aims for exception handling)

目标,早期库(aims of early libraries)

目标语言,C++作为(target language, C++ as a)
 

N

内部类型,和用户定义类型(build-in type, user-defined types)

内部类型派生(build-in type, derivation from)

内部类型的定义(build-in type, definition for)

内部类型的建构函数(build-in type, constructor for)

内部类型的析构函数(build-in type, distructor for)

内部类型和template(build-in type, and template)
 

P

排序(sorting)

匹配,更好(match, better)

匹配,重载(matching, overloading)

匹配规则,参数(matching rules, argument)

评价准则(criteria)

评价准则,对于模板设计(criteria, for template design)

评价准则,接受的特征(criteria, feature acceptance)

评价准则,扩充(criteria, extension)
 

Q

歧义性(ambiguity)

歧义性和多重继承(ambiguity, multiple inheritance and)

歧义性,模板(ambiguity, in template)

歧义性控制(ambiguity, control)

前向函数(forwarding function)

浅复制(shallow copy)

嵌入式系统(embedded system)

嵌套class(nested class)

嵌套class,局部化(nested class, locality)

嵌套class的向前声明(forward declaration of nested class)

嵌套template(nested template)

嵌套的名字空间(nested namespace)

强制(cast)

强制,安全(cast, safe)

强制,从virtual(cast from virtual base)

强制,从void*(cast from void*)

强制,和RTTI(cast and RTTI)

强制,新风格(cast, new-style cast)

强制,隐式(cast, implicit)

强制到private(cast to private base)

强制的过度使用(overuse of cast)

强制的问题(problem with cast)

强制的语法(cast, syntax)

强制和const(cast and const)

强制和不完全类型(cast and incomplete type)

强制和界面(cast and interface)

强制和指向函数的指针(cast and pointer to function)

强制记法,老风格(cast notation, old-style)

强制去掉const(cast away const)

强制删除(cast eliminate)

强制新记法(cast notation, new)

切片(slicing)

取代常规指针(replace ordinary pointer)

全局namespace(global namespace)

全局变量(global variable)

全局分配(global allocation, prohibit)

全局名字(global names)

全局优化(global optimization)

全局作用域(global scope)

全局作用域名字冲突(global scope name clashes)
 

R

容器,classtemplate(container, class and template)

容器,class和宏(container, class and macro)

容器,Clu风格(container, Clu style)

容器,Smalltalk风格(container, Smalltalk style)

容器,标准(container, standard)

软件部件产业(component industry, software)
 

S

删除临时量(elimination of temporaries)

删除强制(eliminate cast)

上下文,template定义的(context of template definition)

上下文,template实例化的(context of template instantiation)

设计(design)

设计,namespace的设计目标(design aims of namespace)

设计,namespace的设计思想(design ideal for namespace)

设计,RTTI的替代设计(design alternative RTTI)

设计,template的清理(design cleanup of template)

设计,template的设计准则(design criteria for template)

设计,template和库(design, template and library)

设计,葱头式(design, onion)

设计,库(design library)

设计,面向对象的(design, object-oriented)

设计,语言(design language)

设计规则,语言(design rules, language)

设计和静态类型检查(design and static type checking)

设计和类型检查(design and type checking)

设计者和实现者(designer and implementer)

深复制(deep copy)

声明(declaration)

声明,Algol68(declaration, Algol68)

声明,实现(declaration, implementation)

声明,特殊化(declaration, specialization)

声明,在for-语句里(declaration, in for-statement)

声明,在嵌套class里,前向(declaration, of nested class, forward)

声明,在条件里(declaration, in condition)

声明的线性记法(linear notation of declarations)

声明的语法,C(declaration syntax, C)

声明重载(declaration overloading)

省略号...(ellipsis ...)

实例化#pragmatemplate(instantiation #pragma, template)

实例化(instantiation)

实例化,多次(instantiation, multiple)

实例化,手工优化(instantiation, manual optimization)

实例化,推迟(instantiation, late)

实例化,显式template(instantiation, explicit template)

实例化,隐式(instantiation, implicit)

实例化,自动template实例化(instantiation, automatic template)

实例化点(instantiation, point of)

实例化上下文,template(instantiation context of template)

实例化指示符,template(instantiation directive, template)

实现,带类的C(implementation C With Classes)

实现Cfront template(implementation Cfront template)

实现private继承(implementation, inheritance private)

实现template遮蔽(implementation hiding of template)

实现virtual函数(implementation virtual function)

实现成员函数(implementation of member function)

实现多重继承(implementation multiple inheritance)

实现复杂性,RTTI(implementation complexity, RTTI)

实现和界面(implementation and interface)

实现和界面,template(implementation and interface, template)

实现问题,template(implementation problem, template)

实现语言,C++作为(implementation language, C++ as an)

使用,通过使用约束(use, constraint through)

使用dynamic_cast(use of dynamic_cast)

使用RTTI(use of RTTI)

使用typeid(use typeid)

使用的复杂性(use, complexity of)

使用多重继承(use multiple inheritance)

使用和误用(use and misuse)

使用模板(use template)

使用声明(using-declaration)

使用声明调整访问(using-declaration adjusting access)

使用声明和访问指示(using-declaration, access declaration and)

使用声明和使用指示(using-declaration vs. using-directive)

使用指示(using-directive)

使用指示和使用声明(using-directive, using declaration vs.)

使用指示和转变(using-directive, transition and)

事件序列(sequence of events)

释放和delete (deallocation, delete and)

释放和清除(deallocation and cleanup)

释放数组(deallocating array)

释放问题(deallocation problem)

手工实例化优化(manual optimization of instantiation)

受限指针(restricted pointer)

书籍和杂志(books and journals)

输出运算符,<<(output operator, <<)

数据,virtual(data, virtual)

数据成员,指针指向(data member, pointer to)

数据抽象,C++(data abstraction, C++)

数组,标准关联数组(array, standard associative)

数组,关联数组(array, associative)

数组template(array template)

数组分配(array allocation)

数组释放(array, deallocating)

水平基础库(horizontal foundation library)

顺序,成员初始化(order of member initialization)

顺序,初始化(order of initialization)

顺序依赖性(order dependence)118,232

顺序依赖性,class成员(order dependencies, class member)

顺序依赖性,迂回处理(order dependence, workaround for)

顺序依赖性和重载(order dependency and overloading)

私用,默认(private, default)

算术,混合模式(arithmetic, mixed mode)

碎片(fragmentation)
 

T

特权(privileges)

特殊存储器(special memory)

特殊地址(special address)

特殊化,模板(specialization of template)

特殊化规则(specialization rule)

特殊化声明(specialization declaration)

特殊化限制(specialization restriction)

特征,ARM(features, ARM)

特征,C++ Release 1.0(features, C++ Release 1.0)

特征,C++ Release 2.0(features, C++ Release 2.0)

特征,C++(features, C++)

特征,带类的C(features, C With Classes)

特征,新的(features, new)

提升,整数(promotions, integral)

条件,在模板中(conditionals in template)

条件中的声明(condition, declarations in)

通讯,兄弟类之间(communication between siblings)

同义词(synonym)

同义词问题(synonym, problem with)

统一的根class(universal root class)

头文件(header file)34,207,235

头文件,预编译(header, precompiled)

推迟实例化(late instantiation)

推断template参数(deducing template argument)
 

W

外国语接口(foreign language interface)

危险的C特征(dangerous C features)

危险的特征(dangerous features)

唯一定义规则(one-definition rule)

唯一定义规则和template(one-definition rule and template)

委托(delegation)

委托,多重继承(delegation, multiple inheritance)

委托,经验(delegation, experiment)

委托和->(delegation and ->)

未初始化变量(uninitialized variables)

文件,头文件(file, header)34,207,235

文件,源文件(file, source)

文件和template.c(file and template, .c)

文件和template.h(file and template, .h)

文件和template,源文件(file and template, source)

污染名字空间(pollution, name space)

无定义函数,调用(undefined function, call of)

无名的namespace(unnamed namespace)

无约束的方法(unconstrained method)

误用friend(misuse of friend)

误用RTTI(misuse of RTTI)

误用typeid(misuse of typeid)
 

X

析构函数(destructor)

析构函数delete()(destructor, delete())

析构函数virtual(destructor, virtual)

析构函数,对于内部类型(destructor, for build-in type)

析构函数,显式调用(destructor, explicit call of)

析构函数和delete(destructor, delete and)

析构函数和废料收集(destructor and garbage collection)

析构函数和异常(destructor, exception and)

系统,大系统(system, large)

系统,大系统和异常(system, and exception, large)

系统,混合(system, mixed)

系统,库和类型系统(system, libraries and type)

系统,嵌入式(system, embedded)

系统,容错系统设计(system, design of fault-tolerant)

系统和语言(system, language and)

系统和语言实现(system and language implementation)

细粒度存储管理的控制(fine-grain control of memory management)

细粒度重载解析(fine-grain overload resolution)

显式template参数(explicit template argument)

显式template实例化(explicit template instantiation)

显式调用析构函数(explicit call of destructor)

显式类型域(explicit type field)

显式量化(explicit qualification)

显式量化::(explicit qualification ::)

限制,特殊化(restriction, specialization)

相同,类型(identity, type)

向量,template(vector, template)

向量,标准(vector, standard)

向前,类成员的向前引用(forward reference of class member)

向前,嵌套class的向前声明(forward declaration of nested class)

效率,virtual(efficiency, virtual)

效率,带类的C(efficiency, C With Classes)

效率,运行时(efficiency, run-time)

效率和灵活性(efficiency, flexibility and)

效率和异常(efficiency, exception and)

效率和重载(efficiency and overloading)78,84

新风格强制(new-style cast)

信号(signals)

性能(performance)

性能,new(performance, new)

性能,启动(performance, startup)

兄弟class(sibling class)

兄弟类间的通讯(siblings, communication between)

虚,在建构函数里调用(virtual call in constructor)

虚表布局(virtual table layout)

虚成员template(virtual member template)

虚复制(virtual copy)

虚函数(virtual function)

虚函数,纯(virtual function, pure)

虚函数表(virtual function table)

虚函数和template(virtual function, template and)

虚函数和布局(virtual function, layout and)

虚函数实现(virtual function implementation)

虚函数效率(virtual function efficiency)

虚函数优化(virtual function optimization)

虚函数指针(virtual function pointer)

虚函数重新编译(virtual function recompilation)

虚基,从虚基强制(virtual base, cast from)

虚基class(virtual base class)

虚基布局(virtual base layout)

虚数据(virtual data)

虚析构函数(virtual distructor)
 

Y

一遍编译(one-pass compilation)

一遍分析(one-pass analysis)

一致的观点(coherent view)

一致性维护(coherence maintaining)

移植问题(porting problems)

异常,捕捉的保证(exceptions, guaranteed catching of)

异常结组(exceptions, grouping of)

异常处理(exception handling)

异常处理,C++的理想(exception handling, ideals for C++)

异常处理,假设(exception handling, assumptions for)

异常处理的目标(exception handling, aims for)

异常处理的语法(exception handling syntax)

异常处理和多重继承(exception handling, multiple inheritance and)

异常处理和可靠性(exception handling and reliability)

异常的代价(cost of exception)

异常的动态检查(exceptions, dynamic checking of)

异常的多层传播(exceptions, multi-level propagation of)

异常的经验(exceptions, experience with)

异常的静态检查(exceptions, static checking of)

异常和C(exceptions and C)

异常和template(exceptions, template and)

异常和并行性(exceptions, concurrency and)

异常和布局(exceptions and layout)

异常和抽象的层次(exceptions and levels of abstraction)

异常和存储耗尽(exceptions, memory exhaustion and)

异常和大系统(exceptions, large system and)

异常和建构函数(exception and constructor)

异常和库(exception and library)

异常和老代码(exceptions and old code)

异常和类层次(exceptions and class hierarchy)

异常和类型安全性(exceptions, type safety and)

异常和其他语言(exceptions and other languages)

异常和析构函数(exception and destructor)

异常和效率(exceptions and efficiency)

异常和溢出(exceptions, overflow and)

异常和重新编译(exceptions and recompilation)

异常和资源管理(exceptions and resource management)

异常检查,静态(checking of exceptions, static)

异常描述(exception specification)

溢出和异常(overflow and exception)

引用(reference)

引用,const(reference, const)

引用,return类型(reference, return type)

引用,this(reference, this)

引用,灵巧(reference, smart)

引用,约束(reference, binding of)

引用传递(pass-by-reference)

引用调用(call-by-reference)

引用和指针(reference, pointer and)

引用语义(reference semantics)

隐式,template里的隐式使用(implicit use in template)

隐式强制(implicit cast)

隐式实例化(implicit instantiation)

隐式窄转换(implicit narrowing conversion)

隐式转换(implicit conversion)

隐式转换和static_cast(implicit conversion, static_cast and)

用户定义类型,class(user-defined type, class is)

用户定义类型的优先级(precedence of user-defined operator)

用户定义类型和内部类型(user-defined and build-in type)

用户定义运算符(user-defined operator)

用户定义运算符的优先级(user-defined operator, precedence of)

优化,全局(optimization, global)

优化,手工(optimization, hand)

优化,手工实例化(optimization of instantiation, manual)

优化return(optimization return value)

优化virtual调用(optimization of virtual call)

优化virtual函数(optimization virtual function)

优化虚表(optimization virtual table)

幽雅和简单(elegance and simplicity)

右值和左值(rvalue, lvalue vs.)

迂回做法,对多重方法(workaround for multi-method)

迂回做法,对关键词参数(workaround keyword argument)

迂回做法,对唤醒(workaround for resumption)

迂回做法,对顺序依赖性(workaround for order dependencies)

与实现有关的行为(implementation-dependent behavior)

语法(syntax)

语法,<...>(syntax, <...>)

语法,=0(syntax, =0)

语法,C声明(syntax, C declaration)

语法,dynamic_cast(syntax of dynamic_cast)

语法,namespace(syntax, namespace)

语法,template(syntax, template)

语法,template>>问题(syntax, >> problem with template)

语法,template的选择(syntax, alternative template)

语法,初始式(syntax, initializer)

语法,类型安全的连接(syntax, type-safe linkage)

语法,类型系统,C++(syntax, type system, C++)

语法,强制(syntax, cast)

语法,异常处理(syntax, exception handling)

语法,指针(syntax, pointer)

语法的重要性(syntax, important of)

语法中的冗余(redundancy in syntax)

语言,C++作为目标语言(language, C++ as a target)

语言,C++作为实现语言(language, C++ as an implementation)

语言和环境,分离(language and environment, separation)

语言和实现(language and implementation)

语言设计规则(language design rules)

语言特征和技术(language features and techniques)

语言特征和库(language feature, library and)

语义,C(semantics, C)

语义,唤醒(semantics, resumption)

语义,引用(semantics, reference)

语义,值(semantics, value)

语义,指针(semantics, pointer)

语义,终止(semantics, termination)

原始存储(raw memory)

源程序,C++(source, C++)

源程序,控制和template(source, control and template)

源程序文件(source file)

源程序文件和template(source file and template)

源程序正文,合法(source text, legal)

源代码里的名字(source code names)

约束,对template参数(constraint on template argument)

约束,通过派生(constraint through derivation)

约束,通过继承(constraint through inheritance)

约束,通过使用(constraint through use)

约束,引用(binding of reference)

约束规则,名字(binding rule, name)

约束和错误检查(constraint and error detection)

约束和可读性(constraint and readability)

运算符--,减量(operator --, decrement)

运算符->(operator ->)

运算符->*(operator ->*)

运算符**,指数(operator **, exponentiation)

运算符*^,指数(operator *^, exponentiation)

运算符,(operator ,)

运算符,private(operator, private)

运算符,禁止(operator, prohibit)

运算符,类型关系(operator, type relation)

运算符,类型获取(operator, type inquiry)

运算符,用户定义(operator, user-defined)

运算符,用户定义优先级(operator, precedence of user-defined)

运算符.(operator .)

运算符.*(operator .^)

运算符++,增量(operator ++, increment)

运算符<<(operator <<)

运算符<<,输出(operator <<, output)

运算符=(operator =)

运算符delete(operator delete)

运算符delete[](operator delete[])

运算符new(operator new)

运算符new[](operator new[])

运算符等价(operator equivalence)

运算符复合(operator composite)

运算符函数(operator function)

运算符默认(operator default)

运算符重载(operator overloading)

运行时,检查的初始化(run-time, checked initialization)

运行时保证(run-time guarantees)

运行时参数检查(run-time argument checking)

运行时初始化(run-time initialization)

运行时初始化,问题(run-time initialization, problems with)

运行时检查(run-time checking)29,42

运行时开销(run-time overhead)

运行时类型获取(run-time type inquire)

运行时类型信息(run-time type information)

运行时类型信息和库(run-time type information and library)

运行时效率(run-time efficiency)

运行时支持,带类的C(run-time support, C With Classes)

运行时支持,最小化(run-time, minimal)
 

Z

增量连接(incremental linking)

增量运算符++(increment operator ++)

窄转换(narrowing conversion)

窄转换,隐式(narrowing conversion, implicit)

找到template定义(finding template definition)

遮蔽,和重载(hiding, overloading and)

遮蔽template实现(hiding of template implementation)

遮蔽表示(hiding of representation)

遮蔽基,派生类(hiding base, derived)

遮蔽基成员(hiding of base member)

遮蔽名字(hiding of name)

真正的局部变量(true local variable)

整数提升(integral promotions)

正交性(orthogonality)

支持,对库的支持(support for libraries)

支持,设计支持规则(support rules, design)

支持,语言对库的支持(support for libraries, language)

支持并行性(support concurrency)

支持库(support library)

值,赋值的值(value of assignment)

值传递(pass-by-value)

值调用(call-by-value)

值语义(value semantics)

只读存储器(read-only memory)

指示符,template实例化(directive, template instantiation)

指数运算符**(exponentiation operator **)

指数运算符*^(exponentiation operator *^)

指针,到成员(pointer to member)

指针,到函数(pointer to function)

指针,到函数的指针和连接(pointer to function linkage)

指针,到函数的指针和强制(pointer to function, cast and)

指针,到数据成员(pointer to data member)

指针,灵巧(pointer, smart)

指针,取代常规(pointer, replace ordinary)

指针,受限的(pointer restricted)

指针0,空(pointer 0, null)

指针this(pointer this)

指针复制(pointer, copy of)

指针和非指针(pointers and non-pointers)

指针和引用(pointers and references)

指针语法(pointer syntax)

指针语义(pointer semantics)

中断(interrupts)

终止的论据(termination, argument)

终止和唤醒(termination vs. resumption)

终止语义(termination semantics)

重定义规则(redefinition rule)

主要和次要扩充(major and minor extension)

转变(transition)

转变到名字空间(transition to namespace)

转变到新强制(transition to new cast)

转变和使用指示(transition and using directive)

转变和重载(transition, overloading and)

转变路径(transition path)

转换(conversion)

转换,static_cast和隐式(conversion, static_cast and implicit)

转换,安全(conversion, safe)

转换,标准(conversion, standard)

转换,浮点数到整数(conversion, floating to integral)

转换,隐式(conversion, implicit)

转换,隐式窄转换(conversion, implicit narrowing)

转换,窄转换(conversion, narrowing)

转换到void*(conversion to void*)

转换格(conversion lattice)

转换函数(conversion function)

转换和C兼容性(conversion and C compatibility)

转换和template(conversion and template)

转换和重载(conversion, overloading and)

转换图(conversion graph)

资源管理(resource management)

资源管理和异常(resource management, exception and)

资源获取,初始化(resource acquisition, initialization)

资源需求,Cfront(resource requirement, Cfront)

字符集(character set)

字符集,8(character set, 8-bit)

字符集,I/O扩充(character set, I/O extended)

字符集,unicode(character set, unicode)

字符集,国家(character set, national)

字符集,扩充(character set, extended)

自动template实例化(automatic template instantiation)

自动存储(automatic storage)

自动废料收集(automatic garbage collection)

自动原型(autoprototyping)

自赋值(self-assignment)

自由存储(free store)32,56

自由存储分配,禁止(free store allocation, prohibit)

组合方法(combination method)

左值与右值(lvalue vs. rvalue)

作业的例子(task example)

作业库(task library)

作用域,半透明(scope, semi-transparent)

作用域,名字冲突,全局(scope, name clashes, global)

作用域,全局(scope, global)

作用域和Cpp(scope, Cpp and)