C++ Library Status

This document, organized by header file, gives details about how much of the C++ library is currently available and what parts remain to be implemented.

By default, assume all C++ 1998 library components are implemented unless otherwise stated. However, also assume that no C++ 2011 library components are implemented unless otherwise stated. In other words, the lists below contain C++ 1998 components that are missing and C++ 2011 components that are available. These defaults reflect the fact that Open Watcom's C++ 2011 support is still in its early stages.

The Open Watcom documentation set also includes a document entitled OWSTL Design Documentation, that described the design decisions made in the Open Watcom Standard Template Library (OWSTL). It is a complement to this document.

All the header files of the C++ 2011 standard are listed here, and all of these header files exist in the Open Watcom distribution. Most of the C++ 2011 headers are little more than placeholders at this time. They allow programs that include those headers to compile, although in most cases none of the C++ 2011 content is actually available.

<algorithm>

The following algorithms are shown in the order in which they appear in the C++ 1998 standard.

Non-modifying Sequence Operations

All C++ 98 components are available.

Mutating Sequence Operations

rotate( Forward, Forward, Forward )
rotate_copy( Forward, Forward, Forward, Output )
random_shuffle( RandomAccess, RandomAccess )
random_shuffle( RandomAccess, RandomAccess, RandomNumberGenerator)
partition( Forward, Forward, Predicate )
stable_partition( Bidirectional, Bidirectional, Predicate )

Sorting and Related Operations

stable_sort( RandomAccess, RandomAccess )
stable_sort( RandomAccess, RandomAccess, Compare )
partial_sort( RandomAccess, RandomAccess, RandomAccess )
partial_sort( RandomAccess, RandomAccess, RandomAccess, Compare )
partial_sort_copy( Input, Input, RandomAccess, RandomAccess )
partial_sort_copy( Input, Input, RandomAccess, RandomAccess, Compare )
nth_element( RandomAccess, RandomAccess, RandomAccess )
nth_element( RandomAccess, RandomAccess, RandomAccess, Compare )
lower_bound( Forward, Forward, const T& )
lower_bound( Forward, Forward, const T&, Compare )
upper_bound( Forward, Forward, const T& )
upper_bound( Forward, Forward, const T& , Compare )
equal_range( Forward, Forward, const T& )
equal_range( Forward, Forward, const T&, Compare )
merge( Input1, Input1, Input2, Input2, Output result )
merge( Input1, Input1, Input2, Input2, Output result, Compare )
includes( Input1, Input1, Input2, Input )
includes( Input1, Input1, Input2, Input2, Compare )
set_union( Input1, Input1, Input2, Input2, Output )
set_union( Input1, Input1, Input2, Input2, Output, Compare )
set_intersection( Input1, Input1, Input2, Input2, Output )
set_intersection( Input1, Input1, Input2, Input2, Output, Compare )
set_difference( Input1, Input1, Input2, Input2, Output )
set_difference( Input1, Input1, Input2, Input2, Output, Compare )
set_symmetric_difference( Input1, Input1, Input2, Input2, Output )
set_symmetric_difference( Input1, Input1, Input2, Input2, Output, Compare )

The OWCPPLIB implementation of unique does not follow the precise letter of the 1998 standard. This is common since the standard is defective in this regard. See "Unique effects unclear when predicate not an equivalence relation" in the WG21 library defects list. The Open Watcom library follows the proposed resolution in the defect report. For maximum portability avoid using unique with a non-equivalence relation.

The OWCPPLIB's implementation of sort uses a QuickSort with a median-of-three pivoting scheme. It is recursive and thus uses O(log(N)) stack space (in the average case).

<array>

Not implemented.

<atomic>

Not implemented.

<bitset>

Mostly complete.

<chrono>

Not implemented.

<codecvt>

Not implemented.

<complex>

Mostly complete. No I/O operators for std::complex have been implemented but essentially all the operations exist. This code needs to be reviewed by someone well versed in numerical methods.

<condition_variable>

Not implemented.

<deque>

Partially complete. Enough functionality exists to be useful, but the following member functions are missing:

assign( size_type, const T& )
clear( )
deque( InputIterator, InputIterator, const Allocator& )
erase( iterator, iterator )
insert( iterator, const T& )
insert( iterator, size_type, const T& )
operator=( const deque& )
swap( deque& )
template assign( InputIterator, InputIterator )
template insert( iterator, InputIterator, InputIterator )

<exception>

Mostly complete.

<forward_list>

Mostly complete.

<fstream>

The old-style IOStreams library is in namespace std.

<functional>

Complete.

<future>

Not implemented.

<initializer_list>

Not implemented.

<iomanip>

The old-style IOStreams library is in namespace std.

<ios>

The old-style IOStreams library is in namespace std.

<iosfwd>

The old-style IOStreams library is in namespace std.

<iostream>

The old-style IOStreams library is in namespace std.

<istream>

The old-style IOStreams library is in namespace std.

<iterator>

Mostly complete. The only significant missing components are the stream iterators. These will be added once the new IOStreams library is sufficiently mature.

<limits>

Mostly complete. Support for numeric_limits on the floating point types is marginal and not complete. The current implementation of limits is based on the macros in the C header limits.h. Including limits will cause limits.h to also be included, bringing the macros it defines into view. This may not be desirable. However, this approach also means that corrections to limits.h are automatically applied to limits as well.

<list>

Partially complete. Enough functionality exists to be useful. The following member functions are missing:

back( ) const;
front( ) const;
max_size( ) const
merge( list &, Compare )
remove_if( Predicate )
resize( size_type, T )
template <InputIterator> ctor
unique( BinaryPredicate )
unique( )

<locale>

Not implemented.

<map>

Partially complete. Enough functionality exists to be useful. The following member functions are missing:

const_reverse_iterator		
count( )		
equal_range( key_type ) and equal_range( key_type ) const		
erase( iterator first, iterator last )		
find( key_type ) const		
key_comp( )		
max_size( )		
rbegin( )
rbegin( ) const		
rend( )
rend( ) const		
reverse_iterator
swap		
template<InputIterator> ctor
value_comp( )

<memory>

Mostly complete. Note that (among other things) std::auto_ptr is not 100% compliant with the standard, although it should be close enough for some applications. The C++ 2011 smart pointer templates are partially complete. In particular, std::unique_ptr is not yet implemented due to missing move semantics in the compiler.

<mutex>

Not implemented.

<new>

Mostly complete.

<numeric>

Complete.

<ostream>

The old-style IOStreams library is in namespace std.

<queue>

Complete.

<random>

Partially complete.

<ratio>

Not implemented.

<regex>

Not implemented.

<set>

Partially complete. Enough functionality exists to be useful.

<sstream>

The old-style IOStreams library is in namespace std.

<stack>

Complete.

<stdexcept>

Mostly complete.

<streambuf>

The old-style IOStreams library is in namespace std.

<string>

Mostly complete, although there are no I/O operators.

Issue 892 notes that the following member functions are still missing:

int compare( const string & ) const;
int compare( size_t, size_t, const string & ) const; 
int compare( size_t, size_t, const string &, size_t, size_t ) const;
int compare( const char * ) const;
int compare( size_t, size_t, const char * ) const;
int compare( size_t, size_t, const char *, size_t ) const;

In addition, the iterator interfaces are not implemented:

template <class InputIterator>
string( InputIterator, InputIterator );

template <class InputIterator>
string &assign( InputIterator, InputIterator );

OWCPPLIB's std::string implementation is not a copy-on-write implementation. The OWSTL Design Documentation discuss the reasons for this in more detail.

String objects always have a capacity that is a power of two in size. When the capacity is increased (for example after a push_back that fills the current buffer) the size of the internal buffer is doubled. The smallest capacity used is eight.

OWCPPLIB's std::string do not bother to null terminate their internal buffers. When c_str is called, a null character is appended to the buffer at that time. At all times there will be space for a null character. Thus, c_str never causes a reallocation and never throws an exception.

<strstream>

The old-style IOStreams library is in namespace std.

<system_error>

Not implemented.

<thread>

Not implemented.

<tuple>

Not implemented.

<typeindex>

Not implemented.

<typeinfo>

Partially complete. Some features require compiler enhancements.

<type_traits>

Partially complete. Some features require compiler enhancements.

<unordered_map>

Not implemented.

<unordered_set>

Not implemented.

<utility>

Complete.

<valarray>

Not implemented.

<vector>

Partially complete. Enough functionality exists to be useful. Some member functions are known to not yet be exception safe.