- aggressive optimizations
-
Any 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 that 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.
- 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.
- 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
-
Any 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.
- 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.
- 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.
- friend
-
Either a class or a function that has access to all of a class's
data and member functions. That is, the friend has access to the class's
public, protected, and
private members.
- function template
-
A template that defines an unbounded set of related functions.
- 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.
- HP aC++
-
HP's most recent C++ compiler.
It closely complies with most features of the ANSI/ISO C++ International Standard.
- header file
-
An C++ source file typically containing class or function
declarations and referenced by other C++ source files using
the
#include preprocessor directive.
- 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.
- 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 (.sl file).
- load compile
-
Invoking the compiler using the +hdr_use option, and
a manual precompiled header file.
- member data
-
Any data elements declared to be part of a class.
- member function
-
Any function declared to be part of a class.
- millicode library
-
The millicode library contains special purpose routines that are
tailored for performance. The routines are implemented in PA-RISC
assembly code and follow a special stream-lined procedure calling
convention. The millicode routines are not intended to be called
directly by user programs due to the strict coding, calling, and
register usage requirements.
Refer to the "PA-RISC Procedure Calling Conventions Reference
Manual" for details on the special millicode calling convention.
- 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.
- 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.
- object
-
An instance of a class.
- 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 and
- 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, and
- 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.
- 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.
- 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.
- yacc
-
A programming tool for describing the input to a computer program.