Glossary of Definitions

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

adaptor:

translator adapts a server interface for a client

architecture:

families of related patterns and components

array:

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

bridge:

abstraction for binding one of many implementations

builder:

factory for building complex objects incrementally

class:

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)

command:

encapsulates an operation as a first-class object

compatibility:

design "bridging" interfaces

components:

self-contained, ready-to-use ADTs

composite:

structure for building recursive aggregations

concurrent source control:

source control that allows parallel development

const methods:

methods that cannot modify its member data directly

constructor:

method used to create a new object

consumer/composition/aggregation:

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

decorator:

extends an object transparently

descendant/inheritance/specialization:

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

destructor:

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

extensibility:

well-defined, abstract interfaces

facade:

simplifies the interface for a subsystem

factory:

assembles resources necessary to create an object

factory method:

method in a derived class creates associates

flyweight:

many fine-grained objects shared efficiently

frameworks:

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

heap:

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

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

interface:

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

interpreter:

language interpreter for a small grammar

Is-A relationship:

see descendant

iterator:

aggregate elements are accessed sequentially

leak:

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)

memento:

snapshot captures and restores object states privately

modular system/modularity (design):

system structured into highly independent abstractions called modules

modules:

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

object:

an instance of a class or any other type

observer:

dependents update automatically when a subject changes

open/closed principle:

classes should be open for extension, closed for modification

overloading:

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

pointer:

contains the address of an object

polymorphism:

support identical treatment of objects of different types

portability:

hide machine dependencies

prototype:

factory for cloning new instances from a prototype

proxy:

one object approximates another

reference variable:

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

reusability:

low-coupling, high-cohesion

singleton:

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

strategy:

abstraction for selecting one of many algorithms

stream:

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