Known Limitations

HP aC++ does not support large files (files greater than 2 GB) with <iostream.h> or <iostream>

Symbolic debugging information is not always emitted for objects which are not directly referenced. For instance, if a pointer to an object is used but no fields are ever referenced, then HP aC++ only emits symbolic debug information for the pointer type and not for the type of object that the pointer points to. For instance, use of Widget * only emits debug information for the pointer type Widget * and not for Widget. If you wish such information, you can create an extra source file which defines a dummy function that has a parameter of that type (Widget) and link it into the executable program.

Known limitations of exception handling features:

Known limitations of signal handling features:

Source-level debugging of C++ shared libraries is supported. However, there are limitations related to debugging C++ shared libraries, generally associated with classes whose member functions are declared in a shared library, and that have objects declared outside the shared library where the class is defined. Refer to the appropriate release notes and manuals for the operating system and debugger you are using. Refer also to the Software Status Bulletin for additional details.

Instantiation of shared objects with virtual functions in shared memory is not supported.

Using shl_load(3X) or dlopen(3C) with Library-Level Versioning:

Once library-level versioning is used, calls to shl_load() or dlopen() (see shl_load(3X)) should specify the actual version of the library that is to be loaded.

For example, if libA.so is now a symbolic link to libA.so.1, then calls to dynamically load this library should specify the latest version available when the application is compiled, such as:

shl_load("libA.so.1", BIND_DEFERRED, 0);

This will insure that, when the application is migrated to a system that has a later version of libA available, the actual version desired is the one that is dynamically loaded.

Memory Allocation Routine alloca()

The compiler supports the built in function, alloca, defined in the /usr/include/alloca.h header file. The implementation of the alloca() routine is system dependent, and its use is not encouraged.

alloca() is a memory allocation routine similar to malloc() (see malloc(3C)). The syntax is:

void *alloca(size_t <size>);

alloca() allocates space from the stack of the caller for a block of at least <size> bytes, but does not initialize the space. The space is automatically freed when the calling routine exits.

	NOTE: Memory returned by alloca() is not related to memory allocated by other memory allocation functions. Behavior of addresses returned by alloca() as parameters to other memory functions is undefined.

To use this function, you must use the <alloca.h> header file.