C++ Library Status

The list below, organized by header file, gives more details about how much of the C++ library is currently available and what parts remain to be implemented relative to the 1998 standard (with additional information about C++ 2011 support where appropriate). It also contains a few implementation notes that may be of interest to some users. This list is intended to be a reference for OWCPPLIB users and serve as a TODO list for potential contributors.

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

<algorithm>

The following algorithms, shown in the order in which they appear in the C++ 2011 standard, are missing from algorithm and are currently unimplemented. This list is complete in the sense that all other algorithms as specified by the 2011 standard should be present. Algorithms that are specific to C++ 2011 are shown with a [2011] prefix.

Non-modifying Sequence Operations

[2011] is_permutation( Forward1, Forward1, Forward2 )
[2011] is_permutation( Forward1, Forward1, Forward2, Predicate )

Mutating Sequence Operations

[2011] copy_n( Input, Size, Output )
[2011] copy_if( Input, Input, Output, Predicate )
[2011] move( Input, Input, Output )
[2011] move_backward( Bidirectional1, Bidirectional1, Bidirectional2 )
       rotate( Forward, Forward, Forward )
       rotate_copy( Forward, Forward, Forward, Output )
       random_shuffle( RandomAccess, RandomAccess )
       random_shuffle( RandomAccess, RandomAccess, RandomNumberGenerator)
[2011] is_partitioned( Input, Input, Predicate )
       partition( Forward, Forward, Predicate )
       stable_partition( Bidirectional, Bidirectional, Predicate )
[2011] partition_copy( Input, Input, Output1, Output2, Predicate )
[2011] partition_point( Forward, Forward, 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 )
[2011] is_sorted( Forward, Forward )
[2011] is_sorted( Forward, Forward, Compare )
[2011] is_sorted_until( Forward, Forward )
[2011] is_sorted_until( Forward, Forward, 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 )
[2011] inplace_merge( Bidirectional, Bidirectional, Bidirectional )
[2011] inplace_merge( Bidirectional, Bidirectional, Bidirectional, 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 )
[2011] is_heap( RandomAccess, RandomAccess )
[2011] is_heap( RandomAccess, RandomAccess, Compare )
[2011] is_heap_until( RandomAccess, RandomAccess )
[2011] is_heap_until( RandomAccess, RandomAccess, Compare )
[2011] min( initializer_list )
[2011] min( initializer_list, Compare )
[2011] max( initializer_list )
[2011] max( initializer_list, Compare )
[2011] minmax( const T& )
[2011] minmax( const T&, Compare )
[2011] minmax( initializer_list )
[2011] minmax( initializer_list, Compare )
[2011] minmax_element( Forward, Forward )
[2011] minmax_element( Forward, Forward, 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 pivioting 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 of 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 many member functions are missing. The following methods 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 methods are missing:

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

<locale>

Not implemented.

<map>

Partially complete. Enough functionality exists to be useful. The following methods 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.

<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, all other member functions and string operations are available. OWCPPLIB's std::string implementation is not a copy-on-write implementation. The OWCPPLIB developer's documentation (part of the source distribution) 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.

<strstram>

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.