This should be two overloaded functions rather than a single function.

Apparently extracting Boolean values was messed up...

If codecvt::do_in returns noconv there are no changes to the values in [to, to_limit).

Re-opening a file stream does not clear the state flags.

Implement the proposed resolution.

Padding issues.

An instance of ios_base::failure is constructed instead.

The return type is the previous state of synchronization.

These members functions are declared private and are thus inaccessible. Specifying the correct semantics of "copying stream state" was deemed too complicated.

This DR made many widespread changes to basic_istream and basic_ostream all of which have been implemented.

Make the policy consistent with that of formatted input, unformatted input, and formatted output.

And they do now. An editing glitch in the last item in the list of [27.6.1.2.3]/7.

The text of the standard was gibberish. Typos gone rampant.

Change the first parameter to stateT& and implement the new effects paragraph.

Safety checks on the size of the string should test against max_size() rather than npos.

The effect contain isspace(c,getloc()) which must be replaced by isspace(c,is.getloc()).

They behave as a formatted input function and as an unformatted input function, respectively (except that getline is not required to set gcount).

For associative containers where the value type is the same as the key type, both iterator and const_iterator are constant iterators.

The binder1st and binder2nd didn't have an operator() taking a non-const parameter.

This was not a const member function. Note that the DR says to replace the function with a const one; we have instead provided an overloaded version with identical contents.

num_put::put() was overloaded on the wrong types.

Same as 117, but for num_get::get().

These functions set failbit on error now.

Make member erase return iterator for set, multiset, map, multimap.

seekp should only set the output stream, and seekg should only set the input stream.

op<< with a const char* was calculating an incorrect number of characters to write.

Grow efficiently the internal array object.

Quite complex to summarize...

This function used to take its arguments as reference-to-const, now it copies them (pass by value).

Yes, it can, specifically if EOF is reached while skipping whitespace.

The nothrow forms of new and delete were changed to call the throwing forms, handling any exception by catching it and returning a null pointer.

If nothing is extracted into the string, op>> now sets failbit (which can cause an exception, etc., etc.).

Both set and multiset were missing overloaded find, lower_bound, upper_bound, and equal_range functions for const instances.

For conversion from a floating-point type, str.precision() is specified in the conversion specification.

Implement N1780, first check before then check after, insert as close to hint as possible.

The declaration of reverse_iterator lists a default constructor. However, no specification is given what this constructor should do.

Add a helper for forward_iterator/output_iterator, fix the existing one for input_iterator/output_iterator to not rely on Assignability.

Store a null character only if the character array has a non-zero size.

This nested typedef was originally not specified.

Make the copy constructor and copy-assignment operator declarations public in gslice_array, indirect_array, mask_array, slice_array; provide definitions.

The default ctor would build its members from copies of temporaries; now it simply uses their respective default ctors.

The bad_* classes no longer have destructors (they are trivial), since no description of them was ever given.

The typedefs it inherits from its base classes can't be used, since (for example) basic_iostream<T>::traits_type is ambiguous.

Similar to 118.

Add global functions with two template parameters. (NB: not added for now a templated assignment operator)

If (this == &rhs) do nothing.

If (this == &x) do nothing.

Basically, compare the input character to is.widen(0) and is.widen(1).

Do not specify what codecvt<wchar_t, char, mbstate_t>::do_length must return.

Change the format string to "%.0Lf".

Add const overloads of is_open.

Add the real(T) and imag(T) members; in C++11 mode, also adjust the existing real() and imag() members and free functions.

Change it to return a const T&.

Implement the proposed resolution.

Replace "new" with "::new".

Tweak the debug-mode checks in _Safe_iterator.

Have open clear the error flags.

Implement Option 3, as per N1599.

Implement the resolution, beyond DR 169.

Add three overloads, taking fewer template arguments.

Implement the resolution, basically cast less.

Change istreambuf_iterator::reference in C++11 mode.

Don't fail if the next pointer is null and newoff is zero.

Initialize cerr tied to cout and wcerr tied to wcout.

Add data() to std::vector and at(const key_type&) to std::map.

Change lt.

Fix the parameters.

Construct a linear_congruential engine and seed with it.

Use &value.

In case of input_iterator/output_iterator rely on Assignability of input_iterator' value_type.

We were almost doing the right thing, just use std::move in adjacent_difference.

Add an auto_ptr<void> specialization.

Follow the straightforward proposed resolution.

In C++11 mode, remove the pow(float,int), etc., signatures.

Change it to be a formatted output function (i.e. catch exceptions).

Add the missing modes to fopen_mode.

Implement the simple resolution.

Add the missing operations.

In C++11 mode add cbegin(size_type) and cend(size_type) to the unordered containers.

Add it, consistently with the discussion.

Make the member functions table and classic_table public.

Implement the straightforward resolution.

In C++11 mode, add at() and at() const.

Implement the int -> size_t replacements.

In C++11 mode, remove assign, add fill.

In C++11 mode, add std::proj.

Add the overload.

Update / add the signatures.

The traditional HP / SGI return type and value is blessed by the resolution of the DR.

Return the end of the filled range.

Correctly decay types in signature of std::async.

Handle non-object types.

Reorder enumerators.

Add additional overloads.

Add noexcept to swap functions.

Respect propagation trait for move assignment.

Add noexcept to the comparison operators.

Fix signatures.

Use the referenceable type concept.

Change the reference type.

Define and use is_always_equal even for C++11.

Adjust constraints to allow safe conversions.

Add assignment operator taking an rvalue.

Constrain the constructor to only accept callable types.

Use decay for the result type.

Add noexcept

Declare a public constexpr constructor.

Add noexcept.

Add emplace and emplace_back member functions.

Move all declarations to a common header and remove the generic abs which accepted unsigned arguments.

Use the referenceable type concept.

The tuple_size and tuple_element partial specializations are defined in <utility> which is included by <array>.

Use __builtin_addressof and add constexpr to addressof for C++17 and later.

Change typedef.

Update definitions of the partial specializations for const and volatile types.

Use perfect forwarding for right operand.

Add deleted overloads for rvalue strings.

Add deleted constructors.

Add overloads of insert taking value_type&& rvalues.

Constrain the constructor to require convertibility.

Use addressof.

Add noexcept to the assignment and comparisons.

Remove explicit from the constructor.

Create empty an shared_ptr from an empty unique_ptr.

Use mem_fn for member pointers.

Add noexcept.

Define the typedefs.

Remove indirection through call wrapper that made copies of arguments and forward arguments straight to std::invoke.

Add the base() member function.

Make noexcept specifications conditional.

Remove unused overloads.

Add debug mode assertion.

Divide by the object type.

Avoid using dynamic_cast when it would be ill-formed.

Add static assertions to enforce the requirement.

Call make_heap.

Add new constructor.

Change internal helper for uses-allocator construction to always check using const lvalue allocators.

Define the value_compare typedef.

Resolved by the changes for 2192.

Safely detect tuple_size<T>::value and only use it if valid.

Remove special handling for reference_wrapper arguments and store them directly as the target object.

Add noexcept.

Use rvalues for deleters.

Add noexcept.

Replaced the constructors with a constrained template, to prevent participation in overload resolution when not valid.

Change scalar operands to be non-deduced context, so that they will allow conversions from other types to the value_type.

Change constructors to constrained templates.

Implement the fix for trailing slashes.