Fall 2003/Spring 2004: CS333 - Problem Solving and Object Oriented Programming in C++
 [ Home | Schedule | Personal Progress | Search | Glossary | Help ]


Glossary of Terms

abstract class:
base class which can only be used to derive other classes - never can be used to create an object of that type.
 
abstraction:
define essential properties and behaviors while hiding the inessential details.
 
acceptance test:
test conducted by the customer to decide whether to purchase or accept a developed system.
 
activation record:
a chunk of memory used to hold the local variables, parameters, and return address of a function. Activation records are stored on an activation stack.
 
alternate constructor:
A constructor with parameters that is called when a newly created object has arguments. There may be several alternate constructors which are resolved by function overloading rules.
 
argument:
actual data object which is passed to a function during a function call. The value or reference to this argument will be bound to the function parameter as appropriate.
 
attribute:
a property of an object. data whose value defines a characteristic of the object.
 
base class:
a class from which another class inherits data and functions forming an IS-A relationship between the classes
 
binary function:
A function which has two arguments, many binary functions use special operator symbols and infix notation
 
binary search:
A search algorithm on a sorted list in which at each step the middle of the list is compared to the value to be found and a decision is made that either the value is at the middle, or is in the first half of the list, or it is in the second half.
 
call by reference:
a method of passing arguments into a function which references that argument allowing it to be modified (unless there is a const modifier). Sometimes used with const modifier for reasons of efficiency (reference is basically a pointer and so usually takes only 32 bits).
 
call by value:
a method of passing arguments into a function in which a copy is made of the argument's value (state) and placed in the parameter (which acts like a local variable of the function). Changes to value parameters have no effect on the value of the argument.
 
cast function:
A function which converts an object from one type to another.
 
class:
A set of objects defined by common attributes or properties (data members) and common behavior or operations (function members). see terminology
 
code review:
A software validation technique conducted by a review team in which the programmer explains the program to the team.
 
compilation:
The process of converting the source code into object code.
 
component:
group of objects that work together
 
 
composition relationship:
See HasA relationship
 
constructor:
A class member function that is called whenever a new call object is created. Default constructors have no parameters. Alternate (or non-default) constructors can have parameters. There can be several constructors for a given class.
 
constructor-initializer:
special syntax for invoking alternate constructors for data members of a class. Needed since all data members are constructed BEFORE the containing class is constructed. Allows arguments to be passed from the containing classes alternate constructor to the data member alternate constructors. SYNTAX: ContainingClassConstructor(parameterList) : dataMember(constructorArguments)
 
data member:
data variables in a class. also known as property or attribute.
 
deep copy:
when an object contains pointers, a deep copy will follow the pointers and make a copy of all objects pointed at. For example. A deep copy of a linked list, will copy every node in the list so that two identical but distinct lists exist.
 
default constructor:
A constructor for a class which has no parameters and is called whenever a new object is created without arguments.
 
derived class:
A class which inherits data members and functions from a base class forming an IS-A relationship with that class.
 
desk checking:
"playing computer" to trace through a program by hand. Can be done on pseudocode.
 
dynamic binding:
A variable is bound to a type at run time.
 
encapsulation:
ability to hide information about the details of an abstraction and to protect those details from unwarranted use. This means that the details could be changed without changing the abstraction. The class and function are the primary encapsulation mechanisms in C++.
 
failure:
An incorrect behavior of a program.
 
fault:
A defect in the source code
 
function prototype:
Information for the compiler and user about how to use a function. Gives function name, return type, a parameter list (number and type of arguments in order)
 
has-a relationship:
A relationship between classes in which one class has data member which are from the other class. also known as a composition relationship
 
header file:
files containing class definitions, function prototypes, global data and other information of general interest to a program.
 
hierarchy:
a relationship between modules where one module is the parent or controller of another module. Inheritance (IS-A) relationships between classes and calling/called relationships between functions are examples of hierarchies.
 
infix functions:
a binary functions where the function name appears in between the arguments of the function
Usually infix functions use special functions names called operators (e.g. +, -, *, /, << , >>)
 
identifiers:
 
inheritance:
Allows the definition of new classes from old classes where the new class can reuse existing data and function members, modify them or add new members. (see also IS-A relationship)
 
instance:
A particular object in a class, usually associated with a variable name. An instance has state which can be changed by the modifiers of the class.
 
implementation file:
file containing member function defintions (i.e. function bodies) usually associated with a header file.
 
Integration Test:
Tests of ``subtrees'' of the total project hierarchy chart --- groups of subroutines calling each other. Integration Testing is generally a team responsibility.
 
is-a relationship:
An inheritance relationship between classes whereby one class (derived class) is a specialization of another class (called the base class)
 
linking:
The process of assembling a number of object code modules into a program. This will require shared functions and data to be linked together. The output of the linking phase is an executable program file (if all goes well).
 
loading:
The process of creating a process for running an executable program file and setting up that process by copying (loading) the executable file.
 
local variable:
a variable whose visibility and lifetime are limited to the function in which it is defined. Thus a local variable cannot be accessed outside the function and only is allocated when the function is invoked (Called). (unless it has the "static" modifier).
 
linear algorithm:
An algorithm whose performance changes in a linear function of the size of the problem. Doubling the size of the problem will double the time it takes to solve the problem.
 
logarithmic algorithm:
An algorithm whose performance changes in a logarithmic function of the size of the problem. Doubling the size of the problem only increases the time by one unit.
 
member access operator:
the single dot ('.') which is used to access both the data and function members of an object. general syntax: objectID.MemberName
 
member function:
functions defined for a class. also known as the bahaviors of the class, the methods of the class or the operations of the class.
 
modularity:
division of a program into units (modules) which have a well defined interface. modules are building blocks for a program.
 
non-default constructor:
see alternate constructor
 
objects:
any thing, real or abstract about which we store data and those methods (operations) that manipulate that data (Martin/Odell) see terminology
 
object-oriented analysis:
process of examining the application requirements to discover the classes and object, their state, behaviors and relationships in the vocabulary of the problem domain.
 
object-oriented design:
is a design method that breaks the problem into class and object abstractions to logically structure the solution
 
object code:
A form of the program expressed in the machine langauge of a particular computer processor (for example, pentium processor). Related to assembly language programming.
Written by the compiler.
 
 
operator:
Special functions names which are represented by special symbols (e.g. +, -, *, /, << , >>, ++)
 
oracle:
A procedure for determining whether a failure has occured on some test.
 
overloading functions:
results whenever the same function name is used for more than one function. The compiler resolves which function should be called by examining the function's signature: that is, the number and type of the parameters. When types differ but are convertible (e.g. int to float), then a best match is made (see pages 75-77 for details)
 
parameter:
place holder in a function definition into which the value or reference to the actual function argument (during a function call) will be bound (copied). This is a variable name that is local to the function body.
 
polymorphism:
Using the same name to denote objects of different (but related by inheritance) types
 
post-condition:
what must be try after a function executes. Usually applies to the output data or data members of a class. With the pre-condition forms a contract between the writer of a function and the user of that function.
 
pre-condition:
says what must be try before a function is executed. Usually places restrictions on the values on the input parameters.
 
preprocessor:
A program that runs before the compiler and which handles pre-processors directives.
Preprocessor directives are given on lines begining with a '#'
The most common preprocessor directive is "#include"
 
prototype:
see function prototype
 
pseudocode:(a1)
is structured English version of the program which uses English nouns and verbs and C++ control structure syntax to express the way the program should work (the algorithm)
 
pure-specifier:
designates a function to be pure ("= 0" added to the function prototype).
 
pure virtual function:
a virtual function which only a prototype - has no definition. Pure virtual functions can only be defined in a derived class.
 
 
reference:
see call by reference
 
regression test:
Test that are repeated after a change has been made to the code.
 
reliability model:
A statistical process for estimating the reliability of software.
 
scope resolution operator:
the double colon ("::") which is used to associate a member function with its class. Needed to disambiguate function definitions for the compiler.
 
shallow copy:
when an object contains pointers, a shallow copy only makes a copy of the pointers and not the objects pointed at. For example. A shallow copy of a linked list, will copy only the head pointer, both the original and copied head pointers will point to the same list.
 
signature of a function:
function name and the order and type of its parameters. (NOTE: this information is contained in the function prototype).
 
source code:
A form of the program expressed in some programming language (for example, c++). Also referred to as the "program". written by the programmer.
 
state (of object):
the values of an objects attributes, the properties of an object, the values of the object's data members
 
static binding:
A variable is bound to a type at compile time.
 
storage class:
determines the period of time that the variable exists in memory.
 
strongly typed language:
Language which requires that only compatible types are used in expressions. Helps catch incorrect usage of variables.
 
system test:
test of the entire system. May be performed by testing specialists
 
unary operator:
An operator which has only one parameter. For example "++"
 
unit test:
test of individual functions, usually conducted by the programmer.
 
value:
see call by value
 
virtual function:
An overloaded member function which can be resolved dynamically (at run time) using the object type and a "vtable" (table of virtual functions).

 


Copyright chris wild 1998-2004.
For problems or questions regarding this web contact [cs333@cs.odu.edu].
Last updated: August 24, 2003.