Doc. no. D????
Date: 2024-11-04
Project: Programming Language C++
Reply to: Jonathan Wakely <lwgchair@gmail.com>

C++ Standard Library Closed Issues List (Revision D125)

Revised 2024-11-04 at 20:57:11 UTC

Reference ISO/IEC IS 14882:2020(E)

Also see:

This document contains only library issues which have been closed by the Library Working Group as duplicates or not defects. That is, issues which have a status of Dup or NAD. See the Library Defect Reports and Accepted Issues for issues considered defects. See the Library Active Issues List for active issues and more information. The introductory material in that document also applies to this document.

Revision History

Closed Issues


2(i). Auto_ptr conversions effects incorrect

Section: 99 [auto.ptr.conv] Status: NAD Submitter: Nathan Myers Opened: 1997-12-04 Last modified: 2016-08-09

Priority: Not Prioritized

View all other issues in [auto.ptr.conv].

View all issues with NAD status.

Discussion:

Paragraph 1 in "Effects", says "Calls p->release()" where it clearly must be "Calls p.release()". (As it is, it seems to require using auto_ptr<>::operator-> to refer to X::release, assuming that exists.)

Proposed resolution:

Change 21.3.5.4 [meta.unary.prop] paragraph 1 Effects from "Calls p->release()" to "Calls p.release()".

Rationale:

Not a defect: the proposed change is already found in the standard. [Originally classified as a defect, later reclassified.]


4(i). basic_string size_type and difference_type should be implementation defined

Section: 27.4.3 [basic.string] Status: NAD Submitter: Beman Dawes Opened: 1997-11-16 Last modified: 2016-08-09

Priority: Not Prioritized

View other active issues in [basic.string].

View all other issues in [basic.string].

View all issues with NAD status.

Discussion:

In Morristown we changed the size_type and difference_type typedefs for all the other containers to implementation defined with a reference to 23.2 [container.requirements]. This should probably also have been done for strings.

Rationale:

Not a defect. [Originally classified as a defect, later reclassified.] basic_string, unlike the other standard library template containers, is severely constrained by its use of char_traits. Those types are dictated by the traits class, and are far from implementation defined.


6(i). File position not an offset unimplementable

Section: 31.5.3 [fpos] Status: NAD Submitter: Matt Austern Opened: 1997-12-15 Last modified: 2016-08-09

Priority: Not Prioritized

View all other issues in [fpos].

View all issues with NAD status.

Discussion:

Table 88, in I/O, is too strict; it's unimplementable on systems where a file position isn't just an offset. It also never says just what fpos<> is really supposed to be. [Here's my summary, which Jerry agrees is more or less accurate. "I think I now know what the class really is, at this point: it's a magic cookie that encapsulates an mbstate_t and a file position (possibly represented as an fpos_t), it has syntactic support for pointer-like arithmetic, and implementors are required to have real, not just syntactic, support for arithmetic." This isn't standardese, of course.]

Rationale:

Not a defect. The LWG believes that the Standard is already clear, and that the above summary is what the Standard in effect says.


10(i). Codecvt<>::do unclear

Section: 28.3.4.2.6 [locale.codecvt.byname] Status: Dup Submitter: Matt Austern Opened: 1998-01-14 Last modified: 2016-08-09

Priority: Not Prioritized

View all other issues in [locale.codecvt.byname].

View all issues with Dup status.

Duplicate of: 19

Discussion:

Section 22.2.1.5.2 says that codecvt<>::do_in and do_out should return the value noconv if "no conversion was needed". However, I don't see anything anywhere that defines what it means for a conversion to be needed or not needed. I can think of several circumstances where one might plausibly think that a conversion is not "needed", but I don't know which one is intended here.

Rationale:


12(i). Way objects hold allocators unclear

Section: 16.4.4.6 [allocator.requirements] Status: NAD Submitter: Angelika Langer Opened: 1998-02-23 Last modified: 2016-08-09

Priority: Not Prioritized

View other active issues in [allocator.requirements].

View all other issues in [allocator.requirements].

View all issues with NAD status.

Discussion:

I couldn't find a statement in the standard saying whether the allocator object held by a container is held as a copy of the constructor argument or whether a pointer of reference is maintained internal. There is an according statement for compare objects and how they are maintained by the associative containers, but I couldn't find anything regarding allocators.

Did I overlook it? Is it an open issue or known defect? Or is it deliberately left unspecified?

Rationale:

Not a defect. The LWG believes that the Standard is already clear.  See 23.2 [container.requirements], paragraph 8.


43(i). Locale table correction

Section: 28.3.4.2.6 [locale.codecvt.byname] Status: Dup Submitter: Brendan Kehoe Opened: 1998-06-01 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.codecvt.byname].

View all issues with Dup status.

Duplicate of: 33

Discussion:

Rationale:


45(i). Stringstreams read/write pointers initial position unclear

Section: 31.8.4 [ostringstream] Status: NAD Submitter: Matthias Mueller Opened: 1998-05-27 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [ostringstream].

View all issues with NAD status.

Discussion:

In a comp.lang.c++.moderated Matthias Mueller wrote:

"We are not sure how to interpret the CD2 (see 31.3 [iostream.forward], 31.8.4.2 [ostringstream.cons], 31.8.2.2 [stringbuf.cons]) with respect to the question as to what the correct initial positions of the write and  read pointers of a stringstream should be."

"Is it the same to output two strings or to initialize the stringstream with the first and to output the second?"

[PJ Plauger, Bjarne Stroustrup, Randy Smithey, Sean Corfield, and Jerry Schwarz have all offered opinions; see reflector messages lib-6518, 6519, 6520, 6521, 6523, 6524.]

Rationale:

The LWG believes the Standard is correct as written. The behavior of stringstreams is consistent with fstreams, and there is a constructor which can be used to obtain the desired effect. This behavior is known to be different from strstreams.


58(i). Extracting a char from a wide-oriented stream

Section: 31.7.5.3.3 [istream.extractors] Status: NAD Submitter: Matt Austern Opened: 1998-07-01 Last modified: 2017-04-22

Priority: Not Prioritized

View all other issues in [istream.extractors].

View all issues with NAD status.

Discussion:

27.6.1.2.3 has member functions for extraction of signed char and unsigned char, both singly and as strings. However, it doesn't say what it means to extract a char from a basic_streambuf<charT, Traits>.

basic_streambuf, after all, has no members to extract a char, so basic_istream must somehow convert from charT to signed char or unsigned char. The standard doesn't say how it is to perform that conversion.

Rationale:

The Standard is correct as written. There is no such extractor and this is the intent of the LWG.


65(i). Underspecification of strstreambuf::seekoff

Section: 99 [depr.strstreambuf.virtuals] Status: NAD Submitter: Matt Austern Opened: 1998-08-18 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [depr.strstreambuf.virtuals].

View all issues with NAD status.

Discussion:

The standard says how this member function affects the current stream position. (gptr or pptr) However, it does not say how this member function affects the beginning and end of the get/put area.

This is an issue when seekoff is used to position the get pointer beyond the end of the current read area. (Which is legal. This is implicit in the definition of seekhigh in D.7.1, paragraph 4.)

Rationale:

The LWG agrees that seekoff() is underspecified, but does not wish to invest effort in this deprecated feature.


67(i). Setw useless for strings

Section: 27.4.4.4 [string.io] Status: Dup Submitter: Steve Clamage Opened: 1998-07-09 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [string.io].

View all issues with Dup status.

Duplicate of: 25

Discussion:

In a comp.std.c++ posting Michel Michaud wrote: What should be output by:

   string text("Hello");
   cout << '[' << setw(10) << right << text << ']';

Shouldn't it be:

   [     Hello]

Another person replied: Actually, according to the FDIS, the width of the field should be the minimum of width and the length of the string, so the output shouldn't have any padding. I think that this is a typo, however, and that what is wanted is the maximum of the two. (As written, setw is useless for strings. If that had been the intent, one wouldn't expect them to have mentioned using its value.)

It's worth pointing out that this is a recent correction anyway; IIRC, earlier versions of the draft forgot to mention formatting parameters whatsoever.

Rationale:


72(i). Do_convert phantom member function

Section: 28.3.4.2.5 [locale.codecvt] Status: Dup Submitter: Nathan Myers Opened: 1998-08-24 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.codecvt].

View all issues with Dup status.

Duplicate of: 24

Discussion:

In 28.3.4.2.5 [locale.codecvt] par 3, and in 28.3.4.2.5.3 [locale.codecvt.virtuals] par 8, a nonexistent member function "do_convert" is mentioned. This member was replaced with "do_in" and "do_out", the proper referents in the contexts above.

Rationale:


73(i). is_open should be const

Section: 31.10 [file.streams] Status: NAD Submitter: Matt Austern Opened: 1998-08-27 Last modified: 2017-06-15

Priority: Not Prioritized

View all other issues in [file.streams].

View all issues with NAD status.

Discussion:

Classes basic_ifstream, basic_ofstream, and basic_fstream all have a member function is_open. It should be a const member function, since it does nothing but call one of basic_filebuf's const member functions.

Rationale:

Not a defect. This is a deliberate feature; const streams would be meaningless.


77(i). Valarray operator[] const returning value

Section: 29.6.2.4 [valarray.access] Status: Dup Submitter: Levente Farkas Opened: 1998-09-09 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [valarray.access].

View all issues with Dup status.

Duplicate of: 389

Discussion:

valarray:

    T operator[] (size_t) const;

why not

    const T& operator[] (size_t) const;

as in vector ???

One can't copy even from a const valarray eg:

    memcpy(ptr, &v[0], v.size() * sizeof(double));

[I] find this bug in valarray is very difficult.

Rationale:

The LWG believes that the interface was deliberately designed that way. That is what valarray was designed to do; that's where the "value array" name comes from. LWG members further comment that "we don't want valarray to be a full STL container." 29.6.2.4 [valarray.access] specifies properties that indicate "an absence of aliasing" for non-constant arrays; this allows optimizations, including special hardware optimizations, that are not otherwise possible.


81(i). Wrong declaration of slice operations

Section: 29.6.5 [template.slice.array], 29.6.7 [template.gslice.array], 29.6.8 [template.mask.array], 29.6.9 [template.indirect.array] Status: NAD Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [template.slice.array].

View all issues with NAD status.

Discussion:

Isn't the definition of copy constructor and assignment operators wrong?        Instead of

      slice_array(const slice_array&); 
      slice_array& operator=(const slice_array&);

IMHO they have to be

      slice_array(const slice_array<T>&); 
      slice_array& operator=(const slice_array<T>&);

Same for gslice_array.

Rationale:

Not a defect. The Standard is correct as written.


82(i). Missing constant for set elements

Section: 23.2.7 [associative.reqmts] Status: NAD Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [associative.reqmts].

View all other issues in [associative.reqmts].

View all issues with NAD status.

Discussion:

Paragraph 5 specifies:

For set and multiset the value type is the same as the key type. For map and multimap it is equal to pair<const Key, T>.

Strictly speaking, this is not correct because for set and multiset the value type is the same as the constant key type.

Rationale:

Not a defect. The Standard is correct as written; it uses a different mechanism (const &) for set and multiset. See issue 103(i) for a related issue.


84(i). Ambiguity with string::insert()

Section: 27.4.3.6 [string.access] Status: NAD Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [string.access].

View all issues with NAD status.

Discussion:

If I try

    s.insert(0,1,' ');

  I get an nasty ambiguity. It might be

    s.insert((size_type)0,(size_type)1,(charT)' ');

which inserts 1 space character at position 0, or

    s.insert((char*)0,(size_type)1,(charT)' ')

which inserts 1 space character at iterator/address 0 (bingo!), or

    s.insert((char*)0, (InputIterator)1, (InputIterator)' ')

which normally inserts characters from iterator 1 to iterator ' '. But according to 23.1.1.9 (the "do the right thing" fix) it is equivalent to the second. However, it is still ambiguous, because of course I mean the first!

Rationale:

Not a defect. The LWG believes this is a "genetic misfortune" inherent in the design of string and thus not a defect in the Standard as such .


85(i). String char types

Section: 27 [strings] Status: NAD Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [strings].

View all issues with NAD status.

Discussion:

The standard seems not to require that charT is equivalent to traits::char_type. So, what happens if charT is not equivalent to traits::char_type?

Rationale:

There is already wording in 27.2 [char.traits] paragraph 3 that requires them to be the same.


87(i). Error in description of string::compare()

Section: 27.4.3.7.8 [string.swap] Status: Dup Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2016-11-12

Priority: Not Prioritized

View all other issues in [string.swap].

View all issues with Dup status.

Duplicate of: 5

Discussion:

The following compare() description is obviously a bug:

int compare(size_type pos, size_type n1, 
            charT *s, size_type n2 = npos) const;

because without passing n2 it should compare up to the end of the string instead of comparing npos characters (which throws an exception)

Rationale:


88(i). Inconsistency between string::insert() and string::append()

Section: 27.4.3.7.4 [string.insert], 27.4.3.7.2 [string.append] Status: NAD Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2016-11-12

Priority: Not Prioritized

View all other issues in [string.insert].

View all issues with NAD status.

Discussion:

Why does

  template<class InputIterator> 
       basic_string& append(InputIterator first, InputIterator last);

return a string, while

  template<class InputIterator> 
       void insert(iterator p, InputIterator first, InputIterator last);

returns nothing ?

Rationale:

The LWG believes this stylistic inconsistency is not sufficiently serious to constitute a defect.


89(i). Missing throw specification for string::insert() and string::replace()

Section: 27.4.3.7.4 [string.insert], 27.4.3.7.6 [string.replace] Status: Dup Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2016-11-12

Priority: Not Prioritized

View all other issues in [string.insert].

View all issues with Dup status.

Duplicate of: 83

Discussion:

All insert() and replace() members for strings with an iterator as first argument lack a throw specification. The throw specification should probably be: length_error if size exceeds maximum.

Rationale:

Considered a duplicate because it will be solved by the resolution of issue 83(i).


93(i). Incomplete Valarray Subset Definitions

Section: 29.6 [numarray] Status: NAD Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [numarray].

View all issues with NAD status.

Discussion:

You can easily create subsets, but you can't easily combine them with other subsets. Unfortunately, you almost always needs an explicit type conversion to valarray. This is because the standard does not specify that valarray subsets provide the same operations as valarrays.

For example, to multiply two subsets and assign the result to a third subset, you can't write the following:

va[slice(0,4,3)] = va[slice(1,4,3)] * va[slice(2,4,3)];

Instead, you have to code as follows:

va[slice(0,4,3)] = static_cast<valarray<double> >(va[slice(1,4,3)]) * 
                   static_cast<valarray<double> >(va[slice(2,4,3)]);

This is tedious and error-prone. Even worse, it costs performance because each cast creates a temporary objects, which could be avoided without the cast.

Proposed resolution:

Extend all valarray subset types so that they offer all valarray operations.

Rationale:

This is not a defect in the Standard; it is a request for an extension.


94(i). May library implementors add template parameters to Standard Library classes?

Section: 16.4.6 [conforming] Status: NAD Submitter: Matt Austern Opened: 1998-01-22 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [conforming].

View all issues with NAD status.

Discussion:

Is it a permitted extension for library implementors to add template parameters to standard library classes, provided that those extra parameters have defaults? For example, instead of defining template <class T, class Alloc = allocator<T> > class vector; defining it as template <class T, class Alloc = allocator<T>, int N = 1> class vector;

The standard may well already allow this (I can't think of any way that this extension could break a conforming program, considering that users are not permitted to forward-declare standard library components), but it ought to be explicitly permitted or forbidden.

comment from Steve Cleary via comp.std.c++:

I disagree [with the proposed resolution] for the following reason: consider user library code with template template parameters. For example, a user library object may be templated on the type of underlying sequence storage to use (deque/list/vector), since these classes all take the same number and type of template parameters; this would allow the user to determine the performance tradeoffs of the user library object. A similar example is a user library object templated on the type of underlying set storage (set/multiset) or map storage (map/multimap), which would allow users to change (within reason) the semantic meanings of operations on that object.

I think that additional template parameters should be forbidden in the Standard classes. Library writers don't lose any expressive power, and can still offer extensions because additional template parameters may be provided by a non-Standard implementation class:

 
   template <class T, class Allocator = allocator<T>, int N = 1>
   class __vector
   { ... };
   template <class T, class Allocator = allocator<T> >
   class vector: public __vector<T, Allocator>
   { ... };

Proposed resolution:

Add a new subclause [presumably 17.4.4.9] following 16.4.6.13 [res.on.exception.handling]:

17.4.4.9 Template Parameters

A specialization of a template class described in the C++ Standard Library behaves the same as if the implementation declares no additional template parameters.

Footnote: Additional template parameters with default values are thus permitted.

Add "template parameters" to the list of subclauses at the end of 16.4.6 [conforming] paragraph 1.

[Kona: The LWG agreed the standard needs clarification. After discussion with John Spicer, it seems added template parameters can be detected by a program using template-template parameters. A straw vote - "should implementors be allowed to add template parameters?" found no consensus ; 5 - yes, 7 - no.]

Rationale:

There is no ambiguity; the standard is clear as written. Library implementors are not permitted to add template parameters to standard library classes. This does not fall under the "as if" rule, so it would be permitted only if the standard gave explicit license for implementors to do this. This would require a change in the standard.

The LWG decided against making this change, because it would break user code involving template template parameters or specializations of standard library class templates.


95(i). Members added by the implementation

Section: 16.4.6.5 [member.functions] Status: NAD Submitter: AFNOR Opened: 1998-10-07 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [member.functions].

View all issues with NAD status.

Discussion:

In 17.3.4.4/2 vs 17.3.4.7/0 there is a hole; an implementation could add virtual members a base class and break user derived classes.

Example:

// implementation code:
struct _Base { // _Base is in the implementer namespace
        virtual void foo ();
};
class vector : _Base // deriving from a class is allowed
{ ... };

// user code:
class vector_checking : public vector 
{
        void foo (); // don't want to override _Base::foo () as the 
                     // user doesn't know about _Base::foo ()
};

Proposed resolution:

Clarify the wording to make the example illegal.

Rationale:

This is not a defect in the Standard.  The example is already illegal.  See 16.4.6.5 [member.functions] paragraph 2.


96(i). Vector<bool> is not a container

Section: 23.3.11 [vector] Status: NAD Submitter: AFNOR Opened: 1998-10-07 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [vector].

View all issues with NAD status.

Discussion:

vector<bool> is not a container as its reference and pointer types are not references and pointers.

Also it forces everyone to have a space optimization instead of a speed one.

See also: 99-0008 == N1185 Vector<bool> is Nonconforming, Forces Optimization Choice.

[In Santa Cruz the LWG felt that this was Not A Defect.]

[In Dublin many present felt that failure to meet Container requirements was a defect. There was disagreement as to whether or not the optimization requirements constituted a defect.]

[The LWG looked at the following resolutions in some detail:
     * Not A Defect.
     * Add a note explaining that vector<bool> does not meet Container requirements.
     * Remove vector<bool>.
     * Add a new category of container requirements which vector<bool> would meet.
     * Rename vector<bool>.

No alternative had strong, wide-spread, support and every alternative had at least one "over my dead body" response.

There was also mention of a transition scheme something like (1) add vector_bool and deprecate vector<bool> in the next standard. (2) Remove vector<bool> in the following standard.]

[Modifying container requirements to permit returning proxies (thus allowing container requirements conforming vector<bool>) was also discussed.]

[It was also noted that there is a partial but ugly workaround in that vector<bool> may be further specialized with a customer allocator.]

[Kona: Herb Sutter presented his paper J16/99-0035==WG21/N1211, vector<bool>: More Problems, Better Solutions. Much discussion of a two step approach: a) deprecate, b) provide replacement under a new name. LWG straw vote on that: 1-favor, 11-could live with, 2-over my dead body. This resolution was mentioned in the LWG report to the full committee, where several additional committee members indicated over-my-dead-body positions.]

Discussed at Lillehammer. General agreement that we should deprecate vector<bool> and introduce this functionality under a different name, e.g. bit_vector. This might make it possible to remove the vector<bool> specialization in the standard that comes after C++0x. There was also a suggestion that in C++0x we could additional say that it's implementation defined whether vector<bool> refers to the specialization or to the primary template, but there wasn't general agreement that this was a good idea.

We need a paper for the new bit_vector class.

[ Batavia: ]

The LWG feels we need something closer to SGI's bitvector to ease migration from vector<bool>. Although some of the funcitonality from N2050 could well be used in such a template. The concern is easing the API migration for those users who want to continue using a bit-packed container. Alan and Beman to work.

[ Post Summit Alisdair adds: ]

vector<bool> is now a conforming container under the revised terms of C++0x, which supports containers of proxies.

Recommend NAD.

Two issues remain:

i/ premature optimization in the specification. There is still some sentiment that deprecation is the correct way to go, although it is still not clear what it would mean to deprecate a single specialization of a template.

Recommend: Create a new issue for the discussion, leave as Open.

ii/ Request for a new bitvector class to guarantee the optimization, perhaps with a better tuned interface.

This is a clear extension request that may be handled via a future TR.

[ Batavia (2009-05): ]

We note that most of this issue has become moot over time, and agree with Alisdair's recommendations. Move to NAD Future for reconsideration of part (ii).

[ 2009-07-29 Alisdair reopens: ]

This infamous issue was closed as NAD Future when concepts introduced support for proxy iterators, so the only remaining requirement was to provide a better type to support bitsets of dynamic length. I fear we must re-open this issue until the post-concept form of iterators is available, and hopefully will support the necessary proxy functionality to allow us to close this issue as NAD.

I recommend we spawn a separate issue (1184(i)) requesting a dynamic length bitset and pre-emptively file it as NAD Future. It is difficult to resolve #96 when it effectively contains two separate sub-issues.

[ 2009-10 Santa Cruz: ]

Mark as NAD, and give rationale.

Proposed resolution:

We now have: N2050 and N2160.

Rationale:

We want to support proxy iterators but that is going to be separate work. Don't want to see this issue come back in these kinds of terms. We're interested in a separate container, and proxy iterators, but both of those are separate issues.

We've looked at a lot of ways to fix this that would be close to this, but those things would break existing code. Attempts to fix this directly have not been tractable, and removing it has not been tractable. Therefore we are closing.


97(i). Insert inconsistent definition

Section: 23 [containers] Status: NAD Submitter: AFNOR Opened: 1998-10-07 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [containers].

View all other issues in [containers].

View all issues with NAD status.

Discussion:

insert(iterator, const value_type&) is defined both on sequences and on set, with unrelated semantics: insert here (in sequences), and insert with hint (in associative containers). They should have different names (B.S. says: do not abuse overloading).

Rationale:

This is not a defect in the Standard. It is a genetic misfortune of the design, for better or for worse.


99(i). Reverse_iterator comparisons completely wrong

Section: 24.5.1.8 [reverse.iter.cmp] Status: NAD Submitter: AFNOR Opened: 1998-10-07 Last modified: 2021-06-06

Priority: Not Prioritized

View all issues with NAD status.

Discussion:

The <, >, <=, >= comparison operator are wrong: they return the opposite of what they should.

Note: same problem in CD2, these were not even defined in CD1. SGI STL code is correct; this problem is known since the Morristown meeting but there it was too late

Rationale:

This is not a defect in the Standard. A careful reading shows the Standard is correct as written. A review of several implementations show that they implement exactly what the Standard says.


100(i). Insert iterators/ostream_iterators overconstrained

Section: 24.5.2 [insert.iterators], 24.6.5 [ostreambuf.iterator] Status: NAD Submitter: AFNOR Opened: 1998-10-07 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [insert.iterators].

View all issues with NAD status.

Discussion:

Overspecified For an insert iterator it, the expression *it is required to return a reference to it. This is a simple possible implementation, but as the SGI STL documentation says, not the only one, and the user should not assume that this is the case.

Rationale:

The LWG believes this causes no harm and is not a defect in the standard. The only example anyone could come up with caused some incorrect code to work, rather than the other way around.


101(i). No way to free storage for vector and deque

Section: 23.3.11 [vector], 23.3.3 [array] Status: NAD Editorial Submitter: AFNOR Opened: 1998-10-07 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [vector].

View all issues with NAD Editorial status.

Discussion:

Reserve can not free storage, unlike string::reserve

[ 2010-02-13 Alisdair adds: ]

This issue has been revisited and addressed (755(i), 850(i)). This issues should be reclassified to NAD Editorial to reflect this action.

Rationale:

This is not a defect in the Standard. The LWG has considered this issue in the past and sees no need to change the Standard. Deque has no reserve() member function. For vector, shrink-to-fit can be expressed in a single line of code (where v is vector<T>):

vector<T>(v).swap(v);  // shrink-to-fit v


102(i). Bug in insert range in associative containers

Section: 23.2.7 [associative.reqmts] Status: Dup Submitter: AFNOR Opened: 1998-10-07 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [associative.reqmts].

View all other issues in [associative.reqmts].

View all issues with Dup status.

Duplicate of: 264

Discussion:

Table 69 of Containers say that a.insert(i,j) is linear if [i, j) is ordered. It seems impossible to implement, as it means that if [i, j) = [x], insert in an associative container is O(1)!

Proposed resolution:

N+log (size()) if [i,j) is sorted according to value_comp()

Rationale:

Subsumed by issue 264(i).


104(i). Description of basic_string::operator[] is unclear

Section: 27.4.3.5 [string.capacity] Status: NAD Submitter: AFNOR Opened: 1998-10-07 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [string.capacity].

View all issues with NAD status.

Discussion:

It is not clear that undefined behavior applies when pos == size () for the non const version.

Proposed resolution:

Rewrite as: Otherwise, if pos > size () or pos == size () and the non-const version is used, then the behavior is undefined.

Rationale:

The Standard is correct. The proposed resolution already appears in the Standard.


105(i). fstream ctors argument types desired

Section: 31.10 [file.streams] Status: Dup Submitter: AFNOR Opened: 1998-10-07 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [file.streams].

View all issues with Dup status.

Duplicate of: 454

Discussion:

fstream ctors take a const char* instead of string.
fstream ctors can't take wchar_t

An extension to add a const wchar_t* to fstream would make the implementation non conforming.

Rationale:

This is not a defect in the Standard. It might be an interesting extension for the next Standard.


107(i). Valarray constructor is strange

Section: 29.6.2 [template.valarray] Status: NAD Submitter: AFNOR Opened: 1998-10-07 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [template.valarray].

View all issues with NAD status.

Discussion:

The order of the arguments is (elem, size) instead of the normal (size, elem) in the rest of the library. Since elem often has an integral or floating point type, both types are convertible to each other and reversing them leads to a well formed program.

Proposed resolution:

Inverting the arguments could silently break programs. Introduce the two signatures (const T&, size_t) and (size_t, const T&), but make the one we do not want private so errors result in a diagnosed access violation. This technique can also be applied to STL containers.

Rationale:

The LWG believes that while the order of arguments is unfortunate, it does not constitute a defect in the standard. The LWG believes that the proposed solution will not work for valarray<size_t> and perhaps other cases.


111(i). istreambuf_iterator::equal overspecified, inefficient

Section: 24.6.4.4 [istreambuf.iterator.ops] Status: NAD Submitter: Nathan Myers Opened: 1998-10-15 Last modified: 2017-11-29

Priority: Not Prioritized

View all other issues in [istreambuf.iterator.ops].

View all issues with NAD status.

Discussion:

The member istreambuf_iterator<>::equal is specified to be unnecessarily inefficient. While this does not affect the efficiency of conforming implementations of iostreams, because they can "reach into" the iterators and bypass this function, it does affect users who use istreambuf_iterators.

The inefficiency results from a too-scrupulous definition, which requires a "true" result if neither iterator is at eof. In practice these iterators can only usefully be compared with the "eof" value, so the extra test implied provides no benefit, but slows down users' code.

The solution is to weaken the requirement on the function to return true only if both iterators are at eof.

[ Summit: ]

Reopened by Alisdair.

[ Post Summit Daniel adds: ]

Recommend NAD. The proposed wording would violate the axioms of concept requirement EqualityComparable axioms as part of concept InputIterator and more specifically it would violate the explicit wording of 24.3.5.3 [input.iterators]/7:

If two iterators a and b of the same type are equal, then either a and b are both dereferenceable or else neither is dereferenceable.

[ 2009-07 Frankfurt ]

Agree NAD.

Proposed resolution:

Replace [istreambuf.iterator::equal], paragraph 1,

-1- Returns: true if and only if both iterators are at end-of-stream, or neither is at end-of-stream, regardless of what streambuf object they use.

with

-1- Returns: true if and only if both iterators are at end-of-stream, regardless of what streambuf object they use.

Rationale:

It is not clear that this is a genuine defect. Additionally, the LWG was reluctant to make a change that would result in operator== not being a equivalence relation. One consequence of this change is that an algorithm that's passed the range [i, i) would no longer treat it as an empty range.


113(i). Missing/extra iostream sync semantics

Section: 31.7.5.2 [istream], 31.7.5.4 [istream.unformatted] Status: NAD Submitter: Steve Clamage Opened: 1998-10-13 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [istream].

View all issues with NAD status.

Discussion:

In 27.6.1.1, class basic_istream has a member function sync, described in 27.6.1.3, paragraph 36.

Following the chain of definitions, I find that the various sync functions have defined semantics for output streams, but no semantics for input streams. On the other hand, basic_ostream has no sync function.

The sync function should at minimum be added to basic_ostream, for internal consistency.

A larger question is whether sync should have assigned semantics for input streams.

Classic iostreams said streambuf::sync flushes pending output and attempts to return unread input characters to the source. It is a protected member function. The filebuf version (which is public) has that behavior (it backs up the read pointer). Class strstreambuf does not override streambuf::sync, and so sync can't be called on a strstream.

If we can add corresponding semantics to the various sync functions, we should. If not, we should remove sync from basic_istream.

Rationale:

A sync function is not needed in basic_ostream because the flush function provides the desired functionality.

As for the other points, the LWG finds the standard correct as written.


116(i). bitset cannot be constructed with a const char*

Section: 22.9.2 [template.bitset] Status: Dup Submitter: Judy Ward Opened: 1998-11-06 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [template.bitset].

View all issues with Dup status.

Duplicate of: 778

Discussion:

The following code does not compile with the EDG compiler:

#include <bitset>
using namespace std;
bitset<32> b("111111111");

If you cast the ctor argument to a string, i.e.:

bitset<32> b(string("111111111"));

then it will compile. The reason is that bitset has the following templatized constructor:

template <class charT, class traits, class Allocator>
explicit bitset (const basic_string<charT, traits, Allocator>& str, ...);

According to the compiler vendor, Steve Adamcyk at EDG, the user cannot pass this template constructor a const char* and expect a conversion to basic_string. The reason is "When you have a template constructor, it can get used in contexts where type deduction can be done. Type deduction basically comes up with exact matches, not ones involving conversions."

I don't think the intention when this constructor became templatized was for construction from a const char* to no longer work.

Proposed resolution:

Add to 22.9.2 [template.bitset] a bitset constructor declaration

explicit bitset(const char*);

and in Section 22.9.2.2 [bitset.cons] add:

explicit bitset(const char* str);

Effects:
    Calls bitset((string) str, 0, string::npos);

Rationale:

Although the problem is real, the standard is designed that way so it is not a defect. Education is the immediate workaround. A future standard may wish to consider the Proposed Resolution as an extension.


121(i). Detailed definition for ctype<wchar_t> specialization

Section: 28.3.3.1.2.1 [locale.category] Status: NAD Submitter: Judy Ward Opened: 1998-12-15 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.category].

View all issues with NAD status.

Discussion:

Section 22.1.1.1.1 has the following listed in Table 51: ctype<char> , ctype<wchar_t>.

Also Section 28.3.4.2.2 [locale.ctype] says:

The instantiations required in Table 51 (22.1.1.1.1) namely ctype<char> and ctype<wchar_t> , implement character classing appropriate to the implementation's native character set.

However, Section 28.3.4.2.4 [facet.ctype.special] only has a detailed description of the ctype<char> specialization, not the ctype<wchar_t> specialization.

Proposed resolution:

Add the ctype<wchar_t> detailed class description to Section 28.3.4.2.4 [facet.ctype.special].

Rationale:

Specialization for wchar_t is not needed since the default is acceptable.


128(i). Need open_mode() function for file stream, string streams, file buffers, and string  buffers

Section: 31.8 [string.streams], 31.10 [file.streams] Status: NAD Submitter: Angelika Langer Opened: 1999-02-22 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [string.streams].

View all issues with NAD status.

Discussion:

The following question came from Thorsten Herlemann:

You can set a mode when constructing or opening a file-stream or filebuf, e.g. ios::in, ios::out, ios::binary, ... But how can I get that mode later on, e.g. in my own operator << or operator >> or when I want to check whether a file-stream or file-buffer object passed as parameter is opened for input or output or binary? Is there no possibility? Is this a design-error in the standard C++ library?

It is indeed impossible to find out what a stream's or stream buffer's open mode is, and without that knowledge you don't know how certain operations behave. Just think of the append mode.

Both streams and stream buffers should have a mode() function that returns the current open mode setting.

[ post Bellevue: Alisdair requested to re-Open. ]

[ 2009-07 Frankfurt ]

Neither Howard nor Bill has received a customer request for this.

No consensus for change. The programmer can save this information to the side.

Moved to NAD.

Proposed resolution:

For stream buffers, add a function to the base class as a non-virtual function qualified as const to 31.6.3 [streambuf]:

    openmode mode() const;

    Returns the current open mode.

With streams, I'm not sure what to suggest. In principle, the mode could already be returned by ios_base, but the mode is only initialized for file and string stream objects, unless I'm overlooking anything. For this reason it should be added to the most derived stream classes. Alternatively, it could be added to basic_ios and would be default initialized in basic_ios<>::init().

Rationale:

This might be an interesting extension for some future, but it is not a defect in the current standard. The Proposed Resolution is retained for future reference.


131(i). list::splice throws nothing

Section: 23.3.9.5 [list.ops] Status: NAD Submitter: Howard Hinnant Opened: 1999-03-06 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [list.ops].

View all issues with NAD status.

Discussion:

What happens if a splice operation causes the size() of a list to grow beyond max_size()?

Rationale:

Size() cannot grow beyond max_size(). 


135(i). basic_iostream doubly initialized

Section: 31.7.5.7.2 [iostream.cons] Status: NAD Submitter: Howard Hinnant Opened: 1999-03-06 Last modified: 2016-01-28

Priority: Not Prioritized

View all issues with NAD status.

Discussion:

-1- Effects Constructs an object of class basic_iostream, assigning initial values to the base classes by calling basic_istream<charT,traits>(sb) (lib.istream) and basic_ostream<charT,traits>(sb) (lib.ostream)

The called for basic_istream and basic_ostream constructors call init(sb). This means that the basic_iostream's virtual base class is initialized twice.

Proposed resolution:

Change 27.6.1.5.1, paragraph 1 to:

-1- Effects Constructs an object of class basic_iostream, assigning initial values to the base classes by calling basic_istream<charT,traits>(sb) (lib.istream).

Rationale:

The LWG agreed that the init() function is called twice, but said that this is harmless and so not a defect in the standard.


138(i). Class ctype_byname<char> redundant and misleading

Section: 28.3.4.2.5 [locale.codecvt] Status: NAD Submitter: Angelika Langer Opened: 1999-03-18 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.codecvt].

View all issues with NAD status.

Discussion:

Section 28.3.4.2.5 [locale.codecvt] specifies that ctype_byname<char> must be a specialization of the ctype_byname template.

It is common practice in the standard that specializations of class templates are only mentioned where the interface of the specialization deviates from the interface of the template that it is a specialization of. Otherwise, the fact whether or not a required instantiation is an actual instantiation or a specialization is left open as an implementation detail.

Clause 22.2.1.4 deviates from that practice and for that reason is misleading. The fact, that ctype_byname<char> is specified as a specialization suggests that there must be something "special" about it, but it has the exact same interface as the ctype_byname template. Clause 22.2.1.4 does not have any explanatory value, is at best redundant, at worst misleading - unless I am missing anything.

Naturally, an implementation will most likely implement ctype_byname<char> as a specialization, because the base class ctype<char> is a specialization with an interface different from the ctype template, but that's an implementation detail and need not be mentioned in the standard.

[ Summit: ]

Reopened by Alisdair.

[ 2009-07 Frankfurt ]

Moved to NAD.

Rationale:

The standard as written is mildly misleading, but the correct fix is to deal with the underlying problem in the ctype_byname base class, not in the specialization. See issue 228(i).


140(i). map<Key, T>::value_type does not satisfy the assignable requirement

Section: 23.4.3 [map] Status: NAD Editorial Submitter: Mark Mitchell Opened: 1999-04-14 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [map].

View all issues with NAD Editorial status.

Discussion:

23.2 [container.requirements]

expression         return type      pre/post-condition
-------------     -----------      -------------------
X::value_type    T                    T is assignable

23.4.3 [map]

A map satisfies all the requirements of a container.

For a map<Key, T> ... the value_type is pair<const Key, T>.

There's a contradiction here. In particular, `pair<const Key, T>' is not assignable; the `const Key' cannot be assigned to. So,  map<Key, T>::value_type does not satisfy the assignable requirement imposed by a container.

[See issue 103(i) for the slightly related issue of modification of set keys.]

Rationale:

The LWG believes that the standard is inconsistent, but that this is a design problem rather than a strict defect. May wish to reconsider for the next standard.


143(i). C .h header wording unclear

Section: 17.14 [support.c.headers] Status: NAD Submitter: Christophe de Dinechin Opened: 1999-05-04 Last modified: 2023-02-07

Priority: Not Prioritized

View all other issues in [support.c.headers].

View all issues with NAD status.

Discussion:

[depr.c.headers] paragraph 2 reads:

Each C header, whose name has the form name.h, behaves as if each name placed in the Standard library namespace by the corresponding cname header is also placed within the namespace scope of the namespace std and is followed by an explicit using-declaration (_namespace.udecl_)

I think it should mention the global name space somewhere...  Currently, it indicates that name placed in std is also placed in std...

I don't know what is the correct wording. For instance, if struct tm is defined in time.h, ctime declares std::tm. However, the current wording seems ambiguous regarding which of the following would occur for use of both ctime and time.h:

// version 1:
namespace std {
        struct tm { ... };
}
using std::tm;

// version 2:
struct tm { ... };
namespace std {
        using ::tm;
}

// version 3:
struct tm { ... };
namespace std {
        struct tm { ... };
}

I think version 1 is intended.

[Kona: The LWG agreed that the wording is not clear. It also agreed that version 1 is intended, version 2 is not equivalent to version 1, and version 3 is clearly not intended. The example below was constructed by Nathan Myers to illustrate why version 2 is not equivalent to version 1.

Although not equivalent, the LWG is unsure if (2) is enough of a problem to be prohibited. Points discussed in favor of allowing (2):

]

Example:

#include <time.h>
#include <utility>

int main() {
    std::tm * t;
    make_pair( t, t ); // okay with version 1 due to Koenig lookup
                       // fails with version 2; make_pair not found
    return 0;
}

Proposed resolution:

Replace [depr.c.headers] paragraph 2 with:

Each C header, whose name has the form name.h, behaves as if each name placed in the Standard library namespace by the corresponding cname header is also placed within the namespace scope of the namespace std by name.h and is followed by an explicit using-declaration (_namespace.udecl_) in global scope.

Rationale:

The current wording in the standard is the result of a difficult compromise that averted delay of the standard. Based on discussions in Tokyo it is clear that there is no still no consensus on stricter wording, so the issue has been closed. It is suggested that users not write code that depends on Koenig lookup of C library functions.


145(i). adjustfield lacks default value

Section: 31.5.4.2 [basic.ios.cons] Status: NAD Submitter: Angelika Langer Opened: 1999-05-12 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [basic.ios.cons].

View all issues with NAD status.

Discussion:

There is no initial value for the adjustfield defined, although many people believe that the default adjustment were right. This is a common misunderstanding. The standard only defines that, if no adjustment is specified, all the predefined inserters must add fill characters before the actual value, which is "as if" the right flag were set. The flag itself need not be set.

When you implement a user-defined inserter you cannot rely on right being the default setting for the adjustfield. Instead, you must be prepared to find none of the flags set and must keep in mind that in this case you should make your inserter behave "as if" the right flag were set. This is surprising to many people and complicates matters more than necessary.

Unless there is a good reason why the adjustfield should not be initialized I would suggest to give it the default value that everybody expects anyway.

Rationale:

This is not a defect. It is deliberate that the default is no bits set. Consider Arabic or Hebrew, for example. See 28.3.4.3.3.3 [facet.num.put.virtuals] paragraph 19, Table 61 - Fill padding.


157(i). Meaningless error handling for pword() and iword()

Section: 31.5.2.6 [ios.base.storage] Status: Dup Submitter: Dietmar Kühl Opened: 1999-07-20 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [ios.base.storage].

View all issues with Dup status.

Duplicate of: 41

Discussion:

According to paragraphs 2 and 4 of 31.5.2.6 [ios.base.storage], the functions iword() and pword() "set the badbit (which might throw an exception)" on failure. ... but what does it mean for ios_base to set the badbit? The state facilities of the IOStream library are defined in basic_ios, a derived class! It would be possible to attempt a down cast but then it would be necessary to know the character type used...

Rationale:


162(i). Really "formatted input functions"?

Section: 31.7.5.3.3 [istream.extractors] Status: Dup Submitter: Dietmar Kühl Opened: 1999-07-20 Last modified: 2017-04-22

Priority: Not Prioritized

View all other issues in [istream.extractors].

View all issues with Dup status.

Duplicate of: 60

Discussion:

It appears to be somewhat nonsensical to consider the functions defined in the paragraphs 1 to 5 to be "Formatted input function" but since these functions are defined in a section labeled "Formatted input functions" it is unclear to me whether these operators are considered formatted input functions which have to conform to the "common requirements" from 31.7.5.3.1 [istream.formatted.reqmts]: If this is the case, all manipulators, not just ws, would skip whitespace unless noskipws is set (... but setting noskipws using the manipulator syntax would also skip whitespace :-)

See also issue 166(i) for the same problem in formatted output

Rationale:


163(i). Return of gcount() after a call to gcount

Section: 31.7.5.4 [istream.unformatted] Status: Dup Submitter: Dietmar Kühl Opened: 1999-07-20 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [istream.unformatted].

View all issues with Dup status.

Duplicate of: 60

Discussion:

It is not clear which functions are to be considered unformatted input functions. As written, it seems that all functions in 31.7.5.4 [istream.unformatted] are unformatted input functions. However, it does not really make much sense to construct a sentry object for gcount(), sync(), ... Also it is unclear what happens to the gcount() if eg. gcount(), putback(), unget(), or sync() is called: These functions don't extract characters, some of them even "unextract" a character. Should this still be reflected in gcount()? Of course, it could be read as if after a call to gcount() gcount() return 0 (the last unformatted input function, gcount(), didn't extract any character) and after a call to putback() gcount() returns -1 (the last unformatted input function putback() did "extract" back into the stream). Correspondingly for unget(). Is this what is intended? If so, this should be clarified. Otherwise, a corresponding clarification should be used.

Rationale:


166(i). Really "formatted output functions"?

Section: 31.7.6.3.3 [ostream.inserters] Status: Dup Submitter: Dietmar Kühl Opened: 1999-07-20 Last modified: 2016-01-28

Priority: Not Prioritized

View all issues with Dup status.

Duplicate of: 60

Discussion:

From 31.7.6.3.1 [ostream.formatted.reqmts] it appears that all the functions defined in 31.7.6.3.3 [ostream.inserters] have to construct a sentry object. Is this really intended?

This is basically the same problem as issue 162(i) but for output instead of input.

Rationale:


177(i). Complex operators cannot be explicitly instantiated

Section: 29.4.6 [complex.ops] Status: NAD Submitter: Judy Ward Opened: 1999-07-02 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [complex.ops].

View all issues with NAD status.

Discussion:

A user who tries to explicitly instantiate a complex non-member operator will get compilation errors. Below is a simplified example of the reason why. The problem is that iterator_traits cannot be instantiated on a non-pointer type like float, yet when the compiler is trying to decide which operator+ needs to be instantiated it must instantiate the declaration to figure out the first argument type of a reverse_iterator operator.

namespace std {
template <class Iterator> 
struct iterator_traits
{
    typedef typename Iterator::value_type value_type;
};

template <class T> class reverse_iterator;

// reverse_iterator operator+
template <class T> 
reverse_iterator<T> operator+
(typename iterator_traits<T>::difference_type, const reverse_iterator<T>&);

template <class T> struct complex {};

// complex operator +
template <class T>
complex<T> operator+ (const T& lhs, const complex<T>& rhs) 
{ return complex<T>();} 
}

// request for explicit instantiation
template std::complex<float> std::operator+<float>(const float&, 
     const std::complex<float>&);

See also c++-stdlib reflector messages: lib-6814, 6815, 6816.

Rationale:

Implementors can make minor changes and the example will work. Users are not affected in any case.

According to John Spicer, It is possible to explicitly instantiate these operators using different syntax: change "std::operator+<float>" to "std::operator+".

The proposed resolution of issue 120 is that users will not be able to explicitly instantiate standard library templates. If that resolution is accepted then library implementors will be the only ones that will be affected by this problem, and they must use the indicated syntax.


178(i). Should clog and cerr initially be tied to cout?

Section: 31.4.3 [narrow.stream.objects] Status: NAD Submitter: Judy Ward Opened: 1999-07-02 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [narrow.stream.objects].

View all issues with NAD status.

Discussion:

Section 27.3.1 says "After the object cerr is initialized, cerr.flags() & unitbuf is nonzero. Its state is otherwise the same as required for ios_base::init (lib.basic.ios.cons). It doesn't say anything about the the state of clog. So this means that calling cerr.tie() and clog.tie() should return 0 (see Table 89 for ios_base::init effects).

Neither of the popular standard library implementations that I tried does this, they both tie cerr and clog to &cout. I would think that would be what users expect.

Rationale:

The standard is clear as written.

27.3.1/5 says that "After the object cerr is initialized, cerr.flags() & unitbuf is nonzero. Its state is otherwise the same as required for ios_base::init (27.4.4.1)." Table 89 in 27.4.4.1, which gives the postconditions of basic_ios::init(), says that tie() is 0. (Other issues correct ios_base::init to basic_ios::init().)


188(i). valarray helpers missing augmented assignment operators

Section: 29.6.2.7 [valarray.cassign] Status: NAD Submitter: Gabriel Dos Reis Opened: 1999-08-15 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [valarray.cassign].

View all issues with NAD status.

Discussion:

26.5.2.6 defines augmented assignment operators valarray<T>::op=(const T&), but fails to provide corresponding versions for the helper classes. Thus making the following illegal:

#include <valarray>

int main()
{
std::valarray<double> v(3.14, 1999);

v[99] *= 2.0; // Ok

std::slice s(0, 50, 2);

v[s] *= 2.0; // ERROR
}

I can't understand the intent of that omission. It makes the valarray library less intuitive and less useful.

Rationale:

Although perhaps an unfortunate design decision, the omission is not a defect in the current standard.  A future standard may wish to add the missing operators.


190(i). min() and max() functions should be std::binary_functions

Section: 26.8.9 [alg.min.max] Status: NAD Submitter: Mark Rintoul Opened: 1999-08-26 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [alg.min.max].

View all other issues in [alg.min.max].

View all issues with NAD status.

Discussion:

Both std::min and std::max are defined as template functions. This is very different than the definition of std::plus (and similar structs) which are defined as function objects which inherit std::binary_function.

This lack of inheritance leaves std::min and std::max somewhat useless in standard library algorithms which require a function object that inherits std::binary_function.

[ post Bellevue: Alisdair requested to re-Open. ]

[ 2009-07 Frankfurt ]

C++0x has lambdas to address this problem now.

Moved to NAD.

Rationale:

Although perhaps an unfortunate design decision, the omission is not a defect in the current standard.  A future standard may wish to consider additional function objects.


191(i). Unclear complexity for algorithms such as binary search

Section: 26.8.4 [alg.binary.search] Status: NAD Submitter: Nico Josuttis Opened: 1999-10-10 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [alg.binary.search].

View all issues with NAD status.

Discussion:

The complexity of binary_search() is stated as "At most log(last-first) + 2 comparisons", which seems to say that the algorithm has logarithmic complexity. However, this algorithms is defined for forward iterators. And for forward iterators, the need to step element-by-element results into linear complexity. But such a statement is missing in the standard. The same applies to lower_bound(), upper_bound(), and equal_range(). 

However, strictly speaking the standard contains no bug here. So this might considered to be a clarification or improvement.

Rationale:

The complexity is expressed in terms of comparisons, and that complexity can be met even if the number of iterators accessed is linear. Paragraph 1 already says exactly what happens to iterators.


192(i). a.insert(p,t) is inefficient and overconstrained

Section: 23.2.7 [associative.reqmts] Status: NAD Submitter: Ed Brey Opened: 1999-06-06 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [associative.reqmts].

View all other issues in [associative.reqmts].

View all issues with NAD status.

Duplicate of: 233

Discussion:

As defined in 23.1.2, paragraph 7 (table 69), a.insert(p,t) suffers from several problems:

expression return type pre/post-condition complexity
a.insert(p,t) iterator inserts t if and only if there is no element with key equivalent to the key of t in containers with unique keys; always inserts t in containers with equivalent keys. always returns the iterator pointing to the element with key equivalent to the key of t . iterator p is a hint pointing to where the insert should start to search. logarithmic in general, but amortized constant if t is inserted right after p .

1. For a container with unique keys, only logarithmic complexity is guaranteed if no element is inserted, even though constant complexity is always possible if p points to an element equivalent to t.

2. For a container with equivalent keys, the amortized constant complexity guarantee is only useful if no key equivalent to t exists in the container. Otherwise, the insertion could occur in one of multiple locations, at least one of which would not be right after p.

3. By guaranteeing amortized constant complexity only when t is inserted after p, it is impossible to guarantee constant complexity if t is inserted at the beginning of the container. Such a problem would not exist if amortized constant complexity was guaranteed if t is inserted before p, since there is always some p immediately before which an insert can take place.

4. For a container with equivalent keys, p does not allow specification of where to insert the element, but rather only acts as a hint for improving performance. This negates the added functionality that p would provide if it specified where within a sequence of equivalent keys the insertion should occur. Specifying the insert location provides more control to the user, while providing no disadvantage to the container implementation.

Proposed resolution:

In 23.2.7 [associative.reqmts] paragraph 7, replace the row in table 69 for a.insert(p,t) with the following two rows:

expression return type pre/post-condition complexity
a_uniq.insert(p,t) iterator inserts t if and only if there is no element with key equivalent to the key of t. returns the iterator pointing to the element with key equivalent to the key of t. logarithmic in general, but amortized constant if t is inserted right before p or p points to an element with key equivalent to t.
a_eq.insert(p,t) iterator inserts t and returns the iterator pointing to the newly inserted element. t is inserted right before p if doing so preserves the container ordering. logarithmic in general, but amortized constant if t is inserted right before p.

Rationale:

Too big a change.  Furthermore, implementors report checking both before p and after p, and don't want to change this behavior.


194(i). rdbuf() functions poorly specified

Section: 31.5.4 [ios] Status: NAD Submitter: Steve Clamage Opened: 1999-09-07 Last modified: 2016-01-28

Priority: Not Prioritized

View all issues with NAD status.

Discussion:

In classic iostreams, base class ios had an rdbuf function that returned a pointer to the associated streambuf. Each derived class had its own rdbuf function that returned a pointer of a type reflecting the actual type derived from streambuf. Because in ARM C++, virtual function overrides had to have the same return type, rdbuf could not be virtual.

In standard iostreams, we retain the non-virtual rdbuf function design, and in addition have an overloaded rdbuf function that sets the buffer pointer. There is no need for the second function to be virtual nor to be implemented in derived classes.

Minor question: Was there a specific reason not to make the original rdbuf function virtual?

Major problem: Friendly compilers warn about functions in derived classes that hide base-class overloads. Any standard implementation of iostreams will result in such a warning on each of the iostream classes, because of the ill-considered decision to overload rdbuf only in a base class.

In addition, users of the second rdbuf function must use explicit qualification or a cast to call it from derived classes. An explicit qualification or cast to basic_ios would prevent access to any later overriding version if there was one.

What I'd like to do in an implementation is add a using- declaration for the second rdbuf function in each derived class. It would eliminate warnings about hiding functions, and would enable access without using explicit qualification. Such a change I don't think would change the behavior of any valid program, but would allow invalid programs to compile:

 filebuf mybuf;
 fstream f;
 f.rdbuf(mybuf); // should be an error, no visible rdbuf

I'd like to suggest this problem as a defect, with the proposed resolution to require the equivalent of a using-declaration for the rdbuf function that is not replaced in a later derived class. We could discuss whether replacing the function should be allowed.

Rationale:

For historical reasons, the standard is correct as written. There is a subtle difference between the base class rdbuf() and derived class rdbuf(). The derived class rdbuf() always returns the original streambuf, whereas the base class rdbuf() will return the "current streambuf" if that has been changed by the variant you mention.

Permission is not required to add such an extension. See 16.4.6.5 [member.functions].


196(i). Placement new example has alignment problems

Section: 17.6.3.4 [new.delete.placement] Status: Dup Submitter: Herb Sutter Opened: 1998-12-15 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [new.delete.placement].

View all issues with Dup status.

Duplicate of: 114

Discussion:

The example in 17.6.3.4 [new.delete.placement] paragraph 4 reads:

[Example: This can be useful for constructing an object at a known address:

   char place[sizeof(Something)];
   Something* p = new (place) Something();

end example]

This example has potential alignment problems.

Rationale:


197(i). max_size() underspecified

Section: 16.4.4.6 [allocator.requirements], 23.2 [container.requirements] Status: NAD Submitter: Andy Sawyer Opened: 1999-10-21 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [allocator.requirements].

View all other issues in [allocator.requirements].

View all issues with NAD status.

Discussion:

Must the value returned by max_size() be unchanged from call to call?

Must the value returned from max_size() be meaningful?

Possible meanings identified in lib-6827:

1) The largest container the implementation can support given "best case" conditions - i.e. assume the run-time platform is "configured to the max", and no overhead from the program itself. This may possibly be determined at the point the library is written, but certainly no later than compile time.

2) The largest container the program could create, given "best case" conditions - i.e. same platform assumptions as (1), but take into account any overhead for executing the program itself. (or, roughly "storage=storage-sizeof(program)"). This does NOT include any resource allocated by the program. This may (or may not) be determinable at compile time.

3) The largest container the current execution of the program could create, given knowledge of the actual run-time platform, but again, not taking into account any currently allocated resource. This is probably best determined at program start-up.

4) The largest container the current execution program could create at the point max_size() is called (or more correctly at the point max_size() returns :-), given it's current environment (i.e. taking into account the actual currently available resources). This, obviously, has to be determined dynamically each time max_size() is called.

Proposed resolution:

Rationale:

max_size() isn't useful for very many things, and the existing wording is sufficiently clear for the few cases that max_size() can be used for. None of the attempts to change the existing wording were an improvement.

It is clear to the LWG that the value returned by max_size() can't change from call to call.


203(i). basic_istream::sentry::sentry() is uninstantiable with ctype<user-defined type>

Section: 31.7.5.2.4 [istream.sentry] Status: NAD Submitter: Matt McClure and Dietmar Kühl Opened: 2000-01-01 Last modified: 2021-06-06

Priority: Not Prioritized

View all other issues in [istream.sentry].

View all issues with NAD status.

Discussion:

27.6.1.1.2 Paragraph 4 states:

To decide if the character c is a whitespace character, the constructor performs ''as if'' it executes the following code fragment: 

const ctype<charT>& ctype = use_facet<ctype<charT> >(is.getloc());
if (ctype.is(ctype.space,c)!=0)
// c is a whitespace character.

But Table 51 in 22.1.1.1.1 only requires an implementation to provide specializations for ctype<char> and ctype<wchar_t>. If sentry's constructor is implemented using ctype, it will be uninstantiable for a user-defined character type charT, unless the implementation has provided non-working (since it would be impossible to define a correct ctype<charT> specialization for an arbitrary charT) definitions of ctype's virtual member functions.

It seems the intent the standard is that sentry should behave, in every respect, not just during execution, as if it were implemented using ctype, with the burden of providing a ctype specialization falling on the user. But as it is written, nothing requires the translation of sentry's constructor to behave as if it used the above code, and it would seem therefore, that sentry's constructor should be instantiable for all character types.

Note: If I have misinterpreted the intent of the standard with respect to sentry's constructor's instantiability, then a note should be added to the following effect:

An implementation is forbidden from using the above code if it renders the constructor uninstantiable for an otherwise valid character type.

In any event, some clarification is needed.

Rationale:

It is possible but not easy to instantiate on types other than char or wchar_t; many things have to be done first. That is by intention and is not a defect.


204(i). distance(first, last) when "last" is before "first"

Section: 24.4.3 [iterator.operations] Status: NAD Submitter: Rintala Matti Opened: 2000-01-28 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [iterator.operations].

View all other issues in [iterator.operations].

View all issues with NAD status.

Discussion:

Section 24.3.4 describes the function distance(first, last) (where first and last are iterators) which calculates "the number of increments or decrements needed to get from 'first' to 'last'".

The function should work for forward, bidirectional and random access iterators, and there is a requirement 24.3.4.5 which states that "'last' must be reachable from 'first'".

With random access iterators the function is easy to implement as "last - first".

With forward iterators it's clear that 'first' must point to a place before 'last', because otherwise 'last' would not be reachable from 'first'.

But what about bidirectional iterators? There 'last' is reachable from 'first' with the -- operator even if 'last' points to an earlier position than 'first'. However, I cannot see how the distance() function could be implemented if the implementation does not know which of the iterators points to an earlier position (you cannot use ++ or -- on either iterator if you don't know which direction is the "safe way to travel").

The paragraph 24.3.4.1 states that "for ... bidirectional iterators they use ++ to provide linear time implementations". However, the ++ operator is not mentioned in the reachability requirement. Furthermore 24.3.4.4 explicitly mentions that distance() returns the number of increments _or decrements_, suggesting that it could return a negative number also for bidirectional iterators when 'last' points to a position before 'first'.

Is a further requirement is needed to state that for forward and bidirectional iterators "'last' must be reachable from 'first' using the ++ operator". Maybe this requirement might also apply to random access iterators so that distance() would work the same way for every iterator category?

Rationale:

"Reachable" is defined in the standard in 24.3.4 [iterator.concepts] paragraph 6. The definition is only in terms of operator++(). The LWG sees no defect in the standard.


205(i). numeric_limits unclear on how to determine floating point types

Section: 17.3.5.2 [numeric.limits.members] Status: NAD Submitter: Steve Cleary Opened: 2000-01-28 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [numeric.limits.members].

View all issues with NAD status.

Discussion:

In several places in 17.3.5.2 [numeric.limits.members], a member is described as "Meaningful for all floating point types." However, no clear method of determining a floating point type is provided.

In 17.3.5.3 [numeric.special], paragraph 1 states ". . . (for example, epsilon() is only meaningful if is_integer is false). . ." which suggests that a type is a floating point type if is_specialized is true and is_integer is false; however, this is unclear.

When clarifying this, please keep in mind this need of users: what exactly is the definition of floating point? Would a fixed point or rational representation be considered one? I guess my statement here is that there could also be types that are neither integer or (strictly) floating point.

Rationale:

It is up to the implementor of a user define type to decide if it is a floating point type.


207(i). ctype<char> members return clause incomplete

Section: 28.3.4.2.4.3 [facet.ctype.char.members] Status: Dup Submitter: Robert Klarer Opened: 1999-11-02 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [facet.ctype.char.members].

View all issues with Dup status.

Duplicate of: 153

Discussion:

The widen and narrow member functions are described in 22.2.1.3.2, paragraphs 9-11. In each case we have two overloaded signatures followed by a Returns clause. The Returns clause only describes one of the overloads.

Proposed resolution:

Change the returns clause in 28.3.4.2.4.3 [facet.ctype.char.members] paragraph 10 from:

    Returns: do_widen(low, high, to).

to:

    Returns: do_widen(c) or do_widen(low, high, to), respectively.

Change the returns clause in 28.3.4.2.4.3 [facet.ctype.char.members] paragraph 11 from:

    Returns: do_narrow(low, high, to).

to:

    Returns: do_narrow(c) or do_narrow(low, high, to), respectively.

Rationale:

Subsumed by issue 153(i), which addresses the same paragraphs.


213(i). Math function overloads ambiguous

Section: 29.7 [c.math] Status: NAD Submitter: Nico Josuttis Opened: 2000-02-26 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [c.math].

View all issues with NAD status.

Discussion:

Due to the additional overloaded versions of numeric functions for float and long double according to Section 26.5, calls such as int x; std::pow (x, 4) are ambiguous now in a standard conforming implementation. Current implementations solve this problem very different (overload for all types, don't overload for float and long double, use preprocessor, follow the standard and get ambiguities).

This behavior should be standardized or at least identified as implementation defined.

Rationale:

These math issues are an understood and accepted consequence of the design. They have been discussed several times in the past. Users must write casts or write floating point expressions as arguments.


215(i). Can a map's key_type be const?

Section: 23.2.7 [associative.reqmts] Status: NAD Submitter: Judy Ward Opened: 2000-02-29 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [associative.reqmts].

View all other issues in [associative.reqmts].

View all issues with NAD status.

Discussion:

A user noticed that this doesn't compile with the Rogue Wave library because the rb_tree class declares a key_allocator, and allocator<const int> is not legal, I think:

map < const int, ... > // legal?

which made me wonder whether it is legal for a map's key_type to be const. In email from Matt Austern he said:

I'm not sure whether it's legal to declare a map with a const key type. I hadn't thought about that question until a couple weeks ago. My intuitive feeling is that it ought not to be allowed, and that the standard ought to say so. It does turn out to work in SGI's library, though, and someone in the compiler group even used it. Perhaps this deserves to be written up as an issue too.

Rationale:

The "key is assignable" requirement from table 69 in 23.2.7 [associative.reqmts] already implies the key cannot be const.


216(i). setbase manipulator description flawed

Section: 31.7.7 [std.manip] Status: Dup Submitter: Hyman Rosen Opened: 2000-02-29 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [std.manip].

View all issues with Dup status.

Duplicate of: 193

Discussion:

31.7.7 [std.manip] paragraph 5 says:

smanip setbase(int base);

Returns: An object s of unspecified type such that if out is an (instance of) basic_ostream then the expression out<<s behaves as if f(s) were called, in is an (instance of) basic_istream then the expression in>>s behaves as if f(s) were called. Where f can be defined as:

ios_base& f(ios_base& str, int base)
{
  // set basefield
  str.setf(n == 8 ? ios_base::oct :
                n == 10 ? ios_base::dec :
                n == 16 ? ios_base::hex :
                  ios_base::fmtflags(0), ios_base::basefield);
  return str;
}

There are two problems here. First, f takes two parameters, so the description needs to say that out<<s and in>>s behave as if f(s,base) had been called. Second, f is has a parameter named base, but is written as if the parameter was named n.

Actually, there's a third problem. The paragraph has grammatical errors. There needs to be an "and" after the first comma, and the "Where f" sentence fragment needs to be merged into its preceding sentence. You may also want to format the function a little better. The formatting above is more-or-less what the Standard contains.

Rationale:

The resolution of this defect is subsumed by the proposed resolution for issue 193(i).

[Tokyo: The LWG agrees that this is a defect and notes that it occurs additional places in the section, all requiring fixes.]


218(i). Algorithms do not use binary predicate objects for default comparisons

Section: 26.8 [alg.sorting] Status: NAD Submitter: Pablo Halpern Opened: 2000-03-06 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [alg.sorting].

View all issues with NAD status.

Discussion:

Many of the algorithms take an argument, pred, of template parameter type BinaryPredicate or an argument comp of template parameter type Compare. These algorithms usually have an overloaded version that does not take the predicate argument. In these cases pred is usually replaced by the use of operator== and comp is replaced by the use of operator<.

This use of hard-coded operators is inconsistent with other parts of the library, particularly the containers library, where equality is established using equal_to<> and ordering is established using less<>. Worse, the use of operator<, would cause the following innocent-looking code to have undefined behavior:

vector<string*> vec;
sort(vec.begin(), vec.end());

The use of operator< is not defined for pointers to unrelated objects. If std::sort used less<> to compare elements, then the above code would be well-defined, since less<> is explicitly specialized to produce a total ordering of pointers.

Rationale:

This use of operator== and operator< was a very deliberate, conscious, and explicitly made design decision; these operators are often more efficient. The predicate forms are available for users who don't want to rely on operator== and operator<.


219(i). find algorithm missing version that takes a binary predicate argument

Section: 26.6.6 [alg.find] Status: NAD Submitter: Pablo Halpern Opened: 2000-03-06 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [alg.find].

View all issues with NAD status.

Discussion:

The find function always searches for a value using operator== to compare the value argument to each element in the input iterator range. This is inconsistent with other find-related functions such as find_end and find_first_of, which allow the caller to specify a binary predicate object to be used for determining equality. The fact that this can be accomplished using a combination of find_if and bind_1st or bind_2nd does not negate the desirability of a consistent, simple, alternative interface to find.

[ Summit: ]

Reopened by Alisdair.

[ 2009-07 Frankfurt ]

The same thing can be achieved using find_if (as noted in the issue).

Moved to NAD.

Proposed resolution:

In section 26.6.6 [alg.find], add a second prototype for find (between the existing prototype and the prototype for find_if), as follows:

    template<class InputIterator, class T, class BinaryPredicate>
      InputIterator find(InputIterator first, InputIterator last,
                         const T& value, BinaryPredicate bin_pred);

Change the description of the return from:

Returns: The first iterator i in the range [first, last) for which the following corresponding conditions hold: *i == value, pred(*i) != false. Returns last if no such iterator is found.

 to:

Returns: The first iterator i in the range [first, last) for which the following  corresponding condition holds: *i == value, bin_pred(*i,value) != false, pred(*) != false. Return last if no such iterator is found.

Rationale:

This is request for a pure extension, so it is not a defect in the current standard.  As the submitter pointed out, "this can be accomplished using a combination of find_if and bind_1st or bind_2nd".


236(i). ctype<char>::is() member modifies facet

Section: 28.3.4.2.4.3 [facet.ctype.char.members] Status: Dup Submitter: Dietmar Kühl Opened: 2000-04-24 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [facet.ctype.char.members].

View all issues with Dup status.

Duplicate of: 28

Discussion:

The description of the is() member in paragraph 4 of 28.3.4.2.4.3 [facet.ctype.char.members] is broken: According to this description, the second form of the is() method modifies the masks in the ctype object. The correct semantics if, of course, to obtain an array of masks. The corresponding method in the general case, ie. the do_is() method as described in 28.3.4.2.2.3 [locale.ctype.virtuals] paragraph 1 does the right thing.

Proposed resolution:

Change paragraph 4 from

The second form, for all *p in the range [low, high), assigns vec[p-low] to table()[(unsigned char)*p].

to become

The second form, for all *p in the range [low, high), assigns table()[(unsigned char)*p] to vec[p-low].

Rationale:


244(i). Must find's third argument be CopyConstructible?

Section: 26.6.6 [alg.find] Status: NAD Submitter: Andrew Koenig Opened: 2000-05-02 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [alg.find].

View all issues with NAD status.

Discussion:

Is the following implementation of find acceptable?

        template<class Iter, class X>
        Iter find(Iter begin, Iter end, const X& x)
        {
            X x1 = x;           // this is the crucial statement
            while (begin != end && *begin != x1)
                ++begin;
            return begin;
        }

If the answer is yes, then it is implementation-dependent as to whether the following fragment is well formed:

        vector<string> v;

        find(v.begin(), v.end(), "foo");

At issue is whether there is a requirement that the third argument of find be CopyConstructible. There may be no problem here, but analysis is necessary.

Rationale:

There is no indication in the standard that find's third argument is required to be Copy Constructible. The LWG believes that no such requirement was intended. As noted above, there are times when a user might reasonably pass an argument that is not Copy Constructible.


245(i). Which operations on istream_iterator trigger input operations?

Section: 24.6.2 [istream.iterator] Status: NAD Submitter: Andrew Koenig Opened: 2000-05-02 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [istream.iterator].

View all issues with NAD status.

Discussion:

I do not think the standard specifies what operation(s) on istream iterators trigger input operations. So, for example:

        istream_iterator<int> i(cin);

        int n = *i++;

I do not think it is specified how many integers have been read from cin. The number must be at least 1, of course, but can it be 2? More?

Rationale:

The standard is clear as written: the stream is read every time operator++ is called, and it is also read either when the iterator is constructed or when operator* is called for the first time. In the example above, exactly two integers are read from cin.

There may be a problem with the interaction between istream_iterator and some STL algorithms, such as find. There are no guarantees about how many times find may invoke operator++.


246(i). a.insert(p,t) is incorrectly specified

Section: 23.2.7 [associative.reqmts] Status: Dup Submitter: Mark Rodgers Opened: 2000-05-19 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [associative.reqmts].

View all other issues in [associative.reqmts].

View all issues with Dup status.

Duplicate of: 233

Discussion:

Closed issue 192 raised several problems with the specification of this function, but was rejected as Not A Defect because it was too big a change with unacceptable impacts on existing implementations. However, issues remain that could be addressed with a smaller change and with little or no consequent impact.

  1. The specification is inconsistent with the original proposal and with several implementations.

    The initial implementation by Hewlett Packard only ever looked immediately before p, and I do not believe there was any intention to standardize anything other than this behavior. Consequently, current implementations by several leading implementors also look immediately before p, and will only insert after p in logarithmic time. I am only aware of one implementation that does actually look after p, and it looks before p as well. It is therefore doubtful that existing code would be relying on the behavior defined in the standard, and it would seem that fixing this defect as proposed below would standardize existing practice.

  2. The specification is inconsistent with insertion for sequence containers.

    This is difficult and confusing to teach to newcomers. All insert operations that specify an iterator as an insertion location should have a consistent meaning for the location represented by that iterator.

  3. As specified, there is no way to hint that the insertion should occur at the beginning of the container, and the way to hint that it should occur at the end is long winded and unnatural.

    For a container containing n elements, there are n+1 possible insertion locations and n+1 valid iterators. For there to be a one-to-one mapping between iterators and insertion locations, the iterator must represent an insertion location immediately before the iterator.

  4. When appending sorted ranges using insert_iterators, insertions are guaranteed to be sub-optimal.

    In such a situation, the optimum location for insertion is always immediately after the element previously inserted. The mechanics of the insert iterator guarantee that it will try and insert after the element after that, which will never be correct. However, if the container first tried to insert before the hint, all insertions would be performed in amortized constant time.

Proposed resolution:

In 23.1.2 [lib.associative.reqmts] paragraph 7, table 69, make the following changes in the row for a.insert(p,t):

assertion/note pre/post condition:
Change the last sentence from

"iterator p is a hint pointing to where the insert should start to search."

to

"iterator p is a hint indicating that immediately before p may be a correct location where the insertion could occur."

complexity:
Change the words "right after" to "immediately before".

Rationale:


249(i). Return Type of auto_ptr::operator=

Section: 99 [auto.ptr] Status: NAD Submitter: Joseph Gottman Opened: 2000-06-30 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [auto.ptr].

View all issues with NAD status.

Discussion:

According to section 20.4.5, the function auto_ptr::operator=() returns a reference to an auto_ptr. The reason that operator=() usually returns a reference is to facilitate code like

    int x,y,z;
    x = y = z = 1;

However, given analogous code for auto_ptrs,

    auto_ptr<int> x, y, z;
    z.reset(new int(1));
    x = y = z;

the result would be that z and y would both be set to NULL, instead of all the auto_ptrs being set to the same value. This makes such cascading assignments useless and counterintuitive for auto_ptrs.

Proposed resolution:

Change auto_ptr::operator=() to return void instead of an auto_ptr reference.

Rationale:

The return value has uses other than cascaded assignments: a user can call an auto_ptr member function, pass the auto_ptr to a function, etc. Removing the return value could break working user code.


255(i). Why do basic_streambuf<>::pbump() and gbump() take an int?

Section: 31.6.3 [streambuf] Status: NAD Submitter: Martin Sebor Opened: 2000-08-12 Last modified: 2017-06-06

Priority: Not Prioritized

View all other issues in [streambuf].

View all issues with NAD status.

Discussion:

The basic_streambuf members gbump() and pbump() are specified to take an int argument. This requirement prevents the functions from effectively manipulating buffers larger than std::numeric_limits<int>::max() characters. It also makes the common use case for these functions somewhat difficult as many compilers will issue a warning when an argument of type larger than int (such as ptrdiff_t on LLP64 architectures) is passed to either of the function. Since it's often the result of the subtraction of two pointers that is passed to the functions, a cast is necessary to silence such warnings. Finally, the usage of a native type in the functions signatures is inconsistent with other member functions (such as sgetn() and sputn()) that manipulate the underlying character buffer. Those functions take a streamsize argument.

[ 2009-07 Frankfurt ]

This is part of a bigger problem. If anyone cares enough, they should write a paper solving the bigger problem of offset types in iostreams.

This is related to the paper about large file sizes. Beman has already agreed to drop the section of that paper that deals with this.

int is big enough for reasonable buffers.

Move to NAD Future.

This is related to LWG 423(i).

[2017-02 in Kona, LEWG recommends NAD]

[2017-06-02 Issues Telecon]

Resolve as NAD

The previous rationale given suggested that LWG believes the change is too big for now. Actually, changing the parameter type is too big a change more or less forever, because that would break every custom streambuf type; there are too many such types in the wild to make a breaking change. The overload approach may be more plausible, but is not an entirely breakage-free solution; it can produce ambiguities, and can still break streambuf hierarchies.

Proposed resolution:

Change the signatures of these functions in the synopsis of template class basic_streambuf (27.5.2) and in their descriptions (27.5.2.3.1, p4 and 27.5.2.3.2, p4) to take a streamsize argument.

Although this change has the potential of changing the ABI of the library, the change will affect only platforms where int is different than the definition of streamsize. However, since both functions are typically inline (they are on all known implementations), even on such platforms the change will not affect any user code unless it explicitly relies on the existing type of the functions (e.g., by taking their address). Such a possibility is IMO quite remote.

Alternate Suggestion from Howard Hinnant, c++std-lib-7780:

This is something of a nit, but I'm wondering if streamoff wouldn't be a better choice than streamsize. The argument to pbump and gbump MUST be signed. But the standard has this to say about streamsize (27.4.1/2/Footnote):

[Footnote: streamsize is used in most places where ISO C would use size_t. Most of the uses of streamsize could use size_t, except for the strstreambuf constructors, which require negative values. It should probably be the signed type corresponding to size_t (which is what Posix.2 calls ssize_t). — end footnote]

This seems a little weak for the argument to pbump and gbump. Should we ever really get rid of strstream, this footnote might go with it, along with the reason to make streamsize signed.

Rationale:

The LWG believes this change is too big for now. We may wish to reconsider this for a future revision of the standard. One possibility is overloading pbump, rather than changing the signature.

[ [2006-05-04: Reopened at the request of Chris (Krzysztof Żelechowski)] ]


257(i). STL functional object and iterator inheritance.

Section: 99 [depr.base], 99 [iterator.basic] Status: NAD Submitter: Robert Dick Opened: 2000-08-17 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [depr.base].

View all issues with NAD status.

Discussion:

According to the November 1997 Draft Standard, the results of deleting an object of a derived class through a pointer to an object of its base class are undefined if the base class has a non-virtual destructor. Therefore, it is potentially dangerous to publicly inherit from such base classes.

Defect:
The STL design encourages users to publicly inherit from a number of classes which do nothing but specify interfaces, and which contain non-virtual destructors.

Attribution:
Wil Evers and William E. Kempf suggested this modification for functional objects.

Proposed resolution:

When a base class in the standard library is useful only as an interface specifier, i.e., when an object of the class will never be directly instantiated, specify that the class contains a protected destructor. This will prevent deletion through a pointer to the base class without performance, or space penalties (on any implementation I'm aware of).

As an example, replace...

    template <class Arg, class Result>
    struct unary_function {
            typedef Arg    argument_type;
            typedef Result result_type;
    };

... with...

    template <class Arg, class Result>
    struct unary_function {
            typedef Arg    argument_type;
            typedef Result result_type;
    protected:
            ~unary_function() {}
    };

Affected definitions:
 20.3.1 [lib.function.objects] -- unary_function, binary_function
 24.3.2 [lib.iterator.basic] -- iterator

Rationale:

The standard is clear as written; this is a request for change, not a defect in the strict sense. The LWG had several different objections to the proposed change. One is that it would prevent users from creating objects of type unary_function and binary_function. Doing so can sometimes be legitimate, if users want to pass temporaries as traits or tag types in generic code.


267(i). interaction of strstreambuf::overflow() and seekoff()

Section: 99 [depr.strstreambuf.virtuals] Status: NAD Submitter: Martin Sebor Opened: 2000-10-05 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [depr.strstreambuf.virtuals].

View all issues with NAD status.

Discussion:

It appears that the interaction of the strstreambuf members overflow() and seekoff() can lead to undefined behavior in cases where defined behavior could reasonably be expected. The following program demonstrates this behavior:

    #include <strstream>

    int main ()
    {
         std::strstreambuf sb;
         sb.sputc ('c');

         sb.pubseekoff (-1, std::ios::end, std::ios::in);
         return !('c' == sb.sgetc ());
    }

D.7.1.1, p1 initializes strstreambuf with a call to basic_streambuf<>(), which in turn sets all pointers to 0 in 27.5.2.1, p1.

27.5.2.2.5, p1 says that basic_streambuf<>::sputc(c) calls overflow(traits::to_int_type(c)) if a write position isn't available (it isn't due to the above).

D.7.1.3, p3 says that strstreambuf::overflow(off, ..., ios::in) makes at least one write position available (i.e., it allows the function to make any positive number of write positions available).

D.7.1.3, p13 computes newoff = seekhigh - eback(). In D.7.1, p4 we see seekhigh = epptr() ? epptr() : egptr(), or seekhigh = epptr() in this case. newoff is then epptr() - eback().

D.7.1.4, p14 sets gptr() so that gptr() == eback() + newoff + off, or gptr() == epptr() + off holds.

If strstreambuf::overflow() made exactly one write position available then gptr() will be set to just before epptr(), and the program will return 0. Buf if the function made more than one write position available, epptr() and gptr() will both point past pptr() and the behavior of the program is undefined.

Proposed resolution:

Change the last sentence of 99 [depr.strstreambuf] paragraph 4 from

Otherwise, seeklow equals gbeg and seekhigh is either pend, if pend is not a null pointer, or gend.

to become

Otherwise, seeklow equals gbeg and seekhigh is either gend if 0 == pptr(), or pbase() + max where max is the maximum value of pptr() - pbase() ever reached for this stream.

[ pre-Copenhagen: Dietmar provided wording for proposed resolution. ]

[ post-Copenhagen: Fixed a typo: proposed resolution said to fix 4.7.1, not D.7.1. ]

Rationale:

This is related to issue 65(i): it's not clear what it means to seek beyond the current area. Without resolving issue 65(i) we can't resolve this. As with issue 65(i), the library working group does not wish to invest time nailing down corner cases in a deprecated feature.


269(i). cstdarg and unnamed parameters

Section: 17.9 [support.exception] Status: NAD Submitter: J. Stephen Adamczyk Opened: 2000-10-10 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [support.exception].

View all issues with NAD status.

Discussion:

One of our customers asks whether this is valid C++:

   #include <cstdarg>

   void bar(const char *, va_list);

   void
   foo(const char *file, const char *, ...)
   {
     va_list ap;
     va_start(ap, file);
     bar(file, ap);
     va_end(ap);
   }

The issue being whether it is valid to use cstdarg when the final parameter before the "..." is unnamed. cstdarg is, as far as I can tell, inherited verbatim from the C standard. and the definition there (7.8.1.1 in the ISO C89 standard) refers to "the identifier of the rightmost parameter". What happens when there is no such identifier?

My personal opinion is that this should be allowed, but some tweak might be required in the C++ standard.

Rationale:

Not a defect, the C and C++ standards are clear. It is impossible to use varargs if the parameter immediately before "..." has no name, because that is the parameter that must be passed to va_start. The example given above is broken, because va_start is being passed the wrong parameter.

There is no support for extending varargs to provide additional functionality beyond what's currently there. For reasons of C/C++ compatibility, it is especially important not to make gratuitous changes in this part of the C++ standard. The C committee has already been requested not to touch this part of the C standard unless necessary.


277(i). Normative encouragement in allocator requirements unclear

Section: 16.4.4.6 [allocator.requirements] Status: NAD Submitter: Matt Austern Opened: 2000-11-07 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [allocator.requirements].

View all other issues in [allocator.requirements].

View all issues with NAD status.

Discussion:

In 20.1.5, paragraph 5, the standard says that "Implementors are encouraged to supply libraries that can accept allocators that encapsulate more general memory models and that support non-equal instances." This is intended as normative encouragement to standard library implementors. However, it is possible to interpret this sentence as applying to nonstandard third-party libraries.

Proposed resolution:

In 20.1.5, paragraph 5, change "Implementors" to "Implementors of the library described in this International Standard".

Rationale:

The LWG believes the normative encouragement is already sufficiently clear, and that there are no important consequences even if it is misunderstood.


279(i). const and non-const iterators should have equivalent typedefs

Section: 23.2 [container.requirements] Status: NAD Submitter: Steve Cleary Opened: 2000-11-27 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [container.requirements].

View all issues with NAD status.

Discussion:

This came from an email from Steve Cleary to Fergus in reference to issue 179(i). The library working group briefly discussed this in Toronto and believes it should be a separate issue.

Steve said: "We may want to state that the const/non-const iterators must have the same difference type, size_type, and category."

(Comment from Judy) I'm not sure if the above sentence should be true for all const and non-const iterators in a particular container, or if it means the container's iterator can't be compared with the container's const_iterator unless the above it true. I suspect the former.

Proposed resolution:

In Section: 23.2 [container.requirements], table 65, in the assertion/note pre/post condition for X::const_iterator, add the following:

typeid(X::const_iterator::difference_type) == typeid(X::iterator::difference_type)

typeid(X::const_iterator::size_type) == typeid(X::iterator::size_type)

typeid(X::const_iterator::category) == typeid(X::iterator::category)

Rationale:

Going through the types one by one: Iterators don't have a size_type. We already know that the difference types are identical, because the container requirements already say that the difference types of both X::iterator and X::const_iterator are both X::difference_type. The standard does not require that X::iterator and X::const_iterator have the same iterator category, but the LWG does not see this as a defect: it's possible to imagine cases in which it would be useful for the categories to be different.

It may be desirable to require X::iterator and X::const_iterator to have the same value type, but that is a new issue. (Issue 322(i).)


287(i). conflicting ios_base fmtflags

Section: 31.5.2.3 [fmtflags.state] Status: NAD Submitter: Judy Ward Opened: 2000-12-30 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [fmtflags.state].

View all issues with NAD status.

Discussion:

The Effects clause for ios_base::setf(fmtflags fmtfl) says "Sets fmtfl in flags()". What happens if the user first calls ios_base::scientific and then calls ios_base::fixed or vice-versa? This is an issue for all of the conflicting flags, i.e. ios_base::left and ios_base::right or ios_base::dec, ios_base::hex and ios_base::oct.

I see three possible solutions:

  1. Set ios_base::failbit whenever the user specifies a conflicting flag with one previously explicitly set. If the constructor is supposed to set ios_base::dec (see discussion below), then the user setting hex or oct format after construction will not set failbit.
  2. The last call to setf "wins", i.e. it clears any conflicting previous setting.
  3. All the flags that the user specifies are set, but when actually interpreting them, fixed always override scientific, right always overrides left, dec overrides hex which overrides oct.

Most existing implementations that I tried seem to conform to resolution #3, except that when using the iomanip manipulator hex or oct then that always overrides dec, but calling setf(ios_base::hex) doesn't.

There is a sort of related issue, which is that although the ios_base constructor says that each ios_base member has an indeterminate value after construction, all the existing implementations I tried explicitly set ios_base::dec.

Proposed resolution:

Rationale:

adjustfield, basefield, and floatfield are each multi-bit fields. It is possible to set multiple bits within each of those fields. (For example, dec and oct). These fields are used by locale facets. The LWG reviewed the way in which each of those three fields is used, and believes that in each case the behavior is well defined for any possible combination of bits. See for example Table 58, in 28.3.4.3.3.3 [facet.num.put.virtuals], noting the requirement in paragraph 6 of that section.

Users are advised to use manipulators, or else use the two-argument version of setf, to avoid unexpected behavior.


289(i). <cmath> requirements missing C float and long double versions

Section: 29.7 [c.math] Status: NAD Submitter: Judy Ward Opened: 2000-12-30 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [c.math].

View all issues with NAD status.

Discussion:

In ISO/IEC 9899:1990 Programming Languages C we find the following concerning <math.h>:

7.13.4 Mathematics <math.h>
The names of all existing functions declared in the <math.h> header, suffixed with f or l, are reserved respectively for corresponding functions with float and long double arguments are return values.

For example, float sinf(float) is reserved.

In the C99 standard, <math.h> must contain declarations for these functions.

So, is it acceptable for an implementor to add these prototypes to the C++ versions of the math headers? Are they required?

Proposed resolution:

Add these Functions to Table 80, section 26.5 and to Table 99, section C.2:

    acosf asinf atanf atan2f ceilf cosf coshf 
    expf fabsf floorf fmodf frexpf ldexpf 
    logf log10f modff powf sinf sinhf sqrtf 
    tanf tanhf 
    acosl asinl atanl atan2l ceill cosl coshl 
    expl fabsl floorl fmodl frexpl ldexpl 
    logl log10l modfl powl sinl sinhl sqrtl 
    tanl tanhl

There should probably be a note saying that these functions are optional and, if supplied, should match the description in the 1999 version of the C standard. In the next round of C++ standardization they can then become mandatory.

Rationale:

The C90 standard, as amended, already permits (but does not require) these functions, and the C++ standard incorporates the C90 standard by reference. C99 is not an issue, because it is never referred to by the C++ standard.


290(i). Requirements to for_each and its function object

Section: 26.6.5 [alg.foreach] Status: NAD Submitter: Angelika Langer Opened: 2001-01-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [alg.foreach].

View all issues with NAD status.

Discussion:

The specification of the for_each algorithm does not have a "Requires" section, which means that there are no restrictions imposed on the function object whatsoever. In essence it means that I can provide any function object with arbitrary side effects and I can still expect a predictable result. In particular I can expect that the function object is applied exactly last - first times, which is promised in the "Complexity" section.

I don't see how any implementation can give such a guarantee without imposing requirements on the function object.

Just as an example: consider a function object that removes elements from the input sequence. In that case, what does the complexity guarantee (applies f exactly last - first times) mean?

One can argue that this is obviously a nonsensical application and a theoretical case, which unfortunately it isn't. I have seen programmers shooting themselves in the foot this way, and they did not understand that there are restrictions even if the description of the algorithm does not say so.

[Lillehammer: This is more general than for_each. We don't want the function object in transform invalidiating iterators either. There should be a note somewhere in clause 17 (17, not 25) saying that user code operating on a range may not invalidate iterators unless otherwise specified. Bill will provide wording.]

[ 2009-07 Frankfurt ]

Moved to NAD.

It was felt that the current description is adequate, and that there are limits to what the standard can reasonably say to prohibit perverse uses of the library.

Proposed resolution:


293(i). Order of execution in transform algorithm

Section: 26.7.4 [alg.transform] Status: NAD Submitter: Angelika Langer Opened: 2001-01-04 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [alg.transform].

View all issues with NAD status.

Discussion:

This issue is related to issue 242. In case that the resolution proposed for issue 242 is accepted, we have have the following situation: The 4 numeric algorithms (accumulate and consorts) as well as transform would allow a certain category of side effects. The numeric algorithms specify that they invoke the functor "for every iterator i in the range [first, last) in order". transform, in contrast, would not give any guarantee regarding order of invocation of the functor, which means that the functor can be invoked in any arbitrary order.

Why would that be a problem? Consider an example: say the transformator that is a simple enumerator ( or more generally speaking, "is order-sensitive" ). Since a standard compliant implementation of transform is free to invoke the enumerator in no definite order, the result could be a garbled enumeration. Strictly speaking this is not a problem, but it is certainly at odds with the prevalent understanding of transform as an algorithms that assigns "a new _corresponding_ value" to the output elements.

All implementations that I know of invoke the transformator in definite order, namely starting from first and proceeding to last - 1. Unless there is an optimization conceivable that takes advantage of the indefinite order I would suggest to specify the order, because it eliminate the uncertainty that users would otherwise have regarding the order of execution of their potentially order-sensitive function objects.

Proposed resolution:

In section 25.2.3 - Transform [lib.alg.transform] change:

-1- Effects: Assigns through every iterator i in the range [result, result + (last1 - first1)) a new corresponding value equal to op(*(first1 + (i - result)) or binary_op(*(first1 + (i - result), *(first2 + (i - result))).

to:

-1- Effects: Computes values by invoking the operation op or binary_op for every iterator in the range [first1, last1) in order. Assigns through every iterator i in the range [result, result + (last1 - first1)) a new corresponding value equal to op(*(first1 + (i - result)) or binary_op(*(first1 + (i - result), *(first2 + (i - result))).

Rationale:

For Input Iterators an order is already guaranteed, because only one order is possible. If a user who passes a Forward Iterator to one of these algorithms really needs a specific order of execution, it's possible to achieve that effect by wrapping it in an Input Iterator adaptor.


299(i). Incorrect return types for iterator dereference

Section: 24.3.5.6 [bidirectional.iterators], 24.3.5.7 [random.access.iterators] Status: NAD Editorial Submitter: John Potter Opened: 2001-01-22 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [bidirectional.iterators].

View all issues with NAD Editorial status.

Discussion:

In section 24.3.5.6 [bidirectional.iterators], Table 75 gives the return type of *r-- as convertible to T. This is not consistent with Table 74 which gives the return type of *r++ as T&. *r++ = t is valid while *r-- = t is invalid.

In section 24.3.5.7 [random.access.iterators], Table 76 gives the return type of a[n] as convertible to T. This is not consistent with the semantics of *(a + n) which returns T& by Table 74. *(a + n) = t is valid while a[n] = t is invalid.

Discussion from the Copenhagen meeting: the first part is uncontroversial. The second part, operator[] for Random Access Iterators, requires more thought. There are reasonable arguments on both sides. Return by value from operator[] enables some potentially useful iterators, e.g. a random access "iota iterator" (a.k.a "counting iterator" or "int iterator"). There isn't any obvious way to do this with return-by-reference, since the reference would be to a temporary. On the other hand, reverse_iterator takes an arbitrary Random Access Iterator as template argument, and its operator[] returns by reference. If we decided that the return type in Table 76 was correct, we would have to change reverse_iterator. This change would probably affect user code.

History: the contradiction between reverse_iterator and the Random Access Iterator requirements has been present from an early stage. In both the STL proposal adopted by the committee (N0527==94-0140) and the STL technical report (HPL-95-11 (R.1), by Stepanov and Lee), the Random Access Iterator requirements say that operator[]'s return value is "convertible to T". In N0527 reverse_iterator's operator[] returns by value, but in HPL-95-11 (R.1), and in the STL implementation that HP released to the public, reverse_iterator's operator[] returns by reference. In 1995, the standard was amended to reflect the contents of HPL-95-11 (R.1). The original intent for operator[] is unclear.

In the long term it may be desirable to add more fine-grained iterator requirements, so that access method and traversal strategy can be decoupled. (See "Improved Iterator Categories and Requirements", N1297 = 01-0011, by Jeremy Siek.) Any decisions about issue 299 should keep this possibility in mind.

Further discussion: I propose a compromise between John Potter's resolution, which requires T& as the return type of a[n], and the current wording, which requires convertible to T. The compromise is to keep the convertible to T for the return type of the expression a[n], but to also add a[n] = t as a valid expression. This compromise "saves" the common case uses of random access iterators, while at the same time allowing iterators such as counting iterator and caching file iterators to remain random access iterators (iterators where the lifetime of the object returned by operator*() is tied to the lifetime of the iterator).

Note that the compromise resolution necessitates a change to reverse_iterator. It would need to use a proxy to support a[n] = t.

Note also there is one kind of mutable random access iterator that will no longer meet the new requirements. Currently, iterators that return an r-value from operator[] meet the requirements for a mutable random access iterator, even though the expression a[n] = t will only modify a temporary that goes away. With this proposed resolution, a[n] = t will be required to have the same operational semantics as *(a + n) = t.

[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]

[ 2009-09-18 Alisdair adds: ]

Why can't we write through the reference returned from operator[] on a random access iterator?

Recommended solution:

In table Table 104 — Random access iterator requirements, replace

a[n] : convertible to const T & T& if X is mutable, otherwise convertible to const T&

[ 2009-10 Santa Cruz: ]

Leave Open. Alisdair to spearhead a paper on revivification.

[ 2010 Pittsburgh: Moved to NAD Editorial. Rationale added below. ]

Rationale:

Solved by N3066.

Proposed resolution:

In section 24.1.4 [lib.bidirectdional.iterators], change the return type in table 75 from "convertible to T" to T&.

In section 24.1.5 [lib.random.access.iterators], change the operational semantics for a[n] to " the r-value of a[n] is equivalent to the r-value of *(a + n)". Add a new row in the table for the expression a[n] = t with a return type of convertible to T and operational semantics of *(a + n) = t.

[Lillehammer: Real problem, but should be addressed as part of iterator redesign]

Rationale:

[ San Francisco: ]

Solved by N2758.


302(i). Need error indication from codecvt<>::do_length

Section: 28.3.4.2.6 [locale.codecvt.byname] Status: NAD Submitter: Gregory Bumgardner Opened: 2001-01-25 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.codecvt.byname].

View all issues with NAD status.

Discussion:

The effects of codecvt<>::do_length() are described in 22.2.1.5.2, paragraph 10. As implied by that paragraph, and clarified in issue 75(i), codecvt<>::do_length() must process the source data and update the stateT argument just as if the data had been processed by codecvt<>::in(). However, the standard does not specify how do_length() would report a translation failure, should the source sequence contain untranslatable or illegal character sequences.

The other conversion methods return an "error" result value to indicate that an untranslatable character has been encountered, but do_length() already has a return value (the number of source characters that have been processed by the method).

Proposed resolution:

This issue cannot be resolved without modifying the interface. An exception cannot be used, as there would be no way to determine how many characters have been processed and the state object would be left in an indeterminate state.

A source compatible solution involves adding a fifth argument to length() and do_length() that could be used to return position of the offending character sequence. This argument would have a default value that would allow it to be ignored:

  int length(stateT& state, 
             const externT* from, 
             const externT* from_end, 
             size_t max,
             const externT** from_next = 0);

  virtual
  int do_length(stateT& state, 
                const externT* from, 
                const externT* from_end, 
                size_t max,
                const externT** from_next);

Then an exception could be used to report any translation errors and the from_next argument, if used, could then be used to retrieve the location of the offending character sequence.

Rationale:

The standard is already clear: the return value is the number of "valid complete characters". If it encounters an invalid sequence of external characters, it stops.


304(i). Must *a return an lvalue when a is an input iterator?

Section: 24.3.4 [iterator.concepts] Status: NAD Submitter: Dave Abrahams Opened: 2001-02-05 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [iterator.concepts].

View all issues with NAD status.

Discussion:

We all "know" that input iterators are allowed to produce values when dereferenced of which there is no other in-memory copy.

But: Table 72, with a careful reading, seems to imply that this can only be the case if the value_type has no members (e.g. is a built-in type).

The problem occurs in the following entry:

  a->m     pre: (*a).m is well-defined
           Equivalent to (*a).m

*a.m can be well-defined if *a is not a reference type, but since operator->() must return a pointer for a->m to be well-formed, it needs something to return a pointer to. This seems to indicate that *a must be buffered somewhere to make a legal input iterator.

I don't think this was intentional.

Rationale:

The current standard is clear and consistent. Input iterators that return rvalues are in fact implementable. They may in some cases require extra work, but it is still possible to define an operator-> in such cases: it doesn't have to return a T*, but may return a proxy type. No change to the standard is justified.


309(i). Does sentry catch exceptions?

Section: 31.7 [iostream.format] Status: NAD Submitter: Martin Sebor Opened: 2001-03-19 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [iostream.format].

View all issues with NAD status.

Discussion:

The descriptions of the constructors of basic_istream<>::sentry ( [istream::sentry]) and basic_ostream<>::sentry ( [ostream::sentry]) do not explain what the functions do in case an exception is thrown while they execute. Some current implementations allow all exceptions to propagate, others catch them and set ios_base::badbit instead, still others catch some but let others propagate.

The text also mentions that the functions may call setstate(failbit) (without actually saying on what object, but presumably the stream argument is meant). That may have been fine for basic_istream<>::sentry prior to issue 195(i), since the function performs an input operation which may fail. However, issue 195(i) amends [istream::sentry], p2 to clarify that the function should actually call setstate(failbit | eofbit), so the sentence in p3 is redundant or even somewhat contradictory.

The same sentence that appears in [ostream::sentry], p3 doesn't seem to be very meaningful for basic_istream<>::sentry which performs no input. It is actually rather misleading since it would appear to guide library implementers to calling setstate(failbit) when os.tie()->flush(), the only called function, throws an exception (typically, it's badbit that's set in response to such an event).

Additional comments from Martin, who isn't comfortable with the current proposed resolution (see c++std-lib-11530)

The istream::sentry ctor says nothing about how the function deals with exemptions (27.6.1.1.2, p1 says that the class is responsible for doing "exception safe"(*) prefix and suffix operations but it doesn't explain what level of exception safety the class promises to provide). The mockup example of a "typical implementation of the sentry ctor" given in 27.6.1.1.2, p6, removed in ISO/IEC 14882:2003, doesn't show exception handling, either. Since the ctor is not classified as a formatted or unformatted input function, the text in 27.6.1.1, p1 through p4 does not apply. All this would seem to suggest that the sentry ctor should not catch or in any way handle exceptions thrown from any functions it may call. Thus, the typical implementation of an istream extractor may look something like [1].

The problem with [1] is that while it correctly sets ios::badbit if an exception is thrown from one of the functions called from the sentry ctor, if the sentry ctor reaches EOF while extracting whitespace from a stream that has eofbit or failbit set in exceptions(), it will cause an ios::failure to be thrown, which will in turn cause the extractor to set ios::badbit.

The only straightforward way to prevent this behavior is to move the definition of the sentry object in the extractor above the try block (as suggested by the example in 22.2.8, p9 and also indirectly supported by 27.6.1.3, p1). See [2]. But such an implementation will allow exceptions thrown from functions called from the ctor to freely propagate to the caller regardless of the setting of ios::badbit in the stream object's exceptions().

So since neither [1] nor [2] behaves as expected, the only possible solution is to have the sentry ctor catch exceptions thrown from called functions, set badbit, and propagate those exceptions if badbit is also set in exceptions(). (Another solution exists that deals with both kinds of sentries, but the code is non-obvious and cumbersome -- see [3].)

Please note that, as the issue points out, current libraries do not behave consistently, suggesting that implementors are not quite clear on the exception handling in istream::sentry, despite the fact that some LWG members might feel otherwise. (As documented by the parenthetical comment here: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1480.html#309)

Also please note that those LWG members who in Copenhagen felt that "a sentry's constructor should not catch exceptions, because sentries should only be used within (un)formatted input functions and that exception handling is the responsibility of those functions, not of the sentries," as noted here http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2001/n1310.html#309 would in effect be either arguing for the behavior described in [1] or for extractors implemented along the lines of [3].

The original proposed resolution (Revision 25 of the issues list) clarifies the role of the sentry ctor WRT exception handling by making it clear that extractors (both library or user-defined) should be implemented along the lines of [2] (as opposed to [1]) and that no exception thrown from the callees should propagate out of either function unless badbit is also set in exceptions().

[1] Extractor that catches exceptions thrown from sentry:

struct S { long i; };

istream& operator>> (istream &strm, S &s)
{
    ios::iostate err = ios::goodbit;
    try {
        const istream::sentry guard (strm, false);
        if (guard) {
            use_facet<num_get<char> >(strm.getloc ())
                .get (istreambuf_iterator<char>(strm),
                      istreambuf_iterator<char>(),
                      strm, err, s.i);
        }
    }
    catch (...) {
        bool rethrow;
        try {
            strm.setstate (ios::badbit);
            rethrow = false;
        }
        catch (...) {
            rethrow = true;
        }
        if (rethrow)
            throw;
    }
    if (err)
        strm.setstate (err);
    return strm;
}

[2] Extractor that propagates exceptions thrown from sentry:

istream& operator>> (istream &strm, S &s)
{
    istream::sentry guard (strm, false);
    if (guard) {
        ios::iostate err = ios::goodbit;
        try {
            use_facet<num_get<char> >(strm.getloc ())
                .get (istreambuf_iterator<char>(strm),
                      istreambuf_iterator<char>(),
                      strm, err, s.i);
        }
        catch (...) {
            bool rethrow;
            try {
                strm.setstate (ios::badbit);
                rethrow = false;
            }
            catch (...) {
                rethrow = true;
            }
            if (rethrow)
                throw;
        }
        if (err)
            strm.setstate (err);
    }
    return strm;
}

[3] Extractor that catches exceptions thrown from sentry but doesn't set badbit if the exception was thrown as a result of a call to strm.clear().

istream& operator>> (istream &strm, S &s)
{
    const ios::iostate state = strm.rdstate ();
    const ios::iostate except = strm.exceptions ();
    ios::iostate err = std::ios::goodbit;
    bool thrown = true;
    try {
        const istream::sentry guard (strm, false);
        thrown = false;
        if (guard) {
            use_facet<num_get<char> >(strm.getloc ())
                .get (istreambuf_iterator<char>(strm),
                      istreambuf_iterator<char>(),
                      strm, err, s.i);
        }
    }
    catch (...) {
        if (thrown && state & except)
            throw;
        try {
            strm.setstate (ios::badbit);
            thrown = false;
        }
        catch (...) {
            thrown = true;
        }
        if (thrown)
            throw;
    }
    if (err)
        strm.setstate (err);

    return strm;
}

[Pre-Berlin] Reopened at the request of Paolo Carlini and Steve Clamage.

[Pre-Portland] A relevant newsgroup post:

The current proposed resolution of issue #309 is unacceptable. I write commerical software and coding around this makes my code ugly, non-intuitive, and requires comments referring people to this very issue. Following is the full explanation of my experience.

In the course of writing software for commercial use, I constructed std::ifstream's based on user-supplied pathnames on typical POSIX systems.

It was expected that some files that opened successfully might not read successfully -- such as a pathname which actually refered to a directory. Intuitively, I expected the streambuffer underflow() code to throw an exception in this situation, and recent implementations of libstdc++'s basic_filebuf do just that (as well as many of my own custom streambufs).

I also intuitively expected that the istream code would convert these exceptions to the "badbit' set on the stream object, because I had not requested exceptions. I refer to 27.6.1.1. P4.

However, this was not the case on at least two implementations -- if the first thing I did with an istream was call operator>>( T& ) for T among the basic arithmetic types and std::string. Looking further I found that the sentry's constructor was invoking the exception when it pre-scanned for whitespace, and the extractor function (operator>>()) was not catching exceptions in this situation.

So, I was in a situation where setting 'noskipws' would change the istream's behavior even though no characters (whitespace or not) could ever be successfully read.

Also, calling .peek() on the istream before calling the extractor() changed the behavior (.peek() had the effect of setting the badbit ahead of time).

I found this all to be so inconsistent and inconvenient for me and my code design, that I filed a bugzilla entry for libstdc++. I was then told that the bug cannot be fixed until issue #309 is resolved by the committee.

[ 2009-07 Frankfurt ]

Moved to NAD.

See the rationale in the issue. Paolo, who requested that the issue be reopened, agreed with the rationale.

Proposed resolution:

Rationale:

The LWG agrees there is minor variation between implementations, but believes that it doesn't matter. This is a rarely used corner case. There is no evidence that this has any commercial importance or that it causes actual portability problems for customers trying to write code that runs on multiple implementations.


313(i). set_terminate and set_unexpected question

Section: 17.9.5.4 [terminate] Status: NAD Submitter: Judy Ward Opened: 2001-04-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [terminate].

View all issues with NAD status.

Discussion:

According to section 18.7.3.3 of the standard, std::terminate() is supposed to call the terminate_handler in effect immediately after evaluating the throw expression.

Question: what if the terminate_handler in effect is itself std::terminate?

For example:

  #include <exception>

  int main () {
      std::set_terminate(std::terminate);
      throw 5;
      return 0;
  }

Is the implementation allowed to go into an infinite loop?

I think the same issue applies to std::set_unexpected.

Proposed resolution:

Rationale:

Infinite recursion is to be expected: users who set the terminate handler to terminate are explicitly asking for terminate to call itself.


314(i). Is the stack unwound when terminate() is called?

Section: 17.9.5.4 [terminate] Status: NAD Submitter: Detlef Vollmann Opened: 2001-04-11 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [terminate].

View all issues with NAD status.

Discussion:

The standard appears to contradict itself about whether the stack is unwound when the implementation calls terminate().

From 18.7.3.3p2:

Calls the terminate_handler function in effect immediately after evaluating the throw-expression (lib.terminate.handler), if called by the implementation [...]

So the stack is guaranteed not to be unwound.

But from 15.3p9:

[...]whether or not the stack is unwound before this call to terminate() is implementation-defined (except.terminate).

And 15.5.1 actually defines that in most cases the stack is unwound.

Proposed resolution:

Rationale:

There is definitely no contradiction between the core and library clauses; nothing in the core clauses says that stack unwinding happens after terminate is called. 18.7.3.3p2 does not say anything about when terminate() is called; it merely specifies which terminate_handler is used.


323(i). abs() overloads in different headers

Section: 29.7 [c.math] Status: NAD Submitter: Dave Abrahams Opened: 2001-06-04 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [c.math].

View all issues with NAD status.

Discussion:

Currently the standard mandates the following overloads of abs():

    abs(long), abs(int) in <cstdlib>

    abs(float), abs(double), abs(long double) in <cmath>

    template<class T> T abs(const complex<T>&) in <complex>

    template<class T> valarray<T> abs(const valarray<T>&); in <valarray>

The problem is that having only some overloads visible of a function that works on "implicitly inter-convertible" types is dangerous in practice. The headers that get included at any point in a translation unit can change unpredictably during program development/maintenance. The wrong overload might be unintentionally selected.

Currently, there is nothing that mandates the simultaneous visibility of these overloads. Indeed, some vendors have begun fastidiously reducing dependencies among their (public) headers as a QOI issue: it helps people to write portable code by refusing to compile unless all the correct headers are #included.

The same issue may exist for other functions in the library.

Redmond: PJP reports that C99 adds two new kinds of abs: complex, and int_max_abs.

Related issue: 343(i).

[ Bellevue: ]

The situation is not sufficiently severe to warrant a change.

Rationale:

The programs that could potentially be broken by this situation are already fragile, and somewhat contrived: For example, a user-defined class that has conversion overloads both to long and to float. If x is a value of such a class, then abs(x) would give the long version if the user included <cstdlib>, the float version if the user included <cmath>, and would be diagnosed as ambiguous at compile time if the user included both headers. The LWG couldn't find an example of a program whose meaning would be changed (as opposed to changing it from well-formed to ill-formed) simply by adding another standard header.

Since the harm seems minimal, and there don't seem to be any simple and noninvasive solutions, this is being closed as NAD. It is marked as "Future" for two reasons. First, it might be useful to define an <all> header that would include all Standard Library headers. Second, we should at least make sure that future library extensions don't make this problem worse.


326(i). Missing typedef in moneypunct_byname

Section: 28.3.4.7.5 [locale.moneypunct.byname] Status: NAD Submitter: Martin Sebor Opened: 2001-07-05 Last modified: 2016-01-28

Priority: Not Prioritized

View all issues with NAD status.

Discussion:

The definition of the moneypunct facet contains the typedefs char_type and string_type. Only one of these names, string_type, is defined in the derived facet, moneypunct_byname.

Proposed resolution:

For consistency with the numpunct facet, add a typedef for char_type to the definition of the moneypunct_byname facet in 28.3.4.7.5 [locale.moneypunct.byname].

Rationale:

The absence of the typedef is irrelevant. Users can still access the typedef, because it is inherited from the base class.


330(i). Misleading "exposition only" value in class locale definition

Section: 28.3.3.1 [locale] Status: NAD Submitter: Martin Sebor Opened: 2001-07-15 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale].

View all issues with NAD status.

Discussion:

The "exposition only" value of the std::locale::none constant shown in the definition of class locale is misleading in that it on many systems conflicts with the value assigned to one if the LC_XXX constants (specifically, LC_COLLATE on AIX, LC_ALL on HP-UX, LC_CTYPE on Linux and SunOS). This causes incorrect behavior when such a constant is passed to one of the locale member functions that accept a locale::category argument and interpret it as either the C LC_XXX constant or a bitmap of locale::category values. At least three major implementations adopt the suggested value without a change and consequently suffer from this problem.

For instance, the following code will (presumably) incorrectly copy facets belonging to the collate category from the German locale on AIX:

  std::locale l (std::locale ("C"), "de_DE", std::locale::none);

Rationale:

The LWG agrees that it may be difficult to implement locale member functions in such a way that they can take either category arguments or the LC_ constants defined in <cctype>. In light of this requirement (28.3.3.1.2.1 [locale.category], paragraph 2), and in light of the requirement in the preceding paragraph that it is possible to combine category bitmask elements with bitwise operations, defining the category elements is delicate, particularly if an implementor is constrained to work with a preexisting C library. (Just using the existing LC_ constants would not work in general.) There's no set of "exposition only" values that could give library implementors proper guidance in such a delicate matter. The non-normative example we're giving is no worse than any other choice would be.

See issue 347(i).


332(i). Consider adding increment and decrement operators to std::fpos< T >

Section: 31.5.3 [fpos] Status: NAD Submitter: PremAnand M. Rao Opened: 2001-08-27 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [fpos].

View all issues with NAD status.

Discussion:

Increment and decrement operators are missing from Table 88 -- Position type requirements in 31.5.3 [fpos].

Proposed resolution:

Table 88 (section 27.4.3) -- Position type requirements be updated to include increment and decrement operators.

expression        return type     operational    note

++p               fpos&           p += O(1)
p++               fpos            { P tmp = p;
                                    ++p;
                                    return tmp; }
--p               fpos&           p -= O(1)
p--               fpos            { P tmp = p;
                                    --p;
                                    return tmp; }

Rationale:

The LWG believes this is a request for extension, not a defect report. Additionally, nobody saw a clear need for this extension; fpos is used only in very limited ways.


342(i). seek and eofbit

Section: 31.7.5.4 [istream.unformatted] Status: NAD Submitter: Howard Hinnant Opened: 2001-10-09 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [istream.unformatted].

View all issues with NAD status.

Discussion:

I think we have a defect.

According to lwg issue 60(i) which is now a dr, the description of seekg in 31.7.5.4 [istream.unformatted] paragraph 38 now looks like:

Behaves as an unformatted input function (as described in 27.6.1.3, paragraph 1), except that it does not count the number of characters extracted and does not affect the value returned by subsequent calls to gcount(). After constructing a sentry object, if fail() != true, executes rdbuf()->pubseekpos( pos).

And according to lwg issue 243(i) which is also now a dr, 27.6.1.3, paragraph 1 looks like:

Each unformatted input function begins execution by constructing an object of class sentry with the default argument noskipws (second) argument true. If the sentry object returns true, when converted to a value of type bool, the function endeavors to obtain the requested input. Otherwise, if the sentry constructor exits by throwing an exception or if the sentry object returns false, when converted to a value of type bool, the function returns without attempting to obtain any input. In either case the number of extracted characters is set to 0; unformatted input functions taking a character array of non-zero size as an argument shall also store a null character (using charT()) in the first location of the array. If an exception is thrown during input then ios::badbit is turned on in *this'ss error state. If (exception()&badbit)!= 0 then the exception is rethrown. It also counts the number of characters extracted. If no exception has been thrown it ends by storing the count in a member object and returning the value specified. In any event the sentry object is destroyed before leaving the unformatted input function.

And finally 27.6.1.1.2/5 says this about sentry:

If, after any preparation is completed, is.good() is true, ok_ != false otherwise, ok_ == false.

So although the seekg paragraph says that the operation proceeds if !fail(), the behavior of unformatted functions says the operation proceeds only if good(). The two statements are contradictory when only eofbit is set. I don't think the current text is clear which condition should be respected.

Further discussion from Redmond:

PJP: It doesn't seem quite right to say that seekg is "unformatted". That makes specific claims about sentry that aren't quite appropriate for seeking, which has less fragile failure modes than actual input. If we do really mean that it's unformatted input, it should behave the same way as other unformatted input. On the other hand, "principle of least surprise" is that seeking from EOF ought to be OK.

Pre-Berlin: Paolo points out several problems with the proposed resolution in Ready state:

[ 2009-07 Frankfurt ]

Moved to NAD. Will reopen if proposed resolution is supplied.

Proposed resolution:

Change 31.7.5.4 [istream.unformatted] to:

Behaves as an unformatted input function (as described in 27.6.1.3, paragraph 1), except that it does not count the number of characters extracted, does not affect the value returned by subsequent calls to gcount(), and does not examine the value returned by the sentry object. After constructing a sentry object, if fail() != true, executes rdbuf()->pubseekpos(pos). In case of success, the function calls clear(). In case of failure, the function calls setstate(failbit) (which may throw ios_base::failure).

[Lillehammer: Matt provided wording.]

Rationale:

In C, fseek does clear EOF. This is probably what most users would expect. We agree that having eofbit set should not deter a seek, and that a successful seek should clear eofbit. Note that fail() is true only if failbit or badbit is set, so using !fail(), rather than good(), satisfies this goal.


344(i). grouping + showbase

Section: 28.3.4.3 [category.numeric] Status: NAD Submitter: Howard Hinnant Opened: 2001-10-13 Last modified: 2016-01-28

Priority: Not Prioritized

View all issues with NAD status.

Discussion:

When both grouping and showbase are active and the basefield is octal, does the leading 0 participate in the grouping or not? For example, should one format as: 0,123,456 or 0123,456?

An analogy can be drawn with hexadecimal. It appears that 0x123,456 is preferred over 0x,123,456. However, this analogy is not universally accepted to apply to the octal base. The standard is not clear on how to format (or parse) in this manner.

Proposed resolution:

Insert into 28.3.4.4.1.3 [facet.numpunct.virtuals] paragraph 3, just before the last sentence:

The leading hexadecimal base specifier "0x" does not participate in grouping. The leading '0' octal base specifier may participate in grouping. It is unspecified if the leading '0' participates in formatting octal numbers. In parsing octal numbers, the implementation is encouraged to accept both the leading '0' participating in the grouping, and not participating (e.g. 0123,456 or 0,123,456).

Rationale:

The current behavior may be unspecified, but it's not clear that it matters. This is an obscure corner case, since grouping is usually intended for the benefit of humans and oct/hex prefixes are usually intended for the benefit of machines. There is not a strong enough consensus in the LWG for action.


348(i). Minor issue with std::pair operator<

Section: 22.3 [pairs] Status: Dup Submitter: Andy Sawyer Opened: 2001-10-23 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [pairs].

View all issues with Dup status.

Duplicate of: 532

Discussion:

The current wording of 20.2.2 [lib.pairs] p6 precludes the use of operator< on any pair type which contains a pointer.

Proposed resolution:

In 22.3 [pairs] paragraph 6, replace:

    Returns: x.first < y.first || (!(y.first < x.first) && x.second <
        y.second).

With:

    Returns: std::less<T1>()( x.first, y.first ) ||
             (!std::less<T1>()( y.first, x.first) && 
             std::less<T2>()( x.second, y.second ) )

Rationale:

This is an instance of a much more general problem. If we want operator< to translate to std::less for pairs of pointers, where do we draw the line? The same issue applies to individual pointers, smart pointer wrappers, std::vector<T*>, and so on.

Andy Koenig suggests that the real issue here is that we aren't distinguishing adequately between two different orderings, a "useful ordering" and a "canonical ordering" that's used just because we sometimes need some ordering without caring much which ordering it is. Another example of the later is typeinfo's before.


350(i). allocator<>::address

Section: 20.2.10.2 [allocator.members], 16.4.4.6 [allocator.requirements], 16.4.2.2 [contents] Status: Dup Submitter: Nathan Myers Opened: 2001-10-25 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [allocator.members].

View all issues with Dup status.

Duplicate of: 634

Discussion:

See c++std-lib-9006 and c++std-lib-9007. This issue is taken verbatim from -9007.

The core language feature allowing definition of operator&() applied to any non-builtin type makes that operator often unsafe to use in implementing libraries, including the Standard Library. The result is that many library facilities fail for legal user code, such as the fragment

  class A { private: A* operator&(); };
  std::vector<A> aa;

  class B { };
  B* operator&(B&) { return 0; }
  std::vector<B> ba;

In particular, the requirements table for Allocator (Table 32) specifies no semantics at all for member address(), and allocator<>::address is defined in terms of unadorned operator &.

Proposed resolution:

In 20.6.1.1, Change the definition of allocator<>::address from:

Returns: &x

to:

Returns: The value that the built in operator&(x) would return if not overloaded.

In 20.1.6, Table 32, add to the Notes column of the a.address(r) and a.address(s) lines, respectively:

  allocator<T>::address(r)
  allocator<T>::address(s)

In addition, in clause 17.4.1.1, add a statement:

The Standard Library does not apply operator& to any type for which operator& may be overloaded.

Rationale:

The LWG believes both examples are ill-formed. The contained type is required to be CopyConstructible (16.4.4.2 [utility.arg.requirements]), and that includes the requirement that &t return the usual types and values. Since allocators are intended to be used in conjunction with containers, and since the CopyConstructible requirements appear to have been written to deal with the concerns of this issue, the LWG feels it is NAD unless someone can come up with a well-formed example exhibiting a problem.

It may well be that the CopyConstructible requirements are too restrictive and that either the container requirements or the CopyConstructive requirements should be relaxed, but that's a far larger issue. Marking this issue as "future" as a pointer to that larger issue.


351(i). unary_negate and binary_negate: struct or class?

Section: 22.10 [function.objects] Status: NAD Editorial Submitter: Dale Riley Opened: 2001-11-12 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [function.objects].

View all issues with NAD Editorial status.

Discussion:

In 22.10 [function.objects] the header <functional> synopsis declares the unary_negate and binary_negate function objects as struct. However in [negators] the unary_negate and binary_negate function objects are defined as class. Given the context, they are not "basic function objects" like negate, so this is either a typo or an editorial oversight.

[Taken from comp.std.c++]

Proposed resolution:

Change the synopsis to reflect the useage in [negators]

[Curaçao: Since the language permits "struct", the LWG views this as NAD. They suggest, however, that the Project Editor might wish to make the change as editorial.]


356(i). Meaning of ctype_base::mask enumerators

Section: 28.3.4.2 [category.ctype] Status: NAD Submitter: Matt Austern Opened: 2002-01-23 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [category.ctype].

View all issues with NAD status.

Discussion:

What should the following program print?

  #include <locale>
  #include <iostream>

  class my_ctype : public std::ctype<char>
  {
    typedef std::ctype<char> base;
  public:
    my_ctype(std::size_t refs = 0) : base(my_table, false, refs)
    {
      std::copy(base::classic_table(), base::classic_table() + base::table_size,
                my_table);
      my_table[(unsigned char) '_'] = (base::mask) (base::print | base::space);
    }
  private:
    mask my_table[base::table_size];
  };

  int main()
  {
    my_ctype ct;
    std::cout << "isspace: " << ct.is(std::ctype_base::space, '_') << "    "
              << "isalpha: " << ct.is(std::ctype_base::alpha, '_') << std::endl;
  }

The goal is to create a facet where '_' is treated as whitespace.

On gcc 3.0, this program prints "isspace: 1 isalpha: 0". On Microsoft C++ it prints "isspace: 1 isalpha: 1".

I believe that both implementations are legal, and the standard does not give enough guidance for users to be able to use std::ctype's protected interface portably.

The above program assumes that ctype_base::mask enumerators like space and print are disjoint, and that the way to say that a character is both a space and a printing character is to or those two enumerators together. This is suggested by the "exposition only" values in 28.3.4.2 [category.ctype], but it is nowhere specified in normative text. An alternative interpretation is that the more specific categories subsume the less specific. The above program gives the results it does on the Microsoft compiler because, on that compiler, print has all the bits set for each specific printing character class.

From the point of view of std::ctype's public interface, there's no important difference between these two techniques. From the point of view of the protected interface, there is. If I'm defining a facet that inherits from std::ctype<char>, I'm the one who defines the value that table()['a'] returns. I need to know what combination of mask values I should use. This isn't so very esoteric: it's exactly why std::ctype has a protected interface. If we care about users being able to write their own ctype facets, we have to give them a portable way to do it.

Related reflector messages: lib-9224, lib-9226, lib-9229, lib-9270, lib-9272, lib-9273, lib-9274, lib-9277, lib-9279.

Issue 339(i) is related, but not identical. The proposed resolution if issue 339(i) says that ctype_base::mask must be a bitmask type. It does not say that the ctype_base::mask elements are bitmask elements, so it doesn't directly affect this issue.

More comments from Benjamin Kosnik, who believes that that C99 compatibility essentially requires what we're calling option 1 below.

I think the C99 standard is clear, that isspace -> !isalpha.
--------

#include <locale>
#include <iostream>

class my_ctype : public std::ctype<char>
{
private:
  typedef std::ctype<char> base;
  mask my_table[base::table_size];

public:
  my_ctype(std::size_t refs = 0) : base(my_table, false, refs)
  {
    std::copy(base::classic_table(), base::classic_table() + base::table_size,
              my_table);
    mask both = base::print | base::space;
    my_table[static_cast<mask>('_')] = both;
  }
};

int main()
{
  using namespace std;
  my_ctype ct;
  cout << "isspace: " << ct.is(ctype_base::space, '_') << endl;
  cout << "isprint: " << ct.is(ctype_base::print, '_') << endl;

  // ISO C99, isalpha iff upper | lower set, and !space.
  // 7.5, p 193
  // -> looks like g++ behavior is correct.
  // 356 -> bitmask elements are required for ctype_base
  // 339 -> bitmask type required for mask
  cout << "isalpha: " << ct.is(ctype_base::alpha, '_') << endl;
}

Proposed resolution:

Informally, we have three choices:

  1. Require that the enumerators are disjoint (except for alnum and graph)
  2. Require that the enumerators are not disjoint, and specify which of them subsume which others. (e.g. mandate that lower includes alpha and print)
  3. Explicitly leave this unspecified, which the result that the above program is not portable.

Either of the first two options is just as good from the standpoint of portability. Either one will require some implementations to change.

Rationale:

The LWG agrees that this is a real ambiguity, and that both interpretations are conforming under the existing standard. However, there's no evidence that it's causing problems for real users. Users who want to define ctype facets portably can test the ctype_base masks to see which interpretation is being used.


357(i). <cmath> float functions cannot return HUGE_VAL

Section: 29.7 [c.math] Status: NAD Editorial Submitter: Ray Lischner Opened: 2002-02-26 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [c.math].

View all issues with NAD Editorial status.

Discussion:

The float versions of the math functions have no meaningful value to return for a range error. The long double versions have a value they can return, but it isn't necessarily the most reasonable value.

Section 26.5 [lib.c.math], paragraph 5, says that C++ "adds float and long double overloaded versions of these functions, with the same semantics," referring to the math functions from the C90 standard.

The C90 standard, in section 7.5.1, paragraph 3, says that functions return "the value of the macro HUGE_VAL" when they encounter a range error. Section 7.5, paragraph 2, defines HUGE_VAL as a macro that "expands to a positive double expression, not necessarily representable as a float."

Therefore, the float versions of the math functions have no way to signal a range error. [Curaçao: The LWG notes that this isn't strictly correct, since errno is set.] The semantics require that they return HUGE_VAL, but they cannot because HUGE_VAL might not be representable as a float.

The problem with long double functions is less severe because HUGE_VAL is representable as a long double. On the other hand, it might not be a "huge" long double value, and might fall well within the range of normal return values for a long double function. Therefore, it does not make sense for a long double function to return a double (HUGE_VAL) for a range error.

Proposed resolution:

Curaçao: C99 was faced with a similar problem, which they fixed by adding HUGE_VALF and HUGE_VALL in addition to HUGE_VAL.

C++ must also fix, but it should be done in the context of the general C99 based changes to C++, not via DR. Thus the LWG in Curaçao felt the resolution should be NAD, FUTURE, but the issue is being held open for one more meeting to ensure LWG members not present during the discussion concur.

Rationale:

Will be fixed as part of more general work in the TR.


361(i). num_get<>::do_get (..., void*&) checks grouping

Section: 28.3.4.3.3.3 [facet.num.put.virtuals] Status: NAD Submitter: Martin Sebor Opened: 2002-03-12 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [facet.num.put.virtuals].

View all other issues in [facet.num.put.virtuals].

View all issues with NAD status.

Discussion:

22.2.2.2.2, p12 specifies that thousands_sep is to be inserted only for integral types (issue 282 suggests that this should be done for all arithmetic types).

22.2.2.1.2, p12 requires that grouping be checked for all extractors including that for void*.

I don't think that's right. void* values should not be checked for grouping, should they? (Although if they should, then num_put needs to write them out, otherwise their extraction will fail.)

Proposed resolution:

Change the first sentence of 22.2.2.2.2, p12 from

Digit grouping is checked. That is, the positions of discarded separators is examined for consistency with use_facet<numpunct<charT> >(loc).grouping(). If they are not consistent then ios_base::failbit is assigned to err.

to

Except for conversions to void*, digit grouping is checked...

Rationale:

This would be a change: as it stands, the standard clearly specifies that grouping applies to void*. A survey of existing practice shows that most existing implementations do that, as they should.


366(i). Excessive const-qualification

Section: 31 [input.output] Status: NAD Submitter: Walter Brown, Marc Paterno Opened: 2002-05-10 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [input.output].

View all issues with NAD status.

Discussion:

The following member functions are declared const, yet return non-const pointers. We believe they are should be changed, because they allow code that may surprise the user. See document N1360 for details and rationale.

[Santa Cruz: the real issue is that we've got const member functions that return pointers to non-const, and N1360 proposes replacing them by overloaded pairs. There isn't a consensus about whether this is a real issue, since we've never said what our constness policy is for iostreams. N1360 relies on a distinction between physical constness and logical constness; that distinction, or those terms, does not appear in the standard.]

Proposed resolution:

In 27.4.4 and 27.4.4.2

Replace

  basic_ostream<charT,traits>* tie() const;

with

  basic_ostream<charT,traits>* tie();
  const basic_ostream<charT,traits>* tie() const;

and replace

  basic_streambuf<charT,traits>* rdbuf() const;

with

  basic_streambuf<charT,traits>* rdbuf();
  const basic_streambuf<charT,traits>* rdbuf() const;

In 27.5.2 and 27.5.2.3.1

Replace

  char_type* eback() const;

with

  char_type* eback();
  const char_type* eback() const;

Replace

  char_type gptr() const;

with

  char_type* gptr();
  const char_type* gptr() const;

Replace

  char_type* egptr() const;

with

  char_type* egptr();
  const char_type* egptr() const;

In 27.5.2 and 27.5.2.3.2

Replace

  char_type* pbase() const;

with

  char_type* pbase();
  const char_type* pbase() const;

Replace

  char_type* pptr() const;

with

  char_type* pptr();
  const char_type* pptr() const;

Replace

  char_type* epptr() const;

with

  char_type* epptr();
  const char_type* epptr() const;

In 27.7.2, 27.7.2.2, 27.7.3 27.7.3.2, 27.7.4, and 27.7.6

Replace

  basic_stringbuf<charT,traits,Allocator>* rdbuf() const;

with

  basic_stringbuf<charT,traits,Allocator>* rdbuf();
  const basic_stringbuf<charT,traits,Allocator>* rdbuf() const;

In 27.8.1.5, 27.8.1.7, 27.8.1.8, 27.8.1.10, 27.8.1.11, and 27.8.1.13

Replace

  basic_filebuf<charT,traits>* rdbuf() const;

with

  basic_filebuf<charT,traits>* rdbuf();
  const basic_filebuf<charT,traits>* rdbuf() const;

Rationale:

The existing specification is a bit sloppy, but there's no particular reason to change this other than tidiness, and there are a number of ways in which streams might have been designed differently if we were starting today. There's no evidence that the existing constness policy is harming users. We might consider a different constness policy as part of a full stream redesign.


367(i). remove_copy/remove_copy_if and Input Iterators

Section: 26.7.8 [alg.remove] Status: NAD Submitter: Anthony Williams Opened: 2002-05-13 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [alg.remove].

View all issues with NAD status.

Discussion:

remove_copy and remove_copy_if (26.7.8 [alg.remove]) permit their input range to be marked with Input Iterators. However, since two operations are required against the elements to copy (comparison and assigment), when the input range uses Input Iterators, a temporary copy must be taken to avoid dereferencing the iterator twice. This therefore requires the value type of the InputIterator to be CopyConstructible. If the iterators are at least Forward Iterators, then the iterator can be dereferenced twice, or a reference to the result maintained, so the temporary is not required.

Proposed resolution:

Add "If InputIterator does not meet the requirements of forward iterator, then the value type of InputIterator must be copy constructible. Otherwise copy constructible is not required." to 26.7.8 [alg.remove] paragraph 6.

Rationale:

The assumption is that an input iterator can't be dereferenced twice. There's no basis for that assumption in the Standard.


368(i). basic_string::replace has two "Throws" paragraphs

Section: 27.4.3.7.6 [string.replace] Status: NAD Editorial Submitter: Beman Dawes Opened: 2002-06-03 Last modified: 2016-11-12

Priority: Not Prioritized

View all other issues in [string.replace].

View all issues with NAD Editorial status.

Discussion:

27.4.3.7.6 [string.replace] basic_string::replace, second signature, given in paragraph 1, has two "Throws" paragraphs (3 and 5).

In addition, the second "Throws" paragraph (5) includes specification (beginning with "Otherwise, the function replaces ...") that should be part of the "Effects" paragraph.

Proposed resolution:

Rationale:

This is editorial. Both "throws" statements are true. The bug is just that the second one should be a sentence, part of the "Effects" clause, not a separate "Throws". The project editor has been notified.


372(i). Inconsistent description of stdlib exceptions

Section: 16.4.6.13 [res.on.exception.handling], 17.7.3 [type.info] Status: NAD Submitter: Randy Maddox Opened: 2002-07-22 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [res.on.exception.handling].

View all other issues in [res.on.exception.handling].

View all issues with NAD status.

Discussion:

Paragraph 3 under clause 16.4.6.13 [res.on.exception.handling], Restrictions on Exception Handling, states that "Any other functions defined in the C++ Standard Library that do not have an exception-specification may throw implementation-defined exceptions unless otherwise specified." This statement is followed by a reference to footnote 178 at the bottom of that page which states, apparently in reference to the C++ Standard Library, that "Library implementations are encouraged (but not required) to report errors by throwing exceptions from (or derived from) the standard exceptions."

These statements appear to be in direct contradiction to clause 17.7.3 [type.info], which states "The class exception defines the base class for the types of objects thrown as exceptions by the C++ Standard library components ...".

Is this inconsistent?

Proposed resolution:

Rationale:

Clause 17 is setting the overall library requirements, and it's clear and consistent. This sentence from Clause 18 is descriptive, not setting a requirement on any other class.


374(i). moneypunct::frac_digits returns int not unsigned

Section: 28.3.4.7.4.2 [locale.moneypunct.members], 28.3.4.7.4.3 [locale.moneypunct.virtuals] Status: NAD Submitter: Ray Lischner Opened: 2002-08-08 Last modified: 2016-01-28

Priority: Not Prioritized

View all issues with NAD status.

Discussion:

In section 28.3.4.7.4.2 [locale.moneypunct.members], frac_digits() returns type "int". This implies that frac_digits() might return a negative value, but a negative value is nonsensical. It should return "unsigned".

Similarly, in section 28.3.4.7.4.3 [locale.moneypunct.virtuals], do_frac_digits() should return "unsigned".

Proposed resolution:

Rationale:

Regardless of whether the return value is int or unsigned, it's always conceivable that frac_digits might return a nonsensical value. (Is 4294967295 really any better than -1?) The clients of moneypunct, the get and put facets, can and do perform range checks.


377(i). basic_string::insert and length_error

Section: 27.4.3.7.4 [string.insert] Status: NAD Submitter: Ray Lischner Opened: 2002-08-16 Last modified: 2016-11-12

Priority: Not Prioritized

View all other issues in [string.insert].

View all issues with NAD status.

Discussion:

Section 27.4.3.7.4 [string.insert], paragraph 4, contains the following, "Then throws length_error if size() >= npos - rlen."

Related to DR 83, this sentence should probably be removed.

Proposed resolution:

Rationale:

This requirement is redundant but correct. No change is needed.


378(i). locale immutability and locale::operator=()

Section: 28.3.3.1 [locale] Status: Dup Submitter: Martin Sebor Opened: 2002-09-06 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale].

View all issues with Dup status.

Duplicate of: 31

Discussion:

I think there is a problem with 22.1.1, p6 which says that

    -6- An instance of locale is immutable; once a facet reference
        is obtained from it, that reference remains usable as long
        as the locale value itself exists.

and 22.1.1.2, p4:

    const locale& operator=(const locale& other) throw();

    -4- Effects: Creates a copy of other, replacing the current value.

How can a reference to a facet obtained from a locale object remain valid after an assignment that clearly must replace all the facets in the locale object? Imagine a program such as this

    std::locale loc ("de_DE");
    const std::ctype<char> &r0 = std::use_facet<std::ctype<char> >(loc);
    loc = std::locale ("en_US");
    const std::ctype<char> &r1 = std::use_facet<std::ctype<char> >(loc);

Is r0 really supposed to be preserved and destroyed only when loc goes out of scope?

Proposed resolution:

[Summer '04 mid-meeting mailing: Martin and Dietmar believe this is a duplicate of issue 31(i) and recommend that it be closed. ]


382(i). codecvt do_in/out result

Section: 28.3.4.2.5 [locale.codecvt] Status: NAD Submitter: Martin Sebor Opened: 2002-08-30 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.codecvt].

View all issues with NAD status.

Discussion:

It seems that the descriptions of codecvt do_in() and do_out() leave sufficient room for interpretation so that two implementations of codecvt may not work correctly with the same filebuf. Specifically, the following seems less than adequately specified:

  1. the conditions under which the functions terminate
  2. precisely when the functions return ok
  3. precisely when the functions return partial
  4. the full set of conditions when the functions return error
  1. 28.3.4.2.5.3 [locale.codecvt.virtuals], p2 says this about the effects of the function: ...Stops if it encounters a character it cannot convert... This assumes that there *is* a character to convert. What happens when there is a sequence that doesn't form a valid source character, such as an unassigned or invalid UNICODE character, or a sequence that cannot possibly form a character (e.g., the sequence "\xc0\xff" in UTF-8)?
  2. Table 53 says that the function returns codecvt_base::ok to indicate that the function(s) "completed the conversion." Suppose that the source sequence is "\xc0\x80" in UTF-8, with from pointing to '\xc0' and (from_end==from + 1). It is not clear whether the return value should be ok or partial (see below).
  3. Table 53 says that the function returns codecvt_base::partial if "not all source characters converted." With the from pointers set up the same way as above, it is not clear whether the return value should be partial or ok (see above).
  4. Table 53, in the row describing the meaning of error mistakenly refers to a "from_type" character, without the symbol from_type having been defined. Most likely, the word "source" character is intended, although that is not sufficient. The functions may also fail when they encounter an invalid source sequence that cannot possibly form a valid source character (e.g., as explained in bullet 1 above).

Finally, the conditions described at the end of 28.3.4.2.5.3 [locale.codecvt.virtuals], p4 don't seem to be possible:

"A return value of partial, if (from_next == from_end), indicates that either the destination sequence has not absorbed all the available destination elements, or that additional source elements are needed before another destination element can be produced."

If the value is partial, it's not clear to me that (from_next ==from_end) could ever hold if there isn't enough room in the destination buffer. In order for (from_next==from_end) to hold, all characters in that range must have been successfully converted (according to 28.3.4.2.5.3 [locale.codecvt.virtuals], p2) and since there are no further source characters to convert, no more room in the destination buffer can be needed.

It's also not clear to me that (from_next==from_end) could ever hold if additional source elements are needed to produce another destination character (not element as incorrectly stated in the text). partial is returned if "not all source characters have been converted" according to Table 53, which also implies that (from_next==from) does NOT hold.

Could it be that the intended qualifying condition was actually (from_next != from_end), i.e., that the sentence was supposed to read

"A return value of partial, if (from_next != from_end),..."

which would make perfect sense, since, as far as I understand it, partial can only occur if (from_next != from_end)?

[Lillehammer: Defer for the moment, but this really needs to be fixed. Right now, the description of codecvt is too vague for it to be a useful contract between providers and clients of codecvt facets. (Note that both vendors and users can be both providers and clients of codecvt facets.) The major philosophical issue is whether the standard should only describe mappings that take a single wide character to multiple narrow characters (and vice versa), or whether it should describe fully general N-to-M conversions. When the original standard was written only the former was contemplated, but today, in light of the popularity of utf8 and utf16, that doesn't seem sufficient for C++0x. Bill supports general N-to-M conversions; we need to make sure Martin and Howard agree.]

[ 2009-07 Frankfurt ]

codecvt is meant to be a 1-to-N to N-to-1 conversion. It does not work well for N-to-M conversions. wbuffer_convert now exists, and handles N-to-M cases. Also, there is a new specialization of codecvt that permits UTF-16 <-> UTF-8 conversions.

NAD without prejudice. Will reopen if proposed resolution is supplied.

Proposed resolution:


385(i). Does call by value imply the CopyConstructible requirement?

Section: 16 [library] Status: NAD Submitter: Matt Austern Opened: 2002-10-23 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [library].

View all other issues in [library].

View all issues with NAD status.

Discussion:

Many function templates have parameters that are passed by value; a typical example is find_if's pred parameter in 26.6.6 [alg.find]. Are the corresponding template parameters (Predicate in this case) implicitly required to be CopyConstructible, or does that need to be spelled out explicitly?

This isn't quite as silly a question as it might seem to be at first sight. If you call find_if in such a way that template argument deduction applies, then of course you'll get call by value and you need to provide a copy constructor. If you explicitly provide the template arguments, however, you can force call by reference by writing something like find_if<my_iterator, my_predicate&>. The question is whether implementation are required to accept this, or whether this is ill-formed because my_predicate& is not CopyConstructible.

The scope of this problem, if it is a problem, is unknown. Function object arguments to generic algorithms in clauses 26 [algorithms] and 29 [numerics] are obvious examples. A review of the whole library is necessary.

[ This is really two issues. First, predicates are typically passed by value but we don't say they must be Copy Constructible. They should be. Second: is specialization allowed to transform value arguments into references? References aren't copy constructible, so this should not be allowed. ]

[ 2007-01-12, Howard: First, despite the note above, references are copy constructible. They just aren't assignable. Second, this is very closely related to 92(i) and should be consistent with that. That issue already says that implementations are allowed to copy function objects. If one passes in a reference, it is copyable, but susceptible to slicing if one passes in a reference to a base. Third, with rvalue reference in the language one only needs to satisfy MoveConstructible to pass an rvalue "by value". Though the function might still copy the function object internally (requiring CopyConstructible). Finally (and fwiw), if we wanted to, it is easy to code all of the std::algorithms such that they do not copy function objects internally. One merely passes them by reference internally if desired (this has been fully implemented and shipped for several years). If this were mandated, it would reverse 92(i), allowing function objects to reliably maintain state. E.g. the example in 92(i) would reliably remove only the third element. ]

Proposed resolution:

Recommend NAD.

Rationale:

Generic algorithms will be marked with concepts and these will imply a requirement of MoveConstructible (not CopyConstructible). The signature of the function will then precisely describe and enforce the precise requirements.


388(i). Use of complex as a key in associative containers

Section: 29.4 [complex.numbers] Status: NAD Submitter: Gabriel Dos Reis Opened: 2002-11-08 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [complex.numbers].

View all issues with NAD status.

Discussion:

Practice with std::complex<> and the associative containers occasionally reveals artificial and distracting issues with constructs resembling: std::set<std::complex<double> > s;

The main reason for the above to fail is the absence of an appropriate definition for std::less<std::complex<T> >. That in turn comes from the definition of the primary template std::less<> in terms of operator<.

The usual argument goes as follows: Since there is no ordering over the complex field compatible with field operations it makes little sense to define a function operator< operating on the datatype std::complex<T>. That is fine. However, that reasoning does not carry over to std::less<T> which is used, among other things, by associative containers as an ordering useful to meet complexity requirements.

Related issue: 348(i).

[ Pre Bellevue: Reopened at the request of Alisdair. ]

[ Bellevue: ]

This is a request for a design change, and not a defect in the standard. It is in scope to consider, but the group feels that it is not a change that we need to do. Is there a total ordering for floating point values, including NaN? There is not a clear enough solution or big enough problem for us to solve. Solving this problem would require solving the problem for floating point, which is equally unclear. The LWG noted that users who want to put objects into an associative container for which operator< isn't defined can simply provide their own comparison function object. NAD

Proposed resolution:

Informally: Add a specialization of std::less for std::complex.

Rationale:

Discussed in Santa Cruz. An overwhelming majority of the LWG believes this should not be treated a DR: it's a request for a design change, not a defect in the existing standard. Most people (10-3) believed that we probably don't want this change, period: as with issue 348(i), it's hard to know where to draw the line. The LWG noted that users who want to put objects into an associative container for which operator< isn't defined can simply provide their own comparison function object.


390(i). CopyConstructible requirements too strict

Section: 16.4.4.2 [utility.arg.requirements] Status: NAD Editorial Submitter: Doug Gregor Opened: 2002-10-24 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [utility.arg.requirements].

View all issues with NAD Editorial status.

Discussion:

The CopyConstructible requirements in Table 30 state that for an object t of type T (where T is CopyConstructible), the expression &t returns the address of t (with type T*). This requirement is overly strict, in that it disallows types that overload operator& to not return a value of type T*. This occurs, for instance, in the Boost.Lambda library, where operator& is overloaded for a Boost.Lambda function object to return another function object.

Example:

  std::vector<int> u, v;
  int x;
  // ...
  std::transform(u.begin(), u.end(), std::back_inserter(v), _1 * x);

_1 * x returns an unnamed function object with operator& overloaded to not return T* , therefore rendering the std::transform call ill-formed. However, most standard library implementations will compile this code properly, and the viability of such binder libraries is severely hindered by the unnecessary restriction in the CopyConstructible requirements.

For reference, the address of an object can be retrieved without using the address-of operator with the following function template:

  template <typename T> T* addressof(T& v)
  {
    return reinterpret_cast<T*>(
         &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
  }

Note: this relates directly to library issue 350(i), which will need to be reexamined if the CopyConstructible requirements change.

Proposed resolution:

Remove the last two rows of Table 30, eliminating the requirements that &t and &u return the address of t and u, respectively.

Rationale:

This was a deliberate design decision. Perhaps it should be reconsidered for C++0x.


392(i). 'equivalence' for input iterators

Section: 24.3.5.3 [input.iterators] Status: NAD Submitter: Corwin Joy Opened: 2002-12-11 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [input.iterators].

View all other issues in [input.iterators].

View all issues with NAD status.

Discussion:

In section 24.3.5.3 [input.iterators] table 72 - 'Input Iterator Requirements' we have as a postcondition of *a: "If a==b and (a, b) is in the domain of == then *a is equivalent to *b".

In section [istreambuf.iterator::equal] it states that "istreambuf_iterator::equal returns true if and only if both iterators are at end-of-stream, or neither is at end-of-stream, regardless of what streambuf object they use." (My emphasis).

The defect is that either 'equivalent' needs to be more precisely defined or the conditions for equality in [istreambuf.iterator::equal] are incorrect. (Or both).

Consider the following example:

   #include <iostream>
   #include <fstream>
   #include <iterator>
   using namespace std;

   int main() {
    ifstream file1("file1.txt"), file2("file2.txt");
    istreambuf_iterator<char> f1(file1), f2(file2);
    cout << "f1 == f2 : " << boolalpha << (f1 == f2) << endl;
    cout << "f1 = " << *f1 << endl;
    cout << "f2 = " << *f2 << endl;
    return 0;
   }

Now assuming that neither f1 or f2 are at the end-of-stream then f1 == f2 by [istreambuf.iterator::equal].

However, it is unlikely that *f1 will give the same value as *f2 except by accident.

So what does *f1 'equivalent' to *f2 mean? I think the standard should be clearer on this point, or at least be explicit that this does not mean that *f1 and *f2 are required to have the same value in the case of input iterators.

Proposed resolution:

Rationale:

The two iterators aer not in the domain of ==


393(i). do_in/do_out operation on state unclear

Section: 28.3.4.2.5.3 [locale.codecvt.virtuals] Status: NAD Editorial Submitter: Alberto Barbati Opened: 2002-12-24 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.codecvt.virtuals].

View all issues with NAD Editorial status.

Discussion:

this DR follows the discussion on the previous thread "codecvt::do_in not consuming external characters". It's just a clarification issue and not a request for a change.

Can do_in()/do_out() produce output characters without consuming input characters as a result of operation on state?

Proposed resolution:

Add a note at the end of 28.3.4.2.5.3 [locale.codecvt.virtuals], paragraph 3:

[Note: As a result of operations on state, it can return ok or partial and set from_next == from and to_next != to. --end note]

Rationale:

The submitter believes that standard already provides an affirmative answer to the question. However, the current wording has induced a few library implementors to make the incorrect assumption that do_in()/do_out() always consume at least one internal character when they succeed.

The submitter also believes that the proposed resolution is not in conflict with the related issue 76. Moreover, by explicitly allowing operations on state to produce characters, a codecvt implementation may effectively implement N-to-M translations without violating the "one character at a time" principle described in such issue. On a side note, the footnote in the proposed resolution of issue 76 that informally rules out N-to-M translations for basic_filebuf should be removed if this issue is accepted as valid.

[ Kona (2007): The proposed resolution is to add a note. Since this is non-normative, the issue is editorial, but we believe that the note is correct. Proposed Disposition: NAD, Editorial ]


394(i). behavior of formatted output on failure

Section: 31.7.6.3.1 [ostream.formatted.reqmts] Status: NAD Submitter: Martin Sebor Opened: 2002-12-27 Last modified: 2016-01-28

Priority: Not Prioritized

View all issues with NAD status.

Discussion:

There is a contradiction in Formatted output about what bit is supposed to be set if the formatting fails. On sentence says it's badbit and another that it's failbit.

27.6.2.5.1, p1 says in the Common Requirements on Formatted output functions:

     ... If the generation fails, then the formatted output function
     does setstate(ios::failbit), which might throw an exception.

27.6.2.5.2, p1 goes on to say this about Arithmetic Inserters:

... The formatting conversion occurs as if it performed the following code fragment:

     bool failed =
         use_facet<num_put<charT,ostreambuf_iterator<charT,traits>
         > >
         (getloc()).put(*this, *this, fill(), val). failed();

     ... If failed is true then does setstate(badbit) ...

The original intent of the text, according to Jerry Schwarz (see c++std-lib-10500), is captured in the following paragraph:

In general "badbit" should mean that the stream is unusable because of some underlying failure, such as disk full or socket closure; "failbit" should mean that the requested formatting wasn't possible because of some inconsistency such as negative widths. So typically if you clear badbit and try to output something else you'll fail again, but if you clear failbit and try to output something else you'll succeed.

In the case of the arithmetic inserters, since num_put cannot report failure by any means other than exceptions (in response to which the stream must set badbit, which prevents the kind of recoverable error reporting mentioned above), the only other detectable failure is if the iterator returned from num_put returns true from failed().

Since that can only happen (at least with the required iostream specializations) under such conditions as the underlying failure referred to above (e.g., disk full), setting badbit would seem to be the appropriate response (indeed, it is required in 27.6.2.5.2, p1). It follows that failbit can never be directly set by the arithmetic (it can only be set by the sentry object under some unspecified conditions).

The situation is different for other formatted output functions which can fail as a result of the streambuf functions failing (they may do so by means other than exceptions), and which are then required to set failbit.

The contradiction, then, is that ostream::operator<<(int) will set badbit if the disk is full, while operator<<(ostream&, char) will set failbit under the same conditions. To make the behavior consistent, the Common requirements sections for the Formatted output functions should be changed as proposed below.

[Kona: There's agreement that this is a real issue. What we decided at Kona: 1. An error from the buffer (which can be detected either directly from streambuf's member functions or by examining a streambuf_iterator) should always result in badbit getting set. 2. There should never be a circumstance where failbit gets set. That represents a formatting error, and there are no circumstances under which the output facets are specified as signaling a formatting error. (Even more so for string output that for numeric because there's nothing to format.) If we ever decide to make it possible for formatting errors to exist then the facets can signal the error directly, and that should go in clause 22, not clause 27. 3. The phrase "if generation fails" is unclear and should be eliminated. It's not clear whether it's intended to mean a buffer error (e.g. a full disk), a formatting error, or something else. Most people thought it was supposed to refer to buffer errors; if so, we should say so. Martin will provide wording.]

[ 2009-07 Frankfurt ]

NAD. This issue is already fixed.

Proposed resolution:

Rationale:


397(i). ostream::sentry dtor throws exceptions

Section: 31.7.6.2.4 [ostream.sentry] Status: NAD Editorial Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2021-06-06

Priority: Not Prioritized

View all other issues in [ostream.sentry].

View all issues with NAD Editorial status.

Discussion:

17.4.4.8, p3 prohibits library dtors from throwing exceptions.

27.6.2.3, p4 says this about the ostream::sentry dtor:

    -4- If ((os.flags() & ios_base::unitbuf) && !uncaught_exception())
        is true, calls os.flush().
    

27.6.2.6, p7 that describes ostream::flush() says:

    -7- If rdbuf() is not a null pointer, calls rdbuf()->pubsync().
        If that function returns ?-1 calls setstate(badbit) (which
        may throw ios_base::failure (27.4.4.3)).
    

That seems like a defect, since both pubsync() and setstate() can throw an exception.

[ The contradiction is real. Clause 17 says destructors may never throw exceptions, and clause 27 specifies a destructor that does throw. In principle we might change either one. We're leaning toward changing clause 17: putting in an "unless otherwise specified" clause, and then putting in a footnote saying the sentry destructor is the only one that can throw. PJP suggests specifying that sentry::~sentry() should internally catch any exceptions it might cause. ]

[ See 418(i) and 622(i) for related issues. ]

[ 2009-07 Frankfurt ]

Move to Review. Add "Throws: nothing" to the specification of ostream::sentry::~sentry().

[ 2009-10-13 Daniel adds: ]

The proposed resolution of 835(i) is written to match the outcome of this issue.

[ 2009 Santa Cruz: ]

Move to Open. Our intent is to solve this issue with 835(i).

[ 2010-03-06 Martin updates wording. ]

[ 2010 Pittsburgh: ]

Moved to NAD Editorial.

Rationale:

Solved by 835(i).

Proposed resolution:

Add after [ostream::sentry] p17:

~sentry();

-17- If (os.flags() & ios_base::unitbuf) is true, calls os.flush().

Throws: Nothing.


398(i). effects of end-of-file on unformatted input functions

Section: 31.7.6.2.4 [ostream.sentry] Status: NAD Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2021-06-06

Priority: Not Prioritized

View all other issues in [ostream.sentry].

View all issues with NAD status.

Discussion:

While reviewing unformatted input member functions of istream for their behavior when they encounter end-of-file during input I found that the requirements vary, sometimes unexpectedly, and in more than one case even contradict established practice (GNU libstdc++ 3.2, IBM VAC++ 6.0, STLPort 4.5, SunPro 5.3, HP aCC 5.38, Rogue Wave libstd 3.1, and Classic Iostreams).

The following unformatted input member functions set eofbit if they encounter an end-of-file (this is the expected behavior, and also the behavior of all major implementations):

    basic_istream<charT, traits>&
    get (char_type*, streamsize, char_type);
    

Also sets failbit if it fails to extract any characters.

    basic_istream<charT, traits>&
    get (char_type*, streamsize);
    

Also sets failbit if it fails to extract any characters.

    basic_istream<charT, traits>&
    getline (char_type*, streamsize, char_type);
    

Also sets failbit if it fails to extract any characters.

    basic_istream<charT, traits>&
    getline (char_type*, streamsize);
    

Also sets failbit if it fails to extract any characters.

    basic_istream<charT, traits>&
    ignore (int, int_type);
    
    basic_istream<charT, traits>&
    read (char_type*, streamsize);
    

Also sets failbit if it encounters end-of-file.

    streamsize readsome (char_type*, streamsize);
    

The following unformated input member functions set failbit but not eofbit if they encounter an end-of-file (I find this odd since the functions make it impossible to distinguish a general failure from a failure due to end-of-file; the requirement is also in conflict with all major implementation which set both eofbit and failbit):

    int_type get();
    
    basic_istream<charT, traits>&
    get (char_type&);
    

These functions only set failbit of they extract no characters, otherwise they don't set any bits, even on failure (I find this inconsistency quite unexpected; the requirement is also in conflict with all major implementations which set eofbit whenever they encounter end-of-file):

    basic_istream<charT, traits>&
    get (basic_streambuf<charT, traits>&, char_type);
    
    basic_istream<charT, traits>&
    get (basic_streambuf<charT, traits>&);
    

This function sets no bits (all implementations except for STLport and Classic Iostreams set eofbit when they encounter end-of-file):

    int_type peek ();
    

Informally, what we want is a global statement of intent saying that eofbit gets set if we trip across EOF, and then we can take away the specific wording for individual functions. A full review is necessary. The wording currently in the standard is a mishmash, and changing it on an individual basis wouldn't make things better. Dietmar will do this work.

[ 2009-07 Frankfurt ]

Moved to NAD. See 31.7.5.2 [istream] p3.

Proposed resolution:


399(i). volations of unformatted input function requirements

Section: 31.7.5.4 [istream.unformatted] Status: NAD Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [istream.unformatted].

View all issues with NAD status.

Discussion:

The Effects clauses for the two functions below violate the general requirements on unformatted input functions outlined in 27.6.1.3: they do not begin by constructing a sentry object. Instead, they begin by calling widen ('\n'), which may throw an exception. The exception is then allowed to propagate from the unformatted input function irrespective of the setting of exceptions().

Note that in light of 27.6.1.1, p3 and p4, the fact that the functions allow exceptions thrown from widen() to propagate may not strictly speaking be a defect (but the fact that the functions do not start by constructing a sentry object still is). However, since an exception thrown from ctype<charT> ::widen() during any other input operation (say, from within a call to num_get<charT>::get()) will be caught and cause badbit to be set, these two functions should not be treated differently for the sake of consistency.

Proposed resolution:

Rationale:

Not a defect. The standard is consistent, and the behavior required by the standard is unambiguous. Yes, it's theoretically possible for widen to throw. (Not that this will happen for the default ctype facet or for most real-world replacement ctype facets.) Users who define ctype facets that can throw, and who care about this behavior, can use alternative signatures that don't call widen.


408(i). Is vector<reverse_iterator<char*> > forbidden?

Section: 24.3 [iterator.requirements] Status: NAD Editorial Submitter: Nathan Myers Opened: 2003-06-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [iterator.requirements].

View all issues with NAD Editorial status.

Discussion:

I've been discussing iterator semantics with Dave Abrahams, and a surprise has popped up. I don't think this has been discussed before.

24.3.4 [iterator.concepts] says that the only operation that can be performed on "singular" iterator values is to assign a non-singular value to them. (It doesn't say they can be destroyed, and that's probably a defect.) Some implementations have taken this to imply that there is no need to initialize the data member of a reverse_iterator<> in the default constructor. As a result, code like

  std::vector<std::reverse_iterator<char*> > v(7);
  v.reserve(1000);

invokes undefined behavior, because it must default-initialize the vector elements, and then copy them to other storage. Of course many other vector operations on these adapters are also left undefined, and which those are is not reliably deducible from the standard.

I don't think that 24.1 was meant to make standard-library iterator types unsafe. Rather, it was meant to restrict what operations may be performed by functions which take general user- and standard iterators as arguments, so that raw pointers would qualify as iterators. However, this is not clear in the text, others have come to the opposite conclusion.

One question is whether the standard iterator adaptors have defined copy semantics. Another is whether they have defined destructor semantics: is

  { std::vector<std::reverse_iterator<char*> >  v(7); }

undefined too?

Note this is not a question of whether algorithms are allowed to rely on copy semantics for arbitrary iterators, just whether the types we actually supply support those operations. I believe the resolution must be expressed in terms of the semantics of the adapter's argument type. It should make clear that, e.g., the reverse_iterator<T> constructor is actually required to execute T(), and so copying is defined if the result of T() is copyable.

Issue 235(i), which defines reverse_iterator's default constructor more precisely, has some relevance to this issue. However, it is not the whole story.

The issue was whether

  reverse_iterator() { }

is allowed, vs.

  reverse_iterator() : current() { }

The difference is when T is char*, where the first leaves the member uninitialized, and possibly equal to an existing pointer value, or (on some targets) may result in a hardware trap when copied.

8.5 paragraph 5 seems to make clear that the second is required to satisfy DR 235(i), at least for non-class Iterator argument types.

But that only takes care of reverse_iterator, and doesn't establish a policy for all iterators. (The reverse iterator adapter was just an example.) In particular, does my function

  template <typename Iterator>
    void f() { std::vector<Iterator>  v(7); } 

evoke undefined behavior for some conforming iterator definitions? I think it does, now, because vector<> will destroy those singular iterator values, and that's explicitly disallowed.

24.1 shouldn't give blanket permission to copy all singular iterators, because then pointers wouldn't qualify as iterators. However, it should allow copying of that subset of singular iterator values that are default-initialized, and it should explicitly allow destroying any iterator value, singular or not, default-initialized or not.

Related issues: 407(i), 1012(i)

[ We don't want to require all singular iterators to be copyable, because that is not the case for pointers. However, default construction may be a special case. Issue: is it really default construction we want to talk about, or is it something like value initialization? We need to check with core to see whether default constructed pointers are required to be copyable; if not, it would be wrong to impose so strict a requirement for iterators. ]

[ 2009-05-10 Alisdair provided wording. ]

The comments regarding destroying singular iterators have already been resolved. That just leaves copying (with moving implied).

[ 2009-07 Frankfurt ]

This is related to LWG 1012(i).

Note that there is a bug in the proposed resolution to LWG 1012(i). The change to [reverse.iter.con] should be modified so that the word "default" in the second sentence of the Effects clause is replaced by "value."

We believe that the proposed fix to LWG 1012(i) (now corrected) is sufficient to solve the problem for reverse_iterator. However, Alisdair pointed out that LWG 1012(i) does not solve the general problem for authors of iterator adaptors.

There are some problems with the proposed resolution. The phrase "safely copyable" is not a term of art. Also, it mentions a DefaultConstructible? concept.

Move to Review after Alisdair updates the wording.

[ 2009-07-31 Alisdair revised wording: ]

[ 2009-08-17 Alisdair and Daniel collaborate on slightly revised wording. This issue depends upon 724(i) ]

[ 2009-10-14 Daniel adds: ]

There is a clear dependency on 1213(i), because the term "singular", which is used as part of the resolution, is not properly defined yet.

[ 2009-10 Santa Cruz: ]

Moved to Open. Alisdair will provide improved wording to make this have "value semantics" and otherwise behave like a valid iterator.

[ 2010 Pittsburgh: Moved to NAD Editorial. Rationale added below. ]

Rationale:

Solved by N3066.

Proposed resolution:

Add a new paragrpah to Iterator concepts 24.3 [iterator.requirements] after para 5 (the one describing singular iterators)

Just as a regular pointer to an array guarantees that there is a pointer value pointing past the last element of the array, so for any iterator type there is an iterator value that points past the last element of a corresponding container. These values are called past-the-end values. Values of an iterator i for which the expression *i is defined are called dereferenceable. The library never assumes that past-the-end values are dereferenceable. Iterators can also have singular values that are not associated with any container. [Example: After the declaration of an uninitialized pointer x (as with int* x;), x must always be assumed to have a singular value of a pointer. — end example] Results of most expressions are undefined for singular values; the only exceptions are destroying an iterator that holds a singular value and the assignment of a non-singular value to an iterator that holds a singular value. In this case the singular value is overwritten the same way as any other value. Dereferenceable values are always non-singular.

After value-initialization, any iterator that satisfies the DefaultConstructible requirements ([defaultconstructible]) shall not introduce undefined behaviour when used as the source of a copy or move operation, even if it would otherwise be singular. [Note: This guarantee is not offered for default-initialization (9.4 [dcl.init]), although the distinction only matters for types with trivial default constructors such as pointers. — end note]


417(i). what does ctype::do_widen() return on failure

Section: 28.3.4.2.2.3 [locale.ctype.virtuals] Status: NAD Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.ctype.virtuals].

View all issues with NAD status.

Discussion:

The Effects and Returns clauses of the do_widen() member function of the ctype facet fail to specify the behavior of the function on failure. That the function may not be able to simply cast the narrow character argument to the type of the result since doing so may yield the wrong value for some wchar_t encodings. Popular implementations of ctype<wchar_t> that use mbtowc() and UTF-8 as the native encoding (e.g., GNU glibc) will fail when the argument's MSB is set. There is no way for the the rest of locale and iostream to reliably detect this failure.

[Kona: This is a real problem. Widening can fail. It's unclear what the solution should be. Returning WEOF works for the wchar_t specialization, but not in general. One option might be to add a default, like narrow. But that's an incompatible change. Using traits::eof might seem like a good idea, but facets don't have access to traits (a recurring problem). We could have widen throw an exception, but that's a scary option; existing library components aren't written with the assumption that widen can throw.]

[ 2009-07 Frankfurt ]

NAD. The behavior is specified for all of the facets that an implementation is required to provide, for the basic character set.

Proposed resolution:


418(i). exceptions thrown during iostream cleanup

Section: 31.5.2.2.6 [ios.init] Status: NAD Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2021-06-06

Priority: Not Prioritized

View all other issues in [ios.init].

View all issues with NAD status.

Discussion:

The dtor of the ios_base::Init object is supposed to call flush() on the 6 standard iostream objects cout, cerr, clog, wcout, wcerr, and wclog. This call may cause an exception to be thrown.

17.4.4.8, p3 prohibits all library destructors from throwing exceptions.

The question is: What should this dtor do if one or more of these calls to flush() ends up throwing an exception? This can happen quite easily if one of the facets installed in the locale imbued in the iostream object throws.

[Kona: We probably can't do much better than what we've got, so the LWG is leaning toward NAD. At the point where the standard stream objects are being cleaned up, the usual error reporting mechanism are all unavailable. And exception from flush at this point will definitely cause problems. A quality implementation might reasonably swallow the exception, or call abort, or do something even more drastic.]

[ See 397(i) and 622(i) for related issues. ]

[ 2009-07 Frankfurt ]

Moved to NAD, no consensus for change.

Proposed resolution:


421(i). is basic_streambuf copy-constructible?

Section: 31.6.3.2 [streambuf.cons] Status: NAD Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [streambuf.cons].

View all issues with NAD status.

Discussion:

The reflector thread starting with c++std-lib-11346 notes that the class template basic_streambuf, along with basic_stringbuf and basic_filebuf, is copy-constructible but that the semantics of the copy constructors are not defined anywhere. Further, different implementations behave differently in this respect: some prevent copy construction of objects of these types by declaring their copy ctors and assignment operators private, others exhibit undefined behavior, while others still give these operations well-defined semantics.

Note that this problem doesn't seem to be isolated to just the three types mentioned above. A number of other types in the library section of the standard provide a compiler-generated copy ctor and assignment operator yet fail to specify their semantics. It's believed that the only types for which this is actually a problem (i.e. types where the compiler-generated default may be inappropriate and may not have been intended) are locale facets. See issue 439(i).

[ 2009-07 Frankfurt ]

NAD. Option B is already in the Working Draft.

Proposed resolution:

27.5.2 [lib.streambuf]: Add into the synopsis, public section, just above the destructor declaration:

basic_streambuf(const basic_streambuf& sb);
basic_streambuf& operator=(const basic_streambuf& sb);

Insert after 27.5.2.1, paragraph 2:

basic_streambuf(const basic_streambuf& sb);

Constructs a copy of sb.

Postcondtions:

                eback() == sb.eback()
                gptr()  == sb.gptr()
                egptr() == sb.egptr()
                pbase() == sb.pbase()
                pptr()  == sb.pptr()
                epptr() == sb.epptr()
                getloc() == sb.getloc()
basic_streambuf& operator=(const basic_streambuf& sb);

Assigns the data members of sb to this.

Postcondtions:

                eback() == sb.eback()
                gptr()  == sb.gptr()
                egptr() == sb.egptr()
                pbase() == sb.pbase()
                pptr()  == sb.pptr()
                epptr() == sb.epptr()
                getloc() == sb.getloc()

Returns: *this.

27.7.1 [lib.stringbuf]:

Option A:

Insert into the basic_stringbuf synopsis in the private section:

basic_stringbuf(const basic_stringbuf&);             // not defined
basic_stringbuf& operator=(const basic_stringbuf&);  // not defined

Option B:

Insert into the basic_stringbuf synopsis in the public section:

basic_stringbuf(const basic_stringbuf& sb);
basic_stringbuf& operator=(const basic_stringbuf& sb);

27.7.1.1, insert after paragraph 4:

basic_stringbuf(const basic_stringbuf& sb);

Constructs an independent copy of sb as if with sb.str(), and with the openmode that sb was constructed with.

Postcondtions:

               str() == sb.str()
               gptr()  - eback() == sb.gptr()  - sb.eback()
               egptr() - eback() == sb.egptr() - sb.eback()
               pptr()  - pbase() == sb.pptr()  - sb.pbase()
               getloc() == sb.getloc()

Note: The only requirement on epptr() is that it point beyond the initialized range if an output sequence exists. There is no requirement that epptr() - pbase() == sb.epptr() - sb.pbase().

basic_stringbuf& operator=(const basic_stringbuf& sb);

After assignment the basic_stringbuf has the same state as if it were initially copy constructed from sb, except that the basic_stringbuf is allowed to retain any excess capacity it might have, which may in turn effect the value of epptr().

27.8.1.1 [lib.filebuf]

Insert at the bottom of the basic_filebuf synopsis:

private:
  basic_filebuf(const basic_filebuf&);             // not defined
  basic_filebuf& operator=(const basic_filebuf&);  // not defined

[Kona: this is an issue for basic_streambuf itself and for its derived classes. We are leaning toward allowing basic_streambuf to be copyable, and specifying its precise semantics. (Probably the obvious: copying the buffer pointers.) We are less sure whether the streambuf derived classes should be copyable. Howard will write up a proposal.]

[Sydney: Dietmar presented a new argument against basic_streambuf being copyable: it can lead to an encapsulation violation. filebuf inherits from streambuf. Now suppose you inherit a my_hijacking_buf from streambuf. You can copy the streambuf portion of a filebuf to a my_hijacking_buf, giving you access to the pointers into the filebuf's internal buffer. Perhaps not a very strong argument, but it was strong enough to make people nervous. There was weak preference for having streambuf not be copyable. There was weak preference for having stringbuf not be copyable even if streambuf is. Move this issue to open for now. ]

[ 2007-01-12, Howard: Rvalue Reference Recommendations for Chapter 27 recommends protected copy constructor and assignment for basic_streambuf with the same semantics as would be generated by the compiler. These members aid in derived classes implementing move semantics. A protected copy constructor and copy assignment operator do not expose encapsulation more so than it is today as each data member of a basic_streambuf is already both readable and writable by derived classes via various get/set protected member functions (eback(), setp(), etc.). Rather a protected copy constructor and copy assignment operator simply make the job of derived classes implementing move semantics less tedious and error prone. ]

Rationale:

27.5.2 [lib.streambuf]: The proposed basic_streambuf copy constructor and assignment operator are the same as currently implied by the lack of declarations: public and simply copies the data members. This resolution is not a change but a clarification of the current standard.

27.7.1 [lib.stringbuf]: There are two reasonable options: A) Make basic_stringbuf not copyable. This is likely the status-quo of current implementations. B) Reasonable copy semantics of basic_stringbuf can be defined and implemented. A copyable basic_streambuf is arguably more useful than a non-copyable one. This should be considered as new functionality and not the fixing of a defect. If option B is chosen, ramifications from issue 432 are taken into account.

27.8.1.1 [lib.filebuf]: There are no reasonable copy semantics for basic_filebuf.


424(i). normative notes

Section: 16.3.2.2 [structure.summary] Status: NAD Editorial Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2016-11-12

Priority: Not Prioritized

View all issues with NAD Editorial status.

Discussion:

The text in 17.3.1.1, p1 says:
"Paragraphs labelled "Note(s):" or "Example(s):" are informative, other paragraphs are normative."
The library section makes heavy use of paragraphs labeled "Notes(s)," some of which are clearly intended to be normative (see list 1), while some others are not (see list 2). There are also those where the intent is not so clear (see list 3).

List 1 -- Examples of (presumably) normative Notes:
20.2.10.2 [allocator.members], p3,
20.2.10.2 [allocator.members], p10,
27.4.3.3 [string.cons], p11,
28.3.3.1.3 [locale.cons], p11,
23.3.5.4 [deque.modifiers], p2,
26.8.9 [alg.min.max], p3,
29.4.6 [complex.ops], p15,
31.6.3.5.3 [streambuf.virt.get], p7.

List 2 -- Examples of (presumably) informative Notes:
17.6.3.4 [new.delete.placement], p3,
27.4.3.7.6 [string.replace], p14,
28.3.4.2.5.3 [locale.codecvt.virtuals], p3,
26.6.5 [alg.foreach], p4,
29.4.5 [complex.member.ops], p1,
31.5.2.6 [ios.base.storage], p6.

List 3 -- Examples of Notes that are not clearly either normative or informative:
28.3.3.1.3 [locale.cons], p8,
28.3.3.1.6 [locale.statics], p6,
31.6.3.5.5 [streambuf.virt.put], p4.

None of these lists is meant to be exhaustive.

[Definitely a real problem. The big problem is there's material that doesn't quite fit any of the named paragraph categories (e.g. Effects). Either we need a new kind of named paragraph, or we need to put more material in unnamed paragraphs jsut after the signature. We need to talk to the Project Editor about how to do this. ]

[ Bellevue: Specifics of list 3: First 2 items correct in std (22.1.1.2, 22.1.1.5) Third item should be non-normative (27.5.2.4.5), which Pete will handle editorially. ]

[ post San Francisco: Howard: reopened, needs attention. ]

[Pete: I changed the paragraphs marked "Note" and "Notes" to use "Remark" and "Remarks". Fixed as editorial. This change has been in the WD since the post-Redmond mailing, in 2004. Recommend NAD.]

[ Batavia: We feel that the references in List 2 above should be changed from Remarks to Notes. We also feel that those items in List 3 need to be double checked for the same change. Alan and Pete to review. ]

[ Batavia (2009-05): ]

A spot-check of List 2 suggests the issue is still relevant, and a review of List 3 still seems called-for.

Move to NAD Editorial.

Proposed resolution:


429(i). typo in basic_ios::clear(iostate)

Section: 31.5.4.4 [iostate.flags] Status: Dup Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [iostate.flags].

View all issues with Dup status.

Duplicate of: 412

Discussion:

The Effects clause in 27.4.4.3, p5 describing the effects of a call to the ios_base member function clear(iostate state) says that the function only throws if the respective bits are already set prior to the function call. That's obviously not the intent. If it was, a call to clear(badbit) on an object for which (rdstate() == goodbit && exceptions() == badbit) holds would not result in an exception being thrown.

Proposed resolution:

The text ought to be changed from
"If (rdstate() & exceptions()) == 0, returns. ..."
to
"If (state & exceptions()) == 0, returns. ..."

Rationale:


433(i). Contradiction in specification of unexpected()

Section: 99 [unexpected] Status: NAD Submitter: Vyatcheslav Sysoltsev Opened: 2003-09-29 Last modified: 2016-01-28

Priority: Not Prioritized

View all issues with NAD status.

Discussion:

Clause [except.unexpected] paragraph 1 says that "void unexpected(); is called (18.7.2) immediately after completing the stack unwinding for the former function", but 18.7.2.4 (Effects) says that "void unexpected(); . . . Calls the unexpected_handler function in effect immediately after evaluating the throwexpression (18.7.2.2),". Isn't here a contradiction: 15.5.2 requires stack have been unwound when in void unexpected() and therefore in unexpected_handler but 18.7.2.4 claims that unexpected_handler is called "in effect immediately" after evaluation of throw expression is finished, so there is no space left for stack to be unwound therefore? I think the phrase "in effect immediately" should be removed from the standard because it brings ambiguity in understanding.

Proposed resolution:

Rationale:

There is no contradiction. The phrase "in effect immediately" is just to clarify which handler is to be called.


437(i). Formatted output of function pointers is confusing

Section: 31.7.6.3.2 [ostream.inserters.arithmetic] Status: NAD Submitter: Ivan Godard Opened: 2003-10-24 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [ostream.inserters.arithmetic].

View all issues with NAD status.

Discussion:

Given:

void f(int) {}
void(*g)(int) = f;
cout << g;

(with the expected #include and usings), the value printed is a rather surprising "true". Rather useless too.

The standard defines:

ostream& operator<<(ostream&, void*);

which picks up all data pointers and prints their hex value, but does not pick up function pointers because there is no default conversion from function pointer to void*. Absent that, we fall back to legacy conversions from C and the function pointer is converted to bool.

There should be an analogous inserter that prints the address of a function pointer.

Proposed resolution:

Rationale:

This is indeed a wart, but there is no good way to solve it. C doesn't provide a portable way of outputting the address of a function point either.


439(i). Should facets be copyable?

Section: 28.3.4 [locale.categories] Status: NAD Submitter: Matt Austern Opened: 2003-11-02 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.categories].

View all issues with NAD status.

Discussion:

The following facets classes have no copy constructors described in the standard, which, according to the standard, means that they are supposed to use the compiler-generated defaults. Default copy behavior is probably inappropriate. We should either make these classes uncopyable or else specify exactly what their constructors do.

Related issue: 421(i).

        ctype_base
        ctype
        ctype_byname
        ctype<char>
        ctype_byname<char>
        codecvt_base
        codecvt
        codecvt_byname
        num_get
        num_put
        numpunct
        numpunct_byname
        collate
        collate_byname
        time_base
        time_get
        time_get_byname
        time_put
        time_put_byname
        money_get
        money_put
        money_base
        moneypunct
        moneypunct_byname
        messages_base
        messages
        messages_byname

Proposed resolution:

Rationale:

The copy constructor in the base class is private.


440(i). Should std::complex use unqualified transcendentals?

Section: 29.4.8 [complex.transcendentals] Status: NAD Submitter: Matt Austern Opened: 2003-11-05 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [complex.transcendentals].

View all issues with NAD status.

Discussion:

Operations like pow and exp on complex<T> are typically implemented in terms of operations like sin and cos on T. Should implementations write this as std::sin, or as plain unqualified sin?

The issue, of course, is whether we want to use argument-dependent lookup in the case where T is a user-defined type. This is similar to the issue of valarray transcendentals, as discussed in issue 226(i).

This issue differs from valarray transcendentals in two important ways. First, "the effect of instantiating the template complex for types other than float, double or long double is unspecified." (29.4.2 [complex.syn]) Second, the standard does not dictate implementation, so there is no guarantee that a particular real math function is used in the implementation of a particular complex function.

Proposed resolution:

Rationale:

If you instantiate std::complex for user-defined types, all bets are off.


446(i). Iterator equality between different containers

Section: 24.3 [iterator.requirements], 23.2 [container.requirements] Status: NAD Editorial Submitter: Andy Koenig Opened: 2003-12-16 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [iterator.requirements].

View all issues with NAD Editorial status.

Discussion:

What requirements does the standard place on equality comparisons between iterators that refer to elements of different containers. For example, if v1 and v2 are empty vectors, is v1.end() == v2.end() allowed to yield true? Is it allowed to throw an exception?

The standard appears to be silent on both questions.

[Sydney: The intention is that comparing two iterators from different containers is undefined, but it's not clear if we say that, or even whether it's something we should be saying in clause 23 or in clause 24. Intuitively we might want to say that equality is defined only if one iterator is reachable from another, but figuring out how to say it in any sensible way is a bit tricky: reachability is defined in terms of equality, so we can't also define equality in terms of reachability. ]

[ 2009-07 Frankfurt ]

Daniel volunteered to work on this.

[ 2009-09-20 Daniel provided wording. ]

[ 2009-10 Santa Cruz: ]

Leave as Open. Alisdair has volunteered to refine the wording.

[ 2010 Pittsburgh: Moved to NAD Editorial. Rationale added below. ]

Rationale:

Solved by N3066.

Proposed resolution:

Insert a new paragraph between 24.3 [iterator.requirements]/7+8:

[..] The result of the application of functions in the library to invalid ranges is undefined.

The result of directly or indirectly evaluating any comparison function or the binary - operator with two iterator values as arguments that were obtained from two different ranges r1 and r2 (including their past-the-end values) which are not subranges of one common range is undefined, unless explicitly described otherwise.


447(i). Wrong template argument for time facets

Section: 28.3.3.1.2.1 [locale.category] Status: Dup Submitter: Pete Becker Opened: 2003-12-26 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.category].

View all issues with Dup status.

Duplicate of: 327

Discussion:

22.1.1.1.1/4, table 52, "Required Instantiations", lists, among others:

    time_get<char,InputIterator>
    time_get_byname<char,InputIterator>
    time_get<wchar_t,OutputIterator>
    time_get_byname<wchar_t,OutputIterator>

The second argument to the last two should be InputIterator, not OutputIterator.

Proposed resolution:

Change the second template argument to InputIterator.

Rationale:


450(i). set::find is inconsistent with associative container requirements

Section: 23.4.6 [set] Status: Dup Submitter: Bill Plauger Opened: 2004-01-30 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [set].

View all issues with Dup status.

Duplicate of: 214

Discussion:

map/multimap have:

    iterator find(const key_type& x) const;
    const_iterator find(const key_type& x) const;

which is consistent with the table of associative container requirements. But set/multiset have:

    iterator find(const key_type&) const;

set/multiset should look like map/multimap, and honor the requirements table, in this regard.

Proposed resolution:

Rationale:


451(i). Associative erase should return an iterator

Section: 23.2.7 [associative.reqmts], 23.4 [associative] Status: Dup Submitter: Bill Plauger Opened: 2004-01-30 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [associative.reqmts].

View all other issues in [associative.reqmts].

View all issues with Dup status.

Duplicate of: 130

Discussion:

map/multimap/set/multiset have:

    void erase(iterator);
    void erase(iterator, iterator);

But there's no good reason why these can't return an iterator, as for vector/deque/list:

    iterator erase(iterator);
    iterator erase(iterator, iterator);

Proposed resolution:

Informally: The table of associative container requirements, and the relevant template classes, should return an iterator designating the first element beyond the erased subrange.

Rationale:


452(i). locale::combine should be permitted to generate a named locale

Section: 28.3.3.1.4 [locale.members] Status: NAD Submitter: Bill Plauger Opened: 2004-01-30 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.members].

View all issues with NAD status.

Discussion:

template<class Facet>
    locale::combine(const locale&) const;

is obliged to create a locale that has no name. This is overspecification and overkill. The resulting locale should follow the usual rules -- it has a name if the locale argument has a name and Facet is one of the standard facets.

[ Sydney and post-Sydney (see c++std-lib-13439, c++std-lib-13440, c++std-lib-13443): agreed that it's overkill to say that the locale is obligated to be nameless. However, we also can't require it to have a name. At the moment, locale names are based on categories and not on individual facets. If a locale contains two different facets of different names from the same category, then this would not fit into existing naming schemes. We need to give implementations more freedom. Bill will provide wording. ]

Rationale:

After further discussion the LWG decided to close this as NAD. The fundamental problem is that names right now are per-category, not per-facet. The combine member function works at the wrong level of granularity.


454(i). basic_filebuf::open should accept wchar_t names

Section: 31.10.3.4 [filebuf.members] Status: NAD Submitter: Bill Plauger Opened: 2004-01-30 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [filebuf.members].

View all issues with NAD status.

Duplicate of: 105

Discussion:

    basic_filebuf *basic_filebuf::open(const char *, ios_base::open_mode);

should be supplemented with the overload:

    basic_filebuf *basic_filebuf::open(const wchar_t *, ios_base::open_mode);

Depending on the operating system, one of these forms is fundamental and the other requires an implementation-defined mapping to determine the actual filename.

[Sydney: Yes, we want to allow wchar_t filenames. Bill will provide wording.]

[ In Toronto we noted that this is issue 5 from N1569. ]

How does this interact with the newly-defined character types, and how do we avoid interface explosion considering std::string overloads that were added? Propose another solution that is different than the suggestion proposed by PJP.

Suggestion is to make a member template function for basic_string (for char, wchar_t, u16char, u32char instantiations), and then just keep a const char* member.

Goal is to do implicit conversion between character string literals to appropriate basic_string type. Not quite sure if this is possible.

Implementors are free to add specific overloads for non-char character types.

[ Martin adds pre-Sophia Antipolis: ]

Please see issue 454: problems and solutions.

[ Sophia Antipolis: ]

Beman is concerned that making these changes to basic_filebuf is not usefully changed unless fstream is also changed; this also only handles wchar_t and not other character types.

The TR2 filesystem library is a more complete solution, but is not available soon.

[ Martin adds: please reference N2683 for problems and solutions. ]

Proposed resolution:

Change from:

basic_filebuf<charT,traits>* open(
    const char* s,
    ios_base::openmode mode );

Effects: If is_open() != false, returns a null pointer. Otherwise, initializes the filebuf as required. It then opens a file, if possible, whose name is the NTBS s ("as if" by calling std::fopen(s,modstr)).

to:

basic_filebuf<charT,traits>* open(
    const char* s,
    ios_base::openmode mode );

basic_filebuf<charT,traits>* open(
    const wchar_t* ws,
    ios_base::openmode mode );

Effects: If is_open() != false, returns a null pointer. Otherwise, initializes the filebuf as required. It then opens a file, if possible, whose name is the NTBS s ("as if" by calling std::fopen(s,modstr)). For the second signature, the NTBS s is determined from the WCBS ws in an implementation-defined manner.

(NOTE: For a system that "naturally" represents a filename as a WCBS, the NTBS s in the first signature may instead be mapped to a WCBS; if so, it follows the same mapping rules as the first argument to open.)

Rationale:

Slightly controversial, but by a 7-1 straw poll the LWG agreed to move this to Ready. The controversy was because the mapping between wide names and files in a filesystem is implementation defined. The counterargument, which most but not all LWG members accepted, is that the mapping between narrow files names and files is also implemenation defined.

[Lillehammer: Moved back to "open" status, at Beman's urging. (1) Why just basic_filebuf, instead of also basic_fstream (and possibly other things too). (2) Why not also constructors that take std::basic_string? (3) We might want to wait until we see Beman's filesystem library; we might decide that it obviates this.]

[ post Bellevue: ]

Move again to Ready.

There is a timing issue here. Since the filesystem library will not be in C++0x, this should be brought forward. This solution would remain valid in the context of the proposed filesystem.

This issue has been kicking around for a while, and the wchar_t addition alone would help many users. Thus, we suggest putting this on the reflector list with an invitation for someone to produce proposed wording that covers basic_fstream. In the meantime, we suggest that the proposed wording be adopted as-is.

If more of the Lillehammer questions come back, they should be introduced as separate issues.

[ San Francisco: ]

Some existing implementations provide overload already. Expected filesystem "path" object overloads neatly, without surprises; implying NAD.


458(i). 24.1.5 contains unintended limitation for operator-

Section: 24.3.5.7 [random.access.iterators] Status: NAD Submitter: Daniel Frey Opened: 2004-02-27 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [random.access.iterators].

View all issues with NAD status.

Discussion:

In 24.1.5 [lib.random.access.iterators], table 76 the operational semantics for the expression "r -= n" are defined as "return r += -n". This means, that the expression -n must be valid, which is not the case for unsigned types.

[ Sydney: Possibly not a real problem, since difference type is required to be a signed integer type. However, the wording in the standard may be less clear than we would like. ]

[ Post Summit Alisdair adds: ]

This issue refers to a requirements table we have removed.

The issue might now relate to 24.3.5.7 [random.access.iterators] p5. However, the rationale in the issue already recognises that the difference_type must be signed, so this really looks NAD.

[ Batavia (2009-05): ]

We agree with Alisdair's observations.

Move to NAD.

[ 2009-07 Frankfurt: ]

Need to look at again without concepts.

There was a question about this phrase in the discussion: "the expression -n must be valid, which is not the case for unsigned types." If n is an object of the iterator difference_type (eg ptrdiff_t), then it is never unsigned.

[ 2009-10 Santa Cruz: ]

The group reviewed the wording in the draft and agreed that n is of difference type, the difference type is signed, and the current wording is correct. Moved to NAD.

Proposed resolution:

To remove this limitation, I suggest to change the operational semantics for this column to:

    { Distance m = n;
      if (m >= 0)
        while (m--) --r;
      else
        while (m++) ++r;
      return r; }

459(i). Requirement for widening in stage 2 is overspecification

Section: 28.3.4.3.2.3 [facet.num.get.virtuals] Status: NAD Submitter: Martin Sebor Opened: 2004-03-16 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [facet.num.get.virtuals].

View all other issues in [facet.num.get.virtuals].

View all issues with NAD status.

Discussion:

When parsing strings of wide-character digits, the standard requires the library to widen narrow-character "atoms" and compare the widened atoms against the characters that are being parsed. Simply narrowing the wide characters would be far simpler, and probably more efficient. The two choices are equivalent except in convoluted test cases, and many implementations already ignore the standard and use narrow instead of widen.

First, I disagree that using narrow() instead of widen() would necessarily have unfortunate performance implications. A possible implementation of narrow() that allows num_get to be implemented in a much simpler and arguably comparably efficient way as calling widen() allows, i.e. without making a virtual call to do_narrow every time, is as follows:

  inline char ctype<wchar_t>::narrow (wchar_t wc, char dflt) const
  {
      const unsigned wi = unsigned (wc);

      if (wi > UCHAR_MAX)
          return typeid (*this) == typeid (ctype<wchar_t>) ?
                 dflt : do_narrow (wc, dflt);

      if (narrow_ [wi] < 0) {
         const char nc = do_narrow (wc, dflt);
         if (nc == dflt)
             return dflt;
         narrow_ [wi] = nc;
      }

      return char (narrow_ [wi]);
  }

Second, I don't think the change proposed in the issue (i.e., to use narrow() instead of widen() during Stage 2) would be at all drastic. Existing implementations with the exception of libstdc++ currently already use narrow() so the impact of the change on programs would presumably be isolated to just a single implementation. Further, since narrow() is not required to translate alternate wide digit representations such as those mentioned in issue 303(i) to their narrow equivalents (i.e., the portable source characters '0' through '9'), the change does not necessarily imply that these alternate digits would be treated as ordinary digits and accepted as part of numbers during parsing. In fact, the requirement in 28.3.4.2.2.3 [locale.ctype.virtuals], p13 forbids narrow() to translate an alternate digit character, wc, to an ordinary digit in the basic source character set unless the expression (ctype<charT>::is(ctype_base::digit, wc) == true) holds. This in turn is prohibited by the C standard (7.25.2.1.5, 7.25.2.1.5, and 5.2.1, respectively) for charT of either char or wchar_t.

[Sydney: To a large extent this is a nonproblem. As long as you're only trafficking in char and wchar_t we're only dealing with a stable character set, so you don't really need either 'widen' or 'narrow': can just use literals. Finally, it's not even clear whether widen-vs-narrow is the right question; arguably we should be using codecvt instead.]

[ 2009-07 Frankfurt ]

NAD. The standard is clear enough as written.

Proposed resolution:

Change stage 2 so that implementations are permitted to use either technique to perform the comparison:

  1. call widen on the atoms and compare (either by using operator== or char_traits<charT>::eq) the input with the widened atoms, or
  2. call narrow on the input and compare the narrow input with the atoms
  3. do (1) or (2) only if charT is not char or wchar_t, respectively; i.e., avoid calling widen or narrow if it the source and destination types are the same

462(i). Destroying objects with static storage duration

Section: 6.9.3.4 [basic.start.term], 17.2.2 [cstdlib.syn] Status: NAD Submitter: Bill Plauger Opened: 2004-03-23 Last modified: 2023-02-07

Priority: Not Prioritized

View all issues with NAD status.

Discussion:

3.6.3 Termination spells out in detail the interleaving of static destructor calls and calls to functions registered with atexit. To match this behavior requires intimate cooperation between the code that calls destructors and the exit/atexit machinery. The former is tied tightly to the compiler; the latter is a primitive mechanism inherited from C that traditionally has nothing to do with static construction and destruction. The benefits of intermixing destructor calls with atexit handler calls is questionable at best, and very difficult to get right, particularly when mixing third-party C++ libraries with different third-party C++ compilers and C libraries supplied by still other parties.

I believe the right thing to do is defer all static destruction until after all atexit handlers are called. This is a change in behavior, but one that is likely visible only to perverse test suites. At the very least, we should permit deferred destruction even if we don't require it.

[If this is to be changed, it should probably be changed by CWG. At this point, however, the LWG is leaning toward NAD. Implementing what the standard says is hard work, but it's not impossible and most vendors went through that pain years ago. Changing this behavior would be a user-visible change, and would break at least one real application.]

[ Batavia: Send to core with our recommendation that we should permit deferred destruction but not require it. ]

[ Howard: The course of action recommended in Batavia would undo LWG issue 3(i) and break current code implementing the "phoenix singleton". Search the net for "phoenix singleton atexit" to get a feel for the size of the adverse impact this change would have. Below is sample code which implements the phoenix singleton and would break if atexit is changed in this way: ]

#include <cstdlib>
#include <iostream>
#include <type_traits>
#include <new>

class A
{
    bool alive_;
    A(const A&);
    A& operator=(const A&);
public:
    A() : alive_(true) {std::cout << "A()\n";}
    ~A() {alive_ = false; std::cout << "~A()\n";}
    void use()
    {
        if (alive_)
            std::cout << "A is alive\n";
        else
            std::cout << "A is dead\n";
    }
};

void deallocate_resource();

// This is the phoenix singleton pattern
A& get_resource(bool create = true)
{
    static std::aligned_storage<sizeof(A), std::alignment_of<A>::value>::type buf;
    static A* a;
    if (create)
    {
        if (a != (A*)&buf)
        {
            a = ::new (&buf) A;
            std::atexit(deallocate_resource);
        }
    }
    else
    {
        a->~A();
        a = (A*)&buf + 1;
    }
    return *a;
}

void deallocate_resource()
{
    get_resource(false);
}

void use_A(const char* message)
{
    A& a = get_resource();
    std::cout << "Using A " << message << "\n";
    a.use();
}

struct B
{
    ~B() {use_A("from ~B()");}
};

B b;

int main()
{
    use_A("from main()");
}

The correct output is:

A()
Using A from main()
A is alive
~A()
A()
Using A from ~B()
A is alive
~A()

[ Bellevue: Confirmed no interaction with quick_exit. Strong feeling against mandating the change. Leaning towards NAD rather than permitting the change, as this would make common implementations of pheonix-singleton pattern implementation defined, as noted by Howard. Bill agrees issue is no longer serious, and accepts NAD. ]

Proposed resolution:


463(i). auto_ptr usability issues

Section: 99 [auto.ptr] Status: NAD Submitter: Rani Sharoni Opened: 2003-12-07 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [auto.ptr].

View all issues with NAD status.

Discussion:

TC1 CWG DR #84 effectively made the template<class Y> operator auto_ptr<Y>() member of auto_ptr (20.4.5.3/4) obsolete.

The sole purpose of this obsolete conversion member is to enable copy initialization base from r-value derived (or any convertible types like cv-types) case:

#include <memory>
using std::auto_ptr;

struct B {};
struct D : B {};

auto_ptr<D> source();
int sink(auto_ptr<B>);
int x1 = sink( source() ); // #1 EDG - no suitable copy constructor

The excellent analysis of conversion operations that was given in the final auto_ptr proposal (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1997/N1128.pdf) explicitly specifies this case analysis (case 4). DR #84 makes the analysis wrong and actually comes to forbid the loophole that was exploited by the auto_ptr designers.

I didn't encounter any compliant compiler (e.g. EDG, GCC, BCC and VC) that ever allowed this case. This is probably because it requires 3 user defined conversions and in fact current compilers conform to DR #84.

I was surprised to discover that the obsolete conversion member actually has negative impact of the copy initialization base from l-value derived case:

auto_ptr<D> dp;
int x2 = sink(dp); // #2 EDG - more than one user-defined conversion applies

I'm sure that the original intention was allowing this initialization using the template<class Y> auto_ptr(auto_ptr<Y>& a) constructor (20.4.5.1/4) but since in this copy initialization it's merely user defined conversion (UDC) and the obsolete conversion member is UDC with the same rank (for the early overloading stage) there is an ambiguity between them.

Removing the obsolete member will have impact on code that explicitly invokes it:

int y = sink(source().operator auto_ptr<B>());

IMHO no one ever wrote such awkward code and the reasonable workaround for #1 is:

int y = sink( auto_ptr<B>(source()) );

I was even more surprised to find out that after removing the obsolete conversion member the initialization was still ill-formed: int x3 = sink(dp); // #3 EDG - no suitable copy constructor

This copy initialization semantically requires copy constructor which means that both template conversion constructor and the auto_ptr_ref conversion member (20.4.5.3/3) are required which is what was explicitly forbidden in DR #84. This is a bit amusing case in which removing ambiguity results with no candidates.

I also found exception safety issue with auto_ptr related to auto_ptr_ref:

int f(auto_ptr<B>, std::string);
auto_ptr<B> source2();

// string constructor throws while auto_ptr_ref
// "holds" the pointer
int x4 = f(source2(), "xyz"); // #4

The theoretic execution sequence that will cause a leak:

  1. call auto_ptr<B>::operator auto_ptr_ref<B>()
  2. call string::string(char const*) and throw

According to 20.4.5.3/3 and 20.4.5/2 the auto_ptr_ref conversion member returns auto_ptr_ref<Y> that holds *this and this is another defect since the type of *this is auto_ptr<X> where X might be different from Y. Several library vendors (e.g. SGI) implement auto_ptr_ref<Y> with Y* as member which is much more reasonable. Other vendor implemented auto_ptr_ref as defectively required and it results with awkward and catastrophic code: int oops = sink(auto_ptr<B>(source())); // warning recursive on all control paths

Dave Abrahams noticed that there is no specification saying that auto_ptr_ref copy constructor can't throw.

My proposal comes to solve all the above issues and significantly simplify auto_ptr implementation. One of the fundamental requirements from auto_ptr is that it can be constructed in an intuitive manner (i.e. like ordinary pointers) but with strict ownership semantics which yield that source auto_ptr in initialization must be non-const. My idea is to add additional constructor template with sole propose to generate ill-formed, diagnostic required, instance for const auto_ptr arguments during instantiation of declaration. This special constructor will not be instantiated for other types which is achievable using 14.8.2/2 (SFINAE). Having this constructor in hand makes the constructor template<class Y> auto_ptr(auto_ptr<Y> const&) legitimate since the actual argument can't be const yet non const r-value are acceptable.

This implementation technique makes the "private auxiliary class" auto_ptr_ref obsolete and I found out that modern C++ compilers (e.g. EDG, GCC and VC) consume the new implementation as expected and allow all intuitive initialization and assignment cases while rejecting illegal cases that involve const auto_ptr arguments.

The proposed auto_ptr interface:

namespace std {
    template<class X> class auto_ptr {
    public:
        typedef X element_type;

        // 20.4.5.1 construct/copy/destroy:
        explicit auto_ptr(X* p=0) throw();
        auto_ptr(auto_ptr&) throw();
        template<class Y> auto_ptr(auto_ptr<Y> const&) throw();
        auto_ptr& operator=(auto_ptr&) throw();
        template<class Y> auto_ptr& operator=(auto_ptr<Y>) throw();
        ~auto_ptr() throw();

        // 20.4.5.2 members:
        X& operator*() const throw();
        X* operator->() const throw();
        X* get() const throw();
        X* release() throw();
        void reset(X* p=0) throw();

    private:
        template<class U>
        auto_ptr(U& rhs, typename
unspecified_error_on_const_auto_ptr<U>::type = 0);
    };
}

One compliant technique to implement the unspecified_error_on_const_auto_ptr helper class is using additional private auto_ptr member class template like the following:

template<typename T> struct unspecified_error_on_const_auto_ptr;

template<typename T>
struct unspecified_error_on_const_auto_ptr<auto_ptr<T> const>
{ typedef typename auto_ptr<T>::const_auto_ptr_is_not_allowed type; };

There are other techniques to implement this helper class that might work better for different compliers (i.e. better diagnostics) and therefore I suggest defining its semantic behavior without mandating any specific implementation. IMO, and I didn't found any compiler that thinks otherwise, 14.7.1/5 doesn't theoretically defeat the suggested technique but I suggest verifying this with core language experts.

Further changes in standard text:

Remove section 20.4.5.3

Change 20.4.5/2 to read something like: Initializing auto_ptr<X> from const auto_ptr<Y> will result with unspecified ill-formed declaration that will require unspecified diagnostic.

Change 20.4.5.1/4,5,6 to read:

template<class Y> auto_ptr(auto_ptr<Y> const& a) throw();

4 Requires: Y* can be implicitly converted to X*.

5 Effects: Calls const_cast<auto_ptr<Y>&>(a).release().

6 Postconditions: *this holds the pointer returned from a.release().

Change 20.4.5.1/10

template<class Y> auto_ptr& operator=(auto_ptr<Y> a) throw();

10 Requires: Y* can be implicitly converted to X*. The expression delete get() is well formed.

LWG TC DR #127 is obsolete.

Notice that the copy constructor and copy assignment operator should remain as before and accept non-const auto_ptr& since they have effect on the form of the implicitly declared copy constructor and copy assignment operator of class that contains auto_ptr as member per 12.8/5,10:

struct X {
    // implicit X(X&)
    // implicit X& operator=(X&)
    auto_ptr<D> aptr_;
};

In most cases this indicates about sloppy programming but preserves the current auto_ptr behavior.

Dave Abrahams encouraged me to suggest fallback implementation in case that my suggestion that involves removing of auto_ptr_ref will not be accepted. In this case removing the obsolete conversion member to auto_ptr<Y> and 20.4.5.3/4,5 is still required in order to eliminate ambiguity in legal cases. The two constructors that I suggested will co exist with the current members but will make auto_ptr_ref obsolete in initialization contexts. auto_ptr_ref will be effective in assignment contexts as suggested in DR #127 and I can't see any serious exception safety issues in those cases (although it's possible to synthesize such). auto_ptr_ref<X> semantics will have to be revised to say that it strictly holds pointer of type X and not reference to an auto_ptr for the favor of cases in which auto_ptr_ref<Y> is constructed from auto_ptr<X> in which X is different from Y (i.e. assignment from r-value derived to base).

[Redmond: punt for the moment. We haven't decided yet whether we want to fix auto_ptr for C++-0x, or remove it and replace it with move_ptr and unique_ptr.]

[ Oxford 2007: Recommend NAD. We're just going to deprecate it. It still works for simple use cases and people know how to deal with it. Going forward unique_ptr is the recommended tool. ]

[ 2007-11-09: Reopened at the request of David Abrahams, Alisdair Meredith and Gabriel Dos Reis. ]

[ 2009-07 Frankfurt ]

This is a complicated issue, so we agreed to defer discussion until later in the week so that interested parties can read up on it.

[ 2009-10-04 Daniel adds: ]

I suggest to close this issue as NAD. The reasons are two-fold: First, the suggested proposed resolution uses no longer appropriate language means to solve this issue, which has the effect that the recommended resolution is another - but better - form of hack. Second, either following the suggested resolution or the now more natural alternative via the added member set

template<class Y> auto_ptr(auto_ptr<Y>&&) throw();
template<class Y> auto_ptr& operator=(auto_ptr<Y>&&) throw();

would still have a non-zero probability to break user-code that actively references auto_ptr_ref. This risk seems to indicate that a decision which would not touch the current spec of auto_ptr at all (but deprecating it) and instead recommending to use unique_ptr for new code instead might have the best cost-benefit ratio. IMO the current solution of 1100(i) can be considered as an active user-support for this transition.

[ 2009-10 Santa Cruz: ]

Mark as NAD. Alisdair will open a new issue (1247(i)) with proposed wording to handle auto_ptr_ref.

Proposed resolution:

Change the synopsis in 99 [auto.ptr]:

namespace std { 
  template <class Y> struct auto_ptr_ref {};

  // exposition only
  template <class T> struct constant_object;

  // exposition only
  template <class T>
  struct cannot_transfer_ownership_from
    : constant_object<T> {};

  template <class X> class auto_ptr { 
  public: 
    typedef X element_type; 

    // D.9.1.1 construct/copy/destroy: 
    explicit auto_ptr(X* p =0) throw(); 
    auto_ptr(auto_ptr&) throw(); 
    template<class Y> auto_ptr(auto_ptr<Y> const&) throw(); 
    auto_ptr& operator=(auto_ptr&) throw(); 
    template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
    auto_ptr& operator=(auto_ptr_ref<X> r) throw();
    ~auto_ptr() throw(); 

    // D.9.1.2 members: 
    X& operator*() const throw();
    X* operator->() const throw();
    X* get() const throw();
    X* release() throw();
    void reset(X* p =0) throw();

    // D.9.1.3 conversions:
    auto_ptr(auto_ptr_ref<X>) throw();
    template<class Y> operator auto_ptr_ref<Y>() throw();
    template<class Y> operator auto_ptr<Y>() throw();

    // exposition only
    template<class U>
    auto_ptr(U& rhs, typename cannot_transfer_ownership_from<U>::error = 0);
  }; 

  template <> class auto_ptr<void> 
  { 
  public: 
    typedef void element_type; 
  }; 

}

Remove 99 [auto.ptr.conv].

Change 99 [auto.ptr], p3:

The auto_ptr provides a semantics of strict ownership. An auto_ptr owns the object it holds a pointer to. Copying an auto_ptr copies the pointer and transfers ownership to the destination. If more than one auto_ptr owns the same object at the same time the behavior of the program is undefined. Templates constant_object and cannot_transfer_ownership_from, and the final constructor of auto_ptr are for exposition only. For any types X and Y, initializing auto_ptr<X> from const auto_ptr<Y> is ill-formed, diagnostic required. [Note: The uses of auto_ptr include providing temporary exception-safety for dynamically allocated memory, passing ownership of dynamically allocated memory to a function, and returning dynamically allocated memory from a function. auto_ptr does not meet the CopyConstructible and Assignable requirements for Standard Library container elements and thus instantiating a Standard Library container with an auto_ptr results in undefined behavior. -- end note]

Change [auto.ptr.cons], p5:

template<class Y> auto_ptr(auto_ptr<Y> const& a) throw();

Requires: Y* can be implicitly converted to X*.

Effects: Calls const_cast<auto_ptr<Y>&>(a).release().

Postconditions: *this holds the pointer returned from a.release().

Change [auto.ptr.cons], p10:

template<class Y> auto_ptr& operator=(auto_ptr<Y>& a) throw();

Requires: Y* can be implicitly converted to X*. The expression delete get() is well formed.

Effects: Calls reset(a.release()).

Returns: *this.


466(i). basic_string ctor should prevent null pointer error

Section: 27.4.3.2 [string.require] Status: NAD Submitter: Daniel Frey Opened: 2004-06-10 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [string.require].

View all issues with NAD status.

Discussion:

Today, my colleagues and me wasted a lot of time. After some time, I found the problem. It could be reduced to the following short example:

  #include <string>
  int main() { std::string( 0 ); }

The problem is that the tested compilers (GCC 2.95.2, GCC 3.3.1 and Comeau online) compile the above without errors or warnings! The programs (at least for the GCC) resulted in a SEGV.

I know that the standard explicitly states that the ctor of string requires a char* which is not zero. STLs could easily detect the above case with a private ctor for basic_string which takes a single 'int' argument. This would catch the above code at compile time and would not ambiguate any other legal ctors.

[Redmond: No great enthusiasm for doing this. If we do, however, we want to do it for all places that take charT* pointers, not just the single-argument constructor. The other question is whether we want to catch this at compile time (in which case we catch the error of a literal 0, but not an expression whose value is a null pointer), at run time, or both. Recommend NAD. Relegate this functionality to debugging implementations.]

[ Post Summit: Alisdair requests this be re-opened as several new language facilities are designed to solve exactly this kind of problem. ]

[ Batavia (2009-05): ]

We are unable to achieve consensus on an approach to a resolution. There is some sentiment for treating this as a QOI matter. It is also possible that when string is brought into the concepts world, this issue might be addressed in that context.

[ 2009-07 Frankfurt ]

We considered three options:

The consensus was NAD.

Proposed resolution:

Add to the synopsis in 27.4.3 [basic.string]

basic_string( nullptr_t ) = delete;

470(i). accessing containers from their elements' special functions

Section: 23 [containers] Status: NAD Submitter: Martin Sebor Opened: 2004-06-28 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [containers].

View all other issues in [containers].

View all issues with NAD status.

Discussion:

The standard doesn't prohibit the destructors (or any other special functions) of containers' elements invoked from a member function of the container from "recursively" calling the same (or any other) member function on the same container object, potentially while the container is in an intermediate state, or even changing the state of the container object while it is being modified. This may result in some surprising (i.e., undefined) behavior.

Read email thread starting with c++std-lib-13637 for more.

Proposed resolution:

Add to Container Requirements the following new paragraph:

    Unless otherwise specified, the behavior of a program that
    invokes a container member function f from a member function
    g of the container's value_type on a container object c that
    called g from its mutating member function h, is undefined.
    I.e., if v is an element of c, directly or indirectly calling
    c.h() from v.g() called from c.f(), is undefined.

[Redmond: This is a real issue, but it's probably a clause 17 issue, not clause 23. We get the same issue, for example, if we try to destroy a stream from one of the stream's callback functions.]

Rationale:

Recommend NAD. We agree this is an issue, but not a defect. We believe that there is no wording we can put in the standard that will cover all cases without introducing unfortunate corner cases.


472(i). Missing "Returns" clause in std::equal_range

Section: 26.8.4.4 [equal.range] Status: Dup Submitter: Prateek R Karandikar Opened: 2004-06-30 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [equal.range].

View all issues with Dup status.

Duplicate of: 270

Discussion:

There is no "Returns:" clause for std::equal_range, which returns non-void.

Proposed resolution:

Rationale:

Fixed as part of issue 270(i).


476(i). Forward Iterator implied mutability

Section: 24.3.5.5 [forward.iterators] Status: NAD Submitter: Dave Abrahams Opened: 2004-07-09 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [forward.iterators].

View all issues with NAD status.

Discussion:

24.1/3 says:

Forward iterators satisfy all the requirements of the input and output iterators and can be used whenever either kind is specified

The problem is that satisfying the requirements of output iterator means that you can always assign *something* into the result of dereferencing it. That makes almost all non-mutable forward iterators non-conforming. I think we need to sever the refinement relationship between forward iterator and output iterator.

Related issue: 200(i). But this is not a dup.

Proposed resolution:

Rationale:

Yes, 24.1/3 does say that. But it's introductory material. The precise specification is in 24.1.3, and the requrements table there is right. We don't need to fine-tune introductory wording. (Especially since this wording is likely to be changed as part of the iterator overhaul.)


477(i). Operator-> for const forward iterators

Section: 24.3.5.5 [forward.iterators] Status: Dup Submitter: Dave Abrahams Opened: 2004-07-11 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [forward.iterators].

View all issues with Dup status.

Duplicate of: 478

Discussion:

The Forward Iterator requirements table contains the following:

 expression  return type         operational  precondition
                                  semantics
  ==========  ==================  ===========  ==========================
  a->m        U& if X is mutable, (*a).m       pre: (*a).m is well-defined.
              otherwise const U&

  r->m        U&                  (*r).m       pre: (*r).m is well-defined.

The first line is exactly right. The second line is wrong. Basically it implies that the const-ness of the iterator affects the const-ness of referenced members. But Paragraph 11 of [lib.iterator.requirements] says:

In the following sections, a and b denote values of type const X, n denotes a value of the difference type Distance, u, tmp, and m denote identifiers, r denotes a value of X&, t denotes a value of value type T, o denotes a value of some type that is writable to the output iterator.

AFAICT if we need the second line at all, it should read the same as the first line.

Related issue: 478(i)

Proposed resolution:

Rationale:

The LWG agrees that this is a real problem. Marked as a DUP because the LWG chose to adopt the solution proposed in 478(i).


479(i). Container requirements and placement new

Section: 23.2 [container.requirements] Status: Dup Submitter: Herb Sutter Opened: 2004-08-01 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [container.requirements].

View all issues with Dup status.

Duplicate of: 580

Discussion:

Nothing in the standard appears to make this program ill-formed:

  struct C {
    void* operator new( size_t s ) { return ::operator new( s ); }
    // NOTE: this hides in-place and nothrow new
  };

  int main() {
    vector<C> v;
    v.push_back( C() );
  }

Is that intentional? We should clarify whether or not we intended to require containers to support types that define their own special versions of operator new.

[ Lillehammer: A container will definitely never use this overridden operator new, but whether it will fail to compile is unclear from the standard. Are containers supposed to use qualified or unqualified placement new? 20.4.1.1 is somewhat relevant, but the standard doesn't make it completely clear whether containers have to use Allocator::construct(). If containers don't use it, the details of how containers use placement new are unspecified. That is the real bug, but it needs to be fixed as part of the allocator overhaul. Weak support that the eventual solution should make this code well formed. ]

Proposed resolution:


480(i). unary_function and binary_function should have protected nonvirtual destructors

Section: 99 [depr.base] Status: NAD Submitter: Joe Gottman Opened: 2004-08-19 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [depr.base].

View all issues with NAD status.

Discussion:

The classes std::unary_function and std::binary_function are both designed to be inherited from but contain no virtual functions. This makes it too easy for a novice programmer to write code like binary_function<int, int, int> *p = new plus<int>; delete p;

There are two common ways to prevent this source of undefined behavior: give the base class a public virtual destructor, or give it a protected nonvirtual destructor. Since unary_function and binary_function have no other virtual functions, (note in particular the absence of an operator()() ), it would cost too much to give them public virtual destructors. Therefore, they should be given protected nonvirtual destructors.

Proposed resolution:

Change Paragraph 20.3.1 of the Standard from

    template <class Arg, class Result>
    struct unary_function {
        typedef Arg argument_type;
        typedef Result result_type;
    };

    template <class Arg1, class Arg2, class Result>
    struct binary_function {
        typedef Arg1 first_argument_type;
        typedef Arg2 second_argument_type;
        typedef Result result_type;
    };

to

    template <class Arg, class Result>
        struct unary_function {
        typedef Arg argument_type;
        typedef Result result_type;
    protected:
        ~unary_function() {}
    };

    template <class Arg1, class Arg2, class Result>
    struct binary_function {
        typedef Arg1 first_argument_type;
        typedef Arg2 second_argument_type;
        typedef Result result_type;
    protected:
        ~binary_function() {}
    };

Rationale:

The LWG doesn't believe the existing definition causes anybody any concrete harm.


481(i). unique's effects on the range [result, last)

Section: 26.7.9 [alg.unique] Status: NAD Submitter: Andrew Koenig Opened: 2004-08-30 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [alg.unique].

View all issues with NAD status.

Discussion:

The standard says that unique(first, last) "eliminates all but the first element from every consecutive group of equal elements" in [first, last) and returns "the end of the resulting range". So a postcondition is that [first, result) is the same as the old [first, last) except that duplicates have been eliminated.

What postconditions are there on the range [result, last)? One might argue that the standard says nothing about those values, so they can be anything. One might also argue that the standard doesn't permit those values to be changed, so they must not be. Should the standard say something explicit one way or the other?

Proposed resolution:

Rationale:

We don't want to make many guarantees about what's in [result, end). Maybe we aren't being quite explicit enough about not being explicit, but it's hard to think that's a major problem.


483(i). Heterogeneous equality and EqualityComparable

Section: 26.6 [alg.nonmodifying], 26.7 [alg.modifying.operations] Status: Dup Submitter: Peter Dimov Opened: 2004-09-20 Last modified: 2016-01-28

Priority: Not Prioritized

View all issues with Dup status.

Duplicate of: 283

Discussion:

c++std-lib-14262

[lib.alg.find] requires T to be EqualityComparable:

template <class InputIterator, class T>
   InputIterator find(InputIterator first, InputIterator last,
                      const T& value);

However the condition being tested, as specified in the Effects clause, is actually *i == value, where i is an InputIterator.

The two clauses are in agreement only if the type of *i is T, but this isn't necessarily the case. *i may have a heterogeneous comparison operator that takes a T, or a T may be convertible to the type of *i.

Further discussion (c++std-lib-14264): this problem affects a number of algorithsm in clause 25, not just find. We should try to resolve this problem everywhere it appears.

Proposed resolution:

[lib.alg.find]:

Remove [lib.alg.find]/1.

[lib.alg.count]:

Remove [lib.alg.count]/1.

[lib.alg.search]:

Remove "Type T is EqualityComparable (20.1.1), " from [lib.alg.search]/4.

[lib.alg.replace]:

Remove [lib.alg.replace]/1. Replace [lb.alg.replace]/2 with:

For every iterator i in the range [first, last) for which *i == value or pred(*i) holds perform *i = new_value.

Remove the first sentence of /4. Replace the beginning of /5 with:

For every iterator i in the range [result, result + (last - first)), assign to *i either...

(Note the defect here, current text says assign to i, not *i).

[lib.alg.fill]:

Remove "Type T is Assignable (23.1), " from /1. Replace /2 with:

For every iterator i in the range [first, last) or [first, first + n), perform *i = value.

[lib.alg.remove]:

Remove /1. Remove the first sentence of /6.

Rationale:

Duplicate of (a subset of) issue 283(i).


486(i). min/max CopyConstructible requirement is too strict

Section: 26.8.9 [alg.min.max] Status: Dup Submitter: Dave Abrahams Opened: 2004-10-13 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [alg.min.max].

View all other issues in [alg.min.max].

View all issues with Dup status.

Duplicate of: 281

Discussion:

A straightforward implementation of these algorithms does not need to copy T.

Proposed resolution:

drop the the words "and CopyConstructible" from paragraphs 1 and 4

Rationale:


487(i). Allocator::construct is too limiting

Section: 16.4.4.6 [allocator.requirements] Status: NAD Submitter: Dhruv Matani Opened: 2004-10-17 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [allocator.requirements].

View all other issues in [allocator.requirements].

View all issues with NAD status.

Discussion:

The standard's version of allocator::construct(pointer, const_reference) severely limits what you can construct using this function. Say you can construct a socket from a file descriptor. Now, using this syntax, I first have to manually construct a socket from the fd, and then pass the constructed socket to the construct() function so it will just to an uninitialized copy of the socket I manually constructed. Now it may not always be possible to copy construct a socket eh! So, I feel that the changes should go in the allocator::construct(), making it:

    template<typename T>
    struct allocator{
      template<typename T1>
      void construct(pointer T1 const& rt1);
    };

Now, the ctor of the class T which matches the one that takes a T1 can be called! Doesn't that sound great?

Proposed resolution:

Rationale:

NAD. STL uses copying all the time, and making it possible for allocators to construct noncopyable objects is useless in the absence of corresponding container changes. We might consider this as part of a larger redesign of STL.


489(i). std::remove / std::remove_if wrongly specified

Section: 26.7.8 [alg.remove] Status: NAD Submitter: Thomas Mang Opened: 2004-12-12 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [alg.remove].

View all issues with NAD status.

Discussion:

In Section 25.2.7 [lib.alg.remove], paragraphs 1 to 5 describe the behavior of the mutating sequence operations std::remove and std::remove_if. However, the wording does not reflect the intended behavior [Note: See definition of intended behavior below] of these algorithms, as it is known to the C++ community [1].

1) Analysis of current wording:

25.2.7 [lib.alg.remove], paragraph 2:

Current wording says: "Effects: Eliminates all the elements referred to by iterator i in the range [first, last) for which the following corresponding conditions hold: *i == value, pred(*i) != false."

This sentences expresses specifically that all elements denoted by the (original) range [first, last) for which the corresponding condition hold will be eliminated. Since there is no formal definition of the term "eliminate" provided, the meaning of "eliminate" in everyday language implies that as postcondition, no element in the range denoted by [first, last) will hold the corresponding condition on reiteration over the range [first, last).

However, this is neither the intent [Note: See definition of intended behavior below] nor a general possible approach. It can be easily proven that if all elements of the original range[first, last) will hold the condition, it is not possible to substitute them by an element for which the condition will not hold.

25.2.7 [lib.alg.remove], paragraph 3:

Current wording says: "Returns: The end of the resulting range."

The resulting range is not specified. In combination with 25.2.7 [lib.alg.remove], paragraph 2, the only reasonable interpretation of this so-called resulting range is the range [first,last) - thus returning always the ForwardIterator 'last' parameter.

25.2.7 [lib.alg.remove], paragraph 4:

Current wording says: "Notes: Stable: the relative order of the elements that are not removed is the same as their relative order in the original range"

This sentences makes use of the term "removed", which is neither specified, nor used in a previous paragraph (which uses the term "eliminate"), nor unamgiuously separated from the name of the algorithm.

2) Description of intended behavior:

For the rest of this Defect Report, it is assumed that the intended behavior was that all elements of the range [first, last) which do not hold the condition *i == value (std::remove) or pred(*i) != false (std::remove_if)], call them s-elements [Note: s...stay], will be placed into a contiguous subrange of [first, last), denoted by the iterators [first, return value). The number of elements in the resulting range [first, return value) shall be equal to the number of s-elements in the original range [first, last). The relative order of the elements in the resulting subrange[first, return value) shall be the same as the relative order of the corresponding elements in the original range. It is undefined whether any elements in the resulting subrange [return value, last) will hold the corresponding condition, or not.

All implementations known to the author of this Defect Report comply with this intent. Since the intent of the behavior (contrary to the current wording) is also described in various utility references serving the C++ community [1], it is not expected that fixing the paragraphs will influence current code - unless the code relies on the behavior as it is described by current wording and the implementation indeed reflects the current wording, and not the intent.

3) Proposed fixes:

Change 25.2.7 [lib.alg.remove], paragraph 2 to:

"Effect: Places all the elements referred to by iterator i in the range [first, last) for which the following corresponding conditions hold : !(*i == value), pred(*i) == false into the subrange [first, k) of the original range, where k shall denote a value of type ForwardIterator. It is undefined whether any elements in the resulting subrange [k, last) will hold the corresponding condition, or not."

Comments to the new wording:

a) "Places" has no special meaning, and the everyday language meaning should fit. b) The corresponding conditions were negated compared to the current wording, becaue the new wording requires it. c) The wording "of the original range" might be redundant, since any subrange starting at 'first' and containing no more elements than the original range is implicitly a subrange of the original range [first, last). d) The iterator k was introduced instead of "return value" in order to avoid a cyclic dependency on 25.2.7/3. The wording ", where k shall denote a value of type ForwardIterator" might be redundant, because it follows implicitly by 25.2.7/3. e) "Places" does, in the author's opinion, explicitly forbid duplicating any element holding the corresponding condition in the original range [first, last) within the resulting range [first, k). If there is doubt this term might be not unambiguous regarding this, it is suggested that k is specified more closely by the following wording: "k shall denote a value of type ForwardIterator [Note: see d)] so that k - first is equal to the number of elements in the original range [first, last) for which the corresponding condition did hold". This could also be expressed as a separate paragraph "Postcondition:" f) The senctence "It is undefined whether any elements in the resulting subrange [k, last) will hold the corresponding condition, or not." was added consciously so the term "Places" does not imply if the original range [first, last) contains n elements holding the corresponding condition, the identical range[first, last) will also contain exactly n elements holding the corresponding condition after application of the algorithm.

Change 25.2.7 [lib.alg.remove], paragraph 3 to: "Returns: The iterator k."

Change 25.2.7 [lib.alg.remove], paragraph 4 to: "Notes: Stable: the relative order of the elements that are placed into the subrange [first, return value) shall be the same as their relative order was in the original range [first, last) prior to application of the algorithm."

Comments to the new wording:

a) the wording "was ... prior to application of the algorithm" is used to explicitly distinguish the original range not only by means of iterators, but also by a 'chronological' factor from the resulting range [first, return value). It might be redundant.

[1]: The wording of these references is not always unambiguous, and provided examples partially contradict verbal description of the algorithms, because the verbal description resembles the problematic wording of ISO/IEC 14882:2003.

Proposed resolution:

Rationale:

The LWG believes that the standard is sufficiently clear, and that there is no evidence of any real-world confusion about this point.


490(i). std::unique wrongly specified

Section: 26.7.9 [alg.unique] Status: NAD Submitter: Thomas Mang Opened: 2004-12-12 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [alg.unique].

View all issues with NAD status.

Discussion:

In Section 25.2.8 [lib.alg.unique], paragraphs 1 to 3 describe the behavior of the mutating sequence operation std::unique. However, the wording does not reflect the intended behavior [Note: See definition of intended behavior below] of these algorithms, as it is known to the C++ community [1].

1) Analysis of current wording:

25.2.8 [lib.alg.unique], paragraph 1:

Current wording says: "Effects: Eliminates all but the first element from every consecutive group of equal elements referred to by the iterator i in the range [first, last) for which the following corresponding conditions hold: *i == *(i - 1) or pred(*i, *(i -1)) != false"

This sentences expresses specifically that all elements denoted by the (original) range [first, last) which are not but the first element from a consecutive group of equal elements (where equality is defined as *i == *(i - 1) or pred(*i, *(i - 1)) ! = false) [Note: See DR 202], call them r-elements [Note: r...remove], will be eliminated. Since there is no formal definition of the term "eliminate" provided, it is undefined how this "elimination" takes place. But the meaning of "eliminate" in everyday language seems to disallow explicitly that after application of the algorithm, any r-element will remain at any position of the range [first, last) [2].

Another defect in the current wording concerns the iterators used to compare two elements for equality: The current wording contains the expression "(i - 1)", which is not covered by 25/9 [Note: See DR submitted by Thomas Mang regarding invalid iterator arithmetic expressions].

25.2.8 [lib.alg.unique], paragraph 2:

Current wording says: "Returns: The end of the resulting range."

The resulting range is not specified. In combination with 25.2.8 [lib.alg.unique], paragraph 1, one reasonable interpretation (in the author's opinion even the only possible interpretation) of this so-called resulting range is the range [first, last) - thus returning always the ForwardIterator 'last' parameter.

2) Description of intended behavior:

For the rest of this Defect Report, it is assumed that the intended behavior was that all elements denoted by the original range [first, last) which are the first element from a consecutive group of elements for which the corresponding conditions: *(i-1) == *i (for the version of unique without a predicate argument) or pred(*(i-1), *i) ! = false (for the version of unique with a predicate argument) [Note: If such a group of elements consists of only a single element, this is also considered the first element] [Note: See resolutions of DR 202], call them s-elements [Note: s...stay], will be placed into a contiguous subrange of [first, last), denoted by the iterators [first, return value). The number of elements in the resulting range [first, return value) shall be equal to the number of s-elements in the original range [first, last). Invalid iterator arithmetic expressions are expected to be resolved as proposed in DR submitted by Thomas Mang regarding invalid iterator arithmetic expressions. It is also assumed by the author that the relative order of the elements in the resulting subrange [first, return value) shall be the same as the relative order of the corresponding elements (the s-elements) in the original range [Note: If this was not intended behavior, the additional proposed paragraph about stable order will certainly become obsolete]. Furthermore, the resolutions of DR 202 are partially considered.

All implementations known to the author of this Defect Report comply with this intent [Note: Except possible effects of DR 202]. Since this intent of the behavior (contrary to the current wording) is also described in various utility references serving the C++ community [1], it is not expected that fixing the paragraphs will influence current code [Note: Except possible effects of DR 202] - unless the code relies on the behavior as it is described by current wording and the implementation indeed reflects the current wording, and not the intent.

3) Proposed fixes:

Change 25.2.8 [lib.alg.unique], paragraph 1 to:

"Effect: Places the first element from every consecutive group of elements, referred to by the iterator i in the range [first, last), for which the following conditions hold: *(i-1) == *i (for the version of unique without a predicate argument) or pred(*(i -1), *i) != false (for the version of unique with a predicate argument), into the subrange [first, k) of the original range, where k shall denote a value of type ForwardIterator."

Comments to the new wording:

a) The new wording was influenced by the resolutions of DR 202. If DR 202 is resolved in another way, the proposed wording need also additional review. b) "Places" has no special meaning, and the everyday language meaning should fit. c) The expression "(i - 1)" was left, but is expected that DR submitted by Thomas Mang regarding invalid iterator arithmetic expressions will take this into account. d) The wording "(for the version of unique without a predicate argument)" and "(for the version of unique with a predicate argument)" was added consciously for clarity and is in resemblence with current 23.2.2.4 [lib.list.ops], paragraph 19. It might be considered redundant. e) The wording "of the original range" might be redundant, since any subrange starting at first and containing no more elements than the original range is implicitly a subrange of the original range [first, last). f) The iterator k was introduced instead of "return value" in order to avoid a cyclic dependency on 25.2.8 [lib.alg.unique], paragraph 2. The wording ", where k shall denote a value of type ForwardIterator" might be redundant, because it follows implicitly by 25.2.8 [lib.alg.unique], paragraph 2. g) "Places" does, in the author's opinion, explicitly forbid duplicating any s-element in the original range [first, last) within the resulting range [first, k). If there is doubt this term might be not unambiguous regarding this, it is suggested that k is specified more closely by the following wording: "k shall denote a value of type ForwardIterator [Note: See f)] so that k - first is equal to the number of elements in the original range [first, last) being the first element from every consecutive group of elements for which the corresponding condition did hold". This could also be expressed as a separate paragraph "Postcondition:". h) If it is considered that the wording is unclear whether it declares the element of a group which consists of only a single element implicitly to be the first element of this group [Note: Such an interpretation could eventually arise especially in case last - first == 1] , the following additional sentence is proposed: "If such a group of elements consists of only a single element, this element is also considered the first element."

Change 25.2.8 [lib.alg.unique], paragraph 2 to: "Returns: The iterator k."

Add a separate paragraph "Notes:" as 25.2.8 [lib.alg.unique], paragraph 2a or 3a, or a separate paragraph "Postcondition:" before 25.2.8 [lib.alg.unique], paragraph 2 (wording inside {} shall be eliminated if the preceding expressions are used, or the preceding expressions shall be eliminated if wording inside {} is used):

"Notes:{Postcondition:} Stable: the relative order of the elements that are placed into the subrange [first, return value {k}) shall be the same as their relative order was in the original range [first, last) prior to application of the algorithm."

Comments to the new wording:

a) It is assumed by the author that the algorithm was intended to be stable. In case this was not the intent, this paragraph becomes certainly obsolete. b) The wording "was ... prior to application of the algorithm" is used to explicitly distinguish the original range not only by means of iterators, but also by a 'chronological' factor from the resulting range [first, return value). It might be redundant.

25.2.8 [lib.alg.unique], paragraph 3:

See DR 239.

4) References to other DRs:

See DR 202, but which does not address any of the problems described in this Defect Report [Note: This DR is supposed to complement DR 202]. See DR 239. See DR submitted by Thomas Mang regarding invalid iterator arithmetic expressions.

[1]: The wording of these references is not always unambiguous, and provided examples partially contradict verbal description of the algorithms, because the verbal description resembles the problematic wording of ISO/IEC 14882:2003.

[2]: Illustration of conforming implementations according to current wording:

One way the author of this DR considers how this "elimination" could be achieved by a conforming implementation according to current wording is by substituting each r-element by _any_ s-element [Note: s...stay; any non-r-element], since all r-elements are "eliminated".

In case of a sequence consisting of elements being all 'equal' [Note: See DR 202], substituting each r-element by the single s-element is the only possible solution according to current wording.

Proposed resolution:

Rationale:

The LWG believes the standard is sufficiently clear. No implementers get it wrong, and changing it wouldn't cause any code to change, so there is no real-world harm here.


491(i). std::list<>::unique incorrectly specified

Section: 23.3.9.5 [list.ops] Status: NAD Submitter: Thomas Mang Opened: 2004-12-12 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [list.ops].

View all issues with NAD status.

Discussion:

In Section 23.3.9.5 [list.ops], paragraphs 19 to 21 describe the behavior of the std::list<T, Allocator>::unique operation. However, the current wording is defective for various reasons.

1) Analysis of current wording:

23.3.9.5 [list.ops], paragraph 19:

Current wording says: "Effects: Eliminates all but the first element from every consecutive group of equal elements referred to by the iterator i in the range [first + 1, last) for which *i == *(i - 1) (for the version of unique with no argument) or pred(*i, *(i -1)) (for the version of unique with a predicate argument) holds."

This sentences makes use of the undefined term "Eliminates". Although it is, to a certain degree, reasonable to consider the term "eliminate" synonymous with "erase", using "Erase" in the first place, as the wording of 23.3.9.5 [list.ops], paragraph 15 does, would be clearer.

The range of the elements referred to by iterator i is "[first + 1, last)". However, neither "first" nor "last" is defined.

The sentence makes three times use of iterator arithmetic expressions ( "first + 1", "*i == *(i - 1)", "pred(*i, *(i -1))" ) which is not defined for bidirectional iterator [see DR submitted by Thomas Mang regarding invalid iterator arithmetic expressions].

The same problems as pointed out in DR 202 (equivalence relation / order of arguments for pred()) apply to this paragraph.

23.3.9.5 [list.ops], paragraph 20:

Current wording says: "Throws: Nothing unless an exception in thrown by *i == *(i-1) or pred(*i, *(i - 1))"

The sentence makes two times use of invalid iterator arithmetic expressions ( "*i == *(i - 1)", "pred(*i, *(i -1))" ).

[Note: Minor typos: "in" / missing dot at end of sentence.]

23.3.9.5 [list.ops], paragraph 21:

Current wording says: "Complexity: If the range (last - first) is not empty, exactly (last - first) - 1 applications of the corresponding predicate, otherwise no application of the predicate.

See DR 315 regarding "(last - first)" not yielding a range.

Invalid iterator arithmetic expression "(last - first) - 1" left .

2) Description of intended behavior:

For the rest of this Defect Report, it is assumed that "eliminate" is supposed to be synonymous to "erase", that "first" is equivalent to an iterator obtained by a call to begin(), "last" is equivalent to an iterator obtained by a call to end(), and that all invalid iterator arithmetic expressions are resolved as described in DR submitted by Thomas Mang regarding invalid iterator arithmetic expressions.

Furthermore, the resolutions of DR 202 are considered regarding equivalence relation and order of arguments for a call to pred.

All implementations known to the author of this Defect Report comply with these assumptions, apart from the impact of the alternative resolution of DR 202. Except for the changes implied by the resolutions of DR 202, no impact on current code is expected.

3) Proposed fixes:

Change 23.3.9.5 [list.ops], paragraph 19 to:

"Effect: Erases all but the first element from every consecutive group of elements, referred to by the iterator i in the range [begin(), end()), for which the following conditions hold: *(i-1) == *i (for the version of unique with no argument) or pred(*(i-1), *i) != false (for the version of unique with a predicate argument)."

Comments to the new wording:

a) The new wording was influenced by DR 202 and the resolutions presented there. If DR 202 is resolved in another way, the proposed wording need also additional review. b) "Erases" refers in the author's opinion unambiguously to the member function "erase". In case there is doubt this might not be unamgibuous, a direct reference to the member function "erase" is suggested [Note: This would also imply a change of 23.3.9.5 [list.ops], paragraph 15.]. c) The expression "(i - 1)" was left, but is expected that DR submitted by Thomas Mang regarding invalid iterator arithmetic expressions will take this into account. d) The wording "(for the version of unique with no argument)" and "(for the version of unique with a predicate argument)" was kept consciously for clarity. e) "begin()" substitutes "first", and "end()" substitutes "last". The range need adjustment from "[first + 1, last)" to "[begin(), end())" to ensure a valid range in case of an empty list. f) If it is considered that the wording is unclear whether it declares the element of a group which consists of only a single element implicitly to be the first element of this group [Note: Such an interpretation could eventually arise especially in case size() == 1] , the following additional sentence is proposed: "If such a group of elements consists of only a single element, this element is also considered the first element."

Change 23.3.9.5 [list.ops], paragraph 20 to:

"Throws: Nothing unless an exception is thrown by *(i-1) == *i or pred(*(i-1), *i)."

Comments to the new wording:

a) The wording regarding the conditions is identical to proposed 23.3.9.5 [list.ops], paragraph 19. If 23.3.9.5 [list.ops], paragraph 19 is resolved in another way, the proposed wording need also additional review. b) The expression "(i - 1)" was left, but is expected that DR submitted by Thomas Mang regarding invalid iterator arithmetic expressions will take this into account. c) Typos fixed.

Change 23.3.9.5 [list.ops], paragraph 21 to:

"Complexity: If empty() == false, exactly size() - 1 applications of the corresponding predicate, otherwise no applications of the corresponding predicate."

Comments to the new wording:

a) The new wording is supposed to also replace the proposed resolution of DR 315, which suffers from the problem of undefined "first" / "last".

5) References to other DRs:

See DR 202. See DR 239. See DR 315. See DR submitted by Thomas Mang regarding invalid iterator arithmetic expressions.

Proposed resolution:

Rationale:

"All implementations known to the author of this Defect Report comply with these assumption", and "no impact on current code is expected", i.e. there is no evidence of real-world confusion or harm.


492(i). Invalid iterator arithmetic expressions

Section: 16.3.2.4 [structure.specifications] Status: NAD Submitter: Thomas Mang Opened: 2004-12-12 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [structure.specifications].

View all other issues in [structure.specifications].

View all issues with NAD status.

Discussion:

Various clauses other than clause 25 make use of iterator arithmetic not supported by the iterator category in question. Algorithms in clause 25 are exceptional because of 25 [lib.algorithms], paragraph 9, but this paragraph does not provide semantics to the expression "iterator - n", where n denotes a value of a distance type between iterators.

1) Examples of current wording:

Current wording outside clause 25:

23.2.2.4 [lib.list.ops], paragraphs 19-21: "first + 1", "(i - 1)", "(last - first)" 23.3.1.1 [lib.map.cons], paragraph 4: "last - first" 23.3.2.1 [lib.multimap.cons], paragraph 4: "last - first" 23.3.3.1 [lib.set.cons], paragraph 4: "last - first" 23.3.4.1 [lib.multiset.cons], paragraph 4: "last - first" 24.4.1 [lib.reverse.iterators], paragraph 1: "(i - 1)"

[Important note: The list is not complete, just an illustration. The same issue might well apply to other paragraphs not listed here.]

None of these expressions is valid for the corresponding iterator category.

Current wording in clause 25:

25.1.1 [lib.alg.foreach], paragraph 1: "last - 1" 25.1.3 [lib.alg.find.end], paragraph 2: "[first1, last1 - (last2-first2))" 25.2.8 [lib.alg.unique], paragraph 1: "(i - 1)" 25.2.8 [lib.alg.unique], paragraph 5: "(i - 1)"

However, current wording of 25 [lib.algorithms], paragraph 9 covers neither of these four cases:

Current wording of 25 [lib.algorithms], paragraph 9:

"In the description of the algorithms operator + and - are used for some of the iterator categories for which they do not have to be defined. In these cases the semantics of a+n is the same as that of

{X tmp = a;
advance(tmp, n);
return tmp;
}

and that of b-a is the same as of return distance(a, b)"

This paragrpah does not take the expression "iterator - n" into account, where n denotes a value of a distance type between two iterators [Note: According to current wording, the expression "iterator - n" would be resolved as equivalent to "return distance(n, iterator)"]. Even if the expression "iterator - n" were to be reinterpreted as equivalent to "iterator + -n" [Note: This would imply that "a" and "b" were interpreted implicitly as values of iterator types, and "n" as value of a distance type], then 24.3.4/2 interfers because it says: "Requires: n may be negative only for random access and bidirectional iterators.", and none of the paragraphs quoted above requires the iterators on which the algorithms operate to be of random access or bidirectional category.

2) Description of intended behavior:

For the rest of this Defect Report, it is assumed that the expression "iterator1 + n" and "iterator1 - iterator2" has the semantics as described in current 25 [lib.algorithms], paragraph 9, but applying to all clauses. The expression "iterator1 - n" is equivalent to an result-iterator for which the expression "result-iterator + n" yields an iterator denoting the same position as iterator1 does. The terms "iterator1", "iterator2" and "result-iterator" shall denote the value of an iterator type, and the term "n" shall denote a value of a distance type between two iterators.

All implementations known to the author of this Defect Report comply with these assumptions. No impact on current code is expected.

3) Proposed fixes:

Change 25 [lib.algorithms], paragraph 9 to:

"In the description of the algorithms operator + and - are used for some of the iterator categories for which they do not have to be defined. In this paragraph, a and b denote values of an iterator type, and n denotes a value of a distance type between two iterators. In these cases the semantics of a+n is the same as that of

{X tmp = a;
advance(tmp, n);
return tmp;
}

,the semantics of a-n denotes the value of an iterator i for which the following condition holds: advance(i, n) == a, and that of b-a is the same as of return distance(a, b)".

Comments to the new wording:

a) The wording " In this paragraph, a and b denote values of an iterator type, and n denotes a value of a distance type between two iterators." was added so the expressions "b-a" and "a-n" are distinguished regarding the types of the values on which they operate. b) The wording ",the semantics of a-n denotes the value of an iterator i for which the following condition holds: advance(i, n) == a" was added to cover the expression 'iterator - n'. The wording "advance(i, n) == a" was used to avoid a dependency on the semantics of a+n, as the wording "i + n == a" would have implied. However, such a dependency might well be deserved. c) DR 225 is not considered in the new wording.

Proposed fixes regarding invalid iterator arithmetic expressions outside clause 25:

Either a) Move modified 25 [lib.algorithms], paragraph 9 (as proposed above) before any current invalid iterator arithmetic expression. In that case, the first sentence of 25 [lib.algorithms], paragraph 9, need also to be modified and could read: "For the rest of this International Standard, ...." / "In the description of the following clauses including this ...." / "In the description of the text below ..." etc. - anyways substituting the wording "algorithms", which is a straight reference to clause 25. In that case, 25 [lib.algorithms] paragraph 9 will certainly become obsolete. Alternatively, b) Add an appropiate paragraph similar to resolved 25 [lib.algorithms], paragraph 9, to the beginning of each clause containing invalid iterator arithmetic expressions. Alternatively, c) Fix each paragraph (both current wording and possible resolutions of DRs) containing invalid iterator arithmetic expressions separately.

5) References to other DRs:

See DR 225. See DR 237. The resolution could then also read "Linear in last - first".

[ Bellevue: ]

Keep open and ask Bill to provide wording.

[ 2009-05-09 Alisdair adds: ]

This issue is related to 997(i).

[ 2009-07 Frankfurt ]

Hinnant: this isn't going to change any user's code or any vendor's implementation.

No objection to "NAD without prejudice." If anyone proposes a resolution, the LWG will consider it.

Move to NAD.

Proposed resolution:

[Lillehammer: Minor issue, but real. We have a blanket statement about this in 25/11. But (a) it should be in 17, not 25; and (b) it's not quite broad enough, because there are some arithmetic expressions it doesn't cover. Bill will provide wording.]


493(i). Undefined Expression in Input Iterator Note Title

Section: 24.3.5.3 [input.iterators] Status: NAD Submitter: Chris Jefferson Opened: 2004-12-13 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [input.iterators].

View all other issues in [input.iterators].

View all issues with NAD status.

Discussion:

1) In 24.1.1/3, the following text is currently present.

"Note: For input iterators, a==b does not imply ++a=++b (Equality does not guarantee the substitution property or referential transparency)."

However, when in Table 72, part of the definition of ++r is given as:

"pre: r is dereferenceable. post: any copies of the previous value of r are no longer required either to be dereferenceable ..."

While a==b does not imply that b is a copy of a, this statement should perhaps still be made more clear.

2) There are no changes to intended behaviour

3) This Note should be altered to say "Note: For input iterators a==b, when its behaviour is defined ++a==++b may still be false (Equality does not guarantee the substitution property or referential transparency).

Proposed resolution:

Rationale:

This is descriptive text, not normative, and the meaning is clear.


494(i). Wrong runtime complexity for associative container's insert and delete

Section: 23.2.7 [associative.reqmts] Status: NAD Submitter: Hans B os Opened: 2004-12-19 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [associative.reqmts].

View all other issues in [associative.reqmts].

View all issues with NAD status.

Discussion:

According to [lib.associative.reqmts] table 69, the runtime comlexity of insert(p, t) and erase(q) can be done in amortized constant time.

It was my understanding that an associative container could be implemented as a balanced binary tree.

For inser(p, t), you 'll have to iterate to p's next node to see if t can be placed next to p. Furthermore, the insertion usually takes place at leaf nodes. An insert next to the root node will be done at the left of the root next node

So when p is the root node you 'll have to iterate from the root to its next node, which takes O(log(size)) time in a balanced tree.

If you insert all values with insert(root, t) (where root is the root of the tree before insertion) then each insert takes O(log(size)) time. The amortized complexity per insertion will be O(log(size)) also.

For erase(q), the normal algorithm for deleting a node that has no empty left or right subtree, is to iterate to the next (or previous), which is a leaf node. Then exchange the node with the next and delete the leaf node. Furthermore according to DR 130, erase should return the next node of the node erased. Thus erasing the root node, requires iterating to the next node.

Now if you empty a map by deleting the root node until the map is empty, each operation will take O(log(size)), and the amortized complexity is still O(log(size)).

The operations can be done in amortized constant time if iterating to the next node can be done in (non amortized) constant time. This can be done by putting all nodes in a double linked list. This requires two extra links per node. To me this is a bit overkill since you can already efficiently insert or erase ranges with erase(first, last) and insert(first, last).

Proposed resolution:

Rationale:

Only "amortized constant" in special circumstances, and we believe that's implementable. That is: doing this N times will be O(N), not O(log N).


499(i). Std. doesn't seem to require stable_sort() to be stable!

Section: 26.8.2.2 [stable.sort] Status: NAD Editorial Submitter: Prateek Karandikar Opened: 2005-04-12 Last modified: 2016-01-28

Priority: Not Prioritized

View all issues with NAD Editorial status.

Discussion:

17.3.1.1 Summary

1 The Summary provides a synopsis of the category, and introduces the first-level subclauses. Each subclause also provides a summary, listing the headers specified in the subclause and the library entities provided in each header.

2 Paragraphs labelled "Note(s):" or "Example(s):" are informative, other paragraphs are normative.

So this means that a "Notes" paragraph wouldn't be normative.

25.3.1.2 stable_sort

template<class RandomAccessIterator> 
void stable_sort(RandomAccessIterat or first, RandomAccessIterator last); 

template<class RandomAccessIterator, class Compare> 
void stable_sort(RandomAccessIterat or first, RandomAccessIterator last, Compare comp);

1 Effects: Sorts the elements in the range [first, last).

2 Complexity: It does at most N(log N)^2 (where N == last - first) comparisons; if enough extra memory is available, it is N log N.

3 Notes: Stable: the relative order of the equivalent elements is preserved.

The Notes para is informative, and nowhere else is stability mentioned above.

Also, I just searched for the word "stable" in my copy of the Standard. and the phrase "Notes: Stable: the relative order of the elements..." is repeated several times in the Standard library clauses for describing various functions. How is it that stability is talked about in the informative paragraph? Or am I missing something obvious?

Proposed resolution:

Rationale:

This change has already been made.


500(i). do_length cannot be implemented correctly

Section: 28.3.4.2.6 [locale.codecvt.byname] Status: NAD Submitter: Krzysztof Żelechowski Opened: 2005-05-24 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.codecvt.byname].

View all issues with NAD status.

Discussion:

  1. codecvt::do_length is of type int;
  2. it is assumed to be sort-of returning from_next - from of type ptrdiff_t;
  3. ptrdiff_t cannot be cast to an int without data loss.

Contradiction.

Proposed resolution:


501(i). Proposal: strengthen guarantees of lib.comparisons

Section: 99 [depr.base] Status: NAD Submitter: Me <anti_spam_email2003@yahoo.com> Opened: 2005-06-07 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [depr.base].

View all issues with NAD status.

Discussion:

"For templates greater, less, greater_equal, and less_equal, the specializations for any pointer type yield a total order, even if the built-in operators <, >, <=, >= do not."

The standard should do much better than guarantee that these provide a total order, it should guarantee that it can be used to test if memory overlaps, i.e. write a portable memmove. You can imagine a platform where the built-in operators use a uint32_t comparison (this tests for overlap on this platform) but the less<T*> functor is allowed to be defined to use a int32_t comparison. On this platform, if you use std::less with the intent of making a portable memmove, comparison on an array that straddles the 0x7FFFFFFF/0x8000000 boundary can give incorrect results.

Proposed resolution:

Add a footnote to 20.5.3/8 saying:

Given a p1 and p2 such that p1 points to N objects of type T and p2 points to M objects of type T. If [p1,p1+N) does not overlap [p2,p2+M), less returns the same value when comparing all pointers in [p1,p1+N) to all pointers in [p2,p2+M). Otherwise, there is a value Q and a value R such that less returns the same value when comparing all pointers in [p1,p1+Q) to all pointers in [p2,p2+R) and an opposite value when comparing all pointers in [p1+Q,p1+N) to all pointers in [p2+R,p2+M). For the sake of completeness, the null pointer value (4.10) for T is considered to be an array of 1 object that doesn't overlap with any non-null pointer to T. less_equal, greater, greater_equal, equal_to, and not_equal_to give the expected results based on the total ordering semantics of less. For T of void, treat it as having similar semantics as T of char i.e. less<cv T*>(a, b) gives the same results as less<cv void*>(a, b) which gives the same results as less<cv char*>((cv char*)(cv void*)a, (cv char*)(cv void*)b).

I'm also thinking there should be a footnote to 20.5.3/1 saying that if A and B are similar types (4.4/4), comp<A>(a,b) returns the same value as comp<B>(a,b) (where comp is less, less_equal, etc.). But this might be problematic if there is some really funky operator overloading going on that does different things based on cv (that should be undefined behavior if somebody does that though). This at least should be guaranteed for all POD types (especially pointers) that use the built-in comparison operators.

Rationale:

less is already required to provide a strict weak ordering which is good enough to detect overlapping memory situations.


502(i). Proposition: Clarification of the interaction between a facet and an iterator

Section: 28.3.3.1.2.1 [locale.category] Status: NAD Submitter: Christopher Conrade Zseleghovski Opened: 2005-06-07 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.category].

View all issues with NAD status.

Discussion:

Motivation:

This requirement seems obvious to me, it is the essence of code modularity. I have complained to Mr. Plauger that the Dinkumware library does not observe this principle but he objected that this behaviour is not covered in the standard.

[ 2009-07 Frankfurt ]

No objection to NAD, Fixed.

Move to NAD.

Proposed resolution:

Append the following point to 22.1.1.1.1:

6. The implementation of a facet of Table 52 parametrized with an InputIterator/OutputIterator should use that iterator only as character source/sink respectively. For a *_get facet, it means that the value received depends only on the sequence of input characters and not on how they are accessed. For a *_put facet, it means that the sequence of characters output depends only on the value to be formatted and not of how the characters are stored.

[ Berlin: Moved to Open, Need to clean up this area to make it clear locales don't have to contain open ended sets of facets. Jack, Howard, Bill. ]


503(i). more on locales

Section: 28.3.4 [locale.categories] Status: NAD Submitter: P.J. Plauger Opened: 2005-06-20 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [locale.categories].

View all issues with NAD status.

Discussion:

a) In 22.2.1.1 para. 2 we refer to "the instantiations required in Table 51" to refer to the facet *objects* associated with a locale. And we almost certainly mean just those associated with the default or "C" locale. Otherwise, you can't switch to a locale that enforces a different mapping between narrow and wide characters, or that defines additional uppercase characters.

b) 22.2.1.5 para. 3 (codecvt) has the same issues.

c) 22.2.1.5.2 (do_unshift) is even worse. It *forbids* the generation of a homing sequence for the basic character set, which might very well need one.

d) 22.2.1.5.2 (do_length) likewise dictates that the default mapping between wide and narrow characters be taken as one-for-one.

e) 22.2.2 para. 2 (num_get/put) is both muddled and vacuous, as far as I can tell. The muddle is, as before, calling Table 51 a list of instantiations. But the constraint it applies seems to me to cover *all* defined uses of num_get/put, so why bother to say so?

f) 22.2.3.1.2 para. 1(do_decimal_point) says "The required instantiations return '.' or L'.'.) Presumably this means "as appropriate for the character type. But given the vague definition of "required" earlier, this overrules *any* change of decimal point for non "C" locales. Surely we don't want to do that.

g) 22.2.3.1.2 para. 2 (do_thousands_sep) says "The required instantiations return ',' or L','.) As above, this probably means "as appropriate for the character type. But this overrules the "C" locale, which requires *no* character ('\0') for the thousands separator. Even if we agree that we don't mean to block changes in decimal point or thousands separator, we should also eliminate this clear incompatibility with C.

h) 22.2.3.1.2 para. 2 (do_grouping) says "The required instantiations return the empty string, indicating no grouping." Same considerations as for do_decimal_point.

i) 22.2.4.1 para. 1 (collate) refers to "instantiations required in Table 51". Same bad jargon.

j) 22.2.4.1.2 para. 1 (do_compare) refers to "instantiations required in Table 51". Same bad jargon.

k) 22.2.5 para. 1 (time_get/put) uses the same muddled and vacuous as num_get/put.

l) 22.2.6 para. 2 (money_get/put) uses the same muddled and vacuous as num_get/put.

m) 22.2.6.3.2 (do_pos/neg_format) says "The instantiations required in Table 51 ... return an object of type pattern initialized to {symbol, sign, none, value}." This once again *overrides* the "C" locale, as well as any other locale."

3) We constrain the use_facet calls that can be made by num_get/put, so why don't we do the same for money_get/put? Or for any of the other facets, for that matter?

4) As an almost aside, we spell out when a facet needs to use the ctype facet, but several also need to use a codecvt facet and we don't say so.

[ Berlin: Bill to provide wording. ]

[ 2009-07 Frankfurt ]

No objection to NAD.

Move to NAD.

Proposed resolution:


504(i). Integer types in pseudo-random number engine requirements

Section: 29.5.3 [rand.req], 99 [tr.rand.req] Status: NAD Editorial Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [rand.req].

View all issues with NAD Editorial status.

Discussion:

In [tr.rand.req], Paragraph 2 states that "... s is a value of integral type, g is an ... object returning values of unsigned integral type ..."

Proposed resolution:

In 5.1.1 [tr.rand.req], Paragraph 2 replace

... s is a value of integral type, g is an lvalue of a type other than X that defines a zero-argument function object returning values of unsigned integral type unsigned long int, ...

In 5.1.1 [tr.rand.seq], Table 16, replace in the line for X(s)

creates an engine with the initial internal state determined by static_cast<unsigned long>(s)

[ Mont Tremblant: Both s and g should be unsigned long. This should refer to the constructor signatures. Jens provided wording post Mont Tremblant. ]

[ Berlin: N1932 adopts the proposed resolution: see 26.3.1.3/1e and Table 3 row 2. Moved to Ready. ]

Rationale:

Jens: Just requiring X(unsigned long) still makes it possible for an evil library writer to also supply a X(int) that does something unexpected. The wording above requires that X(s) always performs as if X(unsigned long) would have been called. I believe that is sufficient and implements our intentions from Mont Tremblant. I see no additional use in actually requiring a X(unsigned long) signature. u.seed(s) is covered by its reference to X(s), same arguments.

[ Portland: Subsumed by N2111. ]


506(i). Requirements of Distribution parameter for variate_generator

Section: 29.5 [rand], 99 [tr.rand.var] Status: NAD Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [rand].

View all issues with NAD status.

Discussion:

Paragraph 3 requires that template argument U (which corresponds to template parameter Engine) satisfy all uniform random number generator requirements. However, there is no analogous requirement regarding the template argument that corresponds to template parameter Distribution. We believe there should be, and that it should require that this template argument satisfy all random distribution requirements.

Proposed resolution:

Consequence 1: Remove the precondition clauses [tr.rand.var]/16 and /18.

Consequence 2: Add max() and min() functions to those distributions that do not already have them.

[ Mont Tremblant: Jens reccommends NAD, min/max not needed everywhere. Marc supports having min and max to satisfy generic programming interface. ]

Rationale:

Berlin: N1932 makes this moot: variate_generator has been eliminated.


509(i). Uniform_int template parameters

Section: 29.5.9.2 [rand.dist.uni], 99 [tr.rand.dist.iunif] Status: NAD Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [rand.dist.uni].

View all issues with NAD status.

Discussion:

In [tr.rand.dist.iunif] the uniform_int distribution currently has a single template parameter, IntType, used as the input_type and as the result_type of the distribution. We believe there is no reason to conflate these types in this way.

Proposed resolution:

We recommend that there be a second template parameter to reflect the distribution's input_type, and that the existing first template parameter continue to reflect (solely) the result_type:

template< class IntType = int, UIntType = unsigned int >
class uniform_int
{
public:
  // types
  typedef  UIntType  input_type;
  typedef  IntType   result_type;

[ Berlin: Moved to NAD. N1932 makes this moot: the input_type template parameter has been eliminated. ]


510(i). Input_type for bernoulli_distribution

Section: 29.5.9.3 [rand.dist.bern], 99 [tr.rand.dist.bern] Status: NAD Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all issues with NAD status.

Discussion:

In [tr.rand.dist.bern] the distribution currently requires;

typedef  int  input_type;

Proposed resolution:

We believe this is an unfortunate choice, and recommend instead:

typedef  unsigned int  input_type;

[ Berlin: Moved to NAD. N1932 makes this moot: the input_type template parameter has been eliminated. ]


511(i). Input_type for binomial_distribution

Section: 29.5.9 [rand.dist], 99 [tr.rand.dist.bin] Status: NAD Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [rand.dist].

View all issues with NAD status.

Discussion:

Unlike all other distributions in TR1, this binomial_distribution has an implementation-defined input_type. We believe this is an unfortunate choice, because it hinders users from writing portable code. It also hinders the writing of compliance tests. We recommend instead:

typedef  RealType  input_type;

While this choice is somewhat arbitrary (as it was for some of the other distributions), we make this particular choice because (unlike all other distributions) otherwise this template would not publish its RealType argument and so users could not write generic code that accessed this second template parameter. In this respect, the choice is consistent with the other distributions in TR1.

We have two reasons for recommending that a real type be specified instead. One reason is based specifically on characteristics of binomial distribution implementations, while the other is based on mathematical characteristics of probability distribution functions in general.

Implementations of binomial distributions commonly use Stirling approximations for values in certain ranges. It is far more natural to use real values to represent these approximations than it would be to use integral values to do so. In other ranges, implementations reply on the Bernoulli distribution to obtain values. While TR1's bernoulli_distribution::input_type is specified as int, we believe this would be better specified as double.

This brings us to our main point: The notion of a random distribution rests on the notion of a cumulative distribution function, which in turn mathematically depends on a continuous dependent variable. Indeed, such a distribution function would be meaningless if it depended on discrete values such as integers - and this remains true even if the distribution function were to take discrete steps.

Although this note is specifically about binomial_distribution::input_type, we intend to recommend that all of the random distributions input_types be specified as a real type (either a RealType template parameter, or double, as appropriate).

Of the nine distributions in TR1, four already have this characteristic (uniform_real, exponential_distribution, normal_distribution, and gamma_distribution). We have already argued the case for the binomial the remaining four distributions.

In the case of uniform_int, we believe that the calculations to produce an integer result in a specified range from an integer in a different specified range is best done using real arithmetic. This is because it involves a product, one of whose terms is the ratio of the extents of the two ranges. Without real arithmetic, the results become less uniform: some numbers become more (or less) probable that they should be. This is, of course, undesireable behavior in a uniform distribution.

Finally, we believe that in the case of the bernoulli_distribution (briefly mentioned earlier), as well as the cases of the geometric_distribution and the poisson_distribution, it would be far more natural to have a real input_type. This is because the most natural computation involves the random number delivered and the distribution's parameter p (in the case of bernoulli_distribution, for example, the computation is a comparison against p), and p is already specified in each case as having some real type.

Proposed resolution:

typedef  RealType  input_type;

[ Berlin: Moved to NAD. N1932 makes this moot: the input_type template parameter has been eliminated. ]


512(i). Seeding subtract_with_carry_01 from a single unsigned long

Section: 29.5.4 [rand.eng], 99 [tr.rand.eng.sub1] Status: NAD Editorial Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [rand.eng].

View all issues with NAD Editorial status.

Discussion:

Paragraph 8 specifies the algorithm by which a subtract_with_carry_01 engine is to be seeded given a single unsigned long. This algorithm is seriously flawed in the case where the engine parameter w (also known as word_size) exceeds 31 [bits]. The key part of the paragraph reads:

sets x(-r) ... x(-1) to (lcg(1)*2**(-w)) mod 1

and so forth.

Since the specified linear congruential engine, lcg, delivers numbers with a maximum of 2147483563 (just a shade under 31 bits), then when w is, for example, 48, each of the x(i) will be less than 2**-17. The consequence is that roughly the first 400 numbers delivered will be conspicuously close to either zero or one.

Unfortunately, this is not an innocuous flaw: One of the predefined engines in [tr.rand.predef], namely ranlux64_base_01, has w = 48 and would exhibit this poor behavior, while the original N1378 proposal states that these pre-defined engines are intended to be of "known good properties."

Proposed resolution:

In 5.1.4.4 [tr.rand.eng.sub1], replace the "effects" clause for void seed(unsigned long value = 19780503) by

Effects: If value == 0, sets value to 19780503. In any case, with a linear congruential generator lcg(i) having parameters mlcg = 2147483563, alcg = 40014, clcg = 0, and lcg(0) = value, sets carry(-1) and x(-r) … x(-1) as if executing


linear_congruential<unsigned long, 40014, 0, 2147483563> lcg(value);
seed(lcg);

to (lcg(1) · 2-w) mod 1 … (lcg(r) · 2-w) mod 1, respectively. If x(-1) == 0, sets carry(-1) = 2-w, else sets carry(-1) = 0.

[ Jens provided revised wording post Mont Tremblant. ]

[ Berlin: N1932 adopts the originally-proposed resolution of the issue. Jens's supplied wording is a clearer description of what is intended. Moved to Ready. ]

Rationale:

Jens: I'm using an explicit type here, because fixing the prose would probably not qualify for the (with issue 504(i) even stricter) requirements we have for seed(Gen&).

[ Portland: Subsumed by N2111. ]


513(i). Size of state for subtract_with_carry_01

Section: 29.5.4 [rand.eng], 99 [tr.rand.eng.sub1] Status: NAD Editorial Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [rand.eng].

View all issues with NAD Editorial status.

Discussion:

Paragraph 3 begins:

The size of the state is r.

However, this is not quite consistent with the remainder of the paragraph which specifies a total of nr+1 items in the textual representation of the state. We recommend the sentence be corrected to match:

The size of the state is nr+1.

To give meaning to the coefficient n, it may be also desirable to move n's definition from later in the paragraph. Either of the following seem reasonable formulations:

With n=..., the size of the state is nr+1.

The size of the state is nr+1, where n=... .

Proposed resolution:

[ Jens: I plead for "NAD" on the grounds that "size of state" is only used as an argument for big-O complexity notation, thus constant factors and additions don't count. ]

[ Berlin: N1932 adopts the proposed NAD. ]


514(i). Size of state for subtract_with_carry

Section: 29.5.4.4 [rand.eng.sub], 99 [tr.rand.eng.sub] Status: NAD Editorial Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [rand.eng.sub].

View all issues with NAD Editorial status.

Discussion:

Paragraph 2 begins:

The size of the state is r.

However, the next sentence specifies a total of r+1 items in the textual representation of the state, r specific x's as well as a specific carry. This makes a total of r+1 items that constitute the size of the state, rather than r.

Proposed resolution:

We recommend the sentence be corrected to match:

The size of the state is r+1.

[ Jens: I plead for "NAD" on the grounds that "size of state" is only used as an argument for big-O complexity notation, thus constant factors and additions don't count. ]

[ Berlin: N1932 adopts the proposed NAD. ]


515(i). Random number engine traits

Section: 29.5.2 [rand.synopsis], 99 [tr.rand.synopsis] Status: NAD Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [rand.synopsis].

View all issues with NAD status.

Discussion:

To accompany the concept of a pseudo-random number engine as defined in Table 17, we propose and recommend an adjunct template, engine_traits, to be declared in [tr.rand.synopsis] as:

template< class PSRE >
class engine_traits;

This template's primary purpose would be as an aid to generic programming involving pseudo-random number engines. Given only the facilities described in tr1, it would be very difficult to produce any algorithms involving the notion of a generic engine. The intent of this proposal is to provide, via engine_traits<>, sufficient descriptive information to allow an algorithm to employ a pseudo-random number engine without regard to its exact type, i.e., as a template parameter.

For example, today it is not possible to write an efficient generic function that requires any specific number of random bits. More specifically, consider a cryptographic application that internally needs 256 bits of randomness per call:

template< class Eng, class InIter, class OutIter >
void crypto( Eng& e, InIter in, OutIter out );

Without knowning the number of bits of randomness produced per call to a provided engine, the algorithm has no means of determining how many times to call the engine.

In a new section [tr.rand.eng.traits], we proposed to define the engine_traits template as:

template< class PSRE >
class engine_traits
{
  static  std::size_t  bits_of_randomness = 0u;
  static  std::string  name()  { return "unknown_engine"; }
  // TODO: other traits here
};

Further, each engine described in [tr.rand.engine] would be accompanied by a complete specialization of this new engine_traits template.

Proposed resolution:

[ Berlin: Walter: While useful for implementation per TR1, N1932 has no need for this feature. Recommend close as NAD. ]

Rationale:

Recommend NAD, N1932, N2111 covers this. Already in WP.


516(i). Seeding subtract_with_carry_01 using a generator

Section: 29.5.4 [rand.eng], 99 [tr.rand.eng.sub1] Status: NAD Editorial Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [rand.eng].

View all issues with NAD Editorial status.

Discussion:

Paragraph 6 says:

... obtained by successive invocations of g, ...

We recommend instead:

... obtained by taking successive invocations of g mod 2**32, ...

as the context seems to require only 32-bit quantities be used here.

Proposed resolution:

Berlin: N1932 adopts the proposed resultion: see 26.3.3.4/7. Moved to Ready.

[ Portland: Subsumed by N2111. ]


517(i). Should include name in external representation

Section: 29.5.3 [rand.req], 99 [tr.rand.req] Status: NAD Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2016-01-28

Priority: Not Prioritized

View all other issues in [rand.req].

View all issues with NAD status.

Discussion:

The last two rows of Table 16 deal with the i/o requirements of an engine, specifying that the textual representation of an engine's state, appropriately formatted, constitute the engine's external representation.

This seems adequate when an engine's type is known. However, it seems inadequate in the context of generic code, where it becomes useful and perhaps even necessary to determine an engine's type via input.

Proposed resolution:

We therefore recommend that, in each of these two rows of Table 16, the text "textual representation" be expanded so as to read "engine name followed by the textual representation."

[ Berlin: N1932 considers this NAD. This is a QOI issue. ]


526(i). Is it undefined if a function in the standard changes in parameters?

Section: 23.2.4 [sequence.reqmts] Status: NAD Submitter: Chris Jefferson Opened: 2005-09-14 Last modified: 2016-01-28

Priority: Not Prioritized

View other active issues in [sequence.reqmts].

View all other issues in [sequence.reqmts].

View all issues with NAD status.

Discussion:

Problem: There are a number of places in the C++ standard library where it is possible to write what appear to be sensible ways of calling functions, but which can cause problems in some (or all) implementations, as they cause the values given to the function to be changed in a way not specified in standard (and therefore not coded to correctly work). These fall into two similar categories.

1) Parameters taken by const reference can be changed during execution of the function

Examples:

Given std::vector<int> v:

v.insert(v.begin(), v[2]);

v[2] can be changed by moving elements of vector

Given std::list<int> l:

l.remove(*l.begin());

Will delete the first element, and then continue trying to access it. This is particularily vicious, as it will appear to work in almost all cases.

2) A range is given which changes during the execution of the function: Similarly,

v.insert(v.begin(), v.begin()+4, v.begin()+6);

This kind of problem has been partly covered in some cases. For example std::copy(first, last, result) states that result cannot be in the range [first, last). However, does this cover the case where result is a reverse_iterator built from some iterator in the range [first, last)? Also, std::copy would still break if result was reverse_iterator(last + 1), yet this is not forbidden by the standard

Solution:

One option would be to try to more carefully limit the requirements of each function. There are many functions which would have to be checked. However as has been show