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.

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++0x 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.

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.

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++0x 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++0x 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++0x mode, add at() and at() const.

Implement the int -> size_t replacements.

In C++0x mode, remove assign, add fill.

In C++0x mode, add std::proj.

Add the overload.

In C++0x mode, remove the pow(complex<T>, int) signature.

Update / add the signatures.

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