Programming Principles C++: Glossary

Front 1

abstract class

Back 1

a class that cannot be directly used to create objects; often used to define an interface to derived classes. A class is made abstract by having a pure virtual function or a protected constructor.

Front 2

abstraction

Back 2

a description of something that selectively and deliberately ignores (hides) details (e.g., implementation details); selective ignorance.

Front 3

address

Back 3

a value that allows us to find an object in a computer’s memory.

Front 4

algorithm

Back 4

a procedure or formula for solving a problem; a finite series of computational steps to produce a result.

Front 5

alias

Back 5

an alternative way of referring to an object; often a name, pointer, or reference.

Front 6

application

Back 6

a program or a collection of programs that is considered an entity by its users.

Front 7

approximation

Back 7

something (e.g., a value or a design) that is close to the perfect or ideal (value or design). Often an approximation is a result of trade-offs among ideals.

Front 8

argument

Back 8

a value passed to a function or a template, in which it is accessed through a parameter.

Front 9

array

Back 9

a homogeneous sequence of elements, usually numbered, e.g., [0:max).

Front 10

assertion

Back 10

a statement inserted into a program to state (assert) that something must always be true at this point in the program.

Front 11

base class

Back 11

a class used as the base of a class hierarchy. Typically a base class has one or more virtual functions.

Front 12

bit

Back 12

the basic unit of information in a computer. A bit can have the value 0 or the value 1.

Front 13

bug

Back 13

an error in a program

Front 14

byte

Back 14

the basic unit of addressing in most computers. Typically, a byte holds 8 bits.

Front 15

class

Back 15

a user-defined type that may contain data members, function members, and member types.

Front 16

code

Back 16

a program or a part of a program; ambiguously used for both source code and object code.

Front 17

compiler

Back 17

a program that turns source code into object code.

Front 18

complexity

Back 18

a hard-to-precisely-define notion or measure of the difficulty of constructing a solution to a problem or of the solution itself. Sometimes complexity is used to (simply) mean an estimate of the number of operations needed to execute an algorithm.

Front 19

computation

Back 19

the execution of some code, usually taking some input and producing some output.

Front 20

concept

Back 20

(1) a notion, an idea; (2) a set of requirements, usually for a template argument.

Front 21

concrete class

Back 21

a class for which objects can be created.

Front 22

constant

Back 22

a value that cannot be changed (in a given scope); not mutable.

Front 23

constructor

Back 23

an operation that initializes (“constructs”) an object. Typically a constructor establishes an invariant and often acquires resources needed for an object to be used (which are then typically released by a destructor).

Front 24

container

Back 24

an object that holds elements (other objects).

Front 25

copy

Back 25

an operation that makes two objects have values that compare equal. See also move.

Front 26

correctness

Back 26

a program or a piece of a program is correct if it meets its specification. Unfortunately, a specification can be incomplete or inconsistent, or can fail to meet users’ reasonable expectations. Thus, to produce acceptable code, we sometimes have to do more than just follow the formal specification.

Front 27

cost

Back 27

the expense (e.g., in programmer time, run time, or space) of producing a program or of executing it. Ideally, cost should be a function of complexity.

Front 28

data

Back 28

values used in a computation.

Front 29

debugging

Back 29

the act of searching for and removing errors from a program; usually far less systematic than testing.

Front 30

declaration

Back 30

the specification of a name with its type in a program.

Front 31

defintion

Back 31

a declaration of an entity that supplies all information necessary to complete a program using the entity. Simplified definition: a declaration that allocates memory.

Front 32

derived class

Back 32

a class derived from one or more base classes.

Front 33

design

Back 33

an overall description of how a piece of software should operate to meet its specification.

Front 34

destructor

Back 34

an operation that is implicitly invoked (called) when an object is destroyed (e.g., at the end of a scope). Often, it releases resources.

Front 35

encapsulation

Back 35

protecting something meant to be private (e.g., implementation details) from unauthorized access.

Front 36

error

Back 36

a mismatch between reasonable expectations of program behavior (often expressed as a requirement or a users’ guide) and what a program actually does.

Front 37

executable

Back 37

a program ready to be run (executed) on a computer.

Front 38

expression

Back 38

a computation usually yielding a value or deposing its result in an object.

Front 39

feature creep

Back 39

a tendency to add excess functionality to a program “just in case.”

Front 40

file

Back 40

a container of permanent information in a computer.

Front 41

function

Back 41

a named unit of code that can be invoked (called) from different parts of a program; a logical unit of computation.

Front 42

generic programming

Back 42

a style of programming focused on the design and efficient implementation of algorithms. A generic algorithm will work for all argument types that meet its requirements. In C++, generic programming typically uses templates.

Front 43

handle

Back 43

a class that allows access to another through a member pointer or reference. See also copy, move,resource.

Front 44

header

Back 44

a file containing declarations used to share interfaces between parts of a program

Front 45

hiding

Back 45

the act of preventing a piece of information from being directly seen or accessed. For example, a name from a nested (inner) scope can prevent that same name from an outer (enclosing) scope from being directly used.

Front 46

ideal

Back 46

the perfect version of something we are striving for. Usually we have to make trade-offs and settle for an approximation

Front 47

implementation

Back 47

(1) the act of writing and testing code; (2) the code that implements a program.

Front 48

infinite loop

Back 48

a loop where the termination condition never becomes true. See iteration.

Front 49

infinite recursion

Back 49

a recursion that doesn't end until the machine runs out of memory to hold the calls. In reality, such recursion is never infinite but is terminated by some hardware error.

Front 50

information hiding

Back 50

the act of separating interface and implementation, thus hiding implementation details not meant for the user’s attention and providing an abstraction.

Front 51

initialize

Back 51

giving an object its first (initial) value.

Front 52

input

Back 52

values used by a computation (e.g., function arguments and characters typed on a keyboard).

Front 53

integer

Back 53

a whole number, such as 42 and –99.

Front 54

interface

Back 54

a declaration or a set of declarations specifying how a piece of code (such as a function or a class) can be called.

Front 55

invariant

Back 55

something that must be always true at a given point (or points) of a program; typically used to describe the state (set of values) of an object or the state of a loop before entry into the repeated statement.

Front 56

iteration

Back 56

the act of repeatedly executing a piece of code; see recursion.

Front 57

iterator

Back 57

an object that identifies an element of a sequence.

Front 58

library

Back 58

a collection of types, functions, classes, etc. implementing a set of facilities (abstractions) meant to be potentially used as part of more than one program.

Front 59

lifetime

Back 59

the time from the initialization of an object until it becomes unusable (goes out of scope, is deleted, or the program terminates).

Front 60

linker

Back 60

a program that combines object code files and libraries into an executable program.

Front 61

literal

Back 61

a notation that directly specifies a value, such as 12 specifying the integer value “twelve.”

Front 62

loop

Back 62

a piece of code executed repeatedly; in C++, typically a for-statement or a while-statement.

Front 63

move

Back 63

an operation that transfers a value from one object to another, leaving behind a value representing “empty.” See also copy.

Front 64

mutable

Back 64

changeable; the opposite of immutable, constant, and variable.

Front 65

object

Back 65

(1) an initialized region of memory of a known type which holds a value of that type; (2) a region of memory.

Front 66

object code

Back 66

output from a compiler intended as input for a linker (for the linker to produce executable code).

Front 67

object file

Back 67

a file containing object code.

Front 68

object-oriented programming

Back 68

a style of programming focused on the design and use of classes and class hierarchies.

Front 69

operation

Back 69

something that can perform some action, such as a function and an operator.

Front 70

output

Back 70

values produced by a computation (e.g., a function result or lines of characters written on a screen).

Front 71

overflow

Back 71

producing a value that cannot be stored in its intended target.

Front 72

overload

Back 72

defining two functions or operators with the same name but different argument (operand) types.

Front 73

override

Back 73

defining a function in a derived class with the same name and argument types as a virtual function in the base class, thus making the function callable through the interface defined by the base class.

Front 74

owner

Back 74

an object responsible for releasing a resource.

Front 75

paradigm

Back 75

a somewhat pretentious term for design or programming style; often used with the (erroneous) implication that there exists a paradigm that is superior to all others.

Front 76

parameter

Back 76

a declaration of an explicit input to a function or a template. When called, a function can access the arguments passed through the names of its parameters.

Front 77

pointer

Back 77

(1) a value used to identify a typed object in memory; (2) a variable holding such a value.

Front 78

post-condition

Back 78

a condition that must hold upon exit from a piece of code, such as a function or a loop.

Front 79

pre-condition

Back 79

a condition that must hold upon entry into a piece of code, such as a function or a loop.

Front 80

program

Back 80

code (possibly with associated data) that is sufficiently complete to be executed by a computer.

Front 81

programming

Back 81

the art of expressing solutions to problems as code.

Front 82

programming language

Back 82

a language for expressing programs

Front 83

pseudo code

Back 83

a description of a computation written in an informal notation rather than a programming language.

Front 84

pure virtual function

Back 84

a virtual function that must be overridden in a derived class.

Front 85

RAII (“Resource Acquisition Is Initialization”)

Back 85

a basic technique for resource management based on scopes.

Front 86

range

Back 86

a sequence of values that can be described by a start point and an end point. For example, [0:5) means the values 0, 1, 2, 3, and 4.

Front 87

recursion

Back 87

the act of a function calling itself; see also iteration.

Front 88

reference

Back 88

(1) a value describing the location of a typed value in memory; (2) a variable holding such a value.

Front 89

regular expression

Back 89

a notation for patterns in character strings.

Front 90

requirement

Back 90

(1) a description of the desired behavior of a program or part of a program; (2) a description of the assumptions a function or template makes of its arguments.

Front 91

resource

Back 91

something that is acquired and must later be released, such as a file handle, a lock, or memory. See also handle, owner.

Front 92

rounding

Back 92

conversion of a value to the mathematically nearest value of a less precise type.

Front 93

scope

Back 93

the region of program text (source code) in which a name can be referred to.

Front 94

sequence

Back 94

elements that can be visited in a linear order.

Front 95

software

Back 95

a collection of pieces of code and associated data; often used interchangeably with program.

Front 96

source code

Back 96

code as produced by a programmer and (in principle) readable by other programmers.

Front 97

source file

Back 97

a file containing source code.

Front 98

specification

Back 98

a description of what a piece of code should do.

Front 99

standard

Back 99

an officially agreed-upon definition of something, such as a programming language.

Front 100

state

Back 100

a set of values.

Front 101

statement

Back 101

a basic unit of a program controlling the execution flow in a function, such as if-statement, for statement, expression statement, and declaration

Front 102

string

Back 102

a sequence of characters.

Front 103

style

Back 103

a set of techniques for programming leading to a consistent use of language features; sometimes used in a very restricted sense to refer just to low-level rules for naming and appearance of code.

Front 104

subtype

Back 104

derived type; a type that has all the properties of a type and possibly more.

Front 105

supertype

Back 105

base type; a type that has a subset of the properties of a type.

Front 106

system

Back 106

(1) a program or a set of programs for performing a task on a computer; (2) a shorthand for “operating system,” that is, the fundamental execution environment and tools for a computer.

Front 107

template

Back 107

a class or a function parameterized by one or more types or (compile-time) values; the basic C++ language construct supporting generic programming.

Front 108

testing

Back 108

a systematic search for errors in a program.

Front 109

trade-off

Back 109

the result of balancing several design and implementation criteria.

Front 110

truncation

Back 110

loss of information in a conversion from a type into another that cannot exactly represent the value to be converted.

Front 111

type

Back 111

something that defines a set of possible values and a set of operations for an object.

Front 112

unitialized

Back 112

the (undefined) state of an object before it is initialized.

Front 113

unit

Back 113

(1) a standard measure that gives meaning to a value (e.g., km for a distance); (2) a distinguished (e.g., named) part of a larger whole.

Front 114

use case

Back 114

a specific (typically simple) use of a program meant to test its functionality and demonstrate its purpose.

Front 115

value

Back 115

a set of bits in memory interpreted according to a type.

Front 116

variable

Back 116

a named object of a given type; contains a value unless uninitialized.

Front 117

virtual function

Back 117

a member function that can be overridden in a derived class.

Front 118

word

Back 118

a basic unit of memory in a computer, usually the unit used to hold an integer.