|
A
- aggressive optimizations
- Optimizations that can change the behavior of structured code. This is a superset of basic optimizations.
- anachronistic constructs
- Elements of the C++ language that will be obsoleted and therefore unsupported in some future release.
- archive library
- A collection of object files grouped using the ar command. At link time, only object files that have needed symbols are extracted from the library.
- argument declaration file
- For templates, a file containing the declaration of a class, struct, union, or enum type.
- automatic instantiation
-
An instantiation mechanism that uses an automatic instantiation algorithm to
determine in which object file instantiations are placed. Instantiation is
attempted for any use of a template.
Use the +inst_auto command-line option to request automatic instantiation.
Note: In versions A.02.00 and A.01.04 and prior versions of HP aC++,
automatic instantiation was the default. The default is now compile-time
instantiation.
B
- base class
- A class from which another class, the derived class,
inherits the public and protected members. That is,
a derived class inherits the nonprivate member data
and nonprivate member functions from its base class.
Sometimes also called a parent class or superclass.
- basename
- The part of a pathname after the last /.
- basic block
- A sequence of instructions with a single entry point, single exit point, and no internal branches.
- basic optimizations
- Any optimizations that do not generally change the behavior of structured code. This category of optimization is performed by default when you specify a level of optimization. Basic optimizations are a subset of aggressive optimizations and a superset of conservative optimizations.
C
- class
- A user-defined type. A class can have member data and member functions and these can be public, protected, or private members.
- class template
- A template that defines an unbounded set of related classes.
- closing a library
- Satisfying all template instantiations needed by a library when building the library, not when linking the library with an application.
- closing
- The process of satisfying all template instantiations for a set of link units.
- compile-time instantiation
- In HP aC++, this is the default instantiation mechanism. Instantiation is attempted for every template used in a translation unit in that translation unit.
Note that in versions A.02.00 and A.01.04 and prior versions of HP aC++, automatic instantiation was the default.
- conservative optimizations
- Optimizations that do not change the behavior of code, in most cases, even
if the code is unstructured or does not conform to standards. This is a
subset of basic optimizations.
- constructor
- An initialization function for the objects of a class. Constructors have the same name as their class.
D
- derived class
- A class that inherits the public and protected member data and the public
and protected member functions from its base class. Sometimes also called
a child class or subclass.
- destructor
- A function that cleans up or deinitializes each object of a class
immediately before the object is destroyed. Destructors execute when the
program leaves the scope in which objects are defined and when any object
is destroyed by delete. Destructors have the same name as their class,
prefixed by a tilde, ~.
- directed instantiation
- Template instantiation that is specified by the developer by means of an
explicit instantiation or a compiler command-line option.
E
- exception
- An exception is a run-time error condition. Exception
handling is a C++ mechanism that allows the detector of the
error to pass the error condition to code (the exception handler)
that is prepared to handle it. An exception is raised by a throw
statement within a try block and handled by a catch clause.
Note: The ANSI/ISO C++ International Standard defines only
synchronous exceptions.
- explicit instantiation
- A method of instantiation that instantiates a template at
the point of its use. You code an explicit template instantiation
(as defined in the Final Draft International Standard) in your
source file.
- external symbol
- A name of a function or data item in an object file that
is available to other object files to link against.
F
- friend
- Either a class or a function that has access to all of a class'
data and member functions. That is, the friend has access to the
class' public, protected, and private members.
- function template
- A template that defines an unbounded set of related functions.
H
- HP aC++
-
HP's most recent C++ compiler. It closely complies with most features
of the ANSI/ISO C++ International Standard.
- HP C++
-
HP's initial, pre-C++ draft proposed international standard C++
compiler. It is based on the cfront compiler and provides
functionality for templates and exception handling.
- header file
-
A C++ source file typically containing class or function declarations
and referenced by other C++ source files using the #include
preprocessor directive.
I
- include guards
-
Preprocessor commands (typically #ifndef, #define, and #endif)
used in a header file to prevent compiling that file more than once.
- inline function
- A function whose code is copied in place of each function call.
- instantiate
- To form an instantiation by binding a template to particular argument types.
- instantiated class
- A class generated from a class template by instantiation.
- instantiated function
- A funtion generated from a funtion template by instantiation.
- instantiation
- A generated class or function (a definition) that is the result of binding a template to particular argument types. Also known as a generation.
L
- lex
- A program generator for lexical analysis of text.
- link unit
- A single entity submitted to the linker. A link unit can be an object file (.o file, the output of a translation unit), an archive library (.a file), or a shared library (.so file).
- load compile
- Invoking the compiler using the +hdr_use option, and a manual precompiled header file.
M
- member data
- Any data elements declared to be part of a class.
- member function
- Any function declared to be part of a class.
- multiple inheritance
- The ability of a class to inherit from more than
one base class. That is, the derived class inherits all public and
protected members from all of its base classes. Compare to single inheritance.
N
- name demangling
-
The process of changing the internal representation of
identifiers back to their original C++ source names.
Compare to name mangling.
- name mangling
-
The process of generating unambiguous internal
identifiers from C++ identifiers to resolve the
scope of variables, overloaded operators, and
overloaded functions. Compare to name demangling.
O
- object
- An instance of a class.
P
- parameterized type
- See template.
- position-independent code (PIC)
- Object code that contains no absolute addresses.
All addresses are specified relative to the program counter.
Position-independent code is used to create shared libraries.
- pragma
- An instruction to the compiler to compile your program
in a certain way. For example, you can use pragmas to insert
copyright information into your object files, to specify a
particular template instantiation, and to specify optimization
levels.
- precompiled header file
- A .C file that has been compiled using either
the +hdr_create option (for subsequent use in a load
compile) or the +hdr_cache option.
- preprocessing directive
- A command entered into a source file to direct the
preprocessor to perform certain actions on the source file.
For example, the preprocessor can replace tokens in the text,
insert the contents of other files into the source file,
or suppress the compilation of part of the file by conditionally
removing sections of text. It also expands preprocessor macros
and conditionally strips out comments.
- preprocessor
- A portion of the HP aC++ compiler that manipulates the
contents of your source file according to the preprocessing
directives coded in the source file.
- private member
- A private member of a class is a data member or member
function that is only accessible:
- From within the class defining the member.
- From any friends of the class defining the private member.
- profile-based optimization
- A kind of optimization in which the compiler and linker
work together to optimize an application based on profile
data obtained from running the application on a typical
input data set.
- protected member
-
A protected member of a class is a data member or member function that is only accessible:
- From within the class defining the member.
- From any class derived from that class.
- From any friends of the class defining the protected member.
- public member
- A public member of a class is a data member or member
function that is accessible from everywhere outside the class
defining the member as well as from inside the class and from
any derived classes.
S
- shared library
- A collection of object files grouped using the aCC
command and comprised of position-independent code.
At link time, all object files are made available.
- single inheritance
- The ability for a class, the derived class, to inherit
from exactly one class, its base class. Compare to multiple inheritance.
- software pipelining
- A code transformation that optimizes program loops. It is
useful for loops that contain arithmetic operations on floats
and doubles.
- source file
- An HP-UX file containing C++ program code.
- specialization
- An instantiation of a template class or template
function that overrides the standard version.
T
- template
- A skeleton or description for an infinite set of classes
or functions. A class template is a specification for a family or
group of classes. A class template is also known as a parameterized
type. A function template is a specification for a family or group
of functions.
- template argument
- A type or constant specified to a template to distinguish a particular usage of the template.
- template function
- An instantiated function template.
- timestamp
- The date and time a file was last changed.
- translation unit
- The standard term for a compilation unit. It refers
to a single source file submitted to the compiler along with
all files included by the compilation of that single source
file (technically, the output of the preprocessor). A translation
unit normally results in a single object file.
Looking at it another way, a variable name explicitly
declared static has the scope of its translation unit
and can be used as a name for other objects, functions,
and so on in other translation units in the same application.
- trigraph sequences
- A set of three characters that is replaced by a
corresponding single character by the preprocessor.
Y
- yacc
- A programming tool for describing the input to a computer program.
|
