�������� Linux Tags


һȺ�������ͬ�ġ����������������һ�ᣬ�Ķ��ĸо��ͺܺá�
һ���Ե���������Ըߣ������Ըߣ�ϵͳ���ߡ�
�� ��ϲ����ʽ����
constructor ����ʽ
declaration ����ʽ
definition  ����ʽ
destructor  �⹹ʽ
expression  ��ʽ������ʽ��
function    ��ʽ
pattern     ��ʽ��ģʽ����ʽ
program     ��ʽ
signature   ���ʽ

�� ��ϲ���������������Ǹ����Էdz���Ŀ�����֣�
assembly ��װ�����
component ���
construct ����
control   �ؼ�
event     �¼�
hardware  Ӳ��
object    ���
part      ���������
singleton ����
software  ����
work      ����������

�� ��ϲ����������
adapter   �����
allocator ������
compiler  ������
container ����
iterator  ������
linker    ������������
listener  ������

�� ��ϲ�����𡹣�
class ���
type  �ͱ�

�� ��ϲ����������
generalized    ����
specialized    �ػ�
overloaded     ���ػ������أ�

�� ��ϲ�����͡���
polymorphism  ����
genericity    ����

�� ��ϲ�����̡���
process     �г̣�or ���̣���½���
thread      �̣߳���½���
programming ���


��Ӣ�з������������
Ӣ��                    �������
                      ����Щ�Ǻ�ݸ���ϲ�ã��ռ������˵��      ��½��������
---------------------------------------------------------------------------------------
#define                 ����                                    Ԥ����
abstract                �����                                  �����
abstraction             �����塢�����������                  �����塢�����������
access                  ��ȡ��ȡ��                              ��ȡ������
access function         ��ȡ��ʽ                                ��ȡ����
activate
active
adapter                 �����                                  ������
address                 λַ                                    ��ַ
address space           λַ�ռ䣬��ַ�ռ�
address-of operator     ȡַ������                              ȡ��ַ�����
aggregation             �ۺ�
algorithm               ���㷨                                  �㷨
allocate                ����                                    ����
allocator               ���ռ䣩������                          ������
application             Ӧ�ó�ʽ                                Ӧ�á�Ӧ�ó���
application framework   Ӧ�ó�ʽ��ܡ�Ӧ�ÿ��                  Ӧ�ó�����
argument                ������������ʽ��ֵ�������� parameter    ������ʵ��������ʵ�����Ա���
array                   ����                                    ����
arrow operator          arrow����ͷ��������                     ��ͷ�����
assembly                ���
assembly language       �������                                �������
assign                  ָ�ɡ�ָ������ֵ����ֵ                  ��ֵ
assignment              ָ�ɡ�ָ��                              ��ֵ������
assignment operator     ָ�ɣ���ֵ�������� =                    ��ֵ�����
associated              ��Ӧ�ġ���ص�                          ��صġ���������Ӧ��
associative container   ����ʽ��������Ӧ sequential container�� ����ʽ����
atomic                  ���ɷָ��                              ԭ�ӵ�
attribute               ����                                    ����
background              ����                                    ���������ͼ����ɫ��
                                                                ��̨������г̣�
base class              �������                                ����
base type               �����ͱ� (��ͬ� base class)
batch                   ���Σ���˼��������ҵ��                  ������
best viable function    ��ѿ��к�ʽ                            ��ѿ��к�ʽ
                      ���� viable functions ������������Ǻ��ߣ�
binary search           ������Ѱ��                              ���ֲ���
binary tree             ��Ԫ��                                  ������
binary operator         ��Ԫ������                              ��Ԫ�����
binding                 ϵ��                                    ��
bit                     λԪ                                    λ
bit field               λԪ�� ?                                λ��
bitmap                  λԪͼ ?                                λͼ
bitwise                 �� bit Ϊ��Ԫ��һ��                     ?
bitwise copy            �� bit Ϊ��Ԫ���и��ƣ�λԪ��һ����     λ����
block                   ����                                    �顢���顢����
boolean                 ����ֵ�����ֵ��true �� false��         ����ֵ
border                  �߿򡢿���                              �߿�
brace(curly brace)      ��������������                          ��������������
bracket(square brakcet) ��������������                          ��������������
breakpoint              �жϵ�                                  �ϵ�
build-in                �ڽ�                                    ����
bus                     ������
byte                    λԪ�飨�� 8 bits ��ɣ�                �ֽ�
cache                   ��ȡ                                    ���ٻ���
call                    ��������                              ����
callback                �غ�                                    �ص�
call operator           call����ʽ���У������� ()               ���������
                      ��ͬ function call operator��
candidate function      ��ѡ��ʽ                                ��ѡ����
                      ���ں�ʽ���ؾ�������г��ֵĺ�ѡ��ʽ��
chain                   �������� chain of function calls��      ��
character               ��Ԫ                                    �ַ�
check box               ��ȡ���� (i.e. check button)            ��ѡ��
check button            ��ť (i.e. check box)                   ��ѡ��ť
child class             ����𣨻��Ϊderived class, subtype��  ����
class                   ���                                    ��
class body              �����                                ���� ?
class declaration       ������桢�������ʽ                    ������
class definition        ����塢�����ʽ                    �ඨ��
class derivation list   ����ܻ���                              ��̳��б�
class head              ����ͷ                                ��ͷ ?
class hierarchy         ���̳���ϵ, ���ײ�                  ������ϵ
class library           ����ʽ�⡢����                      ���
class template          ���ģ�塢��𷶱�                      ��ģ��
class template partial specializations
                        ���ģ��ƫ�ػ�                          ��ģ�岿���ػ�
class template specializations
                        ���ģ���ػ�                            ��ģ���ػ�
cleanup                 ����������                              ���������
client                  �Ͷˡ��ͻ��ˡ��û���                    �ͻ���
client-server           ���Ӽܹ�                                �ͻ�/������
clipboard               ������                                  ������
clone                   ����                                    ��¡
                       (���� copy ����)
collection              Ⱥ��                                    ���� ?
combo box               ���Ϸ��顢���Ͽ�                        ��Ͽ�
command line            ������                                  ������
                       (ϵͳ����ģʽ�µ�����ִ������)
communication           ͨѶ                                    ͨѶ
compile time            ������                                  �����ڡ�����ʱ
compiler                ������                                  ������
component               ���                                    ���
composition             ���ϡ��ϳɡ����                        ���
computer                ���ԡ������                            �����������
concrete                �����                                  ʵ�ڵ�
concurrent              ����                                    ����
configuration           ��̬                                    ����
container               ����                                    ����
                      ��������ϵ�ij�ֽṹ�� list, vector...��
context                 ������ϵ�����⻷������������            ������������
control                 ����Ԫ�����ؼ�                          �ؼ�
const                   ������constant ����д��C++ �ؼ��֣�
constant                ���������� variable��                 ����������
constructor��ctor��     ����ʽ                                  ���캯����������
                        ����class ͬ����һ�� member functions��
copy                    ���ơ�����                              ����
cover                   ����                                    ����
create                  ����������                              ����������
creation                ����������                              ����������
data                    ����                                    ����
data member             ���ϳ�Ա����Ա����                      ���ݳ�Ա����Ա����
data structure          ���Ͻṹ                                ���ݽṹ
datagram                ����Ԫ                                  ���ݱ���
dead lock               ����                                    ����
debug                   ����                                    ����
declaration             ���桢����ʽ                            ����
deduction               �Ƶ�������template argument deduction�� �Ƶ����ƶ�
default                 Ԥ��                                    ȱʡ��Ĭ��
definition              ���塢������������ʽ                    ����
delegate                ί�ɡ�ί�С�ί��
delegation              ��ͬ�ϣ�
dereference             ���죨ȡ��ָ����ָ��������ݣ�          ������
dereference operator    dereference�����죩������ *             ���������
derived class           �������                                ������
design by contract      ��Լʽ���
design pattern          �����ʽ                                ���ģʽ
                        �� ����ұȽ�ϲ������Ʒ�ʽ��һ��
destructor��dtor��      �⹹ʽ                                  ����������������
device                  װ�á��豸                              �豸
dialog                  �Ի������Ի���                          �Ի���
directive               ָ�����using directive��            (����)ָʾ��
directory               Ŀ¼                                    Ŀ¼
distributed computing   �ֲ�ʽ���� (�ֲ�ʽ����)                 �ֲ�ʽ����
                        ��ɢʽ���� (��ɢʽ����)
document                �ļ�                                    �ĵ�
dot operator            dot����㣩������ .                     (Բ)�������
driver                  ������ʽ                                ����������
dynamic binding         ��̬ϵ��                                ��̬��
efficiency              ��Ч��Ч�ʡ�Ч��
entity                  ����                                    ʵ�塢����
encapsulation           ��װ                                    ��װ
enclosing class         ��Χ����볲״��� nested class �йأ���Χ��
enum (enumeration)      �о٣�һ�� C++ �����ͱ�               ö��
enumerators             �о�Ԫ��enum �ͱ��еij�Ա��             ö�ٳ�Ա��ö����
equality operator       equality���Ⱥţ�������  ==              �Ⱥ������
evaluate                ��������ֵ���˶�                        ����
event                   �¼�                                    �¼�
event driven            �¼�������                              �¼�������
exception               �쳣���                                �쳣
exception declaration   �쳣���棨ref. C++ Primer 3/e, 11.3��   �쳣����
exception handling      �쳣�������쳣��������                  �쳣�������쳣��������
exception specification �쳣���ref. C++ Primer 3/e, 11.4��   �쳣�淶
exit                    ���루ָ�뿪��ʽʱ����һ��ִ�е㣩      �˳�
explicit                ���׵ġ����Եġ���ʽ                    ��ʽ
export                  ���                                    ����������
expression              ����ʽ����ʽ                            ����ʽ
facility                ��ʩ���豸                              ��ʩ���豸
feature                 ����
field                   ��λ                                    �ֶ�
file                    ����                                    �ļ�
firmware                ����                                    �̼�
flush                   ������ɨ��                              ˢ��
form                    ������programming ���
formal parameter        ��ʽ����                                ��ʽ����
forward declaration     ǰ������                                ǰ������
fractal                 ����                                    ����
framework               ���                                    ���
full specialization     ȫ�ػ���ref. partial specialization��   ?
function                ��ʽ������                              ����
function call operator  ͬ call operator
function object         ��ʽ�����ref. C++ Primer 3/e, 12.3��   ��������
function overloaded resolution
                        ��ʽ���ؾ������                        �������ؽ����������
function template       ��ʽģ�塢��ʽ����                      ����ģ��
functor                 �º�ʽ                                  �º�ʽ������
generic                 ���͡�һ�㻯��                          һ�㻯�ġ�ͨ�õġ�����
generic algorithm       �������㷨                              ͨ���㷨
global                  ȫ���Եģ���Ӧ� local��                ȫ�ֵ�
global scope resolution operator
                        ȫ������ռ䣨��Χ���飩������ ::       ȫ�ַ�Χ���������
group                   Ⱥ��                                    ?
group box               Ⱥ�鷽��                                �����
hand shaking            ������
handle                  ʶ���롢ʶ��š������ơ�Ȩ��            ���
handler                 ������ʽ                                ��������
hardware                Ӳ��                                    Ӳ��
hash table              �Ӵձ�                                  ��ϣ����ɢ�б�
header file             ��ͷ������ͷ��                          ͷ�ļ�
heap                    �ѻ�                                    ��
hierarchy               �ײ���ϵ                                ��νṹ����ϵ��
hook                    �ҹ�                                    ����
hyperlink               ������                                  ������
IDE                     ���Ͽ�������                            ���ɿ�������
identifier              ʶ���֡�ʶ�����                        ��ʶ��
immediate base          ֱ�ӵģ����ٵģ��ϲ� base class��       ֱ���ϲ����
immediate derived       ֱ�ӵģ����ٵģ��²� derived class��    ֱ���²�������
implement               ʵ��                                    ʵ��
implementation          ʵ��Ʒ��ʵ���ʵ���塢ʵ����          ʵ��
implicit                �����ġ����Եġ���ʽ                    ��ʽ
import                  ����                                    ����
increment operator      �ۼ������� ++                           ���������
information             ��Ѷ                                    ��Ϣ
infrastructure          ������������
inheritance             �̳С��̳л���                          �̳С��̳л���
inline                  ����                                    ����
inline expansion        ����չ��                                ����չ��
initialization          ��ʼ����������                          ��ʼ��
initialization list     ��ֵ��                                  ��ʼֵ�б�
initialize              ��ʼ��                                  ��ʼ��
instance                ʵ��                                    ʵ��
                      ������ij�ֱ�����ʵ�ʲ����ġ���������
instantiated            ���ֻ���ʵ�廯����Ӧ��� template��     ʵ����
instantiation           �����塢���ֻ�ʵ�壨��Ӧ��� template�� ʵ��
integrate               ����                                    ����
interface               ����                                    �ӿ�
invoke                  ����                                    ����
iterate                 ��������Ȧһ���ֻ�һ���ֻصؽ��У�      ����
iterative               �����ģ�������
iterator                ��������һ�ַ���ָ�꣩                  ������
iteration               ��������Ȧÿ���ֻس�Ϊһ�� iteration��  ����
item                    ��Ŀ������                              ������Ŀ
laser                   ����                                    ����
level                   ��                                      ��
  �� high level           �߽�                                    �߲�
library                 ��ʽ�⡢��ʽ��                          �⡢������
lifetime                �����ڡ�����                            �����ڡ�����
link                    ���ᡢ����                              ����
linker                  ��������������                          ������
literal constant        ���泣������ 3.14 �� "hi" ��ȳ���ֵ��  ���泣��
list                    ����linked-list��                     �����������
list box                �б����顢�б���                        �б���
load                    ����                                    װ�ء�����
loader                  ������                                  װ������������
local                   �����Եģ���Ӧ� global��               �ֲ���
lock                    ����
loop                    ��Ȧ                                    ѭ��
lvalue                  ��ֵ                                    ��ֵ
macro                   �޼�                                    ��
maintain                ��                                    ��
manipulator             ��������iostream Ԥ�ȶ����һ�ֶ�����   ������
mechanism               ����                                    ����
member                  ��Ա                                    ��Ա
member access operator  ��Աȡ�������ӣ��� dot �� arrow ���֣�  ��Ա��ȡ�����
member function         ��Ա��ʽ                                ��Ա����
member initialization list
                        ��Ա��ֵ��                              ��Ա��ʼֵ�б�
memberwise              �� member Ϊ��Ԫ����members ��һ��      �Գ�ԱΪ��λ
memberwise copy         �� members Ϊ��Ԫ��һ����
memory                  ������                                  �ڴ�
menu                    ������ѡ��                              �˵�
message                 ѶϢ                                    ��Ϣ
message based           ��ѶϢΪ������                          �����Ϣ��
message loop            ѶϢ��Ȧ                                ��Ϣ��
method (java)           ��������Ϊ
micro                   ΢                                      ΢
modeling                ģ��
modeling language       ��ģ���ԣ���ģ����
module                  ģ��                                    ģ��
most derived class      ��ĩ���������                          ��ײ��������
mouse                   ����                                    ���
mutable                 �ɱ��                                  �ɱ��
multi-tasking           �๤                                    ������
namespace               �����ռ�                                ���ֿռ䡢�����ռ�
nested class            ��״���                                Ƕ����
object                  ���                                    ����
object based            �����Ϊ������                          ��춶����
object model            ���ģ��                                ����ģ��
object oriented         ��������                              ��������
online                  ����                                    ����
operand                 ����Ԫ                                  ������
operating system (OS)   ��ҵϵͳ                                ����ϵͳ
operation               ������������Ϊ                          ����
operator                ������                                  �������������
option                  ѡ��                                    ѡ��
overflow                ������λ������ underflow��            �����underflow:���磩
overhead                ���⸺��                                ���⿪��
overload                ���ػ������ػ�������                    ����
overloaded function     ���ػ���ʽ                              ���صĺ���
overloaded operator     ���ػ�������                            �����ص������
overloaded set          ���ؼ���                                ���ؼ���
override                ��д����д                              ���ء���д�����¶���
                      ���� derived class �����¶������⺯ʽ
package                 �׼�
pair                    ����
palette                 ��ɫ�̡�����̡�������
pane                    ����                                    ����
                      ����ʱΪǶ��֮�⣬�� Java Content Pane��
parameter               ��������ʽ�������ϵı�����              ��������ʽ����������
parameter list          ������                                  �����б�
parent class            ����𣨻�� base class��               ����
parentheses             С������С����                          Բ������Բ����
parse                   ����                                    ����
partial specialization  ƫ�ػ���ref. C++ Primer 3/e, 16.10��    �ֲ��ػ�
                        ��ref. full specialization��
pass by address         ��ַ����ʽ�����Ĵ��ݷ�ʽ��              ����ַ
pass by reference       ��ַ����ʽ�����Ĵ��ݷ�ʽ��              ����ַ
pass by value           ��ֵ����ʽ�����Ĵ��ݷ�ʽ��              ��ֵ
pattern                 ��ʽ                                    ģʽ
                        �� ����ұȽ�ϲ������ʽ��һ��
performance             ��                                    ����
pixel                   ͼ�ء�����                              ����
placement delete        ref. C++ Primer 3/e, 15.8.2
placement new           ref. C++ Primer 3/e, 15.8.2
platform                ƽ̨                                    ƽ̨
pointer                 ָ��                                    ָ��
                        ַλ������ַ���� reference �γɶ�ӳ�����ã�
polymorphism            ����                                    ��̬
pop up                  ð��ʽ������ʽ                          ����ʽ
port                    ��
precedence              ������ͨ����������ӵ�����ִ�д���
preprocessor            ǰ������                                Ԥ������
primitive type          �����ͱ� (��ͬ� base class)
print                   ��ӡ                                    ��ӡ
printer                 ӡ����                                  ��ӡ��
priority                ����Ȩ (ͨ�����ִ������� CPU ʱ������ȴ���
procedure               ����                                    ����
procedural              �����Եġ�����ʽ��                      ����ʽ��
process                 �г�                                    ����
profile                 ����                                    ����
profiler                ��������                              ��������
programmer              ��ʽԱ                                  ����Ա
programming             ��̡���ʽ��ơ���ʽ��                  ���
progress bar            ����ָʾ��                              ����ָʾ��
project                 ר��                                    ��Ŀ������
property                ???                                     ����
protocol                ��                                    ��
pseudo code             ���롢�����롢α��                      α��
qualified               �����ʸ����Σ�������� scope �����ӣ�   �޶� ?
qualifier               �ʸ����δʡ��δ�                        �޶����δ� ?
quality                 Ʒ��                                    ����
queue                   ����                                    ����
radio button            Բť                                    ��ѡ��ť
raise                   ��������������ʾ����һ�� exception��    ��������
random number           �����������                            �����
range                   ��Χ�����䣨��� STL ʱ��               ��Χ������
rank                    �ȼ����ֵȣ�ref. C++Primer 3/e 9,15�£� �ȼ�
raw                     ���ʵġ�δ��������                      δ��������
record                  ��¼                                    ��¼
recordset               ��¼��                                  ��¼��
recursive               �ݻ�                                    �ݹ�
re-direction            �ص���                                  �ض���
refactoring             �ع�������                              �ع�
refer                   ȡ��                                    ����
reference             ��C++ ������ָ��Ķ������൱� "����"��   ���á�����
                        ַ����, see pointer
register                �ݴ���                                  �Ĵ���
relational database     ����ʽ���Ͽ�                            ��ϵ���ݿ�
represent               ����������                              ����������
resolve                 ���飨Ϊ��ʽ�еķ�������Ѱ��            ����
                              ��Ӧ֮����ʽ�Ĺ��̣�
resolution              ������򡢾������                      ��������
return                  ���ء��ط�                              ����
return type             �ط��ͱ�                                ��������
return value            �ط�ֵ                                  ����ֵ
robust                  ǿ�̡��Ƚ�                              ��׳
robustness              ǿ���ԡ��Ƚ���                          ��׳��
routine                 ��ʽ                                    ����
runtime                 ִ����                                  ִ���ڡ�ִ��ʱ
rvalue                  ��ֵ                                    ��ֵ
save                    ����                                    �洢
schedule                �ų�                                    ����
scheduler               �ų���                                  ���ȳ���
scroll bar              ����                                    ������
scope                   ����ռ䡢���淶Χ������                ����ռ�
scope operator          ����ռ䣨��Χ���飩������  ::          ����ռ������
scope resolution operator
                        ����ռ����������                      ����ռ���������
                      ����scope operatorͬ��
search                  ��Ѱ                                    ����
semantics               ����                                    ����
sequential container    ����ʽ����                              ˳��ʽ����
                      ����Ӧ� associative container��
server                  �ŷ������ŷ���                          �������������
serialization           �εڶ�д                                ���л�
  (serialize)
signature               ���ʽ
slider                  ����                                    ����
slot                    ���ס���                                ��
smart pointer           ����ָ�ꡢ����ָ��                      ����ָ��
specialization          ���⻯�����⻯���塢���⻯����          �ػ�
splitter                �����Ӵ�                                �зִ���
software                ����                                    ����
source                  ԭʼ��                                  Դ�롢Դ����
stack                   �ѵ�                                    ջ
stack unwinding         �ѵ�շת���⣨�˴���� exception ���⣩ ջշת���� *
standard library        ��׼��ʽ��
standard template library ��׼ģ���ʽ��
statement               ����                                    ��䡢����
status bar              ״̬�С�״̬��                          ״̬��
STL                     �� standard template library
stream                  ������������                            ��
string                  �ִ�                                    �ַ���
subscript operator      �±������� [ ]                          �±������
subtype                 ���ͱ�                                  ������
support                 ֧Ԯ                                    ֧��
syntax                  �﷨                                    �﷨
target                  ��ģ��� target pointer�����ָ�꣩     Ŀ��
task switch             �����л�                                �����л�
template                ģ�塢����                              ģ��
template argument deduction
                        ģ�������Ƶ�                            ģ�������Ƶ�
template explicit specialization
                        ģ����ʽ�ػ����汾��                    ģ����ʽ�ػ� ?
template parameter      ģ������                                ģ������
text file               ��ʽ���ĵ������ó�ʽԭʼ��ĵ�����      �ı��ļ�
thread                  ִ����                                  �߳�
throw                   ��������ָ����һ�� exception��          ����������
token                   ��㵥Ԫ                                ���š����
transaction             ����                                    ����
trigger                 ����                                    ����
type                    �ͱ�                                    ����
UML unified modeling language  ͳһ��ģ����
unary operator          һԪ������                              һԪ�����
underflow               ����������� overflow��             ����
unqualified             δ���ʸ����Σ���ֱ��ȡ�ã�              ?
unwinding               ref. stack unwinding                    ?
variable                ���������춳��� const��                ����
vector                  ������һ���������е����� array��        ����
viable                  ��ʵ�еġ����е�                        ���е�
viable function         ���к�ʽ                                ���к���
                      ���� candidate functions �������ߣ�
view                                                            ��ͼ
  (document/view)
virtual function        ���⺯ʽ                                �麯��
volatile                �׻ӷ��ġ��ױ��                        ?
window                  �Ӵ�                                    ����
window function         �Ӵ���ʽ                                ���ں���
window procedure        �Ӵ���ʽ                                ���ڹ���
word                    ��                                      ��
wrapper                 �⸲�����


xxx based               �� xxx ����                           ��� xxx
xxx box                 xxx �С�xxx ���顢��                    xxx ��
  ���� dialog box       �Ի��С��Ի����顢�Ի���                �Ի���
xxx oriented            xxx ����                                ���� xxx

---------------------------------------------------------------------------------------