Bjarne Stroustrup's C++ Glossary

Question 1

!=

Answer 1

the inequality operator; compares values for inequality returning a bool.

Question 2

define

Answer 2

a directive that defines a macro.

Question 3

include

Answer 3

a mechanism for textual inclusion of one source file into another. Typically used to compose a translation unit out of a .c file and the header files it needs to define its view if the rest of the program.

Question 4

+=

Answer 4

add–and–assign operator; a+=b is roughly equivalent to a=a+b. Often a useful operation for user–defined types.

Question 5

.c/.cpp/.cxx file

Answer 5

file containing definitions.

Question 6

<<

Answer 6

1. iostream output operator.
2. integer left–shift operator.

Question 7

=/assignment operator

Answer 7

the assignment operator; not an equality operator. = can be used for non-const built-in types (except arrays), enumerations, strings, containers, iterators, complex, and valarray. For a class, = is by default defined member-wise assignment; if necessary, the writer of a class can define it differently.

Question 8

=0

Answer 8

curious notation indicating that a virtual function is a pure virtual function.

Question 9

>>

Answer 9

1. iostream input operator.
2. integer right–shift operator.

Question 10

==/equality operator

Answer 10

the equality operator; compares values for equality returning a bool. == can be used for built–in types, enumerations, strings, iterators, complex, and valarray. == is not by default defined for a class, but a user can define it for a user–defined type. Note that == doesn’t have the naively expected meaning for C–style strings or arrays.

Question 11

abstract class/abstract type

Answer 11

a class defining an interface only; used as a base class. Declaring a member function pure virtual makes its class abstract and prevents creation of objects of the abstract class. Use of abstract classes is one of the most effective ways of minimizing the impact of changes in a C++ program and for minimizing compilation time.

Question 12

abstraction

Answer 12

the act of specifying a general interface hiding implementation details. Classes, abstract classes, and templates are the primary abstraction mechanisms in C++. See also: encapsulation.

Question 13

access control

Answer 13

access to bases and members of a class can be controlled by declaring them public, protected, or private.

Question 14

adapter

Answer 14

a class that takes arguments producing a function object that performs an operation based on those arguments. A simple form of a higher–order function. For example, mem_fun() adapts a member function for use by the standard algorithms. See also: sequence adapter.

Question 15

address

Answer 15

a memory location.

Question 16

aggregate

Answer 16

an array or a struct without a constructor.

Question 17

algorithm

Answer 17

a precise definition of a computation. The standard library provides about 60 standard algorithms, such as sort(), search(), and copy_unique().

Question 18

alignment

Answer 18

placing objects in memory to suit hardware requirements. On many machines, an object must be aligned on a word boundary for acceptable performance.

Question 19

allocator

Answer 19

object used by standard library containers to allocate and deallocate memory.

Question 20

and

Answer 20

synonym for &&, the logical and operator.

Question 21

application

Answer 21

a collection of programs seen as serving a common purpose (usually providing a common interface to their users).

Question 22

argument

Answer 22

a value passed to a function or a template. In the case of templates, an argument is often a type.

Question 23

argument passing

Answer 23

The semantics of function call is to pass a copy of an argument. The copy operation is defined by the argument type’s copy constructor or by binding to a reference. In either case the semantics is those of initialization.

Question 24

argument–based lookup

Answer 24

lookup of a function name or operator based on the namespace of the arguments or operands. Often called Koenig lookup after Andrew Koenig who proposed the scheme to the standards committee.

Question 25

array

Answer 25

contiguous sequence of elements. An array doesn’t know its own size; the programmer must take care to avoid range errors. Where possible use the standard library vector.

Question 26

auto

Answer 26

In C and C++98 a largely useless keyword redundantly indicating stack allocation for local variables. In C++0x a keyword indicating that a variable gets its type from its initializer. For example: double d1 = 2; auto d2 = 3*d1; (d2 will have type double). Primarily useful in generic programming.

Question 27

auto_ptr

Answer 27

standard library class template for representing ownership of an object in a way that guarantees proper release (delete) even when an exception is thrown. See also: resource management, resource acquisition is initialization.

Question 28

back–end

Answer 28

the parts of a compiler that generates code given an internal representation of a correct program. This representation is produced by a compiler front–end. See also: front–end.

Question 29

back_inserter()

Answer 29

returns an iterator that can be used to add elements at the back of a container.

Question 30

bad_alloc

Answer 30

standard exception thrown by new in case of failure to allocate free store.

Question 31

bad_cast

Answer 31

standard exception thrown if a dynamic_cast to a reference fails. TC++PL 15.4.1.1, D&E 14.2.2.

Question 32

base class

Answer 32

a class from which another is derived. TC++PL 2.6.2, 12, 15, D&E 2.9.

Question 33

base initializer

Answer 33

initializer for a base class specified in the constructor for a derived class. TC++PL 12.2.2, 15.2.4.1, D&E 12.9.

Question 34

basic guarantee

Answer 34

the guarantee that basic invariants are maintained if an exception is thrown and that no resources are leaked/lost. Provided by all standard library operations. See also exception safety, nothrow guarantee, and strong guarantee. TC++PL E.2.

Question 35

basic_string

Answer 35

general standard–library string template parameterized by character type. See also: string, C–style string. TC++PL 20.3.

Question 36

binary operator

Answer 36

an operator taking two operands, such as /, &&, and binary *.

Question 37

binder

Answer 37

a function taking a function and a value, returning a function object; when called, that function object will invoke the function with the value as an argument in addition to other arguments supplied in the call. The standard library provides bind1st() and bind2nd() for binding the first and second argument of a binary function, respectively. TC++PL 18.4.4.

Question 38

bit

Answer 38

a unit of memory that can hold 0 or 1. An individual bit cannot be directly accessed in C++ (the unit of addressing is a byte), but a bit can be accessed through a bitfield or by using the bitwise logical operators & and |. TC++PL 6.2.4.

Question 39

bitand

Answer 39

synonym for &, the bitwise and operator. TC++PL C.3.1.

Question 40

bitfield

Answer 40

a number of bits in a word made accessible as a struct member. TC++PL C.8.1

Question 41

bitor

Answer 41

synonym for |, the bitwise or operator TC++PL C.3.1.

Question 42

bitset

Answer 42

a standard library almost container holding N bits and providing logical operations on those. TC++PL 17.5.3.

Question 43

block

Answer 43

see compound statement. See also: try–block.

Question 44

block comment

Answer 44

comment started by /* and terminated by */. TC++PL 6.4, D&E 3.11.1.

Question 45

bool

Answer 45

the built–in Boolean type. A bool can have the values true and false. TC++PL 4.2, D&E 11.7.2.

Question 46

boost.org

Answer 46

a collection of people

Question 47

bug

Answer 47

colloquial term for error.

Question 48

built–in type

Answer 48

A type provided directly by C++, such as int, double, and char*. See also: integral types, floating–point type, pointer, reference. TC++PL 4.1.1, 5.1, 5.2, 5.5, D&E 4.4, 15.11.3.

Question 49

byte

Answer 49

a unit of memory that can hold a character of the C++ representation character set. The smallest unit of memory that can be directly addressed in C++. Usually, a byte is 8 bits. TC++PL 4.6.

Question 50

C

Answer 50

programming language designed and originally implemented by Dennis Ritchie. C++ is based on C and maintains a high degree of compatibility with C. See also: K&R C, C89, C99, ANSI C. TC++PL B, D&E 3.12.

Question 51

C standard library

Answer 51

the library defined for C in the C standard. Inherited by C++. Most C standard library functions have safer and more convenient alternatived in the C++ standard library. See also: algorithm, container, stream I/O, string, locale.

Question 52

C++

Answer 52

a general–purpose programming language with a bias towards systems programming that supports procedural programming, data abstraction, object–oriented programming, and generic programming. C++ was designed and originally implemented by Bjarne Stroustrup. C++ is defined by ISO/IEC 14882

Question 53

C++ standard

Answer 53

the definition of C++ provided by ISO. Available from ANSI; see my C++ page. TC++PL 1.4, B.1. D&E 6.1.

Question 54

C++/CLI

Answer 54

A set of Microsoft extensions to C++ for use with their .Net system. See FAQ comments.

Question 55

C–style cast

Answer 55

dangerous form of explicit type conversion; prefer new–style cast if you must use explicit type conversion. TC++PL 6.2.7, D&E 14.3.5.1.

Question 56

C–style string

Answer 56

zero–terminated array of characters, supported by C standard library functions. A low–level and error–prone mechanism; where possible prefer strings. TC++PL 3.5.1, 20.3.7, 20.4.

Question 57

C/C++

Answer 57

(1) an abbreviation used when discussing similarities, differences, and compatibility issues of C and C++. (2) a mythical language referred to by people who cannot or do not want to recognize the magnitude of differences between the facilities offered by C and C++ or the significant differences in the programming styles supported by the two language. See also: multi–paradigm programming, object–oriented programming, generic programming, exception, template, user–defined type, C++ standard library.

Question 58

C/C++ compatibility

Answer 58

C++ was designed to be as compatible as possible to C, but no more. This basically means as compatible as can be without compromising C++’s level of type safety. You can download Appendix B of TC++PL,. Compatibility, which describes incompatibilities and differences in facilities offered by C and C++. TC++PL B. D&E 2.7, 3.12, 4.5.

Question 59

call–by–reference

Answer 59

declaring a function argument type to be a reference, thus passing a reference rather than a value to the called function. See Also: call–by–value. TC++PL 5.5, D&E 3.7.

Question 60

call–by–value

Answer 60

passing a copy of an argument to the called function. The semantics of function call is to pass a copy of an argument. The copy operation is defined by the argument type’s copy constructor. See Also: call–by–reference. TC++PL 7.2.

Question 61

cast

Answer 61

operator for explicit type conversion; most often best avoided. See also dynamic_cast, C–style cast, new–style cast. TC++PL 6.2.7, D&E 7.2, 14.2.2.1.

Question 62

catch

Answer 62

keyword used to introduce a catch–clause.

Question 63

catch(…)

Answer 63

catch every exception. TC++PL 14.3.2, D&E 16.5.

Question 64

catch–clause

Answer 64

a part of a try–block that handles exceptions of a specified type. Also called a handler or an exception handler. TC++PL 8.3.1, 14.3, D&E 16.3–4.

Question 65

cerr

Answer 65

standard unbuffered ostream for error or diagnostic output. TC++PL 21.2.1.

Question 66

Cfront

Answer 66

the front–end of Bjarne Stroustrup’s original C++ compiler. D&E 3.3.

Question 67

char

Answer 67

character type; typically an 8–bit byte. See also: wchar_t. TC++PL 4.3, C.3.4.

Question 68

char*

Answer 68

pointer to a char or an array of char. Typically assumed to point to a C–style string. Prefer a standard library string over a C–style string when you can. TC++PL 2.3.3, 13.5.2.

Question 69

character set

Answer 69

a set of integer values with a mapping to character representations; for example, ASCII (ANSI13.4–1968) gives meaning to the values 0–127. ASCII is C++’s representation character set, the character set used to represent program source text. TC++PL C.3. D&E 6.5.3.

Question 70

character type

Answer 70

char, unsigned char, and signed char. These are three distinct types. See also: wchar_t. TC++PL 2.3.1, 4.3, C.3.4.

Question 71

cin

Answer 71

standard istream. TC++PL 3.6, 21.3.1 D&E 8.3.1.

Question 72

class

Answer 72

a user–defined type. A class can have member functions, member data, member constants, and member types. A class is thee primary mechanism for representing concepts in C++. See also: template class. TC++PL 2.5.2, 10, D&E 2.3.

Question 73

class hierarchy

Answer 73

a collection of classes organized into a directed acyclic graph (DAG) by derived/base relationships. TC++PL 2.6.2, 12, 15, D&E 1.1, 7.2, 8.2.3.

Question 74

class template/template class

Answer 74

class parameterized by types, values, or templates. The template arguments necessary to identify the class to be generated for the class template must be provided where a template class is used. For example vector v; generates a vector of ints from the vector template. See also template. TC++PL 13.2, D&E 15.3.

Question 75

clone

Answer 75

a function that makes a copy of an object; usually a clone function relies on run–time information (e.g. a virtual function call) to correctly copy an object given only a pointer or reference to a sub–object.

Question 76

closure

Answer 76

object representing a context. C++ does not have general closures, but function objects can be efficiently used to hold specific parts of a context relevant to a computation. TC++PL 22.4.7, 18.4.

Question 77

code generator

Answer 77

the part of a compiler that takes the output from the front–end and generates code from it. See also: back–end, optimizer.

Question 78

collection

Answer 78

a term sometimes used as a synonym for container.

Question 79

Comeau C++

Answer 79

a family of ports of the EDG C++ front–end.

Question 80

comment

Answer 80

block comment /* … */ or line comment // …

Question 81

compiler

Answer 81

the part of a C++ implementation that produces object code from a translation unit. See also: front–end, back–end.

Question 82

complex

Answer 82

standard library complex number template parameterized by scalar type. TC++PL 11.3, 22.5, D&E 3.6.1, 8.5, 15.10.2.1.

Question 83

compound statement

Answer 83

sequence of statements enclosed in curly braces: { … } See also: try–block. TC++PL 2.3, 6.3.

Question 84

concept

Answer 84

a C++ language construct, providing type chaecking for template arguments.

Question 85

concrete type

Answer 85

a type without virtual functions, so that objects of the type can be allocated on the stack and manipulated directly (without a need to use pointers or references to allow the possibility for derived classes). Often, small self–contained classes. See also abstract class, vector, list, string, complex. TC++PL 25.2.

Question 86

const

Answer 86

attribute of a declaration that makes the entity to which it refers readonly. See also: const member function. TC++PL 5.4, D&E 3.8.

Question 87

const definition

Answer 87

declaration of a const including an initializer.

Question 88

const member function

Answer 88

member function declared not to modify the state of the object for which it is called. Can be called for const objects only. TC++PL 10.2.6, D&E 13.3.

Question 89

constant

Answer 89

literal, object or value declared const, or enumerator.

Question 90

constant expression

Answer 90

expression of integral type that is evaluated at compile time. TC++PL C.5.

Question 91

constraint/concept checking

Answer 91

rule that restricts the set of acceptable arguments for a template parameter. For example the argument must have + and

Question 92

constructor

Answer 92

member function with the same name as its class, used to initialize objects of its class. Often used to establish an invariant for the class. Often used to acquire resources. A constructor establishes a local environment in which member functions execute. See also: order of construction, destructor. TC++PL 10.2.3, D&E 2.11.1.

Question 93

const_cast

Answer 93

a type conversion operation that conversion between types that differ in const and volatile type modifiers only. See also: cast. TC++PL 15.4.2.1, D&E 14.3.4.

Question 94

container

Answer 94

(1) object that holds other objects. (2) type of object that holds other objects. (3) template that generates types of objects that hold other objects. (4) standard library template such as vector, list, and map. TC++PL 16.2, 16.2.3, 17, D&E 15.3.

Question 95

controlled variable

Answer 95

a variable used to express the part of the exit condition of a loop that varies each time around the loop. For example ``i’’ in for (int i=0; i<max></max>

Question 96

conversion

Answer 96

explicit type conversion or implicit type conversion. See also: user–defined type conversion.

Question 97

conversion operator

Answer 97

operator function specifying a conversion from a user–defined type to either another user–defined type or a built–in type. Note that constructors cannot define conversions to built–in types. TC++PL 11.4, D&E 3.6.3.

Question 98

copy assignment

Answer 98

an assignment accepting an object of the class itself as its argument, typically Z::operator=(const Z&). A copy assignment is used for assignment of an object of type T with an object of type T. If a copy assignment is not declared for a class, memberwise copy is used. See also: copy constructor. TC++PL 10.4.4.1, 10.4.6.3 D&E 11.4.

Question 99

copy constructor

Answer 99

a constructor accepting an object of the class itself as its argument, typically Z::Z(const Z&). A copy constructor is used for initialization of objects of type T with objects of type T. If a copy constructor is not declared for a class, memberwise initialization is used. See also: call–by–value, argument passing, value return, copy assignment. TC++PL 10.4.4.1, 10.4.6.3, D&E 11.4.

Question 100

copy()

Answer 100

standard algorithm for copying one sequence into another. The two sequences need not be of the same type. TC++PL 18.6.1.

Question 101

copying class object

Answer 101

an object of a class is copied by the class’ copy assignment and copy constructors. The default meaning of these operations is memberwise copy. TC++PL 10.4.4.1, 10.4.6.3 D&E 11.4.

Question 102

cout

Answer 102

standard ostream. TC++PL 3.4, 21.2.1, D&E 8.3.1.

Question 103

cpp

Answer 103

see preprocessor.

Question 104

crosscast

Answer 104

a cast from a class to a sibling class. See also: dynamic_cast, upcast, downcast. TC++PL 15.4.

Question 105

Currying

Answer 105

producing a function of N–M arguments by specifying M arguments for a function of N arguments. See also: binder, default argument. TC++PL 18.4.4.1.

Question 106

data abstraction

Answer 106

programming relying on user–defined types with well–defined interfaces. See also: generic programming and object–oriented programming. TC++PL 2.5, 24.2.2, D&E 9.2.1.

Question 107

data member

Answer 107

member of a class that can hold a value. A memer can be a static member or a non–static member. TC++PL 2.5.2–3, 10.2, D&E 2.3, 2.5.2.

Question 108

declaration

Answer 108

an introduction of a name into a scope. The type of the name must be specified. If the declaration also specifies the entity to which the name refers, the declaration is also a definition. TC++PL 4.9, D&E 3.11.5.

Question 109

decltype

Answer 109

C++ox operator meaning the type of its operand. For example: const double& d1 =2.0; decltype(d1) d2; (d2 will also be a const double&). Primarily useful for writing forwarding functions in generic programming.

Question 110

default argument

Answer 110

a value specified for an argument in a function declaration, to be used if a call of the function doesn’t specify a value for that argument. This is commonly used to allow a simple interface for common uses while making it easy to use less common facilities by specifying more arguments. See also: default template argument, binder. TC++PL 7.5, 10.2.3, D&E 2.12.2.

Question 111

default constructor

Answer 111

constructor requiring no arguments. Used for default initialization. TC++PL 10.4.2, 10.4.6, D&E 2.12.2, 15.11.3.

Question 112

default template argument

Answer 112

a type or value specified for an argument in a template declaration, to be used if a use of the template doesn’t provide a type or value for that argument. This is commonly used to allow a simple interface for common uses while making it easy to use less common facilities by specifying more arguments. See also: default argument. TC++PL 13.4.1, B.3.5.

Question 113

default value

Answer 113

value defined by a default constructor. For built–in types, the default value is defined to be 0. TC++PL 4.9.5, 10.3.1, 10.4.2 D&E 15.11.3.

Question 114

definition

Answer 114

a declaration that specifies the entity to which the declared name refers. See also: one definition rule, variable definition, const definition, template definition, function definition. TC++PL 4.9, D&E 15.11.3.

Question 115

delayed evaluation

Answer 115

technique for eliminating temporary values, and in general to delay a computation until sufficient information is available to do it well. TC++PL 21.4.6.3, 22.4.7.

Question 116

delete

Answer 116

object destruction operator. Invokes destructor, if any. See also: resource management, memory management, garbage collection, operator delete(). TC++PL 6.2.6, D&E 2.3, 10.2.

Question 117

deprecated feature

Answer 117

feature left in a programming language for historical reasons only. The standard s committee recommends against its use and warns that it may be removed in future revisions of the standard.

Question 118

deque

Answer 118

double–ended queue (pronounced deck). A standard library template allowing insertions and deletions at both ends. Use a vector if you need insertions and deletions only at one end (as is typical). Use a list if you need frequent insertions and deletions in the middle. TC++PL 17.2.3.

Question 119

derived class

Answer 119

a class with one or more base classes TC++PL 2.6.2, 12, 15, D&E 3.5.

Question 120

design

Answer 120

creating a clean and reasonably simple structure of a system TC++PL 23.3.

Question 121

destructor

Answer 121

member of a class used to clean up before deleting an object. It’s name is its class’ name prefixed by ‘~’. For example, Foo’s destructor is ~Foo(). Often used to release resources. A destructor is implicitly called whenever an object goes out of scope or is deleted. See also: virtual destructor, order of destruction. TC++PL 10.4.2, D&E 2.11.1, 3.11.2.

Question 122

digraph

Answer 122

alternative representation for C++ representation characters that doesn’t exist in every national character set, such as {, }, [,], and #: , and %:. TC++PL C.3.1.

Question 123

double

Answer 123

double–precision floating–point number. TC++PL 4.5.

Question 124

double dispatch

Answer 124

a technique for selecting a function to be invoked on the dynamic type of two operands. TC++PL 21.2.3.1, D&E 13.8.

Question 125

downcast

Answer 125

a cast from a base class to one of its derived classes. The name reflects the fact that in programming, trees tend to be drawn growing downwards from the roots. See also: dynamic_cast, upcast, crosscast. TC++PL 15.4.

Question 126

dynamic type

Answer 126

the type of an object as determined at run–time; e.g. using dynamic_cast or typeid. Also known as most–derived type.

Question 127

dynamic type safety

Answer 127

type safety enforced at run time (typically requiring a programmer to catch exceptions to deal with violations). An example is range checking for vectors.

Question 128

dynamic_cast

Answer 128

a type conversion operation that performs safe conversions using on run time type information. Used for navigation of a class hierarchy. See also: downcast, crosscast, static_cast. TC++PL 15.4.1, D&E 14.2.2, 14.3.2.1.

Question 129

EDG C++ front–end

Answer 129

a quality C++ compiler front–end, which is the core of several well–regarded C++ compilers.

Question 130

element

Answer 130

an object in a container.

Question 131

encapsulation

Answer 131

the enforcement of abstraction by mechanisms that prevent access to implementation details of an object or a group of objects except through a well–defined interface. C++ enforces encapsulation of private and proteced members of a class as long as users do not violate the type system using casts. See also: interface and access control. TC++PL 15.3, 24.3.7.4, D&E 2.10.

Question 132

enum

Answer 132

keyword for declaring enumerations. TC++PL 4.8, D&E 11.7.

Question 133

enumeration

Answer 133

a user–defined type consisting of a set of named values. TC++PL 4.8, D&E 11.7.

Question 134

enumerator

Answer 134

a name identifying a value of an enumeration. TC++PL 4.8, D&E 11.7.

Question 135

escape character/backslash

Answer 135

the character \, also called backslash, sed an initial character in representations of characters that cannot be represented by a single ASCII character, such as newline (‘\n’) and horizontal tab (‘\t’). TC++PL C.3.2.

Question 136

exception

Answer 136

object thrown by a throw–statement and (potentially) caught by an exception handler associated by a try–block. See also: exception safety, termination semantics, catch. TC++PL 8.3, 14.2, D&E 16.

Question 137

exception handler

Answer 137

a catch–clause associated with a try–block for handling exceptions of a specified type. TC++PL 8.3.1, 14.3, D&E 16.3–4.

Question 138

exception handling/error handling

Answer 138

the primary way of reporting an error that cannot be handled locally. An exception is thrown and will be caught by an exception handler or terminate() will be called. See also: exception safety, termination semantics, try–block, throw, catch. TC++PL 8.3, 14, E, D&E 16.

Question 139

exception safety

Answer 139

the notion that a program is structured so that throwing an exception doesn’t cause unintended side effects. See also: basic guarantee, strong guarantee, and nothrow guarantee. You can download Appendix E Standard–Library Exception Safety of TC++PL describing techniques for exception handling. TC++PL E.2.

Question 140

executable file

Answer 140

the result of linking the object files of a complete program. See also: compiler, linker.

Question 141

explicit

Answer 141

keyword used to define a constructor so that it isn’t used for implicit conversions. TC++PL 11.7.1.

Question 142

explicit call of constructor

Answer 142

See placement new.

Question 143

explicit call of destructor

Answer 143

destructors are implicitly called when an object goes out of scope or is deleted. However, if a user have taken over construction (using placement new) and destruction, a destructor must be explicitly called. Example. For example, explicit call of destructor is used in the implementation of standard library containers. See also: placement new. TC++PL 10.4.11, E.3.1, D&E 10.5.1.

Question 144

explicit constructor

Answer 144

constructor so that will not be used for implicit conversions. TC++PL 11.7.1.

Question 145

explicit instantiation

Answer 145

explicit request to instantiate a template in a specific context. See also: template instantiation. TC++PL C.13.10, D&E 15.10.1.

Question 146

explicit qualification

Answer 146

(1) by namespace name, see qualified name. (2) by template argument. TCP++L 13.3.2.

Question 147

explicit type conversion

Answer 147

type conversion (explicitly) requested by the use of a C–style cast, new–style cast, or functional notation. See also, implicit type conversion, user–defined type conversion. TC++PL 6.2.7, D&E 14.3.2.

Question 148

expression

Answer 148

combination of operators and names producing a value. TC++PL 6.2.

Question 149

extended type information

Answer 149

any scheme that provides additional information base on the standard run time type information. TC++PL 15.4.4.1, D&E 14.2.5.2.

Question 150

extension

Answer 150

see language extension

Question 151

extern

Answer 151

a keyword used to indicate that the definition of an entity being declared is defined elsewhere. Because extern: is only necessary for global variables it is largely redundant.

Question 152

extracter

Answer 152

an iostream >> (put to) function. TC++PL 21.2,21.3, D&E 8.3.1.

Question 153

facet

Answer 153

a class representing a primitive aspect of a locale, such as a way of writing an integer or a character encoding. TC++PL D.3.

Question 154

FALSE

Answer 154

bool value; converts to 0. TC++PL 4.2, D&E 11.7.2.

Question 155

fat interface

Answer 155

an interface with more member functions and friends than are logically necessary. TC++PL 24.4.3.

Question 156

field

Answer 156

see bitfield.

Question 157

file

Answer 157

a sequence of bytes or words holding information in a computer. The term file is usually reserved to information placed on disk or elsewhere outside the main memory. The iostream part of the C++ standard library provides ifstream, ofstream, and fstream as abstraction for accessing files. TC++PL 21.5.

Question 158

file stream

Answer 158

stream attached to a file. See also, fstream, ifstream, ofstream. TC++PL 21.5.1.

Question 159

finally

Answer 159

a language construct supporting ad hoc cleanup in some languages. Similar, but not identical to C++’s catch(…). Use the resource acquisition is initialization technique instead.

Question 160

find()

Answer 160

standard library linear search algorithm for a value in a sequence. TC++PL 18.5.2.

Question 161

find_if()

Answer 161

standard library linear search algorithm for an element meeting a search criterion in a sequence. TC++PL 18.5.2.

Question 162

float

Answer 162

single–precision floating–point number. TC++PL 4.5.

Question 163

floating–point literal

Answer 163

the source text representation of a floating point value. For example, 0.314e1. TC++PL 4.5.1.

Question 164

floating–point type

Answer 164

a float, double, or long double. A floating–point number is typically represented as a mantissa and an exponent. TC++PL 4.5.

Question 165

for–statement

Answer 165

iteration statement specifying an initializer, an iteration condition, a next–iteration operation, and a controlled statement. TC++PL 6.3.3.

Question 166

free store/dynamic memory

Answer 166

memory allocated by new; also called dynamic memory. Often standard library facilities, such as vector, can be used to avoid explicit use of free store. TC++PL 6.2.6, 10.4.3, D&E 2.11.2, 11.4.2.

Question 167

free()

Answer 167

C standard deallocation function. Use delete instead.

Question 168

free–standing function

Answer 168

a function that is not a member function. Useful for decreasing coupling between representation and algorithm. TC++PL 7, 18.

Question 169

friend

Answer 169

a function or class explicitly granted access to members of a class by that class. TC++PL 11.5, C.11.4, D&E 2.10, 3.6.1–2.

Question 170

friend function

Answer 170

a function declared as friend in a class so that it has the same access as the class’ members without having to be within the scope of the class. And, no, friends do not violate encapsulation. TC++PL 11.5, 11.2.3, C.11.4, D&E 2.10, 3.6.1.

Question 171

front–end

Answer 171

the parts of a compiler that perform lexical and syntax checking, type checking, and initial semantic checking of a translation unit. Typically all compiler error messages comes from the front–end. See also: back–end. D&E 3.3.

Question 172

front_inserter()

Answer 172

returns an iterator that can be used to add elements at the front of the container . TC++PL 19.2.4.

Question 173

fstream

Answer 173

a file stream for input and output.

Question 174

function

Answer 174

a named sequence of statements that can be invoked/called given arguments and that might return a value. The type of the function includes the number and types of argument and the type of the value returned, if any. See also: function declaration, function body. TC++PL 2.3, 7, D&E 2.6.

Question 175

function argument

Answer 175

an argument to a function.

Question 176

function body

Answer 176

the outermost block of a function. See also: try–block, function definition. TC++PL 2.7, 13.

Question 177

function declaration

Answer 177

declaration of a function, including its name, argument types, and return type.

Question 178

function definition

Answer 178

function declaration including a function body.

Question 179

function parameter

Answer 179

a parameter of a function.

Question 180

function prototype

Answer 180

C term for a function declaration that isn’t also a function definition. D&E 2.6.

Question 181

function template

Answer 181

function parameterized by types, values, or templates. The function to be generated from a template function can usually be deduced from the function arguments in a call. For example, sort(b,e) generates sort(b,e) from the sort() template function if b and e are standard library vector iterators. If a template argument cannot be deduced, it must be provided through explicit qualification. See also template. TC++PL 13,3, D&E 15.6.

Question 182

function try–block

Answer 182

try–block associated with the outmost block of a function, the function body. TC++PL 3.7.2.

Question 183

functor/function object

Answer 183

object with the application operator, operator()(), defined so that it can be called like a function. A function object is more general than a function because it can hold data and provide additional operations. Sometimes called a functor. Given current compiler technology, simple function objects inline better than pointers to functions, so that parameterization with function objects can be far more efficient than use of pointers to functions or virtual functions. See also: binder, adapter, inlining. Example. TC++PL 18.4.

Question 184

G++

Answer 184

see GNU C++.

Question 185

garbage collection/automatic garbage collection

Answer 185

techniques for reclaiming unused memory without relying on user–supplied delete or free() commands. A permitted but not required technique for C++. Commercial and free garbage collectors exist for C++: See my C++ page. Use of classes that control their own storage, such as the standard library vector, string, and map, reduces the need for garbage collection. See also: resource acquisition is initialization, destructor. TC++PL C.9.1. D&E 10.7.

Question 186

general–purpose programming language

Answer 186

(1) a programming language intended for use in a wide range of application areas without restrictions that make it totally unsuitable for traditional major uses of computers, such as mathematical computations, data processing, text processing, graphics, and communications. (2) a language that can do what at least as much as other languages called general purpose can do. See also: C++.

Question 187

generic programming

Answer 187

programming using templates to express algorithms and data structures parameterized by data types, operations, and polices. See also: polymorphism, multi–paradigm programming. TC++PL 2.7, 24.4.1, D&E 15.11.2.

Question 188

get function

Answer 188

see >>.

Question 189

global data

Answer 189

data defined in the global scope. This is usually best avoided because a programmer can’t easily know what code manipulates it and how. It is therefore a common source of errors. Global constants are usually ok.

Question 190

global scope

Answer 190

the scope containing all names defined outside any function, class, or namespace. Names in the global scope can be prefixed by ::. For example, ::main(). TC++PL 2.9.4.

Question 191

glossary

Answer 191

collection of glosses; lists and explanations of special words.

Question 192

goto

Answer 192

the infamous goto. Primarily useful in machine generated C++ code. TC++PL 6.3.4.

Question 193

grammar

Answer 193

a systematic description of the syntax of a language. The C++ grammar is large and rather messy. Some of the syntactic complexity was inherited from C. TC++PL A, D&E 2.8.

Question 194

handle

Answer 194

an object that controls access to another. Often, a handle also controls the acquisition and release of resources. A common use is for a handle to control access to a variably–sized data structure. See also: resource acquisition is initialization, vector, string, smart pointer. TC++PL 25.7, D&E 11.5.2.

Question 195

handle class

Answer 195

a small class that provides interface to an object of another class. A handle is the standard way of providing variable sized data structures in C++. Examples are string and vector. TC++PL 25.7.

Question 196

handler

Answer 196

see exception handler

Question 197

hash_map

Answer 197

hashed contained based on the standard library framework. Not (yet) part of the standard but very common in libraries based on the standard library. See also: map, vector, list. TC++PL 17.6.

Question 198

header file/.h

Answer 198

file holding declarations used in more than one translation unit. Thus, a header file acts as an interface between separately compiled parts of a program. A header file often contains inline function definitions, const definitions, enumerations, and template definitions, but it cannot be #included from for than one source file if it contain non–inline function definitions or variable definitions. TC++PL 2.4.1, 9.2.1. D&E 2.5, 11.3.3.

Question 199

higher–order function

Answer 199

functions that produce other functions. C++ does not have general higher–order functions, but by returning function objects a function can efficiently emulate some techniques traditionally relying of higher–order functions. See also: binder. TC++PL 18.4.4.

Question 200

history of C++

Answer 200

The work on what became C++ started by Bjarne Stroustrup in AT&T Bell Labs in 1979. The first commercial release was in 1985. Standards work stared in 1990 leading to ratification of the ISO standard in 1998. TC++PL 1.4. D&E Part 1.

Question 201

Hungarian notation

Answer 201

a coding convention that encodes type information in variable names. Its main use is to compensate for lack of type checking in weakly–typed or untyped languages. It is totally unsutable for C++ where it complicates maintenance and gets in the way of abstraction.

Question 202

hybrid language

Answer 202

derogative term for a programming language that supports more programming styles (paradigms) rather than just object–oriented programming.

Question 203

I/O

Answer 203

see iostream

Question 204

IDE

Answer 204

Integrated (or Interactive) Development Enviornment. A software development environment (SDE) emphasizing a GUI interface centered around a source code editor. There are many IDEs for C++, but no standard SDE.

Question 205

identifier

Answer 205

see name.

Question 206

if–statement

Answer 206

statement selecting between two alternatives based on a condition. TC++PL 6.3.2.

Question 207

ifstream

Answer 207

an file stream for input.

Question 208

implementation defined

Answer 208

an aspect of C++’s semantics that is defined for each implementation rather than specified in the standard for every implementation. An example is the size of an int (which must be at least 16 bits but can be longer). Avoid implementation defined behavior whenever possible. See also: undefined. TC++PL C.2.

Question 209

implementation inheritance

Answer 209

see private base.

Question 210

implicit type conversion

Answer 210

conversion applied implicitly based on an expected type and the type of a value. See also, explicit type conversion, user–defined type conversion. TC++PL 11.3.3, 11.3.5, 11.4, C.6, D&E 2.6.2, 3.6.1, 3.6.3, 11.2.

Question 211

in–class

Answer 211

lexically within the declaration of a class. TC++PL 10.2.9, 10.4.6.2.

Question 212

include

Answer 212

see #include.

Question 213

incomplete type

Answer 213

type that allows an object to be copied, but not otherwise used. A pointer to an undeclared type is the typical example of an incomplete type.

Question 214

inequality operator

Answer 214

see !=.

Question 215

infix operator

Answer 215

a binary operator where the operator appears between the operands. For example, a+b.

Question 216

information hiding/data hiding

Answer 216

placing information where it can be accessed only through a well–defined interface. See also: access control, abstract class, separate compilation. TC++PL 2.4.

Question 217

inheritance

Answer 217

a derived class is said to inherit the members of its base classes. TC++PL 2.6.2, 12.2, 23.4.3.1, D&E 3.5, 7.2, 12.

Question 218

initialization

Answer 218

giving an object an initial value. Initialization differs from assignment in that there is no previous value involved. Initialization is done by constructors.

Question 219

initializer list

Answer 219

comma–separated list of expressions enclosed in curly braces, e.g. { 1, 2, 3 } used to initialize a struct or an array. TC++PL 5.2.1, 5.7, 11.3.3.

Question 220

inline function

Answer 220

function declared inline using the inline keyword or by being a member function defined in–class. Compilers are encouraged to generate inline code rather than function calls for inline functions. Most benefits from inlining comes with very short functions. TC++PL 7.1.1, 9.2, 10.2.9, D&E 2.4.1 .

Question 221

inlining

Answer 221

see inline function.

Question 222

input

Answer 222

see iostream.

Question 223

inserter

Answer 223

(1) an iostream << (put to) function. (2) an STL operation yielding an iterator to be used for adding elements to a containter. TC++PL 19.2.4, 21.2, D&E 8.3.1. See also: extracter, back_inserter, front_inserter.

Question 224

instantiation

Answer 224

see template instantiation.

Question 225

int

Answer 225

basic signed integer type; its precision is implementation–defined, but an int has at least 32 bits. TC++PL 2.3.1, 4.4.

Question 226

integer type

Answer 226

a short, int, or long. Standard C++ doesn’t support long long. TC++PL 4.4.

Question 227

integral type

Answer 227

a bool, character type, or integer type. Supports arithmetic and logical operations. TC++PL 4.1.1.

Question 228

interface

Answer 228

a set of declarations that defines how a part of a program can be accessed. The public members and the friends of a class defines that class’ interface for other code to use. A class without data members defines a pure interface. The protected members provide an additional interface for use by members of derived classes. See also: abstract class.

Question 229

interface function

Answer 229

A function that can access the representation of a class. See also: friend, member function, derived class, protected.

Question 230

interface inheritance

Answer 230

see abstract class, public base.

Question 231

invariant

Answer 231

a condition of the representation of an object (the object’s state) that should hold each time an interface function is called; usually established by a constructor TC++PL 24.3.7, E.3.5.

Question 232

iostream

Answer 232

(1) standard library flexible, extensible, type–safe input and output framework. (1) stream that can be used for both input and output. See also: file stream, string stream. TC++PL 3.4, 3.6, 21, D&E 3.11.4.1, 8.3.1.

Question 233

istream

Answer 233

input stream type. TC++PL 3.6, 21.3.

Question 234

istringstream

Answer 234

a string stream for input.

Question 235

iteration

Answer 235

traversal of data structure, directly or indirectly using an iteration–statement. See also: recursion. The standard library offer algorithms, such as copy() and find(), that can be effective alternatives to explicit iteration. TC++PL 6.3.3. 18.

Question 236

iteration–statement

Answer 236

for–statement, while–statement, or do–statement.

Question 237

iterator

Answer 237

a standard library abstraction for objects referring to elements of a sequence. TC++PL 3.8.1, 19.2–3.

Question 238

Koenig lookup

Answer 238

see argument–based lookup.

Question 239

language extension

Answer 239

(1) relatively new feature that people haven’t yet gotten used to. (2) proposed new feature. (3) feature provided by one or more implementations, but not adopted by the standard; the use of some such features implies lock–in to a particular compiler supplier.

Question 240

learning C++

Answer 240

focus on concepts and techniques. You don’t need to learn C first. See also Learning Standard C++ as a New Language, available from my papers page. How do I start?. TC++PL 1.2,1.7, D&E 7.2.

Question 241

line comment

Answer 241

comment started by // and terminated by end–of–line. TC++PL 6.4, D&E 3.11.1.

Question 242

linkage

Answer 242

the process of merging code from separately compiled translation units into a program or part of a program. TC++PL 9.

Question 243

linker

Answer 243

the part of a C++ implementation that merge the code generated from separately compiled translation units into a program or part of a program. TC++PL 9.1, D&E 4.5, 11.3.

Question 244

Liskov Substitution Principle

Answer 244

design classes so that any derived class will be acceptable where its base class is. C++ public bases enforce that as far as the interface provided by the base class. TC++PL 24.3.4, D&E 2.10.

Question 245

list

Answer 245

standard library linked container. See also: vector, map. TC++PL 3.7.3, 17.2.2.

Question 246

literal

Answer 246

notation for values of bool, character types, integer types, or floating–point types. See also: enumerators. TC++PL 4.2, 4.3.1, 4.4.1, 4.5.1, 5.2.2, D&E 11.2.1.

Question 247

local class

Answer 247

class defined within a function. Most often, the use of a local class is a sign that a function is too large. Beware that a local class cannot be a valid template argument.

Question 248

local function

Answer 248

function defined within a function. Not supported by C++. Most often, the use of a local function is a sign that a function is too large.

Question 249

locale

Answer 249

standard library class for representing culture dependencies relating to input and output, such as floating–point output formats, character sets, and collating rules. A locale is a container of facets. TC++PL 21.1, D.

Question 250

long double

Answer 250

extended–precision floating–point number. TC++PL 4.5.

Question 251

long int

Answer 251

integer of a size greater than or equal to the size of an int. TC++PL 4.4.

Question 252

loop

Answer 252

a statement that expresses the notion of doing something zero or more times, such as a for–statement and a while–statement.

Question 253

LSP

Answer 253

see Liskov Substitution Principle.

Question 254

lvalue

Answer 254

an expression that may appear on the left–hand side of an assignment; for example, v[7] if v is an array or a vector. An lvalue is modifiable unless it is const. TC++PL 4.9.6, D&E 3.7.1.

Question 255

macro

Answer 255

facility for character substitution; doesn’t obey C++ scope or type rules. C++ provides alternatives to most uses of macros; see template, inline, const, and namespace. Don’t use macros unless you absolutely have to. TC++PL 7.8, D&E 2.9.2, 4.4, 18.

Question 256

main()

Answer 256

the function called by the system to start a C++ program. TC++PL 3.2, 6.1.7, 9.4 .

Question 257

maintenance

Answer 257

work on a program after its initial release. Typical maintenance activities include bug fixing, minor feature enhancements, porting to new systems, improvements of error handling, modification to use different natural languages, improvements to documentation, and performance tuning. Maintenance typically consumes more than 80% of the total effort and cost expended on a program.

Question 258

malloc()

Answer 258

C standard allocation function. Use new or vector instead.

Question 259

map

Answer 259

standard library associative container, based on less than ordering. See also: hash_map, vector, list. TC++PL 3.7.4, 17.4.1.

Question 260

Max Munch

Answer 260

(1) mythical participant in the C++ standards process. (2) the rule that says that while parsing C++ always chooses the lexically or syntactically longest alternative. Thus ++ is the increment operation, not two additions, and long int is a single integer type rather than the long integer followed by an int. Cross references in this glossary follow this rule.

Question 261

member

Answer 261

type, variable, constant, or function declared in the scope of a class. TC++PL 5.7, 10.2, D&E 2.3, 2.5.2, 2.11.

Question 262

member class

Answer 262

a class that is a member of another; also called a nested class. TC++PL 11.12, D&E 3.12, 13.5.

Question 263

member constant

Answer 263

const or enumeration declared as a member. If initialized in–class, such a constant can be used in constant expressions within the class. TC++PL 10.4.6.2.

Question 264

member data

Answer 264

see data member.

Question 265

member function

Answer 265

a function declared in the scope of a class. A member function that is not a static member function must be called for an object of its class. TC++PL 10.2.1, D&E 2.3, 3.5.

Question 266

member initializer

Answer 266

initializer for a member specified in the constructor for its class. TC++PL 10.4.6, 12.2.2, D&E 12.9.

Question 267

member type

Answer 267

member class, member enumeration, or member typedef.

Question 268

memberwise copy

Answer 268

copying a class object by copying each of its members in turn, using proper copy constructors or copy assignments. That’s the default meaning of copy. TC++PL 10.4.4.1, 10.4.6.3, D&E 11.4.4.

Question 269

memory

Answer 269

static memory, stack, or free store.

Question 270

memory management

Answer 270

a way of allocating and freeing memory. In C++ memory is either static, allocated on the stack, or allocated on the free store. When people talk about memory management, they usually think of free store or even specifically about garbage collection. Memory can often be effectively managed through standard library containers, such as vector or string, or through general resource management techniques. See also: auto_ptr, constructor, destructor, resource acquisition is initialization. TC++PL C.9, D&E 3.9, 10.

Question 271

mem_fun()

Answer 271

an adapter that allows a member function to be used as an argument to a standard algorithm requiring a free–standing function. TC++PL 18.4.4.2.

Question 272

method

Answer 272

see virtual member function.

Question 273

modifiable lvalue

Answer 273

lvalue that is not const. TC++PL 4.9.6.

Question 274

most–derived type

Answer 274

the type used to create an object (before any conversions). See also: dynamic type, static type.

Question 275

multi–method

Answer 275

a virtual function that selects the function to be called based on more than one operand. See also: multiple dispatch. D&E 13.8.

Question 276

multi–paradigm design

Answer 276

design focussed on applying the various paradigms to their best advantage. See also: multi–paradigm programming.

Question 277

multi–paradigm programming

Answer 277

programming applying different styles of programming, such as object–oriented programming and generic programming where they are most appropriate. In particular, programming using combinations of different programming styles (paradigms) to express code more clearly than is possible using only one style. See also: C++.

Question 278

multimap

Answer 278

map that allows multiple values for a key. TC++PL 17.4.2.

Question 279

multiple dispatch

Answer 279

the generalization of double dispatch to more operands. See also: single dispatch.

Question 280

multiple inheritance

Answer 280

the use of more than one immediate base class for a derived class. One typical use is to have one base define an interface and another providing help for the implementation. TC++PL 12.2.4, 12.4, 15.2.5, D&E 12.

Question 281

mutable

Answer 281

an attribute of a member that makes it possible to change its value even if its object is declared to be const TC++PL 10.2.7.2, D&E 13.3.3.

Question 282

namespace

Answer 282

a named scope. TC++PL 2.5.1, 8.1, C.10. D&E 17.

Question 283

namespace alias

Answer 283

alternative name for a namespace; often a shorter name. TC++PL 8.2.7, D&E 17.4.3.

Question 284

nested function

Answer 284

see local function.

Question 285

new

Answer 285

object creation operator. See also: constructor, placement new, operator new(), resource management, memory management, garbage collection. TC++PL 6.2.6, 19.4.5, D&E 2.3, 10.2.

Question 286

new–style cast

Answer 286

dynamic_cast, static_cast, const_cast, or reinterpret_cast. D&E 14.3.

Question 287

new_handler

Answer 287

a (possibly user–defined) function called by new if operator new() fails to allocate sufficient memory. See also: std::bad_alloc exception. TC++PL 6.2.6.2, 14.4.5., 19.4.5.

Question 288

non–static member

Answer 288

member of a class that is not declared to be a static member. An object of a class has its own space for each non–static data member.

Question 289

not

Answer 289

synonym for !, the logical negation operator TC++PL C.3.1.

Question 290

nothrow guarantee

Answer 290

the guarantee that an operation will not throw an exception. See also exception safety, basic guarantee, and strong guarantee. TC++PL E.2.

Question 291

NULL

Answer 291

zero. 0. 0 is an integer. 0 can be implicitly converted to every pointer type. See also: nullptr. TC++PL 5.1.1, D&E 11.2.3.

Question 292

nullptr

Answer 292

C++0x keyword for the null pointer. It is not an integer. It can be assigned only to pointers.

Question 293

object

Answer 293

(1) a contiguous region of memory holding a value of some type. (2) a named or unnamed variable of some type; an object of a type with a constructor is not considered an object before the constructor has completed and is no longer considered an object once a destructor has started executing for it. Objects can be allocated in static memory, on the stack, on on the free store. TC++PL 4.9.6, 10.4, 10.4.3, D&E 2.3, 3.9.

Question 294

object code

Answer 294

see object file.

Question 295

object file

Answer 295

the result of compiling a source file. See also: compiler.

Question 296

object–oriented design

Answer 296

design focussed on objects and object–oriented programming. TC++PL 23.2, D&E 7.2.

Question 297

object–oriented programming

Answer 297

programming using class hierarchies and virtual functions to allow manipulation of objects of a variety of types through well–defined interfaces and allow a program to be extended incrementally through derivation. See also: polymorphism, data abstraction. TC++PL 2.6, 12, D&E 3.5, 7.2.

Question 298

object–oriented programming language

Answer 298

a programming language designed to support or enforce some notion of object–oriented programming. C++ supports OOP and other effective forms of programming, but does not try to enforce a single style of programming. See also: generic programming, multi–paradigm programming, hybrid language.

Question 299

ODR

Answer 299

see one definition rule

Question 300

ofstream

Answer 300

an file stream for output.

Question 301

old–style cast

Answer 301

see C–style cast.

Question 302

one definition rule

Answer 302

there must be exactly one definition of each entity in a program. If more than one definition appears, say because of replication through header files, the meaning of all such duplicates must be identical. TC++PL 9.2.3, D&E 2.5, 15.10.2.

Question 303

operator

Answer 303

conventional notation for built–in operation, such as +, *, and &. A programmer can define meanings for operators for user–defined types. See also: operator overloading, unary operator, binary operator, ternary operator, prefix operator, postfix operator. TC++PL 6.2.

Question 304

operator delete()

Answer 304

deallocation function used by delete#. Possibly defined by user. TC++PL 6.2.6.2, 19.4.5. See also: operator new().

Question 305

operator delete

Answer 305

deallocation function used by delete#. Possibly defined by user. TC++PL 6.2.6.2, 19.4.5. See also: operator new.

Question 306

operator function

Answer 306

function defining one of the standard operators; e.g. operator+(). See also: operator, operator overloading, conversion operator.

Question 307

operator new()

Answer 307

allocation function used by new. Possibly defined by user. TC++PL 6.2.6.2, 19.4.5. See also: operator delete().

Question 308

operator new

Answer 308

allocation function used by new. Possibly defined by user. TC++PL 6.2.6.2, 19.4.5. See also: operator delete.

Question 309

operator overloading

Answer 309

having more than one operator with the same name in the same scope. Built–in operators, such as + and *, are overloaded for types such as int and float. Users can define their own additional meanings for user–defined types. It is not possible to define new operators or to give new meanings to operators for built–in types. The compiler picks the operator to be used based on argument types based overload resolution rules. See also: overload resolution. TC++PL 6.2, D&E 3.6, 11.7.1.

Question 310

optimizer

Answer 310

a part of a compiler that eliminates redundant operations from code and adjusts code to perform better on a given computer. See also, front–end, back–end, code generator. D&E 3.3.3.

Question 311

or

Answer 311

synonym for ||, the logical or operator TC++PL C.3.1.

Question 312

order of construction

Answer 312

a class object is constructed from the bottom up: first bases in declaration order, then members in declaration order, and finally the body of the constructor itself. TC++PL 10.4.6, 12.2.2, 15.2.4.1, 15.4.3. D&E 2.11.1, 13.2.4.2.

Question 313

order of destruction

Answer 313

a class object is destroyed in the reverse order of construction. See also: destructor.

Question 314

ostream

Answer 314

output stream type. TC++PL 3.4, 21.2.

Question 315

ostringstream

Answer 315

a string stream for output.

Question 316

output

Answer 316

see iostream.

Question 317

out_of_range

Answer 317

standard exception thrown by vector if an argument to at() is out of range. TC++PL 16.3.3.

Question 318

overload

Answer 318

see overloading.

Question 319

overload resolution

Answer 319

a set of rules for selecting the best version of an operator based on the types of its operands. A set of rules for selecting the best version of an overloaded function based on the types of its arguments. The intent of the overload resolution rules is to reject ambiguous uses and to select the simplest function or operator for each use. TC++PL 6.2, D&E 11.2.

Question 320

overloaded function

Answer 320

see overloading.

Question 321

overloaded operator

Answer 321

see operator overloading

Question 322

overloading

Answer 322

having more than one function with the same name in the same scope or having more than one operator with the same name in the same scope. It is not possible to overload across different scopes. See also: using–declaration. TC++PL 6.2, D&E 3.6, 11.2.

Question 323

override

Answer 323

see overriding.

Question 324

overriding

Answer 324

declaring a function in a derived class with the same name and a matching type as a virtual function in a base class. The argument types must match exactly. The return types must match exactly or be co–variant. The overriding function will be invoked when the virtual function is called. TC++PL 15.6.2, 6.2, D&E 3.5.2–3, 13.7.

Question 325

paradigm

Answer 325

pretentious and overused term for a way of thinking. Often used with the erroneous assumption that paradigms are mutually exclusive, and often assuming that one paradigm is inherently superior to all others. Derived from Kuhn’s theory of science. TC++PL 2.2.

Question 326

parameter

Answer 326

a variable declared in a function or templates for representing an argument. Also called a formal argument. Similarly, for templates.

Question 327

partial specialization

Answer 327

a template used (only) for the subset of its template parameters that matches a specialization pattern. TC++PL 13.5.

Question 328

Performance TR

Answer 328

technical report from the ISO C++ standards committee discussing issues related to perfoemance, especially as concerns embedded systems programming and hardware access. See my C++ page.

Question 329

placement delete

Answer 329

See explicit call of destructor.

Question 330

placement new

Answer 330

a version of the new operator where the user can add arguments to guide allocation. The simplest form, where the object is placed in a specific location, is supported by the standard library. Example. For example, placement new is used in the implementation of standard library containers. See also: explicit call of destructor. TC++PL 10.4.11, E.3.1, D&E 10.4.

Question 331

POD

Answer 331

Plain Old Data

Question 332

pointer

Answer 332

an object holding an address or 0. TC++PL 2.3.3, 5.1, D&E 9.2.2.1, 11.4.4.

Question 333

policy object

Answer 333

an object used to specify guide decisions (e.g. the meaning of less than) or implementation details (e.g. how to access memory) for an object or an algorithm. See also trait, facet. TC++PL 13.4, 24.4.1.

Question 334

polymorphism

Answer 334

providing a single interface to entities of different types. virtual functions provide dynamic (run–time) polymorphism through an interface provided by a base class. Overloaded functions and templates provide static (compile–time) polymorphism. TC++PL 12.2.6, 13.6.1, D&E 2.9.

Question 335

postfix operator

Answer 335

a unary operator that appears after its operand. For example var++.

Question 336

prefix operator

Answer 336

a unary operato that appears before its operand. For example, &var.

Question 337

preprocessor

Answer 337

the part of a C++ implementation that removes comments, performs macro substitution and #includes. Avoid using the preprocessor whenever possible. See also: macro, #include, inline, const, template, namespace. TC++PL 7.8, 9.2.1, D&E 18.

Question 338

priority_queue

Answer 338

standard library queue where a priority determines the order in which an element reaches the head of the queue. TC++PL 17.3.3.

Question 339

private

Answer 339

access control keyword. See private member, private base.

Question 340

private base

Answer 340

a base class declared private in a derived class, so that the base’s public members are accessible only from that derived class. TC++PL 15.3.2, D&E 2.10.

Question 341

private member

Answer 341

a member accessible only from its own class. TC++PL 2.5.2, 10.2.2, 15.3, D&E 2.10.

Question 342

procedural programming

Answer 342

programming using procedures (functions) and data structures (structs). See also: data abstraction, object–oriented programming, generic programming, multi–paradigm programming. TC++PL 2.3.

Question 343

procedure

Answer 343

see function.

Question 344

program

Answer 344

a set of translation units complete enough to be made executable by a linker. TC++PL 9.4.

Question 345

programming language

Answer 345

artificial language for expressing concepts and general algorithms in a way that lends itself to solving problems using computers. There do not appear to be a general consensus on what a programming language is or should be. TC++PL 1.3.2, 2.1–2, D&E page 7.

Question 346

prohibiting operations

Answer 346

operations can be rendered inaccessible by declaring them private; in this way default operations, such as construction, destruction, and copying can be disallowed for a class. TC++PL 11.2.2, D&E 11.4.

Question 347

proprietary language

Answer 347

language owned by an organization that is not an official standards organization, such as ISO; usually manipulated by its owner for commercial advantage.

Question 348

protected

Answer 348

access control keyword. See protected member, protected base.

Question 349

protected base

Answer 349

a base class declared protected in a derived class, so that the base’s public and protected members are accessible only in that derived class and classes derived from that. TC++PL 15.3.2, D&E 13.9.

Question 350

protected member

Answer 350

a member accessible only from classes derived from its class. TC++PL 15.3.1, D&E 13.9.

Question 351

protection

Answer 351

see encapsulation.

Question 352

protection model

Answer 352

the mechanisms for access control. See public, private, protected, friend. TC++PL 15.3, D&E 2.10.

Question 353

public

Answer 353

access control keyword. See public member, public base.

Question 354

public base

Answer 354

a base class declared public in a derived class, so that the base’s public members are accessible to the users of that derived class. TC++PL 15.3.2, D&E 2.3.

Question 355

public member

Answer 355

a member accessible to all users of a class. TC++PL 2.5.2, 10.2.2, 15.3, D&E 2.10.

Question 356

pure object–oriented language

Answer 356

programming language claiming to support only object–oriented programming. C++ is designed to support several programming paradigms, including traditional C–style programming, data abstraction, object–oriented programming, and generic programming. For a longer explanation, read Why C++ isn’t just an object–oriented programming language. See also: hybrid language.

Question 357

pure virtual function

Answer 357

virtual function that must be overridden in a derived class. Indicated by the curious =0 syntax. A pure virtual function can be defined in the class where it is declared pure, but needn’t be and usually isn’t. A class with at least one pure virtual function is an abstract class. TC++PL 12.3. D&E 13.2.1.

Question 358

push_back()

Answer 358

member function that adds an element at the end of a standard container, such as vector, thereby increasing the container’s size by one. Example. TC++PL 3.7.3, 16.3.5, E.3.4.

Question 359

put function

Answer 359

see <<.

Question 360

qualified name

Answer 360

name qualified by the name of its enclosing class or namespace using the scope resolution operator ::. For example, std::vector or ::main. TC++PL 4.9.3, 8.2.1, 10.2.4, 15.2.1, 15.2.2, D&E 3.11.3.

Question 361

queue

Answer 361

standard library first–in–first–out sequence. TC++PL 17.3.2.

Question 362

RAII

Answer 362

see resource acquisition is initialization.

Question 363

random number generator

Answer 363

function or function object producing a series of pseudorandom numbers according to some distribution. TC++PL 22.7.

Question 364

raw memory

Answer 364

see uninitialized memory.

Question 365

realloc()

Answer 365

C standard allocation function. Use vector and push_back() instead.

Question 366

recursion

Answer 366

a function calling itself, hopefully with different arguments so that the recursion eventually ends with a call for which the function doesn’t call itself. See also: iteration. TC++PL 7.1.1.

Question 367

reference

Answer 367

an alternative name for an object or a function. See also: operator overloading, call–by–reference. TC++PL 5.4.1, D&E 3.7.

Question 368

regression testing

Answer 368

systematically checking that a new version of a program doesn’t break correct uses of a previous version of the program.

Question 369

reinterpret_cast

Answer 369

a type conversion operation that reinterprets the raw memory of an object as a value of another type. The result of a reinterpret_cast can only be portably used after being converted back into its original type. Use only as a last resort. See also: cast. TC++PL 6.2.7, D&E 14.3.3.

Question 370

resource

Answer 370

any entity that a program acquires and releases. Typical examples are free store, file handles, threads, sockets. See also: resource acquisition is initialization, exception safety, basic guarantee, resource management. TC++PL 14.4, E.2–3 D&E 16.5.

Question 371

resource acquisition is initialization

Answer 371

A simple technique for handling resources in programs using exceptions. One of the keys to exception safety. Example. TC++PL 14.4, E.3 D&E 16.5.

Question 372

resource leak

Answer 372

programming error causing a resource not to be released. See also: resource acquisition is initialization, basic guarantee. TC++PL 14.4, E.2–3 D&E 16.5.

Question 373

resource management

Answer 373

a way of acquiring and releasing a resource, such as memory, thread, or file. See also: resource acquisition is initialization, auto_ptr, vector. TC++PL 14.4, D&E 10.4.

Question 374

resumption semantics

Answer 374

In some languages, but not C++, an exception handler can respond by telling the thrower to resume (``just carry on as if the problem hadn’t happened). This looks like a good idea in some cases, but in general leads to contorted code because of unfortunate dependencies between separate levels of abstraction. See also: termination semantics. TC++PL 14.4.5, D&E 16.6.

Question 375

return type relaxation/co–variant return type

Answer 375

Allowing a virtual function returning a B* or a B& to be overridden by a function with a return type D* or D&, provided B is a public base of D. See also: overriding. TC++PL 15.6.2, D&E 13.7.

Question 376

reverse iterator

Answer 376

iterator for iterating through a sequence in reverse order. TC++PL 19.2.5.

Question 377

Ritchie

Answer 377

Dennis Ritchie is the designer and original implementer of C. Co–author of Kernighan & Ritchie: The C programming Language.

Question 378

RTFM

Answer 378

Read The Manual (The ‘F’ is silent). Usually a very good idea.

Question 379

RTTI

Answer 379

see Run Time Type Information.

Question 380

run time type information

Answer 380

information about a type available at run time through operations on an object of that type. See also: dynamic_cast, typeid(), and type_info. TC++PL 15.4, D&E 14.2.

Question 381

rvalue

Answer 381

an expression that may appear on the right–hand side of an assignment, but not of the left–hand side; for example, 7. D&E 3.7.1.

Question 382

scope

Answer 382

a region of source text delimited by curly braces: { … }, a list of function or template parameters, or all of a translation unit outside other scopes. See also: block, namespace, global scope. TC++PL 2.9.4.

Question 383

SDE

Answer 383

Software Development Environment. An environment of editors, compilers, tools, libraries, etc. used by a programmer to produce software. There are many SDEs for C++, but no standard SDE.

Question 384

selection–statement

Answer 384

if–statement or switch–statement. TC++PL 6.3.2.

Question 385

self

Answer 385

see this.

Question 386

semantics

Answer 386

the rules specifying the meaning of a syntactically correct construct of a program. For example, specifying the actions taken to perform a for–statement or an object definition.

Question 387

separate compilation

Answer 387

the practice of compiling parts of a program, called translation units, separately and then later linking the results together using a linker. This is essential for larger programs. See also: linkage, header file, one definition rule. TC++PL 2.4.1, 9.1. D&E 2.5.

Question 388

separately compiled

Answer 388

see separate compilation.

Question 389

sequence adapter

Answer 389

a class that provides a modified interface to another. For example, a standard library stack is an adapter for a more flexible data structure such as a vector. See also: adapter, stack, queue, priority_queue. TC++PL 17.3.

Question 390

set

Answer 390

standard library associative container

Question 391

short

Answer 391

integer of a size less than or equal to the size of an int. TC++PL 4.4.

Question 392

sibling class

Answer 392

two classes are siblings if a class is (directly or indirectly) derived from them both and one is not derived from the other. Note that this is a rather inclusive definition of sibling class in that is does not require that the siblings have the same immediate derived class (I didn’t want to introduce a notion of cousin classes). See also: dynamic_cast, crosscast.

Question 393

signature

Answer 393

the set of parameter types for a function; that is, the function’s type ignoring its return type. This is a confusingly specialized definition compared to other programming languages where signature means function type.

Question 394

Simula

Answer 394

ancestor of C++ designed by Ole–Johan Dahl and Kristen Nygaard; the source of the C++ class concept. TC++PL 1.4, 2.6.2, D&E 1.1, 3.1.

Question 395

single dispatch

Answer 395

the technique of choosing the member function to be invoked based on the object used in the call. See also: double dispatch.

Question 396

size of an object

Answer 396

the number of bytes required to represent an object. See also sizeof, alignment. TC++PL 4.6.

Question 397

sizeof

Answer 397

operator yielding the size of an object.

Question 398

smart pointer

Answer 398

user–defined type providing operators like a function, such as * and ++, and with a semantics similar to pointers. See also: iterator. Sometimes smart a pointer is called a handle. TC++PL 11.10–11, 13.6.3.1, 19.3, 25.7, D&E 11.5.1

Question 399

software

Answer 399

a collection of programs

Question 400

sort()

Answer 400

standard library algorithm for sorting a random access sequence, such as a vector or an array. Example comparing sort() to qsort(). TC++PL 18.7.1.

Question 401

source file

Answer 401

.c file or header.

Question 402

specialization

Answer 402

a class or function generated from a template by supplying a complete set of template arguments. TC++PL 13.2.2, 13.5, D&E 15.10.3.

Question 403

stack

Answer 403

(1) memory used to hold local variables for a function. (2) standard library first–in–last–out sequence. TC++PL 10.4.3, 17.3.1, D&E 2.3, 3.9.

Question 404

Standard C++

Answer 404

C++ as defined by ISO.

Question 405

standard header

Answer 405

header for standard library facility. Included using the #include< … > syntax. TC++PL 9.2.2, 16.1.2.

Question 406

standard library

Answer 406

The library defined in the C++ standard. Contains strings, stream I/O, a framework of containers and algorithms, support for numerical computation, support for internationalization, the C standard library, and some language support facilities. See also: complex, valarray, locale. TC++PL 16–22, D, E.

Question 407

standards committee

Answer 407

see C++ standards committees.

Question 408

statement

Answer 408

the basic unit controlling the execution flow in a function, such as if–statement, while–statement, do–statement, switch–statement, expression statement, and declaration. TC++PL 6.3.

Question 409

static

Answer 409

(1) keyword used to declare a class member static; meaning allocated in static memory. For a member function, this implies that there is no this pointer. (2) keyword used to specify that a local variable should be allocated in static memory. (3) deprecated: keyword used to specify that a global name should not be visible from other translation units. TC++PL 7.1.2, 10.2.4, 10.4.8–9.

Question 410

static member

Answer 410

member of a class for which there is only one copy for the whole program rather than one per object. TC++PL 10.2.4, D&E 13.4.

Question 411

static member function

Answer 411

a member function that need not be called for an object of the class. TC++PL 10.2.4, D&E 13.4.

Question 412

static memory

Answer 412

memory allocated by the linker. TC++PL 10.4.3, D&E 2.3, 2.11.1, 3.9, 11.4.2.

Question 413

static type

Answer 413

the type of an object as known to the compiler based on its declaration. See also: dynamic type.

Question 414

static type safety

Answer 414

type safety enforced before a program starts executing (at compile time or at static link time).

Question 415

static variable

Answer 415

variable allocated in static memory. TC++PL 7.1.2, 10.2.4, 10.4.3, D&E 3.9.

Question 416

static_cast

Answer 416

a type conversion operation that converts between related types, such as pointer types within a class hierarchy and between enumerations and integral types. See also: cast, dynamic_cast. TC++PL 6.2.7, 15.4.2.1, D&E 14.3.2.

Question 417

Stepanov

Answer 417

Alex Stepanov is the original designer and implementer of the STL. D&E 11.15.2.

Question 418

STL

Answer 418

the Standard Template Library by Alex Stepanov, which became the basis for the containers, algorithms, and iterators part of the ISO C++ standard library. TC++PL 15–19.

Question 419

strcmp()

Answer 419

a C–style standard library function for comparing C–style strings.

Question 420

stream

Answer 420

see iostream.

Question 421

stream I/O

Answer 421

see iostream.

Question 422

string

Answer 422

standard–library type representing a sequence of characters, support by convenient operators, such as == and +=. The general form of of strings, basic_string, supports strings of different kinds of characters. TC++PL 3.5, 20.

Question 423

string stream

Answer 423

stream attached to a string. See also, stringstream, istringstream, ostringstream. TC++PL 21.5.3.

Question 424

stringstream

Answer 424

a string stream for input and output.

Question 425

strong guarantee

Answer 425

the guarantee that an exception thrown by an operation leaves every object in the state in which it was before the start of the operation. Builds on the basic guarantee. See also exception safety, nothrow guarantee, and basic guarantee. TC++PL E.2.

Question 426

strstream

Answer 426

deprecated ancestor of stringstream.

Question 427

struct

Answer 427

class with members public by default. Most often used for data structures without member functions or class invariants, as in C–style programming. TC++PL 5.7, 10.2.8, D&E 3.5.1.

Question 428

subclass

Answer 428

a derived class.

Question 429

subtype

Answer 429

see derived class. See also: public base.

Question 430

suffix operator

Answer 430

a postfix operator.

Question 431

superclass

Answer 431

a base class.

Question 432

switch–statement

Answer 432

statement selecting among many alternatives based on an integer value. TC++PL 6.3.2.

Question 433

syntax

Answer 433

the set of gramatical rules specifying how the text of a program must be composed. For example, specifying the form of a declaration or the form of a for–statement.

Question 434

template

Answer 434

class or function parameterized by a set of types, values, or templates. See also template instantiation, specialization, template class, template function. TC++PL 2.7, 13, D&E 15.

Question 435

template argument

Answer 435

an argument to a template.

Question 436

template argument constraint

Answer 436

see constraint.

Question 437

template definition

Answer 437

declaration of a template class or of a template function including a function body.

Question 438

template instantiation

Answer 438

the process of creating a specialization from a template. TC++PL 13.2.2, D&E 15.10.

Question 439

template parameter

Answer 439

a parameter of a template.

Question 440

terminate()

Answer 440

If an exception is thrown but no handler is found, terminate() is called. By default, terminate() terminates the program. If program termination is unacceptable, a user can provide an alternative terminate() function. If you are worried about uncaught exceptions, make the body of main() a try–block. TC++PL 14.7.

Question 441

termination semantics

Answer 441

a somewhat ominous terminology for the idea that throwing an exception terminates an operation and returns through the function call chain to a handler. The handler can initiate any error handling it likes, including calling the function that caused the exception again (presumably after fixing the problem that caused the problem). What a handler can’t do is simply tell the thrower to just carry on; by the time the handler is invoked we have returned from the block/function that threw and all blocks/functions that led to it from the handler’s try–block. See also: resumption semantics. TC++PL 14.4.5, D&E 16.6.

Question 442

ternary operator

Answer 442

an operator taking three operands, such as ?:.

Question 443

testing

Answer 443

systematically verifying that a program meets its specification and systematically searching for error.

Question 444

this

Answer 444

pointer to the object for which a non–static member function is called. TC++PL 10.2.7, D&E 2.5.2.

Question 445

throw

Answer 445

operation for interrupting the normal flow of control and returning to an appropriate exception handler identifyed by the type of the exception throw. See also: catch, exception handling. TC++PL 8.3.1, 14.3, D&E 16.3.

Question 446

trait

Answer 446

a small policy object, typically used to describe aspects of a type. For example, iterator_trait specifies the types resulting from operations on an iterator T. TC++PL 19.2.2.

Question 447

translation unit

Answer 447

a part of a program that can be separately compiled. TC++PL 9.1.

Question 448

trigraph

Answer 448

alternative representation for C++ representation characters that doesn’t exist in every national character set, such as {, }, [,], and #: ??, ??(, ??), and ??=. TC++PL C.3.1.

Question 449

TRUE

Answer 449

bool value; converts to 1. TC++PL 4.2, D&E 11.7.2.

Question 450

try

Answer 450

keyword used to start a try–block.

Question 451

try–block

Answer 451

a block, prefixed by the keyword try, specifying handlers for exceptions. See also: catch, exception handling. TC++PL 8.3.1,14.3, D&E 16.3.

Question 452

two–phase lookup

Answer 452

a somewhat complicated mechanism used in compilation of templates. Names that do not depend on a template parameter are looked up (and bound) early, i.e., when the template template definition is first seen (phase 1 lookup). Names that depend on a template parameter are looked up late, i.e. during template instantiation (phase 2 lookup) so that the lookup can find names relating to actual template arguments. TC++PL C::13.8.

Question 453

type

Answer 453

a built–in type or a user–defined type. A type defines the proper use of a name or an expression. TC++PL 2.3.1, 4.1.

Question 454

type checking

Answer 454

the process of checking that every expression is used according to its type. the compiler checks every expression based on the declared types of the names involved. TC++PL 7.2–3, 24.2.3, D&E 2.3, 2.6, 3.10, 3.15, 9.2.2.1.

Question 455

type conversion

Answer 455

producing a value of one type from a value of another type. A type conversion can be an implicit conversion or an explicit conversion. See also: user–defined type conversion, cast. TC++PL 6.2.7.

Question 456

type safety

Answer 456

the property that an object can be accessed only according to its definition. C++ approximates this ideal. A programmer can violate type safety by explicitly using a cast, by using an uninitialized variable, by using a pointer that doesn’t point to an object, by accessing beyond the end of an array, and by misusing a union. For low–level systems code, it can be necessary to violate type safety (e.g. to write out the byte representation of some objects), but generally type safety must be preserved for a program to be correct and maintainable.

Question 457

type system

Answer 457

the set of rules for how objects can be used according to their types. See also: type checking.

Question 458

typedef

Answer 458

synonym for some type declared using the keyword typedef.

Question 459

typeid()

Answer 459

operator returning basic type information. TC++PL 15.4.4, D&E 14.2.5.

Question 460

typename

Answer 460

(1) an alternative to class when declaring template arguments; for example, template void f(T); (2) a way of telling a compiler that a name is meant to name a type in template code; for example template void f(T a) { typename T::diff_type x = 0; … }. TC++PL C::13.5.

Question 461

type_info

Answer 461

class containing basic run time type information. TC++PL 15.4.4, D&E 14.2.5.1.

Question 462

unary operator

Answer 462

an operator taking one operand, such as ! and unary *.

Question 463

uncaught exception

Answer 463

Exception for which no handler was found. Invokes terminate(), which by default terminates the program. TC++PL 14.7.

Question 464

undefined

Answer 464

an aspect of C++’s semantics for which no reasonable behavior is required. An example is dereferencing a pointer with the value zero. Avoid undefined behavior. See also: implementation defined. TC++PL C.2.

Question 465

uninitialized memory

Answer 465

memory that hasn’t been initialized to hold a specific value of a type. TC++PL 19.4.4.

Question 466

union

Answer 466

a struct with all members allocated at the same offset within an object. The language does not guarantee type safety for all uses of unions. Primarily used to save space. TC++PL C.8.2.

Question 467

upcast

Answer 467

a cast from a derived class to one of its bases. See also: downcast, crosscast. TC++PL 15.4.

Question 468

user–defined type

Answer 468

Class or enumeration. A programmer can define meanings for operators for user–defined types. See also: operator overloading. TC++PL 6.2, 11, D&E 3.6, 11.7.1.

Question 469

user–defined type conversion

Answer 469

a user can define conversions either as constructors or conversion operators. These conversions are applied explicitly or implicitly just like built–in conversions. TC++PL 11.3.5, 11.4, D&E 3.6.1, 3.6.3.

Question 470

using

Answer 470

see using–directive and using–declaration.

Question 471

using–declaration

Answer 471

declaration of a local synonym for a name in another namespace or class. Example of using–declaration used to simplify overloading. See also: overloading, argument–based lookup. TC++PL 8.2.2. D&E 17.4.

Question 472

using–directive

Answer 472

directive making a namespace accessible. See also: argument–based lookup. TC++PL 8.2.3. D&E 17.4.

Question 473

valarray

Answer 473

standard library numeric vector type supporting vector operations. TC++PL 22.4.

Question 474

value

Answer 474

the bits of an object interpreted according to the objects type.

Question 475

value return

Answer 475

The semantics of function return is to pass a copy of the return value. The copy operation is defined by the return type’s copy constructor. TC++PL 7.4.

Question 476

variable

Answer 476

named object in a scope. TC++PL 2.3.1, 10.4.3, D&E 2.3.

Question 477

variable definition

Answer 477

declaration of a named object of a data type without an extern specifier.

Question 478

vector

Answer 478

standard library template providing contiguous storage, re–sizing and the useful push_back() functions for adding elements at the end. Vector is the default container. See also: map, multimap, list, deque. TC++PL 3.7.1, 16.3.

Question 479

virtual

Answer 479

keyword used to declare a member function virtual.

Question 480

virtual base

Answer 480

a base that is shared by all classes in a class hierarchy that has declared it virtual. TC++PL 15.2.4, D&E 12.3, 12.4.1.

Question 481

virtual constructor

Answer 481

a constructor cannot be virtual, because to create an object, we need complete information of its type. virtual constructor is the name of a technique for calling a virtual function to create an object of an appropriate type. Example. TC++PL 12.4.4, 15.6.2.

Question 482

virtual destructor

Answer 482

a destructor declared virtual to ensure that the proper derived class destructor is called if an object of a derived class is deleted through a pointer to a base class. If a class has any virtual functions, it should have a virtual destructor. Example. TC++PL 12.4.2, D&E 10.5.

Question 483

virtual member function

Answer 483

a member function that a derived class can override; the primary mechanism for run–time polymorphism in C++. A virtual member function is sometimes called a method. See also: overriding, pure virtual function. TC++PL 2.5.4, 2.5.5, 12.2.6, D&E 3.5, 12.4.

Question 484

virtual–function pointer

Answer 484

a pointer to a class’ virtual function table.

Question 485

virtual–function table

Answer 485

table of all virtual functions for a class. The most common way of implementing virtual functions is to have each object of a class with virtual functions contain a virtual function pointer pointing to the class’ virtual function table.

Question 486

visitor pattern

Answer 486

a way of using double dispatch to simulate virtual calls without adding new virtual functions.

Question 487

void

Answer 487

a keyword used to indicate an absence of information. TC++PL 4.1.1, 4.7.

Question 488

void*

Answer 488

pointer to void; that is, a pointer to an object of unknown type; also called pointer to raw memory. A void* cannot be used or assigned without a cast. TC++PL 5.6, D&E 11.2.1, 11.2.3.

Question 489

volatile

Answer 489

attribute of a declaration telling the compiler that an entity can have its value changed by extralinguistic means; for example, a real time clock: extern volatile const long clock;. Limits optimizations. TC++PL A.7.1.

Question 490

vptr

Answer 490

see virtual–function pointer.

Question 491

vtbl

Answer 491

see virtual–function table.

Question 492

wchar_t

Answer 492

wide character type. Used to hold characters of character sets that require more than a byte to represent, such as unicode. TC++PL 4.3, C.3.3. See also: large character sets, universal character name.

Question 493

WG21

Answer 493

a common abbreviation of the name of the ISO C++ standards committee.

Question 494

while–statement

Answer 494

a loop statement presenting its condition at the top. For example, while (cin>>var) vec.push_back(var);

Question 495

whitespace

Answer 495

characters that a represented only by the space they take up on a page or screen. The most common examples are space (‘ ‘), newline (‘\n’), and tab (‘\t’).

Question 496

word

Answer 496

a number of bytes that on a given machine is particularly suied to holding an integers or a pointer. On many machines, an object must be aligned on a word boundary for acceptable performance. An int is typically a stored in a word. Often, a word is 4 bytes. See also: alignment. TC++PL 4.6.

Question 497

xor

Answer 497

synonym for ^, the bitwise exclusive or operator TC++PL C.3.1.

Question 498

zero

Answer 498

see NULL