You copied the Doc URL to your clipboard.

Standard C++ library implementation definition (Rogue Wave)

The ARM C++ library provides all of the library defined in the ISO/IEC 14882 :1998(E) C++ Standard, aside from some limitations.

For information on implementation-defined behavior that is defined in the Rogue Wave C++ library, see the Rogue Wave HTML documentation.


The Rogue Wave C++ libraries are deprecated.

The Standard C++ library is distributed in binary form only.

The following table describes the most important features missing from the current release.

Table 1-12 Standard C++ library differences

Standard Implementation differences
locale The locale message facet is not supported. It fails to open catalogs at runtime because the ARM C library does not support catopen() and catclose() through nl_types.h. One of two locale definitions can be selected at link time. Other locales can be created by user-redefinable functions.
Timezone Not supported by the ARM C library.

Thread safety

The following points summarize thread safety in the Rogue Wave C++ library:

  • The function std::set_new_handler() is not thread-safe. This means that some forms of ::operator new and ::operator delete are not thread-safe with respect to std::set_new_handler():

    • The default C++ runtime library implementations of the following use malloc() and free() and are thread-safe with respect to each other. They are not thread-safe with respect to std::set_new_handler(). You are permitted to replace them:

      ::operator new(std::size_t)

      ::operator new[](std::size_t)

      ::operator new(std::size_t, const std::nothrow_t&)

      ::operator new[](std::size_t, const std::nothrow_t)

      ::operator delete(void*)

      ::operator delete[](void*)

      ::operator delete(void*, const std::nothrow_t&)

      ::operator delete[](void*, const std::nothrow_t&)

    • The following placement forms are also thread-safe. You are not permitted to replace them:

      ::operator new(std::size_t, void*)

      ::operator new[](std::size_t, void*)

      ::operator delete(void*, void*)

      ::operator delete[](void*, void*)

  • Construction and destruction of global objects are not thread-safe.

  • Construction of local static objects can be made thread-safe if you re-implement the functions __cxa_guard_acquire(), __cxa_guard_release(), __cxa_guard_abort(), __cxa_atexit() and __aeabi_atexit() appropriately. For example, with appropriate re-implementation, the following construction of lsobj can be made thread-safe:

    struct T { T(); };
    void f() { static T lsobj; }
  • Throwing an exception is thread-safe if any user constructors and destructors that get called are also thread-safe.

  • The ARM C++ library uses the ARM C library. To use the ARM C++ library in a multithreaded environment, you must provide the same functions that you would be required to provide when using the ARM C library in a multithreaded environment.

  • The libc++ library is not thread-safe.
Was this page helpful? Yes No