- 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.
- IPF
- Itanium Processor Family
- 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.
- 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.