| C++ User's Guide | |
Glossary
- See application binary interface.
- 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.
- 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.
- 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.
- See inheritance.
- 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.
- A template that describes a set of classes or related data types.
- 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.
- An instruction to the compiler that changes its behavior. For example, the
-goption 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.
- An element of a class that is data, as opposed to a function or type definition.
- 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.
- See inheritance.
- A special class member function that is automatically called by the compiler whenever a class object is destroyed or the operator
deleteis 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.
- Connection of the function call to the function body at runtime. Occurs only with virtual functions. Also called late binding, runtime binding.
- 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.
- The actual type of an object that is accessed by a pointer or reference that might have a different declared type.
- See static binding.
- 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.
- Code specifically written to deal with errors, and that is invoked automatically when an exception occurs for which the handler has been registered.
- 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.
- Giving the same name, but different argument types and numbers, to different functions. Also called functional polymorphism.
- See function overloading.
- A declaration that describes the function's interface with the rest of the program.
- 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.
- A linker that creates a new executable file by linking only the changed
.ofiles 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.
- A function that replaces the function call with the actual function code.
- The process by which a C++ compiler creates a usable function or object (instance) from a template.
- 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.
- International Organization for Standardization.
- The de facto C programming language standard that was developed by Brian Kernighan and Dennis Ritchie before ANSI C.
- A word that has unique meaning in a programming language, and that can be used only in a specialized context in that language.
- See dynamic binding.
- The tool that connects object code and libraries to form a complete, executable program.
- 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.
- A set of conventions that are unique to a geographical area and/or language, such as date, time, and monetary format.
- 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.
- 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.
- 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.
- 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.
- 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.
- See dynamic binding.
- 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.outfiles 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.
- 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.
- 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.
- A directory containing all configuration files that are needed to handle and instantiate the templates that are required by a program.
- 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.
- 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
integerandfloat. 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
intorvoid, 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.
|
Sun Microsystems, Inc. Copyright information. All rights reserved. Feedback |
Library | Contents | Previous | Next | Index |