Extended C++03 Support

Overview

libc++ is an implementation of the C++ standard library targeting C++11 or later.

In C++03, the library implements the C++11 standard using C++11 language extensions provided by Clang.

This document tracks the C++11 extensions libc++ requires, the C++11 extensions it provides, and how to write minimal C++11 inside libc++.

Required C++11 Compiler Extensions

Clang provides a large subset of C++11 in C++03 as an extension. The features libc++ expects Clang to provide are:

• Variadic templates.
• RValue references and perfect forwarding.
• Alias templates
• defaulted and deleted Functions.
• reference qualified Functions

There are also features that Clang does not provide as an extension in C++03 mode. These include:

• constexpr and noexcept
• auto
• Trailing return types.
• >> without a space.

Provided C++11 Library Extensions

Using Minimal C++11 in libc++

This section is for developers submitting patches to libc++. It describes idioms that should be used in libc++ code, even in C++03, and the reasons behind them.

Use Alias Templates over Class Templates

Alias templates should be used instead of class templates in metaprogramming. Unlike class templates, Alias templates do not produce a new instantiation every time they are used. This significantly decreases the amount of memory used by the compiler.

For example, libc++ should not use add_const internally. Instead it should use an alias template like

template <class _Tp>
using _AddConst = const _Tp;

Use Default Template Parameters for SFINAE

There are three places in a function declaration that SFINAE may occur: In the template parameter list, in the function parameter list, and in the return type. For example:

template <class _Tp, class _ = enable_if_t</*...*/ >
void foo(_Tp); // #1

template <class _Tp>
void bar(_Tp, enable_if_t</*...*/>* = nullptr); // # 2

template <class _Tp>
enable_if_t</*...*/> baz(_Tp); // # 3

Using default template parameters for SFINAE (#1) should always be prefered.

Option #2 has two problems. First, users can observe and accidentally pass values to the SFINAE function argument. Second, the default arguement creates a live variable, which causes debug information to be emitted containing the text of the SFINAE.

Option #3 can also cause more debug information to be emitted than is needed, because the function return type will appear in the debug information.

Use unique_ptr when allocating memory

The standard library often needs to allocate memory and then construct a user type in it. If the users constructor throws, the library needs to deallocate that memory. The idiomatic way to achieve this is with unique_ptr.

__builtin_new_allocator is an example of this idiom. Example usage would look like:

template <class T>
T* __create() {
  using _UniquePtr = unique_ptr<void*, __default_new_allocator::__default_new_deleter>;
  _UniquePtr __p = __default_new_allocator::__allocate_bytes(sizeof(T), alignof(T));
  T* __res = ::new(__p.get()) T();
  (void)__p.release();
  return __res;
}