Glossary of Definitions


Contributors: Sam C. Pan

abstract data type (ADT):

an interface and its associated behavior, usually implemented as an class containing some data (the internal representation) and a set of methods which define the public interface

abstract factory:

factory for building related objects

abstraction (design):

way to manage complexity by emphasizing essential characteristics and suppressing implementation details

accessor functions:

provide an interface to various components in the class's state

Adaptive Communication Environment (ACE):

object-oriented framework that implements many core design patterns for concurrent communication software


translator adapts a server interface for a client


families of related patterns and components


data structure that contains indexed object(s) of the same type

automatic (lifetime):

lives only during function invocation, on the "run-time stack"

base class:

class which is inherited by other class(es)

behavioral patterns:

deal with dynamic itneractions among societies of classes and objects; i.e. iterator, memento, observer, strategy, command, template method patterns


abstraction for binding one of many implementations


factory for building complex objects incrementally


definition of a type of object

code segment:

read-only code that contains function definitions; objects live for the duration of program (can't be modified)


encapsulates an operation as a first-class object


design "bridging" interfaces


self-contained, ready-to-use ADTs


structure for building recursive aggregations

concurrent source control:

source control that allows parallel development

const methods:

methods that cannot modify its member data directly


method used to create a new object


a class is a consumer of another class when it makes use of the other class's services as defined in the interface; a Has-A relationship

creational patterns:

deal with initializing and configuring classes and objects; i.e. factory method, factory, singleton patterns

core dump:

an image of the memory; used for debugging; prevent leaks

data abstraction:

package a class abstraction so taht only the public interface is visible and the implementation details are hidden from clients

decomposition (design):

determine the individual components of the whole problem


extends an object transparently


a class is a descendant of one or more classes when it is designed as an extension or specialization of these classes; a Is-A relationship

design patterns:

solutions to problems that arise when developing software within a particular context


deallocates data allocated by the constructor

dynamic (lifetime):

lives between corresponding calls to operators new and delete

dynamic binding:

a design in which the definition the object type and its type-dependent behaviors deferred until run-time

exception handling:

disciplined way of dealing with erroneous run-time events


well-defined, abstract interfaces


simplifies the interface for a subsystem


assembles resources necessary to create an object

factory method:

method in a derived class creates associates


many fine-grained objects shared efficiently


semi-complete applications available for reuse by the developer; actual code

friends (declaration):

grants access to the class's private data and methods

function prototype:

describes the interface of the function; consists of the function return type, the name of the function, and the parameter list

global data segment:

global data; object locations are fixed, but their values can be modified; objects live for duration of program execution

Has-A relationship:

see consumer

header file:

file that contains declarations; interface


memory managed explicitly by application (new/delete); contains dynamically allocated objects; objects live until programmer destroys them with delete

helper functions:

"hidden" functions that assist in the class implementation


actual coding for a class and its methods

implementation inheritance:

method of reusing an implementation to create a new class type

implementor functions:

perform the main class operations

information hiding (design):

details of design decisions that are subject to change should be hidden behind abstract interfaces

inheritance (single & multiple):

a derived class inherits operations and attributes from one or more base classes, with the ability to provide additional operations and/or attributes

inline functions:

functions that have the source expanded into the program at each invocation point, eliminating the overhead of a function call


communication between a class and its users

interface inheritance:

method of creating a subtype of an existing class for purposes of setting up dynamic binding


language interpreter for a small grammar

Is-A relationship:

see descendant


aggregate elements are accessed sequentially


dynamically allocated objects that are never deleted

manager functions:

allow user-defined control over class creation, initialization, assignment, deallocation, and termination; i.e. constructors, destrictors, and operator

member class:

class which inherits other class(es)


snapshot captures and restores object states privately

modular system/modularity (design):

system structured into highly independent abstractions called modules


highly independent abstractions that can be used together to solve the big problem


an instance of a class or any other type


dependents update automatically when a subject changes

open/closed principle:

classes should be open for extension, closed for modification


when two or more functions or operators are given the same name, provided that the type signature for each function is unique

parametrized types:

types that serve to describe general container class data structures that have identical implementations, regardless of the elements they are composed of


contains the address of an object


support identical treatment of objects of different types


hide machine dependencies


factory for cloning new instances from a prototype


one object approximates another

reference variable:

an alternative name (alias) for an object; uses call-by-value syntax, but possesss call-by-value semantics


low-coupling, high-cohesion


factory for a single (sole) instance

stack (memory):

memory managed by compiler; used for each function call; contains function parameters and local objects; objects live until end of function

static (lifetime):

lives throughout the lifetime of the program; used for local, global, or class-specific objects


abstraction for selecting one of many algorithms


a logical entity that can produce or consume data

structural patterns:

deal with decoupling interface and implementation of classes and objects; i.e. adaptor, bridge, composite, decorator, facade patterns

template method:

algorithm with some steps supplied by a derived class

this pointer:

identifies the pointer to the object for which the method is called

virtual base class:

allows class designers to specify that a base class will be shared among derived classes

virtual machine:

system of small, manageable units with an extended instruction set