Sun Studio 12: C++ User's Guide



See Application Binary Interface.

abstract class

A class that contains one or more abstract methods, and therefore can never be instantiated. Abstract classes are defined so that other classes can extend them and make them concrete by implementing the abstract methods.

abstract method

A method that has no implementation.


American National Standards Institute’s definition of the C programming language. It is the same as the ISO definition. See ISO.


The American National Standards Institute and the ISO standard for the C++ programming language. See ISO.

application binary interface

The binary system interface between compiled applications and the operating system on which they run.


A data structure that stores a collection of values of a single data type consecutively in memory. Each value is accessed by its position in the array.

base class

See inheritance.

binary compatibility

The ability to link object files that are compiled by one release while using a compiler of a different release.


Associating a function call with a specific function definition. More generally, associating a name with a particular entity.


A C++ to C compiler program that translates C++ to C source code, which in turn can be compiled by a standard C compiler.


A user-defined data type consisting of named data elements (which may be of different types), and a set of operations that can be performed with the data.

class template

A template that describes a set of classes or related data types.

class variable

A data item associated with a particular class as a whole, not with particular instances of the class. Class variables are defined in class definitions. Also called static field. See also instance variable.

compiler option

An instruction to the compiler that changes its behavior. For example, the -g option tells the compiler to generate data for the debugger. Synonyms: flag, switch.


A special class member function that is automatically called by the compiler whenever a class object is created to ensure the initialization of that object’s instance variables. The constructor must always have the same name as the class to which it belongs. See destructor.

data member

An element of a class that is data, as opposed to a function or type definition.

data type

The mechanism that allows the representation of, for example, characters, integers, or floating-point numbers. The type determines the storage that is allocated to a variable and the operations that can be performed on the variable.

derived class

See inheritance.


A special class member function that is automatically called by the compiler whenever a class object is destroyed or the operator delete is applied to a class pointer. The destructor must always have the same name as the class to which it belongs, preceded by a tilde (~). See constructor.

dynamic binding

Connection of the function call to the function body at runtime. Occurs only with virtual functions. Also called late binding, runtime binding.

dynamic cast

A safe method of converting a pointer or reference from its declared type to any type that is consistent with the dynamic type to which it refers.

dynamic type

The actual type of an object that is accessed by a pointer or reference that might have a different declared type.

early binding

See static binding.

ELF file

Executable and Linking Format file, which is produced by the compiler.


An error occurring in the normal flow of a program that prevents the program from continuing. Some reasons for errors include memory exhaustion or division by zero.

exception handler

Code specifically written to deal with errors, and that is invoked automatically when an exception occurs for which the handler has been registered.

exception handling

An error recovery process that is designed to intercept and prevent errors. During the execution of a program, if a synchronous error is detected, control of the program returns to an exception handler that was registered at an earlier point in the execution, and the code containing the error is bypassed.


See compiler option.

functional polymorphism

See function overloading.

function overloading

Giving the same name, but different argument types and numbers, to different functions. Also called functional polymorphism.

function prototype

A declaration that describes the function’s interface with the rest of the program.

function template

A mechanism that allows you to write a single function that you can then use as a model, or pattern, for writing related functions.


The property of a header file that including it many times in one translation unit has the same effect as including it once.

incremental linker

A linker that creates a new executable file by linking only the changed .o files to the previous executable.


A feature of object-oriented programming that allows the programmer to derive new classes (derived classes) from existing ones (base classes). There are three kinds of inheritance: public, protected, and private.

inline function

A function that replaces the function call with the actual function code.

instance variable

Any item of data that is associated with a particular object. Each instance of a class has its own copy of the instance variables defined in the class. Also called field. See also class variable.


The process by which a C++ compiler creates a usable function or object (instance) from a template.


International Organization for Standardization.


A word that has unique meaning in a programming language, and that can be used only in a specialized context in that language.


The de facto C programming language standard that was developed by Brian Kernighan and Dennis Ritchie before ANSI C.

late binding

See dynamic binding.


The tool that connects object code and libraries to form a complete, executable program.


A set of conventions that are unique to a geographical area and/or language, such as date, time, and monetary format.

local variable

A data item known within a block, but inaccessible to code outside the block. For example, any variable defined within a method is a local variable and cannot be used outside the method.


An expression that designates a location in memory at which a variable’s data value is stored. Also, the instance of a variable that appears to the left of the assignment operator.


See name mangling.

member function

An element of a class that is a function, as opposed to a data definition or type definition.


In some object-oriented languages, another name for a member function.

multiple inheritance

Inheritance of a derived class directly from more than one base class.


The software technology that enables the development of parallel applications, whether on single- or multiple-processor systems.

name mangling

In C++, many functions can share the same name, so name alone is not sufficient to distinguish different functions. The compiler solves this problem by name mangling—creating a unique name for the function that consists of some combination of the function name and its parameters—to enable type-safe linkage. Also called name decoration.


A mechanism that controls the scope of global names by allowing the global space to be divided into uniquely named scopes.

operator overloading

The ability to use the same operator notation to produce different outcomes. A special form of function overloading.


The process of improving the efficiency of the object code that is generated by the compiler.


See compiler option.


To give the same name to more than one function or operator.


The ability of a pointer or reference to refer to objects whose dynamic type is different from the declared pointer or reference type.


A compiler preprocessor directive, or special comment, that instructs the compiler to take a specific action.

runtime binding

See dynamic binding.

runtime type identification (RTTI)

A mechanism that provides a standard method for a program to determine an object type during runtime.


The variable that is located to the right of an assignment operator. The rvalue can be read but not altered.


The range over which an action or definition applies.


A symbol table entry that is generated in the object code. The same format is used in both a.out files and ELF files to contain debugging information.


A data storage method by which data can be added to or removed from only the top of the stack, using a last-in, first-out strategy.

static binding

Connection of a function call to a function body at compile time. Also called early binding.


A function. In Fortran, a function that does not return a value.


See compiler option.


A name or label that denotes some program entity.

symbol table

A list of all identifiers that are present when a program is compiled, their locations in the program, and their attributes. The compiler uses this table to interpret uses of identifiers.

template database

A directory containing all configuration files that are needed to handle and instantiate the templates that are required by a program.

template options file

A user-provided file containing options for the compilation of templates, as well as source location and other information. The template options file is deprecated and should not be used.

template specialization

A specialized instance of a class template member function that overrides the default instantiation when the default cannot handle a given type adequately.


Interception of an action, such as program execution, in order to take other action. The interception causes the temporary suspension of microprocessor operations and transfers program control to another source.


A description of the ways in which a symbol can be used. The basic types are integer and float. All other types are constructed from these basic types by collecting them into arrays or structures, or by adding modifiers such as pointer-to or constant attributes.


An item of data named by an identifier. Each variable has a type, such as int or void, and a scope. See also class variable, instance variable, local variable.


A table that is created by the compiler for each class that contains virtual functions.