C++        GLOSSARY 




   A Mc Millan & Mc Cluskey PRODUCT


                This page is designed in Association with   Glen Mc Cluskey





                       C++ PROGRAMS

                       C++   PROJECTS

                       C++       DOUBTS

                       C++          RULES      






abstract class

abstract Data Type (ADT)


access control

access declaration

access Operations

access Specifier







argument matching





assignment operator



base class

bit field

bitwise copy




built-in type



C-style string

call by reference

call by value

calling conventions









class hierarchy

class layout

class library

class member

class Network

class Oriented

class template

Classification Structure


compilation unit


composition structure



constant expression



container class



copy constructor


data abstraction

Data Hiding

Data Member




declaration statement



default argument

delete operator

delete[] operator



derived class






Dynamic Binding

Dynamic Memory allocation

dynamic storage



embedded system






exception handler

exception handling



expression statement


external name




floating point


forward class

free store


front end


function template

fundamental type

garbage collection

generic class

generic programming

global name

global namespace

global scope

global variable




header file

heap storage

helper class



implementation-dependent behavior

implicit conversion


Information Hiding:






inline function


Instance variable




integral conversion

integral promotion










local class

local variable


long double





member function

member pointer

memberwise copy


mixed-mode arithmetic


multiple inheritance



name lookup

name mangling

name space


namespace alias

namespace member

nested class

new handler

new operator

new-style cast

new[] operator


null pointer



object file

object layout


old-style cast




operator overloading


overload resolution



parameterized type





pointer to data member

pointer to function

pointer to member








private base class

programming environment






public base class

pure virtual function


recursive descent parser








return value



run-time efficiency

run-time type information



semantic analysis


separate compilation




single Inheritance:


smart pointer


stack frame

stack unwinding

standard conversion

standard library



static binding

static member

static object

static storage

static type checking


storage class


stream I/O





symbol table


systems programming



template argument

template class

template declaration

template definition

template instantiation

template parameter





translation limit

translation unit




try block


type checking

type conversion

type safety

type system

type-safe linkage






user-defined conversion

user-defined type

using declaration

using directive

using namespace



virtual base class

virtual function

virtual table







abstract class - A class that can only be used as a base class to derive one or more sub classes. No objects of an abstract base class are created. A class is abstract if it contains at least one pure virtual function.

abstract Data Type(ADT): An abstraction that describes a set of objects in terms of an encapsulated or hidden data and operations on that data.

Abstraction: The act of representing the essential features of something without including much detail.

access control - a C++ mechanism for prohibiting or granting access to individual
members of a class. See public, private, protected, and visibility.

access declaration - a way of controlling access to a specified member of
a base class when it is used in a derived class.

access Operations: Operations which access the state of a variable or object but do not modify it.

access Specifier - a way of labelling members of a class to specify what
access is permitted. See public, private, and protected.

aggregate - an array or object of a class with noconstructors, no private
or protected members, nobase classes, and no virtual functions. Seeinitializer
and initialization.

allocation - the process of giving memory space to an object. See dynamic storage,
static storage, and deallocation.

alias: Reference to a variable. Two or more variable that refer to the same data in memory is said to be aliases of one another.

Anonymous: Means unnamed. Anonymous enum means defining a enumerated type without enum name 7 variable. ex: (enum{false,true}; For an Anonymous union the members can be used as ordinary variables.

ANSI - acronym for American National Standards Institute, a standards body
currently standardizing C++.

argument - when calling a function, refers to the actual values passed to
the function. See parameter.

argument matching - the process of determining which of a set of functions
of a specified name matches given arguments in a function call.

ARM - acronym for the book The C++ Annotated Reference Manual, a C++ reference
book by Ellis and Stroustrup.

array - an ordered and indexable sequence of values. C++ supports arrays
of a single dimension (a vector) or of multiple dimensions.

asm - C++ keyword used to specify assembly language in the middle of C++
code. It's use is implementation dependent.

assignment - the process of giving a value to a pre-existing object. See
copy constructor and initialization.

assignment operator - an operator for doing assignment. See also copy constructor.

Attribute: A property of an object. It cannot exist independently of the object. Attributes may take other objects as values.

auto - a C++ keyword used to declare a stack-based local variable in a function.
This is the default( declared within main or any other function) and is normally not needed. An auto variable is visible only in the block or function where it is declared. See storage class.

base class -  A class that is used to derive one or more subclasses. The derived class have the ability to inherit all the capabilities of the base class. Also known as superclass. See inheritance.

bit field - a member of a class that represents small integral values.

bitwise copy - to copy an object without regard to its structure or members.
See memberwise copy.

bool - C++ keyword used to declare a Boolean data type.

break - C++ keyword used to specify a statement that is used to break out
of a for or while or do- while loop or out of a switch statement. CANNOT BE USED WITHIN AN UNEMBEDDED IF STRUCTURE.

browser - a software development tool used for viewing class declarations
and the class hierarchy. See programming environment.

built-in type - see fundamental type.

C - a programming language in widespread use. C++ is based on C.


C-style string - refers to a char* and to the contents of any dynamic storage
it may point at. C++ does not have true strings as part of the language
proper, though a standard string class library is envisioned as part of the
ANSI standardization effort.

call by reference - A function call mechanism used to access the actual arguments of the function by passing its address. The only mechanism used to pass more than one values from function. Also passing a pointer by an argument to a function. The
function can then change the argument value. See call by value.

call by value - passing a copy of an argument to a function. The function
cannot then change the argument value. C and C++ use call by value argument
passing. But also see pointer and reference, also call by reference.

calling conventions - refers to the system-specific details of just how the
arguments to a function are passed. For example, the order in which they
are passed on the stack or placed in machine registers.

case - a C++ keyword used to denote an individual element of a switch statement. It is the label of a switch statement. CASE CONSTANT MUST BE AN INTEGRAL CONSTANT.

cast - a way of doing explicit type conversion via a cast operator. See
new-style cast, old-style cast.

catch - a C++ keyword used to declare an exception handler. Usually to catch unusual conditions in a program.

cerr - in C++ stream I/O, the standard error stream.

cfront - a C++ front end that translates C++ source code to C code, which
is then compiled via a C compiler. Originally developed by AT&T Bell Labs
in the mid-1980s.

char - a C++ keyword used to declare an object of character type. Often
considered the same as a byte, though it is possible to have multi-byte characters. It is a basic data type of size 1 byte.

cin - in C++ stream I/O, the standard input stream.

class - a C++ keyword used to declare the fundamental building block of C++
programs. Class is the template of one or more objects. It describes how object are created in memory. A class has a tag, members, access control mechanisms, and so

class hierarchy - Class hierarchy contains base classes and derived classes. see base class, derived class.

class layout - the way in which data class members are arranged in a class

class library - a set of related classes declared in header files and defined
in object files

class member - a constituent member of a class, such as a datadeclaration,
a function, or a nested class.

class network: When a derived class have more than one base classes it is said to be class network or multiple inheritance. A collection of classes, some of which are derived from others. It is sometimes known as FOREST MODEL of classes.

Class-Oriented: Object based systems in which every instance belongs to a class, but classes may not have superclasses.

class template - a template used for generating classtypes.

classification structure: A tree or network structure based on the semantic primitives of inclusion and membership which indicates that inheritance may implement specialization or generalization.

comments - C++ has C-style comments delimited with /* and */, and new C++-style
line-oriented comments starting with //.

compilation unit - see translation unit.

compiler - a software tool that converts a language such as C++ into a different
form, typically assembly language. See front end.

composition structure:  A tree structure based on the semantic primitive ' part-of' which indicates that certain objects may be assembled from the collection of other objects.

const - a C++ keyword & data type qualifier used to declare an object as constant or used to declare a constant parameter. A CONSTANT CAN NOT BE GIVEN NEW VALUES AT PROGRAMS RUNS.

constant - a literal or variable declared as const.

constant expression - a C++ expression that can be evaluated by thecompiler.
Used to declare bounds for an array among other things.

constructor - A member function which is called automatically when creating objects for the class. It has the same name as class name and have no return types. This is a function called when a class object comes into scope. The
constructor is used to initialize the object. See allocation, copy constructor,
and destructor.

const_cast - a C++ keyword used as a style of cast for explicitly casting
away const.

container class - class or template that contains the objects
of other classes. Lists and stacks would be examples of container classes.

continue - C++ keyword used with for , while and do-while statements to continue the
iteration at the top of the loop. It works only with innermost iterations and not innermost decisions.  CANNOT BE USED WITH UNEMBEDDED DECISIONS.

conversion - to convert from one data type to another.

copy constructor - The constructor that creates a new class object from an existing object of the same class. That is a special type of constructor that is called when an object is copied. If a constructor takes a reference to an object of the same class, as itself as an Argument, then it is a copy constructor. See memberwise copy.

cout - in C++ stream I/O, the standard output stream.

data abstraction - the idea of defining a data representation (for example,
to represent a calendar date), and a set of operations to manipulate that
representation, with no public access to the representation except via the
operations. See class.

Data Hiding: Isolating the data from unauthorized access is called as hiding. Preventing private data to access from outside of the class is data hiding

Data Member: A variable declared in a class having the scope of at least the entire class.

deallocation - the processing of freeing memory space previously used by
an object. See allocation.

debugger - a tool for stepping through the execution of a program, examining
variables, setting breakpoints, and so on.

declaration - a C++ entity that introduces one or more names into a program.

declaration statement - a declaration in the form of astatement that may
be used in C++ where statements would normally be used.

declarator - a part of a declaration that actually declares an identifier
name. A declarator appears after a sequence of type and storage class specifiers.

default: It is a default label in a switch statement, called when no matches in a case label found.

default argument - Initialization of the function. an optional argument to a function. A value specified in the function declaration is used if the argument is not given.

delete operator - C++ keyword and operator used to delete an object from memory that was created by new operator. see also dynamic storage.

delete[ ] operator - See delete operator. Used to delete array objects.

demotion - converting a fundamental type to another fundamental type, with
possible loss of precision. For example, a demotion would occur in converting
a long to a char.

deprecate - to make obsolete (a language feature).

derived class - a class that inherits some or all of its members from a base class. See inheritance.

destructor - a function called when a class object goes out of scope used to delete the object. It cleans up the object, freeing resources like dynamic storage. See constructor
and deallocation.

dialect - refers to a variant of a programming language, used by a subset
of the software community. Can also refer to a particular style of programming.

do - An iteration executed at least one time, without regarding to the conditional expression. see while.

dominance - refers to the case where one name is used in preference to another.
See multiple inheritance.

double - C++ keyword used to declare a floating  point type having a size of 8 bytes and 15 decimal digits.

Dynamic Binding: The addresses of the functions are determined at runtime rather than compile time. Also known as LATE BINDING.

dynamic storage - refers to memory allocated and deallocated during program
execution using the new operator and delete operator.

dynamic_cast - a C++ keyword that specifies a style of cast used with run-time type information.
Using dynamic_cast one can obtain a pointer to an object of a derived class
given apointer of a base class type. If the object pointed to is not of th
specified derived class, dynamic_cast will return 0.

else - C++ keyword, part of the if statement executed only when the if expression is false..

embedded system - a low-level software program that executes without much
in the way of run-time services, such as those provided by an operating system.

encapsulation - a term meaning to wrap up or contain within. Binding data and functions together is called as encapsulation. Used in relation to the members of a class. See access control.

enum - C++ keyword used to declare an enumeration. User defined Integer entities.

enumeration - a set of discrete named integral values. See enum.

enumerator - a member of an enumeration.

exception - a value of some type that is thrown. Seeexception handling.

exception handler - a piece of code that catches anexception. See catch
and try block.

exception handling - the process of signalling that an exceptional condition
(such as divide by zero) has occurred. An exception isthrown and then caught
by an exception handler, after stack unwinding has occurred.

explicit - a C++ keyword used in the declaration ofconstructors to indicate
that conversion of an initializer should not take place.

expression - a combination of constants, variables, andoperators used to
produce a value of some type.

expression statement - a statement that is an expression, such as a function
call or assignment.

extern - a C++ keyword used to declare an external name. Usually used to tell the compiler that the variable denoted as extern is initialized in another source file.

external name - a name available to other translation units in a program.
See linker and global variable.

false - C++ keyword used to specify a value for the booltype.

finalization - to declare that an object or resource is no longer needed,
and initiate cleanup of that object. Seeinitialization.

float - a C++ keyword used to declare a floating point type of size 4 bytes and has a precision of 7 digits.

floating point - non-integral arithmetic. A floating-point number is typically
represented as a base-two fraction part and an exponent.

for - a C++ keyword used to specify an iteration or looping statement.

forward class - a class for which only the tag has been declared. Such a
class can be used where the size of the class is not needed, for example
in pointer declarations.

free store - A pool of memory from which storage for objects are allocated. It is also known as HEAP. see dynamic storage.

friend - A function that has access to the private members of a class but is not itself a member of the class. A entire class can be a friend of another class. a type of declaration used within a class to grant other classes or functions access to that class. A function may be friend to more than one classes.See access control.

front end - often refers to the early stages of C++ compilation, such as
parsing and semantic analysis.

function - a C++ entity that is a sequence of statements. It has its own
scope, accepts a set of argument values, and returns a value on completion.

function template - a template used for generating functiontypes.

fundamental type - a type built in to the C++ language. Examples would be
integral types like int and pointer types such as void*.

garbage collection - a way of automatically managing dynamic storage such
that explicit cleanup of storage is not required. C++ does not have garbage
collection. See new operator and delete operator.

generic class: A class definition that depends on a parameter. A family of classes can be defined by setting the parameter to different data types. Also known asPARAMETERIZED CLASS.

generic programming - see template.

global name - a name declared at global scope.

global namespace - the implicit namespace where global variables reside.

global scope - see global namespace.

global variable - a variable that is accessible throughout the whole program,
whose lifetime is that of the program.

goto - C++ keyword, used to transfer control within a C++ function indicated by a label (declared variable). See label.

grammar - a way of expressing the syntax of a programming language, to describe
exactly what usage is valid and invalid.

header - see header file.

header file - a file containing class declarations,preprocessor directives,
and so on, and included in a translation unit. It is expanded by the preprocessor.

heap storage - see dynamic storage.

helper class - a class defined as part of implementing the details of another

hiding - see encapsulation.

if - C++ keyword used in conditional statements. Execute the block once, only if the test expression is true.

implementation-dependent behavior - not every aspect of a programming language
like C++ is specified in a language standard. This term refers to behavior
that may vary from implementation to implementation.

implicit conversion - a conversion done as part of another operation, for
example converting a pointer type to bool in anif statement.

Indirection: The operator *, which is used to access a value referred to by a pointer.

Information Hiding: The principle which states that the state and implementation of an object or module should be private to that object or module and only accessible via its public interface.

inheritance  Deriving one or more subclasses from a base class is called as inheritance. The derived class have the ability to access the capabilities of the base class and also have the possibility to add its own features.

initialization - to give an initial value to an object. See constructor
and assignment.

initialize - the process of initialization.

initializer - a value or expression used to initialize anobject during initialization.

inline - C++ keyword used to declare an inline function. Request to the compiler that the function call should be substituted by the function block.

inline function - a function that can be replaced with actual code by a compiler at the point of call, thereby saving the overhead time required to call the function.

Instance: An Instance of a class is an object whose type is the class in question.

Instance Variable: A data member that is not designated as static.

instantiation - The creation of a data item representing a variable or a class (giving a value to something) see template instantiation.

int - a C++  keyword and Default fundamental type, used to declare an integral type of size 2 bytes.

Interface: The visible methods of an object.

integral conversion - the process by which an integer is converted to signed
or unsigned.

integral promotion - the process by which a bool, char, short,enumerator,
or bit field are converted to int for use in expressions, argument passing,
and so on.

keyword - a reserved identifier in C++, used to denote data types,statements
of the language, and so on.

label - a name that is the target of a goto statement.

layout - refers to the way that objects are arranged in memory.

library - a set of object files grouped together. A linker will search them
repeatedly and use whatever object files are needed. See class library.

lifetime - refers to the duration of the existence of an object. (time period between creation and destruction of an object) Some objects last for the whole execution of a program, while other objects have a shorter

linkage - refers to whether a name is visible only inside or also outside
its translation unit.

linker - a program that combines object files and library code to produce
an executable program.

literal - a constant like 1234.

local - typically refers to the scope and lifetime ofnames used in a function.

local class - a class declared local to a function.

local variable - a variable declared local to a function.

long - C++ keyword used to declare a long integer data type of size 4 bytes.

long double - a floating point type in C++.

lvalue - an expression referring to an object. Seervalue.

macro - a preprocessor feature that supports parameter substitution and expansion
of commonly-used code sequences. Seeinline function.

mangling - see name mangling.

member - see class member and namespace member.

member function - A function declared within the class and not declared as a friend. a function that is an element of a class and that operates
on objects of that class via the this pointer to the object.

member pointer: A pointer that designates a member of a class. Member pointers are distinct from, and must not be confused with pointers that designate data objects.

memberwise copy - to copy an object a member at a time, taking into account
a copy constructor for the member. See bitwise copy.

method - see member function.

mixed-mode arithmetic - mixing of integral and floating point arithmetic.

module - see translation unit.

multiple inheritance - a derived class with multiple base classes. See inheritance and also class network.

mutable - C++ keyword declaring a member non-constant even if it is a member
of a const object.

name - an identifier that denotes an object, function, a set ofoverloaded
functions, a type, an enumerator, a member, a template, a namespace, or a

name lookup - refers to taking a name and determining what it refers to,
or its value, based on the scope and other rules of C++.

name mangling - a way of encoding an external name representing a function
so as to be able to distinguish the types of itsparameters. See overload.

name space - a grouping of names.

namespace - a C++ keyword used to declare a namespace, which is a collection
of names such as function declarations, classes, and so on.

namespace alias - an alias for a namespace, that can be used to refer to
the namespace.

namespace member - an element of a namespace, such as afunction, typedef,
or class declaration.

nested class - a class declaration nested within anotherclass.

new handler - a function established by callingset_new_handler. It is called
when the new operator cannot obtain dynamic storage.

new operator - C++ keyword and operator used to allocate dynamic storage. Usually used to allocate memory for objects from free store.

new-style cast - a cast written in functional notation.

new [ ] operator - see new operator. Used to allocate dynamic storage for
array objects.

NULL - a special constant value that represents a null pointer.

null pointer - A pointer that does not point to any data object. a pointer value that evaluates to zero.

object  has several meanings. In C++, often refers to an instance of a class. Allocate memory for a class members and used to access the class members. Also more loosely refers to any named declaration of a variable or other entity that involves storage.

object-based: Systems that support all the object-oriented features except Polymorphism and Inheritance.

object file - in C or C++, typically the output of a compiler. An object
file consists of machine language plus an external name list that is resolved
by a linker.

object layout - refers to the ordering of data members within aclass.

object-oriented - this term has various definitions, usually including the
notions of object based and Inheritance with polymorphism.

old-style cast - a cast written in C style, with the type in parentheses
before the value being casted.

OOA / OOD - acronym for object-oriented analysis andobject-oriented design,
processes of analyzing and designingobject-oriented software.

OOP - acronym for object-oriented programming.

operator - A c++ keyword and a built in operation of the C++ language, or an overloaded operator corresponding to a member function of a class. Usually used to overload c++ operators to operate on user defined data .See function
and operator overloading.

operator overloading - The ability to make an existing operator to operate on user defined data types is called as operator overloading.

overload - to specify more than one function of the same name, but with varying
numbers and types of parameters. See argument matching.

overload resolution - see argument matching.

overriding: The ability to change the definition of an inherited method or attribute in a subclass.

parameter - refers to the variables passed into a function. See also argument.

parameterized type - see template.

parser - see parsing.

parsing - the process by which a program written in some programming language
is broken down into its syntactic elements.

placement - the ability to define a variant of the new operator to take an
additional argument that specifies what storage is to be used.

pointer - an address of an object.

pointer to data member - a pointer that points at a data member of a class.

pointer to function - an address of a function or a member function.

pointer to member - see pointer to data member, pointer to function.

polymorphism - the ability to call a variety of member functions for a given
class object using an identical interface in each case. See virtual function.

postfix - refers to operators that appear after their operand. See prefix.

pragma - a preprocessor directive used to affect compiler behavior in an
implementation-defined way.

prefix - refers to operators that appear before their operand. See postfix.

preprocessing - a stage of compilation processing that occurs before the
compiler proper is invoked. Preprocessing handles macro expansion among
other things. In C++ use of const and inline functions makes preprocessing
less important.

preprocessor - A part of the compiler . see preprocessing.

private - a C++ keyword used to specify that a class member can only be accessed
by its own member functions and friends of the class. Also used to indicate that the members of base class cannot be access by using the base class objects. See access control, protected, and public.

Private Base class: A base class which allows its public and protected members to be inherited as "private" members of the derived class. Thus, the inherited members are accessible to the members and friends of the derived class, but they are not accessible to the users of the derived class.

programming environment - a set of integrated tools used in developing software,
including a compiler, linker,debugger, and browser.

promotion - see integral promotion.

protected - a C++ keyword used to specify that a class member can only be
accessed by member functions and friends of its own class and by member functions
and friends of classes derived from this class. See private, public, and access control.

prototype: The declaration of the function which specify the function name,return type and argument types to the main function is called as prototype.

PT - see parameterized type.

public - a C++ keyword used to specify that class members are accessible
from any (non-member) function throughout the programs. (expect by privately derived class's objects) See access control, protected, and private.

public base class: A base class which allows its public and protected members to be inherited by a derived class.

pure virtual function - A virtual function that is declared in a base class but not defined there. The responsibility for defining the function falls on the derived classes, each of which generally provides a different definition. It is illegal to create instances of a class that declares a pure virtual function.a virtual function with a "= 0" initializer. See abstract class.

qualification - to prefix a name with the name of a class ornamespace.

recursive descent parser - see parsing. This is a type of parsing used in
C++ compilers. It is more flexible than the older Yacc approach often used
in C compilers.

reference - alternative name(alias) for an object. Access to an object via a reference
is like manipulating the object itself. References are typically implemented
as pointers in the underlying generated code.

register - C++ keyword used as a hint to the compiler that a particular local variable
should be placed in a machine register. Used for faster access of the variable.

reinterpret_cast - a C++ keyword used as a style of cast for performing unsafe
and implementation dependent casts.

repository - a location where an instantiated template class can be stored.
See template instantiation.

resolution - see overload resolution.

resumption - a style of exception handling where program execution continues
from the point where an exception isthrown. C++ uses the termination style.

return - C++ keyword used for returning values from a function. Also used to indicate the end of the function execution and to transfer the control back to the calling function.

return value - the value returned from a function.

RTTI - acronym for run-time type information.

run-time - refers to actions that occur during program execution.

run-time efficiency - refers to the issue of whether basic C++ operations
will cause a performance penalty when the program is run.

run-time type information - a system for determining at run-time what the
type of an object is.

rvalue - a value that may appear on the right-hand side of anassignment.

scope - the region of a program where a name has visibility.

semantic analysis - a stage that a compiler goes through afterparsing.
In this stage the meaning of the program is analyzed.

semantics - the meaning of a program, as opposed to its syntax.

separate compilation - refers to the process by which eachtranslation unit
of a program is compiled separately to produce anobject file. The object
files are then combined by a linker.

set_new_handler - a function used to establish a new handler.

short - a C++ fundamental type used to declare small integers.

signed - C++ keyword used to indicate a signed data type (by default).

single inheritance: The situation in which the derived class has only one base class.

sizeof - C++ keyword for taking the size of an object or type in bytes.

smart pointer - an object that acts like a pointer but also does some processing
whenever an object is accessed through them. The C++ operator -> can be
overloaded to achieve this effect.

specialization - a special case of a template defined for particular template argument

stack frame - refers to a region of storage on the hardware stack, used to
store information such as local variables for each invocation of a function.

stack unwinding - see exception handling. When an exception is thrown, each
active stack frame must be removed from the stack until an exception handler
is found. This process involves calling a destructor as appropriate for
each local object in the stack frame, and so on.

standard conversion - refers to standardized conversions betweentypes, such
as integral conversion.

standard library - see library. The C++ standard library includes much of
the C standard library along with new features such as strings and container class

statement - the parts of a program that actually do the work.

static - a storage class Specifier. when it is applied to a local variable, permanent storage is created and it returns its value between function calls in the program. When it is applied to a global variable, the variable becomes internal to the file in which it is declared. see also static member, static object, and static storage.

static binding: The opposite of dynamic binding. The functions are bound to the code to be executed at compile time. Also known asEARLY BINDING.

static member - a class member that is part of a class for purposes of access control
but does not operate on particular object instances of the class.

static object - an object that is local to a function or to a translation unit
and whose lifetime is the life of the program.

static storage - storage that persists throughout the life of the program.
See static object and dynamic storage.

static type checking - refers to type checking that occurs during compilation
of a program rather than at run-time.

static_cast - a C++ keyword specifying a style of cast meant to replace old-style
C casts.

storage class - see auto and static.

stream - an object used to represent an input or output channel. See stream I/O.

stream I/O - a C++ I/O library using overloaded operators << and>>. It
has more type safety than C-style I/O.

string - see C-style string.

struct - a C++ class in which all the class members are by default public.

switch - C++ keyword denoting a control statement and decision, used to dispatch to one of several sequences of statements based on the value of an expression. Also known as multiway branching statement.

symbol table - a compiler structure used to record type information about
program names. The symbol table is used to generate compiler output.

syntax - the rules that govern how C++ expressions,statements, declarations,
and programs are constructed. Seegrammar and semantics.

systems programming - refers to low-level programming, for example writing
I/O drivers or operating systems. C and C++ are suitable languages for this
type of programming.

tag - a name given to a class, struct, or union.

template - a parameterized type. A template can accept type parameters that
are used to customize the resulting type. Used to declare generic classes and functions.

template argument - an actual value or type given to atemplate to form a
template class. See argument.

template class - a combination of a template with a template argument list
via the process of template instantiation.

template declaration - a declaration of a template with its associated template parameter

template definition - an actual definition of a template or one of its members.

template instantiation - the process of combining template arguments with
a template to form a template class.

template parameter - a value or type declared to be passed in to atemplate.
See parameter.

temporary - an unnamed object used during the evaluation of an expression
to store intermediate values.

termination - a style of exception handling where control does not return
to the point where an exception is thrown. C++ uses this style of exception

this - C++ keyword used in a member function to point at the object currently
being operated on (with the help of an arrow operator). It is passed implicitly to an overloaded operator function.

throw - C++ keyword used to throw (initiate) an exception for further action. See exception handling.

translation limit - a limit on the size of a source program that acompiler
will accept.

translation unit - a source file presented to a compiler with anobject file
produced as a result.

trigraph - a sequence of characters used to represent another character,
for example to represent a character not normally found in the character

true - C++ keyword used to specify a value for the booltype.

try - C++ keyword used to delimit a try block. Instruct the compiler to try a particular function, while there is a chance to exception.

try block - a statement that sets up a context for exception handling. A
subsequent throw from a function called from within the try block will be
caught by the exception handler associated with the try block or by a handler
further out in the chain of handlers.

type - a property of a name that determines how it can be used. For example,
an object of a class type cannot be assigned to an integer variable.

type checking - see type system.

type conversion - converting a value from one type to another, for example
via a constructor.

type safety - see type system.

type system - a system of types and operations on objects of those types.
Type checking is done to ensure that the operations for given types are
appropriate, for example that a function is called with arguments of the
appropriate types.

type-safe linkage - refers to the process of encoding parametertype information
in external names so that the linker will reject mismatches between the use
and definition of functions. See name mangling.

typedef - a C++ keyword used to declare an alias for a type. Used to write complex declarations easily for further use.

typeid - an operator that returns an object describing thetype of the operand.
See run-time type information.

union - a structure somewhat like a class or struct, except that individual
union members share the same memory. See class layout.

unsigned - a C++ keyword used to declare an integral unsigned fundamental type.

unwinding - see stack unwinding.

user-defined conversion - a member function that supportsconversion from
an object of class type to any target type.

user-defined type - a class or typedef.

using declaration - a declaration making a class ornamespace name available
in another scope.

using directive - a way of making available to a program the members of a

using namespace - see using directive.

variable - an object that can be assigned to.

vector - a one-dimensional array.

virtual base class - a base class where a single subobject of the base class
is shared by every derived class that declared the base class as virtual.

virtual function - a member function whose interpretation when called depends
on the type of the object for which it is called; a function for an object
of a derived class will override a function of its base class.

virtual table - a lookup table used for dispatching virtual function calls.
A class object for a class containing virtual functions will contain a pointer
to a virtual table.

visibility - refers to the processing of doing name lookup without regard
to whether a name is accessible. Once a name is found, then type checking
and access control are applied.

void - a C++ keyword used to declare no type. It has special uses in C++,
for example to declare that a function has no parameter list. See also void*.

void* - a pointer to a void type. Often used as the lowest common denominator
type of pointer in C and C++. Denote object of unknown type. Declare a generic pointer.

volatile - a type qualifier used to indicate that an object may unpredictably
change value (for example if it is mapped to a machine register) and thus
should not have accesses to it optimized. Indicates that the variable may be modified by factors outside the control of the program.

wchar_t - C++ keyword to declare a fundamental type used for handling wide

while - C++ keyword used to declare an iteration statement executed the block repeatedly until the test expression becomes zero.

                                         TO BE CONTINUED.......