Index

Symbols

#define preprocessor directive, Constant Data Types, Macro Replacement
#elif preprocessor directive, Syntax
#else preprocessor directive, Syntax
#endif preprocessor directive, Syntax
#error preprocessor directive, Error Directive
#if preprocessor directive, Syntax
#ifdef preprocessor directive, Syntax
#ifndef preprocessor directive, Syntax
#include preprocessor directive, Source File Inclusion, Location of Standard HP-UX Header Files, Linking
#line preprocessor directive, Description
#pragma preprocessor directive, Pragma Directive, Pragma Directives
#undef preprocessor directive, Description
-pt template options to CC, The CC Command Options
.C file, Preprocessing, Preprocessing, Data Hiding Using Files as Modules
.c file, Preprocessing, Preprocessing, Data Hiding Using Files as Modules
.i file, Preprocessing, Preprocessing, Translating C++ Source Code to C, Specifying Files to the CC Command
.o file, Compiling C++ Source Code, Compiling the Translated C Source Code, Specifying Files to the CC Command, The CC Command Options, Linking
.s assembly source file, Specifying Files to the CC Command
__cplusplus, Predefined Macros
__DATE__, Predefined Macros
__FILE__, Predefined Macros, Description
__LINE__, Predefined Macros, Description
__STDCPP__, Predefined Macros
__TIME__, Predefined Macros
_main, Calling HP C++ from HP C

A

a.out file, Linking, Linking Constructors and Destructors, Linking, Linking Constructors and Destructors, An Example of Using a Compiler Option, Executing HP C++ Programs

address operator (&), Using Reference Variables to Pass Arguments

ANSI C, Constant Data Types, Variable Number of Arguments, Function Declarations, Constants

ANSI C mode preprocessor, Overview, Using Preprocessor Directives, The CC Command Options

archive library

linking, Linking to C++ Libraries, Linking Archive or Shared Libraries
searching, The CC Command Options

argument

checking, Type Checking Features in Functions
default, Default Arguments
passing, Differences in Argument Passing Conventions, Using Reference Variables to Pass Arguments
variable number of, Default Arguments
widening, Calling HP C from HP C++, Differences in Argument Passing Conventions

arrays, Character Array Initialization, Arrays

assembler, Specifying Files to the CC Command

substituting for, The CC Command Options

assignment of void pointer, Assignment of Void Pointers

auto keyword, The new and delete Operators

automatic instantiation of templates, Templates, Template Code is Stored in a Repository, Link-Time Template Processing, Link-Time Template Processing

automatic object, The new and delete Operators

B

bank example program, Object-Oriented Programming: The Bank Example

base class, Inheritance

binding

dynamic, Type Polymorphism
run-time, Type Polymorphism

built-in types, Data Abstraction

C

C, Data Compatibility between C and C++, Calling HP C++ from HP C

compiler (cc), Compiling the Translated C Source Code, The CC Command Options
converting to C++, Changing Your C Programs to C++
language, Overview of HP C++

C++

advantages over C, Overview of HP C++
compatibility with C, Compatibility with C, Data Compatibility between C and C++
compiling system, Phases of the Compiling System
converting from C, Changing Your C Programs to C++
history, History of C++
overview, Overview of HP C++
release notes, Exception Handling
service, Data Hiding Using Files as Modules, The Lending Library
versions, History of C++

c++filt

substituting for, The CC Command Options

c++merge, Adding Debug Information

substituting for, The CC Command Options

c++patch, Linking Constructors and Destructors, Linking Constructors and Destructors

substituting for, The CC Command Options

c++ptcomp, Compile-Time Template Processing, Compile-Time Template Processing

c++ptlink, Link-Time Template Processing, Link-Time Template Processing

c__plusplus, Predefined Macros

calling

HP C from HP C++, Calling HP C from HP C++
HP C++ from HP C, Calling HP C++ from HP C
HP FORTRAN 77 from HP C++, Calling HP Pascal and HP FORTRAN 77 from HP C++
HP Pascal from HP C++, Calling HP Pascal and HP FORTRAN 77 from HP C++

case sensitivity

with FORTRAN and Pascal, Function Naming Conventions

catch keyword, New Keywords

catching exceptions, You Must Use the +eh Option

CC command

example use, Getting Started with HP C++
how it works, Phases of the Compiling System
options, Specifying Options to the CC Command
path, Compiling with the CC Command
syntax, Setting Your Path to the CC Command

cc command, Compiling the Translated C Source Code

CCLIBDIR environment variable, The CCLIBDIR and CCROOTDIR Environment Variables

CCOPTS, The CXXOPTS Environment Variable

CCROOTDIR environment variable, The CCLIBDIR and CCROOTDIR Environment Variables

cfront, Compiling C++ Source Code, Translating C++ Source Code to C

substituting for, The CC Command Options

cfront2, Compiling C++ Source Code

changing C program to C++, Changing Your C Programs to C++

class

base, Inheritance
data type, Encapsulation, Data Abstraction
derived, Inheritance
keyword, New Keywords, Data Compatibility between C and C++
template, Class Templates

client, Data Hiding Using Files as Modules

codelibs library, HP Codelibs Library, HP C++ Library Files

comments, Comments

compatibility

between versions of HP C++, History of C++
with C data, Data Compatibility between C and C++

compatibility mode, preprocessor operation, Overview, The CC Command Options

compiler

cfront, Compiling C++ Source Code, Translating C++ Source Code to C
mode, History of C++, What Happens in Compiler Mode, The CC Command Options, Differences in Argument Passing Conventions
options, Compiling with the CC Command

compiling

HP C++ programs, Getting Started with HP C++, Compiling with the CC Command
system, Phases of the Compiling System

complex library, Complex Library

complex.h, C++ Library Header Files

concatenating

compiler options, Concatenating Options
strings, Macros with Parameters

conditional compilation, Syntax, Conditional Compilation

const keyword, Constant Data Types, New Keywords, Constants

constants, Constant Data Types, Constants, Example 2

constructor, Constructors and Destructors, The main() Function

constructor linker, Linking Constructors and Destructors, Linking Constructors and Destructors

conversion operators, Conversion Operators

COPYRIGHT, Pragma COPYRIGHT

COPYRIGHT Pragma, Pragma HP_SHLIB_VERSION

COPYRIGHT_DATE, Pragma COPYRIGHT_DATE

cxxdl.h, Shared Library Header files

CXXOPTS environment variable, The CXXOPTS Environment Variable

cxxshl_load, Routines You Can Use to Manage C++ Shared Libraries

cxxshl_unload, Routines You Can Use to Manage C++ Shared Libraries

D

data

abstraction, How Does C++ Support Object-Oriented Programming?, Data Abstraction
compatibility with C, Data Compatibility between C and C++
hiding, Data Hiding Using Files as Modules
long double type, Data Compatibility between C and C++
member, Encapsulation
primitive types, Data Compatibility between C and C++

debugger compiler options -g, -g1, Debugging C++ Programs, The CC Command Options

debugging C++ programs, Debugging C++ Programs

declaring

functions, Type Checking Features in Functions
variables, Variable Declarations

default function arguments, Default Arguments

defined preprocessor operator, Using the defined Operator

defining constants, Constant Data Types, Example 2

definition of TRUE and FALSE, Definition of TRUE and FALSE

delete keyword, New Keywords

delete operator, The new and delete Operators

dem.h, C++ Library Header Files

dereferencing null pointers, The CC Command Options

derived class, Inheritance

destructor, Constructors and Destructors, The main() Function

differences

between C and C++, How C++ Differs from C

directive, preprocessor

#define, Constant Data Types, Macro Replacement
#elif, Syntax
#else, Syntax
#endif, Syntax
#error, Error Directive
#if, Syntax
#ifdef, Syntax
#ifndef, Syntax
#include, Source File Inclusion
#line, Description
#pragma, Pragma Directive
#undef, Description

distributing files, Distributing HP C++ Libraries, Object Files, and Executable Files

dynamic binding, Type Polymorphism

E

eh.h, C++ Library Header Files

ellipsis points, Variable Number of Arguments, Function Declarations

encapsulation, Encapsulation

endfunction

inline, Inline Functions

endinline

function, Inline Functions

endmacro, Predefined Macros

environment variables, Environment Variables

example programs

bank example, Object-Oriented Programming: The Bank Example
C calling C++, Calling HP C++ from HP C
C++ calling C, The main() Function
class template of a stack, Class Templates
exception handling in a stack, Examples
function template, Function Templates
library example, Data Hiding Using Files as Modules
online source files, Using the Online Sample Programs

exception handling, Exception Handling

example program, Examples
required command line option +eh, You Must Use the +eh Option

executable file, Linking, Linking, Executing HP C++ Programs, Linking

executing HP C++ programs, Getting Started with HP C++, Executing HP C++ Programs

expanded functions, Inline Functions

extern "C" declaration, Introduction

C example, Calling HP C++ from HP C
with C, Calling HP C from HP C++
with FORTRAN and Pascal, Using extern "C" Linkage

extern keyword, Constants

external file, External Names

F

FALSE, definition of, Definition of TRUE and FALSE

file

a.out, Linking, Linking Constructors and Destructors, Linking, Linking Constructors and Destructors, An Example of Using a Compiler Option, Executing HP C++ Programs
accessing from C++ and other languages, Files
executable, Linking, Linking, Executing HP C++ Programs, Linking
external, External Names
header, Standard HP-UX Libraries
source file name, Specifying Files to the CC Command

FORTRAN 77, Calling HP Pascal and HP FORTRAN 77 from HP C++

free function, The new and delete Operators

free storage, The new and delete Operators

friend keyword, New Keywords

fstream.h, C++ Library Header Files

function

declaring, Type Checking Features in Functions
default arguments, Default Arguments
expanded, Inline Functions
free, The new and delete Operators
inline, Inline Functions, Using Constants and Inline Functions instead of Macros
malloc, The new and delete Operators
member, Encapsulation
overloaded, Overloaded Functions, Using the extern "C" Linkage Specification
prototypes, Differences in Argument Passing Conventions
virtual, Type Polymorphism, Constructors and Destructors

function template, Function Templates

inline

function, Inline Functions, Using Constants and Inline Functions instead of Macros
keyword, New Keywords, Inline Functions

instantiation of templates, Templates, Template Code is Stored in a Repository, Link-Time Template Processing, Link-Time Template Processing

inter-language calling, Inter-Language Communication

interface, Data Hiding Using Files as Modules

iomanip.h, C++ Library Header Files

iostream.h, C++ Library Header Files

K

keywords, New Keywords

L

libraries

codelibs, HP Codelibs Library, HP C++ Library Files
complex, Complex Library
HP-UX, Standard HP-UX Libraries
libC.a, libC.sl, Linking, Linking, Support for Multi-Threaded Applications, Linking to C++ Libraries, Differences in Argument Passing Conventions
libc.a, libc.sl, Linking, Linking, Linking to C++ Libraries
libC.ansi.a, libC.ansi.sl, Linking, Linking, Differences in Argument Passing Conventions
ostream, Ostream Library, Support for Multi-Threaded Applications
run-time, C++ Run-Time Libraries
standard components, Standard Components Library, HP C++ Library Files
stream, Stream Library
task, Task Library, HP C++ Library Files

line control, Syntax, Line Control

link editor (ld)

libraries searched by, The CC Command Options, Linking to C++ Libraries
link phase, Linking, Linking
substituting for, The CC Command Options

linking

example, Linking
overview, Linking, Linking
to libraries, Linking to C++ Libraries
with mixed language modules, Introduction, Linking HP FORTRAN 77 and HP Pascal Routines on HP-UX

LOCALITY, Pragma LOCALITY

long double type, Data Compatibility between C and C++

M

macro, Constant Data Types, Syntax, Macro Replacement

defining, Syntax
FALSE, Other Macros
parameters, Macros with Parameters
predefined, Predefined Macros
TRUE, Other Macros

main(), Introduction, The main() Function, Calling HP C++ from HP C, The main() Function

maintemplate

CC command line options, The CC Command Options

malloc function, The new and delete Operators

mangling names, Calling HP C++ from HP C

member

data, Encapsulation
function, Encapsulation

merging debug information, Adding Debug Information

messages

sending to objects, What Is Object-Oriented Programming?

mixed language modules, Introduction

mode

ANSI C mode preprocessor, Overview, Using Preprocessor Directives, The CC Command Options
compatibility mode preprocessor, Overview, The CC Command Options
compiler, History of C++, What Happens in Compiler Mode, The CC Command Options, Differences in Argument Passing Conventions
translator, What Happens in Translator Mode, The CC Command Options, Differences in Argument Passing Conventions

module, Data Hiding Using Files as Modules, Inter-Language Communication

multi-thread support, Support for Multi-Threaded Applications

multiple inheritance, Inheritance

N

name

mangling, Calling HP C++ from HP C

new

keyword, New Keywords
operator, The new and delete Operators

new.h, C++ Library Header Files

null pointer dereferencing, The CC Command Options

O

object, What Is Object-Oriented Programming?

object-oriented programming, Overview of HP C++, Support for Object-Oriented Programming

online source files for example programs, Using the Online Sample Programs

operator

#, Macros with Parameters
##, Specifying String Literals with the # Operator
&, Using Reference Variables to Pass Arguments
conversion, Conversion Operators
delete, The new and delete Operators
keyword, New Keywords, Overloaded Operators
new, The new and delete Operators
overloaded, Overloaded Operators

optimization

-O option, The CC Command Options
pragmas, Optimization Pragmas

OPTIMIZE pragma, Optimization Pragmas

ostream library, Ostream Library, Support for Multi-Threaded Applications

ostream.h, Ostream Library

overload keyword, Overloaded Functions

overloaded

function, Overloaded Functions, Using the extern "C" Linkage Specification
operator, Overloaded Operators

P

Pascal, Calling HP Pascal and HP FORTRAN 77 from HP C++

patch phase of C++ compiler, Linking Constructors and Destructors, Linking Constructors and Destructors

pointer

and polymorphism, Type Polymorphism
void, Assignment of Void Pointers

polymorphism, How Does C++ Support Object-Oriented Programming?, Type Polymorphism

pound sign (#) in preprocessor directives, Using Preprocessor Directives

predefined macros, Predefined Macros

preprocessor, Preprocessing, Preprocessing

ANSI C mode, Overview, Using Preprocessor Directives, The CC Command Options
compatibility mode, Overview, The CC Command Options
substituting for, The CC Command Options

primitive data types, Data Compatibility between C and C++

private keyword, New Keywords, Encapsulation

program design, An Extensive Example

protected keyword, New Keywords

PTOPTS not supported, CC Options for Templates

public keyword, New Keywords, Encapsulation

R

redirecting stdin and stdout, Redirecting stdin and stdout
reference variable, Calling HP C++ from HP C, Using Reference Variables to Pass Arguments
release notes, Exception Handling
releases of C++, History of C++
reliability improvements of C++, Reliability Improvements
run-time binding, Type Polymorphism
run-time libraries, C++ Run-Time Libraries

S

shared library

binding time, Binding Times
creating, The CC Command Options, Creating a Shared Library
cxxdl.h, Shared Library Header files
cxxshl_load, Routines You Can Use to Manage C++ Shared Libraries
cxxshl_unload, Routines You Can Use to Manage C++ Shared Libraries
generating position-independent code for, The CC Command Options, Compiling for Shared Libraries
linking, Linking to C++ Libraries, Linking Archive or Shared Libraries
managing, Routines You Can Use to Manage C++ Shared Libraries
pragma, Pragmas for Shared Libraries
restriction on creating C++, Creating a Shared Library
restriction on linking C++, Using a Shared Library
restriction on moving, Using a Shared Library
searching, The CC Command Options
updating, Updating a Shared Library
version control, Pragmas for Shared Libraries

simulated linking option -ptb, The CC Command Options

single inheritance, Inheritance

source file

allowable names, Specifying Files to the CC Command
example programs, Using the Online Sample Programs
inclusion of, Syntax, Source File Inclusion

standard components library, Standard Components Library, HP C++ Library Files

static

keyword, Constants, The new and delete Operators
object, The new and delete Operators

static analysis information option -y, The CC Command Options

stdiostream.h, C++ Library Header Files

stream library, Stream Library

stream.h, C++ Library Header Files

string

concatenating, Macros with Parameters
FORTRAN, Strings
Pascal, Strings

Stroustrup, Bjarne, History of C++

strstream.h, C++ Library Header Files

struct keyword, Structures, Data Compatibility between C and C++

structures, Structures

T

task library, Task Library, HP C++ Library Files

task.h, C++ Library Header Files

template, Templates

CC command line options, CC Options for Templates
class, Class Templates
function, Function Templates
instantiation, Templates, Template Code is Stored in a Repository
keyword, New Keywords
processing with c++ptcomp, Compile-Time Template Processing, Compile-Time Template Processing
processing with c++ptlink, Link-Time Template Processing, Link-Time Template Processing
repository, Template Code is Stored in a Repository, Compile-Time Template Processing, Link-Time Template Processing, Compile-Time Template Processing, Link-Time Template Processing

this keyword, New Keywords

throw keyword, New Keywords

throwing exceptions, You Must Use the +eh Option

tilde (~) in destructor name, Constructors and Destructors

TMPDIR environment variable, The TMPDIR Environment Variable

trailing arguments, Default Arguments

translator

mode, What Happens in Translator Mode, The CC Command Options, Differences in Argument Passing Conventions
USL, Overview of HP C++, History of C++

trigraph sequences, Trigraph Sequences

TRUE, definition of, Definition of TRUE and FALSE

try block, You Must Use the +eh Option

try keyword, New Keywords

type

built-in, Data Abstraction
checking, Type Checking Features in Functions
conversion, Type Checking Features in Functions, Conversion Operators
polymorphism, How Does C++ Support Object-Oriented Programming?, Type Polymorphism

U

USL

translator, Overview of HP C++, History of C++
version 2.0, History of C++
version 2.1, History of C++
version 3.0, Overview of HP C++

V

variable declarations, Variable Declarations

vector.h, C++ Library Header Files

VERSIONID, Pragma VERSIONID

versions of C++, History of C++

virtual

function, Type Polymorphism, Constructors and Destructors
keyword, New Keywords, Type Polymorphism
table , HP C++ Compiler Options

void keyword, Function Declarations

void pointer, Assignment of Void Pointers

volatile keyword, New Keywords

W

warnings

generated by lex programs, Notes on Using lex and yacc
generated by yacc programs, Notes on Using lex and yacc

Y

yacc routines

requiring yacc.h, Notes on Using lex and yacc

yacc.h

required when calling yacc routines, Notes on Using lex and yacc

Index

Technical documentation

» Table of Contents

» Index

Symbols

A

B

C

D

E

F

G

H

I

K

L

M

N

O

P

R

S

T

U

V

W

Y