Known Problems

Incompatibilities Between the Standard C++ Library Version 1.2.1 and the Draft Standard

As the ANSI C++ standard has evolved over time, the Standard C++ Library has not always kept up. Such is the case for the times function object in the functional header file. In the standard, times has been renamed to multiplies.

If you want to use multiplies in your code, to be compatible with the ISO/ANSI C++ standard, use a conditional compilation flag on the aCC command line. For example, for the following program, compile with the command line:

aCC -D__HPACC_USING_MULTIPLIES_IN_FUNCTIONAL test.c// test.c
int times;			 //user defined variable
#include <functional>
// multiplies can be used inint main() {}
// end of test.c

Depending on the existence of the conditional compilation flag, functional defines either times or multiplies, not both. So, if you have old source that uses times in header functional and also new source that uses multiplies, the sources cannot be mixed. Mixing the two sources would constitute a non-conforming program, and the old and new sources may or may not link.

If your code uses the old name times, and you want to continue to use the now non-standard times function object, you do not need to do anything to compile the old source.

Changes to the math.h System Header File

At the HP-UX 11.00 release, the math.h header file has changed in the following ways:

Conflict between macros.h and numeric_limits Class (min and max)

If your code includes /usr/include/macros.h, note that the min and max macros defined in macros.h conflict with the min and max functions defined in the numeric_limits class of the Standard C++ Library. The following code, for example, would generate a compiler Error 134:

numeric_limits<unsigned int>::max();

If you must use the macros.h header, try undefining the macros that conflict:

...
#include <macros.h>
#undef max
#undef min
...

Unsatisfied Symbols if Using Non-current Run-time Support Library

If you see a message like the following, you may be using a non-current version of the HP aC++ run-time support library.

/opt/aCC/lbin/ld: Unsatisfied symbols:
   Class tables [Vtable] dependent on key function:
   "__versioned_type_info::~__versioned_type_info()" (data)

For example, if you are a library distributor, you must ensure that your customers use the same or a newer version of the libCsup run-time library as you. If necessary, you should install the most current HP aC++ library support patch and distribute this patch to your customers.

Unsatisfied Symbols for Inline Template Functions

If you use explicit instantiation instead of closing a library, and you compile with the +inst_auto option, then unless you compile with the +inst_none option, unsatisfied symbols will be generated for inline template functions that are too large to inline.

Potential Binary Incompatibility of Objects Built with HP-UX 10.10, 10.20 HP aC++

The underlying type corresponding to the "size_t" typedef has changed from unsigned int to unsigned long. Similarly, "ptrdiff_t " has changed from int to long. These changes make the 10.10, 10.20 HP aC++ runtime libraries incompatible with subsequent compiler releases. The changes will cause compatibility problems when size_t is used in a non-extern "C" interface. (The mangled signature would be different.)

Due to these changes, if any object files are recompiled or linked, then all HP aC++ files must be recompiled. This implies that third party libraries in archive form also need to be recompiled or resupplied.

Potential Source Incompatibility of Objects built with HP-UX 10.10, 10.20 HP aC++

When your code overloads system header file functions, it is possible that C++ source files that compile without error using HP aC++ for HP-UX 10.10 or 10.20 might not compile with a subsequent compiler release. The example below shows why this potential problem exists.

1: #include <time.h>
2: time_t ff (time_t t) { return t; }
3: time_t ff (long t) { return t; }   // This causes a duplicate.
4: time_t ff (char t) { return t; }   // This causes an ambiguity.
5: int main () { long tt = ff (1L); return 0; }

ff is overloaded to take either a time_t, long, or char parameter. On a 10.10 or 10.20 system where time_t is a long, the call to ff in main resolves to ff(time_t). On a 10.30 system, however, where time_t is an int, the code fails to compile:

Error 225: "t1.C", line 4 # Ambiguous overloaded function call; more than one acceptable function found. Two such functions that matched were "int ff(char)" ["t1.C", line 5] and "int ff(int)" ["t1.C", line 3]. int main () { long tt = ff (1L); }
                                           ^^

Binary Compatibility Between HP-UX 11.00 bundle from the June 2000 Support Plus media revision B.11.00.49 and HP-UX 11.00

An application that ran on the HP-UX 11.00 release will generally continue to run with the same behavior on 32-bit and 64-bit HP-UX 11.00 bundle from the June 2000 Support Plus media revision B.11.00.49 provided that any dependent shared libraries are also present. An executable is a binary file that has been processed by the HP linker with ld or indirectly with the compiler, and can be run by the HP-UX loader(exec).

The following items describe exceptions to binary compatibility between the 11.00 and bundle from the June 2000 Support Plus media revision B.11.00.49 releases. These conditions can occur during your development process, but rarely affect deployed applications.