Page History

Anchor
abnormal termination abnormal termination

abnormal termination [Open Group 08]
Abnormal termination occurs when requested by the abort() function or when some signals are received. See also #normal normal termination.

Anchor
asynchronous-safe asynchronous-safe

asynchronous-safe [GNU Pth]
A function is asynchronous-safe, or asynchronous-signal safe, if it can be called safely and without side effects from within a signal handler context. That is, it must be able to be interrupted at any point and run linearly out of sequence without causing an inconsistent state. It must also function properly when global data might itself be in an inconsistent state. Some asynchronous-safe operations are listed here:

• call Call the signal() function to reinstall a signal handler
• unconditionally Unconditionally modify a volatile sig_atomic_t variable (as modification to this type is atomic)
• call Call the _Exit() function to immediately terminate program execution
• invoke Invoke an asynchronous-safe function, as specified by your implementation

...

Anchor
basic exception safety basic exception safety

basic exception safety [Stroustrup 01], [Sutter 00]
The basic exception safety guarantee is a property of an operation such that, if the operation terminates by raising an exception, it preserves program state invariants and prevents resource leaks. See also : exception safety, strong exception safety, and no-throw guarantee.

Anchor
conforming program conforming program

conforming [ISO/IEC 9899-1999]
Conforming programs may depend upon nonportable features of a conforming implementation.

Anchor
data race data race

data race [ISO/IEC Document Number N3000 – Working Draft, Standard for Programming Language C++, November 2009]
The execution of a program contains a data race if it contains two conflicting actions in different threads, at least one of which is not atomic, and neither happens before the other. Any such data race results in undefined behavior.

...

Anchor
exception safety exception safety

exception safety [Stroustrup 01]
An operation on an object is said to be exception safe if that operation leaves the object in a valid state when the operation is terminated by throwing an exception. See also : basic exception safety, strong exception safety, and no-throw guarantee.

Anchor
exploit exploit

exploit [Seacord 05a]
An exploit is a piece of software or technique that takes advantage of a security vulnerability to violate an explicit or implicit security policy.

...

Anchor
function-like macro function-like macro

function-like macro [ISO/IEC 9899-1999]
A #define preprocessing directive that defines an identifier immediately followed by zero or more parameters, the ellipsis (...), or a combination of the two, enclosed in parentheses, similar syntactically to a function call. Subsequent instances of the macro name followed by a parenthesized list of arguments in a translation unit are replaced by the replacement list of preprocessing tokens that constitute the remainder of the directive. See also #object object-like macro and #unsafe unsafe function-like macro.

Anchor
hosted environment hosted environment

Anchor
hosted implementation hosted implementation

hosted implementation [ISO/IEC 14882-2003]
An implementation that is not freestanding. Program startup occurs at main(), complex types are implemented, and all C++ standard library facilities are available. Also referred to as hosted environment.

Anchor
ill-formed ill-formed

Anchor
ill-formed program ill-formed program

ill-formed program [ISO/IEC 14882-2003]
A C++ program that is not #wellwell-formed, that is a program not constructed according to the syntax rules, diagnosable semantic rules, and the #One One Definition Rule.

Anchor
implementation implementation

implementation [ISO/IEC 9899-1999]
Particular set of software, running in a particular translation environment under particular control options, that performs translation of programs for, and supports execution of functions in, a particular execution environment.

Anchor
implementation-defined behavior implementation-defined behavior

implementation-defined behavior [ISO/IEC 14882-2003]
Behavior, for a #wellwell-formed program construct and correct data, that depends on the implementation and that each implementation shall document.

...

Anchor
indeterminate value indeterminate value

indeterminate value [ISO/IEC 9899-1999]
Either an #unspecified unspecified value or a #trap trap representation.

Anchor
invalid pointer invalid pointer

invalid pointer
A pointer that is not a #valid valid pointer.

Anchor
locale-specific behavior locale-specific behavior

locale-specific behavior [ISO/IEC 14882-2003]
Behavior that depends on local conventions of nationality, culture, and language that each implementation documents.

Anchor
lvalue lvalue

lvalue [ISO/IEC 9899-1999]
An lvalue is an expression with an object type or an incomplete type other than void. The name "lvalue" comes originally from the assignment expression E1 = E2, in which the left operand E1 is required to be a (modifiable) lvalue. It is perhaps better considered as representing an object "locator value.".

Anchor
mitigation mitigation

mitigation [Seacord 05a]
Mitigations are methods, techniques, processes, tools, or runtime libraries that can prevent or limit exploits against vulnerabilities.

Anchor
normal termination normal termination

normal termination [Open Group 08]
Normal termination occurs by a return from main(), when requested with the exit(), _exit(), or _Exit() functions; or when the last thread in the process terminates by returning from its start function, by calling the pthread_exit() function, or through cancellation. See also #abnormal abnormal termination.

Anchor
no-throw guarantee no-throw guarantee

no-throw guarantee [Sutter 00]
The no-throw guarantee is a property of an operation such that it is guaranteed to complete successfully without raising or propagating an exception. See also : exception safety, basic exception safety, and strong exception safety.

Anchor
object-like macro object-like macro

object-like macro [ISO/IEC 9899-1999]
A #define preprocessing directive that defines an identifier with no parentheses. Subsequent instances of the macro name in a translation unit are replaced by the replacement list of preprocessing tokens that constitute the remainder of the directive. See also #function function-like macro.

Anchor
one definition rule one definition rule

Anchor
odr odr

one definition rule (ODR) [ISO/IEC 14882-2014]
A fundamental C++ rule that states that no translation unit shall contain more than one definition of any variable, function, class type, enumeration type or template, and that every program shall contain exactly one definition of every non-inline function or variable. Some definitions may be duplicated in multiple translation units, subject to strict rules.

...

The following sequence points are defined by C99 [ISO/IEC 9899-1999]:

• the The call to a function, after the arguments have been evaluated
• the The end of the first operand of the following operators: && (logical AND); || (logical OR); ? (conditional); , (comma operator)
• the The end of a full declarator
• the The end of a full expression: an initializer; the expression in an expression statement (that is, at the semicolon); the controlling expression of a selection statement (if or switch); the controlling expression of a while or do statement; each of the expressions of a for statement; the expression in a return statement
• immediately Immediately before a function returns
• after After the actions associated with each formatted input/output function conversion specifier
• immediately Immediately before and immediately after each call to a comparison function, by a standard searching or sorting function, and between any call to a comparison function and any movement of the objects passed as arguments to that call

...

Anchor
strictly conforming strictly conforming

strictly conforming [ISO/IEC 9899-1999]
A strictly conforming program is one that uses only those features of the language and library specified in the international standard. Strictly conforming programs are intended to be maximally portable among conforming implementations and can't, for example, depend upon implementation-defined behavior.

Anchor
strong exception safety strong exception safety

strong exception safety [Stroustrup 01], [Sutter 00]
The strong exception safety guarantee is a property of an operation such that, in addition to satisfying the basic exception safety guarantee, if the operation terminates by raising an exception it has no observable effects on program state. See also : exception safety, basic exception safety, and no-throw guarantee.

Anchor
trap representation trap representation

trap representation [ISO/IEC 9899-1999]
Object representation that does not represent a value of the object type. Attempting to read the value of an object that has a trap representation other than by an expression that has a character type is undefined. Producing such a representation by a side effect that modifies all or any part of the object other than by an expression that has a character type is undefined.

...

Anchor
unsafe function-like macro unsafe function-like macro

unsafe function-like macro
A #functionfunction-like macro whose expansion causes one or more of its arguments not to be evaluated exactly once.

Anchor
unspecified behavior unspecified behavior

unspecified behavior [ISO/IEC 14882-2003]
Behavior, for a #wellwell-formed program construct and correct data, that depends on the implementation. The implementation is not required to document which behavior occurs.

Anchor
unspecified value unspecified value

unspecified value [ISO/IEC 9899-1999]
A valid value of the relevant type where the C++ Standard imposes no requirements on which value is chosen in any instance. An unspecified value cannot be a #trap trap representation.

Anchor
valid pointer valid pointer

valid pointer
A pointer that refers to an element within an array or one past the last element of an array. For the purposes of this definition, a pointer to an object that is not an element of an array behaves the same as a pointer to the first element of an array of length one with the type of the object as its element type. (Cf 6.5.8p3)
For the purposes of this definition, an object can be considered to be an array of a certain number of bytes; that number is the size of the object, as produced by the sizeof operator.

...

well-formed program [ISO/IEC 14882-2003]
A C++ program constructed according to the syntax rules, diagnosable semantic rules, and the #One Definition Rule. See also #ill ill-formed program.

 

...