From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libstdc++-v3/doc/html/ext/lwg-closed.html | 51135 ++++++++++++++++++++++++++++ 1 file changed, 51135 insertions(+) create mode 100644 libstdc++-v3/doc/html/ext/lwg-closed.html (limited to 'libstdc++-v3/doc/html/ext/lwg-closed.html') diff --git a/libstdc++-v3/doc/html/ext/lwg-closed.html b/libstdc++-v3/doc/html/ext/lwg-closed.html new file mode 100644 index 000000000..c0848eb90 --- /dev/null +++ b/libstdc++-v3/doc/html/ext/lwg-closed.html @@ -0,0 +1,51135 @@ + + + +C++ Standard Library Closed Issues List + + + + + + + + + + + + + + + + + + + + +
Doc. no.D3183=10-0173
Date:2010-11-29
Project:Programming Language C++
Reply to:Alisdair Meredith <lwgchair@gmail.com>
+

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

+

Revised 2010-11-29 at 10:11:56 UTC

+ +

Reference ISO/IEC IS 14882:2003(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 Active Issues List active issues and more + information. See the Library Defect Reports List for issues considered + defects. The introductory material in that document also applies to + this document.

+ +

Revision History

+ + +

Closed Issues

+
+

2. Auto_ptr conversions effects incorrect

+

Section: D.12.1.3 [auto.ptr.conv] Status: NAD + Submitter: Nathan Myers Opened: 1997-12-04 Last modified: 2010-10-29

+

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 20.7.4.3 [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. Basic_string size_type and difference_type should be implementation defined

+

Section: 21.4 [basic.string] Status: NAD + Submitter: Beman Dawes Opened: 1997-11-16 Last modified: 2010-10-29

+

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. File position not an offset unimplementable

+

Section: 27.5.3 [fpos] Status: NAD + Submitter: Matt Austern Opened: 1997-12-15 Last modified: 2010-10-29

+

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. Codecvt<>::do unclear

+

Section: 22.4.1.5 [locale.codecvt.byname] Status: Dup + Submitter: Matt Austern Opened: 1998-01-14 Last modified: 2010-10-29

+

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. Way objects hold allocators unclear

+

Section: 20.2.5 [allocator.requirements] Status: NAD + Submitter: Angelika Langer Opened: 1998-02-23 Last modified: 2010-10-29

+

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. Locale table correction

+

Section: 22.4.1.5 [locale.codecvt.byname] Status: Dup + Submitter: Brendan Kehoe Opened: 1998-06-01 Last modified: 2010-10-29

+

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

+

View all issues with Dup status.

+

Duplicate of: 33

+

Discussion:

+ + +

Rationale:

+ + + + + + +
+

45. Stringstreams read/write pointers initial position unclear

+

Section: 27.8.3 [ostringstream] Status: NAD + Submitter: Matthias Mueller Opened: 1998-05-27 Last modified: 2010-10-29

+

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 27.3 [iostream.forward], 27.8.3.1 [ostringstream.cons], 27.8.1.1 [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. Extracting a char from a wide-oriented stream

+

Section: 27.7.1.2.3 [istream::extractors] Status: NAD + Submitter: Matt Austern Opened: 1998-07-01 Last modified: 2010-10-29

+

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. Underspecification of strstreambuf::seekoff

+

Section: D.9.1.3 [depr.strstreambuf.virtuals] Status: NAD + Submitter: Matt Austern Opened: 1998-08-18 Last modified: 2010-10-29

+

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. Setw useless for strings

+

Section: 21.4.8.9 [string.io] Status: Dup + Submitter: Steve Clamage Opened: 1998-07-09 Last modified: 2010-10-29

+

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. Do_convert phantom member function

+

Section: 22.4.1.4 [locale.codecvt] Status: Dup + Submitter: Nathan Myers Opened: 1998-08-24 Last modified: 2010-10-29

+

View all other issues in [locale.codecvt].

+

View all issues with Dup status.

+

Duplicate of: 24

+

Discussion:

+

In 22.4.1.4 [locale.codecvt] par 3, and in 22.4.1.4.2 [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. is_open should be const

+

Section: 27.9.1 [fstreams] Status: NAD + Submitter: Matt Austern Opened: 1998-08-27 Last modified: 2010-10-29

+

View all other issues in [fstreams].

+

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. Valarray operator[] const returning value

+

Section: 26.6.2.3 [valarray.access] Status: Dup + Submitter: Levente Farkas Opened: 1998-09-09 Last modified: 2010-10-29

+

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." +26.6.2.3 [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. Wrong declaration of slice operations

+

Section: 26.6.5 [template.slice.array], 26.6.7 [template.gslice.array], 26.6.8 [template.mask.array], 26.6.9 [template.indirect.array] Status: NAD + Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2010-10-29

+

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. Missing constant for set elements

+

Section: 23.2.4 [associative.reqmts] Status: NAD + Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2010-10-29

+

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 for a related +issue.

+ + + + +
+

84. Ambiguity with string::insert()

+

Section: 21.4.5 [string.access] Status: NAD + Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2010-10-29

+

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. String char types

+

Section: 21 [strings] Status: NAD + Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2010-10-29

+

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 21.2 [char.traits] paragraph 3 that +requires them to be the same.

+ + + + +
+

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

+

Section: 21.4.6.8 [string::swap] Status: Dup + Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2010-10-29

+

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. Inconsistency between string::insert() and string::append()

+

Section: 21.4.6.4 [string::insert], 21.4.6.2 [string::append] Status: NAD + Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2010-10-29

+

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. Missing throw specification for string::insert() and string::replace()

+

Section: 21.4.6.4 [string::insert], 21.4.6.6 [string::replace] Status: Dup + Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2010-10-29

+

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.

+ + + + + +
+

93. Incomplete Valarray Subset Definitions

+

Section: 26.6 [numarray] Status: NAD + Submitter: Nico Josuttis Opened: 1998-09-29 Last modified: 2010-10-29

+

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. May library implementors add template parameters to Standard Library classes?

+

Section: 17.6.4 [conforming] Status: NAD + Submitter: Matt Austern Opened: 1998-01-22 Last modified: 2010-10-29

+

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 17.6.4.12 [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 17.6.4 [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. Members added by the implementation

+

Section: 17.6.4.5 [member.functions] Status: NAD + Submitter: AFNOR Opened: 1998-10-07 Last modified: 2010-10-29

+

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 17.6.4.5 [member.functions] paragraph 2.

+ + + + +
+

96. Vector<bool> is not a container

+

Section: 23.4.1 [vector] Status: NAD + Submitter: AFNOR Opened: 1998-10-07 Last modified: 2010-10-29

+

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) 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. Insert inconsistent definition

+

Section: 23 [containers] Status: NAD + Submitter: AFNOR Opened: 1998-10-07 Last modified: 2010-10-29

+

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. Reverse_iterator comparisons completely wrong

+

Section: 24.5.1.3.13 [reverse.iter.op==] Status: NAD + Submitter: AFNOR Opened: 1998-10-07 Last modified: 2010-10-29

+

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. Insert iterators/ostream_iterators overconstrained

+

Section: 24.5.2 [insert.iterators], 24.6.4 [ostreambuf.iterator] Status: NAD + Submitter: AFNOR Opened: 1998-10-07 Last modified: 2010-10-29

+

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. No way to free storage for vector and deque

+

Section: 23.4.1 [vector], 23.3.1 [array] Status: NAD Editorial + Submitter: AFNOR Opened: 1998-10-07 Last modified: 2010-10-29

+

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, 850). 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. Bug in insert range in associative containers

+

Section: 23.2.4 [associative.reqmts] Status: Dup + Submitter: AFNOR Opened: 1998-10-07 Last modified: 2010-10-29

+

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.

+ + + + + +
+

104. Description of basic_string::operator[] is unclear

+

Section: 21.4.4 [string.capacity] Status: NAD + Submitter: AFNOR Opened: 1998-10-07 Last modified: 2010-10-29

+

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. fstream ctors argument types desired

+

Section: 27.9 [file.streams] Status: Dup + Submitter: AFNOR Opened: 1998-10-07 Last modified: 2010-10-29

+

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. Valarray constructor is strange

+

Section: 26.6.2 [template.valarray] Status: NAD + Submitter: AFNOR Opened: 1998-10-07 Last modified: 2010-10-29

+

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. istreambuf_iterator::equal overspecified, inefficient

+

Section: 24.6.3.5 [istreambuf.iterator::equal] Status: NAD + Submitter: Nathan Myers Opened: 1998-10-15 Last modified: 2010-10-29

+

View all other issues in [istreambuf.iterator::equal].

+

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.2.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 24.6.3.5 [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. Missing/extra iostream sync semantics

+

Section: 27.7.1.1 [istream], 27.7.1.3 [istream.unformatted] Status: NAD + Submitter: Steve Clamage Opened: 1998-10-13 Last modified: 2010-10-29

+

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. bitset cannot be constructed with a const char*

+

Section: 20.5 [template.bitset] Status: Dup + Submitter: Judy Ward Opened: 1998-11-06 Last modified: 2010-10-29

+

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 20.5 [template.bitset] a bitset constructor declaration

+ +
+ 
explicit bitset(const char*);
+
+ +

and in Section 20.5.1 [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. Detailed definition for ctype<wchar_t> specialization

+

Section: 22.3.1.1.1 [locale.category] Status: NAD + Submitter: Judy Ward Opened: 1998-12-15 Last modified: 2010-10-29

+

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 22.4.1.1 [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 22.4.1.3 [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 +22.4.1.3 [facet.ctype.special].

+ + +

Rationale:

+

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

+ + + + + +
+

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

+

Section: 27.8 [string.streams], 27.9 [file.streams] Status: NAD + Submitter: Angelika Langer Opened: 1999-02-22 Last modified: 2010-10-29

+

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 27.6.2 [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. list::splice throws nothing

+

Section: 23.3.4.4 [list.ops] Status: NAD + Submitter: Howard Hinnant Opened: 1999-03-06 Last modified: 2010-10-29

+

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. basic_iostream doubly initialized

+

Section: 27.7.1.5.1 [iostream.cons] Status: NAD + Submitter: Howard Hinnant Opened: 1999-03-06 Last modified: 2010-10-29

+

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. Class ctype_byname<char> redundant and misleading

+

Section: 22.4.1.4 [locale.codecvt] Status: NAD + Submitter: Angelika Langer Opened: 1999-03-18 Last modified: 2010-10-29

+

View all other issues in [locale.codecvt].

+

View all issues with NAD status.

+

Discussion:

+

Section 22.4.1.4 [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.

+ + + + +
+

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

+

Section: 23.6.1 [map] Status: NAD Editorial + Submitter: Mark Mitchell Opened: 1999-04-14 Last modified: 2010-10-29

+

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.6.1 [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 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. C .h header wording unclear

+

Section: D.7 [depr.c.headers] Status: NAD + Submitter: Christophe de Dinechin Opened: 1999-05-04 Last modified: 2010-10-29

+

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 D.7 [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. adjustfield lacks default value

+

Section: 27.5.4.1 [basic.ios.cons] Status: NAD + Submitter: Angelika Langer Opened: 1999-05-12 Last modified: 2010-10-29

+

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 22.4.2.2.2 [facet.num.put.virtuals] paragraph 19, Table 61 - Fill padding.

+ + + + +
+

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

+

Section: 27.5.2.5 [ios.base.storage] Status: Dup + Submitter: Dietmar Kühl Opened: 1999-07-20 Last modified: 2010-10-29

+

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 27.5.2.5 [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. Really "formatted input functions"?

+

Section: 27.7.1.2.3 [istream::extractors] Status: Dup + Submitter: Dietmar Kühl Opened: 1999-07-20 Last modified: 2010-10-29

+

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 27.7.1.2.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 for the same problem in formatted +output

+ + +

Rationale:

+ + + + + +
+

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

+

Section: 27.7.1.3 [istream.unformatted] Status: Dup + Submitter: Dietmar Kühl Opened: 1999-07-20 Last modified: 2010-10-29

+

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 27.7.1.3 [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. Really "formatted output functions"?

+

Section: 27.7.2.6.3 [ostream.inserters] Status: Dup + Submitter: Dietmar Kühl Opened: 1999-07-20 Last modified: 2010-10-29

+

View all issues with Dup status.

+

Duplicate of: 60

+

Discussion:

+

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

+ +

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

+ + +

Rationale:

+ + + + + +
+

177. Complex operators cannot be explicitly instantiated

+

Section: 26.4.6 [complex.ops] Status: NAD + Submitter: Judy Ward Opened: 1999-07-02 Last modified: 2010-10-29

+

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. Should clog and cerr initially be tied to cout?

+

Section: 27.4.1 [narrow.stream.objects] Status: NAD + Submitter: Judy Ward Opened: 1999-07-02 Last modified: 2010-10-29

+

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. valarray helpers missing augmented assignment operators

+

Section: 26.6.2.6 [valarray.cassign] Status: NAD + Submitter: Gabriel Dos Reis Opened: 1999-08-15 Last modified: 2010-10-29

+

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. min() and max() functions should be std::binary_functions

+

Section: 25.4.7 [alg.min.max] Status: NAD + Submitter: Mark Rintoul Opened: 1999-08-26 Last modified: 2010-10-29

+

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. Unclear complexity for algorithms such as binary search

+

Section: 25.4.3 [alg.binary.search] Status: NAD + Submitter: Nico Josuttis Opened: 1999-10-10 Last modified: 2010-10-29

+

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. a.insert(p,t) is inefficient and overconstrained

+

Section: 23.2.4 [associative.reqmts] Status: NAD + Submitter: Ed Brey Opened: 1999-06-06 Last modified: 2010-10-29

+

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:

+ + + + + + + + + + + + + +
expressionreturn typepre/post-conditioncomplexity
a.insert(p,t)iteratorinserts 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.4 [associative.reqmts] paragraph 7, replace the row in table 69 +for a.insert(p,t) with the following two rows:

+ + + + + + + + + + + + + + + + + + + +
expressionreturn typepre/post-conditioncomplexity
a_uniq.insert(p,t)iteratorinserts 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)iteratorinserts 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. rdbuf() functions poorly specified

+

Section: 27.5.4 [ios] Status: NAD + Submitter: Steve Clamage Opened: 1999-09-07 Last modified: 2010-10-29

+

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 +17.6.4.5 [member.functions].

+ + + + +
+

196. Placement new example has alignment problems

+

Section: 18.6.1.3 [new.delete.placement] Status: Dup + Submitter: Herb Sutter Opened: 1998-12-15 Last modified: 2010-10-29

+

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

+

View all issues with Dup status.

+

Duplicate of: 114

+

Discussion:

+

The example in 18.6.1.3 [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. max_size() underspecified

+

Section: 20.2.5 [allocator.requirements], 23.2 [container.requirements] Status: NAD + Submitter: Andy Sawyer Opened: 1999-10-21 Last modified: 2010-10-29

+

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. basic_istream::sentry::sentry() is uninstantiable with ctype<user-defined type>

+

Section: 27.7.1.1.3 [istream::sentry] Status: NAD + Submitter: Matt McClure and Dietmar Kühl Opened: 2000-01-01 Last modified: 2010-10-29

+

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. distance(first, last) when "last" is before "first"

+

Section: 24.4.4 [iterator.operations] Status: NAD + Submitter: Rintala Matti Opened: 2000-01-28 Last modified: 2010-10-29

+

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 X [iterator.concepts] paragraph 6. +The definition is only in terms of operator++(). The LWG sees no defect in +the standard.

+ + + + +
+

205. numeric_limits unclear on how to determine floating point types

+

Section: 18.3.1.2 [numeric.limits.members] Status: NAD + Submitter: Steve Cleary Opened: 2000-01-28 Last modified: 2010-10-29

+

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

+

View all issues with NAD status.

+

Discussion:

+

In several places in 18.3.1.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 18.3.1.5 [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. ctype<char> members return clause incomplete

+

Section: 22.4.1.3.2 [facet.ctype.char.members] Status: Dup + Submitter: Robert Klarer Opened: 1999-11-02 Last modified: 2010-10-29

+

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 22.4.1.3.2 [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 22.4.1.3.2 [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, which addresses the same +paragraphs.

+ + + + + + +
+

213. Math function overloads ambiguous

+

Section: 26.8 [c.math] Status: NAD + Submitter: Nico Josuttis Opened: 2000-02-26 Last modified: 2010-10-29

+

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. Can a map's key_type be const?

+

Section: 23.2.4 [associative.reqmts] Status: NAD + Submitter: Judy Ward Opened: 2000-02-29 Last modified: 2010-10-29

+

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.4 [associative.reqmts] already implies the key cannot be const.

+ + + + +
+

216. setbase manipulator description flawed

+

Section: 27.7.3 [std.manip] Status: Dup + Submitter: Hyman Rosen Opened: 2000-02-29 Last modified: 2010-10-29

+

View all other issues in [std.manip].

+

View all issues with Dup status.

+

Duplicate of: 193

+

Discussion:

+

27.7.3 [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.

+ +

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

+ + + + + + + + +
+

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

+

Section: 25.4 [alg.sorting] Status: NAD + Submitter: Pablo Halpern Opened: 2000-03-06 Last modified: 2010-10-29

+

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. find algorithm missing version that takes a binary predicate argument

+

Section: 25.2.5 [alg.find] Status: NAD + Submitter: Pablo Halpern Opened: 2000-03-06 Last modified: 2010-10-29

+

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 25.2.5 [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. ctype<char>::is() member modifies facet

+

Section: 22.4.1.3.2 [facet.ctype.char.members] Status: Dup + Submitter: Dietmar Kühl Opened: 2000-04-24 Last modified: 2010-10-29

+

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 22.4.1.3.2 [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 22.4.1.1.2 [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. Must find's third argument be CopyConstructible?

+

Section: 25.2.5 [alg.find] Status: NAD + Submitter: Andrew Koenig Opened: 2000-05-02 Last modified: 2010-10-29

+

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. Which operations on istream_iterator trigger input operations?

+

Section: 24.6.1 [istream.iterator] Status: NAD + Submitter: Andrew Koenig Opened: 2000-05-02 Last modified: 2010-10-29

+

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. a.insert(p,t) is incorrectly specified

+

Section: 23.2.4 [associative.reqmts] Status: Dup + Submitter: Mark Rodgers Opened: 2000-05-19 Last modified: 2010-10-29

+

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

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

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

  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.

    5. +
+ + +

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. Return Type of auto_ptr::operator=

+

Section: D.12.1 [auto.ptr] Status: NAD + Submitter: Joseph Gottman Opened: 2000-06-30 Last modified: 2010-10-29

+

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. Why do basic_streambuf<>::pbump() and gbump() take an int?

+

Section: 27.6.2 [streambuf] Status: NAD Future + Submitter: Martin Sebor Opened: 2000-08-12 Last modified: 2010-10-29

+

View all other issues in [streambuf].

+

View all issues with NAD Future 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. +

+
+ + + +

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. STL functional object and iterator inheritance.

+

Section: X [base], 24.4.2 [iterator.basic] Status: NAD + Submitter: Robert Dick Opened: 2000-08-17 Last modified: 2010-10-29

+

View all other issues in [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. interaction of strstreambuf::overflow() and seekoff()

+

Section: D.9.1.3 [depr.strstreambuf.virtuals] Status: NAD + Submitter: Martin Sebor Opened: 2000-10-05 Last modified: 2010-10-29

+

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 D.9.1 [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: it's not clear what it +means to seek beyond the current area. Without resolving issue 65 we can't resolve this. As with issue 65, +the library working group does not wish to invest time nailing down +corner cases in a deprecated feature.

+ + + + + +
+

269. cstdarg and unnamed parameters

+

Section: 18.8 [support.exception] Status: NAD + Submitter: J. Stephen Adamczyk Opened: 2000-10-10 Last modified: 2010-10-29

+

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. Normative encouragement in allocator requirements unclear

+

Section: 20.2.5 [allocator.requirements] Status: NAD + Submitter: Matt Austern Opened: 2000-11-07 Last modified: 2010-10-29

+

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. 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: 2010-10-29

+

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. 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.)

+ + + + + + +
+

287. conflicting ios_base fmtflags

+

Section: 27.5.2.2 [fmtflags.state] Status: NAD + Submitter: Judy Ward Opened: 2000-12-30 Last modified: 2010-10-29

+

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. +
  2. The last call to setf "wins", i.e. it clears any conflicting +previous setting.
    3. +
  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.
    4. +
+ +

+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 22.4.2.2.2 [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. <cmath> requirements missing C float and long double versions

+

Section: 26.8 [c.math] Status: NAD + Submitter: Judy Ward Opened: 2000-12-30 Last modified: 2010-10-29

+

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. Requirements to for_each and its function object

+

Section: 25.2.4 [alg.foreach] Status: NAD + Submitter: Angelika Langer Opened: 2001-01-03 Last modified: 2010-10-29

+

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. Order of execution in transform algorithm

+

Section: 25.3.4 [alg.transform] Status: NAD + Submitter: Angelika Langer Opened: 2001-01-04 Last modified: 2010-10-29

+

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. Incorrect return types for iterator dereference

+

Section: 24.2.6 [bidirectional.iterators], 24.2.7 [random.access.iterators] Status: NAD Editorial + Submitter: John Potter Opened: 2001-01-22 Last modified: 2010-10-29

+

View all other issues in [bidirectional.iterators].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In section 24.2.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.2.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 iterartor, 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. Need error indication from codecvt<>::do_length

+

Section: 22.4.1.5 [locale.codecvt.byname] Status: NAD + Submitter: Gregory Bumgardner Opened: 2001-01-25 Last modified: 2010-10-29

+

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, 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. Must *a return an lvalue when a is an input iterator?

+

Section: X [iterator.concepts] Status: NAD + Submitter: Dave Abrahams Opened: 2001-02-05 Last modified: 2010-10-29

+

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. Does sentry catch exceptions?

+

Section: 27.7 [iostream.format] Status: NAD + Submitter: Martin Sebor Opened: 2001-03-19 Last modified: 2010-10-29

+

View all other issues in [iostream.format].

+

View all issues with NAD status.

+

Discussion:

+

+The descriptions of the constructors of basic_istream<>::sentry +(27.7.1.1.3 [istream::sentry]) and basic_ostream<>::sentry +(27.7.2.4 [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, since +the function performs an input operation which may fail. However, +issue 195 amends 27.7.1.1.3 [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 27.7.2.4 [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://anubis.dkuug.dk/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://anubis.dkuug.dk/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 +(http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#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. set_terminate and set_unexpected question

+

Section: 18.8.3.3 [terminate] Status: NAD + Submitter: Judy Ward Opened: 2001-04-03 Last modified: 2010-10-29

+

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. Is the stack unwound when terminate() is called?

+

Section: 18.8.3.3 [terminate] Status: NAD + Submitter: Detlef Vollmann Opened: 2001-04-11 Last modified: 2010-10-29

+

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. abs() overloads in different headers

+

Section: 26.8 [c.math] Status: NAD + Submitter: Dave Abrahams Opened: 2001-06-04 Last modified: 2010-10-29

+

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.

+ +

[ +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. Missing typedef in moneypunct_byname

+

Section: 22.4.6.4 [locale.moneypunct.byname] Status: NAD + Submitter: Martin Sebor Opened: 2001-07-05 Last modified: 2010-10-29

+

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 +22.4.6.4 [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. Misleading "exposition only" value in class locale definition

+

Section: 22.3.1 [locale] Status: NAD + Submitter: Martin Sebor Opened: 2001-07-15 Last modified: 2010-10-29

+

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 (22.3.1.1.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.

+ + + + + +
+

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

+

Section: 27.5.3 [fpos] Status: NAD + Submitter: PremAnand M. Rao Opened: 2001-08-27 Last modified: 2010-10-29

+

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 27.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. seek and eofbit

+

Section: 27.7.1.3 [istream.unformatted] Status: NAD + Submitter: Howard Hinnant Opened: 2001-10-09 Last modified: 2010-10-29

+

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 which is now a dr, the +description of seekg in 27.7.1.3 [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 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 27.7.1.3 [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.

+ + + + + +
+

343. Unspecified library header dependencies

+

Section: 17 [library] Status: NAD + Submitter: Martin Sebor Opened: 2001-10-09 Last modified: 2010-10-29

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD status.

+

Discussion:

+

+The synopses of the C++ library headers clearly show which names are +required to be defined in each header. Since in order to implement the +classes and templates defined in these headers declarations of other +templates (but not necessarily their definitions) are typically +necessary the standard in 17.4.4, p1 permits library implementers to +include any headers needed to implement the definitions in each header. +

+ +

+For instance, although it is not explicitly specified in the synopsis of +<string>, at the point of definition of the std::basic_string template +the declaration of the std::allocator template must be in scope. All +current implementations simply include <memory> from within <string>, +either directly or indirectly, to bring the declaration of +std::allocator into scope. +

+ +

+Additionally, however, some implementation also include <istream> and +<ostream> at the top of <string> to bring the declarations of +std::basic_istream and std::basic_ostream into scope (which are needed +in order to implement the string inserter and extractor operators +(21.3.7.9 [lib.string.io])). Other implementations only include +<iosfwd>, since strictly speaking, only the declarations and not the +full definitions are necessary. +

+ +

+Obviously, it is possible to implement <string> without actually +providing the full definitions of all the templates std::basic_string +uses (std::allocator, std::basic_istream, and std::basic_ostream). +Furthermore, not only is it possible, doing so is likely to have a +positive effect on compile-time efficiency. +

+ +

+But while it may seem perfectly reasonable to expect a program that uses +the std::basic_string insertion and extraction operators to also +explicitly include <istream> or <ostream>, respectively, it doesn't seem +reasonable to also expect it to explicitly include <memory>. Since +what's reasonable and what isn't is highly subjective one would expect +the standard to specify what can and what cannot be assumed. +Unfortunately, that isn't the case. +

+ +

The examples below demonstrate the issue.

+ +

Example 1:

+ +

It is not clear whether the following program is complete:

+ +
#include <string>
+
+extern std::basic_ostream<char> &strm;
+
+int main () {
+    strm << std::string ("Hello, World!\n");
+}
+
+ +

or whether one must explicitly include <memory> or +<ostream> (or both) in addition to <string> in order for +the program to compile.

+ + +

Example 2:

+ +

Similarly, it is unclear whether the following program is complete:

+ +
#include <istream>
+
+extern std::basic_iostream<char> &strm;
+
+int main () {
+    strm << "Hello, World!\n";
+}
+
+ +

+or whether one needs to explicitly include <ostream>, and +perhaps even other headers containing the definitions of other +required templates:

+ +
#include <ios>
+#include <istream>
+#include <ostream>
+#include <streambuf>
+
+extern std::basic_iostream<char> &strm;
+
+int main () {
+    strm << "Hello, World!\n";
+}
+
+ +

Example 3:

+ +

Likewise, it seems unclear whether the program below is complete:

+
#include <iterator>
+
+bool foo (std::istream_iterator<int> a, std::istream_iterator<int> b)
+{
+    return a == b;
+}
+
+int main () { }
+
+ +

or whether one should be required to include <istream>.

+ +

There are many more examples that demonstrate this lack of a +requirement. I believe that in a good number of cases it would be +unreasonable to require that a program explicitly include all the +headers necessary for a particular template to be specialized, but I +think that there are cases such as some of those above where it would +be desirable to allow implementations to include only as much as +necessary and not more.

+ +

[ +post Bellevue: +]

+ + +
+Position taken in prior reviews is that the idea of a table of header +dependencies is a good one. Our view is that a full paper is needed to +do justice to this, and we've made that recommendation to the issue +author. +
+ +

[ +2009-07 Frankfurt +]

+ + +
+NAD. Handled by LWG 1178. +
+ + + +

Proposed resolution:

+

+For every C++ library header, supply a minimum set of other C++ library +headers that are required to be included by that header. The proposed +list is below (C++ headers for C Library Facilities, table 12 in +17.4.1.2, p3, are omitted): +

+ +
+------------+--------------------+
+| C++ header |required to include |
++============+====================+
+|<algorithm> |                    |
++------------+--------------------+
+|<bitset>    |                    |
++------------+--------------------+
+|<complex>   |                    |
++------------+--------------------+
+|<deque>     |<memory>            |
++------------+--------------------+
+|<exception> |                    |
++------------+--------------------+
+|<fstream>   |<ios>               |
++------------+--------------------+
+|<functional>|                    |
++------------+--------------------+
+|<iomanip>   |<ios>               |
++------------+--------------------+
+|<ios>       |<streambuf>         |
++------------+--------------------+
+|<iosfwd>    |                    |
++------------+--------------------+
+|<iostream>  |<istream>, <ostream>|
++------------+--------------------+
+|<istream>   |<ios>               |
++------------+--------------------+
+|<iterator>  |                    |
++------------+--------------------+
+|<limits>    |                    |
++------------+--------------------+
+|<list>      |<memory>            |
++------------+--------------------+
+|<locale>    |                    |
++------------+--------------------+
+|<map>       |<memory>            |
++------------+--------------------+
+|<memory>    |                    |
++------------+--------------------+
+|<new>       |<exception>         |
++------------+--------------------+
+|<numeric>   |                    |
++------------+--------------------+
+|<ostream>   |<ios>               |
++------------+--------------------+
+|<queue>     |<deque>             |
++------------+--------------------+
+|<set>       |<memory>            |
++------------+--------------------+
+|<sstream>   |<ios>, <string>     |
++------------+--------------------+
+|<stack>     |<deque>             |
++------------+--------------------+
+|<stdexcept> |                    |
++------------+--------------------+
+|<streambuf> |<ios>               |
++------------+--------------------+
+|<string>    |<memory>            |
++------------+--------------------+
+|<strstream> |                    |
++------------+--------------------+
+|<typeinfo>  |<exception>         |
++------------+--------------------+
+|<utility>   |                    |
++------------+--------------------+
+|<valarray>  |                    |
++------------+--------------------+
+|<vector>    |<memory>            |
++------------+--------------------+
+
+ + +

Rationale:

+

The portability problem is real. A program that works correctly on +one implementation might fail on another, because of different header +dependencies. This problem was understood before the standard was +completed, and it was a conscious design choice.

+

One possible way to deal with this, as a library extension, would +be an <all> header.

+ +

+Hinnant: It's time we dealt with this issue for C++0X. Reopened. +

+ + + + + + + +
+

344. grouping + showbase

+

Section: 22.4.2 [category.numeric] Status: NAD + Submitter: Howard Hinnant Opened: 2001-10-13 Last modified: 2010-10-29

+

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 22.4.3.1.2 [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. Minor issue with std::pair operator<

+

Section: 20.3.5 [pairs] Status: Dup + Submitter: Andy Sawyer Opened: 2001-10-23 Last modified: 2010-10-29

+

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 20.3.5 [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. allocator<>::address

+

Section: 20.9.5.1 [allocator.members], 20.2.5 [allocator.requirements], 17.6.1.1 [contents] Status: Dup + Submitter: Nathan Myers Opened: 2001-10-25 Last modified: 2010-10-29

+

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 (20.2.1 [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. unary_negate and binary_negate: struct or class?

+

Section: 20.8 [function.objects] Status: NAD Editorial + Submitter: Dale Riley Opened: 2001-11-12 Last modified: 2010-10-29

+

View all other issues in [function.objects].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In 20.8 [function.objects] the header <functional> synopsis declares +the unary_negate and binary_negate function objects as struct. +However in 20.8.9 [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 20.8.9 [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. Meaning of ctype_base::mask enumerators

+

Section: 22.4.1 [category.ctype] Status: NAD + Submitter: Matt Austern Opened: 2002-01-23 Last modified: 2010-10-29

+

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 22.4.1 [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 is related, but not identical. The +proposed resolution if issue 339 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. +
  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. +
  3. Explicitly leave this unspecified, which the result that the above +program is not portable.
    4. +
+ +

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. <cmath> float functions cannot return HUGE_VAL

+

Section: 26.8 [c.math] Status: NAD Editorial + Submitter: Ray Lischner Opened: 2002-02-26 Last modified: 2010-10-29

+

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. num_get<>::do_get (..., void*&) checks grouping

+

Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: NAD + Submitter: Martin Sebor Opened: 2002-03-12 Last modified: 2010-10-29

+

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. Excessive const-qualification

+

Section: 27 [input.output] Status: NAD + Submitter: Walter Brown, Marc Paterno Opened: 2002-05-10 Last modified: 2010-10-29

+

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. remove_copy/remove_copy_if and Input Iterators

+

Section: 25.3.8 [alg.remove] Status: NAD + Submitter: Anthony Williams Opened: 2002-05-13 Last modified: 2010-10-29

+

View all other issues in [alg.remove].

+

View all issues with NAD status.

+

Discussion:

+

+remove_copy and remove_copy_if (25.3.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 +25.3.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. basic_string::replace has two "Throws" paragraphs

+

Section: 21.4.6.6 [string::replace] Status: NAD Editorial + Submitter: Beman Dawes Opened: 2002-06-03 Last modified: 2010-10-29

+

View all other issues in [string::replace].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+21.4.6.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. Inconsistent description of stdlib exceptions

+

Section: 17.6.4.12 [res.on.exception.handling], 18.7.1 [type.info] Status: NAD + Submitter: Randy Maddox Opened: 2002-07-22 Last modified: 2010-10-29

+

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

+

View all issues with NAD status.

+

Discussion:

+ +

Paragraph 3 under clause 17.6.4.12 [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 +18.7.1 [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. moneypunct::frac_digits returns int not unsigned

+

Section: 22.4.6.3.1 [locale.moneypunct.members], 22.4.6.3.2 [locale.moneypunct.virtuals] Status: NAD + Submitter: Ray Lischner Opened: 2002-08-08 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+In section 22.4.6.3.1 [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 22.4.6.3.2 [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. basic_string::insert and length_error

+

Section: 21.4.6.4 [string::insert] Status: NAD + Submitter: Ray Lischner Opened: 2002-08-16 Last modified: 2010-10-29

+

View all other issues in [string::insert].

+

View all issues with NAD status.

+

Discussion:

+

+Section 21.4.6.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. locale immutability and locale::operator=()

+

Section: 22.3.1 [locale] Status: Dup + Submitter: Martin Sebor Opened: 2002-09-06 Last modified: 2010-10-29

+

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 and recommend that it be + closed. +]

+ + + + + + +
+

382. codecvt do_in/out result

+

Section: 22.4.1.4 [locale.codecvt] Status: NAD + Submitter: Martin Sebor Opened: 2002-08-30 Last modified: 2010-10-29

+

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. +
  2. + precisely when the functions return ok +
    3. +
  3. + precisely when the functions return partial +
    4. +
  4. + the full set of conditions when the functions return error +
    5. +
+ +
    +
  1. + 22.4.1.4.2 [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. +
  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. +
  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. +
  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). +
    5. +
+

+Finally, the conditions described at the end of 22.4.1.4.2 [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 22.4.1.4.2 [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. Does call by value imply the CopyConstructible requirement?

+

Section: 17 [library] Status: NAD + Submitter: Matt Austern Opened: 2002-10-23 Last modified: 2010-10-29

+

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 +25.2.5 [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 25 [algorithms] +and 26 [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 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, allowing +function objects to reliably maintain state. E.g. the example in 92 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. Use of complex as a key in associative containers

+

Section: 26.4 [complex.numbers] Status: NAD + Submitter: Gabriel Dos Reis Opened: 2002-11-08 Last modified: 2010-10-29

+

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 approriate +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.

+ +

[ +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, 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. CopyConstructible requirements too strict

+

Section: 20.2.1 [utility.arg.requirements] Status: NAD Editorial + Submitter: Doug Gregor Opened: 2002-10-24 Last modified: 2010-10-29

+

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, 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. 'equivalence' for input iterators

+

Section: 24.2.3 [input.iterators] Status: NAD + Submitter: Corwin Joy Opened: 2002-12-11 Last modified: 2010-10-29

+

View all other issues in [input.iterators].

+

View all issues with NAD status.

+

Discussion:

+ +

+In section 24.2.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 24.6.3.5 [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 24.6.3.5 [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 24.6.3.5 [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. do_in/do_out operation on state unclear

+

Section: 22.4.1.4.2 [locale.codecvt.virtuals] Status: NAD Editorial + Submitter: Alberto Barbati Opened: 2002-12-24 Last modified: 2010-10-29

+

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 22.4.1.4.2 [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. behavior of formatted output on failure

+

Section: 27.7.2.6.1 [ostream.formatted.reqmts] Status: NAD + Submitter: Martin Sebor Opened: 2002-12-27 Last modified: 2010-10-29

+

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. ostream::sentry dtor throws exceptions

+

Section: 27.7.2.4 [ostream::sentry] Status: NAD Editorial + Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2010-10-29

+

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 and 622 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 is written to match the outcome +of this issue. +
+ +

[ +2009 Santa Cruz: +]

+ + +
+Move to Open. Our intent is to solve this issue with 835. +
+ +

[ +2010-03-06 Martin updates wording. +]

+ + +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Editorial. +
+ + + +

Rationale:

+

+Solved by 835. +

+ + +

Proposed resolution:

+

+Add after 27.7.2.4 [ostream::sentry] p17: +

+ +
+
~sentry();
+
+
+

+-17- If (os.flags() & ios_base::unitbuf) +is true, calls os.flush(). +

+ +

+Throws: Nothing. +

+
+
+ + + + + +
+

398. effects of end-of-file on unformatted input functions

+

Section: 27.7.2.4 [ostream::sentry] Status: NAD + Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2010-10-29

+

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 27.7.1.1 [istream] p3. +
+ + + +

Proposed resolution:

+ + + + +
+

399. volations of unformatted input function requirements

+

Section: 27.7.1.3 [istream.unformatted] Status: NAD + Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2010-10-29

+

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. Is vector<reverse_iterator<char*> > forbidden?

+

Section: 24.2 [iterator.requirements] Status: NAD Editorial + Submitter: Nathan Myers Opened: 2003-06-03 Last modified: 2010-10-29

+

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

+ +

+X [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, 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, 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, 1012

+

[ +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. +

+

+Note that there is a bug in the proposed resolution to LWG 1012. 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 (now corrected) is +sufficient to solve the problem for reverse_iterator. However, Alisdair +pointed out that LWG 1012 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 +]

+ + +

[ +2009-10-14 Daniel adds: +]

+ + +
+There is a clear dependency on 1213, 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.2 [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 (8.5 [dcl.init]), although the distinction only +matters for types with trivial default constructors such as pointers. — +end note] +

+ + +
+ + + + + + +
+

417. what does ctype::do_widen() return on failure

+

Section: 22.4.1.1.2 [locale.ctype.virtuals] Status: NAD + Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2010-10-29

+

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. exceptions thrown during iostream cleanup

+

Section: 27.5.2.1.6 [ios::Init] Status: NAD + Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2010-10-29

+

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 and 622 for related issues. +]

+ + +

[ +2009-07 Frankfurt +]

+ + +
+Moved to NAD, no consensus for change. +
+ + + +

Proposed resolution:

+ + + + +
+

421. is basic_streambuf copy-constructible?

+

Section: 27.6.2.1 [streambuf.cons] Status: NAD + Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2010-10-29

+

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

+ +

[ +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 inhert 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. +

+ + + + + + +
+

423. effects of negative streamsize in iostreams

+

Section: 27 [input.output] Status: NAD Future + Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2010-10-29

+

View all other issues in [input.output].

+

View all issues with NAD Future status.

+

Discussion:

+ +

+A third party test suite tries to exercise istream::ignore(N) with +a negative value of N and expects that the implementation will treat +N as if it were 0. Our implementation asserts that (N >= 0) holds and +aborts the test. +

+ +

+I can't find anything in section 27 that prohibits such values but I don't +see what the effects of such calls should be, either (this applies to +a number of unformatted input functions as well as some member functions +of the basic_streambuf template). +

+ +

[ +2009-07 Frankfurt +]

+ + +
+

+This is related to LWG 255. +

+

+Move to NAD Future. +

+
+ + + +

Proposed resolution:

+

+I propose that we add to each function in clause 27 that takes an argument, +say N, of type streamsize a Requires clause saying that "N >= 0." The intent +is to allow negative streamsize values in calls to precision() and width() +but disallow it in calls to streambuf::sgetn(), istream::ignore(), or +ostream::write(). +

+ +

[Kona: The LWG agreed that this is probably what we want. However, we + need a review to find all places where functions in clause 27 take + arguments of type streamsize that shouldn't be allowed to go + negative. Martin will do that review.]

+ + + + + + +
+

424. normative notes

+

Section: 17.5.1.2 [structure.summary] Status: NAD Editorial + Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2010-10-29

+

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.9.5.1 [allocator.members], p3,
+20.9.5.1 [allocator.members], p10,
+21.4.2 [string.cons], p11,
+22.3.1.2 [locale.cons], p11,
+23.3.2.3 [deque.modifiers], p2,
+25.4.7 [alg.min.max], p3,
+26.4.6 [complex.ops], p15,
+27.6.2.4.3 [streambuf.virt.get], p7.
+
+ +List 2 -- Examples of (presumably) informative Notes: +
+ +18.6.1.3 [new.delete.placement], p3,
+21.4.6.6 [string::replace], p14,
+22.4.1.4.2 [locale.codecvt.virtuals], p3,
+25.2.4 [alg.foreach], p4,
+26.4.5 [complex.member.ops], p1,
+27.5.2.5 [ios.base.storage], p6.
+
+ +List 3 -- Examples of Notes that are not clearly either normative +or informative: +
+ +22.3.1.2 [locale.cons], p8,
+22.3.1.5 [locale.statics], p6,
+27.6.2.4.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. typo in basic_ios::clear(iostate)

+

Section: 27.5.4.3 [iostate.flags] Status: Dup + Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2010-10-29

+

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. Contradiction in specification of unexpected()

+

Section: D.13.3 [unexpected] Status: NAD + Submitter: Vyatcheslav Sysoltsev Opened: 2003-09-29 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+Clause 15.5.2 [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. Formatted output of function pointers is confusing

+

Section: 27.7.2.6.2 [ostream.inserters.arithmetic] Status: NAD + Submitter: Ivan Godard Opened: 2003-10-24 Last modified: 2010-10-29

+

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. Should facets be copyable?

+

Section: 22.4 [locale.categories] Status: NAD + Submitter: Matt Austern Opened: 2003-11-02 Last modified: 2010-10-29

+

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.

+ +
        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. Should std::complex use unqualified transcendentals?

+

Section: 26.4.8 [complex.transcendentals] Status: NAD + Submitter: Matt Austern Opened: 2003-11-05 Last modified: 2010-10-29

+

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.

+ +

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." (26.4.1 [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. Iterator equality between different containers

+

Section: 24.2 [iterator.requirements], 23.2 [container.requirements] Status: NAD Editorial + Submitter: Andy Koenig Opened: 2003-12-16 Last modified: 2010-10-29

+

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.2 [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. Wrong template argument for time facets

+

Section: 22.3.1.1.1 [locale.category] Status: Dup + Submitter: Pete Becker Opened: 2003-12-26 Last modified: 2010-10-29

+

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. set::find is inconsistent with associative container requirements

+

Section: 23.6.3 [set] Status: Dup + Submitter: Bill Plauger Opened: 2004-01-30 Last modified: 2010-10-29

+

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. Associative erase should return an iterator

+

Section: 23.2.4 [associative.reqmts], 23.6 [associative] Status: Dup + Submitter: Bill Plauger Opened: 2004-01-30 Last modified: 2010-10-29

+

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. locale::combine should be permitted to generate a named locale

+

Section: 22.3.1.3 [locale.members] Status: NAD + Submitter: Bill Plauger Opened: 2004-01-30 Last modified: 2010-10-29

+

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. basic_filebuf::open should accept wchar_t names

+

Section: 27.9.1.4 [filebuf.members] Status: NAD + Submitter: Bill Plauger Opened: 2004-01-30 Last modified: 2010-10-29

+

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. 24.1.5 contains unintended limitation for operator-

+

Section: 24.2.7 [random.access.iterators] Status: NAD + Submitter: Daniel Frey Opened: 2004-02-27 Last modified: 2010-10-29

+

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.2.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 ofthe 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. Requirement for widening in stage 2 is overspecification

+

Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: NAD + Submitter: Martin Sebor Opened: 2004-03-16 Last modified: 2010-10-29

+

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 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 22.4.1.1.2 [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. +
  2. call narrow on the input and compare the narrow input + with the atoms
    3. +
  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
    4. +
+ + + + + +
+

462. Destroying objects with static storage duration

+

Section: 3.6.3 [basic.start.term], 18.4 [cstdint] Status: NAD + Submitter: Bill Plauger Opened: 2004-03-23 Last modified: 2010-10-29

+

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 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. auto_ptr usability issues

+

Section: D.12.1 [auto.ptr] Status: NAD + Submitter: Rani Sharoni Opened: 2003-12-07 Last modified: 2010-10-29

+

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://anubis.dkuug.dk/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. +
  2. call string::string(char const*) and throw
    3. +
+ +

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

[ +209-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 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) with +proposed wording to handle auto_ptr_ref. +
+ + + +

Proposed resolution:

+

+Change the synopsis in D.12.1 [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 D.12.1.3 [auto.ptr.conv]. +

+ +

+Change D.12.1 [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 D.12.1.1 [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 D.12.1.1 [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. basic_string ctor should prevent null pointer error

+

Section: 21.4.1 [string.require] Status: NAD + Submitter: Daniel Frey Opened: 2004-06-10 Last modified: 2010-10-29

+

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 21.4 [basic.string] +

+ +
basic_string( nullptr_t ) = delete;
+
+ + + + + +
+

470. accessing containers from their elements' special functions

+

Section: 23 [containers] Status: NAD + Submitter: Martin Sebor Opened: 2004-06-28 Last modified: 2010-10-29

+

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. Missing "Returns" clause in std::equal_range

+

Section: 25.4.3.3 [equal.range] Status: Dup + Submitter: Prateek R Karandikar Opened: 2004-06-30 Last modified: 2010-10-29

+

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.

+ + + + + + +
+

476. Forward Iterator implied mutability

+

Section: 24.2.5 [forward.iterators] Status: NAD + Submitter: Dave Abrahams Opened: 2004-07-09 Last modified: 2010-10-29

+

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. 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. Operator-> for const forward iterators

+

Section: 24.2.5 [forward.iterators] Status: Dup + Submitter: Dave Abrahams Opened: 2004-07-11 Last modified: 2010-10-29

+

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

+ + +

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

+ + + + + +
+

479. Container requirements and placement new

+

Section: 23.2 [container.requirements] Status: Dup + Submitter: Herb Sutter Opened: 2004-08-01 Last modified: 2010-10-29

+

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. unary_function and binary_function should have protected nonvirtual destructors

+

Section: X [base] Status: NAD + Submitter: Joe Gottman Opened: 2004-08-19 Last modified: 2010-10-29

+

View all other issues in [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. unique's effects on the range [result, last)

+

Section: 25.3.9 [alg.unique] Status: NAD + Submitter: Andrew Koenig Opened: 2004-08-30 Last modified: 2010-10-29

+

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. Heterogeneous equality and EqualityComparable

+

Section: 25.2 [alg.nonmodifying], 25.3 [alg.modifying.operations] Status: Dup + Submitter: Peter Dimov Opened: 2004-09-20 Last modified: 2010-10-29

+

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.

+ + + + + + +
+

484. Convertible to T

+

Section: 24.2.3 [input.iterators] Status: NAD Future + Submitter: Chris Jefferson Opened: 2004-09-16 Last modified: 2010-10-29

+

View all other issues in [input.iterators].

+

View all issues with NAD Future status.

+

Discussion:

+

From comp.std.c++:

+ +

+I note that given an input iterator a for type T, +then *a only has to be "convertable to T", not actually of type T. +

+ +

Firstly, I can't seem to find an exact definition of "convertable to T". +While I assume it is the obvious definition (an implicit conversion), I +can't find an exact definition. Is there one?

+ +

Slightly more worryingly, there doesn't seem to be any restriction on +the this type, other than it is "convertable to T". Consider two input +iterators a and b. I would personally assume that most people would +expect *a==*b would perform T(*a)==T(*b), however it doesn't seem that +the standard requires that, and that whatever type *a is (call it U) +could have == defined on it with totally different symantics and still +be a valid inputer iterator.

+ +

Is this a correct reading? When using input iterators should I write +T(*a) all over the place to be sure that the object i'm using is the +class I expect?

+ +

This is especially a nuisance for operations that are defined to be + "convertible to bool". (This is probably allowed so that + implementations could return say an int and avoid an unnessary + conversion. However all implementations I have seen simply return a + bool anyway. Typical implemtations of STL algorithms just write + things like while(a!=b && *a!=0). But strictly + speaking, there are lots of types that are convertible to T but + that also overload the appropriate operators so this doesn't behave + as expected.

+ +

If we want to make code like this legal (which most people seem to + expect), then we'll need to tighten up what we mean by "convertible + to T".

+ +

[Lillehammer: The first part is NAD, since "convertible" is + well-defined in core. The second part is basically about pathological + overloads. It's a minor problem but a real one. So leave open for + now, hope we solve it as part of iterator redesign.]

+ + +

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

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD Future. We agree there's an issue, but there is no +proposed solution at this time and this will be solved by concepts in +the future. +
+ + + +

Proposed resolution:

+ + +

Rationale:

+

[ +San Francisco: +]

+ + +
+Solved by +N2758. +
+ + + + + + + +
+

485. output iterator insufficiently constrained

+

Section: 24.2.4 [output.iterators] Status: NAD Editorial + Submitter: Chris Jefferson Opened: 2004-10-13 Last modified: 2010-10-29

+

View all other issues in [output.iterators].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The note on 24.1.2 Output iterators insufficiently limits what can be +performed on output iterators. While it requires that each iterator is +progressed through only once and that each iterator is written to only +once, it does not require the following things:

+ +

Note: Here it is assumed that x is an output iterator of type X which +has not yet been assigned to.

+ +

a) That each value of the output iterator is written to: +The standard allows: +++x; ++x; ++x; +

+ +

+b) That assignments to the output iterator are made in order +X a(x); ++a; *a=1; *x=2; is allowed +

+ +

+c) Chains of output iterators cannot be constructed: +X a(x); ++a; X b(a); ++b; X c(b); ++c; is allowed, and under the current +wording (I believe) x,a,b,c could be written to in any order. +

+ +

I do not believe this was the intension of the standard?

+

[Lillehammer: Real issue. There are lots of constraints we + intended but didn't specify. Should be solved as part of iterator + redesign.]

+ + +

[ +2009-07 Frankfurt +]

+ + +
+Bill provided wording according to consensus. +
+ +

[ +2009-07-21 Alisdair requests change from Review to Open. See thread starting +with c++std-lib-24459 for discussion. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+Modified wording. Set to Review. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Move to Ready after looking at again in a larger group in Santa Cruz. +
+ +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Editorial. Rationale added below. +
+ + + +

Rationale:

+

+Solved by N3066. +

+ + +

Proposed resolution:

+

+Change Table 101 — Output iterator requirements in 24.2.4 [output.iterators]: +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Table 101 — Output iterator requirements
ExpressionReturn typeOperational semanticsAssertion/note pre-/post-condition
+X(a) + +  + +  + +a = t is equivalent to X(a) = t. note: a destructor is assumed. +
+X u(a);
+X u = a; +		 +  + +  + +  +
+*r = o + +result is not used + +  + + +Post: r is not required to be dereferenceable. r is incrementable. + +
+++r + +X& + +  + +&r == &++r + +Post: r is dereferenceable, unless otherwise specified. r is not required to be incrementable. + +
+r++ + +convertible to const X& + +{X tmp = r;
++r;
return tmp;} +		 + +Post: r is dereferenceable, unless otherwise specified. r is not required to be incrementable. + +
+*r++ = o; + +result is not used + +  + + +
+
+ + + + + +
+

486. min/max CopyConstructible requirement is too strict

+

Section: 25.4.7 [alg.min.max] Status: Dup + Submitter: Dave Abrahams Opened: 2004-10-13 Last modified: 2010-10-29

+

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. Allocator::construct is too limiting

+

Section: 20.2.5 [allocator.requirements] Status: NAD + Submitter: Dhruv Matani Opened: 2004-10-17 Last modified: 2010-10-29

+

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. std::remove / std::remove_if wrongly specified

+

Section: 25.3.8 [alg.remove] Status: NAD + Submitter: Thomas Mang Opened: 2004-12-12 Last modified: 2010-10-29

+

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. std::unique wrongly specified

+

Section: 25.3.9 [alg.unique] Status: NAD + Submitter: Thomas Mang Opened: 2004-12-12 Last modified: 2010-10-29

+

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. std::list<>::unique incorrectly specified

+

Section: 23.3.4.4 [list.ops] Status: NAD + Submitter: Thomas Mang Opened: 2004-12-12 Last modified: 2010-10-29

+

View all other issues in [list.ops].

+

View all issues with NAD status.

+

Discussion:

+

In Section 23.3.4.4 [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.4.4 [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.4.4 [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.4.4 [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.4.4 [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.4.4 [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.4.4 [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.4.4 [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.4.4 [list.ops], paragraph 19. If 23.3.4.4 [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.4.4 [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. Invalid iterator arithmetic expressions

+

Section: 17.5.1.4 [structure.specifications] Status: NAD + Submitter: Thomas Mang Opened: 2004-12-12 Last modified: 2010-10-29

+

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

[ +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. Undefined Expression in Input Iterator Note Title

+

Section: 24.2.3 [input.iterators] Status: NAD + Submitter: Chris Jefferson Opened: 2004-12-13 Last modified: 2010-10-29

+

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. Wrong runtime complexity for associative container's insert and delete

+

Section: 23.2.4 [associative.reqmts] Status: NAD + Submitter: Hans B os Opened: 2004-12-19 Last modified: 2010-10-29

+

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. Std. doesn't seem to require stable_sort() to be stable!

+

Section: 25.4.1.2 [stable.sort] Status: NAD Editorial + Submitter: Prateek Karandikar Opened: 2005-04-12 Last modified: 2010-10-29

+

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. do_length cannot be implemented correctly

+

Section: 22.4.1.5 [locale.codecvt.byname] Status: NAD + Submitter: Krzysztof Żelechowski Opened: 2005-05-24 Last modified: 2010-10-29

+

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

+

View all issues with NAD status.

+

Discussion:

+
    +
  1. codecvt::do_length is of type int;
    2. +
  2. it is assumed to be sort-of returning from_next - from of type ptrdiff_t;
    3. +
  3. ptrdiff_t cannot be cast to an int without data loss.
    4. +
+

+Contradiction. +

+ + +

Proposed resolution:

+

+

+ + + + + +
+

501. Proposal: strengthen guarantees of lib.comparisons

+

Section: X [base] Status: NAD + Submitter: Me <anti_spam_email2003@yahoo.com> Opened: 2005-06-07 Last modified: 2010-10-29

+

View all other issues in [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. Proposition: Clarification of the interaction between a facet and an iterator

+

Section: 22.3.1.1.1 [locale.category] Status: NAD + Submitter: Christopher Conrade Zseleghovski Opened: 2005-06-07 Last modified: 2010-10-29

+

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. more on locales

+

Section: 22.4 [locale.categories] Status: NAD + Submitter: P.J. Plauger Opened: 2005-06-20 Last modified: 2010-10-29

+

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. Integer types in pseudo-random number engine requirements

+

Section: 26.5.1 [rand.req], TR1 5.1.1 [tr.rand.req] Status: NAD Editorial + Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2010-10-29

+

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. Requirements of Distribution parameter for variate_generator

+

Section: 26.5 [rand], TR1 5.1.3 [tr.rand.var] Status: NAD + Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2010-10-29

+

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. Uniform_int template parameters

+

Section: 26.5.8.1 [rand.dist.uni], TR1 5.1.7.1 [tr.rand.dist.iunif] Status: NAD + Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2010-10-29

+

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. Input_type for bernoulli_distribution

+

Section: 26.5.8.2 [rand.dist.bern], TR1 5.1.7.2 [tr.rand.dist.bern] Status: NAD + Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2010-10-29

+

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. Input_type for binomial_distribution

+

Section: 26.5.8 [rand.dist], TR1 5.1.7.5 [tr.rand.dist.bin] Status: NAD + Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2010-10-29

+

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. Seeding subtract_with_carry_01 from a single unsigned long

+

Section: 26.5.3 [rand.eng], TR1 5.1.4.4 [tr.rand.eng.sub1] Status: NAD Editorial + Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2010-10-29

+

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 even +stricter) requirements we have for seed(Gen&). +

+ +

[ +Portland: Subsumed by N2111. +]

+ + + + + + +
+

513. Size of state for subtract_with_carry_01

+

Section: 26.5.3 [rand.eng], TR1 5.1.4.4 [tr.rand.eng.sub1] Status: NAD Editorial + Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2010-10-29

+

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. Size of state for subtract_with_carry

+

Section: 26.5.3.3 [rand.eng.sub], TR1 5.1.4.3 [tr.rand.eng.sub] Status: NAD Editorial + Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2010-10-29

+

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. Random number engine traits

+

Section: 26.5.2 [rand.synopsis], TR1 5.1.2 [tr.rand.synopsis] Status: NAD + Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2010-10-29

+

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. Seeding subtract_with_carry_01 using a generator

+

Section: 26.5.3 [rand.eng], TR1 5.1.4.4 [tr.rand.eng.sub1] Status: NAD Editorial + Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2010-10-29

+

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. Should include name in external representation

+

Section: 26.5.1 [rand.req], TR1 5.1.1 [tr.rand.req] Status: NAD + Submitter: Walter Brown Opened: 2005-07-03 Last modified: 2010-10-29

+

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. +]

+ + + + + + + +
+

523. regex case-insensitive character ranges are unimplementable as specified

+

Section: 28 [re] Status: NAD Future + Submitter: Eric Niebler Opened: 2005-07-01 Last modified: 2010-10-29

+

View all other issues in [re].

+

View all issues with NAD Future status.

+

Discussion:

+

+A problem with TR1 regex is currently being discussed on the Boost +developers list. It involves the handling of case-insensitive matching +of character ranges such as [Z-a]. The proper behavior (according to the +ECMAScript standard) is unimplementable given the current specification +of the TR1 regex_traits<> class template. John Maddock, the author of +the TR1 regex proposal, agrees there is a problem. The full discussion +can be found at http://lists.boost.org/boost/2005/06/28850.php (first +message copied below). We don't have any recommendations as yet. +

+

+-- Begin original message -- +

+

+The situation of interest is described in the ECMAScript specification +(ECMA-262), section 15.10.2.15: +

+

+"Even if the pattern ignores case, the case of the two ends of a range +is significant in determining which characters belong to the range. +Thus, for example, the pattern /[E-F]/i matches only the letters E, F, +e, and f, while the pattern /[E-f]/i matches all upper and lower-case +ASCII letters as well as the symbols [, \, ], ^, _, and `." +

+

+A more interesting case is what should happen when doing a +case-insentitive match on a range such as [Z-a]. It should match z, Z, +a, A and the symbols [, \, ], ^, _, and `. This is not what happens with +Boost.Regex (it throws an exception from the regex constructor). +

+

+The tough pill to swallow is that, given the specification in TR1, I +don't think there is any effective way to handle this situation. +According to the spec, case-insensitivity is handled with +regex_traits<>::translate_nocase(CharT) -- two characters are equivalent +if they compare equal after both are sent through the translate_nocase +function. But I don't see any way of using this translation function to +make character ranges case-insensitive. Consider the difficulty of +detecting whether "z" is in the range [Z-a]. Applying the transformation +to "z" has no effect (it is essentially std::tolower). And we're not +allowed to apply the transformation to the ends of the range, because as +ECMA-262 says, "the case of the two ends of a range is significant." +

+

+So AFAICT, TR1 regex is just broken, as is Boost.Regex. One possible fix +is to redefine translate_nocase to return a string_type containing all +the characters that should compare equal to the specified character. But +this function is hard to implement for Unicode, and it doesn't play nice +with the existing ctype facet. What a mess! +

+

+-- End original message -- +

+ +

[ +John Maddock adds: +]

+ + +

+One small correction, I have since found that ICU's regex package does +implement this correctly, using a similar mechanism to the current +TR1.Regex. +

+

+Given an expression [c1-c2] that is compiled as case insensitive it: +

+

+Enumerates every character in the range c1 to c2 and converts it to it's +case folded equivalent. That case folded character is then used a key to a +table of equivalence classes, and each member of the class is added to the +list of possible matches supported by the character-class. This second step +isn't possible with our current traits class design, but isn't necessary if +the input text is also converted to a case-folded equivalent on the fly. +

+

+ICU applies similar brute force mechanisms to character classes such as +[[:lower:]] and [[:word:]], however these are at least cached, so the impact +is less noticeable in this case. +

+

+Quick and dirty performance comparisons show that expressions such as +"[X-\\x{fff0}]+" are indeed very slow to compile with ICU (about 200 times +slower than a "normal" expression). For an application that uses a lot of +regexes this could have a noticeable performance impact. ICU also has an +advantage in that it knows the range of valid characters codes: code points +outside that range are assumed not to require enumeration, as they can not +be part of any equivalence class. I presume that if we want the TR1.Regex +to work with arbitrarily large character sets enumeration really does become +impractical. +

+

+Finally note that Unicode has: +

+

+Three cases (upper, lower and title). +One to many, and many to one case transformations. +Character that have context sensitive case translations - for example an +uppercase sigma has two different lowercase forms - the form chosen depends +on context(is it end of a word or not), a caseless match for an upper case +sigma should match either of the lower case forms, which is why case folding +is often approximated by tolower(toupper(c)). +

+

+Probably we need some way to enumerate character equivalence classes, +including digraphs (either as a result or an input), and some way to tell +whether the next character pair is a valid digraph in the current locale. +

+

+Hoping this doesn't make this even more complex that it was already, +

+ +

[ +Portland: Alisdair: Detect as invalid, throw an exception. +Pete: Possible general problem with case insensitive ranges. +]

+ + +

[ +2009-07 Frankfurt +]

+ + +
+

+We agree that this is a problem, but we do not know the answer. +

+

+We are going to declare this NAD until existing practice leads us in some direction. +

+

+No objection to NAD Future. +

+

+Move to NAD Future. +

+
+ + + +

Proposed resolution:

+ + + + + +
+

526. Is it undefined if a function in the standard changes in parameters?

+

Section: 23.2.3 [sequence.reqmts] Status: NAD + Submitter: Chris Jefferson Opened: 2005-09-14 Last modified: 2010-10-29

+

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 shown in the std::copy case, this may be difficult. +A simpler, more global option would be to somewhere insert text similar to: +

+ +

+If the execution of any function would change either any values passed +by reference or any value in any range passed to a function in a way not +defined in the definition of that function, the result is undefined. +

+ +

+Such code would have to at least cover chapters 23 and 25 (the sections +I read through carefully). I can see no harm on applying it to much of +the rest of the standard. +

+ +

+Some existing parts of the standard could be improved to fit with this, +for example the requires for 25.2.1 (Copy) could be adjusted to: +

+ +

+Requires: For each non-negative integer n < (last - first), assigning to +*(result + n) must not alter any value in the range [first + n, last). +

+ +

+However, this may add excessive complication. +

+ +

+One other benefit of clearly introducing this text is that it would +allow a number of small optimisations, such as caching values passed +by const reference. +

+ +

+Matt Austern adds that this issue also exists for the insert and +erase members of the ordered and unordered associative containers. +

+ +

[ +Berlin: Lots of controversey over how this should be solved. Lots of confusion +as to whether we're talking about self referencing iterators or references. +Needs a good survey as to the cases where this matters, for which +implementations, and how expensive it is to fix each case. +]

+ + + + +

Proposed resolution:

+ + +

Rationale:

+

+Recommend NAD. +

+ + + + + + +
+

528. const_iterator iterator issue when they are the same type

+

Section: 23.7 [unord], TR1 6.3.4 [tr.unord.unord] Status: NAD + Submitter: Paolo Carlini Opened: 2005-10-12 Last modified: 2010-10-29

+

View all other issues in [unord].

+

View all issues with NAD status.

+

Discussion:

+

+while implementing the resolution of issue 6.19 I'm noticing the +following: according to 6.3.4.3/2 (and 6.3.4.5/2), for unordered_set and +unordered_multiset: +

+ +

+ "The iterator and const_iterator types are both const types. It is +unspecified whether they are the same type" +

+ +

+Now, according to the resolution of 6.19, we have overloads of insert +with hint and erase (single and range) both for iterator and +const_iterator, which, AFAICS, can be meaningful at the same time *only* +if iterator and const_iterator *are* in fact different types. +

+

+Then, iterator and const_iterator are *required* to be different types? +Or that is an unintended consequence? Maybe the overloads for plain +iterators should be added only to unordered_map and unordered_multimap? +Or, of course, I'm missing something? +

+ + + +

Proposed resolution:

+

+Add to 6.3.4.3p2 (and 6.3.4.5p2): +

+

+2 ... The iterator and const_iterator types are both const +constant iterator types. +It is unspecified whether they are the same type. +

+ +

+Add a new subsection to 17.4.4 [lib.conforming]: +

+ +
+

+An implementation shall not supply an overloaded function + signature specified in any library clause if such a signature + would be inherently ambiguous during overload resolution + due to two library types referring to the same type. +

+

+ [Note: For example, this occurs when a container's iterator + and const_iterator types are the same. -- end note] +

+
+ +

[ +Post-Berlin: Beman supplied wording. +]

+ + + + +

Rationale:

+Toronto: The first issue has been fixed by N2350 (the insert and erase members +are collapsed into one signature). Alisdair to open a separate issue on the +chapter 17 wording. + + + + + +
+

529. The standard encourages redundant and confusing preconditions

+

Section: 17.6.3.11 [res.on.required] Status: NAD Editorial + Submitter: David Abrahams Opened: 2005-10-25 Last modified: 2010-10-29

+

View all issues with NAD Editorial status.

+

Discussion:

+

+17.4.3.8/1 says: +

+ +

+Violation of the preconditions specified in a function's +Required behavior: paragraph results in undefined behavior unless the +function's Throws: paragraph specifies throwing an exception when the +precondition is violated. +

+ +

+This implies that a precondition violation can lead to defined +behavior. That conflicts with the only reasonable definition of +precondition: that a violation leads to undefined behavior. Any other +definition muddies the waters when it comes to analyzing program +correctness, because precondition violations may be routinely done in +correct code (e.g. you can use std::vector::at with the full +expectation that you'll get an exception when your index is out of +range, catch the exception, and continue). Not only is it a bad +example to set, but it encourages needless complication and redundancy +in the standard. For example: +

+ +
  21 Strings library 
+  21.3.3 basic_string capacity
+
+  void resize(size_type n, charT c);
+
+  5 Requires: n <= max_size()
+  6 Throws: length_error if n > max_size().
+  7 Effects: Alters the length of the string designated by *this as follows:
+
+ +

+The Requires clause is entirely redundant and can be dropped. We +could make that simplifying change (and many others like it) even +without changing 17.4.3.8/1; the wording there just seems to encourage +the redundant and error-prone Requires: clause. +

+ +

[ +Batavia: Alan and Pete to work. +]

+ + +

[ +Bellevue: NAD Editorial, this group likes +N2121, +Pete agrees, accepting it is Pete's business. +General agreement that precondition violations are synonymous with UB. +]

+ + + +

Proposed resolution:

+

+1. Change 17.4.3.8/1 to read: +

+ +

+Violation of the preconditions specified in a function's +Required behavior: paragraph results in undefined behavior +unless the function's Throws: paragraph specifies throwing +an exception when the precondition is violated. +

+ +

+2. Go through and remove redundant Requires: clauses. Specifics to be + provided by Dave A. +

+ +

[ +Berlin: The LWG requests a detailed survey of part 2 of the proposed resolution. +]

+ + +

[ +Alan provided the survey +N2121. +]

+ + + + + + + +
+

532. Tuple comparison

+

Section: 20.4.2.7 [tuple.rel], TR1 6.1.3.5 [tr.tuple.rel] Status: NAD Future + Submitter: David Abrahams Opened: 2005-11-29 Last modified: 2010-10-29

+

View all other issues in [tuple.rel].

+

View all issues with NAD Future status.

+

Duplicate of: 348

+

Discussion:

+

+Where possible, tuple comparison operators <,<=,=>, and > ought to be +defined in terms of std::less rather than operator<, in order to +support comparison of tuples of pointers. +

+ +

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

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+

+If we solve this for tuple we would have to solve it for pair +algorithms, etc. It is too late to do that at this time. Move to NAD Future. +

+
+ + + +

Proposed resolution:

+

+change 6.1.3.5/5 from: +

+ +

+ Returns: The result of a lexicographical comparison between t and + u. The result is defined as: (bool)(get<0>(t) < get<0>(u)) || + (!(bool)(get<0>(u) < get<0>(t)) && ttail < utail), where rtail for + some tuple r is a tuple containing all but the first element of + r. For any two zero-length tuples e and f, e < f returns false. +

+ +

+to: +

+ +
+

+ Returns: The result of a lexicographical comparison between t and + u. For any two zero-length tuples e and f, e < f returns false. + Otherwise, the result is defined as: cmp( get<0>(t), get<0>(u)) || + (!cmp(get<0>(u), get<0>(t)) && ttail < utail), where rtail for some + tuple r is a tuple containing all but the first element of r, and + cmp(x,y) is an unspecified function template defined as follows. +

+

+ Where T is the type of x and U is the type of y: +

+ +

+ if T and U are pointer types and T is convertible to U, returns + less<U>()(x,y) +

+ +

+ otherwise, if T and U are pointer types, returns less<T>()(x,y) +

+ +

+ otherwise, returns (bool)(x < y) +

+
+ +

[ +Berlin: This issue is much bigger than just tuple (pair, containers, +algorithms). Dietmar will survey and work up proposed wording. +]

+ + + + +

Rationale:

+

+Recommend NAD. This will be fixed with the next revision of concepts. +

+ +

[ +San Francisco: +]

+ + +
+Solved by +N2770. +
+ + + + + +
+

536. Container iterator constructor and explicit convertibility

+

Section: 23.2 [container.requirements] Status: Dup + Submitter: Joaquín M López Muńoz Opened: 2005-12-17 Last modified: 2010-10-29

+

View all other issues in [container.requirements].

+

View all issues with Dup status.

+

Duplicate of: 589

+

Discussion:

+

+The iterator constructor X(i,j) for containers as defined in 23.1.1 and +23.2.2 does only require that i and j be input iterators but +nothing is said about their associated value_type. There are three +sensible +options: +

+
    +
  1. iterator's value_type is exactly X::value_type (modulo cv).
    2. +
  2. iterator's value_type is *implicitly* convertible to X::value_type.
    3. +
  3. iterator's value_type is *explicitly* convertible to X::value_type.
    4. +
+

+The issue has practical implications, and stdlib vendors have +taken divergent approaches to it: Dinkumware follows 2, +libstdc++ follows 3. +

+

+The same problem applies to the definition of insert(p,i,j) for +sequences and insert(i,j) for associative contianers, as well as +assign. +

+ +

[ +The following added by Howard and the example code was originally written by +Dietmar. +]

+ +

+Valid code below? +

+ +
#include <vector> 
+#include <iterator> 
+#include <iostream> 
+
+struct foo 
+{ 
+    explicit foo(int) {} 
+}; 
+
+int main() 
+{ 
+    std::vector<int> v_int; 
+    std::vector<foo> v_foo1(v_int.begin(), v_int.end()); 
+    std::vector<foo> v_foo2((std::istream_iterator<int>(std::cin)), 
+                             std::istream_iterator<int>()); 
+} 
+
+

[ +Berlin: Some support, not universal, for respecting the explicit qualifier. +]

+ + + + +

Proposed resolution:

+ + + + + + +
+

544. minor NULL problems in C.2

+

Section: C.2 [diff.library] Status: NAD Editorial + Submitter: Martin Sebor Opened: 2005-11-25 Last modified: 2010-10-29

+

View all other issues in [diff.library].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+According to C.2.2.3, p1, "the macro NULL, defined in any of <clocale>, +<cstddef>, <cstdio>, <cstdlib>, <cstring>, <ctime>, +or <cwchar>." This is consistent with the C standard. +

+

+However, Table 95 in C.2 fails to mention <clocale> and <cstdlib>. +

+

+In addition, C.2, p2 claims that "The C++ Standard library provides +54 standard macros from the C library, as shown in Table 95." While +table 95 does have 54 entries, since a couple of them (including the +NULL macro) are listed more than once, the actual number of macros +defined by the C++ Standard Library may not be 54. +

+ + +

Proposed resolution:

+

+I propose we add <clocale> and <cstdlib> to Table 96 and remove the +number of macros from C.2, p2 and reword the sentence as follows: +

+

+The C++ Standard library provides 54 standard macros from +defines a number macros corresponding to those defined by the C +Standard library, as shown in Table 96. +

+ +

[ +Portland: Resolution is considered editorial. It will be incorporated into the WD. +]

+ + + + + + + +
+

546. _Longlong and _ULonglong are integer types

+

Section: TR1 5.1.1 [tr.rand.req] Status: NAD + Submitter: Matt Austern Opened: 2006-01-10 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+The TR sneaks in two new integer types, _Longlong and _Ulonglong, in [tr.c99]. +The rest of the TR should use that type. I believe this affects two places. +First, the random number requirements, 5.1.1/10-11, lists all of the types with +which template parameters named IntType and UIntType may be instantiated. +_Longlong (or "long long", assuming it is added to C++0x) should be added to the +IntType list, and UIntType (again, or "unsigned long long") should be added to +the UIntType list. Second, 6.3.2 lists the types for which hash<> is +required to be instantiable. _Longlong and _Ulonglong should be added to that +list, so that people may use long long as a hash key. +

+ +

[ +2009-07 Frankfurt +]

+ + +
+

+We are not going to fix TR1. +

+

+The paper "long long goes to the library" addresses the integration of +long long into the C++0x library. +

+

+Move to NAD. +

+
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

547. division should be floating-point, not integer

+

Section: 26.5 [rand], TR1 5.1 [tr.rand] Status: NAD + Submitter: Matt Austern Opened: 2006-01-10 Last modified: 2010-10-29

+

View all other issues in [rand].

+

View all issues with NAD status.

+

Discussion:

+

+Paragraph 10 describes how a variate generator uses numbers produced by an +engine to pass to a generator. The sentence that concerns me is: "Otherwise, if +the value for engine_value_type::result_type is true and the value for +Distribution::input_type is false [i.e. if the engine produces integers and the +engine wants floating-point values], then the numbers in s_eng are divided by +engine().max() - engine().min() + 1 to obtain the numbers in s_e." Since the +engine is producing integers, both the numerator and the denominator are +integers and we'll be doing integer division, which I don't think is what we +want. Shouldn't we be performing a conversion to a floating-point type first? +

+ + +

Proposed resolution:

+ + +

Rationale:

+

+Recommend NAD as the affected section is now gone and so the issue is moot. +N2111. +

+ + + + + +
+

548. May random_device block?

+

Section: 26.5.6 [rand.device], TR1 5.1.6 [tr.rand.device] Status: NAD + Submitter: Matt Austern Opened: 2006-01-10 Last modified: 2010-10-29

+

View all other issues in [rand.device].

+

View all issues with NAD status.

+

Discussion:

+

+Class random_device "produces non-deterministic random numbers", using some +external source of entropy. In most real-world systems, the amount of available +entropy is limited. Suppose that entropy has been exhausted. What is an +implementation permitted to do? In particular, is it permitted to block +indefinitely until more random bits are available, or is the implementation +required to detect failure immediately? This is not an academic question. On +Linux a straightforward implementation would read from /dev/random, and "When +the entropy pool is empty, reads to /dev/random will block until additional +environmental noise is gathered." Programmers need to know whether random_device +is permitted to (or possibly even required to?) behave the same way. +

+ +

[ +Berlin: Walter: N1932 considers this NAD. Does the standard specify whether std::cin +may block? +]

+ + +

+See N2391 and +N2423 +for some further discussion. +

+ + +

Proposed resolution:

+

+Adopt the proposed resolution in +N2423 (NAD). +

+ + + + + +
+

549. Undefined variable in binomial_distribution

+

Section: 26.5.8 [rand.dist], TR1 5.1.7.5 [tr.rand.dist.bin] Status: NAD Editorial + Submitter: Matt Austern Opened: 2006-01-10 Last modified: 2010-10-29

+

View all other issues in [rand.dist].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Paragraph 1 says that "A binomial distributon random distribution produces +integer values i>0 with p(i) = (n choose i) * p*i * (1-p)^(t-i), where t and +p are the parameters of the distribution. OK, that tells us what t, p, and i +are. What's n? +

+ + +

Proposed resolution:

+

+Berlin: Typo: "n" replaced by "t" in N1932: see 26.3.7.2.2/1. +

+ +

[ +Portland: Subsumed by N2111. +]

+ + + + + + +
+

553. very minor editorial change intptr_t / uintptr_t

+

Section: 18.4.1 [cstdint.syn], TR1 8.22.1 [tr.c99.cstdint.syn] Status: NAD Editorial + Submitter: Paolo Carlini Opened: 2006-01-30 Last modified: 2010-10-29

+

View all other issues in [cstdint.syn].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In the synopsis, some types are identified as optional: int8_t, int16_t, +and so on, consistently with C99, indeed. +

+

+On the other hand, intptr_t and uintptr_t, are not marked as such and +probably should, consistently with C99, 7.18.1.4. +

+ + +

Proposed resolution:

+

+Change 18.4.1 [cstdint.syn]: +

+ +
...
+typedef signed integer type intptr_t;    // optional
+...
+typedef unsigned integer type uintptr_t;    // optional
+...
+
+ + + +

Rationale:

+Recommend NAD and fix as editorial with the proposed resolution. + + + + + +
+

554. Problem with lwg DR 184 numeric_limits<bool>

+

Section: 18.3.1.5 [numeric.special] Status: NAD + Submitter: Howard Hinnant Opened: 2006-01-29 Last modified: 2010-10-29

+

View all other issues in [numeric.special].

+

View all issues with NAD status.

+

Discussion:

+

+I believe we have a bug in the resolution of: +lwg 184 +(WP status). +

+ +

+The resolution spells out each member of numeric_limits<bool>. +The part I'm having a little trouble with is: +

+
static const bool traps = false;
+
+ +

+Should this not be implementation defined? Given: +

+ +
int main()
+{
+     bool b1 = true;
+     bool b2 = false;
+     bool b3 = b1/b2;
+}
+
+ +

+If this causes a trap, shouldn't numeric_limits<bool>::traps be +true? +

+ + +

Proposed resolution:

+

+Change 18.2.1.5p3: +

+ +

+-3- The specialization for bool shall be provided as follows:

+
namespace std { 
+   template <> class numeric_limits<bool> {
+      ...
+      static const bool traps = false implementation-defined;
+      ...
+   };
+}
+
+
+ +

[ +Redmond: NAD because traps refers to values, not operations. There is no bool +value that will trap. +]

+ + + + + + + +
+

555. TR1, 8.21/1: typo

+

Section: TR1 8.21 [tr.c99.boolh] Status: NAD Editorial + Submitter: Paolo Carlini Opened: 2006-02-02 Last modified: 2010-10-29

+

View all issues with NAD Editorial status.

+

Discussion:

+

+This one, if nobody noticed it yet, seems really editorial: +s/cstbool/cstdbool/ +

+ + +

Proposed resolution:

+

+Change 8.21p1: +

+

+-1- The header behaves as if it defines the additional macro defined in +<cstdbool> by including the header <cstdbool>. +

+ +

[ +Redmond: Editorial. +]

+ + + + + + + +
+

557. TR1: div(_Longlong, _Longlong) vs div(intmax_t, intmax_t)

+

Section: 18.4 [cstdint], TR1 8.22 [tr.c99.cstdint] Status: NAD Editorial + Submitter: Paolo Carlini Opened: 2006-02-06 Last modified: 2010-10-29

+

View all other issues in [cstdint].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+I'm seeing a problem with such overloads: when, _Longlong == intmax_t == +long long we end up, essentially, with the same arguments and different +return types (lldiv_t and imaxdiv_t, respectively). Similar issue with +abs(_Longlong) and abs(intmax_t), of course. +

+

+Comparing sections 8.25 and 8.11, I see an important difference, +however: 8.25.3 and 8.25.4 carefully describe div and abs for _Longlong +types (rightfully, because not moved over directly from C99), whereas +there is no equivalent in 8.11: the abs and div overloads for intmax_t +types appear only in the synopsis and are not described anywhere, in +particular no mention in 8.11.2 (at variance with 8.25.2). +

+

+I'm wondering whether we really, really, want div and abs for intmax_t... +

+ + + +

Proposed resolution:

+ + + +

[ +Portland: no consensus. +]

+ + +

Rationale:

+

[ +Batavia, Bill: The <cstdint> synopsis in TR1 8.11.1 [tr.c99.cinttypes.syn] contains: +]

+ +
intmax_t imaxabs(intmax_t i);
+intmax_t abs(intmax_t i);
+
+imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
+imaxdiv_t div(intmax_t numer, intmax_t denom);
+
+ +

[ +and in TR1 8.11.2 [tr.c99.cinttypes.def]: +]

+ + +

+The header defines all functions, types, and macros the same as C99 +subclause 7.8. +

+ +

[ +This is as much definition as we give for most other C99 functions, +so nothing need change. We might, however, choose to add the footnote: +]

+ + +

+[Note: These overloads for abs and div may well be equivalent to +those that take long long arguments. If so, the implementation is +responsible for avoiding conflicting declarations. -- end note] +

+ +

[ +Bellevue: NAD Editorial. Pete must add a footnote, as described below. +]

+ + +
+

[ +Looks like a real problem. Dietmar suggests div() return a template +type. Matt: looks like imaxdiv_t is loosly defined. Can it be a typedef +for lldiv_t when _Longlong == intmax_t? PJP seems to agree. We would +need a non-normative note declaring that the types lldiv_t and imaxdiv_t +may not be unique if intmax_t==_longlong. +]

+ +
+ + + + + + +
+

558. lib.input.iterators Defect

+

Section: 24.2.3 [input.iterators] Status: NAD Editorial + Submitter: David Abrahams Opened: 2006-02-09 Last modified: 2010-10-29

+

View all other issues in [input.iterators].

+

View all issues with NAD Editorial status.

+

Discussion:

+
+

+ 24.1.1 Input iterators [lib.input.iterators] +

+

+ 1 A class or a built-in type X satisfies the requirements of an + input iterator for the value type T if the following expressions are + valid, where U is the type of any specified member of type T, as + shown in Table 73. +

+
+

+There is no capital U used in table 73. There is a lowercase u, but +that is clearly not meant to denote a member of type T. Also, there's +no description in 24.1.1 of what lowercase a means. IMO the above +should have been...Hah, a and b are already covered in 24.1/11, so maybe it +should have just been: +

+ + +

Proposed resolution:

+

+Change 24.1.1p1: +

+

+-1- A class or a built-in type X satisfies the requirements of an +input iterator for the value type T if the following expressions +are valid, where U is the type of any specified member of type +T, as shown in Table 73. +

+ +

[ +Portland: Editorial. +]

+ + + + + + + +
+

560. User-defined allocators without default constructor

+

Section: 20.2.5 [allocator.requirements] Status: NAD + Submitter: Sergey P. Derevyago Opened: 2006-02-17 Last modified: 2010-10-29

+

View all other issues in [allocator.requirements].

+

View all issues with NAD status.

+

Discussion:

+

1. The essence of the problem.

+

+User-defined allocators without default constructor are not explicitly +supported by the standard but they can be supported just like std::vector +supports elements without default constructor. +

+

+As a result, there exist implementations that work well with such allocators +and implementations that don't. +

+ +

2. The cause of the problem.

+

+1) The standard doesn't explicitly state this intent but it should. In +particular, 20.1.5p5 explicitly state the intent w.r.t. the allocator +instances that compare non-equal. So it can similarly state the intent w.r.t. +the user-defined allocators without default constructor. +

+

+2) Some container operations are obviously underspecified. In particular, +21.3.7.1p2 tells: +

+
template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator> operator+(
+    const charT* lhs,
+    const basic_string<charT,traits,Allocator>& rhs
+  );
+
+

+Returns: basic_string<charT,traits,Allocator>(lhs) + rhs. +

+
+

+That leads to the basic_string<charT,traits,Allocator>(lhs, Allocator()) call. +Obviously, the right requirement is: +

+

+Returns: basic_string<charT,traits,Allocator>(lhs, rhs.get_allocator()) + rhs. +

+

+It seems like a lot of DRs can be submitted on this "Absent call to +get_allocator()" topic. +

+ +

3. Proposed actions.

+

+1) Explicitly state the intent to allow for user-defined allocators without +default constructor in 20.1.5 Allocator requirements. +

+

+2) Correct all the places, where a correct allocator object is available +through the get_allocator() call but default Allocator() gets passed instead. +

+

4. Code sample.

+

+Let's suppose that the following memory pool is available: +

+
class mem_pool {
+      // ...
+      void* allocate(size_t size);
+      void deallocate(void* ptr, size_t size);
+};
+
+

+So the following allocator can be implemented via this pool: +

+
class stl_allocator {
+      mem_pool& pool;
+
+ public:
+      explicit stl_allocator(mem_pool& mp) : pool(mp) {}
+      stl_allocator(const stl_allocator& sa) : pool(sa.pool) {}
+      template <class U>
+      stl_allocator(const stl_allocator<U>& sa)  : pool(sa.get_pool()) {}
+      ~stl_allocator() {}
+
+      pointer allocate(size_type n, std::allocator<void>::const_pointer = 0)
+      {
+       return (n!=0) ? static_cast<pointer>(pool.allocate(n*sizeof(T))) : 0;
+      }
+
+      void deallocate(pointer p, size_type n)
+      {
+       if (n!=0) pool.deallocate(p, n*sizeof(T));
+      }
+
+      // ...
+};
+
+

+Then the following code works well on some implementations and doesn't work on +another: +

+
typedef basic_string<char, char_traits<char>, stl_allocator<char> > 
+  tl_string;
+mem_pool mp;
+tl_string s1("abc", stl_allocator<int>(mp));
+printf("(%s)\n", ("def"+s1).c_str());
+
+

+In particular, on some implementations the code can't be compiled without +default stl_allocator() constructor. +

+

+The obvious way to solve the compile-time problems is to intentionally define +a NULL pointer dereferencing default constructor +

+
stl_allocator() : pool(*static_cast<mem_pool*>(0)) {}
+
+

+in a hope that it will not be called. The problem is that it really gets +called by operator+(const char*, const string&) under the current 21.3.7.1p2 +wording. +

+ + +

Proposed resolution:

+

+

+ + +

Rationale:

+

+Recommend NAD. operator+() with string already requires the desired +semantics of copying the allocator from one of the strings (lhs when there is a choice). +

+ + + + + +
+

568. log2 overloads missing

+

Section: TR1 8.16.4 [tr.c99.cmath.over] Status: NAD + Submitter: Paolo Carlini Opened: 2006-03-07 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+log2 is missing from the list of "additional overloads" in TR1 8.16.4 [tr.c99.cmath.over] p1. +

+ +

+Hinnant: This is a TR1 issue only. It is fixed in the current (N2135) WD. +

+ +

[ +Batavia (2009-05): +]

+ +
+We agree this has been fixed in the Working Draft. +Move to NAD. +
+ + +

Proposed resolution:

+

+Add log2 to the list of functions in TR1 8.16.4 [tr.c99.cmath.over] p1. +

+ + + + + +
+

569. Postcondition for basic_ios::clear(iostate) incorrectly stated

+

Section: 27.5.4.3 [iostate.flags] Status: Dup + Submitter: Seungbeom Kim Opened: 2006-03-10 Last modified: 2010-10-29

+

View all other issues in [iostate.flags].

+

View all issues with Dup status.

+

Duplicate of: 272

+

Discussion:

+

+Section: 27.4.4.3 [lib.iostate.flags] +

+

+Paragraph 4 says: +

+
+
void clear(iostate state = goodbit);
+
+

+Postcondition: If rdbuf()!=0 then state == rdstate(); +otherwise rdstate()==state|ios_base::badbit. +

+
+ +

+The postcondition "rdstate()==state|ios_base::badbit" is parsed as +"(rdstate()==state)|ios_base::badbit", which is probably what the +committee meant. +

+ + + + +

Rationale:

+ + + + + + +
+

570. Request adding additional explicit specializations of char_traits

+

Section: 21.2 [char.traits] Status: NAD + Submitter: Jack Reeves Opened: 2006-04-06 Last modified: 2010-10-29

+

View all other issues in [char.traits].

+

View all issues with NAD status.

+

Discussion:

+

+Currently, the Standard Library specifies only a declaration for template class +char_traits<> and requires the implementation provide two explicit +specializations: char_traits<char> and char_traits<wchar_t>. I feel the Standard +should require explicit specializations for all built-in character types, i.e. +char, wchar_t, unsigned char, and signed char. +

+

+I have put together a paper +(N1985) +that describes this in more detail and +includes all the necessary wording. +

+

[ +Portland: Jack will rewrite +N1985 +to propose a primary template that will work with other integral types. +]

+ +

[ +Toronto: issue has grown with addition of char16_t and char32_t. +]

+ + +

[ +post Bellevue: +]

+ + +
+

+We suggest that Jack be asked about the status of his paper, and if it +is not forthcoming, the work-item be assigned to someone else. If no one +steps forward to do the paper before the next meeting, we propose to +make this NAD without further discussion. We leave this Open for now, +but our recommendation is NAD. +

+

+Note: the issue statement should be updated, as the Toronto comment has +already been resolved. E.g., char_traits specializations for char16_t +and char32_t are now in the working paper. +

+
+ +

[ +Sophia Antipolis: +]

+ + +
+Nobody has submitted the requested paper, so we move to NAD, as suggested by the decision at the last meeting. +
+ + +

Proposed resolution:

+ + + + + +
+

571. Update C90 references to C99?

+

Section: 1.2 [intro.refs] Status: NAD Editorial + Submitter: Beman Dawes Opened: 2006-04-08 Last modified: 2010-10-29

+

View all other issues in [intro.refs].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+1.2 Normative references [intro.refs] of the WP currently refers to ISO/IEC +9899:1990, Programming languages - C. Should that be changed to ISO/IEC +9899:1999? +

+

+What impact does this have on the library? +

+ + +

Proposed resolution:

+

+In 1.2/1 [intro.refs] of the WP, change: +

+
+ +
+ + + +

Rationale:

+Recommend NAD, fixed editorially. + + + + + +
+

572. Oops, we gave 507 WP status

+

Section: 26.5 [rand], TR1 5.1 [tr.rand] Status: NAD + Submitter: Howard Hinnant Opened: 2006-04-11 Last modified: 2010-10-29

+

View all other issues in [rand].

+

View all issues with NAD status.

+

Discussion:

+

+In Berlin, as a working group, we voted in favor of N1932 which makes issue 507 moot: +variate_generator has been eliminated. Then in full committee we voted to give +this issue WP status (mistakenly). +

+ + +

Proposed resolution:

+

+Strike the proposed resolution of issue 507. +

+

[ +post-Portland: Walter and Howard recommend NAD. The proposed resolution of 507 no longer +exists in the current WD. +]

+ + + +

Rationale:

+

+NAD. Will be moot once +N2135 +is adopted. +

+ + + + + +
+

573. C++0x file positioning should handle modern file sizes

+

Section: 27.5.3 [fpos] Status: NAD + Submitter: Beman Dawes Opened: 2006-04-12 Last modified: 2010-10-29

+

View all other issues in [fpos].

+

View all issues with NAD status.

+

Discussion:

+

+There are two deficiencies related to file sizes: +

+
    +
  1. It doesn't appear that the Standard Library is specified in + a way that handles modern file sizes, which are often too + large to be represented by an unsigned long.
    2. + +
  2. The std::fpos class does not currently have the ability to + set/get file positions.
    3. +
+

+The Dinkumware implementation of the Standard Library as shipped with the Microsoft compiler copes with these issues by: +

+
    +
  1. Defining fpos_t be long long, which is large enough to + represent any file position likely in the foreseeable future.
    2. + +
  2. Adding member functions to class fpos. For example, +
    fpos_t seekpos() const;
+
    +
    3. +
+

+Because there are so many types relating to file positions and offsets (fpos_t, +fpos, pos_type, off_type, streamoff, streamsize, streampos, wstreampos, and +perhaps more), it is difficult to know if the Dinkumware extensions are +sufficient. But they seem a useful starting place for discussions, and they do +represent existing practice. +

+ +

[ +Kona (2007): We need a paper. It would be nice if someone proposed +clarifications to the definitions of pos_type and off_type. Currently +these definitions are horrible. Proposed Disposition: Open +]

+ + +

[ +2009-07 Frankfurt +]

+ + +
+

+This is the subject of paper N2926. +

+

+If we choose to take any action, we will move the paper, so the issue can be closed. +

+

+Move to NAD. +

+
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

579. erase(iterator) for unordered containers should not return an iterator

+

Section: 23.2.5 [unord.req] Status: NAD + Submitter: Joaquín M López Muńoz Opened: 2006-06-13 Last modified: 2010-11-29

+

View other active issues in [unord.req].

+

View all other issues in [unord.req].

+

View all issues with NAD status.

+

Discussion:

+

+See +N2023 +for full discussion. +

+ +

[ +2009-12-11 Paolo opens: +]

+ + +
+I'm asking for DR 579 to be re-opened, basing on recent discussions on the +library reflector, see Message c++std-lib-26040 and replies. +
+ +

[ +2010-02-07 Paolo updates wording. +]

+ + +
+As pointed out by Chris in c++std-lib-26040, that an +erase(unordered_container, iterator) returning an iterator can +easily implemented in user code, if needed; that actually returning an +iterator costs nothing for the overload taking two iterators, +thus that proposed change is only for consistency; that +forward_list::erase_after also returns void (for different +reasons, granted, but isn't that any "erase" function in the containers +uniformly returns an iterator); that, also in thread started by Chris' +message, Alberto pointed out that the proxy idea isn't a good one; that users +both of the GNU and Boost implementations are reporting serious performance +problems with the current version returning an iterator. +
+ +

[ +2010-02-07 Original wording saved here: +]

+ + +
+

+Option 1: +

+ +

+The problem can be eliminated by omitting the requirement that a.erase(q) return an +iterator. This is, however, in contrast with the equivalent requirements for other +standard containers. +

+ +

+Option 2: +

+ +

+a.erase(q) can be made to compute the next iterator only when explicitly requested: +the technique consists in returning a proxy object implicitly convertible to iterator, so +that +

+ +
iterator q1=a.erase(q);
+
+ +

+works as expected, while +

+ +
a.erase(q);
+
+ +

+does not ever invoke the conversion-to-iterator operator, thus avoiding the associated +computation. To allow this technique, some sections of TR1 along the line "return value +is an iterator..." should be changed to "return value is an unspecified object implicitly +convertible to an iterator..." Although this trick is expected to work transparently, it can +have some collateral effects when the expression a.erase(q) is used inside generic +code. +

+ +
+ +

[ +2010-03-27 Joaquín adds: +]

+ + +
+

+Signature of iterator erase(const_iterator) should be changed to void +erase(const_iterator). If this is not viable an acceptable tradeoff +could be to make the return type of erase(const_iterator) +implementation defined. +

+ +

+The standard should allow implementations of unordered associative +containers using either singly or doubly linked lists. +N2023 +proves that singly-linked lists implementations cannot provide the required +complexity for iterator erase(const_iterator). Thus, some action is +needed to allow both implementations. +

+ +

+Option 1: Changing the required complexity from O(1) to O(log n). This option +merely masks a design flaw. Users are forcefully penalized for what they don't +use (the returned iterator). Besides, they would have to learn about the +pathological (yet very real) situations where using erase can lead to +quadratic performance. Two out of these three objections remain even if some +alternative member function like void quick_erase(const_iterator) is +thrown in to the interface. +

+ +

+Some objections have been expressed to changing return type of erase to +void, arguing that it would break current existing practice with +standard library implementations based on doubly-linked lists, where the problem +does not occur. However implementations based on drafts should not block the +resolution of a serious design issue, more so when the issue will hurt future +users of C++, as it's happening already. +

+ +

+Option 2: Make erase return type implementation defined. There's +a possible tradeoff with the objectors above consisting in changing the +signature to implementation defined erase(iterator), so that +returning an iterator is indeed a valid extension. To this it can be argued that +this would make implementantions returning an iterator look as somehow promoting +proprietary extensions: this in my opinion is not a valid argument since those +implementations are already extending the required interface by +providing bidirectional iterators (just forward iterators are required). +

+
+ +

[ +2010 Rapperswil: +]

+ + +
+

+The issue was lengthy discussed and implementation experience was demonstrated that a non-void return +type is implementable for both single-linked and double-linked lists without loss of efficiency. +

+ +

+By a 12-1-1-0 poll voted to keep the return type of erase as iterator instead of +void and a second 0-0-3-10 poll rejected the additional proposal to add a +quick_erase returning void, thus LWG decided for NAD. +

+
+ + +

Rationale:

+ +

+No consensus for a change. +

+ + + +

Proposed resolution:

+ + + + + +
+

580. unused allocator members

+

Section: 23.2.1 [container.requirements.general] Status: NAD Editorial + Submitter: Martin Sebor Opened: 2006-06-14 Last modified: 2010-10-29

+

View other active issues in [container.requirements.general].

+

View all other issues in [container.requirements.general].

+

View all issues with NAD Editorial status.

+

Duplicate of: 479

+

Discussion:

+

+ +C++ Standard Library templates that take an allocator as an argument +are required to call the allocate() and +deallocate() members of the allocator object to obtain +storage. However, they do not appear to be required to call any other +allocator members such as construct(), +destroy(), address(), and +max_size(). This makes these allocator members less than +useful in portable programs. + +

+

+ +It's unclear to me whether the absence of the requirement to use these +allocator members is an unintentional omission or a deliberate +choice. However, since the functions exist in the standard allocator +and since they are required to be provided by any user-defined +allocator I believe the standard ought to be clarified to explictly +specify whether programs should or should not be able to rely on +standard containers calling the functions. + +

+

+ +I propose that all containers be required to make use of these +functions. + +

+

[ +Batavia: We support this resolution. Martin to provide wording. +]

+ +

[ +pre-Oxford: Martin provided wording. +]

+ + +

[ +2009-04-28 Pablo adds: +]

+ + +
+N2554 +(scoped allocators), +N2768 +(allocator concepts), and +N2810 +(allocator defects), address all of these points EXCEPT max_size(). +So, I would add a note to that affect and re-class the defect as belonging +to section 23.2.1 [container.requirements.general]. +
+ +

[ +2009-07 Frankfurt +]

+ + +
+The comment in the description of this issue that this "would be" +rendered editorial by the adoption of N2257 is confusing. It appears +that N2257 was never adopted. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Addressed by +N2982. +
+ + + +

Proposed resolution:

+

+ +Specifically, I propose to change 23.2 [container.requirements], +p9 as follows: + +

+
+

+-9- Copy constructors for all container types defined in this clause +that are parametrized on Allocator copy +anthe allocator argument from their respective +first parameters. + +All other constructors for these container types take an +const Allocator& argument (20.1.6), an +allocator whose value_type is the same as the container's +value_type. + +A copy of this argument isshall be used for any +memory allocation and deallocation performed, +by these constructors and by all member functions, during +the lifetime of each container object. Allocation shall be +performed "as if" by calling the allocate() member +function on a copy of the allocator object of the appropriate type +New Footnote), and deallocation "as if" by calling +deallocate() on a copy of the same allocator object of +the corresponding type. + +A copy of this argument shall also be used to construct and +destroy objects whose lifetime is managed by the container, including +but not limited to those of the container's value_type, +and to obtain their address. All objects residing in storage +allocated by a container's allocator shall be constructed "as if" by +calling the construct() member function on a copy of the +allocator object of the appropriate type. The same objects shall be +destroyed "as if" by calling destroy() on a copy of the +same allocator object of the same type. The address of such objects +shall be obtained "as if" by calling the address() member +function on a copy of the allocator object of the appropriate +type. + +Finally, a copy of this argument shall be used by its container +object to determine the maximum number of objects of the container's +value_type the container may store at the same time. The +container member function max_size() obtains this number +from the value returned by a call to +get_allocator().max_size(). + +In all container types defined in this clause that are +parametrized on Allocator, the member +get_allocator() returns a copy of the +Allocator object used to construct the +container.258) +

+

+New Footnote: This type may be different from Allocator: +it may be derived from Allocator via +Allocator::rebind<U>::other for the appropriate +type U. +

+
+

+ +The proposed wording seems cumbersome but I couldn't think of a better +way to describe the requirement that containers use their +Allocator to manage only objects (regardless of their +type) that persist over their lifetimes and not, for example, +temporaries created on the stack. That is, containers shouldn't be +required to call Allocator::construct(Allocator::allocate(1), +elem) just to construct a temporary copy of an element, or +Allocator::destroy(Allocator::address(temp), 1) to +destroy temporaries. + +

+ + +

[ +Howard: This same paragraph will need some work to accommodate 431. +]

+ + +

[ +post Oxford: This would be rendered NAD Editorial by acceptance of +N2257. +]

+ + + + + +
+

582. specialized algorithms and volatile storage

+

Section: 20.9.8.2 [uninitialized.copy] Status: NAD + Submitter: Martin Sebor Opened: 2006-06-14 Last modified: 2010-10-29

+

View all other issues in [uninitialized.copy].

+

View all issues with NAD status.

+

Discussion:

+ +

Related to 1029

+

+ +The specialized algorithms [lib.specialized.algorithms] are specified +as having the general effect of invoking the following expression: + +

+ 
+new (static_cast<void*>(&*i))
+    typename iterator_traits<ForwardIterator>::value_type (x)
+
+
+

+ +This expression is ill-formed when the type of the subexpression +&*i is some volatile-qualified T. + +

+ +

[ +Batavia: Lack of support for proposed resolution but agree there is a +defect. Howard to look at wording. Concern that move semantics +properly expressed if iterator returns rvalue. +]

+ + + +

[ +2009-06-17 Pablo adds: +]

+ + +
+ +

Propose that Issue 582 be closed NAD.

+

+Issue 582 asks that uninitialized_copy, +uninitialized_fill, and uninitialized_fill_n should be +well-formed if the result type is volatile. My feeling is that the +standard does not, and should not, guarantee any useful behavior when +constructors are invoked on volatile storage, so making it syntactically +legal to call uninitialized_copy on volatile storage is not useful. A +possible editorial change would be to put my previous sentence into a +non-normative note. +

+

+Note that the three sections starting with 20.9.8.2 [uninitialized.copy] do not +yet have concepts. Here's a first crack at the first one: +

+
template <InputIterator InIter, OutputIterator OutIter>
+requires ExplicitConvertible<HasDereference<OutIter::reference>::result,
+                             OutIter::value_type&>
+      && Convertible<OutIter::value_type*, void*>
+      && ExplicitConvertible<OutIter::value_type, InIter::reference>
+  OutIter uninitialized_copy(InIter first, InIter last, OutIter result);
+
+
+

+Effects: +

+
while (first != last) {
+  typedef OutIter::value_type value_type;
+  value_type& outRef = static_cast<value_type&>(*result++);
+  ::new (static_cast<void*>(addressof(outRef))) value_type(*first++);
+}
+
+
+ +
+ +

+Notes: +

+
    +
  1. This definition is actually LESS constrained than in C++03 because +there is no requirement that the result be a forward iterator. +
    2. +
  2. +If +OutIter returns a proxy type with an overloaded operator&, this +definition probably won't compile. Lifting this limitation while +allowing value_type to have an overloaded operator& would be hard, but +is probably possible with careful overloading. I'm not sure it's worth +it. +
    3. +
  3. +This definition retains the prohibition on the use of volatile types for the result. +
    4. +
+ +
+ +

[ +2009-07 Frankfurt +]

+ + +
+

+We don't deal with volatile in the library. +

+

+Jim: should we state that explicitly somewhere? +

+

+Beman: you might argue that clause 17 should say something about +volatile. However, if you want to raise we argument, we should open it +as a separate issue and consult with experts on concurrency. +

+

+Hinnant: actually, some library components do handle volatile, so we'd +need to be very careful about what we say in clause 17. +

+

+No objection to NAD. +

+

+Move to NAD. +

+
+ + + +

Proposed resolution:

+

+ +In order to allow these algorithms to operate on volatile storage I +propose to change the expression so as to make it well-formed even for +pointers to volatile types. Specifically, I propose the following +changes to clauses 20 and 24. Change 20.6.4.1, p1 to read: + +

+ 
+Effects:
+
+typedef typename iterator_traits<ForwardIterator>::pointer    pointer;
+typedef typename iterator_traits<ForwardIterator>::value_type value_type;
+
+for (; first != last; ++result, ++first)
+    new (static_cast<void*>(const_cast<pointer>(&*result))
+        value_type (*first);
+
+
+

+ +change 20.6.4.2, p1 to read + +

+ 
+Effects:
+
+typedef typename iterator_traits<ForwardIterator>::pointer    pointer;
+typedef typename iterator_traits<ForwardIterator>::value_type value_type;
+
+for (; first != last; ++result, ++first)
+    new (static_cast<void*>(const_cast<pointer>(&*first))
+        value_type (*x);
+
+
+

+ +and change 20.6.4.3, p1 to read + +

+ 
+Effects:
+
+typedef typename iterator_traits<ForwardIterator>::pointer    pointer;
+typedef typename iterator_traits<ForwardIterator>::value_type value_type;
+
+for (; n--; ++first)
+    new (static_cast<void*>(const_cast<pointer>(&*first))
+        value_type (*x);
+
+
+

+ +In addition, since there is no partial specialization for +iterator_traits<volatile T*> I propose to add one +to parallel such specialization for <const T*>. Specifically, I +propose to add the following text to the end of 24.3.1, p3: + +

+

+ +and for pointers to volatile as + +

+ 
+namespace std {
+template<class T> struct iterator_traits<volatile T*> {
+typedef ptrdiff_t difference_type;
+typedef T value_type;
+typedef volatile T* pointer;
+typedef volatile T& reference;
+typedef random_access_iterator_tag iterator_category;
+};
+}
+
+
+

+ +Note that the change to iterator_traits isn't necessary +in order to implement the specialized algorithms in a way that allows +them to operate on volatile strorage. It is only necesassary in order +to specify their effects in terms of iterator_traits as +is done here. Implementations can (and some do) achieve the same +effect by means of function template overloading. + +

+ + + + +
+

583. div() for unsigned integral types

+

Section: 26.8 [c.math] Status: NAD + Submitter: Beman Dawes Opened: 2006-06-15 Last modified: 2010-10-29

+

View all other issues in [c.math].

+

View all issues with NAD status.

+

Discussion:

+

+There is no div() function for unsigned integer types. +

+

+There are several possible resolutions. The simplest one is noted below. Other +possibilities include a templated solution. +

+ + +

Proposed resolution:

+

+Add to 26.7 [lib.c.math] paragraph 8: +

+ +
struct udiv_t div(unsigned, unsigned);
+struct uldiv_t div(unsigned long, unsigned long);
+struct ulldiv_t div(unsigned long long, unsigned long long);
+
+ + + +

Rationale:

+Toronto: C99 does not have these unsigned versions because +the signed version exist just to define the implementation-defined behavior +of signed integer division. Unsigned integer division has no implementation-defined +behavior and thus does not need this treatment. + + + + + +
+

584. missing int pow(int,int) functionality

+

Section: 26.8 [c.math] Status: NAD + Submitter: Beman Dawes Opened: 2006-06-15 Last modified: 2010-10-29

+

View all other issues in [c.math].

+

View all issues with NAD status.

+

Discussion:

+

+There is no pow() function for any integral type. +

+ + +

Proposed resolution:

+

+Add something like: +

+ +
template< typename T>
+T power( T x, int n );
+// requires: n >=0
+
+ + +

Rationale:

+Toronto: We already have double pow(integral, integral) from 26.8 [c.math] p11. + + + + + +
+

585. facet error reporting

+

Section: 22.4 [locale.categories] Status: NAD + Submitter: Martin Sebor, Paolo Carlini Opened: 2006-06-22 Last modified: 2010-10-29

+

View all other issues in [locale.categories].

+

View all issues with NAD status.

+

Discussion:

+

+ +Section 22.2, paragraph 2 requires facet get() members +that take an ios_base::iostate& argument, +err, to ignore the (initial) value of the +argument, but to set it to ios_base::failbit in case of a +parse error. + +

+

+ +We believe there are a few minor problems with this blanket +requirement in conjunction with the wording specific to each +get() member function. + +

+

+ +First, besides get() there are other member functions +with a slightly different name (for example, +get_date()). It's not completely clear that the intent of +the paragraph is to include those as well, and at least one +implementation has interpreted the requirement literally. + +

+

+ +Second, the requirement to "set the argument to +ios_base::failbit suggests that the functions are not +permitted to set it to any other value (such as +ios_base::eofbit, or even ios_base::eofbit | +ios_base::failbit). + +

+

+ +However, 22.2.2.1.2, p5 (Stage 3 of num_get parsing) and +p6 (bool parsing) specifies that the do_get +functions perform err |= ios_base::eofbit, which +contradicts the earlier requirement to ignore err's initial +value. + +

+

+ +22.2.6.1.2, p1 (the Effects clause of the money_get +facet's do_get member functions) also specifies that +err's initial value be used to compute the final +value by ORing it with either ios_base::failbit or +withios_base::eofbit | ios_base::failbit. + +

+ +

[ +2009-07 Frankfurt +]

+ + +
+Move to NAD. +
+ + + +

Proposed resolution:

+

+ +We believe the intent is for all facet member functions that take an +ios_base::iostate& argument to: + +

+ +

+ +To that effect we propose to change 22.2, p2 as follows: + +

+

+ +The put() members make no provision for error +reporting. (Any failures of the OutputIterator argument must be +extracted from the returned iterator.) Unless otherwise +specified, the get() members that +take an ios_base::iostate& argument whose value +they ignore, but set to ios_base::failbit in case of a parse +error., err, start by evaluating +err = ios_base::goodbit, and may subsequently set +err to either ios_base::eofbit, or +ios_base::failbit, or ios_base::eofbit | +ios_base::failbit in response to reaching the end-of-file or in +case of a parse error, or both, respectively. + +

+ + +

[ +Kona (2007): We need to change the proposed wording to clarify that the +phrase "the get members" actually denotes get(), get_date(), etc. +Proposed Disposition: Open +]

+ + + + +
+

587. iststream ctor missing description

+

Section: D.9.2.1 [depr.istrstream.cons] Status: NAD Editorial + Submitter: Martin Sebor Opened: 2006-06-22 Last modified: 2010-10-29

+

View all issues with NAD Editorial status.

+

Discussion:

+

+ +The iststream(char*, streamsize) ctor is in the class +synopsis in D.7.2 but its signature is missing in the description +below (in D.7.2.1). + +

+ + +

Proposed resolution:

+

+ +This seems like a simple editorial issue and the missing signature can +be added to the one for const char* in paragraph 2. + +

+ +

[ +post Oxford: Noted that it is already fixed in +N2284 +]

+ + + + + + +
+

588. requirements on zero sized tr1::arrays and other details

+

Section: 23.3.1 [array] Status: NAD + Submitter: Gennaro Prota Opened: 2006-07-18 Last modified: 2010-10-29

+

View all other issues in [array].

+

View all issues with NAD status.

+

Discussion:

+

+The wording used for section 23.2.1 [lib.array] seems to be subtly +ambiguous about zero sized arrays (N==0). Specifically: +

+

+* "An instance of array<T, N> stores N elements of type T, so that +[...]" +

+

+Does this imply that a zero sized array object stores 0 elements, i.e. +that it cannot store any element of type T? The next point clarifies +the rationale behind this question, basically how to implement begin() +and end(): +

+

+* 23.2.1.5 [lib.array.zero], p2: "In the case that N == 0, begin() == +end() == unique value." +

+

+What does "unique" mean in this context? Let's consider the following +possible implementations, all relying on a partial specialization: +

+
a)
+    template< typename T >
+    class array< T, 0 > {
+    
+        ....
+
+        iterator begin()
+        { return iterator( reinterpret_cast< T * >( this ) ); }
+        ....
+
+    };
+
+

+This has been used in boost, probably intending that the return value +had to be unique to the specific array object and that array couldn't +store any T. Note that, besides relying on a reinterpret_cast, has +(more than potential) alignment problems. +

+
b)
+    template< typename T >
+    class array< T, 0 > {
+    
+        T t;
+
+        iterator begin()
+        { return iterator( &t ); }
+        ....
+
+    };
+
+

+This provides a value which is unique to the object and to the type of +the array, but requires storing a T. Also, it would allow the user to +mistakenly provide an initializer list with one element. +

+

+A slight variant could be returning *the* null pointer of type T +

+
    return static_cast<T*>(0);
+
+

+In this case the value would be unique to the type array<T, 0> but not +to the objects (all objects of type array<T, 0> with the same value +for T would yield the same pointer value). +

+

+Furthermore this is inconsistent with what the standard requires from +allocation functions (see library issue 9). +

+

+c) same as above but with t being a static data member; again, the +value would be unique to the type, not to the object. +

+

+d) to avoid storing a T *directly* while disallowing the possibility +to use a one-element initializer list a non-aggregate nested class +could be defined +

+
    struct holder { holder() {} T t; } h;
+
+

+and then begin be defined as +

+
 iterator begin() { return &h.t; }
+
+

+But then, it's arguable whether the array stores a T or not. +Indirectly it does. +

+

+----------------------------------------------------- +

+

+Now, on different issues: +

+

+* what's the effect of calling assign(T&) on a zero-sized array? There +seems to be only mention of front() and back(), in 23.2.1 [lib.array] +p4 (I would also suggest to move that bullet to section 23.2.1.5 +[lib.array.zero], for locality of reference) +

+

+* (minor) the opening paragraph of 23.2.1 [lib.array] wording is a bit +inconsistent with that of other sequences: that's not a problem in +itself, but compare it for instance with "A vector is a kind of +sequence that supports random access iterators"; though the intent is +obvious one might argue that the wording used for arrays doesn't tell +what an array is, and relies on the reader to infer that it is what +the <array> header defines. +

+

+* it would be desiderable to have a static const data member of type +std::size_t, with value N, for usage as integral constant expression +

+

+* section 23.1 [lib.container.requirements] seem not to consider +fixed-size containers at all, as it says: "[containers] control +allocation and deallocation of these objects [the contained objects] +through constructors, destructors, *insert and erase* operations" +

+

+* max_size() isn't specified: the result is obvious but, technically, +it relies on table 80: "size() of the largest possible container" +which, again, doesn't seem to consider fixed size containers +

+ +

[ +2009-05-29 Daniel adds: +]

+ + +
+
    +
  1. +

    +star bullet 1 ("what's the effect of calling assign(T&) on a +zero-sized array?[..]"); +

    +
    +assign has been renamed to fill and the semantic of fill is now +defined in terms of +the free algorithm fill_n, which is well-defined for this situation. +
    +
    2. +
  2. +

    +star bullet 3 ("it would be desiderable to have a static const data +member..."): +

    +
    +It seems that tuple_size<array<T, N> >::value as of 23.3.1.8 [array.tuple] does +provide this functionality now. +
    +
    3. +
+
+ +

[ +2009-07 Frankfurt +]

+ + +
+

+Alisdair to address by the next meeting, or declare NAD. +

+

+Moved to Tentatively NAD. +

+
+ +

[ +2009 Santa Cruz: +]

+ + +
+Moved to NAD. +
+ + + +

Proposed resolution:

+

+

+ + +

[ +Kona (2007): requirements on zero sized tr1::arrays and other details +Issue 617: std::array is a sequence that doesn't satisfy the sequence +requirements? Alisdair will prepare a paper. Proposed Disposition: Open +]

+ + + + + +
+

590. Type traits implementation latitude should be removed for C++0x

+

Section: 20.7 [meta], TR1 4.9 [tr.meta.req] Status: NAD Editorial + Submitter: Beman Dawes Opened: 2006-08-10 Last modified: 2010-10-29

+

View all other issues in [meta].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+20.4.9 [lib.meta.req], Implementation requirements, provides latitude for type +traits implementers that is not needed in C++0x. It includes the wording: +

+ +

+[Note: the latitude granted to implementers in this clause is temporary, +and is expected to be removed in future revisions of this document. -- end note] +

+ +

+Note: +N2157: Minor Modifications to the type traits Wording +also has the intent of removing this wording from the WP. +

+ + + +

Proposed resolution:

+

+Remove 20.4.9 [lib.meta.req] in its entirety from the WP. +

+ +

[ +post-Oxford: Recommend NAD Editorial. This resolution is now in the +current working draft. +]

+ + + + + + + +
+

591. Misleading "built-in

+

Section: 18.3.1.2 [numeric.limits.members] Status: NAD Editorial + Submitter: whyglinux Opened: 2006-08-08 Last modified: 2010-10-29

+

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

+

View all issues with NAD Editorial status.

+

Discussion:

+

+18.2.1.2 numeric_limits members [lib.numeric.limits.members] +Paragraph 7: +

+

+"For built-in integer types, the number of non-sign bits in the +representation." +

+ +

+26.1 Numeric type requirements [lib.numeric.requirements] +Footnote: +

+ +

+"In other words, value types. These include built-in arithmetic types, +pointers, the library class complex, and instantiations of valarray for +value types." +

+ +

+Integer types (which are bool, char, wchar_t, and the signed and +unsigned integer types) and arithmetic types (which are integer and +floating types) are all built-in types and thus there are no +non-built-in (that is, user-defined) integer or arithmetic types. Since +the redundant "built-in" in the above 2 sentences can mislead that +there may be built-in or user-defined integer and arithmetic types +(which is not correct), the "built-in" should be removed. +

+ + +

Proposed resolution:

+

+18.2.1.2 numeric_limits members [lib.numeric.limits.members] +Paragraph 7: +

+

+"For built-in integer types, the number of non-sign bits in the +representation." +

+ +

+26.1 Numeric type requirements [lib.numeric.requirements] +Footnote: +

+ +

+"In other words, value types. These include built-in arithmetic types, +pointers, the library class complex, and instantiations of valarray for +value types." +

+ + +

Rationale:

+

+Recommend NAD / Editorial. The proposed resolution is accepted as editorial. +

+ + + + + +
+

592. Incorrect treatment of rdbuf()->close() return type

+

Section: 27.9.1.9 [ifstream.members] Status: NAD Editorial + Submitter: Christopher Kohlhoff Opened: 2006-08-17 Last modified: 2010-10-29

+

View all other issues in [ifstream.members].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+I just spotted a minor problem in 27.8.1.7 +[lib.ifstream.members] para 4 and also 27.8.1.13 +[lib.fstream.members] para 4. In both places it says: +

+
+
void close();
+
+

+Effects: Calls rdbuf()->close() and, if that function returns false, ... +

+
+

+However, basic_filebuf::close() (27.8.1.2) returns a pointer to the +filebuf on success, null on failure, so I think it is meant to +say "if that function returns a null pointer". Oddly, it is +correct for basic_ofstream. +

+ + +

Proposed resolution:

+

+Change 27.9.1.9 [ifstream.members], p5: +

+ +

+Effects: Calls rdbuf()->close() and, if that function +fails (returns false a null pointer), +calls setstate(failbit) (which may throw ios_base::failure +(27.4.4.3)). +

+ +

+Change 27.9.1.17 [fstream.members], p5: +

+ +

+Effects: Calls rdbuf()->close() and, if that function +fails (returns false a null pointer), +calls setstate(failbit) (which may throw ios_base::failure +(27.4.4.3)). +

+ + + +

[ +Kona (2007): Proposed Disposition: NAD, Editorial +]

+ + + + + +
+

597. Decimal: The notion of 'promotion' cannot be emulated by user-defined types.

+

Section: TRDecimal 3.2 [trdec.types.types] Status: NAD + Submitter: Daveed Vandevoorde Opened: 2006-04-05 Last modified: 2010-10-29

+

View all other issues in [trdec.types.types].

+

View all issues with NAD status.

+

Discussion:

+

+In a private email, Daveed writes: +

+
+

+I am not familiar with the C TR, but my guess is that the +class type approach still won't match a built-in type +approach because the notion of "promotion" cannot be +emulated by user-defined types. +

+

+Here is an example: +

+
+
+         struct S {
+           S(_Decimal32 const&);  // Converting constructor
+         };
+         void f(S);
+
+         void f(_Decimal64);
+
+         void g(_Decimal32 d) {
+           f(d);
+         }
+
+ +
+

+If _Decimal32 is a built-in type, the call f(d) will likely +resolve to f(_Decimal64) because that requires only a +promotion, whereas f(S) requires a user-defined conversion. +

+

+If _Decimal32 is a class type, I think the call f(d) will be +ambiguous because both the conversion to _Decimal64 and the +conversion to S will be user-defined conversions with neither +better than the other. +

+
+

+Robert comments: +

+

+In general, a library of arithmetic types cannot exactly emulate the behavior of the intrinsic numeric types. There are several ways to tell whether an implementation of the decimal types uses compiler intrinisics or a library. For example: +

+
                 _Decimal32 d1;
+                 d1.operator+=(5);  // If d1 is a builtin type, this won't compile.
+
+

+In preparing the decimal TR, we have three options: +

+
    +
  1. require that the decimal types be class types
    2. +
  2. require that the decimal types be builtin types, like float and double
    3. +
  3. specify a library of class types, but allow enough implementor latitude that a conforming implementation could instead provide builtin types
    4. +
+

+We decided as a group to pursue option #3, but that approach implies that implementations may not agree on the semantics of certain use cases (first example, above), or on whether certain other cases are well-formed (second example). Another potentially important problem is that, under the present definition of POD, the decimal classes are not POD types, but builtins will be. +

+

+Note that neither example above implies any problems with respect to C-to-C++ compatibility, since neither example can be expressed in C. +

+ +

[ +2009-07 Frankfurt +]

+ + +
+

+Decimal numeric types may either be builtin types or library types. We +only intend to specify the common subset of behaviors of the two +implementation approaches. The front matter of the Decimal TR says this +explicitly. +

+

+Move to NAD. +

+
+ + + +

Proposed resolution:

+ + + + + +
+

606. Decimal: allow narrowing conversions

+

Section: TRDecimal 3.2 [trdec.types.types] Status: NAD + Submitter: Martin Sebor Opened: 2006-06-15 Last modified: 2010-10-29

+

View all other issues in [trdec.types.types].

+

View all issues with NAD status.

+

Discussion:

+

+In c++std-lib-17205, Martin writes: +

+

+...was it a deliberate design choice to make narrowing assignments ill-formed while permitting narrowing compound assignments? For instance: +

+
      decimal32 d32;
+      decimal64 d64;
+
+      d32 = 64;     // error
+      d32 += 64;    // okay
+
+

+In c++std-lib-17229, Robert responds: +

+

+It is a vestige of an old idea that I forgot to remove from the paper. Narrowing assignments should be permitted. The bug is that the converting constructors that cause narrowing should not be explicit. Thanks for pointing this out. +

+ +

[ +2009-07 Frankfurt +]

+ + +
+

+The current state of the Decimal TR is the result of a deliberate design +decision that has been examined many times. +

+

+Move to NAD. +

+
+ + +

Proposed resolution:

+

+1. In "3.2.2 Class decimal32" synopsis, remove the explicit specifier from the narrowing conversions: +

+
                // 3.2.2.2 conversion from floating-point type:
+                explicit decimal32(decimal64 d64);
+                explicit decimal32(decimal128 d128);
+
+

+2. Do the same thing in "3.2.2.2. Conversion from floating-point type." +

+

+3. In "3.2.3 Class decimal64" synopsis, remove the explicit specifier from the narrowing conversion: +

+
                // 3.2.3.2 conversion from floating-point type:
+                explicit decimal64(decimal128 d128);
+
+

+4. Do the same thing in "3.2.3.2. Conversion from floating-point type." +

+ +

[ +Redmond: We prefer explicit conversions for narrowing and implicit for widening. +]

+ + + + + + +
+

614. std::string allocator requirements still inconsistent

+

Section: 21.4 [basic.string] Status: NAD + Submitter: Bo Persson Opened: 2006-12-05 Last modified: 2010-10-29

+

View all other issues in [basic.string].

+

View all issues with NAD status.

+

Discussion:

+

+This is based on N2134, where 21.3.1/2 states: +"... The Allocator object used shall be a copy of the Allocator object +passed to the basic_string object's constructor or, if the constructor does +not take an Allocator argument, a copy of a default-constructed Allocator +object." +

+

+Section 21.3.2/1 lists two constructors: +

+
basic_string(const basic_string<charT,traits,Allocator>& str );
+
+basic_string(const basic_string<charT,traits,Allocator>& str ,
+             size_type pos , size_type n = npos,
+             const Allocator& a = Allocator());
+
+

+and then says "In the first form, the Allocator value used is copied from +str.get_allocator().", which isn't an option according to 21.3.1. +

+

[ +Batavia: We need blanket statement to the effect of: +]

+ + +
    +
  1. If an allocator is passed in, use it, or,
    2. +
  2. If a string is passed in, use its allocator.
    3. +
+

[ +Review constructors and functions that return a string; make sure we follow these +rules (substr, operator+, etc.). Howard to supply wording. +]

+ + +

[ +Bo adds: The new container constructor which takes only a size_type is not +consistent with 23.2 [container.requirements], p9 which says in part: + +

+All other constructors for these container types take an +Allocator& argument (20.1.2), an allocator whose value type +is the same as the container's value type. A copy of this argument is +used for any memory allocation performed, by these constructors and by +all member functions, during the lifetime of each container object. +
+]

+ + +

[ +post Bellevue: We re-confirm that the issue is real. Pablo will provide wording. +]

+ + +

[ +2009-07 Frankfurt +]

+ + +
+Move to NAD. +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

615. Inconsistencies in Section 21.4

+

Section: 21.7 [c.strings] Status: NAD Editorial + Submitter: Bo Persson Opened: 2006-12-11 Last modified: 2010-10-29

+

View all other issues in [c.strings].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In the current draft N2134, 21.4/1 says +

+

+"Tables 59,228) 60, 61, 62,and 63 229) 230) describe headers <cctype>, +<cwctype>, <cstring>, <cwchar>, and <cstdlib> (character conversions), +respectively." +

+

+Here footnote 229 applies to table 62, not table 63. +

+

+Also, footnote 230 lists the new functions in table 63, "atoll, strtoll, +strtoull, strtof, and strtold added by TR1". However, strtof is not present +in table 63. +

+ + +

Proposed resolution:

+

+

+ + +

Rationale:

+

+Recommend NAD, editorial. Send to Pete. +

+ + + + + +
+

617. std::array is a sequence that doesn't satisfy the sequence requirements?

+

Section: 23.3.1 [array] Status: NAD + Submitter: Bo Persson Opened: 2006-12-30 Last modified: 2010-10-29

+

View all other issues in [array].

+

View all issues with NAD status.

+

Discussion:

+

+The <array> header is given under 23.3 [sequences]. +23.3.1 [array]/paragraph 3 says: +

+

+"Unless otherwise specified, all array operations are as described in +23.2 [container.requirements]". +

+

+However, array isn't mentioned at all in section 23.2 [container.requirements]. +In particular, Table 82 "Sequence requirements" lists several operations (insert, erase, clear) +that std::array does not have in 23.3.1 [array]. +

+

+Also, Table 83 "Optional sequence operations" lists several operations that +std::array does have, but array isn't mentioned. +

+ +

[ +2009-07 Frankfurt +]

+ + +
+

+The real issue seems to be different than what is described here. +Non-normative text says that std::array is a sequence container, but +there is disagreement about what that really means. There are two +possible interpretations: +

+
    +
  1. +a sequence container is one that satisfies all sequence container requirements +
    2. +
  2. +a sequence container is one that satisfies some of the sequence +container requirements. Any operation that the container supports is +specified by one or more sequence container requirements, unless that +operation is specifically singled out and defined alongside the +description of the container itself. +
    3. +
+

+Move to Tentatively NAD. +

+
+ +

[ +2009-07-15 Loďc Joly adds: +]

+ + +
+

+The section 23.2.3 [sequence.reqmts]/1 states that array is a sequence. 23.2.3 [sequence.reqmts]/3 +introduces table 83, named Sequence container requirements. This seems +to me to be defining the requirements for all sequences. However, array +does not follow all of this requirements (this can be read in the array +specific section, for the standard is currently inconsistent). +

+ +

+Proposed resolution 1 (minimal change): +

+
+

+Say that array is a container, that in addition follows only some of the +sequence requirements, as described in the array section: +

+ +
+The library provides five three basic kinds of sequence containers: array, +vector, +forward_list, list, and deque. In addition, array +and forward_list follows some of the requirements +of sequences, as described in their respective sections. +
+ +
+ +

+Proposed resolution 2 (most descriptive description, no full wording provided): +

+
+Introduce the notion of a Fixed Size Sequence, with it requirement table +that would be a subset of the current Sequence container. array would be +the only Fixed Size Sequence (but dynarray is in the queue for TR2). +Sequence requirements would now be requirements in addition to Fixed +Size Sequence requirements (it is currently in addition to container). +
+
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Move to NAD Editorial +
+ +

[ +2009 Santa Cruz: +]

+ + +
+This will require a lot of reorganization. Editor doesn't think this is really +an issue, since the description of array can be considered as overriding +what's specified about sequences. Move to NAD. +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

626. new Remark clauses not documented

+

Section: 17.5.1.4 [structure.specifications] Status: NAD Editorial + Submitter: Martin Sebor Opened: 2007-01-20 Last modified: 2010-10-29

+

View all other issues in [structure.specifications].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+ +The Remark clauses newly introduced into the Working Paper +(N2134) +are not mentioned in 17.5.1.4 [structure.specifications] where we list the +meaning of Effects, Requires, and other clauses (with +the exception of Notes which are documented as informative in +17.5.1.2 [structure.summary], p2, and which they replace in many cases). + +

+

+ +Propose add a bullet for Remarks along with a brief description. + +

+

[ +Batavia: Alan and Pete to work. +]

+ + +

[ +Bellevue: Already resolved in current working paper. +]

+ + + +

Proposed resolution:

+

+

+ + + + + +
+

627. Low memory and exceptions

+

Section: 18.6.1.1 [new.delete.single] Status: NAD + Submitter: P.J. Plauger Opened: 2007-01-23 Last modified: 2010-10-29

+

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

+

View all issues with NAD status.

+

Discussion:

+

+I recognize the need for nothrow guarantees in the exception reporting +mechanism, but I strongly believe that implementors also need an escape hatch +when memory gets really low. (Like, there's not enough heap to construct and +copy exception objects, or not enough stack to process the throw.) I'd like to +think we can put this escape hatch in 18.6.1.1 [new.delete.single], +operator new, but I'm not sure how to do it. We need more than a +footnote, but the wording has to be a bit vague. The idea is that if +new can't allocate something sufficiently small, it has the right to +abort/call terminate/call unexpected. +

+ +

[ +Bellevue: NAD. 1.4p2 specifies a program must behave correctly "within +its resource limits", so no further escape hatch is necessary. +]

+ + + +

Proposed resolution:

+

+

+ + + + + +
+

631. conflicting requirements for BinaryPredicate

+

Section: 25 [algorithms] Status: NAD + Submitter: James Kanze Opened: 2007-01-31 Last modified: 2010-10-29

+

View all other issues in [algorithms].

+

View all issues with NAD status.

+

Discussion:

+

+The general requirements for BinaryPredicate (in 25 [algorithms]/8) contradict the implied specific requirements for +some functions. In particular, it says that: +

+ +

+[...] if an algorithm takes BinaryPredicate binary_pred +as its argument and first1 and first2 as its +iterator arguments, it should work correctly in the construct if +(binary_pred (*first1 , *first2 )){...}. +BinaryPredicate always takes the first iterator type as its +first argument, that is, in those cases when T value is +part of the signature, it should work correctly in the context of if +(binary_pred (*first1 , value)){...}. +

+ +

+In the description of upper_bound (25.4.3.2 [upper.bound]/2), however, the use is described as +"!comp(value, e)", where e is an +element of the sequence (a result of dereferencing +*first). +

+ +

+In the description of lexicographical_compare, we have both +"*first1 < *first2" and "*first2 +< *first1" (which presumably implies "comp( +*first1, *first2 )" and "comp( *first2, +*first1 )". +

+ +

+Logically, the BinaryPredicate is used as an ordering +relationship, with the semantics of "less than". Depending on the +function, it may be used to determine equality, or any of the inequality +relationships; doing this requires being able to use it with either +parameter first. I would thus suggest that the requirement be: +

+ +

+Alternatively, one could specify an order for each function. IMHO, this +would be more work for the committee, more work for the implementors, +and of no real advantage for the user: some functions, such as +lexicographical_compare or equal_range, will still require both +functions, and it seems like a much easier rule to teach that both +functions are always required, rather than to have a complicated list of +when you only need one, and which one. +

+ +

[ +Toronto: Moved to Open. ConceptGCC seems to get lower_bound +and upper_bound to work withoutt these changes. +]

+ + +

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

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+Move to Review. The small problem with the "iterator type" +will be fixed. The cited functions (lower_bound, uppwer_bound, +equal_range) don't actually use BinaryPredicate , and where it is used, +it is consistent with [algorithm]/8, so the main complaint of the issue +is moot. +
+ +

[ +2010-01-16 Beman clarified wording. +]

+ + +

[ +2010-01-31: Moved to Tentatively NAD after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + + + +

Rationale:

+

[ +post San Francisco: +]

+ + +
+

+Solved by +N2759. +

+
+ +

+2010-01-31: The draft standard is well specified as is, and this specification +is desired. Issues 556 and 870 solve the remaining +unclearness regarding the meaning of BinaryPredicate. +

+ + + +

Proposed resolution:

+

Change 25 [algorithms] paragraph 8 as indicated:

+ +
+ +

+8 The BinaryPredicate parameter is used whenever an algorithm expects a +function object that when applied to the result of dereferencing two +corresponding iterators or to dereferencing an iterator and type T when +T is part of the signature returns a value testable as true. +BinaryPredicate always takes the first iterator value_type as +one of its arguments; which argument is unspecified. In other words, +if If an algorithm takes BinaryPredicate binary_pred +as its argument and first1 and first2 as its iterator +arguments, it should work correctly both in the construct if +(binary_pred(*first1, *first2)){...} and if (binary_pred (*first2, +*first1)){...}. BinaryPredicate always takes the first +iterator type as its first argument, that is, in In those cases +when T value is part of the signature, it should work correctly in the +context of if (binary_pred(*first1, value)){...} and of if +(binary_pred (value, *first1)){...}. binary_pred shall +not apply any non-constant function through the dereferenced iterators. +[Note: if the two types are not identical, and neither is +convertable to the other, this may require that the BinaryPredicate be +a functional object with two overloaded operator()() functions. +— end note] +

+ +
+ + + + + + +
+

632. Time complexity of size() for std::set

+

Section: 23.2 [container.requirements] Status: NAD + Submitter: Lionel B Opened: 2007-02-01 Last modified: 2010-10-29

+

View all other issues in [container.requirements].

+

View all issues with NAD status.

+

Discussion:

+

+A recent news group discussion: +

+
+

+Anyone know if the Standard has anything to say about the time complexity +of size() for std::set? I need to access a set's size (/not/ to know if it is empty!) heavily +during an algorithm and was thus wondering whether I'd be better off +tracking the size "manually" or whether that'd be pointless. +

+

+That would be pointless. size() is O(1). +

+

+Nit: the standard says "should" have constant time. Implementations may take +license to do worse. I know that some do this for std::list<> as a part of +some trade-off with other operation. +

+ +

+I was aware of that, hence my reluctance to use size() for std::set. +

+

+However, this reason would not apply to std::set<> as far as I can see. +

+

+Ok, I guess the only option is to try it and see... +

+
+ +

+If I have any recommendation to the C++ Standards Committee it is that +implementations must (not "should"!) document clearly[1], where known, the +time complexity of *all* container access operations. +

+

+[1] In my case (gcc 4.1.1) I can't swear that the time complexity of size() +for std::set is not documented... but if it is it's certainly well hidden +away. +

+ +

[ +Kona (2007): This issue affects all the containers. We'd love to see a +paper dealing with the broad issue. We think that the complexity of the +size() member of every container -- except possibly list -- should be +O(1). Alan has volunteered to provide wording. +]

+ + +

[ +Bellevue: +]

+ + +
+Mandating O(1) size will not fly, too many implementations would be +invalidated. Alan to provide wording that toughens wording, but that +does not absolutely mandate O(1). +
+ +

[ +Batavia (2009-05): +]

+ +
+We observed that the wording "should" (in note a) has no effect. +Howard prefers that O(1) size be mandated. +It is not clear that this issue can be resolved to everyone's satisfaction, +but Alan will provide wording nonetheless. +
+ +

[ +2009-07 Frankfurt +]

+ + +
+Fixed by paper N2923. +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

633. Return clause mentions undefined "type()"

+

Section: 20.8.14.2.5 [func.wrap.func.targ] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2007-02-03 Last modified: 2010-10-29

+

View all issues with NAD Editorial status.

+

Discussion:

+

+20.8.14.2.5 [func.wrap.func.targ], p4 says: +

+

+Returns: If type() == typeid(T), a pointer to the stored +function target; otherwise a null pointer. +

+ +
    +
  1. +There exists neither a type, a typedef type, nor member +function type() in class template function nor in the global or +std namespace. +
    2. +
  2. +Assuming that type should have been target_type(), +this description would lead to false results, if T = cv +void due to returns clause 20.8.14.2.5 [func.wrap.func.targ], p1. +
    3. +
+ + + +

Proposed resolution:

+

+Change 20.8.14.2.5 [func.wrap.func.targ], p4: +

+ +

+Returns: If type() target_type() == typeid(T) && typeid(T) != +typeid(void), a pointer to the stored function target; +otherwise a null pointer. +

+ +

[ +Pete: Agreed. It's editorial, so I'll fix it. +]

+ + + + + + + +
+

636. 26.5.2.3 valarray::operator[]

+

Section: 26.6.2.3 [valarray.access] Status: NAD Editorial + Submitter: Bo Persson Opened: 2007-02-11 Last modified: 2010-10-29

+

View all other issues in [valarray.access].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The signature of the const operator[] has been changed to return a const +reference. +

+

+The description in paragraph 1 still says that the operator returns by +value. +

+

[ +Pete recommends editorial fix. +]

+ + + +

Proposed resolution:

+

+

+ + + + + +
+

637. [c.math]/10 inconsistent return values

+

Section: 26.8 [c.math] Status: NAD Editorial + Submitter: Bo Persson Opened: 2007-02-13 Last modified: 2010-10-29

+

View all other issues in [c.math].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+26.8 [c.math], paragraph 10 has long lists of added signatures for float and long double +functions. All the signatures have float/long double return values, which is +inconsistent with some of the double functions they are supposed to +overload. +

+ + +

Proposed resolution:

+

+Change 26.8 [c.math], paragraph 10, +

+ +
float int ilogb(float);
+float long lrint(float);
+float long lround(float);
+float long long llrint(float);
+float long long llround(float);
+
+long double int ilogb(long double);
+long double long lrint(long double);
+long double long lround(long double);
+long double long long llrint(long double);
+long double long long llround(long double);
+
+ + + + + +
+

639. Still problems with exceptions during streambuf IO

+

Section: 27.7.1.2.3 [istream::extractors], 27.7.2.6.3 [ostream.inserters] Status: NAD + Submitter: Daniel Krügler Opened: 2007-02-17 Last modified: 2010-10-29

+

View all other issues in [istream::extractors].

+

View all issues with NAD status.

+

Discussion:

+

+There already exist two active DR's for the wording of 27.7.1.2.3 [istream::extractors]/13 +from 14882:2003(E), namely 64 and 413. +

+ +

+Even with these proposed corrections, already maintained in N2134, +I have the feeling, that the current wording does still not properly +handle the "exceptional" situation. The combination of para 14 +

+ +

+"[..] Characters are extracted and inserted until +any of the following occurs: +

+

+[..] +

+

+- an exception occurs (in which case the exception is caught)." +

+ +

+and 15 +

+ +

+"If the function inserts no characters, it calls setstate(failbit), +which +may throw ios_base::failure (27.4.4.3). If it inserted no characters +because it caught an exception thrown while extracting characters +from *this and failbit is on in exceptions() (27.4.4.3), then the +caught +exception is rethrown." +

+ +

+both in N2134 seems to imply that any exception, which occurs +*after* at least one character has been inserted is caught and lost +for +ever. It seems that even if failbit is on in exceptions() rethrow is +not +allowed due to the wording "If it inserted no characters because it +caught an exception thrown while extracting". +

+ +

+Is this behaviour by design? +

+ +

+I would like to add that its output counterpart in 27.7.2.6.3 [ostream.inserters]/7-9 +(also +N2134) does not demonstrate such an exception-loss-behaviour. +On the other side, I wonder concerning several subtle differences +compared to input:: +

+

+1) Paragraph 8 says at its end: +

+ +

+"- an exception occurs while getting a character from sb." +

+ +

+Note that there is nothing mentioned which would imply that such +an exception will be caught compared to 27.7.1.2.3 [istream::extractors]/14. +

+ +

+2) Paragraph 9 says: +

+ +

+"If the function inserts no characters, it calls setstate(failbit) +(which +may throw ios_base::failure (27.4.4.3)). If an exception was thrown +while extracting a character, the function sets failbit in error +state, +and if failbit is on in exceptions() the caught exception is +rethrown." +

+ +

+The sentence starting with "If an exception was thrown" seems to +imply that such an exception *should* be caught before. +

+ + +

Proposed resolution:

+

+(a) In 27.7.1.2.3 [istream::extractors]/15 (N2134) change the sentence +

+ +

+If the function inserts no characters, it calls +setstate(failbit), which may throw ios_base::failure +(27.4.4.3). If it inserted no characters because it caught an +exception thrown while extracting characters from *this +an exception was thrown while extracting a character from +*this, the function sets failbit in error state, +and failbit is on in exceptions() (27.4.4.3), then the +caught exception is rethrown. +

+ +

+(b) In 27.7.2.6.3 [ostream.inserters]/8 (N2134) change the sentence: +

+ +
+

+Gets characters from sb and inserts them in *this. +Characters are read from sb and inserted until any of the +following occurs: +

+ +
+ + + +

Rationale:

+This extractor is described as a formatted input function so the +exception behavior is already specified. There is additional behavior +described in this section that applies to the case in which failbit is +set. This doesn't contradict the usual exception behavior for formatted +input functions because that applies to the case in which badbit is set. + + + + + +
+

641. Editorial fix for 27.6.4 (N2134)

+

Section: 27.7.4 [ext.manip] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2007-02-18 Last modified: 2010-10-29

+

View all other issues in [ext.manip].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The function f in para 4 (27.7.4 [ext.manip]) references an unknown strm +in the following line: +

+ +
mg.get(Iter(str.rdbuf()), Iter(), intl, strm, err, mon);
+
+ + +

Proposed resolution:

+

+Change 27.7.4 [ext.manip], p4: +

+ +
mg.get(Iter(str.rdbuf()), Iter(), intl, strm, err, mon);
+
+ +

[ +Oxford: Editorial. +]

+ + + + + + + +
+

642. Invalidated fstream footnotes in N2134

+

Section: 27.9.1.9 [ifstream.members], 27.9.1.13 [ofstream.members] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2007-02-20 Last modified: 2010-10-29

+

View all other issues in [ifstream.members].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The standard wording of N2134 has extended the 14882:2003(E) +wording for the ifstream/ofstream/fstream open function to fix +a long standing problem, see 409. +

+ +

+Now it's properly written as +

+ +

+"If that function does not return a null pointer calls clear(), +otherwise +calls setstate(failbit)[..]" +

+ +

+instead of the previous +

+ +

+"If that function returns a null pointer, calls setstate(failbit)[..] +

+ +

+While the old footnotes saying +

+ +

+"A successful open does not change the error state." +

+ +

+where correct and important, they are invalid now for ifstream and +ofstream (because clear *does* indeed modify the error state) and +should be removed (Interestingly fstream itself never had these, +although +they where needed for that time). +

+ + +

Proposed resolution:

+

+In 27.9.1.9 [ifstream.members], remove footnote: +

+ +

+334) A successful open does not change the error state. +

+ +

+In 27.9.1.13 [ofstream.members], remove footnote: +

+ +

+335) A successful open does not change the error state. +

+ + + + + + +
+

644. Possible typos in 'function' description

+

Section: 20.8.14.2 [func.wrap.func] Status: NAD + Submitter: Bo Persson Opened: 2007-02-25 Last modified: 2010-10-29

+

View all other issues in [func.wrap.func].

+

View all issues with NAD status.

+

Discussion:

+

+20.8.14.2 [func.wrap.func] +

+

+The note in paragraph 2 refers to 'undefined void operators', while the +section declares a pair of operators returning bool. +

+ +

[ +Post-Sophia Antipolis: +]

+ + +
+Changed from Pending WP to Open. This issue was voted to WP at the same time the operators were +changed from private to deleted. The two issues stepped on each other. What do we want the return +type of these deleted functions to be? +
+ +

[ +2009-05-02 Daniel adds: +]

+ + +
+

+I suggest harmonizing this issue with similar classes. E.g. in +20.9.10.3 [util.smartptr.weak] bool return values for +

+
template <class Y> bool operator<(weak_ptr<Y> const&) const = delete;
+template <class Y> bool operator<=(weak_ptr<Y> const&) const = delete;
+template <class Y> bool operator>(weak_ptr<Y> const&) const = delete;
+template <class Y> bool operator>=(weak_ptr<Y> const&) const = delete;
+
+ +

+are used and basically all newer provided deleted copy assignment operators +of type X use the canonical return type X& instead of void. Since the note +mentioned in the issue description has now already been changed to +

+
+deleted overloads close possible hole in the type system +
+

+it seems to be of even lesser need to perform the change. Therefore +I recommend declaring the issue as NAD. +

+
+ +

[ +Batavia (2009-05): +]

+ +
+

+We agree with Daniel's recommendation. +

+

+Move to NAD. +

+
+ + +

Proposed resolution:

+

+Change 20.8.14.2 [func.wrap.func] +

+ +
...
+private:
+   // 20.8.14.2 [func.wrap.func], undefined operators:
+   template<class Function2> bool void operator==(const function<Function2>&);
+   template<class Function2> bool void operator!=(const function<Function2>&);
+};
+
+ +

+Change 20.8.14.2 [func.wrap.func] +

+ +
template<class Function2> bool void operator==(const function<Function2>&);
+template<class Function2> bool void operator!=(const function<Function2>&);
+
+ + + + + +
+

645. Missing members in match_results

+

Section: 28.10 [re.results] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2007-02-26 Last modified: 2010-10-29

+

View all other issues in [re.results].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+According to the description given in 28.10 [re.results]/2 the class template +match_results "shall satisfy the requirements of a Sequence, [..], +except that only operations defined for const-qualified Sequences +are supported". +Comparing the provided operations from 28.10 [re.results]/3 with the +sequence/container tables 80 and 81 one recognizes the following +missing operations: +

+ +

+1) The members +

+ +
const_iterator rbegin() const;
+const_iterator rend() const;
+
+ +

+should exists because 23.1/10 demands these for containers +(all sequences are containers) which support bidirectional +iterators. Aren't these supported by match_result? This is not +explicitely expressed, but it's somewhat implied by two arguments: +

+

+(a) Several typedefs delegate to +iterator_traits<BidirectionalIterator>. +

+

+(b) The existence of const_reference operator[](size_type n) const +implies even random-access iteration. +I also suggest, that match_result should explicitly mention, +which minimum iterator category is supported and if this does +not include random-access the existence of operator[] is +somewhat questionable. +

+

+2) The new "convenience" members +

+
const_iterator cbegin() const;
+const_iterator cend() const;
+const_iterator crbegin() const;
+const_iterator crend() const;
+
+

+should be added according to tables 80/81. +

+ + +

Proposed resolution:

+

+Add the following members to the match_results synopsis after end() in 28.10 [re.results] +para 3: +

+ +
const_iterator cbegin() const; 
+const_iterator cend() const;
+
+ +

+In section 28.10.4 [re.results.acc] change: +

+ +
+
const_iterator begin() const;
+const_iterator cbegin() const;
+
+
+

+-7- Returns: A starting iterator that enumerates over all the sub-expressions stored in *this. +

+
+ +
const_iterator end() const;
+const_iterator cend() const;
+
+
+

+-8- Returns: A terminating iterator that enumerates over all the sub-expressions stored in *this. +

+
+
+ + + +

[ +Kona (2007): Voted to adopt proposed wording in +N2409 +except removing the entry in the table container requirements. Moved to Review. +]

+ + +

[ +Bellevue: Proposed wording now in the WP. +]

+ + + + + +
+

647. Inconsistent regex_search params

+

Section: 28.11.3 [re.alg.search] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2007-02-26 Last modified: 2010-10-29

+

View all issues with NAD Editorial status.

+

Discussion:

+

+28.11.3 [re.alg.search]/5 declares +

+ +
template <class iterator, class charT, class traits>
+bool regex_search(iterator first, iterator last,
+                  const basic_regex<charT, traits>& e,
+                  regex_constants::match_flag_type flags =
+                      regex_constants::match_default);
+
+ +

+where it's not explained, which iterator category +the parameter iterator belongs to. This is inconsistent +to the preceding declaration in the synopsis section +28.4 [re.syn], which says: +

+ +
template <class BidirectionalIterator, class charT, class traits>
+bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
+                  const basic_regex<charT, traits>& e,
+                  regex_constants::match_flag_type flags =
+                      regex_constants::match_default);
+
+ + +

Proposed resolution:

+

+In 28.11.3 [re.alg.search]/5 replace all three occurences of param "iterator" with +"BidirectionalIterator" +

+ +
template <class iterator BidirectionalIterator, class charT, class traits>
+  bool regex_search(iterator BidirectionalIterator first, iterator BidirectionalIterator last, 
+                    const basic_regex<charT, traits>& e, 
+                    regex_constants::match_flag_type flags = 
+                      regex_constants::match_default);
+
+

+-6- Effects: Behaves "as if" by constructing an object what of +type match_results<iterator +BidirectionalIterator> and then returning the result +of regex_search(first, last, what, e, flags). +

+
+ + +

Rationale:

+Applied to working paper while issue was still in New status. + + + + + +
+

648. regex_iterator c'tor needs clarification/editorial fix

+

Section: 28.12.1.1 [re.regiter.cnstr] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2007-03-03 Last modified: 2010-10-29

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In 28.12.1.1 [re.regiter.cnstr]/2 the effects paragraph starts with: +

+ +
+

+Effects: Initializes begin and end to point to the beginning and the +end of the target sequence, sets pregex to &re, sets flags to f,[..] +

+ +

+There are two issues with this description: +

+ +
    +
  1. +The meaning of very first part of this quote is unclear, because +there is no target sequence provided, instead there are given two +parameters a and b, both of type BidirectionalIterator. The mentioned +part does not explain what a and b represent. +
    2. +
  2. +There does not exist any parameter f, but instead a parameter +m in the constructor declaration, so this is actually an editorial +fix. +
    3. +
+ + +

Proposed resolution:

+

+In 28.12.1.1 [re.regiter.cnstr]/2 change the above quoted part by +

+ +

+Effects: Initializes begin and end to point to +the beginning and the end of the target sequence designated by the +iterator range [a, b), sets pregex to +&re, sets flags to f +m, then calls regex_search(begin, end, match, +*pregex, flags). If this call returns false the +constructor sets *this to the end-of-sequence iterator. +

+ + + + + +
+

649. Several typos in regex_token_iterator constructors

+

Section: 28.12.2.1 [re.tokiter.cnstr] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2007-03-03 Last modified: 2010-10-29

+

View all other issues in [re.tokiter.cnstr].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In 28.12.2.1 [re.tokiter.cnstr]/1+2 both the constructor declaration +and the following text shows some obvious typos: +

+

+1) The third constructor form is written as +

+
template <std::size_t N>
+  regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 
+                       const regex_type& re, 
+                       const int (&submatches)[R], 
+                       regex_constants::match_flag_type m = 
+                         regex_constants::match_default);
+
+ +

+where the dimensions of submatches are specified by an +unknown value R, which should be N. +

+

+2) Paragraph 2 of the same section says in its last sentence: +

+ +

+The third constructor initializes the member subs to hold a +copy of the sequence of integer values pointed to by the iterator range +[&submatches, &submatches + R). +

+ +

+where again R must be replaced by N. +

+ +

+3) Paragraph 3 of the same section says in its first sentence: +

+ +

+Each constructor then sets N to 0, and +position to position_iterator(a, b, re, f). +

+ +

+where a non-existing parameter "f" is mentioned, which must be +replaced +by the parameter "m". +

+ + +

Proposed resolution:

+

+Change 28.12.2.1 [re.tokiter.cnstr]/1: +

+
template <std::size_t N>
+  regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, 
+                       const regex_type& re, 
+                       const int (&submatches)[R N], 
+                       regex_constants::match_flag_type m = 
+                         regex_constants::match_default);
+
+ +

+Change 28.12.2.1 [re.tokiter.cnstr]/2: +

+ +

+Effects: The first constructor initializes the member +subs to hold the single value submatch. The second +constructor initializes the member subs to hold a copy of the +argument submatches. The third constructor initializes the +member subs to hold a copy of the sequence of integer values +pointed to by the iterator range [&submatches, &submatches + +R N). +

+ +

+Change 28.12.2.1 [re.tokiter.cnstr]/3: +

+ +

+Each constructor then sets N to 0, and +position to position_iterator(a, b, re, f +m). If position is not an end-of-sequence +iterator the constructor sets result to the address of the +current match. Otherwise if any of the values stored in subs is +equal to -1 the constructor sets *this to a suffix +iterator that points to the range [a, b), otherwise the +constructor sets *this to an end-of-sequence iterator. +

+ + + + + + +
+

653. Library reserved names

+

Section: 1.2 [intro.refs] Status: NAD + Submitter: Alisdair Meredith Opened: 2007-03-08 Last modified: 2010-10-29

+

View all other issues in [intro.refs].

+

View all issues with NAD status.

+

Discussion:

+

+

+
+

+1.2 [intro.refs] Normative references +

+ +

+The following standards contain provisions which, through reference in +this text, constitute provisions of this Interna- tional Standard. At +the time of publication, the editions indicated were valid. All +standards are subject to revision, and parties to agreements based on +this International Standard are encouraged to investigate the +possibility of applying the most recent editions of the standards +indicated below. Members of IEC and ISO maintain registers of currently +valid International Standards. +

+ + +
+ +

+I'm not sure how many of those reserve naming patterns that might affect +us, but I am equally sure I don't own a copy of any of these to check! +

+

+The point is to list the reserved naming patterns, rather than the +individual names themselves - although we may want to list C keywords +that are valid identifiers in C++ but likely to cause trouble in shared +headers (e.g. restrict) +

+ +

[ +Kona (2007): Recommend NAD. No one has identified a specific defect, just the possibility of one. +]

+ + +

[ +Post-Kona: Alisdair request Open. A good example of the problem was a +discussion of the system error proposal, where it was pointed out an all-caps +identifier starting with a capital E conflicted with reserved macro names for +both Posix and C. I had absolutely no idea of this rule, and suspect I was +not the only one in the room.
+
+Resolution will require someone with access to all the listed documents to +research their respective name reservation rules, or people with access to +specific documents add their rules to this issue until the list is complete. +]

+ + +

[ +Bellevue: Wording is aleady present in various standards, and no-one has come forward with wording. +Suggest a formal paper rather than a defect report is the correct way to proceed. +]

+ + + + +

Proposed resolution:

+ + + + + +
+

656. Typo in subtract_with_carry_engine declaration

+

Section: 26.5.2 [rand.synopsis] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2007-03-08 Last modified: 2010-10-29

+

View all other issues in [rand.synopsis].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+26.5.2 [rand.synopsis] the header <random> synopsis +contains an unreasonable closing curly brace inside the +subtract_with_carry_engine declaration. +

+ + +

Proposed resolution:

+

+Change the current declaration in 26.5.2 [rand.synopsis] +

+ +
template <class UIntType, size_t w}, size_t s, size_t r>
+class subtract_with_carry_engine;
+
+ + +

[ +Pete: Recommends editorial. +]

+ + + + + +
+

657. unclear requirement about header inclusion

+

Section: 17.6.2.2 [using.headers] Status: NAD + Submitter: Gennaro Prota Opened: 2007-03-14 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+17.6.2.2 [using.headers] states: +

+ +

+A translation unit shall include a header only outside of any +external declaration or definition, [...] +

+ +

+I see three problems with this requirement: +

+ +
    +

  1. The C++ standard doesn't define what an "external declaration" or +an "external definition" are (incidentally the C99 standard does, and +has a sentence very similar to the above regarding header inclusion). +

    +I think the intent is that the #include directive shall lexically +appear outside *any* declaration; instead, when the issue was pointed +out on comp.std.c++ at least one poster interpreted "external +declaration" as "declaration of an identifier with external linkage". +If this were the correct interpretation, then the two inclusions below +would be legal: +

    +
      // at global scope
+  static void f()
+  {
+# include <cstddef>
+  }
+
+  static void g()
+  {
+# include <stddef.h>
+  }
+
    +

    +(note that while the first example is unlikely to compile correctly, +the second one may well do) +

    2. + +

  2. as the sentence stands, violations will require a diagnostic; is +this the intent? It was pointed out on comp.std.c++ (by several +posters) that at least one way to ensure a diagnostic exists: +

    +

    + [If there is an actual file for each header,] one simple way + to implement this would be to insert a reserved identifier + such as __begin_header at the start of each standard header. + This reserved identifier would be ignored for all other + purposes, except that, at the appropriate point in phase 7, if + it is found inside an external definition, a diagnostic is + generated. There's many other similar ways to achieve the same + effect. +

    +

    --James Kuyper, on comp.std.c++ +

    3. + +

  3. is the term "header" meant to be limited to standard headers? +Clause 17 is all about the library, but still the general question is +interesting and affects one of the points in the explicit namespaces +proposal (n1691): +

    +

    + Those seeking to conveniently enable argument-dependent + lookups for all operators within an explicit namespace + could easily create a header file that does so: +

        namespace mymath::
+    {
+        #include "using_ops.hpp"
+    }
+
    +
    4. +
+ + +

Proposed resolution:

+

+

+ + +

Rationale:

+We believe that the existing language does not cause any real confusion +and any new formulation of the rules that we could come up with are +unlikely to be better than what's already in the standard. + + + + + +
+

662. Inconsistent handling of incorrectly-placed thousands separators

+

Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: NAD + Submitter: Cosmin Truta Opened: 2007-04-05 Last modified: 2010-10-29

+

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

+

View all issues with NAD status.

+

Discussion:

+

+From Section 22.4.2.1.2 [facet.num.get.virtuals], paragraphs 11 and 12, it is implied +that the value read from a stream must be stored +even if the placement of thousands separators does not conform to the +grouping() specification from the numpunct facet. +Since incorrectly-placed thousands separators are flagged as an extraction +failure (by the means of failbit), we believe it is better not +to store the value. A consistent strategy, in which any kind of extraction +failure leaves the input item intact, is conceptually cleaner, is able to avoid +corner-case traps, and is also more understandable from the programmer's point +of view. +

+

+Here is a quote from "The C++ Programming Language (Special Edition)" +by B. Stroustrup (Section D.4.2.3, pg. 897): +

+

+"If a value of the desired type could not be read, failbit is set in r. +[...] An input operator will use r to determine how to set the state of its +stream. If no error was encountered, the value read is assigned through v; +otherwise, v is left unchanged." +

+

+This statement implies that rdstate() alone is sufficient to +determine whether an extracted value is to be assigned to the input item +val passed to do_get. However, this is in disagreement +with the current C++ Standard. The above-mentioned assumption is true in all +cases, except when there are mismatches in digit grouping. In the latter case, +the parsed value is assigned to val, and, at the same time, err +is assigned to ios_base::failbit (essentially "lying" about the +success of the operation). Is this intentional? The current behavior raises +both consistency and usability concerns. +

+

+Although digit grouping is outside the scope of scanf (on which +the virtual methods of num_get are based), handling of grouping +should be consistent with the overall behavior of scanf. The specification of +scanf makes a distinction between input failures and matching +failures, and yet both kinds of failures have no effect on the input items +passed to scanf. A mismatch in digit grouping logically falls in +the category of matching failures, and it would be more consistent, and less +surprising to the user, to leave the input item intact whenever a failure is +being signaled. +

+

+The extraction of bool is another example outside the scope of +scanf, and yet consistent, even in the event of a successful +extraction of a long but a failed conversion from +long to bool. +

+

+Inconsistency is further aggravated by the fact that, when failbit is set, +subsequent extraction operations are no-ops until failbit is +explicitly cleared. Assuming that there is no explicit handling of +rdstate() (as in cin>>i>>j) it is +counter-intuitive to be able to extract an integer with mismatched digit +grouping, but to be unable to extract another, properly-formatted integer +that immediately follows. +

+

+Moreover, setting failbit, and selectively assigning a value to +the input item, raises usability problems. Either the strategy of +scanf (when there is no extracted value in case of failure), or +the strategy of the strtol family (when there is always an +extracted value, and there are well-defined defaults in case of a failure) are +easy to understand and easy to use. On the other hand, if failbit +alone cannot consistently make a difference between a failed extraction, and a +successful but not-quite-correct extraction whose output happens to be the same +as the previous value, the programmer must resort to implementation tricks. +Consider the following example: +

+
    int i = old_i;
+    cin >> i;
+    if (cin.fail())
+        // can the value of i be trusted?
+        // what does it mean if i == old_i?
+        // ...
+
+

+Last but not least, the current behvaior is not only confusing to the casual +reader, but it has also been confusing to some book authors. Besides +Stroustrup's book, other books (e.g. "Standard C++ IOStreams and Locales" by +Langer and Kreft) are describing the same mistaken assumption. Although books +are not to be used instead of the standard reference, the readers of these +books, as well as the people who are generally familiar to scanf, +are even more likely to misinterpret the standard, and expect the input items +to remain intact when a failure occurs. +

+ + +

Proposed resolution:

+ +

+Change 22.4.2.1.2 [facet.num.get.virtuals]: +

+ +
+

+Stage 3: The result of stage 2 processing can be one of +

+ +

+In the first case, Ddigit 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. Otherwise, the value that was converted in stage 2 is stored in val and ios_base::goodbit is stored in err. +

+
+ + +

Rationale:

+post-Toronto: Changed from New to NAD at the request of the author. The preferred solution of +N2327 +makes this resolution obsolete. + + + + + +
+

663. Complexity Requirements

+

Section: 17.5.1.4 [structure.specifications] Status: NAD + Submitter: Thomas Plum Opened: 2007-04-16 Last modified: 2010-10-29

+

View all other issues in [structure.specifications].

+

View all issues with NAD status.

+

Discussion:

+

+17.5.1.4 [structure.specifications] para 5 says +

+ +

+-5- Complexity requirements specified in the library +clauses are upper bounds, and implementations that provide better +complexity guarantees satisfy the requirements. +

+ +

+The following +objection has been raised: +

+ +

+The library clauses suggest general +guidelines regarding complexity, but we have been unable to discover +any absolute hard-and-fast formulae for these requirements. Unless +or until the Library group standardizes specific hard-and-fast +formulae, we regard all the complexity requirements as subject to a +"fudge factor" without any intrinsic upper bound. +

+ +

+[Plum ref +_23213Y31 etc] +

+ + +

Proposed resolution:

+

+

+ + +

Rationale:

+Kona (2007): No specific instances of underspecification have been +identified, and big-O notation always involves constant factors. + + + + + +
+

667. money_get's widened minus sign

+

Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: NAD + Submitter: Thomas Plum Opened: 2007-04-16 Last modified: 2010-10-29

+

View all other issues in [locale.money.get.virtuals].

+

View all issues with NAD status.

+

Discussion:

+

+22.4.6.1.2 [locale.money.get.virtuals], para 1 says: +

+ +

+The result is returned as an integral value +stored in units or as a sequence of digits possibly preceded by a +minus sign (as produced by ct.widen(c) where c is '-' or in the range +from '0' through '9', inclusive) stored in digits. +

+ +

+The following +objection has been raised: +

+ +

+Some implementations interpret this to mean that a facet derived from +ctype<wchar_t> can provide its own member do_widen(char) +which produces e.g. L'@' for the "widened" minus sign, and that the +'@' symbol will appear in the resulting sequence of digits. Other +implementations have assumed that one or more places in the standard permit the +implementation to "hard-wire" L'-' as the "widened" minus sign. Are +both interpretations permissible, or only one? +

+ +

+[Plum ref _222612Y14] +

+ +

+Furthermore: if ct.widen('9') produces L'X' (a non-digit), does a +parse fail if a '9' appears in the subject string? [Plum ref _22263Y33] +

+ +

[ +Kona (2007): Bill and Dietmar to provide proposed wording. +]

+ + +

[ +post Bellevue: Bill adds: +]

+ + +
+The Standard is clear that the minus sign stored in digits is ct.widen('-'). +The subject string must contain characters c in the set [-0123456789] +which are translated by ct.widen(c) calls before being stored in digits; +the widened characters are not relevant to the parsing of the subject string. +
+ +

[ +Batavia (2009-05): +]

+ +
+We agree with Bill's comment above, +in line with the first of the interpretations offered in the issue. +Move to NAD. +
+ + +

Proposed resolution:

+

+

+ + + + + +
+

668. money_get's empty minus sign

+

Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: NAD + Submitter: Thomas Plum Opened: 2007-04-16 Last modified: 2010-10-29

+

View all other issues in [locale.money.get.virtuals].

+

View all issues with NAD status.

+

Discussion:

+

+22.4.6.1.2 [locale.money.get.virtuals], para 3 says: +

+ +

+If pos or neg is empty, the sign component is +optional, and if no sign is detected, the result is given the sign +that corresponds to the source of the empty string. +

+ +

+The following objection has been raised: +

+ +

+A negative_sign of "" means "there is no +way to write a negative sign" not "any null sequence is a negative +sign, so it's always there when you look for it". +

+ +

+[Plum ref _222612Y32] +

+ +

[ +Kona (2007): Bill to provide proposed wording and interpretation of existing wording. +]

+ + +

+Related to 669. +

+ +

[ +2009-05-17 Howard adds: +]

+ + +
+

+I disagree that a negative_sign of "" means "there is no way to +write a negative sign". The meaning requires the sentences of 22.4.6.1.2 [locale.money.get.virtuals] p3 following that quoted above to be +taken into account: +

+ +
+-3- ... If pos or neg is empty, the sign component is +optional, and if no sign is detected, the result is given the sign that +corresponds to the source of the empty string. Otherwise, the character +in the indicated position must match the first character of pos +or neg, and the result is given the corresponding sign. If the +first character of pos is equal to the first character of +neg, or if both strings are empty, the result is given a +positive sign. +
+ +

+So a negative_sign of "" means "there is no way to write a +negative sign" only when positive_sign is also "". However +when negative_sign is "" and postive_sign.size() > +0, then one writes a negative value by not writing the +postive_sign in the position indicated by +money_base::sign. +For example: +

+ +
pattern = {symbol, sign, value, none}
+positive_sign = "+"
+negative_sign = ""
+$123   // a negative value, using optional sign
+$+123  // a positive value
+$-123  // a parse error
+
+ +

+And: +

+ +
pattern = {symbol, sign, value, none}
+positive_sign = ""
+negative_sign = ""
+$123   // a positive value, no sign possible
+$+123  // a parse error
+$-123  // a parse error
+
+ + +

+And (regarding 669): +

+ +
pattern = {symbol, sign, value, none}
+positive_sign = "-"
+negative_sign = "-"
+$123   // a parse error, sign is mandatory
+$+123  // a parse error
+$-123  // a positive value
+
+ + +

+The text seems both unambiguous and clear to me. I recommend NAD for +both this issue and 669. However I would have no +objection to adding examples such as those above. +

+
+ +

[ +Batavia (2009-05): +]

+ +
+

+This discussion applies equally to issue 669 (q.v.). +Howard has added examples above, +and recommends either NAD or a resolution that adds his (or similar) examples +to the Working Paper. +

+

+Alan would like to rewrite paragraph 3. +

+

+We recommend moving to NAD. +Anyone who feels strongly about adding the examples +is invited to submit corresponding wording. +We further recommend issue 669 be handled identically. +

+
+ +

[ +2009-07-14 Alan reopens with improved wording. +]

+ + +

[ +2009-07 Frankfurt +]

+ + +
+No consensus for closing as NAD. Leave in Review. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD. Agreed that the original assessment as NAD was correct. +
+ + + +

Proposed resolution:

+

+Change 22.4.6.1.2 [locale.money.get.virtuals] p3: +

+ +
+-3- If the first character (if any) in the string pos returned by +mp.positive_sign() or the string neg returned by +mp.negative_sign() is recognized in the position indicated by +sign in the format pattern, it is consumed and any remaining characters +in the string are required after all the other format components. +[Example: If showbase is off, then for a neg +value of "()" and a currency symbol of "L", in "(100 L)" the "L" is +consumed; but if neg is "-", the "L" in "-100 L" is not +consumed. -- end example] If pos or neg is +empty, the sign component is optional, and if no sign is detected, the +result is given the sign that corresponds to the source of the empty +string. Otherwise, the character in the indicated position must match +the first character of pos or neg, and the result is +given the corresponding sign. If the first character of pos is +equal to the first character of neg, or if both strings are +empty, the result is given a positive sign. + +The sign pattern strings pos and neg are returned by +mp.positive_sign() and mp.negative_sign() respectively. A sign pattern +is matched if its first character is recognized in s in the position +indicated by sign in the format pattern, or if the pattern is empty and +there is no sign recognized in s. A match is required to occur. If both +patterns are matched, the result is given a positive sign, otherwise the +result is given the sign corresponding to the matched pattern. +If the pattern contains more than one character, the characters after the first +must be matched in s after all other format components. +If any sign +characters are matched, s is consumed up to and including those characters. +[Example: If showbase is off, then for a neg +value of "()" and a currency symbol of "L", in +"(100 L)" the entire string is consumed; but for a neg +value of "-", in "-100 L", the string is consumed +through the second "0" (the space and "L" are not consumed). — end +example] +
+ + + + + +
+

669. Equivalent postive and negative signs in money_get

+

Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: NAD + Submitter: Thomas Plum Opened: 2007-04-16 Last modified: 2010-10-29

+

View all other issues in [locale.money.get.virtuals].

+

View all issues with NAD status.

+

Discussion:

+

+22.4.6.1.2 [locale.money.get.virtuals], para 3 sentence 4 says: +

+ +

+If the first character of pos is equal to the first character of neg, +or if both strings are empty, the result is given a positive sign. +

+ +

+One interpretation is that an input sequence must match either the +positive pattern or the negative pattern, and then in either event it +is interpreted as positive. The following objections has been raised: +

+ +

+The input can successfully match only a positive sign, so the negative +pattern is an unsuccessful match. +

+ +

+[Plum ref _222612Y34, 222612Y51b] +

+ +

[ +Bill to provide proposed wording and interpretation of existing wording. +]

+ + +

[ +2009-05-17 See Howard's comments in related issue 668. +]

+ + +

[ +Batavia (2009-05): +]

+ +
+

+This discussion applies equally to issue 668 (q.v.). +Howard has added examples there, +and recommends either NAD or a resolution that adds his (or similar) examples +to the Working Paper. +

+

+We recommend moving to NAD. +Anyone who feels strongly about adding the examples +is invited to submit corresponding wording. +We further recommend issue 668 be handled identically. +

+
+ + +

Proposed resolution:

+

+

+ + + + + +
+

670. money_base::pattern and space

+

Section: 22.4.6.3 [locale.moneypunct] Status: Dup + Submitter: Thomas Plum Opened: 2007-04-16 Last modified: 2010-10-29

+

View all issues with Dup status.

+

Duplicate of: 836

+

Discussion:

+

+22.4.6.3 [locale.moneypunct], para 2 says: +

+ +

+The value space indicates that at least one space is required at +that position. +

+ +

+The following objection has been raised: +

+ +

+Whitespace is optional when matching space. (See 22.4.6.1.2 [locale.money.get.virtuals], para 2.) +

+ +

+[Plum ref _22263Y22] +

+ +

[ +Kona (2007): Bill to provide proposed wording. We agree that C++03 is +ambiguous, and that we want C++0X to say "space" means 0 or more +whitespace characters on input. +]

+ + + + +

Proposed resolution:

+ + + + + +
+

683. regex_token_iterator summary error

+

Section: 28.12.2 [re.tokiter] Status: NAD Editorial + Submitter: Eric Niebler Opened: 2007-06-02 Last modified: 2010-10-29

+

View all other issues in [re.tokiter].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+28.12.2 [re.tokiter], p3 says: +

+
+

+After it is constructed, the iterator finds and stores a value +match_results<BidirectionalIterator> position and sets the +internal count N to zero. +

+
+ +

+Should read: +

+ +
+

+After it is constructed, the iterator finds and stores a value +match_resultsregex_iterator<BidirectionalIterator, charT, traits> +position and sets the internal count N to zero. +

+
+ +

[ +John adds: +]

+ + +

+Yep, looks like a typo/administrative fix to me. +

+ + + +

Proposed resolution:

+

+

+ + + + + +
+

684. Unclear which members of match_results should be used in comparison

+

Section: 28.10 [re.results] Status: NAD Editorial + Submitter: Nozomu Katoo Opened: 2007-05-27 Last modified: 2010-10-29

+

View all other issues in [re.results].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In 28.4 [re.syn] of N2284, two template functions +are declared here: +

+
// 28.10, class template match_results: 
+  <snip>
+// match_results comparisons 
+  template <class BidirectionalIterator, class Allocator> 
+    bool operator== (const match_results<BidirectionalIterator, Allocator>& m1, 
+                     const match_results<BidirectionalIterator, Allocator>& m2); 
+  template <class BidirectionalIterator, class Allocator> 
+    bool operator!= (const match_results<BidirectionalIterator, Allocator>& m1, 
+                     const match_results<BidirectionalIterator, Allocator>& m2); 
+
+// 28.10.6, match_results swap:
+
+ +

+But the details of these two bool operator functions (i.e., which members of +match_results should be used in comparison) are not described in any +following sections. +

+ +

[ +John adds: +]

+ + +

+That looks like a bug: operator== should return true only if +the two objects refer to the same match - ie if one object was constructed as a +copy of the other. +

+ +

[ +Kona (2007): Bill and Pete to add minor wording to that proposed in +N2409. +]

+ + + +

Proposed resolution:

+

+Add a new section after 28.10.7 [re.results.swap], which reads: +

+

+28.10.7 match_results non-member functions. +

+ +
+
template<class BidirectionalIterator, class Allocator> 
+  bool operator==(const match_results<BidirectionalIterator, Allocator>& m1, 
+                  const match_results<BidirectionalIterator, Allocator>& m2);
+
+
+

+Returns: true only if the two objects refer to the same match. +

+
+
+ +
+
template<class BidirectionalIterator, class Allocator> 
+  bool operator!=(const match_results<BidirectionalIterator, Allocator>& m1, 
+                  const match_results<BidirectionalIterator, Allocator>& m2);
+
+
+

+Returns: !(m1 == m2). +

+
+
+ +
+
template<class BidirectionalIterator, class Allocator> 
+  void swap(match_results<BidirectionalIterator, Allocator>& m1, 
+            match_results<BidirectionalIterator, Allocator>& m2);
+
+
+

+Returns: m1.swap(m2). +

+
+
+ + +

[ +Bellevue: Proposed wording now in WP. +]

+ + + + + +
+

686. Unique_ptr and shared_ptr fail to specify non-convertibility to int for unspecified-bool-type

+

Section: 20.9.9.2.4 [unique.ptr.single.observers], 20.9.10.2.5 [util.smartptr.shared.obs] Status: NAD + Submitter: Beman Dawes Opened: 2007-06-14 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+The standard library uses the operator unspecified-bool-type() const idiom in +five places. In three of those places (20.8.14.2.3 [func.wrap.func.cap], function capacity +for example) the returned value is constrained to disallow +unintended conversions to int. The standardese is +

+

+The return type shall not be convertible to int. +

+

+This constraint is omitted for unique_ptr and shared_ptr. It should be added for those. +

+ +

[ +Bellevue: +]

+ + +
+Close as NAD. Accepting paper +N2435 +makes it irrelevant. +
+ + + +

Proposed resolution:

+

+To the Returns paragraph for operator unspecified-bool-type() +const of 20.9.9.2.4 [unique.ptr.single.observers] paragraph 11 and 20.9.10.2.5 [util.smartptr.shared.obs] paragraph 16, add the sentence: +

+

+The return type shall not be convertible to int. +

+ + +

[ +Kona (2007): Uncertain if nullptr will address this issue. +]

+ + + + + +
+

690. abs(long long) should return long long

+

Section: 26.8 [c.math] Status: NAD Editorial + Submitter: Niels Dekker Opened: 2007-06-10 Last modified: 2010-10-29

+

View all other issues in [c.math].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Quoting the latest draft (n2135), 26.8 [c.math]: +

+ +
+

+The added signatures are: +

+
long abs(long); // labs()
+long abs(long long); // llabs()
+
+
+

+Shouldn't abs(long long) have long long as return type? +

+ + +

Proposed resolution:

+

+Change 26.8 [c.math]: +

+
long long abs(long long); // llabs()
+
+ + +

Rationale:

+Had already been fixed in the WP by the time the LWG reviewed this. + + + + + +
+

701. assoc laguerre poly's

+

Section: TR1 5.2.1.1 [tr.num.sf.Lnm] Status: NAD + Submitter: Christopher Crawford Opened: 2007-06-30 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+I see that the definition the associated Laguerre +polynomials TR1 5.2.1.1 [tr.num.sf.Lnm] has been corrected since +N1687. +However, the draft standard only specifies ranks of integer value m, +while the associated Laguerre polynomials are actually valid for real +values of m > -1. In the case of non-integer values of m, the +definition Ln(m) = (1/n!)exx-m (d/dx)n (e-xxm+n) +must be used, which also holds for integer values of m. See +Abramowitz & Stegun, 22.11.6 for the general case, and 22.5.16-17 for +the integer case. In fact fractional values are most commonly used in +physics, for example to m = +/- 1/2 to describe the harmonic +oscillator in 1 dimension, and 1/2, 3/2, 5/2, ... in 3 +dimensions. +

+

+If I am correct, the calculation of the more general case is no +more difficult, and is in fact the function implemented in the GNU +Scientific Library. I would urge you to consider upgrading the +standard, either adding extra functions for real m or switching the +current ones to double. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+We understand the issue, and have opted not to extend as recommended. +

+

+Move to NAD. +

+
+ + +

Proposed resolution:

+

+

+ + + + + +
+

702. Restriction in associated Legendre functions

+

Section: TR1 5.2.1.2 [tr.num.sf.Plm] Status: NAD + Submitter: Christopher Crawford Opened: 2007-06-30 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+One other small thing, in TR1 5.2.1.2 [tr.num.sf.Plm], the restriction should be +|x| <= 1, not x >= 0.

+ +

[ +Batavia (2009-05): +]

+ +
+

+The error has been corrected in the pending IS. +

+

+Move to NAD. +

+
+ + +

Proposed resolution:

+

+

+ + + + + +
+

707. null pointer constant for exception_ptr

+

Section: 18.8.5 [propagation] Status: NAD + Submitter: Jens Maurer Opened: 2007-07-20 Last modified: 2010-10-29

+

View other active issues in [propagation].

+

View all other issues in [propagation].

+

View all issues with NAD status.

+

Discussion:

+ +

+From the Toronto Core wiki: +

+ +

+What do you mean by "null pointer constant"? How do you guarantee that +exception_ptr() == 1 doesn't work? Do you even want to prevent that? +What's the semantics? What about void *p = 0; exception_ptr() == p? +Maybe disallow those in the interface, but how do you do that with +portable C++? Could specify just "make it work". +

+ +

+Peter's response: +

+ +

+null pointer constant as defined in 4.10 [conv.ptr]. Intent is "just make it +work", can be implemented as assignment operator taking a unique pointer +to member, as in the unspecified bool type idiom. +

+ +

[ +Bellevue: +]

+ + +
+

+Original implementation was possible using the "unspecified-null-pointer" idiom, similar to unspecified-bool. +

+

+Even simpler now with nullptr_t. +

+

+NAD Rationale : null pointer constant is a perfectly defined term, and +while API is clearly implementable there is no need to spell out +implementation details. +

+
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

708. Locales need to be per thread and updated for POSIX changes

+

Section: 22 [localization] Status: NAD Future + Submitter: Peter Dimov Opened: 2007-07-28 Last modified: 2010-10-29

+

View all other issues in [localization].

+

View all issues with NAD Future status.

+

Discussion:

+

+The POSIX "Extended API Set Part 4," +

+

+http://www.opengroup.org/sib/details.tpl?id=C065 +

+

+introduces extensions to the C locale mechanism that +allow multiple concurrent locales to be used in the same application +by introducing a type locale_t that is very similar to +std::locale, and a number of _l functions that make use of it. +

+

+The global locale (set by setlocale) is now specified to be per- +process. If a thread does not call uselocale, the global locale is +in effect for that thread. It can install a per-thread locale by +using uselocale. +

+

+There is also a nice querylocale mechanism by which one can obtain +the name (such as "de_DE") for a specific facet, even for combined +locales, with no std::locale equivalent. +

+

+std::locale should be harmonized with the new POSIX locale_t +mechanism and provide equivalents for uselocale and querylocale. +

+ +

[ +Kona (2007): Bill and Nick to provide wording. +]

+ + +

[ +San Francisco: Bill and Nick still intend to provide wording, but this +is a part of the task to be addressed by the group that will look into +issue 860. +]

+ + +

[ +2009-07 Frankfurt: +]

+ + +
+

+It's our intention to stay in sync with WG14. If WG14 makes a decision +that requires a change in WG21 the issue will be reopened. +

+

+Move to NAD Future. +

+
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

717. Incomplete valarray::operator[] specification in [valarray.access]

+

Section: 26.6.2.3 [valarray.access] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2007-08-27 Last modified: 2010-10-29

+

View all other issues in [valarray.access].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Since the return type of valarray's operator[] const overload has been +changed to const T& as described in 389 several paragraphs of +the section 26.6.2.3 [valarray.access] are now +incompletely +specified, because many requirements and guarantees should now also +apply to the const overload. Most notably, the address and reference +guarantees should be extended to the const overload case. +

+ + +

Proposed resolution:

+

+Change 26.6.2.3 [valarray.access]: +

+ +
+

+-1- When applied to a constant array, the subscript operator returns a +reference to the corresponding element of the array. When applied to a +non-constant array, tThe subscript operator returns a +reference to the corresponding element of the array. +

+ +

+-3- The expression &a[i+j] == &a[i] + j evaluates as true for all size_t i +and size_t j such that i+j is less +than the length of the non-constant array a. +

+ +

+-4- Likewise, the expression &a[i] != &b[j] evaluates +as true for any two non-constant arrays a and +b and for any size_t i and size_t j such that +i is less than the length of a and j is less +than the length of b. This property indicates an absence of +aliasing and may be used to advantage by optimizing +compilers.281) +

+ +

+-5- The reference returned by the subscript operator for an non-constant array is guaranteed to be valid until +the member function resize(size_t, T) (26.5.2.7) is called for that array or until the lifetime +of that array ends, whichever happens first. +

+ +
+ + + + + + +
+

718. basic_string is not a sequence

+

Section: 21.4 [basic.string] Status: NAD Editorial + Submitter: Bo Persson Opened: 2007-08-18 Last modified: 2010-10-29

+

View all other issues in [basic.string].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Paragraph 21.4 [basic.string]/3 states: +

+ +
+

+The class template basic_string conforms to the requirements for a +Sequence (23.1.1) and for a Reversible Container (23.1). +

+
+ +

+First of all, 23.2.3 [sequence.reqmts] is no longer "Sequence" but "Sequence container". +Secondly, after the resent changes to containers (emplace, push_back, +const_iterator parameters to insert and erase), basic_string is not +even close to conform to the current requirements. +

+ +

[ +Bellevue: +]

+ + +
+ + +General consensus is to suggest option 2. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Move to NAD Editorial +
+ + + +

Proposed resolution:

+

+Remove this sentence, in recognition of the fact that basic_string is +not just a vector-light for literal types, but something quite +different, a string abstraction in its own right. +

+ + + + + +
+

721. wstring_convert inconsistensies

+

Section: 22.3.3.2.2 [conversions.string] Status: NAD + Submitter: Bo Persson Opened: 2007-08-27 Last modified: 2010-10-29

+

View all other issues in [conversions.string].

+

View all issues with NAD status.

+

Discussion:

+

+Paragraph 3 says that the Codecvt template parameter shall meet the +requirements of std::codecvt, even though std::codecvt itself cannot +be used (because of a protected destructor). +

+ +

+How are we going to explain this code to beginning programmers? +

+ +
template<class I, class E, class S>
+struct codecvt : std::codecvt<I, E, S>
+{
+    ~codecvt()
+    { }
+};
+
+void main()
+{
+    std::wstring_convert<codecvt<wchar_t, char, std::mbstate_t> > compiles_ok;
+    
+    std::wstring_convert<std::codecvt<wchar_t, char, std::mbstate_t> >   not_ok;
+}
+
+ +

[ +San Francisco: +]

+ + +
+Bill will propose a resolution. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+

+codecvt isn't intended for beginning programmers. This is a regrettable +consequence of the original design of the facet. +

+

+Move to NAD. +

+
+ + +

Proposed resolution:

+

+

+ + + + + +
+

725. Optional sequence container requirements column label

+

Section: 23.2.3 [sequence.reqmts] Status: NAD Editorial + Submitter: David Abrahams Opened: 2007-09-16 Last modified: 2010-10-29

+

View all other issues in [sequence.reqmts].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Table 90: (Optional sequence container operations) states the +"assertion note pre/post-condition" of operator[] to be +

+ +
*(a.begin() + n)
+
+ +

+Surely that's meant to be "operational semantics?" +

+ + + +

Proposed resolution:

+
+ + + + + +
Table 90: Optional sequence container operations
expression return type assertion/note
pre/post-condition
operational semantics		 container
+
+ + + + + + +
+

726. Missing regex_replace() overloads

+

Section: 28.11.4 [re.alg.replace] Status: NAD + Submitter: Stephan T. Lavavej Opened: 2007-09-22 Last modified: 2010-10-29

+

View all other issues in [re.alg.replace].

+

View all issues with NAD status.

+

Discussion:

+

+Two overloads of regex_replace() are currently provided: +

+ +
template <class OutputIterator, class BidirectionalIterator, 
+    class traits, class charT> 
+  OutputIterator 
+  regex_replace(OutputIterator out, 
+                BidirectionalIterator first, BidirectionalIterator last, 
+                const basic_regex<charT, traits>& e, 
+                const basic_string<charT>& fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+ 
+template <class traits, class charT> 
+  basic_string<charT> 
+  regex_replace(const basic_string<charT>& s, 
+                const basic_regex<charT, traits>& e, 
+                const basic_string<charT>& fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
+ +
    +
  1. Overloads taking const charT * are provided for regex_match() and +regex_search(), but not regex_replace(). This is inconsistent.
    2. +
  2. +

    The absence of const charT * overloads prevents ordinary-looking code from compiling, such as:

    + +
    const string s("kitten");
+const regex r("en");
+cout << regex_replace(s, r, "y") << endl;
+
    + +

    +The compiler error message will be something like "could not deduce +template argument for 'const std::basic_string<_Elem> &' from 'const +char[1]'". +

    + +

    +Users expect that anything taking a basic_string<charT> can also take a +const charT *. In their own code, when they write a function taking +std::string (or std::wstring), they can pass a const char * (or const +wchar_t *), thanks to basic_string's implicit constructor. Because the +regex algorithms are templated on charT, they can't rely on +basic_string's implicit constructor (as the compiler error message +indicates, template argument deduction fails first). +

    + +

    +If a user figures out what the compiler error message means, workarounds +are available - but they are all verbose. Explicit template arguments +could be given to regex_replace(), allowing basic_string's implicit +constructor to be invoked - but charT is the last template argument, not +the first, so this would be extremely verbose. Therefore, constructing +a basic_string from each C string is the simplest workaround. +

    +
    3. + +
  3. +There is an efficiency consideration: constructing basic_strings can +impose performance costs that could be avoided by a library +implementation taking C strings and dealing with them directly. +(Currently, for replacement sources, C strings can be converted into +iterator pairs at the cost of verbosity, but for format strings, there +is no way to avoid constructing a basic_string.) +
    4. +
+ +

[ +Sophia Antipolis: +]

+ + +
+We note that Boost already has these overloads. However, the proposed +wording is provided only for 28.11.4 [re.alg.replace]; wording is needed for the synopsis +as well. We also note that this has impact on match_results::format, +which may require further overloads. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Daniel to tweak for us. +
+ +

[ +2009-07-25 Daniel tweaks both this issue and 727. +]

+ + +
+

+This is solved by the proposed resolution of 727. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Leave Open. Though we believe this is solved by the proposed resolution +to 727. +
+ +

[ +2010-01-27 Moved to Tentatively NAD after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + + +

Rationale:

+

+Solved by 727. +

+ + +

Proposed resolution:

+ +

+Provide additional overloads for regex_replace(): one additional +overload of the iterator-based form (taking const charT* fmt), and three +additional overloads of the convenience form (one taking const charT* +str, another taking const charT* fmt, and the third taking both const +charT* str and const charT* fmt). 28.11.4 [re.alg.replace]: +

+ +
+
template <class OutputIterator, class BidirectionalIterator, 
+    class traits, class charT> 
+  OutputIterator 
+  regex_replace(OutputIterator out, 
+                BidirectionalIterator first, BidirectionalIterator last, 
+                const basic_regex<charT, traits>& e, 
+                const basic_string<charT>& fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
+template <class OutputIterator, class BidirectionalIterator, 
+    class traits, class charT> 
+  OutputIterator 
+  regex_replace(OutputIterator out, 
+                BidirectionalIterator first, BidirectionalIterator last, 
+                const basic_regex<charT, traits>& e, 
+                const charT* fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
+

...

+
template <class traits, class charT> 
+  basic_string<charT> 
+  regex_replace(const basic_string<charT>& s, 
+                const basic_regex<charT, traits>& e, 
+                const basic_string<charT>& fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
+template <class traits, class charT> 
+  basic_string<charT> 
+  regex_replace(const basic_string<charT>& s, 
+                const basic_regex<charT, traits>& e, 
+                const charT* fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
+template <class traits, class charT> 
+  basic_string<charT> 
+  regex_replace(const charT* s, 
+                const basic_regex<charT, traits>& e, 
+                const basic_string<charT>& fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
+template <class traits, class charT> 
+  basic_string<charT> 
+  regex_replace(const charT* s, 
+                const basic_regex<charT, traits>& e, 
+                const charT* fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
+
+ + + + + + +
+

729. Problem in [rand.req.eng]/3

+

Section: 26.5.1.4 [rand.req.eng] Status: NAD + Submitter: Stephan Tolksdorf Opened: 2007-09-21 Last modified: 2010-10-29

+

View all other issues in [rand.req.eng].

+

View all issues with NAD status.

+

Discussion:

+

+The 3rd table row in 26.5.1.4 [rand.req.eng]/3 requires random number engines to accept any +arithmetic type as a seed, which is then casted to the engine's result_type and subsequently +used for seeding the state of the engine. The requirement stated as "Creates an engine with +initial state determined by static_cast<X::result_type>(s)" forces random number engines +to either use a seeding method that completely depends on the result_type (see the discussion +of seeding for the mersenne_twister_engine in point T2 above) or at least to throw away "bits +of randomness" in the seed value if the result_type is smaller than the seed type. This seems +to be inappropriate for many modern random number generators, in particular F2-linear or +cryptographic ones, which operate on an internal bit array that in principle is independent of the +type of numbers returned. +

+ +

+Posible resolution: I propose to change the wording to a version similar to "Creates an +engine with initial state determined by static_cast<UintType>(s), where UintType is an +implementation specific unsigned integer type." +

+ +

+Additionally, the definition of s in 26.5.1.4 [rand.req.eng]/1 c) could be restricted to unsigned integer types. +

+ +

+Similarly, the type of the seed in 26.5.1.5 [rand.req.adapt]/3 e) could be left unspecified. +

+ +

+See N2424 +for further discussion. +

+ +

[ +Stephan Tolksdorf adds pre-Bellevue: +]

+ + +
+

+In reply to the discussion in +N2424 +regarding this issue: +

+

+The descriptions of all engines and engine adaptors given in sections +26.5.3 [rand.eng] and 26.5.4 [rand.adapt] already specify the concrete +types of the integer arguments for seeding. Hence, relaxing the general +requirement in 26.5.1.4 [rand.req.eng] would not affect portability and +reproducibility of the standard library. Furthermore, it is not clear to +me what exactly the guarantee "with initial state determined by +static_cast<X::result_type>(s)" is useful for. On the other hand, +relaxing the requirement would allow developers to implement other +random number engines that do not have to cast all arithmetic seed +arguments to their result_types. +

+
+ +

[ +Bellevue: +]

+ + +
+Propose close NAD for the reasons given in N2424. +
+ + + + +

Proposed resolution:

+

+See N2424 +for further discussion. +

+ +

[ +Stephan Tolksdorf adds pre-Bellevue: +]

+ + +
+

+Change row 3 of table 105 "Random number engine requirements" in 26.5.1.4 [rand.req.eng]/3 +

+ +
+Creates an engine with initial state determined by +static_cast<X::result_type>(s) +
+ +

+Similarly, change 26.5.1.5 [rand.req.adapt]/3 e) +

+ +
+When X::X is invoked with an X::result_type value s +of arithmetic type (3.9.1), ... +
+ +
+ + + + + + +
+

730. Comment on [rand.req.adapt]/3 e)

+

Section: 26.5.1.5 [rand.req.adapt] Status: NAD + Submitter: Stephan Tolksdorf Opened: 2007-09-21 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+If an engine adaptor is invoked with an argument of type seed_seq, then all base +engines are specified to be seeded with this seed_seq. As seed_seq's randomization method is +qualified as constant, this procedure will ef fectively initialize all base engines with the same seed +(though the resulting state might still dif fer to a certain degree if the engines are of different types). +It is not clear whether this mode of operation is in general appropriate, hence -- as far as the +stated requirements are of general nature and not just specific to the engine adaptors provided by +the library -- it might be better to leave the behaviour unspecified, since the current definition of +seed_seq does not allow for a generally satisfying specification. +

+ +

+Posssible resolution: [As above] +

+ +

+See N2424 +for further discussion. +

+ +

[ +Bellevue: +]

+ + +
+Close NAD for the reasons given in N2424. +
+ + + +

Proposed resolution:

+

+See N2424 +for the proposed resolution. +

+ + + + + +
+

731. proposal for a customizable seed_seq

+

Section: 26.5.7.1 [rand.util.seedseq] Status: NAD + Submitter: Stephan Tolksdorf Opened: 2007-09-21 Last modified: 2010-10-29

+

View all other issues in [rand.util.seedseq].

+

View all issues with NAD status.

+

Discussion:

+

+The proper way to seed random number engines seems to be the most frequently +discussed issue of the 26.5 [rand] proposal. While the new seed_seq approach is already rather +general and probably sufficient for most situations, it is unlikely to be optimal in every case (one +problem was pointed out in point T5 above). In some situations it might, for instance, be better to +seed the state with a cryptographic generator. +

+

+In my opinion this is a pretty strong argument for extending the standard with a simple facility to +customize the seeding procedure. This could, for example, be done with the following minimal +changes: +

+ +

+Possible resolution: +

+ +
    +
  1. +Turn the interface specification of 26.5.7.1 [rand.util.seedseq]/2 into a "SeedSeq" requirement, where the +exact behaviour of the constructors and the randomize method are left unspecified and where the +const qualification for randomize is removed. Classes implementing this interface are additionally +required to specialize the traits class in c). +
    2. +
  2. +Provide the class seed_seq as a default implementation of the SeedSeq interface. +
    3. +
  3. +

    +Supplement the seed_seq with a traits class +

    +
    template <typename T> 
+struct is_seed_seq { static const bool value = false; }
+
    +

    and the specialization

    +
    template <> 
+struct is_seed_seq<seed_seq> { static const bool value = true; }
+
    +

    which users can supplement with further specializations.

    +
    4. +
  4. +Change 26.5.1.4 [rand.req.eng]/1 d) to "q is an lvalue of a type that fulfils the SeedSeq requirements", and +modify the constructors and seed methods in 26.5.3 [rand.eng] appropriately (the actual implementation +could be done using the SFINAE technique). +
    5. +
+ +

[ +Bellevue: +]

+ + +
+See N2424. Close NAD but note that "conceptizing" the library may cause +this problem to be solved by that route. +
+ + +

Proposed resolution:

+

+See N2424 +for the proposed resolution. +

+ + + + + +
+

732. Defect in [rand.dist.samp.genpdf]

+

Section: X [rand.dist.samp.genpdf] Status: NAD Editorial + Submitter: Stephan Tolksdorf Opened: 2007-09-21 Last modified: 2010-10-29

+

View all other issues in [rand.dist.samp.genpdf].

+

View all issues with NAD Editorial status.

+

Duplicate of: 795

+

Discussion:

+

+X [rand.dist.samp.genpdf] describes the interface for a distribution template that is +meant to simulate random numbers from any general distribution given only the density and the +support of the distribution. I'm not aware of any general purpose algorithm that would be capable +of correctly and efficiently implementing the described functionality. From what I know, this is +essentially an unsolved research problem. Existing algorithms either require more knowledge +about the distribution and the problem domain or work only under very limited circumstances. +Even the state of the art special purpose library UNU.RAN does not solve the problem in full +generality, and in any case, testing and customer support for such a library feature would be a +nightmare. +

+ +

+Possible resolution: For these reasons, I propose to delete section X [rand.dist.samp.genpdf]. +

+ +

[ +Bellevue: +]

+ + +
+

+Disagreement persists. +

+

+Objection to this issue is that this function takes a general functor. +The general approach would be to normalize this function, integrate it, +and take the inverse of the integral, which is not possible in general. +An example function is sin(1+n*x) -- for any spatial frequency that the +implementor chooses, there is a value of n that renders that choice +arbitrarily erroneous. +

+

+Correction: The formula above should instead read 1+sin(n*x). +

+

+Objector proposes the following possible compromise positions: +

+ +
+ + + +

Proposed resolution:

+

+See N2813 +for the proposed resolution. +

+ + +

Rationale:

+Addressed by +N2836 "Wording Tweaks for Concept-enabled Random Number Generation in C++0X". + + + + + +
+

733. Comment on [rand.req.dist]/9

+

Section: 26.5.1.6 [rand.req.dist] Status: NAD + Submitter: Stephan Tolksdorf Opened: 2007-09-21 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+The requirement "P shall have a declaration of the form typedef X distribution_- +type" effectively makes the use of inheritance for implementing distributions very inconvenient, +because the child of a distribution class in general will not satisfy this requirement. In my opinion +the benefits of having a typedef in the parameter class pointing back to the distribution class are +not worth the hassle this requirement causes. [In my code base I never made use of the nested +typedef but on several occasions could have profited from being able to use simple inheritance for +the implementation of a distribution class.] +

+ +

+Proposed resolution: I propose to drop this requirement. +

+ +

[ +Bellevue: +]

+ + +
+Close NAD for the reasons given in N2424. In practice it is not inconvenient to meet these requirements. +
+ + + +

Proposed resolution:

+

+See N2424 +for the proposed resolution. +

+ + + + + +
+

735. Unfortunate naming

+

Section: 26.5.8.2.2 [rand.dist.bern.bin], 26.5.8.2.4 [rand.dist.bern.negbin] Status: NAD + Submitter: Stephan Tolksdorf Opened: 2007-09-21 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+In my opinion the choice of name for the t parameter of the binomial_distribution +is very unfortunate. In virtually every internet reference, book and software implementation +this parameter is called n instead, see for example Wikipedia, Mathworld, Evans et al. (1993) +Statistical Distributions, 2nd E., Wiley, p. 38, the R statistical computing language, p. 926, +Mathematica and Matlab. +

+ +

+Similarly, the choice of k for the parameter of the negative binomial distributions is rather unusual. +The most common choice for the negative binomial distribution seems to be r instead. +

+ +

+Choosing unusual names for the parameters causes confusion among users and makes the +interface unnecessarily inconvenient to use. +

+ +

+Possible resolution: For these reasons, I propose to change the name of the respective parameters +to n and r. +

+ +

[ +Bellevue: +]

+ + +
+In N2424. NAD It has been around for a while. It is hardly universal, +there is prior art, and this would confuse people. +
+ + +

Proposed resolution:

+

+See N2424 +for the proposed resolution. +

+ + + + + +
+

736. Comment on [rand.dist.samp.discrete]

+

Section: 26.5.8.5.1 [rand.dist.samp.discrete] Status: NAD + Submitter: Stephan Tolksdorf Opened: 2007-09-21 Last modified: 2010-10-29

+

View all other issues in [rand.dist.samp.discrete].

+

View all issues with NAD status.

+

Discussion:

+
    +
  1. +The specification for discrete_distribution requires the member probabilities() +to return a vector of standardized probabilities, which forces the implementation every time to +divide each probability by the sum of all probabilities, as the sum will in practice almost never be +exactly 1.0. This is unnecessarily inef ficient as the implementation would otherwise not need to +compute the standardized probabilities at all and could instead work with the non-standardized +probabilities and the sum. If there was no standardization the user would just get back the +probabilities that were previously supplied to the distribution object, which to me seems to be the +more obvious solution. +
    2. +
  2. +The behaviour of discrete_distribution is not specified in case the number of given +probabilities is larger than the maximum number representable by the IntType. +
    3. +
+ +

+Possible resolution: I propose to change the specification such that the non-standardized +probabilities need to be returned and that an additional requirement is included for the number +of probabilities to be smaller than the maximum of IntType. +

+ +

[ +Stephan Tolksdorf adds pre-Bellevue: +]

+ + +
+

+In reply to the discussion in +N2424 +of this issue: +

+

+Rescaled floating-point parameter vectors can not be expected to compare +equal because of the limited precision of floating-point numbers. +My proposal would at least guarantee that a parameter +vector (of type double) passed into the distribution would compare equal +with the one returned by the probabilities() method. Furthermore, I do +not understand why "the changed requirement would lead to a significant +increase in the amount of state in the distribution object". A typical +implementation's state would increase by exactly one number: the sum of +all probabilities. The textual representation for serialization would +not need to grow at all. Finally, the proposed replacement "0 < n <= +numeric_limits<IntType>::max() + 1" makes the implementation +unnecessarily complicated, "0 < n <= numeric_limits<IntType>::max()" +would be better. +

+
+ +

[ +Bellevue: +]

+ + +
+

+In N2424. We agree with the observation and the proposed resolution to +part b). We recommend the wording n > 0 be replaced with 0 < n +numeric_limits::max() + 1. However, we disagree with part a), as it +would interfere with the definition of parameters' equality. Further, +the changed requirement would lead to a significant increase in the +amount of state of the distribution object. +

+ +

+As it stands now, it is convenient, and the changes proposed make it +much less so. +

+ +

+NAD. Part a the current behavior is desirable. Part b, any constructor +can fail, but the rules under which it can fail do not need to be listed +here. +

+
+ + +

Proposed resolution:

+

+See N2424 +for the proposed resolution. +

+ +

[ +Stephan Tolksdorf adds pre-Bellevue: +]

+ + +
+

+In 26.5.8.5.1 [rand.dist.samp.discrete]: +

+ +

+Proposed wording a): +

+ +
+

+Changae in para. 2 +

+ +
+Constructs a discrete_distribution object with n=1 and p0 = w0 = 1 +
+ +

+and change in para. 5 +

+ +
+Returns: A vector<double> whose size member returns n and whose +operator[] member returns pk +the weight wk as a double value +when invoked with argument k for k = 0, +..., n-1 +
+ +
+ +

+Proposed wording b): +

+ +
+

+Change in para. 3: +

+ +
+If firstW == lastW, let the sequence w have length n = 1 and consist +of the single value w0 = 1. Otherwise, [firstW,lastW) shall form a +sequence w of length n > 0 +such that 0 < n <= numeric_limits<IntType>::max(), +and *firstW shall yield a value w0 +convertible to double. [Note: The values wk are commonly known +as the weights . -- end note] +
+ +
+ +
+ + + + + +
+

737. Comment on [rand.dist.samp.pconst]

+

Section: 26.5.8.5.2 [rand.dist.samp.pconst] Status: NAD + Submitter: Stephan Tolksdorf Opened: 2007-09-21 Last modified: 2010-10-29

+

View all other issues in [rand.dist.samp.pconst].

+

View all issues with NAD status.

+

Discussion:

+
    +
  1. +The discussion in point T11 above regarding probabilities() similarly applies +to the method densities() of piecewise_constant_distribution. +
    2. +
  2. +

    +The design of the constructor +

    +
    template <class InputIteratorB, class InputIteratorW> 
+piecewise_constant_distribution( InputIteratorB firstB, InputIteratorB lastB, 
+                                 InputIteratorW firstW);
+
    +

    +is unnecessarily unsafe, as there is no separate end-iterator given for the weights. I can't see +any performance or convenience reasons that would justify the risks inherent in such a function +interface, in particular the risk that input error might go unnoticed. +

    +
    3. +
+ +

+Possible resolution: I propose to add an InputIteratorW lastW argument to the interface. +

+ +

[ +Stephan Tolksdorf adds pre-Bellevue: +]

+ +
+In reply to the discussion in +N2424 +I'd like to make the same comments as for 736. +
+ +

[ +Bellevue: +]

+ + +
+In N2424. There is already precedent elsewhere in the library. Follows existing convention. NAD. +
+ + +

Proposed resolution:

+

+See N2424 +for the proposed resolution. +

+ +

[ +Stephan Tolksdorf adds pre-Bellevue: +]

+ + +
+

+In 26.5.8.5.2 [rand.dist.samp.pconst]: +

+ +

+Proposed wording a) +

+ +
+

+Change in para. 2 +

+
+Constructs a piecewise_constant_distribution object with n = 1, p0 = w0 = 1, +b0 = 0, and b1 = 1 +
+ +

+and change in para. 5 +

+ +
+A vector<result_type> whose size member returns n and whose operator[] +member returns pk +the weight wk as a double value +when invoked with argument k for k = 0, ..., n-1 +
+ +
+ +

+Proposed wording b) +

+ +
+

+Change both occurrences of +

+ +
+"piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB, + InputIteratorW firstW, InputIteratorW lastW) +
+ +

+and change in para. 3 +

+ +
+the length of the sequence w starting from firstW shall be at least n, +*firstW shall return a value w0 that is convertible to double, and any +wk for k >= n shall be ignored by the distribution +[firstW, lastW) shall form a sequence w of length n whose leading element +w0 shall be convertible to double +
+ +
+ + +
+ + + + + + +
+

738. Editorial issue in [rand.adapt.disc]/3

+

Section: 26.5.4.1 [rand.adapt.disc] Status: NAD Editorial + Submitter: Stephan Tolksdorf Opened: 2007-09-21 Last modified: 2010-10-29

+

View all other issues in [rand.adapt.disc].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Since the template parameter p and r are of type size_t, the member n in the class +exposition should have type size_t, too. +

+ + +

Proposed resolution:

+

+See N2424 +for the proposed resolution. +

+ + + + + +
+

739. Defect in [rand.util.canonical]/3

+

Section: 26.5.7.2 [rand.util.canonical] Status: NAD + Submitter: Stephan Tolksdorf Opened: 2007-09-21 Last modified: 2010-10-29

+

View all other issues in [rand.util.canonical].

+

View all issues with NAD status.

+

Discussion:

+

+The complexity of generate_canonical is specified to be "exactly k=max(1, ceil(b/log2 +R)) invocations of g". This terms involves a logarithm that is not rounded and hence can not (in +general) be computed at compile time. As this function template is performance critical, I propose +to replace ceil(b/log2 R) with ceil(b/floor(log2 R)). +

+ +

+See N2424 +for further discussion. +

+ +

[ +Bellevue: +]

+ + +
+In N2424. Close NAD as described there. +
+ + + +

Proposed resolution:

+

+See N2424 +for the proposed resolution. +

+ + + + + +
+

741. Const-incorrect get_deleter function for shared_ptr

+

Section: 20.9.10.2.11 [util.smartptr.getdeleter] Status: NAD + Submitter: Daniel Krügler Opened: 2007-09-27 Last modified: 2010-10-29

+

View all other issues in [util.smartptr.getdeleter].

+

View all issues with NAD status.

+

Discussion:

+

+The following issue was raised by Alf P. Steinbach in c.l.c++.mod: +

+ +

+According to the recent draft N2369, both the header memory synopsis +of 20.9 [memory] and 20.9.10.2.11 [util.smartptr.getdeleter] declare: +

+ +
template<class D, class T> D* get_deleter(shared_ptr<T> const& p);
+
+ +

+This allows to retrieve the pointer to a mutable deleter of a const +shared_ptr (if that owns one) and therefore contradicts the usual +philosophy that associated functors are either read-only (e.g. +key_comp or value_comp of std::map) or do at least reflect +the mutability of the owner (as seen for the both overloads of +unique_ptr::get_deleter). +Even the next similar counter-part of get_deleter - the two +overloads of function::target in the class template function +synopsis 20.8.14.2 [func.wrap.func] or in 20.8.14.2.5 [func.wrap.func.targ] - do +properly mirror the const-state of the owner. +

+ +Possible proposed resolutions: + +

+Replace the declarations of get_deleter in the header <memory> +synopsis of 20.9 [memory] and in 20.9.10.2.11 [util.smartptr.getdeleter] by one of the +following alternatives (A) or (B): +

+ +
    +
  1. +Provide only the immutable variant. This would reflect the +current praxis of container::get_allocator(), map::key_comp(), or +map::value_comp. + +
    template<class D, class T> const D* get_deleter(shared_ptr<T> const& p);
+
    +
    2. +
  2. +Just remove the function. +
    3. +
+ +

+Alberto Ganesh Barbati adds: +

+ +
    +
  1. +

    +Replace it with two functions: +

    +
    template <class D, class T> D get_deleter(shared_ptr<T> const&);
+template <class D, class T> bool has_deleter(shared_ptr<T> const&);
+
    + +

    +The first one would throw if D is the wrong type, while the latter would +never throw. This approach would reflect the current praxis of +use_facet/has_facet, with the twist of returning the deleter by value as +container::get_allocator() do. +

    +
    2. +
+ +

+Peter Dimov adds: +

+ +
+

+My favorite option is "not a defect". A, B and C break useful code. +

+
+ +

[ +Bellevue: +]

+ + +
+Concern this is similar to confusing "pointer to const" with "a constant pointer". +
+ + +

Proposed resolution:

+

+

+ + + + + +
+

745. copy_exception API slices.

+

Section: 18.8.5 [propagation] Status: NAD + Submitter: Alisdair Meredith Opened: 2007-10-10 Last modified: 2010-10-29

+

View other active issues in [propagation].

+

View all other issues in [propagation].

+

View all issues with NAD status.

+

Discussion:

+

+It could be I did not understand the design rationale, but I thought +copy_exception would produce an exception_ptr to the most-derived (dynamic) +type of the passed exception. Instead it slices, which appears to be less +useful, and a likely source of FAQ questions in the future. +

+

+(Peter Dimov suggests NAD) +

+ +

[ +Bellevue: +]

+ + +
+

+How could this be implemented in a way that the dynamic type is cloned? +

+

+The feature is designed to create an exception_ptr from an object whose +static type is identical to the dynamic type and thus there is no +slicing involved. +

+
+ + +

Proposed resolution:

+

+

+ + + + + +
+

747. We have 3 separate type traits to identify classes supporting no-throw operations

+

Section: 20.7.4.3 [meta.unary.prop] Status: NAD + Submitter: Alisdair Meredith Opened: 2007-10-10 Last modified: 2010-10-29

+

View all other issues in [meta.unary.prop].

+

View all issues with NAD status.

+

Discussion:

+

+We have 3 separate type traits to identify classes supporting no-throw +operations, which are very useful when trying to provide exception safety +guarantees. However, I'm not entirely clear on what the current wording +requires of a conforming implementation. To quote from +has_nothrow_default_constructor: +

+

+or T is a class type with a default constructor that is known not to throw +any exceptions +

+

+What level of magic do we expect to deduce if this is known? +

+

+E.g. +

+ +
struct test{
+ int x;
+ test() : x() {}
+};
+
+

+Should I expect a conforming compiler to + assert( has_nothrow_constructor<test>::value ) +

+

+Is this a QoI issue? +

+

+Should I expect to 'know' only if-and-only-if there is an inline definition +available? +

+

+Should I never expect that to be true, and insist that the user supplies an +empty throw spec if they want to assert the no-throw guarantee? +

+

+It would be helpful to maybe have a footnote explaining what is required, +but right now I don't know what to suggest putting in the footnote. +

+

+(agreement since is that trivial ops and explicit no-throws are required. +Open if QoI should be allowed to detect further) +

+ +

[ +Bellevue: +]

+ + +
+This looks like a QoI issue. +In the case of trivial and nothrow it is known. Static analysis of the program is definitely into QoI. +Move to OPEN. Need to talk to Core about this. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+

+This is QoI. +

+

+Move to NAD. +

+
+ + +

Proposed resolution:

+

+

+ + + + + +
+

748. The is_abstract type trait is defined by reference to 10.4.

+

Section: 20.7.4.3 [meta.unary.prop] Status: NAD + Submitter: Alisdair Meredith Opened: 2007-10-10 Last modified: 2010-10-29

+

View all other issues in [meta.unary.prop].

+

View all issues with NAD status.

+

Discussion:

+

+I am trying to decide is a pure virtual function is a necessary as well as +sufficient requirement to be classified as abstract? +

+

+For instance, is the following (non-polymorphic) type considered abstract? +

+
struct abstract {
+protected:
+ abstract(){}
+ abstract( abstract const & ) {}
+ ~abstract() {}
+};
+
+

+(Suggested that this may be NAD, with an editorial fix-up from Pete on the +core wording to make clear that abstract requires a pure virtual function) +

+ + +

Proposed resolution:

+

+Core has clarified that the definition abstract is adequate. Issue withdrawn by submitter. NAD. +

+ + + + + +
+

750. The current definition for is_convertible requires that the type be +implicitly convertible, so explicit constructors are ignored.

+

Section: 20.7.6 [meta.rel] Status: Dup + Submitter: Alisdair Meredith Opened: 2007-10-10 Last modified: 2010-10-29

+

View all other issues in [meta.rel].

+

View all issues with Dup status.

+

Duplicate of: 719

+

Discussion:

+

+With the pending arrival of explicit conversion functions though, I'm +wondering if we want an additional trait, is_explictly_convertible? +

+ +

[ +Bellevue: +]

+ + +
+Alisdair is considering preparing a paper listing a number of missing +type traits, and feels that it might be useful to handle them all +together rather than piecemeal. This would affect issue 719 and 750. +These two issues should move to OPEN pending AM paper on type traits. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Duplicate of 719 (for our purposes). +
+ +

[ +Addressed in N2947. +]

+ + + + +

Proposed resolution:

+ + + + + + +
+

751. change pass-by-reference members of vector<bool> to pass-by-value?

+

Section: 23.4.2 [vector.bool] Status: NAD + Submitter: Alisdair Meredith Opened: 2007-10-10 Last modified: 2010-10-29

+

View all other issues in [vector.bool].

+

View all issues with NAD status.

+

Discussion:

+

+A number of vector<bool> members take const bool& as arguments. +Is there any chance we could change them to pass-by-value or would I +be wasting everyone's time if wrote up an issue? +

+ +

[ +post Bellevue: +]

+ + +
+

+As we understand it, the original requester (Martin Sebor) would like +for implementations to be permitted to pass-by-value. Alisdair suggests +that if this is to be resolved, it should be resolved more generally, +e.g. in other containers as well. +

+

+We note that this would break ABI. However, we also suspect that this +might be covered under the "as-if" rule in section 1.9. +

+

+Many in the group feel that for vector<bool>, this is a "don't care", +and that at this point in the process it's not worth the bandwidth. +

+

+Issue 679 -- which was in ready status pre-Bellevue and is +now in the working paper -- is related to this, though not a duplicate. +

+

+Moving to Open with a task for Alisdair to craft a informative note to +be put whereever appropriate in the WP. This note would clarify places +where pass-by-const-ref can be transformed to pass-by-value under the +as-if rule. +

+
+ +

[ +San Francisco: +]

+ + +
+

+This is really a clause 17 issue, rather than something specific to vector<bool>. +

+

+Move to Open. Alisdair to provide a resolution. Alternately, Howard can +close this as NAD and then open a new issue to handle the general issue +(rather than the vector<bool> one). +

+

+Howard: Haven't yet opened new issue. Lacking wording for it. +

+
+ +

[ +2009-07 Frankfurt: +]

+ + +
+NAD. Insufficient motivation to make any changes. +
+ + +

Proposed resolution:

+

+

+ + + + + +
+

754. Ambiguous return clause for std::uninitialized_copy

+

Section: 20.9.8.2 [uninitialized.copy] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2007-10-15 Last modified: 2010-10-29

+

View all other issues in [uninitialized.copy].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+14882-2003, [lib.uninitialized.copy] is currently written as follows: +

+ +
+
template <class InputIterator, class ForwardIterator>
+  ForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
+                                     ForwardIterator result);
+
+
+

+-1- Effects: +

+
for (; first != last; ++result, ++first)
+  new (static_cast<void*>(&*result))
+    typename iterator_traits<ForwardIterator>::value_type(*first);
+
+

+-2- Returns: result +

+
+
+ +

+similarily for N2369, and its corresponding section +20.9.8.2 [uninitialized.copy]. +

+ +

+It's not clear to me what the return clause is supposed to mean, I see +two +possible interpretations: +

+ +
    +
  1. +The notion of result is supposed to mean the value given by the +function parameter result [Note to the issue editor: Please use italics for +result]. +This seems somewhat implied by recognizing that both the function +parameter +and the name used in the clause do have the same italic font. +
    2. +
  2. +The notion of "result" is supposed to mean the value of result +after the +preceding effects clause. This is in fact what all implementations I +checked +do (and which is probably it's intend, because it matches the +specification of std::copy). +
    3. +
+ +

+The problem is: I see nothing in the standard which grants that this +interpretation +is correct, specifically [lib.structure.specifications] or +17.5.1.4 [structure.specifications] +resp. do not clarify which "look-up" rules apply for names found in +the elements +of the detailed specifications - Do they relate to the corresponding +synopsis or +to the effects clause (or possibly other elements)? Fortunately most +detailed +descriptions are unambigious in this regard, e.g. this problem does +not apply +for std::copy. +

+ + + +

Proposed resolution:

+

+Change the wording of the return clause to say (20.9.8.2 [uninitialized.copy]): +

+ +
+

+-2- Returns: The value of result after effects have taken place. +

+
+ + +

[ +Bellevue: +]

+ + +
+Resolution: NAD editorial -- project editor to decide if change is +worthwhile. Concern is that there are many other places this might +occur. +
+ + + + +
+

756. Container adaptors push

+

Section: 23.5 [container.adaptors] Status: NAD Editorial + Submitter: Paolo Carlini Opened: 2007-10-31 Last modified: 2010-10-29

+

View all other issues in [container.adaptors].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+After n2369 we have a single push_back overload in the sequence containers, +of the "emplace" type. At variance with that, still in n2461, we have +two separate overloads, the C++03 one + one taking an rvalue reference +in the container adaptors. Therefore, simply from a consistency point of +view, I was wondering whether the container adaptors should be aligned +with the specifications of the sequence container themselves: thus have +a single push along the lines: +

+ +
template<typename... _Args>
+void
+push(_Args&&... __args)
+  { c.push_back(std::forward<_Args>(__args)...); }
+
+ +

[ +Related to 767 +]

+ + + +

Proposed resolution:

+

+Change 23.5.1.1 [queue.defn]: +

+ +
void push(const value_type& x) { c.push_back(x); }
+void push(value_type&& x) { c.push_back(std::move(x)); }
+template<class... Args> void push(Args&&... args) { c.push_back(std::forward<Args>(args)...); }
+
+ +

+Change 23.5.2 [priority.queue]: +

+ +
void push(const value_type& x) { c.push_back(x); }
+void push(value_type&& x) { c.push_back(std::move(x)); }
+template<class... Args> void push(Args&&... args) { c.push_back(std::forward<Args>(args)...); }
+
+ +

+Change 23.5.2.3 [priqueue.members]: +

+ +
+
void push(const value_type& x);
+
+
+

+Effects: +

+
c.push_back(x);
+push_heap(c.begin(), c.end(), comp);
+
+
+ +
template<class... Args> void push(value_type Args&&... x args);
+
+
+

+Effects: +

+
c.push_back(std::moveforward<Args>(x args)...);
+push_heap(c.begin(), c.end(), comp);
+
+
+
+ +

+Change 23.5.3.1 [stack.defn]: +

+ +
void push(const value_type& x) { c.push_back(x); }
+void push(value_type&& x) { c.push_back(std::move(x)); }
+template<class... Args> void push(Args&&... args) { c.push_back(std::forward<Args>(args)...); }
+
+ + + +

Rationale:

+

+Addressed by +N2680 Proposed Wording for Placement Insert (Revision 1). +

+ + + + + +
+

757. Typo in the synopsis of vector

+

Section: 23.4.1 [vector] Status: NAD Editorial + Submitter: Paolo Carlini Opened: 2007-11-04 Last modified: 2010-10-29

+

View all other issues in [vector].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In the synopsis 23.4.1 [vector], there is the signature: +

+ +
void insert(const_iterator position, size_type n, T&& x);
+
+ +

+instead of: +

+ +
iterator insert(const_iterator position, T&& x);
+
+ +

+23.4.1.4 [vector.modifiers] is fine. +

+ + + +

Proposed resolution:

+

+Change the synopsis in 23.4.1 [vector]: +

+ +
iterator insert(const_iterator position, const T& x); 
+iterator insert(const_iterator position, T&& x);
+void     insert(const_iterator position, size_type n, const T& x); 
+void     insert(const_iterator position, size_type n, T&& x);
+
+ + + + + +
+

760. The emplace issue

+

Section: 23.2 [container.requirements] Status: NAD Future + Submitter: Paolo Carlini Opened: 2007-11-11 Last modified: 2010-10-29

+

View all other issues in [container.requirements].

+

View all issues with NAD Future status.

+

Discussion:

+

+In an emplace member function the function parameter pack may be bound +to a priori unlimited number of objects: some or all of them can be +elements of the container itself. Apparently, in order to conform to the +blanket statement 23.2 [container.requirements]/11, the +implementation must check all of them for that possibility. A possible +solution can involve extending the exception in 23.2 [container.requirements]/12 also to the emplace member. As a +side note, the push_back and push_front member +functions are luckily not affected by this problem, can be efficiently +implemented anyway +

+ +

[ +Related to 767 +]

+ + +

[ +Bellevue: +]

+ + +
+

+The proposed addition (13) is partially redundant with the existing +paragraph 12. Why was the qualifier "rvalues" added to paragraph 12? Why +does it not cover subelements and pointers? +

+

+Resolution: Alan Talbot to rework language, then set state to Review. +

+
+ +

[ +2009-07 Frankfurt +]

+ + +
+

+The problem is broader than emplace. The LWG doesn't +feel that it knows how to write wording that prohibits all of the +problematic use cases at this time. +

+

+NAD Future. +

+
+ + + +

Proposed resolution:

+

+Add after 23.2 [container.requirements]/12: +

+ +
+

+-12- Objects passed to member functions of a container as rvalue +references shall not be elements of that container. No diagnostic +required. +

+

+ +-13- Objects bound to the function parameter pack of the +emplace member function shall not be elements or sub-objects of +elements of the container. No diagnostic required. + +

+ +
+ + + + + + +
+

763. Renaming emplace() overloads

+

Section: 23.2.4 [associative.reqmts] Status: NAD + Submitter: Sylvain Pion Opened: 2007-12-04 Last modified: 2010-10-29

+

View other active issues in [associative.reqmts].

+

View all other issues in [associative.reqmts].

+

View all issues with NAD status.

+

Discussion:

+

+The associative containers provide 2 overloads of emplace(): +

+ +
template <class... Args> pair<iterator, bool> emplace(Args&&... args);
+template <class... Args> iterator emplace(const_iterator position, Args&&... args);
+
+ +

+This is a problem if you mean the first overload while passing +a const_iterator as first argument. +

+ +

[ +Related to 767 +]

+ + +

[ +Bellevue: +]

+ + +
+
+

+This can be disambiguated by passing "begin" as the first argument in +the case when the non-default choice is desired. We believe that desire +will be rare. +

+

+Resolution: Change state to NAD. +

+ + +

Proposed resolution:

+

+Rename one of the two overloads. +For example to emplace_here, hint_emplace... +

+ + + + + +
+

764. equal_range on unordered containers should return a pair of local_iterators

+

Section: 23.2.5 [unord.req] Status: NAD + Submitter: Joe Gottman Opened: 2007-11-29 Last modified: 2010-10-29

+

View other active issues in [unord.req].

+

View all other issues in [unord.req].

+

View all issues with NAD status.

+

Discussion:

+

+ A major attribute of the unordered containers is that iterating +though them inside a bucket is very fast while iterating between buckets +can be much slower. If an unordered container has a low load factor, +iterating between the last iterator in one bucket and the next iterator, +which is in another bucket, is O(bucket_count()) which may be much +larger than O(size()). +

+

+ If b is an non-const unordered container of type B and k is an +object of it's key_type, then b.equal_range(k) currently returns +pair<B::iterator, B::iterator>. Consider the following code: +

+ +
B::iterator lb, ub;
+tie(lb, ub) = b.equal_range(k);
+for (B::iterator it = lb; it != ub; ++it) {
+        // Do something with *it
+}
+
+ +

+If b.equal_range(k) returns a non-empty range (i.e. b contains at least +on element whose key is equivalent to k), then every iterator in the +half-open range [lb, ub) will be in the same bucket, but ub will likely +either be in a different bucket or be equal to b.end(). In either case, +iterating between ub - 1 and ub could take a much longer time than +iterating through the rest of the range. +

+

+If instead of returning pair<iterator, iterator>, equal_range were to +return pair<local_iterator, local_iterator>, then ub (which, like lb, +would now be a local_iterator) could be guaranteed to always be in the +same bucket as lb. In the cases where currently ub is equal to b.end() +or is in a different bucket, ub would be equal to b.end(b.bucket(key)). + This would make iterating between lb and ub much faster, as every +iteration would be constant time. +

+ +

[ +Bellevue: +]

+ + +
+The proposed resolution breaks consistency with other container types +for dubious benefit, and iterators are already constant time. +
+ + + +

Proposed resolution:

+

+Change the entry for equal_range in Table 93 (23.2.5 [unord.req]) as follows: +

+ + + + + + + + + + + +
expression return type assertion/note pre/post-condition complexity
b.equal_range(k)pair<local_iterator,local_iterator>; pair<const_local_iterator,const_local_iterator> for const b.Returns a range containing all elements with keys equivalent to k. Returns make_pair(b.end(b.bucket(key)),b.end(b.bucket(key))) if no such elements exist.Average case Θ(b.count(k)). Worst case Θ(b.size()).
+ + + + + +
+

767. Forwarding and backward compatibility

+

Section: 23 [containers] Status: NAD Editorial + Submitter: Sylvain Pion Opened: 2007-12-28 Last modified: 2010-10-29

+

View all other issues in [containers].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Playing with g++'s C++0X mode, I noticed that the following +code, which used to compile: +

+ +
#include <vector>
+
+int main()
+{
+    std::vector<char *> v;
+    v.push_back(0);
+}
+
+ +

+now fails with the following error message: +

+ +
+.../include/c++/4.3.0/ext/new_allocator.h: In member function 'void __gnu_cxx::new_allocator<_Tp>::construct(_Tp*, _Args&& ...) [with _Args = int, _Tp = char*]': +.../include/c++/4.3.0/bits/stl_vector.h:707: instantiated from 'void std::vector<_Tp, _Alloc>::push_back(_Args&& ...) [with _Args = int, _Tp = char*, _Alloc = std::allocator<char*>]' +test.cpp:6: instantiated from here +.../include/c++/4.3.0/ext/new_allocator.h:114: error: invalid conversion from 'int' to 'char*' +
+ +

+As far as I know, g++ follows the current draft here. +

+

+Does the committee really intend to break compatibility for such cases? +

+ +

[ +Sylvain adds: +]

+ + +
+

+I just noticed that std::pair has the same issue. +The following now fails with GCC's -std=c++0x mode: +

+ +
#include <utility>
+
+int main()
+{
+   std::pair<char *, char *> p (0,0);
+}
+
+ +

+I have not made any general audit for such problems elsewhere. +

+
+ +

[ +Related to 756 +]

+ + +

[ +Bellevue: +]

+ + +
+

+Motivation is to handle the old-style int-zero-valued NULL pointers. +Problem: this solution requires concepts in some cases, which some users +will be slow to adopt. Some discussion of alternatives involving +prohibiting variadic forms and additional library-implementation +complexity. +

+

+Discussion of "perfect world" solutions, the only such solution put +forward being to retroactively prohibit use of the integer zero for a +NULL pointer. This approach was deemed unacceptable given the large +bodies of pre-existing code that do use integer zero for a NULL pointer. +

+

+Another approach is to change the member names. Yet another approach is +to forbid the extension in absence of concepts. +

+

+Resolution: These issues (756, 767, 760, 763) will be subsumed into a +paper to be produced by Alan Talbot in time for review at the 2008 +meeting in France. Once this paper is produced, these issues will be +moved to NAD. +

+
+ + + +

Proposed resolution:

+

+Add the following rows to Table 90 "Optional sequence container operations", 23.2.3 [sequence.reqmts]: +

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
expression return type assertion/note
pre-/post-condition		 container
+a.push_front(t) + +void + +a.insert(a.begin(), t)
+Requires: T shall be CopyConstructible. +		 +list, deque +
+a.push_front(rv) + +void + +a.insert(a.begin(), rv)
+Requires: T shall be MoveConstructible. +		 +list, deque +
+a.push_back(t) + +void + +a.insert(a.end(), t)
+Requires: T shall be CopyConstructible. +		 +list, deque, vector, basic_string +
+a.push_back(rv) + +void + +a.insert(a.end(), rv)
+Requires: T shall be MoveConstructible. +		 +list, deque, vector, basic_string +
+
+ +

+Change the synopsis in 23.3.2 [deque]: +

+ +
void push_front(const T& x);
+void push_front(T&& x);
+void push_back(const T& x);
+void push_back(T&& x);
+template <class... Args> requires Constructible<T, Args&&...> void push_front(Args&&... args);
+template <class... Args> requires Constructible<T, Args&&...> void push_back(Args&&... args);
+
+ +

+Change 23.3.2.3 [deque.modifiers]: +

+ +
void push_front(const T& x);
+void push_front(T&& x);
+void push_back(const T& x);
+void push_back(T&& x);
+template <class... Args> requires Constructible<T, Args&&...> void push_front(Args&&... args);
+template <class... Args> requires Constructible<T, Args&&...> void push_back(Args&&... args);
+
+ +

+Change the synopsis in 23.3.4 [list]: +

+ +
void push_front(const T& x);
+void push_front(T&& x);
+void push_back(const T& x);
+void push_back(T&& x);
+template <class... Args> requires Constructible<T, Args&&...> void push_front(Args&&... args);
+template <class... Args> requires Constructible<T, Args&&...> void push_back(Args&&... args);
+
+ +

+Change 23.3.4.3 [list.modifiers]: +

+ +
void push_front(const T& x);
+void push_front(T&& x);
+void push_back(const T& x);
+void push_back(T&& x);
+template <class... Args> requires Constructible<T, Args&&...> void push_front(Args&&... args);
+template <class... Args> requires Constructible<T, Args&&...> void push_back(Args&&... args);
+
+ +

+Change the synopsis in 23.4.1 [vector]: +

+ +
void push_back(const T& x);
+void push_back(T&& x);
+template <class... Args> requires Constructible<T, Args&&...> void push_back(Args&&... args);
+
+ +

+Change 23.4.1.4 [vector.modifiers]: +

+ +
void push_back(const T& x);
+void push_back(T&& x);
+template <class... Args> requires Constructible<T, Args&&...> void push_back(Args&&... args);
+
+ + + + +

Rationale:

+

+Addressed by +N2680 Proposed Wording for Placement Insert (Revision 1). +

+ +

+If there is still an issue with pair, Howard should submit another issue. +

+ + + + + +
+

773. issues with random

+

Section: 26.5.8.1 [rand.dist.uni] Status: NAD + Submitter: P.J. Plauger Opened: 2008-01-14 Last modified: 2010-10-29

+

View all other issues in [rand.dist.uni].

+

View all issues with NAD status.

+

Discussion:

+
    +
  1. +26.5.8.1.1 [rand.dist.uni.int] uniform_int constructor has changed the default +max constructor parameter from 9 (in TR1) to max(). The value +is arbitrary at best and shouldn't be lightly changed because +it breaks backward compatibility. +
    2. + +
  2. +26.5.8.1.1 [rand.dist.uni.int] uniform_int has a parameter param that you can +provide on construction or operator(), set, and get. But there +is not even a hint of what this might be for. +
    3. + +
  3. +26.5.8.1.2 [rand.dist.uni.real] uniform_real. Same issue as #2. +
    4. +
+ +

[ +Bellevue: +]

+ + +
+NAD. Withdrawn. +
+ + +

Proposed resolution:

+

+

+ + + + + +
+

784. unique_lock::release

+

Section: 30.4.2.2.3 [thread.lock.unique.mod] Status: NAD + Submitter: Constantine Sapuntzakis Opened: 2008-02-02 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+unique_lock::release will probably lead to many mistakes where people +call release instead of unlock. I just coded such a mistake using the +boost pre-1.35 threads library last week. +

+ +

+In many threading libraries, a call with release in it unlocks the +lock (e.g. ReleaseMutex in Win32, java.util.concurrent.Semaphore). +

+ +

+I don't call unique_lock::lock much at all, so I don't get to see the +symmetry between ::lock and ::unlock. I usually use the constructor to +lock the mutex. So I'm left to remember whether to call release or +unlock during the few times I need to release the mutex before the scope +ends. If I get it wrong, the compiler doesn't warn me. +

+ +

+An alternative name for release may be disown. +

+ +

+This might be a rare case where usability is hurt by consistency with +the rest of the C++ standard (e.g. std::auto_ptr::release). +

+ +

[ +Bellevue: +]

+ + +
+Change a name from release to disown. However prior art uses the release +name. Compatibility with prior art is more important that any possible +benefit such a change might make. We do not see the benefit for +changing. NAD +
+ + +

Proposed resolution:

+

+Change the synopsis in 30.4.2.2 [thread.lock.unique]: +

+ +
template <class Mutex> 
+class unique_lock 
+{ 
+public:
+   ...
+   mutex_type* release disown();
+   ...
+};
+
+ +

+Change 30.4.2.2.3 [thread.lock.unique.mod]: +

+ +
mutex_type *release disown();
+
+ + + + + +
+

785. Random Number Requirements in TR1

+

Section: TR1 5.1.4.5 [tr.rand.eng.disc], TR1 5.1.4.6 [tr.rand.eng.xor] Status: NAD + Submitter: John Maddock Opened: 2008-01-15 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+Table 16 of TR1 requires that all Pseudo Random Number generators have a +

+ +
seed(integer-type s)
+
+ +

+member function that is equivalent to: +

+ +
mygen = Generator(s)
+
+ +

+But the generators xor_combine and discard_block have no such seed member, only the +

+ +
template <class Gen>
+seed(Gen&);
+
+ +

+member, which will not accept an integer literal as an argument: something that appears to violate the intent of Table 16. +

+ +

+So... is this a bug in TR1? +

+ +

+This is a real issue BTW, since the Boost implementation does adhere to the requirements of Table 16, while at least one commercial implementation does not and follows a strict adherence to sections 5.1.4.5 and 5.1.4.6 instead. +

+ +

[ +Jens adds: +]

+ + +
+Both engines do have the necessary +constructor, therefore the omission of the seed() member +functions appears to be an oversight. +
+ +

[ +Post Summit Daniel adds: +]

+ + +
+Recommend NAD: xor_combine does no longer exist and discard_block[_engine] +has now the required seed overload accepting a result_type, which shall be an +unsigned integral type. +
+ +

[ +Batavia (2009-05): +]

+ +
+Move to NAD as recommended. +
+ + +

Proposed resolution:

+

+NAD Recommended. +

+ + + + + +
+

790. xor_combine::seed not specified

+

Section: X [rand.adapt.xor] Status: NAD + Submitter: P.J. Plauger Opened: 2008-02-09 Last modified: 2010-10-29

+

View all other issues in [rand.adapt.xor].

+

View all issues with NAD status.

+

Discussion:

+

+xor_combine::seed(result_type) and seed(seed_seq&) don't say what +happens to each of the sub-engine seeds. (Should probably do the same +to both, unlike TR1.) +

+ +

[ +Bellevue: +]

+ + +
+Overcome by the previous proposal. NAD mooted by resolution of 789. +
+ + + +

Proposed resolution:

+ + + + + +
+

791. piecewise_constant_distribution::densities has wrong name

+

Section: 26.5.8.5.2 [rand.dist.samp.pconst] Status: NAD + Submitter: P.J. Plauger Opened: 2008-02-09 Last modified: 2010-10-29

+

View all other issues in [rand.dist.samp.pconst].

+

View all issues with NAD status.

+

Discussion:

+

+piecewise_constant_distribution::densities() should be probabilities(), +just like discrete_distribution. (There's no real use for weights divided +by areas.) +

+ +

[ +Bellevue: +]

+ + +
+

+Fermilab does not agree with this summary. As defined in the equation in +26.4.8.5.2/4, the quantities are indeed probability densities not +probabilities. Because we view this distribution as a parameterization +of a *probability density function*, we prefer to work in terms of +probability densities. +

+ +

+We don't think this should be changed. +

+ +

+If there is a technical argument about why the implementation dealing +with these values can't be as efficient as one dealing with +probabilities, we might reconsider. We don't care about this one member +function being somewhat more or less efficient; we care about the size +of the distribution object and the speed of the calls to generate +variates. +

+
+ + + +

Proposed resolution:

+ +

+Change synopsis in 26.5.8.5.2 [rand.dist.samp.pconst]: +

+ +
template <class RealType = double> 
+class piecewise_constant_distribution 
+{ 
+public:
+    ...
+    vector<double> densities probabilities() const;
+    ...
+};
+
+ +

+Change 26.5.8.5.2 [rand.dist.samp.pconst]/6: +

+ +
vector<double> densities probabilities() const;
+
+ + + + + + +
+

793. discrete_distribution missing constructor

+

Section: 26.5.8.5.1 [rand.dist.samp.discrete] Status: NAD Editorial + Submitter: P.J. Plauger Opened: 2008-02-09 Last modified: 2010-10-29

+

View all other issues in [rand.dist.samp.discrete].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+discrete_distribution should have a constructor like: +

+ +
template<class _Fn>
+  discrete_distribution(result_type _Count, double _Low, double _High,
+                        _Fn& _Func);
+
+ +

+(Makes it easier to fill a histogram with function values over a range.) +

+ +

[ +Bellevue: +]

+ + +
+How do you specify the function so that it does not return negative +values? If you do it is a bad construction. This requirement is already +there. Where in each bin does one evaluate the function? In the middle. +Need to revisit tomorrow. +
+ +

[ +Sophia Antipolis: +]

+ + +
+

+Bill is not requesting this. +

+

+Marc Paterno: _Fn cannot return negative values at the points where the +function is sampled. It is sampled in the middle of each bin. _Fn cannot +return 0 everywhere it is sampled. +

+

+Jens: lambda expressions are rvalues +

+

+Add a library issue to provide an +initializer_list<double> constructor for +discrete_distribution. +

+

+Marc Paterno: dislikes reference for _Fn parameter. Make it pass-by-value (to use lambda), +use std::ref to wrap giant-state function objects. +

+

+Daniel: See random_shuffle, pass-by-rvalue-reference. +

+

+Daniel to draft wording. +

+
+ +

[ +Pre San Francisco, Daniel provided wording: +]

+ + +
+The here proposed changes of the WP refer to the current state of +N2691. +During the Sophia Antipolis meeting two different proposals came up +regarding the functor argument type, either by value or by rvalue-reference. +For consistence with existing conventions (state-free algorithms and the +general_pdf_distribution c'tor signature) the author decided to propose a +function argument that is provided by value. If severe concerns exists that +stateful functions would be of dominant relevance, it should be possible to +replace the two occurrences of Func by Func&& in this proposal as part +of an editorial process. +
+ + + +

Proposed resolution:

+ +

Non-concept version of the proposed resolution

+ +
    +
  1. +

    +In 26.5.8.5.1 [rand.dist.samp.discrete]/1, class discrete_distribution, just +before the member declaration +

    + +
    explicit discrete_distribution(const param_type& parm);
+
    + +

    +insert: +

    + + +
    template<typename Func>
+discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
+
    +
    2. + +
  2. +

    +Between p.4 and p.5 insert a series of new paragraphs as part of the +new member description:: +

    +
    template<typename Func>
+discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
+
    + +

    +Complexity: Exactly nf invocations of fw. +

    +

    +Requires: +

    +
      +
    1. +fw shall be callable with one argument of type double, and shall +return values of a type convertible to double;
      2. + +
    2. If nf > 0, the relation xmin < xmax shall hold, and for all sample values +xk, fw(xk) shall return a weight value wk that is non-negative, non-NaN, +and non-infinity;
      3. + +
    3. The following relations shall hold: nf ≥ 0, and 0 < S = w0+. . .+wn-1.
      4. + +
    + +

    +Effects: +

    +
      +
    1. If nf == 0, sets n = 1 and lets the sequence w have length n = 1 and + consist of the single value w0 = 1.
      2. + +
    2. +

      Otherwise, sets n = nf, deltax = (xmax - xmin)/n and xcent = xmin + +0.5 * deltax.

      +
      For each k = 0, . . . ,n-1, calculates:
+  xk = xcent + k * deltax
+  wk = fw(xk)
+
      +
      3. +
    3. +

      Constructs a discrete_distribution object with probabilities:

      +
      pk = wk/S  for k = 0, . . . , n-1.
+
      +
      4. +
    +
    +
    3. +
+ +

Concept version of the proposed resolution

+ + +
    +
  1. +

    +In 26.5.8.5.1 [rand.dist.samp.discrete]/1, class discrete_distribution, just +before the member declaration +

    + +
    explicit discrete_distribution(const param_type& parm);
+
    + +

    +insert: +

    + + +
    template<Callable<auto, double> Func>
+ requires Convertible<Func::result_type, double>
+discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
+
    +
    2. + +
  2. +

    +Between p.4 and p.5 insert a series of new paragraphs as part of the +new member description:: +

    +
    template<Callable<auto, double> Func>
+ requires Convertible<Func::result_type, double>
+discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
+
    + +

    +Complexity: Exactly nf invocations of fw. +

    +

    +Requires: +

    +
      +
    1. If nf > 0, the relation xmin < xmax shall hold, and for all sample values +xk, fw(xk) shall return a weight value wk that is non-negative, non-NaN, +and non-infinity;
      2. + +
    2. The following relations shall hold: nf ≥ 0, and 0 < S = w0+. . .+wn-1.
      3. + +
    + +

    +Effects: +

    +
      +
    1. If nf == 0, sets n = 1 and lets the sequence w have length n = 1 and + consist of the single value w0 = 1.
      2. + +
    2. +

      Otherwise, sets n = nf, deltax = (xmax - xmin)/n and xcent = xmin + +0.5 * deltax.

      +
      For each k = 0, . . . ,n-1, calculates:
+  xk = xcent + k * deltax
+  wk = fw(xk)
+
      +
      3. +
    3. +

      Constructs a discrete_distribution object with probabilities:

      +
      pk = wk/S  for k = 0, . . . , n-1.
+
      +
      4. +
    +
    +
    3. +
+ + + +

Rationale:

+Addressed by +N2836 "Wording Tweaks for Concept-enabled Random Number Generation in C++0X". + + + + + +
+

794. piecewise_constant_distribution missing constructor

+

Section: 26.5.8.5.2 [rand.dist.samp.pconst] Status: NAD Editorial + Submitter: P.J. Plauger Opened: 2008-02-09 Last modified: 2010-10-29

+

View all other issues in [rand.dist.samp.pconst].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+piecewise_constant_distribution should have a constructor like: +

+ +
template<class _Fn>
+   piecewise_constant_distribution(size_t _Count,
+            _Ty _Low, _Ty _High, _Fn& _Func);
+
+ +

+(Makes it easier to fill a histogram with function values over a range. +The two (reference 793) make a sensible replacement for +general_pdf_distribution.) +

+ +

[ +Sophia Antipolis: +]

+ + +
+

+Marc: uses variable width of bins and weight for each bin. This is not +giving enough flexibility to control both variables. +

+

+Add a library issue to provide an constructor taking an +initializer_list<double> and _Fn for piecewise_constant_distribution. +

+

+Daniel to draft wording. +

+
+ +

[ +Pre San Francisco, Daniel provided wording. +]

+ + +
+The here proposed changes of the WP refer to the current state of +N2691. +For reasons explained in 793, the author decided to propose a function +argument that is provided by value. The issue proposes a c'tor signature, +that does not take advantage of the full flexibility of +piecewise_constant_distribution, +because it restricts on a constant bin width, but the use-case seems to +be popular enough to justify it's introduction. +
+ + + +

Proposed resolution:

+ +

Non-concept version of the proposed resolution

+ +
    +
  1. +

    +In 26.5.8.5.2 [rand.dist.samp.pconst]/1, class piecewise_constant_distribution, +just before the member declaration +

    + +
    explicit piecewise_constant_distribution(const param_type& parm);
+
    +

    +insert: +

    +
    template<typename Func>
+piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
+
    +
    2. + +
  2. +

    +Between p.4 and p.5 insert a new sequence of paragraphs nominated +below as [p5_1], [p5_2], +[p5_3], and [p5_4] as part of the new member description: +

    + +
    template<typename Func>
+piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
+
    +
    +

    +[p5_1] Complexity: Exactly nf invocations of fw. +

    +

    +[p5_2] Requires: +

    +
      +
    1. fw shall be callable with one argument of type RealType, and shall +return values of a type convertible to double; +
      2. +
    2. +For all sample values xk defined below, fw(xk) shall return a weight +value wk that is non-negative, non-NaN, and non-infinity; +
      3. +
    3. +The following relations shall hold: xmin < xmax, and +0 < S = w0+. . .+wn-1. +
      4. +
    +

    +[p5_3] Effects: +

    +
      +
    1. +

      If nf == 0,

      +
        +
      1. +sets deltax = xmax - xmin, and
        2. +
      2. lets the sequence w have length n = 1 and consist of the single + value w0 = 1, and
        3. +
      3. lets the sequence b have length n+1 with b0 = xmin and + b1 = xmax +
        4. +
      +
      2. +
    2. +

      Otherwise,

      +
        +
      1. sets n = nf, deltax = (xmax - xmin)/n, + xcent = xmin + 0.5 * deltax, and +
        2. +

      2. lets the sequences w and b have length n and n+1, resp. and

        +
        for each k = 0, . . . ,n-1, calculates:
+  dxk = k * deltax
+  bk = xmin + dxk
+  xk = xcent + dxk
+  wk = fw(xk),
+
        +

        and

        +
        3. +
      3. sets bn = xmax
        4. +
      +
      3. +
    3. +

      +Constructs a piecewise_constant_distribution object with +the above computed sequence b as the interval boundaries +and with the probability densities: +

      +
      ρk = wk/(S * deltax)  for k = 0, . . . , n-1.
+
      +
      4. +
    +

    +[p5_4] [Note: In this context, the subintervals [bk, bk+1) are commonly + known as the bins of a histogram. -- end note] +

    +
    +
    +
    3. +
+ +

Concept version of the proposed resolution

+ +
    +
  1. +

    +In 26.5.8.5.2 [rand.dist.samp.pconst]/1, class piecewise_constant_distribution, +just before the member declaration +

    + +
    explicit piecewise_constant_distribution(const param_type& parm);
+
    +

    +insert: +

    +
    template<Callable<auto, RealType> Func>
+ requires Convertible<Func::result_type, double>
+piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
+
    +
    2. + +
  2. +

    +Between p.4 and p.5 insert a new sequence of paragraphs nominated +below as [p5_1], [p5_2], +[p5_3], and [p5_4] as part of the new member description: +

    + +
    template<Callable<auto, RealType> Func>
+ requires Convertible<Func::result_type, double>
+piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
+
    +
    +

    +[p5_1] Complexity: Exactly nf invocations of fw. +

    +

    +[p5_2] Requires: +

    +
      +
    1. +For all sample values xk defined below, fw(xk) shall return a weight +value wk that is non-negative, non-NaN, and non-infinity; +
      2. +
    2. +The following relations shall hold: xmin < xmax, and +0 < S = w0+. . .+wn-1. +
      3. +
    +

    +[p5_3] Effects: +

    +
      +
    1. +

      If nf == 0,

      +
        +
      1. +sets deltax = xmax - xmin, and
        2. +
      2. lets the sequence w have length n = 1 and consist of the single + value w0 = 1, and
        3. +
      3. lets the sequence b have length n+1 with b0 = xmin and + b1 = xmax +
        4. +
      +
      2. +
    2. +

      Otherwise,

      +
        +
      1. sets n = nf, deltax = (xmax - xmin)/n, + xcent = xmin + 0.5 * deltax, and +
        2. +

      2. lets the sequences w and b have length n and n+1, resp. and

        +
        for each k = 0, . . . ,n-1, calculates:
+  dxk = k * deltax
+  bk = xmin + dxk
+  xk = xcent + dxk
+  wk = fw(xk),
+
        +

        and

        +
        3. +
      3. sets bn = xmax
        4. +
      +
      3. +
    3. +

      +Constructs a piecewise_constant_distribution object with +the above computed sequence b as the interval boundaries +and with the probability densities: +

      +
      ρk = wk/(S * deltax)  for k = 0, . . . , n-1.
+
      +
      4. +
    +

    +[p5_4] [Note: In this context, the subintervals [bk, bk+1) are commonly + known as the bins of a histogram. -- end note] +

    +
    +
    +
    3. +
+ + + +

Rationale:

+Addressed by +N2836 "Wording Tweaks for Concept-enabled Random Number Generation in C++0X". + + + + + +
+

795. general_pdf_distribution should be dropped

+

Section: X [rand.dist.samp.genpdf] Status: Dup + Submitter: P.J. Plauger Opened: 2008-02-09 Last modified: 2010-10-29

+

View all other issues in [rand.dist.samp.genpdf].

+

View all issues with Dup status.

+

Duplicate of: 732

+

Discussion:

+

+general_pdf_distribution should be dropped. (It's a research topic in +adaptive numerical integration.) +

+ +

[ +Stephan Tolksdorf notes: +]

+ + +
+This appears to be a duplicate of 732. +
+ + +

Proposed resolution:

+ + + + + + +
+

796. ranlux48_base returns wrong value

+

Section: 26.5.5 [rand.predef] Status: NAD + Submitter: P.J. Plauger Opened: 2008-02-09 Last modified: 2010-10-29

+

View all other issues in [rand.predef].

+

View all issues with NAD status.

+

Discussion:

+

+The 10,000th value returned by ranlux48_base is supposed to be +61839128582725. We get 192113843633948. (Note that the underlying +generator was changed in Kona.) +

+ +

[ +Bellevue: +]

+ + +
+Submitter withdraws defect. +
+ + + +

Proposed resolution:

+

+Change 26.5.5 [rand.predef]/p5: +

+ +
+
typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> 
+        ranlux48_base; 
+
+
+Required behavior: The 10000th consecutive invocation of a default-constructed +object of type ranlux48_base shall produce the value +61839128582725 192113843633948. +
+
+ + + + + +
+

797. ranlux48 returns wrong value

+

Section: 26.5.5 [rand.predef] Status: NAD + Submitter: P.J. Plauger Opened: 2008-02-09 Last modified: 2010-10-29

+

View all other issues in [rand.predef].

+

View all issues with NAD status.

+

Discussion:

+

+The 10,000th value returned by ranlux48 is supposed to be +249142670248501. We get 88229545517833. (Note that this depends +on ranlux48_base.) +

+

[ +Bellevue: +]

+ + +
+Submitter withdraws defect. +
+ + + +

Proposed resolution:

+

+Change 26.5.5 [rand.predef]/p6: +

+ +
+
typedef discard_block_engine<ranlux48_base, 389, 11> 
+        ranlux48
+
+
+Required behavior: The 10000th consecutive invocation of a default-constructed +object of type ranlux48 shall produce the value +249142670248501 88229545517833. +
+
+ + + + + +
+

799. [tr.rand.eng.mers] and [rand.eng.mers]

+

Section: 26.5.3.2 [rand.eng.mers], TR1 5.1.4.2 [tr.rand.eng.mers] Status: NAD + Submitter: Stephan Tolksdorf Opened: 2008-02-18 Last modified: 2010-10-29

+

View all other issues in [rand.eng.mers].

+

View all issues with NAD status.

+

Discussion:

+

+TR1 5.1.4.2 [tr.rand.eng.mers](10) requires that operator== for the mersenne_twister +returns true if and only if the states of two mersenne_twisters, +consisting each of n integers between 0 and 2w - 1, are completely +equal. This is a contradiction with TR1 5.1.1 [tr.rand.req](3) because the given +definition of the state also includes the lower r bits of x(i-n), which +will never be used to generate a random number. If two mersenne_twisters +only differ in the lower bits of x(i-n) they will not compare equal, +although they will produce an identical sequence of random numbers. +

+ +

+26.5.3.2 [rand.eng.mers] in the latest C++ draft does not specify the behaviour +of operator== but uses a similar definition of the state and, just like +TR1 5.1.4.2 [tr.rand.eng.mers], requires the textual representation of a +mersenne_twister_engine to consist of Xi-n to Xi-1, including the +lower bits of Xi-n. This leads to two problems: First, the +unsuspecting implementer is likely to erroneously compare the lower r +bits of Xi-n in operator==. Second, if only the lower r bits differ, +two mersenne_twister_engines will compare equal (if correctly +implemented) but have different textual representations, which +conceptually is a bit ugly. +

+ +

+I propose that a paragraph or footnote is added to 26.5.3.2 [rand.eng.mers] which +clarifies that the lower r bits of Xi-n are not to be compared in +operator== and operator!=. It would only be consequent if furthermore +the specification for the textual respresentation was changed to +Xi-n bitand ((2w - 1) - (2r - 1)), Xi-(n-1), ..., Xi-1 or +something similar. +

+ +

+These changes would likely have no practical effect, but would allow an +implementation that does the right thing to be standard-conformant. +

+ +

[ +Bellevue: +]

+ + +
+

+Fermi Lab has no objection to the proposed change. However it feels that +more time is needed to check the details, which would suggest a change +to REVIEW. +

+

+Bill feels that this is NAD, not enough practical importance to abandon +the simple definition of equality, and someone would have to do a lot +more study to ensure that all cases are covered for a very small +payback. The submitter admits that "These changes would likely have no +practical effect,", and according to Plum's razor this means that it is +not worth the effort! +

+

+Revisted: Agree that the fact that there is no practical difference means that no change can be justified. +

+
+ + +

Proposed resolution:

+

+In 26.5.3.2 [rand.eng.mers]: +

+ +
+

+Insert at the end of para 2.: +

+ +
+[Note: The lower r bits of Xi-n do not influence +the state transition and hence should not be compared when comparing two +mersenne_twister_engine objects. -- end note] +
+ +

+In para 5. change: +

+ +
+The textual representation of xi consists of the values of +Xi-n bitand ((2w - 1) - (2r - 1)), Xi-(n-1), +..., Xi-1, in that order. +
+
+ + + + + +
+

800. Issues in 26.4.7.1 [rand.util.seedseq](6)

+

Section: 26.5.7.1 [rand.util.seedseq] Status: NAD Editorial + Submitter: Stephan Tolksdorf Opened: 2008-02-18 Last modified: 2010-10-29

+

View all other issues in [rand.util.seedseq].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The for-loop in the algorithm specification has n iterations, where n is +defined to be end - begin, i.e. the number of supplied w-bit quantities. +Previous versions of this algorithm and the general logic behind it +suggest that this is an oversight and that in the context of the +for-loop n should be the number of full 32-bit quantities in b (rounded +upwards). If w is 64, the current algorithm throws away half of all bits +in b. If w is 16, the current algorithm sets half of all elements in v +to 0. +

+ +

+There are two more minor issues: +

+ + + +

[ +Bellevue: +]

+ + +
+Move to OPEN Bill will try to propose a resolution by the next meeting. +
+ +

[ +post Bellevue: Bill provided wording. +]

+ + +

+This issue is made moot if 803 is accepted. +

+ + + +

Proposed resolution:

+

+Replace 26.5.7.1 [rand.util.seedseq] paragraph 6 with: +

+ +
+

+Effects: Constructs a seed_seq object by effectively concatenating the +low-order u bits of each of the elements of the supplied sequence [begin, +end) +in ascending order of significance to make a (possibly very large) unsigned +binary number b having a total of n bits, and then carrying out the +following +algorithm: +

+ +
for( v.clear(); n > 0; n -= 32 )
+   v.push_back(b mod 232), b /= 232;
+
+
+ + +

Rationale:

+Addressed by +N2836 "Wording Tweaks for Concept-enabled Random Number Generation in C++0X". + + + + + +
+

802. knuth_b returns wrong value

+

Section: 26.5.5 [rand.predef] Status: NAD + Submitter: P.J. Plauger Opened: 2008-02-20 Last modified: 2010-10-29

+

View all other issues in [rand.predef].

+

View all issues with NAD status.

+

Discussion:

+

+The 10,000th value returned by knuth_b is supposed to be +1112339016. We get 2126698284. +

+ + +

Proposed resolution:

+

+Change 26.5.5 [rand.predef]/p8: +

+ +
+
typedef shuffle_order_engine<minstd_rand0, 256> 
+        knuth_b; 
+
+
+Required behavior: The 10000th consecutive invocation of a default-constructed +object of type knuth_b shall produce the value +1112339016 2126698284. +
+
+ + +

[ +Bellevue: Submitter withdraws defect. "We got the wrong value for entirely the right reasons". NAD. +]

+ + + + + +
+

803. Simplification of seed_seq::seq_seq

+

Section: 26.5.7.1 [rand.util.seedseq] Status: NAD Editorial + Submitter: Charles Karney Opened: 2008-02-22 Last modified: 2010-10-29

+

View all other issues in [rand.util.seedseq].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+seed_seq(InputIterator begin, InputIterator end); constructs a seed_seq +object repacking the bits of supplied sequence [begin, end) into a +32-bit vector. +

+

+This repacking triggers several problems: +

+
    +
  1. +Distinctness of the output of seed_seq::generate required the +introduction of the initial "if (w < 32) v.push_back(n);" (Otherwise +the unsigned short vectors [1, 0] and [1] generate the same sequence.) +
    2. +
  2. +Portability demanded the introduction of the template parameter u. +(Otherwise some sequences could not be obtained on computers where no +integer types are exactly 32-bits wide.) +
    3. +
  3. +The description and algorithm have become unduly complicated. +
    4. +
+

+I propose simplifying this seed_seq constructor to be "32-bit only". +Despite it's being simpler, there is NO loss of functionality (see +below). +

+

+Here's how the description would read +

+
+

+26.5.7.1 [rand.util.seedseq] Class seed_seq +

+ +
+
template<class InputIterator>
+  seed_seq(InputIterator begin, InputIterator end);
+
+
+

+5 Requires: NO CHANGE +

+

+6 Effects: Constructs a seed_seq object by +

+
+
for (InputIterator s = begin; s != end; ++s)
+   v.push_back((*s) mod 2^32);
+
+
+
+
+
+ +

+Discussion: +

+

+The chief virtues here are simplicity, portability, and generality. +

+ +

+Arguments (and counter-arguments) against making this change (and +retaining the +n2461 +behavior) are: +

+ + +

+Note: this proposal renders moot issues 782 and 800. +

+ +

[ +Bellevue: +]

+ + +
+Walter needs to ask Fermilab for guidance. Defer till tomorrow. Bill likes the proposed resolution. +
+ +

[ +Sophia Antipolis: +]

+ + +
+

+Marc Paterno wants portable behavior between 32bit and 64bit machines; +we've gone to significant trouble to support portability of engines and +their values. +

+

+Jens: the new algorithm looks perfectly portable +

+

+Marc Paterno to review off-line. +

+

+Modify the proposed resolution to read "Constructs a seed_seq object by the following algorithm ..." +

+

+Disposition: move to review; unanimous consent. +

+

+(moots 782 and 800) +

+
+ + + +

Proposed resolution:

+

+Change 26.5.7.1 [rand.util.seedseq]: +

+ +
+
template<class InputIterator, 
+  size_t u = numeric_limits<iterator_traits<InputIterator>::value_type>::digits>
+  seed_seq(InputIterator begin, InputIterator end);
+
+
+

+-5- Requires: InputIterator shall satisfy the requirements of an input iterator (24.1.1) +such that iterator_traits<InputIterator>::value_type shall denote an integral type. +

+

+-6- Constructs a seed_seq object by the following algorithm rearranging some or all of the bits of the supplied sequence +[begin,end) of w-bit quantities into 32-bit units, as if by the following: +

+

+First extract the rightmost u bits from each of the n = end +- begin elements of the supplied sequence and concatenate all the +extracted bits to initialize a single (possibly very large) unsigned +binary number, b = ∑n-1i=0 (begin[i] +mod 2u) · 2w·i (in which the bits of each begin[i] +are treated as denoting an unsigned quantity). Then carry out +the following algorithm: +

+

+v.clear(); 
+if ($w$ < 32) 
+  v.push_back($n$); 
+for( ; $n$ > 0; --$n$) 
+  v.push_back(b mod 232), b /= 232;
+
+
+

+for (InputIterator s = begin; s != end; ++s)
+   v.push_back((*s) mod 232);
+
+
+
+
+ + +

Rationale:

+Addressed by +N2836 "Wording Tweaks for Concept-enabled Random Number Generation in C++0X". + + + + + +
+

812. unsolicited multithreading considered harmful?

+

Section: 25.4.1 [alg.sort] Status: NAD Editorial + Submitter: Paul McKenney Opened: 2008-02-27 Last modified: 2010-10-29

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Multi-threading is a good thing, but unsolicited multi-threading can +potentially be harmful. For example, sort() performance might be +greatly increased via a multithreaded implementation. However, such +a multithreaded implementation could result in concurrent invocations +of the user-supplied comparator. This would in turn result in problems +given a caching comparator that might be written for complex sort keys. +Please note that this is not a theoretical issue, as multithreaded +implementations of sort() already exist. +

+

+Having a multithreaded sort() available is good, but it should not +be the default for programs that are not explicitly multithreaded. +Users should not be forced to deal with concurrency unless they have +asked for it. +

+ +

[ +This may be covered by +N2410 +Thread-Safety in the Standard Library (Rev 1). +]

+ + + +

Proposed resolution:

+

+

+ + +

Rationale:

+This is already covered by 17.6.5.6/20 in N2723. + + + + + +
+

822. Object with explicit copy constructor no longer CopyConstructible

+

Section: 20.2.1 [utility.arg.requirements] Status: NAD + Submitter: James Kanze Opened: 2008-04-01 Last modified: 2010-11-29

+

View all other issues in [utility.arg.requirements].

+

View all issues with NAD status.

+

Discussion:

+

+I just noticed that the following program is legal in C++03, but +is forbidden in the current draft: +

+ +
#include <vector>
+#include <iostream>
+
+class Toto
+{
+public:
+    Toto() {}
+    explicit Toto( Toto const& ) {}
+} ;
+
+int
+main()
+{
+    std::vector< Toto > v( 10 ) ;
+    return 0 ;
+}
+
+ +

+Is this change intentional? (And if so, what is the +justification? I wouldn't call such code good, but I don't see +any reason to break it unless we get something else in return.) +

+ +

[ +San Francisco: +]

+ + +
+The subgroup that looked at this felt this was a good change, but it may +already be handled by incoming concepts (we're not sure). +
+ +

[ +Post Summit: +]

+ + +
+

+Alisdair: Proposed resolution kinda funky as these tables no longer +exist. Move from direct init to copy init. Clarify with Doug, recommends +NAD. +

+

+Walter: Suggest NAD via introduction of concepts. +

+

+Recommend close as NAD. +

+
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Need to look at again without concepts. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+

+Move to Ready with original proposed resolution. +

+

[Howard: Original proposed resolution restored.]

+ +
+ +

[ +2010-11 Batavia: +]

+ +

+This issue was re-reviewed in relation to [another issue, number to follow], +and the verdict was reversed. Explicit copy and move constructors are rare +beasts, and the ripple effect of this fix was far more difficult to contain +than simply saying such types do not satisfy the MoveConstructible +and CopyConstructible requirements. +

+ +
+

+In 20.2.1 [utility.arg.requirements] change Table 33: MoveConstructible requirements [moveconstructible]: +

+ +
+ + + + + + + + + + +
expressionpost-condition
T t(rv) = rvt is equivalent to the value of rv before the construction
...
+
+ +

+In 20.2.1 [utility.arg.requirements] change Table 34: CopyConstructible requirements [copyconstructible]: +

+ +
+ + + + + + + + + + +
expressionpost-condition
T t(u) = uthe value of u is unchanged and is equivalent to t
...
+
+ +
+ + + +

Proposed resolution:

+Resolved by n3215. + + + + + +
+

825. Missing rvalues reference stream insert/extract operators?

+

Section: 19.5.2.1 [syserr.errcode.overview], 20.9.10.2.8 [util.smartptr.shared.io], 22.4.8 [facets.examples], 20.5.4 [bitset.operators], 26.4.6 [complex.ops], 27.6 [stream.buffers], 28.9 [re.submatch] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2008-04-10 Last modified: 2010-10-29

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses UK 220

+ +

+Should the following use rvalues references to stream in insert/extract +operators? +

+ + + +

[ +Sophia Antipolis +]

+ + +
+Agree with the idea in the issue, Alisdair to provide wording. +
+ +

[ +Daniel adds 2009-02-14: +]

+ + +
+The proposal given in the paper +N2831 +apparently resolves this issue. +
+ +

[ +Batavia (2009-05): +]

+ +
+

+The cited paper is an earlier version of +N2844, +which changed the rvalue reference binding rules. +That paper includes generic templates +operator<< and operator>> +that adapt rvalue streams. +

+

+We therefore agree with Daniel's observation. +Move to NAD Editorial. +

+
+ + +

Proposed resolution:

+

+

+ + + + + +
+

826. Equivalent of %'d, or rather, lack thereof?

+

Section: 22.4.2.2 [locale.nm.put] Status: NAD + Submitter: Peter Dimov Opened: 2008-04-07 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+In the spirit of printf vs iostream... +

+ +

+POSIX printf says that %'d should insert grouping characters (and the +implication is that in the absence of ' no grouping characters are +inserted). The num_put facet, on the other hand, seems to always insert +grouping characters. Can this be considered a defect worth fixing for +C++0x? Maybe ios_base needs an additional flag? +

+ +

[ +Pablo Halpern: +]

+ + +
+I'm not sure it constitutes a defect, but I would be in favor of adding +another flag (and corresponding manipulator). +
+ +

[ +Martin Sebor: +]

+ + +
+I don't know if it qualifies as a defect but I agree that there +should be an easy way to control whether the thousands separator +should or shouldn't be inserted. A new flag would be in line with +the current design of iostreams (like boolalpha, showpos, or +showbase). +
+ +

[ +Sophia Antipolis: +]

+ + +
+This is not a part of C99. LWG suggests submitting a paper may be appropriate. +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

828. Static initialization for std::mutex?

+

Section: 30.4.1.2.1 [thread.mutex.class] Status: NAD Editorial + Submitter: Peter Dimov Opened: 2008-04-18 Last modified: 2010-10-29

+

View all other issues in [thread.mutex.class].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+[Note: I'm assuming here that 3.6.2 [basic.start.init]/1 will be fixed.] +

+

+Currently std::mutex doesn't support static initialization. This is a +regression with respect to pthread_mutex_t, which does. I believe that +we should strive to eliminate such regressions in expressive power where +possible, both to ease migration and to not provide incentives to (or +force) people to forego the C++ primitives in favor of pthreads. +

+ +

[ +Sophia Antipolis: +]

+ + +
+

+We believe this is implementable on POSIX, because the initializer-list +feature and the constexpr feature make this work. Double-check core +language about static initialization for this case. Ask core for a core +issue about order of destruction of statically-initialized objects wrt. +dynamically-initialized objects (should come afterwards). Check +non-POSIX systems for implementability. +

+

+If ubiquitous implementability cannot be assured, plan B is to introduce +another constructor, make this constexpr, which is +conditionally-supported. To avoid ambiguities, this new constructor needs +to have an additional parameter. +

+
+ +

[ +Post Summit: +]

+ + +
+

+Jens: constant initialization seems to be ok core-language wise +

+

+Consensus: Defer to threading experts, in particular a Microsoft platform expert. +

+

+Lawrence to send e-mail to Herb Sutter, Jonathan Caves, Anthony Wiliams, +Paul McKenney, Martin Tasker, Hans Boehm, Bill Plauger, Pete Becker, +Peter Dimov to alert them of this issue. +

+

+Lawrence: What about header file shared with C? The initialization +syntax is different in C and C++. +

+

+Recommend Keep in Review +

+
+ +

[ +Batavia (2009-05): +]

+ +
+Keep in Review status pending feedback from members of the Concurrency subgroup. +
+ +

[ +See related comments from Alisdiar and Daniel in 827. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2994. +
+ + + +

Proposed resolution:

+

+Change 30.4.1.2.1 [thread.mutex.class]: +

+ +
class mutex {
+public:
+  constexpr mutex();
+  ...
+
+ + + + + +
+

830. Incomplete list of char_traits specializations

+

Section: 21.2 [char.traits] Status: NAD Editorial + Submitter: Dietmar Kühl Opened: 2008-04-23 Last modified: 2010-10-29

+

View all other issues in [char.traits].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+ Paragraph 4 of 21.2 [char.traits] mentions that this + section specifies two specializations (char_traits<char> + and (char_traits<wchar_t>). However, there are actually + four specializations provided, i.e. in addition to the two above also + char_traits<char16_t> and char_traits<char32_t>). + I guess this was just an oversight and there is nothing wrong with just + fixing this. +

+ +

[ +Alisdair adds: +]

+ +
+char_traits< char16/32_t > +should also be added to <ios_fwd> in 27.3 [iostream.forward], and all the specializations +taking a char_traits parameter in that header. +
+ +

[ +Sophia Antipolis: +]

+ + +
+

+Idea of the issue is ok. +

+

+Alisdair to provide wording, once that wording arrives, move to review. +

+ +
+ +

[ +2009-05-04 Alisdair adds: +]

+ + +
+

+The main point of the issue was resolved editorially in +N2723, +so we are +close to NAD Editorial. +However, exploring the issue we found a second tweak was necessary for +<iosfwd> and that is still outstanding, so here are the words I am long +overdue delivering: +

+ +

[ +Howard: I've put Alisdair's words into the proposed wording section and +moved the issue to Review. +]

+ + +
+ +

[ +Original proposed wording. +]

+ + +
+ +

+ Replace paragraph 4 of 21.2 [char.traits] by: +

+
+

+ This subclause specifies a struct template, char_traits<charT>, + and four explicit specializations of it, char_traits<char>, + char_traits<char16_t>, char_traits<char32_t>, and + char_traits<wchar_t>, all of which appear in the header + <string> and satisfy the requirements below. +

+
+
+ +

[ +Batavia (2009-05): +]

+ +
+We agree. Move to NAD Editorial. +
+ + +

Proposed resolution:

+

+Change Forward declarations 27.3 [iostream.forward]: +

+ +
+

+Header <iosfwd> synopsis +

+
namespace std {
+   template<class charT> class char_traits;
+   template<> class char_traits<char>;
+   template<> class char_traits<char16_t>;
+   template<> class char_traits<char32_t>;
+   template<> class char_traits<wchar_t>;
+...
+}
+
+
+ + + + + +
+

831. wrong type for not_eof()

+

Section: 21.2.3 [char.traits.specializations] Status: NAD Editorial + Submitter: Dietmar Kühl Opened: 2008-04-23 Last modified: 2010-10-29

+

View all other issues in [char.traits.specializations].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+ In Table 56 (Traits requirements) the not_eof() member function + is using an argument of type e which denotes an object of + type X::int_type. However, the specializations in + 21.2.3 [char.traits.specializations] all use char_type. + This would effectively mean that the argument type actually can't + represent EOF in the first place. I'm pretty sure that the type used + to be int_type which is quite obviously the only sensible + argument. +

+

+ This issue is close to being editorial. I suspect that the proposal + changing this section to include the specializations for char16_t + and char32_t accidentally used the wrong type. +

+ + +

Proposed resolution:

+

+ In 21.2.3.1 [char.traits.specializations.char], + 21.2.3.2 [char.traits.specializations.char16_t], + 21.2.3.3 [char.traits.specializations.char32_t], and + [char.traits.specializations.wchar_t] correct the + argument type from char_type to int_type. +

+ + +

Rationale:

+Already fixed in WP. + + + + + +
+

832. Applying constexpr to System error support

+

Section: 19.5 [syserr] Status: NAD + Submitter: Beman Dawes Opened: 2008-05-14 Last modified: 2010-10-29

+

View all other issues in [syserr].

+

View all issues with NAD status.

+

Discussion:

+

+Initialization of objects of class error_code +(19.5.2 [syserr.errcode]) and class +error_condition (19.5.3 [syserr.errcondition]) can be made simpler and more reliable by use of +the new constexpr feature +[N2349] +of C++0x. Less code will need to be +generated for both library implementations and user programs when +manipulating constant objects of these types. +

+ +

+This was not proposed originally because the constant expressions +proposal was moving into the standard at about the same time as the +Diagnostics Enhancements proposal +[N2241], +and it wasn't desirable to +make the later depend on the former. There were also technical concerns +as to how constexpr would apply to references. Those concerns are now +resolved; constexpr can't be used for references, and that fact is +reflected in the proposed resolution. +

+ +

+Thanks to Jens Maurer, Gabriel Dos Reis, and Bjarne Stroustrup for clarification of constexpr requirements. +

+ +

+LWG issue 804 is related in that it raises the question of whether the +exposition only member cat_ of class error_code (19.5.2 [syserr.errcode]) and class +error_condition (19.5.3 [syserr.errcondition]) should be presented as a reference or pointer. +While in the context of 804 that is arguably an editorial question, +presenting it as a pointer becomes more or less required with this +proposal, given constexpr does not play well with references. The +proposed resolution thus changes the private member to a pointer, which +also brings it in sync with real implementations. +

+ +

[ +Sophia Antipolis: +]

+ + +
+On going question of extern pointer vs. inline functions for interface. +
+ +

[ +Pre-San Francisco: +]

+ + +
+

+Beman Dawes reports that this proposal is unimplementable, and thus NAD. +

+

+Implementation would require constexpr objects of classes derived +from class error_category, which has virtual functions, and that is +not allowed by the core language. This was determined when trying to +implement the proposal using a constexpr enabled compiler provided +by Gabriel Dos Reis, and subsequently verified in discussions with +Gabriel and Jens Maurer. +

+ +
+ + +

Proposed resolution:

+

+The proposed wording assumes the LWG 805 proposed wording has been +applied to the WP, resulting in the former posix_category being renamed +generic_category. If 805 has not been applied, the names in this +proposal must be adjusted accordingly. +

+ +

+Change 19.5.1.1 [syserr.errcat.overview] Class +error_category overview error_category synopsis as +indicated: +

+ +
const error_category& get_generic_category();
+const error_category& get_system_category();
+
+static extern const error_category&* const generic_category = get_generic_category();
+static extern const error_category&* const native_category system_category = get_system_category();
+
+ +

+Change 19.5.1.5 [syserr.errcat.objects] Error category objects as indicated: +

+ +
+
extern const error_category&* const get_generic_category();
+
+

+Returns: A reference generic_category shall point +to an a statically initialized object of a type derived from +class error_category. +

+ +

+Remarks: The object's default_error_condition and equivalent virtual +functions shall behave as specified for the class error_category. The +object's name virtual function shall return a pointer to the string +"GENERIC". +

+ +
extern const error_category&* const get_system_category();
+
+ +

+Returns: A reference system_category shall point +to an a statically +initialized object of a type derived from class error_category. +

+ +

+Remarks: The object's equivalent virtual functions shall behave as +specified for class error_category. The object's name virtual function +shall return a pointer to the string "system". The object's +default_error_condition virtual function shall behave as follows: +

+ +

+If the argument ev corresponds to a POSIX errno value posv, the function +shall return error_condition(posv, generic_category). Otherwise, the +function shall return error_condition(ev, system_category). What +constitutes correspondence for any given operating system is +unspecified. [Note: The number of potential system error codes is large +and unbounded, and some may not correspond to any POSIX errno value. +Thus implementations are given latitude in determining correspondence. +-- end note] +

+
+ +

+Change 19.5.2.1 [syserr.errcode.overview] Class error_code overview as indicated: +

+ +
class error_code {
+public:
+  ...;
+  constexpr error_code(int val, const error_category&* cat);
+  ...
+  void assign(int val, const error_category&* cat);
+  ...
+  const error_category&* category() const;
+  ...
+private:
+  int val_;                    // exposition only
+  const error_category&* cat_; // exposition only
+
+ +

+Change 19.5.2.2 [syserr.errcode.constructors] Class error_code constructors as indicated: +

+ +
+
constexpr error_code(int val, const error_category&* cat);
+
+

+Effects: Constructs an object of type error_code. +

+

+Postconditions: val_ == val and cat_ == cat. +

+

+Throws: Nothing. +

+
+ +

+Change 19.5.2.3 [syserr.errcode.modifiers] Class error_code modifiers as indicated: +

+ +
+
void assign(int val, const error_category&* cat);
+
+

+Postconditions: val_ == val and cat_ == cat. +

+

+Throws: Nothing. +

+
+ +

+Change 19.5.2.4 [syserr.errcode.observers] Class error_code observers as indicated: +

+ +
+
const error_category&* category() const;
+
+ +

+Returns: cat_. +

+

+Throws: Nothing. +

+
+ +

+Change 19.5.3.1 [syserr.errcondition.overview] Class error_condition overview as indicated: +

+ +
+
class error_condition {
+public:
+  ...;
+  constexpr error_condition(int val, const error_category&* cat);
+  ...
+  void assign(int val, const error_category&* cat);
+  ...
+  const error_category&* category() const;
+  ...
+private:
+  int val_;                    // exposition only
+  const error_category&* cat_; // exposition only
+
+
+ +

+Change 19.5.3.2 [syserr.errcondition.constructors] Class error_condition constructors as indicated: +

+ +
+
constexpr error_condition(int val, const error_category&* cat);
+
+

+Effects: Constructs an object of type error_condition. +

+

+Postconditions: val_ == val and cat_ == cat. +

+

+Throws: Nothing. +

+
+ +

+Change 19.5.3.3 [syserr.errcondition.modifiers] Class error_condition modifiers as indicated: +

+ +
+
void assign(int val, const error_category&* cat);
+
+

+Postconditions: val_ == val and cat_ == cat. +

+

+Throws: Nothing. +

+
+ +

+Change 19.5.3.4 [syserr.errcondition.observers] Class error_condition observers as indicated: +

+ +
+
const error_category&* category() const;
+
+

+Returns: cat_. +

+

+Throws: Nothing. +

+
+ +

+Throughout 19.5 [syserr] System error support, change "category()." to "category()->". +Appears approximately six times. +

+ +

+[Partially Editorial] In 19.5.4 [syserr.compare] Comparison operators, +paragraphs 2 and 4, change "category.equivalent(" to +"category()->equivalent(". +

+ +

+Change 19.5.6.1 [syserr.syserr.overview] Class system_error overview as indicated: +

+ +
public:
+  system_error(error_code ec, const string& what_arg);
+  system_error(error_code ec);
+  system_error(int ev, const error_category&* ecat,
+      const string& what_arg);
+  system_error(int ev, const error_category&* ecat);
+
+ +

+Change 19.5.6.2 [syserr.syserr.members] Class system_error members as indicated: +

+ +
+
system_error(int ev, const error_category&* ecat, const string& what_arg);
+
+
+

+Effects: Constructs an object of class system_error. +

+

+Postconditions: code() == error_code(ev, ecat) and +strcmp(runtime_error::what(), what_arg.c_str()) == 0. +

+
+ +
system_error(int ev, const error_category&* ecat);
+
+
+

+Effects: Constructs an object of class system_error. +

+

+Postconditions: code() == error_code(ev, ecat) and +strcmp(runtime_error::what(), "") == 0. +

+
+
+ + + +

Rationale:

+

[ +San Francisco: +]

+ + +
+NAD because Beman said so. +
+ + + + + +
+

833. Freestanding implementations header list needs review for C++0x

+

Section: 17.6.1.3 [compliance] Status: NAD + Submitter: Beman Dawes Opened: 2008-05-14 Last modified: 2010-10-29

+

View all other issues in [compliance].

+

View all issues with NAD status.

+

Discussion:

+

+Once the C++0x standard library is feature complete, the LWG needs to +review 17.6.1.3 [compliance] Freestanding implementations header list to +ensure it reflects LWG consensus. +

+ +

[ +San Francisco: +]

+ + +
+

+This is a placeholder defect to remind us to review the table once we've +stopped adding headers to the library. +

+

+Three new headers that need to be added to the list: +

+
<initializer_list> <concept> <iterator_concepts>
+
+

+<iterator_concepts>, in particular, has lots of stuff +that isn't needed, so maybe the stuff that is needed should be broken +out into a separate header. +

+

+Robert: What about reference_closure? It's currently in +<functional>. +

+
+ +

[ +Post Summit Daniel adds: +]

+ + +
+
    +
  1. +The comment regarding reference_closure seems moot since it was just +recently decided to remove that. +
    2. +
  2. +A reference to proposal +N2814 +("Fixing freestanding") should be added. This +paper e.g. proposes to add only <initializer_list> to the include list +of freestanding. +
    3. +
+
+ +

[ +2009-07 Frankfurt: +]

+ + +
+

+Addressed by paper +N2814. +

+

+Move to NAD. +

+
+ + + +

Proposed resolution:

+ + + + + +
+

837. + basic_ios::copyfmt() overly loosely specified +

+

Section: 27.5.4.2 [basic.ios.members] Status: NAD Editorial + Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2010-10-29

+

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

+

View all issues with NAD Editorial status.

+

Discussion:

+

+ +The basic_ios::copyfmt() member function is specified in 27.5.4.2 [basic.ios.members] to have the following effects: + +

+
+ +Effects: If (this == &rhs) does +nothing. Otherwise assigns to the member objects of *this +the corresponding member objects of rhs, except that + + +
+

+ +Since the rest of the text doesn't specify what the member objects +of basic_ios are this seems a little too loose. + +

+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the proposed resolution. +Move to NAD Editorial. +
+ + +

Proposed resolution:

+

+ +I propose to tighten things up by adding a Postcondition clause +to the function like so: + +

+
+ Postconditions: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
copyfmt() postconditions
ElementValue
rdbuf()unchanged
tie()rhs.tie()
rdstate()unchanged
exceptions()rhs.exceptions()
flags()rhs.flags()
width()rhs.width()
precision()rhs.precision()
fill()rhs.fill()
getloc()rhs.getloc()
+
+

+ +The format of the table follows Table 117 (as +of N2588): basic_ios::init() +effects. + +

+

+ +The intent of the new table is not to impose any new requirements or +change existing ones, just to be more explicit about what I believe is +already there. + +

+ + + + +
+

839. Maps and sets missing splice operation

+

Section: 23.6 [associative], 23.7 [unord] Status: NAD Future + Submitter: Alan Talbot Opened: 2008-05-18 Last modified: 2010-10-29

+

View all other issues in [associative].

+

View all issues with NAD Future status.

+

Discussion:

+

+Splice is a very useful feature of list. This functionality is also very +useful for any other node based container, and I frequently wish it were +available for maps and sets. It seems like an omission that these +containers lack this capability. Although the complexity for a splice is +the same as for an insert, the actual time can be much less since the +objects need not be reallocated and copied. When the element objects are +heavy and the compare operations are fast (say a map<int, huge_thingy>) +this can be a big win. +

+ +

+Suggested resolution: +

+ +

+Add the following signatures to map, set, multimap, multiset, and the unordered associative containers: +

+
 
+void splice(list<T,Allocator>&& x);
+void splice(list<T,Allocator>&& x, const_iterator i);
+void splice(list<T,Allocator>&& x, const_iterator first, const_iterator last);
+
+ +

+Hint versions of these are also useful to the extent hint is useful. +(I'm looking for guidance about whether hints are in fact useful.) +

+ +
 
+void splice(const_iterator position, list<T,Allocator>&& x);
+void splice(const_iterator position, list<T,Allocator>&& x, const_iterator i);
+void splice(const_iterator position, list<T,Allocator>&& x, const_iterator first, const_iterator last);
+
+ +

[ +Sophia Antipolis: +]

+ + +
+

+Don't try to splice "list" into the other containers, it should be container-type. +

+

+forward_list already has splice_after. +

+

+Would "splice" make sense for an unordered_map? +

+

+Jens, Robert: "splice" is not the right term, it implies maintaining ordering in lists. +

+

+Howard: adopt? +

+

+Jens: absorb? +

+

+Alan: subsume? +

+

+Robert: recycle? +

+

+Howard: transfer? (but no direction) +

+

+Jens: transfer_from. No. +

+

+Alisdair: Can we give a nothrow guarantee? If your compare() and hash() doesn't throw, yes. +

+

+Daniel: For unordered_map, we can't guarantee nothrow. +

+
+ +

[ +San Francisco: +]

+ + +
+

+Martin: this would possibly outlaw an implementation technique that is +currently in use; caching nodes in containers. +

+

+Alan: if you cache in the allocator, rather than the individual +container, this proposal doesn't interfere with that. +

+

+Martin: I'm not opposed to this, but I'd like to see an implementation +that demonstrates that it works. +

+
+ +

[ +2009-07 Frankfurt: +]

+ + +
+NAD Future. +
+ +

[ +2009-09-19 Howard adds: +]

+ + +
+

+I'm not disagreeing with the NAD Future resolution. But when the future gets +here, here is a possibility worth exploring: +

+ +
+

+Add to the "unique" associative containers: +

+ +
typedef details      node_ptr;
+
+node_ptr             remove(const_iterator p);
+pair<iterator, bool> insert(node_ptr&& nd);
+iterator             insert(const_iterator p, node_ptr&& nd);
+
+ +

+And add to the "multi" associative containers: +

+ +
typedef details node_ptr;
+
+node_ptr remove(const_iterator p);
+iterator insert(node_ptr&& nd);
+iterator insert(const_iterator p, node_ptr&& nd);
+
+ +

+Container::node_ptr is a smart pointer much like unique_ptr. +It owns a node obtained from the container it was removed from. It maintains a +reference to the allocator in the container so that it can properly deallocate +the node if asked to, even if the allocator is stateful. This being said, the +node_ptr can not outlive the container for this reason. +

+ +

+The node_ptr offers "const-free" access to the node's +value_type. +

+ +

+With this interface, clients have a great deal of flexibility: +

+ +
    +
  • +A client can remove a node from one container, and insert it into another +(without any heap allocation). This is the splice functionality this issue +asks for. +
    • +
  • +A client can remove a node from a container, change its key or value, and insert +it back into the same container, or another container, all without the cost of +allocating a node. +
    • +
  • +If the Compare function is nothrow (which is very common), then this functionality +is nothrow unless modifying the value throws. And if this does throw, it does +so outside of the containers involved. +
    • +
  • +If the Compare function does throw, the insert function will have the +argument nd retain ownership of the node. +
    • +
  • +The node_ptr should be independent of the Compare parameter +so that a node can be transferred from set<T, C1, A> +to set<T, C2, A> (for example). +
    • +
+ +

+Here is how the customer might use this functionality: +

+ +
    +
  • +

    +Splice a node from one container to another: +

    +
    m2.insert(m1.remove(i));
+
    +
    • + +
  • +

    +Change the "key" in a std::map without the cost of node reallocation: +

    +
    auto p = m.remove(i);
+p->first = new_key;
+m.insert(std::move(p));
+
    +
    • + +
  • +

    +Change the "value" in a std::set without the cost of node reallocation: +

    +
    auto p = s.remove(i);
+*p = new_value;
+s.insert(std::move(p));
+
    +
    • + +
  • +

    +Move a move-only or heavy object out of an associative container (as opposed to +the proposal in 1041): +

    +
    MoveOnly x = std::move(*s.remove(i));
+
    +
      +
    1. +remove(i) transfers ownership of the node from the set to a temporary +node_ptr. +
      2. +
    2. +The node_ptr is dereferenced, and that non-const reference is sent to +move to cast it to an rvalue. +
      3. +
    3. +The rvalue MoveOnly is move constructed into x from +the node_ptr. +
      4. +
    4. +~node_ptr() destructs the moved-from MoveOnly and deallocates +the node. +
      5. +
    + +

    +Contrast this with the 1041 solution: +

    +
    MoveOnly x = std::move(s.extract(i).first);
+
    + +

    +The former requires one move construction for x while the latter +requires two (one into the pair and then one into x). Either +of these constructions can throw (say if there is only a copy constructor for +x). With the former, the point of throw is outside of the container +s, after the element has been removed from the container. With the latter, +one throwing construction takes place prior to the removal of the element, and +the second takes place after the element is removed. +

    + +
    • +
+ +

+The "node insertion" API maintains the API associated with inserting value_types +so the customer can use familiar techniques for getting an iterator to the +inserted node, or finding out whether it was inserted or not for the "unique" +containers. +

+ +

+Lightly prototyped. No implementation problems. Appears to work great +for the client. +

+ +
+
+ + + +

Proposed resolution:

+ + + + + +
+

840. pair default template argument

+

Section: 20.3.5 [pairs] Status: NAD + Submitter: Thorsten Ottosen Opened: 2008-05-23 Last modified: 2010-10-29

+

View all other issues in [pairs].

+

View all issues with NAD status.

+

Discussion:

+

+I have one issue with std::pair. Well, it might just be a very annoying +historical accident, but why is there no default template argument for +the second template argument? This is so annoying when the type in +question is looong and hard to write (type deduction with auto won't +help those cases where we use it as a return or argument type). +

+ + +

Proposed resolution:

+

+Change the synopsis in 20.3 [utility] to read: +

+ +
template <class T1, class T2 = T1> struct pair;
+
+ +

+Change 20.3.5 [pairs] to read: +

+ +
namespace std {
+ template <class T1, class T2 = T1>
+ struct pair {
+   typedef T1 first_type;
+   typedef T2 second_type;
+   ...
+
+ + +

Rationale:

+std::pair is a heterogeneous container. + + + + + +
+

841. cstdint.syn inconsistent with C99

+

Section: 18.4.1 [cstdint.syn] Status: NAD Editorial + Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2010-10-29

+

View all other issues in [cstdint.syn].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+ +In specifying the names of macros and types defined in +header <stdint.h>, C99 makes use of the +symbol N to accommodate unusual platforms with +word sizes that aren't powers of two. C99 +permits N to take on any positive integer value +(including, for example, 24). + +

+

+ +In cstdint.syn Header <cstdint> +synopsis, C++ on the other hand, fixes the value +of N to 8, 16, 32, and 64, and specifies only +types with these exact widths. + +

+

+

+ +In addition, paragraph 1 of the same section makes use of a rather +informal shorthand notation to specify sets of macros. When +interpreted strictly, the notation specifies macros such +as INT_8_MIN that are not intended to be specified. + +

+ +Finally, the section is missing the usual table of symbols defined +in that header, making it inconsistent with the rest of the +specification. + +

+ +

Proposed resolution:

+

+ +I propose to use the same approach in the C++ spec as C99 uses, that +is, to specify the header synopsis in terms of "exposition only" types +that make use of the symbol N to denote one or +more of a theoretically unbounded set of widths. + +

+

+ +Further, I propose to add a new table to section listing the symbols +defined in the header using a more formal notation that avoids +introducing inconsistencies. + +

+

+ +To this effect, in cstdint.syn +Header <cstdint> synopsis, replace both the +synopsis and paragraph 1 with the following text: + +

+
+

+

    +
  1. + +In the names defined in the <cstdint> header, the +symbol N represents a positive decimal integer +with no leading zeros (e.g., 8 or 24, but not 0, 04, or 048). With the +exception of exact-width types, macros and types for values +of N in the set of 8, 16, 32, and 64 are +required. Exact-width types, and any macros and types for values +of N other than 8, 16, 32, and 64 are +optional. However, if an implementation provides integer types with +widths of 8, 16, 32, or 64 bits, the corresponding exact-width types +and macros are required. + +
    2. +
+

+ 
namespace std {
+
+   // required types
+
+   // Fastest minimum-width integer types
+   typedef signed integer type   int_fast8_t;
+   typedef signed integer type   int_fast16_t;
+   typedef signed integer type   int_fast32_t;
+   typedef signed integer type   int_fast64_t;
+
+   typedef unsigned integer type uint_fast8_t;
+   typedef unsigned integer type uint_fast16_t;
+   typedef unsigned integer type uint_fast32_t;
+   typedef unsigned integer type uint_fast64_t;
+
+   // Minimum-width integer types
+   typedef signed integer type   int_least8_t;
+   typedef signed integer type   int_least16_t;
+   typedef signed integer type   int_least32_t;
+   typedef signed integer type   int_least64_t;
+
+   typedef unsigned integer type uint_least8_t;
+   typedef unsigned integer type uint_least16_t;
+   typedef unsigned integer type uint_least32_t;
+   typedef unsigned integer type uint_least64_t;
+
+   // Greatest-width integer types
+   typedef signed integer type   intmax_t;
+   typedef unsigned integer type uintmax_t;
+
+   // optionally defined types
+
+   // Exact-width integer types
+   typedef signed integer type   intN_t;
+   typedef unsigned integer type uintN_t;
+
+   // Fastest minimum-width integer types for values
+   // of N other than 8, 16, 32, and 64
+   typedef signed integer type   uint_fastN_t;
+   typedef unsigned integer type uint_fastN_t;
+
+   // Minimum-width integer types for values
+   // of N other than 8, 16, 32, and 64
+   typedef signed integer type   uint_leastN_t;
+   typedef unsigned integer type uint_leastN_t;
+
+   // Integer types capable of holding object pointers
+   typedef signed integer type   intptr_t;
+   typedef signed integer type   intptr_t;
+
+}
+
+

+ +[Note to editor: Remove all of the existing paragraph 1 from cstdint.syn.] + +

+
+ Table ??: Header <cstdint> synopsis + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TypeName(s)
Macros:INTN_MININTN_MAXUINTN_MAX
INT_FASTN_MININT_FASTN_MAXUINT_FASTN_MAX
INT_LEASTN_MININT_LEASTN_MAXUINT_LEASTN_MAX
INTPTR_MININTPTR_MAXUINTPTR_MAX
INTMAX_MININTMAX_MAXUINTMAX_MAX
PTRDIFF_MINPTRDIFF_MAXPTRDIFF_MAX
SIG_ATOMIC_MINSIG_ATOMIC_MAXSIZE_MAX
WCHAR_MINWCHAR_MAX
WINT_MINWINT_MAX
INTN_C()UINTN_C()
INTMAX_C()UINTMAX_C()
Types:intN_tuintN_t
int_fastN_tuint_fastN_t
int_leastN_tuint_leastN_t
intptr_tuintptr_t
intmax_tuintmax_t
+
+ + + + + +
+

849. missing type traits to compute root class and derived class of types in a class hierachy

+

Section: 20.7.7.6 [meta.trans.other] Status: NAD + Submitter: Thorsten Ottosen Opened: 2008-06-05 Last modified: 2010-10-29

+

View all other issues in [meta.trans.other].

+

View all issues with NAD status.

+

Discussion:

+

+The type traits library contains various traits to dealt with +polymorphic types, e.g. std::has_virtual_destructor, std::is_polymorphic +and std::is_base_of. However, there is no way to compute the unique +public base class of a type if such one exists. Such a trait could be +very useful if one needs to instantiate a specialization made for the +root class whenever a derived class is passed as parameter. For example, +imagine that you wanted to specialize std::hash for a class +hierarchy---instead of specializing each class, you could specialize the +std::hash<root_class> and provide a partial specialization that worked +for all derived classes. +

+ +

+This ability---to specify operations in terms of their equivalent in the +root class---can be done with e.g. normal functions, but there is, +AFAIK, no way to do it for class templates. Being able to access +compile-time information about the type-hierachy can be very powerful, +and I therefore also suggest traits that computes the directly derived +class whenever that is possible. +

+ +

+If the computation can not be done, the traits should fall back on an +identity transformation. I expect this gives the best overall usability. +

+ + +

Proposed resolution:

+

+Add the following to the synopsis in 20.7.2 [meta.type.synop] under "other transformations": +

+ +
template< class T > struct direct_base_class;
+template< class T > struct direct_derived_class;
+template< class T > struct root_base_class;
+
+ +

+Add three new entries to table 51 (20.7.7.6 [meta.trans.other]) with the following content +

+ +
+ + + + + + + + + + + + + + + + + + + +
TemplateConditionComments
template< class T > struct direct_base_class;T shall be a complete type.The member typedef type shall equal the accessible unambiguous direct base class of T. +If no such type exists, the member typedef type shall equal T.
template< class T > struct direct_derived_class;T shall be a complete type.The member typedef type shall equal the unambiguous type which has T +as an accessible unambiguous direct base class. If no such type exists, the member typedef +type shall equal T.
template< class T > struct root_base_class;T shall be a complete type.The member typedef type shall equal the accessible unambiguous most indirect base class of +T. If no such type exists, the member typedef type shall equal T.
+
+ + + +

Rationale:

+2008-9-16 San Francisco: Issue pulled by author prior to being reviewed by the LWG. + + + + + +
+

851. simplified array construction

+

Section: 23.3.1 [array] Status: NAD Future + Submitter: Benjamin Kosnik Opened: 2008-06-05 Last modified: 2010-10-29

+

View all other issues in [array].

+

View all issues with NAD Future status.

+

Discussion:

+

+This is an issue that came up on the libstdc++ list, where a +discrepancy between "C" arrays and C++0x's std::array was pointed +out. +

+ +

+In "C," this array usage is possible: +

+ +
int ar[] = {1, 4, 6};
+
+ +

+But for C++, +

+ +
std::array<int> a = { 1, 4, 6 }; // error
+
+ +

+Instead, the second parameter of the array template must be +explicit, like so: +

+ +
std::array<int, 3> a = { 1, 4, 6 };
+
+ +

+Doug Gregor proposes the following solution, that assumes +generalized initializer lists. +

+ +
template<typename T, typename... Args>
+inline array<T, sizeof...(Args)> 
+make_array(Args&&... args) 
+{ return { std::forward<Args>(args)... };  }
+
+ +

+Then, the way to build an array from a list of unknown size is: +

+ +
auto a = make_array<T>(1, 4, 6);
+
+ +

[ +San Francisco: +]

+ + +
+

+Benjamin: Move to Ready? +

+

+Bjarne: I'm not convinced this is useful enough to add, so I'd like us +to have time to reflect on it. +

+

+Alisdair: the constraints are wrong, they should be +

+
template<ValueType T, ValueType... Args>
+requires Convertible<Args, T>...
+array<T, sizeof...(Args)> make_array(Args&&... args);
+
+

+Alidair: this would be useful if we had a constexpr version. +

+

+Bjarne: this is probably useful for arrays with a small number of +elements, but it's not clearly useful otherwise. +

+

+Consensus is to move to Open. +

+
+ +

[ +2009-06-07 Daniel adds: +]

+ + +
+

+I suggest a fix and a simplification of the current proposal: Recent +prototyping by +Howard showed, that a fix is required because narrowing conversion +8.5.4 [dcl.init.list]/6 b.3 +would severely limit the possible distribution of argument types, e.g. +the expression +make_array<double>(1, 2.0) is ill-formed, because the narrowing +happens inside the +function body where no constant expressions exist anymore. Furthermore +given e.g. +

+
int f();
+double g();
+
+

+we probably want to support +

+
make_array<double>(f(), g());
+
+ +

+as well. To make this feasible, the currently suggested expansion +

+ +
{ std::forward<Args>(args)... }
+
+ +

+needs to be replaced by +

+ +
{ static_cast<T>(std::forward<Args>(args))... }
+
+ +

+which is safe, because we already ensure convertibility via the +element-wise Convertible<Args, T> requirement. Some other fixes are +necessary: The ValueType requirement for the function parameters +is invalid, because all lvalue arguments will deduce to an lvalue-reference, +thereby no longer satisfying this requirement. +

+ +

+The suggested simplification is to provide a default-computed effective +type for the result array based on common_type and decay, in +unconstrained form: +

+ +
template<typename... Args>
+array<typename decay<typename common_type<Args...>::type>::type,
+sizeof...(Args)>
+make_array(Args&&... args);
+
+ +

+The approach used below is similar to that of make_pair and make_tuple +using a symbol C to represent the decayed common type [Note: Special +handling of reference_wrapper types is intentionally not provided, because +our target has so satisfy ValueType, thus under the revised proposal only +an all-reference_wrapper-arguments would be well-formed and an array of +reference_wrapper will be constructed]. I do currently not suggest to +add new concepts reflecting decay and common_type, but an implementor will +need something like this to succeed. Note that we use a similar fuzziness for +make_pair and make_tuple currently. This fuzziness is not related to +the currently +missing Constructible<Vi, Ti&&> requirement for those functions. The following +proposal fixes that miss for make_array. If the corresponding C type +deduction is +explicitly wanted for standardization, here the implementation +

+ +
auto concept DC<typename... T> {
+  typename type = typename decay<typename common_type<T...>::type>::type;
+}
+
+ +

+where C is identical to DC<Args...>::type in the proposed resolution below. +

+

+I intentionally added no further type relation between type and the concept +template parameters, but instead added this requirement below to make +the specification as transparent as possible. As written this concept is +satisfied, if the corresponding associated type exists. +

+ +

Suggested Resolution:

+ +
    +
  1. +

    +Add to the array synopsis in 23.3 [sequences]: +

    +
    
+template<ReferentType... Args>
+requires ValueType<C> && IdentityOf<Args> && Constructible<C, Args&&>...
+array<C, sizeof...(Args)>
+make_array(Args&&... args);
+
+
    +
    2. + +
  2. +

    +Append after 23.3.1.8 [array.tuple] Tuple interface to class template array +the following new section: +

    +
    +

    +23.4.1.7 Array creation functions [array.creation] +

    + +
    
+template<ReferentType... Args>
+requires ValueType<C> && IdentityOf<Args> && Constructible<C, Args&&>...
+array<C, sizeof...(Args)>
+make_array(Args&&... args);
+
    + +
    +

    +Let C be decay<common_type<Args...>::type>::type. +

    +

    +Returns: an array<C, sizeof...(Args)> initialized with +{ static_cast<C>(std::forward<Args>(args))... }. +

    +
    +
    + +
    3. + +
+ +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+

+The proposed resolution uses concepts. +

+

+Daniel to rewrite the proposed resolution. +

+

+Leave Open. +

+
+ +

[ +2009-07-25 Daniel provides rewritten proposed resolution. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+Argument for NAD future: everything about this could be added on. This +does not require changes to the existing text. +
+ + + +

Proposed resolution:

+ +
    +
  1. +

    +Add to the array synopsis in 23.3 [sequences]: +

    + +
    template<class... Args>
+  array<CT, sizeof...(Args)>
+  make_array(Args&&... args);
+
    +
    2. + +
  2. +

    +Append after 23.3.1.8 [array.tuple] "Tuple interface to class template array" the +following new section: +

    + +
    +

    +XX.X.X.X Array creation functions [array.creation] +

    + +
    
+template<class... Args>
+array<CT, sizeof...(Args)>
+make_array(Args&&... args)
+
    + +
    +

    +Let CT be decay<common_type<Args...>::type>::type. +

    +

    +Returns: An array<CT, sizeof...(Args)> initialized with { +static_cast<CT>(std::forward<Args>(args))... }. +

    + +

    +[Example: +

    +
    
+int i = 0; int& ri = i;
+make_array(42u, i, 2.78, ri);
+
    +

    +returns an array of type +

    +
    
+array<double, 4>
+
    + +

    +—end example] +

    +
    +
    +
    3. + +
+ + + + + + + + +
+

855. capacity() and reserve() for deque?

+

Section: 23.3.2.2 [deque.capacity] Status: NAD + Submitter: Hervé Brönnimann Opened: 2008-06-11 Last modified: 2010-10-29

+

View all other issues in [deque.capacity].

+

View all issues with NAD status.

+

Discussion:

+

+The main point is that capacity can be viewed as a mechanism to +guarantee the validity of iterators when only push_back/pop_back +operations are used. For vector, this goes with reallocation. For +deque, this is a bit more subtle: capacity() of a deque may shrink, +whereas that of vector doesn't. In a circular buffer impl. of the +map, as Howard did, there is very similar notion of capacity: as long +as size() is less than B * (total size of the map - 2), it is +guaranteed that no iterator is invalidated after any number of +push_front/back and pop_front/back operations. But this does not +hold for other implementations. +

+

+Still, I believe, capacity() can be defined by size() + how many +push_front/back minus pop_front/back that can be performed before +terators are invalidated. In a classical impl., capacity() = size() ++ the min distance to either "physical" end of the deque (i.e., +counting the empty space in the last block plus all the blocks until +the end of the map of block pointers). In Howard's circular buffer +impl., capacity() = B * (total size of the map - 2) still works with +this definition, even though the guarantee could be made stronger. +

+

+A simple picture of a deque: +

+
A-----|----|-----|---F+|++++|++B--|-----|-----Z
+
+

+(A,Z mark the beginning/end, | the block boundaries, F=front, B=back, +and - are uninitialized, + are initialized) +In that picture: capacity = size() + min(dist(A,F),dist(B,Z)) = min +(dist(A,B),dist(F,Z)). +

+

+Reserve(n) can grow the map of pointers and add possibly a number of +empty blocks to it, in order to guarantee that the next n-size() +push_back/push_front operations will not invalidate iterators, and +also will not allocate (i.e. cannot throw). The second guarantee is +not essential and can be left as a QoI. I know well enough existing +implementations of deque (sgi/stl, roguewave, stlport, and +dinkumware) to know that either can be implemented with no change to +the existing class layout and code, and only a few modifications if +blocks are pre-allocated (instead of always allocating a new block, +check if the next entry in the map of block pointers is not zero). +

+

+Due to the difference with vector, wording is crucial. Here's a +proposed wording to make things concrete; I tried to be reasonably +careful but please double-check me: +

+ +

[ +San Francisco: +]

+ + +
+

+Hans: should the Returns clause for capacity read "1 Returns: A lower +bound..." rather than "1 Returns: An upper bound..." +

+

+Howard: maybe what's needed is capacity_front and capacity_back. In +fact, I think I implemented a deque that had these members as +implementation details. +

+
+ + + +

Proposed resolution:

+ +

+Add new signatures to synopsis in 23.3.2 [deque]: +

+ +
size_type capacity() const;
+bool reserve(size_type n);
+
+ +

+Add new signatures to 23.3.2.2 [deque.capacity]: +

+ +
+
size_type capacity() const;
+
+
+

+1 Returns: An upper bound on n + max(n_f - m_f, n_b - m_b) such +that, for any sequence of n_f push_front, m_f pop_front, n_b +push_back, and m_b pop_back operations, interleaved in any order, +starting with the current deque of size n, the deque does not +invalidate any of its iterators except to the erased elements. +

+

+2 Remarks: Unlike a vector's capacity, the capacity of a deque can +decrease after a sequence of insertions at both ends, even if none of +the operations caused the deque to invalidate any of its iterators +except to the erased elements. +

+
+
+ +
+
bool reserve(size_type n);
+
+
+

+2 Effects: A directive that informs a deque of a planned sequence of +push_front, pop_front, push_back, and pop_back operations, so that it +can manage iterator invalidation accordingly. After reserve(), +capacity() is greater or equal to the argument of reserve if this +operation returns true; and equal to the previous value of capacity() +otherwise. If an exception is thrown, there are no effects. +

+

+3 Returns: true if iterators are invalidated as a result of this +operation, and false otherwise. +

+

+4 Complexity: It does not change the size of the sequence and takes +at most linear time in n. +

+

+5 Throws: length_error if n > max_size(). +

+

+6 Remarks: It is guaranteed that no invalidation takes place during a +sequence of insert or erase operations at either end that happens +after a call to reserve() except to the erased elements, until the +time when an insertion would make max(n_f-m_f, n_b-m_b) larger than +capacity(), where n_f is the number of push_front, m_f of pop_front, +n_b of push_back, and m_b of pop_back operations since the call to +reserve(). +

+

+7 An implementation is free to pre-allocate buffers so as to +offer the additional guarantee that no exception will be thrown +during such a sequence other than by the element constructors. +

+
+
+ +

+And 23.3.2.3 [deque.modifiers] para 1, can be enhanced: +

+ +
+1 Effects: An insertion in the middle of the deque invalidates all the iterators and references to elements of the +deque. An insertion at either end of the deque invalidates all the iterators to the deque, +unless provisions have been made with reserve, +but has no effect on the validity of references to elements of the deque. +
+ + +

Rationale:

+Complication outweighs the benefit. + + + + + +
+

862. Impossible complexity for 'includes'

+

Section: 25.4.5.1 [includes] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2008-07-02 Last modified: 2010-10-29

+

View all other issues in [includes].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In 25.4.5.1 [includes] the complexity is "at most -1 comparisons" if passed +two empty ranges. I don't know how to perform a negative number of +comparisions! +

+ +

+This same issue also applies to: +

+ + + +

[ +2009-03-30 Beman adds: +]

+ + +
+Suggest NAD. The complexity of empty ranges is -1 in other places in the +standard. See 25.4.4 [alg.merge] merge and +inplace_merge, and forward_list merge, for example. +The time and effort to find and fix all places in the standard where +empty range[s] result in negative complexity isn't worth the very +limited benefit. +
+ +

[ +2009-05-09 Alisdair adds: +]

+ + +
+

+I'm not happy with NAD if we can find a simple solution. +

+

+How about adding a rider somewhere in clause 17 suggesting that complexities +that specify a negative number of operations are treated as specifying zero +operations? That should generically solve the issue without looking for +further cases. +

+
+ +

[ +Batavia (2009-05): +]

+ +
+Pete to provide "straightforward" wording. +Move to NAD Editorial. +
+ + +

Proposed resolution:

+

+Recommend NAD. +

+ + + + + +
+

863. What is the state of a stream after close() succeeds

+

Section: 27.9.1 [fstreams] Status: NAD + Submitter: Steve Clamage Opened: 2008-07-08 Last modified: 2010-10-29

+

View all other issues in [fstreams].

+

View all issues with NAD status.

+

Discussion:

+

+Suppose writing to an [o]fstream fails and you later close the stream. +The overflow() function is called to flush the buffer (if it exists). +Then the file is unconditionally closed, as if by calling flcose. +

+

+If either overflow or fclose fails, close() reports failure, and clearly +the stream should be in a failed or bad state. +

+

+Suppose the buffer is empty or non-existent (so that overflow() does not +fail), and fclose succeeds. The close() function reports success, but +what is the state of the stream? +

+ +

[ +Batavia (2009-05): +]

+ +
+

+Tom's impression is that the issue is about the failbit, etc. +

+

+Bill responds that the stream is now closed, +and any status bits remain unchanged. +

+

+See the description of close() in 27.9.1.17 [fstream.members]. +

+

+We prefer not to add wording to say that nothing changes. +Move to NAD. +

+
+ + +

Proposed resolution:

+

+

+ + + + + +
+

864. Defect in atomic wording

+

Section: 29.6 [atomics.types.operations] Status: NAD Editorial + Submitter: Anthony Williams Opened: 2008-07-10 Last modified: 2010-10-29

+

View other active issues in [atomics.types.operations].

+

View all other issues in [atomics.types.operations].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+There's an error in 29.6 [atomics.types.operations]/p9: +

+ +
+
C atomic_load(const volatile A * object);
+C atomic_load_explicit(const volatile A * object, memory_order);
+C A ::load(memory_order order = memory_order_seq_cst) const volatile;
+
+
+

+Requires: The order argument shall not be memory_order_acquire nor +memory_order_acq_rel. +

+
+
+ +

+I believe that this should state +

+
+shall not be memory_order_release. +
+ +

+There's also an error in 29.6 [atomics.types.operations]/p17: +

+ +
+... When only one memory_order argument is supplied, the value of success +is order, and +the value of failure is order except that a value of +memory_order_acq_rel shall be replaced by the value +memory_order_require ... +
+

+I believe this should state +

+
+shall be replaced by the value memory_order_acquire ... +
+ + +

Proposed resolution:

+

+Change 29.6 [atomics.types.operations]/p9: +

+ +
+
C atomic_load(const volatile A * object);
+C atomic_load_explicit(const volatile A * object, memory_order);
+C A ::load(memory_order order = memory_order_seq_cst) const volatile;
+
+
+

+Requires: The order argument shall not be memory_order_acquire +memory_order_release nor memory_order_acq_rel. +

+
+
+ +

+Change 29.6 [atomics.types.operations]/p17: +

+ +
+... When only one memory_order argument is supplied, the value of success +is order, and +the value of failure is order except that a value of +memory_order_acq_rel shall be replaced by the value +memory_order_require memory_order_acquire ... +
+ + + +

Rationale:

+Already fixed by the time the LWG processed it. + + + + + +
+

867. Valarray and value-initialization

+

Section: 26.6.2.1 [valarray.cons] Status: NAD Editorial + Submitter: Alberto Ganesh Barbati Opened: 2008-07-20 Last modified: 2010-10-29

+

View all other issues in [valarray.cons].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+From 26.6.2.1 [valarray.cons], paragraph 2: +

+ +
explicit  valarray(size_t);
+
+
+The array created by this constructor has a length equal to the value of the argument. The elements +of the array are constructed using the default constructor for the instantiating type T. +
+
+ +

+The problem is that the most obvious Ts for valarray are float +and double, they don't have a default constructor. I guess the intent is to value-initialize +the elements, so I suggest replacing: +

+ +
+The elements of the array are constructed using the default constructor for the instantiating type T. +
+

+with +

+
+The elements of the array are value-initialized. +
+ +

+There is another reference to the default constructor of T in the non-normative note in paragraph 9. +That reference should also be replaced. (The normative wording in paragraph 8 refers to T() +and so it doesn't need changes). +

+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the proposed resolution. +Move to NAD Editorial. +
+ + +

Proposed resolution:

+

+Change 26.6.2.1 [valarray.cons], paragraph 2: +

+ +
+
explicit  valarray(size_t);
+
+
+The array created by this constructor has a length equal to the value of the argument. The elements +of the array are constructed using the default constructor for the instantiating type T +value-initialized (8.5 [dcl.init]). +
+
+ +

+Change 26.6.2.7 [valarray.members], paragraph 9: +

+ +
+[Example: If the argument has the value -2, the first two elements of the result will be constructed using the +default constructor +value-initialized (8.5 [dcl.init]); +the third element of the result will be assigned the value of the first element of the argument; etc. -- end example] +
+ + + + + + +
+

873. signed integral type and unsigned integral type are not clearly defined

+

Section: 3.9.1 [basic.fundamental] Status: NAD Editorial + Submitter: Travis Vitek Opened: 2008-06-30 Last modified: 2010-10-29

+

View all issues with NAD Editorial status.

+

Discussion:

+

+ Neither the term "signed integral type" nor the term "unsigned + integral type" is defined in the core language section of the + standard, therefore the library section should avoid its use. The + terms signed integer type and unsigned integer type are + indeed defined (in 3.9.1 [basic.fundamental]), thus the usages should be + replaced accordingly. +

+ +

+ Note that the key issue here is that "signed" + "integral type" != + "signed integral type". + + The types bool, char, char16_t, + char32_t and wchar_t are all listed as + integral types, but are neither of signed integer type or + unsigned integer type. According to 3.9 [basic.types] p7, a synonym for + integral type is integer type. + + Given this, one may choose to assume that an integral type that + can represent values less than zero is a signed integral type. + Unfortunately this can cause ambiguities. + + As an example, if T is unsigned char, the + expression make_signed<T>::type, is supposed to + name a signed integral type. There are potentially two types that + satisfy this requirement, namely signed char and + char (assuming CHAR_MIN < 0). +

+ +

[ +San Francisco: +]

+ + +
+Plum, Sebor to review. +
+ +

[ +Post Summit Daniel adds: +]

+ + +
+The proposed resolution needs to be "conceptualized". Currently we have +in [concept.support] only concept IntegralType +for all "integral types", thus indeed the current Container +concept and Iterator concepts are sufficiently satisfied with "integral +types". If the changes are applied, we might ask core for concept +BilateralIntegerType and add proper restrictions to the library +concepts. +
+ + + +

Proposed resolution:

+

+ I propose to use the terms "signed integer type" and "unsigned integer + type" in place of "signed integral type" and "unsigned integral type" + to eliminate such ambiguities. +

+ +

+ The proposed change makes it absolutely clear that the difference + between two pointers cannot be char or wchar_t, + but could be any of the signed integer types. + 5.7 [expr.add] paragraph 6... +

+
+

+

    +
  1. + When two pointers to elements of the same array object are + subtracted, the result is the difference of the subscripts of + the two array elements. The type of the result is an + implementation-defined signed integral + typesigned integer type; this type shall be the + same type that is defined as std::ptrdiff_t in the + <cstdint> header (18.1)... +
    2. +
+

+
+ +

+ The proposed change makes it clear that X::size_type and + X::difference_type cannot be char or + wchar_t, but could be one of the signed or unsigned integer + types as appropriate. + 20.2.5 [allocator.requirements] table 40... +

+
+ Table 40: Allocator requirements + + + + + + + + + + + + + + + + + + + + +
expressionreturn typeassertion/note/pre/post-condition
X::size_type + unsigned integral type + unsigned integer type + a type that can represent the size of the largest object in + the allocation model.
X::difference_type + signed integral type + signed integer type + a type that can represent the difference between any two + pointers in the allocation model.
+
+ +

+ The proposed change makes it clear that make_signed<T>::type + must be one of the signed integer types as defined in 3.9.1. Ditto for + make_unsigned<T>type and unsigned integer types. + 20.7.7.3 [meta.trans.sign] table 48... +

+
+ Table 48: Sign modifications + + + + + + + + + + + + + + + + + +
TemplateComments
+ template <class T> struct make_signed; + + If T names a (possibly cv-qualified) signed + integral typesigned integer type (3.9.1) then + the member typedef type shall name the type + T; otherwise, if T names a (possibly + cv-qualified) unsigned integral typeunsigned + integer type then type shall name the + corresponding signed integral typesigned + integer type, with the same cv-qualifiers as + T; otherwise, type shall name the + signed integral typesigned integer type + with the smallest rank (4.13) for which sizeof(T) == + sizeof(type), with the same cv-qualifiers as + T. + + Requires: T shall be a (possibly + cv-qualified) integral type or enumeration but not a + bool type. +
+ template <class T> struct make_unsigned; + + If T names a (possibly cv-qualified) + unsigned integral typeunsigned integer + type (3.9.1) then the member typedef type + shall name the type T; otherwise, if + T names a (possibly cv-qualified) signed + integral typesigned integer type then + type shall name the corresponding unsigned + integral typeunsigned integer type, with the + same cv-qualifiers as T; otherwise, + type shall name the unsigned integral + typeunsigned integer type with the smallest + rank (4.13) for which sizeof(T) == sizeof(type), + with the same cv-qualifiers as T. + + Requires: T shall be a (possibly + cv-qualified) integral type or enumeration but not a + bool type. +
+
+ + +

+ Note: I believe that the basefield values should probably be + prefixed with ios_base:: as they are in 22.4.2.2.2 [facet.num.put.virtuals] + + The listed virtuals are all overloaded on signed and unsigned integer + types, the new wording just maintains consistency. + + 22.4.2.1.2 [facet.num.get.virtuals] table 78... +

+
+ Table 78: Integer Conversions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Statestdio equivalent
basefield == oct%o
basefield == hex%X
basefield == 0%i
signed integral typesigned integer + type%d
unsigned integral typeunsigned integer + type%u
+
+ + + +

+ Rationale is same as above. + 22.4.2.2.2 [facet.num.put.virtuals] table 80... +

+
+ Table 80: Integer Conversions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Statestdio equivalent
basefield == ios_base::oct%o
(basefield == ios_base::hex) && + !uppercase%x
(basefield == ios_base::hex)%X
basefield == 0%i
for a signed integral typesigned integer + type%d
for a unsigned integral typeunsigned integer + type%u
+
+ + +

+ 23.2 [container.requirements] table 80... +

+
+ Table 89: Container requirements + + + + + + + + + + + + + + + + + + + + + + + + + + +
expressionreturn typeoperational semanticsassertion/note/pre/post-conditioncomplexity
X::difference_typesigned integral typesigned integer type is identical to the difference type of X::iterator + and X::const_iteratorcompile time
X::size_typeunsigned integral typeunsigned integer type size_type can represent any non-negative value of + difference_typecompile time
+
+ +

+ X [iterator.concepts] paragraph 1... +

+
+ Iterators are a generalization of pointers that allow a C++ program to + work with different data structures (containers) in a uniform manner. + To be able to construct template algorithms that work correctly and + efficiently on different types of data structures, the library + formalizes not just the interfaces but also the semantics and + complexity assumptions of iterators. All input iterators + i support the expression *i, resulting in a + value of some class, enumeration, or built-in type T, + called the value type of the iterator. All output iterators + support the expression *i = o where o is a + value of some type that is in the set of types that are + writable to the particular iterator type of i. All + iterators i for which the expression (*i).m + is well-defined, support the expression i->m with the + same semantics as (*i).m. For every iterator type + X for which equality is defined, there is a corresponding + signed integral type signed integer type called + the difference type of the iterator. +
+ +

+ I'm a little unsure of this change. Previously this paragraph would + allow instantiations of linear_congruential_engine on + char, wchar_t, bool, and other types. The + new wording prohibits this. + 26.5.3.1 [rand.eng.lcong] paragraph 2... +

+
+ The template parameter UIntType shall denote an + unsigned integral typeunsigned integer type + large enough to store values as large as m - 1. If the + template parameter m is 0, the modulus m + used throughout this section 26.4.3.1 is + numeric_limits<result_type>::max() plus 1. [Note: + The result need not be representable as a value of type + result_type. --end note] Otherwise, the following + relations shall hold: a < m and c < + m. +
+ +

+ Same rationale as the previous change. + X [rand.adapt.xor] paragraph 6... +

+
+ Both Engine1::result_type and + Engine2::result_type shall denote (possibly different) + unsigned integral typesunsigned integer types. + The member result_type shall denote either the type + Engine1::result_type or the type Engine2::result_type, + whichever provides the most storage according to clause 3.9.1. +
+ +

+ 26.5.7.1 [rand.util.seedseq] paragraph 7... +

+
+ Requires:RandomAccessIterator shall meet the + requirements of a random access iterator (24.1.5) such that + iterator_traits<RandomAccessIterator>::value_type + shall denote an unsigned integral typeunsigned integer + type capable of accomodating 32-bit quantities. +
+ +

+ By making this change, integral types that happen to have a signed + representation, but are not signed integer types, would no longer be + required to use a two's complement representation. This may go against + the original intent, and should be reviewed. + 29.6 [atomics.types.operations] paragraph 24... +

+
+ Remark: For signed integral typessigned integer + types, arithmetic is defined using two's complement + representation. There are no undefined results. For address types, the + result may be an undefined address, but the operations otherwise have + no undefined behavior. +
+ + + + + + +
+

874. Missing initializer_list constructor for discrete_distribution

+

Section: 26.5.8.5.1 [rand.dist.samp.discrete] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2008-08-22 Last modified: 2010-10-29

+

View all other issues in [rand.dist.samp.discrete].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+During the Sophia Antipolis meeting it was decided to separate from 793 a +subrequest that adds initializer list support to +discrete_distribution, specifically, +the issue proposed to add a c'tor taking a initializer_list<double>. +

+ + + +

Proposed resolution:

+
    +
  1. +

    +In 26.5.8.5.1 [rand.dist.samp.discrete]/1, class discrete_distribution, +just before the member declaration +

    + +
    explicit discrete_distribution(const param_type& parm);
+
    + +

    +insert +

    + +
    discrete_distribution(initializer_list<double> wl);
+
    +
    2. + +
  2. +

    +Between p.4 and p.5 of the same section insert a new +paragraph as part of the new member description: +

    + +
    discrete_distribution(initializer_list<double> wl);
+
    + +
    +Effects: Same as discrete_distribution(wl.begin(), wl.end()). +
    +
    +
    3. +
+ + +

Rationale:

+Addressed by +N2836 "Wording Tweaks for Concept-enabled Random Number Generation in C++0X". + + + + + +
+

875. Missing initializer_list constructor for piecewise_constant_distribution

+

Section: 26.5.8.5.2 [rand.dist.samp.pconst] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2008-08-22 Last modified: 2010-10-29

+

View all other issues in [rand.dist.samp.pconst].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+During the Sophia Antipolis meeting it was decided to separate from +794 a subrequest that adds initializer list support to +piecewise_constant_distribution, specifically, the issue proposed +to add a c'tor taking a initializer_list<double> and a Callable to evaluate +weight values. For consistency with the remainder of this class and +the remainder of the initializer_list-aware library the author decided to +change the list argument type to the template parameter RealType +instead. For the reasoning to use Func instead of Func&& as c'tor +function argument see issue 793. +

+ + +

Proposed resolution:

+

Non-concept version of the proposed resolution

+ +
    +
  1. +

    +In 26.5.8.5.2 [rand.dist.samp.pconst]/1, class piecewise_constant_distribution, +just before the member declaration +

    + +
    explicit piecewise_constant_distribution(const param_type& parm);
+
    + +

    +insert +

    + +
    template<typename Func>
+piecewise_constant_distribution(initializer_list<RealType> bl, Func fw);
+
    +
    2. + +
  2. +

    +Between p.4 and p.5 of the same section insert a series of +new paragraphs nominated below as [p5_1], [p5_2], and [p5_3] +as part of the new member description: +

    + +
    template<typename Func>
+piecewise_constant_distribution(initializer_list<RealType> bl, Func fw);
+
    + +
    + +

    +[p5_1] Complexity: Exactly nf = max(bl.size(), 1) - 1 invocations of fw. +

    + +

    +[p5_2] Requires: +

    + +
      +
    1. +fw shall be callable with one argument of type RealType, and shall + return values of a type convertible to double; +
      2. +
    2. +The relation 0 < S = w0+. . .+wn-1 shall hold. +For all sampled values xk defined below, fw(xk) shall return a weight + value wk that is non-negative, non-NaN, and non-infinity; +
      3. +
    3. +If nf > 0 let bk = *(bl.begin() + k), k = 0, . . . , bl.size()-1 and the +following relations shall hold for k = 0, . . . , nf-1: bk < bk+1. +
      4. +
    + +

    +[p5_3] Effects: +

    + +
      +
    1. +

      If nf == 0,

      +
        +
      1. +lets the sequence w have length n = 1 and consist of the single + value w0 = 1, and +
        2. +
      2. +lets the sequence b have length n+1 with b0 = 0 and b1 = 1. +
        3. +
      +
      2. + +
    2. +

      Otherwise,

      +
        +
      1. +sets n = nf, and [bl.begin(), bl.end()) shall form the sequence b of +length n+1, and +
        2. +
      2. +

        lets the sequences w have length n and for each k = 0, . . . ,n-1, + calculates:

        +
        xk = 0.5*(bk+1 + bk)
+wk = fw(xk)
+
        +
        3. +
      +
      3. + +
    3. +

      +Constructs a piecewise_constant_distribution object with +the above computed sequence b as the interval boundaries +and with the probability densities: +

      +
      ρk = wk/(S * (bk+1 - bk)) for k = 0, . . . , n-1.
+
      + +
      4. +
    + +
    +
    +
    3. +
+ +

Concept version of the proposed resolution

+ +
    +
  1. +

    +In 26.5.8.5.2 [rand.dist.samp.pconst]/1, class piecewise_constant_distribution, +just before the member declaration +

    + +
    explicit piecewise_constant_distribution(const param_type& parm);
+
    + +

    +insert +

    + +
    template<Callable<auto, RealType> Func>
+ requires Convertible<Func::result_type, double>
+piecewise_constant_distribution(initializer_list<RealType> bl, Func fw);
+
    +
    2. + +
  2. +

    +Between p.4 and p.5 of the same section insert a series of +new paragraphs nominated below as [p5_1], [p5_2], and [p5_3] +as part of the new member description: +

    + +
    template<Callable<auto, RealType> Func>
+ requires Convertible<Func::result_type, double>
+piecewise_constant_distribution(initializer_list<RealType> bl, Func fw);
+
    + +
    + +

    +[p5_1] Complexity: Exactly nf = max(bl.size(), 1) - 1 invocations of fw. +

    + +

    +[p5_2] Requires: +

    + +
      +
    1. +The relation 0 < S = w0+. . .+wn-1 shall hold. +For all sampled values xk defined below, fw(xk) shall return a weight + value wk that is non-negative, non-NaN, and non-infinity; +
      2. +
    2. +If nf > 0 let bk = *(bl.begin() + k), k = 0, . . . , bl.size()-1 and the +following relations shall hold for k = 0, . . . , nf-1: bk < bk+1. +
      3. +
    + +

    +[p5_3] Effects: +

    + +
      +
    1. +

      If nf == 0,

      +
        +
      1. +lets the sequence w have length n = 1 and consist of the single + value w0 = 1, and +
        2. +
      2. +lets the sequence b have length n+1 with b0 = 0 and b1 = 1. +
        3. +
      +
      2. + +
    2. +

      Otherwise,

      +
        +
      1. +sets n = nf, and [bl.begin(), bl.end()) shall form the sequence b of +length n+1, and +
        2. +
      2. +

        lets the sequences w have length n and for each k = 0, . . . ,n-1, + calculates:

        +
        xk = 0.5*(bk+1 + bk)
+wk = fw(xk)
+
        +
        3. +
      +
      3. + +
    3. +

      +Constructs a piecewise_constant_distribution object with +the above computed sequence b as the interval boundaries +and with the probability densities: +

      +
      ρk = wk/(S * (bk+1 - bk)) for k = 0, . . . , n-1.
+
      + +
      4. +
    + +
    +
    +
    3. +
+ + + +

Rationale:

+Addressed by +N2836 "Wording Tweaks for Concept-enabled Random Number Generation in C++0X". + + + + + +
+

877. to throw() or to Throw: Nothing.

+

Section: 17 [library] Status: NAD Future + Submitter: Martin Sebor Opened: 2008-08-23 Last modified: 2010-10-29

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD Future status.

+

Discussion:

+

+ +Recent changes to +the working +draft have introduced a gratuitous inconsistency with the C++ 2003 +version of the specification with respect to exception guarantees +provided by standard functions. While the C++ 2003 standard +consistenly uses the empty exception specification, throw(), +to declare functions that are guaranteed not to throw exceptions, the +current working draft contains a number of "Throws: Nothing." +clause to specify essentially the same requirement. The difference +between the two approaches is that the former specifies the behavior +of programs that violate the requirement (std::unexpected() +is called) while the latter leaves the behavior undefined. + +

+

+ +A survey of the working draft reveals that there are a total of 209 +occurrences of throw() in the library portion of the spec, +the majority in clause 18, a couple (literally) in 19, a handful in +20, a bunch in 22, four in 24, one in 27, and about a dozen in D.9. + +

+

+ +There are also 203 occurrences of "Throws: Nothing." scattered +throughout the spec. + +

+

+ +While sometimes there are good reasons to use the "Throws: +Nothing." approach rather than making use of throw(), these +reasons do not apply in most of the cases where this new clause has +been introduced and the empty exception specification would be a +better approach. + +

+

+ +First, functions declared with the empty exception specification +permit compilers to generate better code for calls to such +functions. In some cases, the compiler might even be able to eliminate +whole chunks of user-written code when instantiating a generic +template on a type whose operations invoked from the template +specialization are known not to throw. The prototypical example are +the std::uninitialized_copy() +and std::uninitialized_fill() algorithms where the +entire catch(...) block can be optimized away. + +

+

+ +For example, given the following definition of +the std::uninitialized_copy function template and a +user-defined type SomeType: + +

+
+ 
template <class InputIterator, class ForwardIterator>
+ForwardIterator
+uninitialized_copy (InputIterator first, InputIterator last, ForwardIterator res)
+{
+   typedef iterator_traits<ForwardIterator>::value_type ValueType;
+
+   ForwardIterator start = res;
+
+   try {
+       for (; first != last; ++first, ++res)
+           ::new (&*res) ValueType (*first);
+   }
+   catch (...) {
+       for (; start != res; --start)
+           (&*start)->~ValueType ();
+       throw;
+   }
+   return res;
+}
+
+struct SomeType {
+   SomeType (const SomeType&) throw ();
+}
+
+

+ +compilers are able to emit the following efficient specialization +of std::uninitialized_copy<const SomeType*, SomeType*> +(note that the catch block has been optimized away): + +

+
+ 
template <> SomeType*
+uninitialized_copy (const SomeType *first, const SomeType *last, SomeType *res)
+{
+   for (; first != last; ++first, ++res)
+       ::new (res) SomeType (*first);
+
+   return res;
+}
+
+

+ +Another general example is default constructors which, when decorated +with throw(), allow the compiler to eliminate the +implicit try and catch blocks that it otherwise must +emit around each the invocation of the constructor +in new-expressions. + +

+

+ +For example, given the following definitions of +class MayThrow and WontThrow and the two +statements below: + +

+
+ 
struct MayThrow {
+   MayThrow ();
+};
+
+struct WontThrow {
+   WontThrow () throw ();
+};
+
+MayThrow  *a = new MayThrow [N];
+WontThrow *b = new WontThrow [N];
+ +
+

+ +the compiler generates the following code for the first statement: + +

+
+ 
MayThrow *a;
+{
+   MayThrow *first = operator new[] (N * sizeof (*a));
+   MayThrow *last  = first + N;
+   MayThrow *next  = first;
+   try {
+       for ( ; next != last; ++next)
+           new (next) MayThrow;
+   }
+   catch (...) {
+       for ( ; first != first; --next)
+           next->~MayThrow ();
+       operator delete[] (first);
+       throw;
+   }
+   a = first;
+}
+
+

+ +but it is can generate much more compact code for the second statement: + +

+
+ 
WontThrow *b    = operator new[] (N * sizeof (*b));
+WontThrow *last = b + N;
+for (WontThrow *next = b; next != last; ++next)
+   new (next) WontThrow;
+
+
+

+ +Second, in order for users to get the maximum benefit out of the new +std::has_nothrow_xxx traits when using standard library types +it will be important for implementations to decorate all non throwing +copy constructors and assignment operators with throw(). Note +that while an optimizer may be able to tell whether a function without +an explicit exception specification can throw or not based on its +definition, it can only do so when it can see the source code of the +definition. When it can't it must assume that the function may +throw. To prevent violating the One Definition Rule, +the std::has_nothrow_xxx trait must return the most +pessimistic guess across all translation units in the program, meaning +that std::has_nothrow_xxx<T>::value must evaluate to +false for any T whose xxx +(where xxx is default or copy ctor, or assignment operator) +is defined out-of-line. + +

+

+ +Counterarguments: + +

+

+ +During the discussion of this issue +on c++std-lib@accu.org +(starting with post c++std-lib-21950) the following arguments +in favor of the "Throws: Nothing." style have been made. + +

+

+

    +
  1. + +Decorating functions that cannot throw with the empty exception +specification can cause the compiler to generate suboptimal code for +the implementation of the function when it calls other functions that +aren't known to the compiler not to throw (i.e., that aren't decorated +with throw() even if they don't actually throw). This is a +common situation when the called function is a C or POSIX function. + +
    2. +
  2. + +Alternate, proprietary mechanisms exist (such as +GCC __attribute__((nothrow)) +or Visual +C++ __declspec(nothrow)) +that let implementers mark up non-throwing functions, often without +the penalty mentioned in (1) above. The C++ standard shouldn't +preclude the use of these potentially more efficient mechanisms. + +
    3. +
  3. + +There are functions, especially function templates, that invoke +user-defined functions that may or may not be +declared throw(). Declaring such functions with the empty +exception specification will cause compilers to generate suboptimal +code when the user-defined function isn't also declared not to throw. + +
    4. +
+

+

+ +The answer to point (1) above is that implementers can (and some have) +declare functions with throw() to indicate to the compiler +that calls to the function can safely be assumed not to throw in order +to allow it to generate efficient code at the call site without also +having to define the functions the same way and causing the compiler +to generate suboptimal code for the function definition. That is, the +function is declared with throw() in a header but it's +defined without it in the source file. The throw() +declaration is suppressed when compiling the definition to avoid +compiler errors. This technique, while strictly speaking no permitted +by the language, is safe and has been employed in practice. For +example, the GNU C library takes this approach. Microsoft Visual C++ +takes a similar approach by simply assuming that no function with C +language linkage can throw an exception unless it's explicitly +declared to do so using the language extension throw(...). + +

+

+ +Our answer to point (2) above is that there is no existing practice +where C++ Standard Library implementers have opted to make use of the +proprietary mechanisms to declare functions that don't throw. The +language provides a mechanism specifically designed for this +purpose. Avoiding its use in the specification itself in favor of +proprietary mechanisms defeats the purpose of the feature. In +addition, making use of the empty exception specification +inconsistently, in some areas of the standard, while conspicuously +avoiding it and making use of the "Throws: Nothing." form in +others is confusing to users. + +

+

+ +The answer to point (3) is simply to exercise caution when declaring +functions and especially function templates with the empty exception +specification. Functions that required not to throw but that may call +back into user code are poor candidates for the empty exception +specification and should instead be specified using "Throws: +Nothing." clause. + +

+ +

[ +2009-07 Frankfurt +]

+ + +
+

+We need someone to do an extensive review. +

+

+NAD Future. +

+
+ + +

Proposed resolution:

+

+ +We propose two possible solutions. Our recommendation is to adopt +Option 1 below. + +

+

+ +Option 1: + +

+

+ +Except for functions or function templates that make calls back to +user-defined functions that may not be declared throw() +replace all occurrences of the "Throws: Nothing." clause with +the empty exception specification. Functions that are required not to +throw but that make calls back to user code should be specified to +"Throw: Nothing." + +

+

+ +Option 2: + +

+

+ +For consistency, replace all occurrences of the empty exception +specification with a "Throws: Nothing." clause. + +

+ + + + +
+

879. Atomic load const qualification

+

Section: 29 [atomics] Status: NAD Editorial + Submitter: Alexander Chemeris Opened: 2008-08-24 Last modified: 2010-10-29

+

View other active issues in [atomics].

+

View all other issues in [atomics].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The atomic_address type and atomic<T*> specialization provide atomic +updates to pointers. However, the current specification requires +that the types pointer be to non-const objects. This restriction +is unnecessary and unintended. +

+ +

[ +Summit: +]

+ +
+Move to review. Lawrence will first check with Peter whether the +current examples are sufficient, or whether they need to be expanded to +include all cases. +
+ +

[ +2009-07 Frankfurt +]

+ + +
+

+Lawrence will handle all issues relating to atomics in a single paper. +

+

+LWG will defer discussion on atomics until that paper appears. +

+

+Move to Open. +

+
+ +

[ +2009-08-17 Handled by +N2925. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+

+Add const qualification to the pointer values of the atomic_address +and atomic<T*> specializations. E.g. +

+ +
typedef struct atomic_address {
+   void store(const void*, memory_order = memory_order_seq_cst) volatile;
+   void* exchange( const void*, memory_order = memory_order_seq_cst) volatile;
+   bool compare_exchange( const void*&, const void*,
+                          memory_order, memory_order) volatile;
+   bool compare_exchange( const void*&, const void*,
+                          memory_order = memory_order_seq_cst ) volatile;
+   void* operator=(const void*) volatile;
+} atomic_address;
+
+void atomic_store(volatile atomic_address*, const void*);
+void atomic_store_explicit(volatile atomic_address*, const void*,
+                          memory_order);
+void* atomic_exchange(volatile atomic_address*, const void*);
+void* atomic_exchange_explicit(volatile atomic_address*, const void*,
+                              memory_order);
+bool atomic_compare_exchange(volatile atomic_address*,
+                            const void**, const void*);
+bool atomic_compare_exchange_explicit(volatile atomic_address*,
+                                     const void**, const void*,
+                                     memory_order, memory_order);
+
+ + + + + +
+

880. Missing atomic exchange parameter

+

Section: 29 [atomics] Status: NAD Editorial + Submitter: Lawrence Crowl Opened: 2008-08-24 Last modified: 2010-10-29

+

View other active issues in [atomics].

+

View all other issues in [atomics].

+

View all issues with NAD Editorial status.

+

Duplicate of: 942

+

Discussion:

+

+The atomic_exchange and atomic_exchange_explicit functions seem to +be inconsistently missing parameters. +

+ +

[ +Post Summit: +]

+ + +
+

+Lawrence: Need to write up a list for Pete with details. +

+

+Detlef: Should not be New, we already talked about in Concurrency group. +

+

+Recommend Open. +

+
+ +

[ +2009-07 Frankfurt +]

+ + +
+

+Lawrence will handle all issues relating to atomics in a single paper. +

+

+LWG will defer discussion on atomics until that paper appears. +

+

+Move to Open. +

+
+ +

[ +2009-08-17 Handled by +N2925. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+

+Add the appropriate parameters. For example, +

+ +
bool atomic_exchange(volatile atomic_bool*, bool);
+bool atomic_exchange_explicit(volatile atomic_bool*, bool, memory_order);
+
+ + + + + +
+

887. issue with condition::wait_...

+

Section: 30.5.1 [thread.condition.condvar] Status: NAD + Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2010-10-29

+

View all other issues in [thread.condition.condvar].

+

View all issues with NAD status.

+

Discussion:

+

+The Posix/C++ working group has identified an inconsistency between +Posix and the C++ working draft in that Posix requires the clock to be +identified at creation, whereas C++ permits identifying the clock at the +call to wait. The latter cannot be implemented with the former. +

+ +

[ +San Francisco: +]

+ + +
+

+Howard recommends NAD with the following explanation: +

+ +

+The intent of the current wording is for the condtion_variable::wait_until +be able to handle user-defined clocks as well as clocks the system knows about. +This can be done by providing overloads for the known clocks, and another +overload for unknown clocks which synchs to a known clock before waiting. +For example: +

+ +
template <class Duration>
+bool
+condition_variable::wait_until(unique_lock<mutex>& lock,
+                               const chrono::time_point<chrono::system_clock, Duration>& abs_time)
+{
+    using namespace chrono;
+    nanoseconds d = __round_up<nanoseconds>(abs_time.time_since_epoch());
+    __do_timed_wait(lock.mutex()->native_handle(), time_point<system_clock, nanoseconds>(d));
+    return system_clock::now() < abs_time;
+}
+
+template <class Clock, class Duration>
+bool
+condition_variable::wait_until(unique_lock<mutex>& lock,
+                               const chrono::time_point<Clock, Duration>& abs_time)
+{
+    using namespace chrono;
+    system_clock::time_point    s_entry = system_clock::now();
+    typename Clock::time_point  c_entry = Clock::now();
+    nanoseconds dn = __round_up<nanoseconds>(abs_time.time_since_epoch() -
+                                              c_entry.time_since_epoch());
+    __do_timed_wait(lock.mutex()->native_handle(), s_entry + dn);
+    return Clock::now() < abs_time;
+}
+
+ +

+In the above example, system_clock is the only clock which the underlying +condition variable knows how to deal with. One overload just passes that clock +through. The second overload (approximately) converts the unknown clock into +a system_clock time_point prior to passing it down to the native +condition variable. +

+ +

+On Posix systems vendors are free to add implementation defined constructors which +take a clock. That clock can be stored in the condition_variable, and converted +to (or not as necessary) as shown above. +

+ +

+If an implementation defined constructor takes a clock (for example), then part +of the semantics for that implementation defined ctor might include that a +wait_until using a clock other than the one constructed with results +in an error (exceptional condition) instead of a conversion to the stored clock. +Such a design is up to the vendor as once an implementation defined ctor is used, +the vendor is free to specifiy the behavior of waits and/or notifies however +he pleases (when the cv is constructed in an implementation defined manner). +

+
+ +

[ +Post Summit: +]

+ + +
+

+"POSIX people will review the proposed NAD resolution at their upcoming NY +meeting. +

+ +

+See the minutes at: http://wiki.dinkumware.com/twiki/bin/view/Posix/POSIX-CppBindingWorkingGroupNewYork2009. +

+
+ +

[ +2009-07 Frankfurt +]

+ + +
+Move to NAD. +
+ +

[ +2009-07-18 Detlef reopens the issue: +]

+ + +
+

+On Friday afternoon in Frankfurt is was decided that 887 is NAD. +This decision was mainly based on a sample implementation presented +by Howard that implemented one clock on top of another. +Unfortunately this implementation doesn't work for the probably most +important case where a system has a monotonic clock and a real-time +clock (or "wall time" clock): +

+

+If the underlying "system_clock" is a monotonic clock, and +the program waits on the real-time clock, and the real-time clock +is set forward, the wait will unblock too late. +

+ +

+If the underlying "system_clock" is a real-time clock, and the +program waits on the monotonic clock, and the real-time clock +is set back, the wait again will unblock too late. +

+ +

+Sorry that I didn't remember this on Friday, but it was Friday +afternoon after a busy week... +

+ +

+So as the decision was made on a wrong asumption, I propose to re-open +the issue. +

+
+ +

[ +2009-07-26 Howard adds: +]

+ + +
+

+Detlef correctly argues that condition_variable::wait_until could +return "too late" in the context of clocks being adjusted during the wait. I agree +with his logic. But I disagree that this makes this interface unimplementable +on POSIX. +

+ +

+The POSIX spec also does not guarantee that pthread_cond_timedwait does +not return "too late" when clocks are readjusted during the wait. Indeed, the +POSIX specification lacks any requirements at all concerning how soon +pthread_cond_timedwait returns after a time out. This is evidently a +QOI issue by the POSIX standard. Here is a quote of the most relevant normative +text concerning pthread_cond_timedwait found +here. +

+ +
+The pthread_cond_timedwait() function shall be equivalent to +pthread_cond_wait(), except that an error is returned if the absolute +time specified by abstime passes (that is, system time equals or exceeds +abstime) before the condition cond is signaled or broadcasted, or if the +absolute time specified by abstime has already been passed at the time +of the call. +
+ +

+I.e. the POSIX specification speaks of the error code returned in case of a time +out, but not on the timeliness of that return. +

+ +

+Might this simply be an oversight, or minor defect in the POSIX specification? +

+ +

+I do not believe so. This same section goes on to say in non-normative +text: +

+ +
+For cases when the system clock is advanced discontinuously by an +operator, it is expected that implementations process any timed wait +expiring at an intervening time as if that time had actually occurred. +
+ +

+Here is non-normative wording encouraging the implementation to ignore an advancing +underlying clock and subsequently causing an early (spurious) return. There is +no wording at all which addresses Detlef's example of a "late return". With +pthread_cond_timedwait this would be caused by setting the system clock +backwards. It seems reasonable to assume, based on the wording that is already +in the POSIX spec, that again, the discontinuously changed clock would be ignored +by pthread_cond_timedwait. +

+ +

+A noteworthy difference between pthread_cond_timedwait and +condition_variable::wait_until is that the POSIX spec appears to +say that ETIMEDOUT should be returned if pthread_cond_timedwait +returns because of timeout signal, whether or not the system clock was discontinuously +advanced during the wait. In contrast condition_variable::wait_until +always returns: +

+ +
Clock::now() < abs_time
+
+ +

+That is, the C++ spec requires that the clock be rechecked (detecting discontinuous +adjustments during the wait) at the time of return. condition_variable::wait_until +may indeed return early or late. But regardless it will return a value +reflecting timeout status at the time of return (even if clocks have been adjusted). +Of course the clock may be adjusted after the return value is computed but before the client has +a chance to read the result of the return. Thus there are no iron-clad guarantees +here. +

+ +

+condition_variable::wait_until (and pthread_cond_timedwait) +is little more than a convenience function for making sure +condition_variable::wait doesn't hang for an unreasonable amount of +time (where the client gets to define "unreasonable"). I do not think it +is in anyone's interest to try to make it into anything more than that. +

+ +

+I maintain that this is a useful and flexible specification in the spirit of +C++, and is implementable on POSIX. The implementation technique described above +is a reasonable approach. There may also be higher quality approaches. This +specification, like the POSIX specification, gives a wide latitude for QOI. +

+ +

+I continue to recommend NAD, but would not object to a clarifying note regarding +the behavior of condition_variable::wait_until. At the moment, I do +not have good wording for such a note, but welcome suggestions. +

+ +
+ +

[ +2009-09-30: See N2969. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+The LWG is in favor of Detlef to supply revision which adopts Option 2 from +N2969 +but is modified by saying that system_clock must be available for wait_until. +
+ +

[ +2010-02-11 Anthony provided wording. +]

+ + +

[ +2010-02-22 Anthony adds: +]

+ + +
+

+I am strongly against +N2999. +

+ +

+Firstly, I think that the most appropriate use of a timed wait on a condition +variable is with a monotonic clock, so it ought to be guaranteed to be available +on systems that support such a clock. Also, making the set of supported clocks +implementation defined essentially kills portability around the use of +user-defined clocks. +

+ +

+I also think that wait_for is potentially useful, and trivially +implementable given a working templated wait_until and a monotonic +clock. +

+ +

+I also disagree with many of Detlef's points in the rationale. In a system with +hard latency limits there is likely to be a monotonic clock, otherwise you have +no way of measuring against these latency limits since the system_clock +may change arbitrarily. In such systems, you want to be able to use +wait_for, or wait_until with a monotonic clock. +

+ +

+I disagree that the wait_* functions cannot be implemented correctly on +top of POSIX: I have done so. The only guarantee in the working draft is that +when the function returns certain properties are true; there is no guarantee +that the function will return immediately that the properties are true. +My resolution to issue 887 makes this clear. How small the latency is is QoI. +

+ +

+On systems without a monotonic clock, you cannot measure the problem since the +system clock can change arbitrarily so any timing calculations you make may be +wrong due to clock changes. +

+ +

+On systems with a monotonic clock, you can choose to use it for your condition +variables. If you are waiting against a system_clock::time_point then +you can check the clock when waking, and either return as a timeout or spurious +wake depending on whether system_clock::now() is before or after the +specified time_point. +

+ +

+Windows does provide condition variables from Vista onwards. I choose +not to use them, but they are there. If people are concerned about +implementation difficulty, the Boost implementation can be used for most +purposes; the Boost license is pretty liberal in that regard. +

+ +

+My preferred resolution to issue 887 is currently the PR in the issues list. +

+
+ +

[ +2010 Pittsburgh: +]

+ + +
+

+There is no consensus for moving the related paper +N2999 +into the WP. +

+

+There was support for moving this issue as proposed to Ready, but the support +was insufficient to call a consensus. +

+

+There was consensus for moving this issue to NAD as opposed to leaving it open. +Rationale added. +

+
+ + + +

Rationale:

+

+The standard as written is sufficiently implementable and self consistent. +

+ + +

Proposed resolution:

+

+Add a new paragraph after 30.2.4 [thread.req.timing]p3: +

+ +
+

+3 The resolution of timing provided by an implementation depends on both +operating system and hardware. The finest resolution provided by an +implementation is called the native resolution. +

+ +

+If a function in this clause takes a timeout argument, and the time point or +elapsed time specified passes before the function returns, the latency between +the timeout occurring and the function returning is unspecified [Note: +Implementations should strive to keep such latency as small as possible, but +portable code should not rely on any specific upper limits — end +note] +

+
+ + + + + +
+

889. thread::id comparisons

+

Section: 30.3.1.1 [thread.thread.id] Status: NAD Editorial + Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2010-10-29

+

View all other issues in [thread.thread.id].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 324

+ +

+The thread::id type supports the full set of comparison operators. This +is substantially more than is required for the associative containers that +justified them. Please place an issue against the threads library. +

+ +

[ +San Francisco: +]

+ + +
+

+Would depend on proposed extension to POSIX, or non-standard extension. +What about hash? POSIX discussing op. POSIX not known to be considering +support needed for hash, op. +

+

+Group expresses support for putting ids in both unordered and ordered containers. +

+
+ +

[ +post San Francisco: +]

+ + +
+

+Howard: It turns out the current working paper +N2723 +already has hash<thread::id> +(20.8 [function.objects], 20.8.15 [unord.hash]). We simply +overlooked it in the meeting. It is a good thing we voted in favor of it +(again). :-) +

+

+Recommend NAD. +

+ +
+ +

[ +Post Summit: +]

+ + +
+Recommend to close as NAD. For POSIX, see if we need to add a function to +convert pthread_t to integer. +
+ +

[ +Post Summit, Alisdair adds: +]

+ + +
+

+The recommendation for LWG-889/UK-324 is NAD, already specified. +

+

+It is not clear to me that the specification is complete. +

+

+In particular, the synopsis of <functional> in 20.8 [function.objects] does not mention hash< thread::id +> nor hash< error_code >, although their +existence is implied by 20.8.15 [unord.hash], p1. +

+

+I am fairly uncomfortable putting the declaration for the +thread_id specialization into <functional> as +id is a nested class inside std::thread, so it implies +that <functional> would require the definition of the +thread class template in order to forward declared +thread::id and form this specialization. +

+

+It seems better to me that the dependency goes the other way around +(<thread> will more typically make use of +<functional> than vice-versa) and the +hash<thread::id> specialization be declared in the +<thread> header. +

+

+I think hash<error_code> could go into either +<system_error> or <functional> and have no +immediate preference either way. However, it should clearly appear in +the synopsis of one of these two. +

+

+Recommend moving 889 back to open, and tying in a reference to UK-324. +

+
+ +

[ +Batavia (2009-05): +]

+ +
+Howard observes that thread::id need not be a nested class; +it could be a typedef for a more visible type. +
+ +

[ +2009-05-24 Alisdair adds: +]

+ +
+I do not believe this is correct. thread::id is explicitly documents as a +nested class, rather than as an unspecified typedef analogous to an +iterator. If the intent is that this is not implemented as a nested class +(under the as-if freedoms) then this is a novel form of standardese. +
+ +

[ +2009-07 Frankfurt +]

+ + +
+Decided we want to move hash specialization for thread_id to the thread +header. Alisdair to provide wording. +
+ +

[ +2009-07-28 Alisdair provided wording, moved to Review. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+Add a strike for hash<thread::id>. Move to Ready +
+ +

[ +2009-11-13 The proposed wording of 1182 is a superset of the +wording in this issue. +]

+ + +

[ +2010-02-09 Moved from Ready to Open: +]

+ + +
+

+Issue 1182 is not quite a superset of this issue and it is controversial +whether or not the note: +

+ +
+hash template specialization allows thread::id objects to be used as keys in +unordered containers. +
+ +

+should be added to the WP. +

+ + +
+ +

[ +2010-02-09 Objections to moving this to NAD Editorial, solved by 1182 have been removed. Set to Tentatively NAD Editorial. +]

+ + + + +

Rationale:

+

+Solved by 1182. +

+ + +

Proposed resolution:

+ +

+Remove the following prototype from the synopsis in +20.8 [function.objects]: +

+ +

+template <> struct hash<std::thread::id>;
+
+ +

+Add to 30.3 [thread.threads], p1 Header <thread> synopsis: +

+ +
template <class T> struct hash;
+template <> struct hash<thread::id>;
+
+ +

+Add template specialization below class definition in 30.3.1.1 [thread.thread.id] +

+ +
template <>
+struct hash<thread::id> : public unary_function<thread::id, size_t> {
+   size_t operator()(thread::id val) const;
+};
+
+ +

+Extend note in p2 30.3.1.1 [thread.thread.id] with second sentence: +

+ +
+[Note: Relational operators allow thread::id objects to be used +as keys in associative containers. +hash template specialization allows thread::id objects to be used as keys +in unordered containers. +— end note] +
+ +

+Add new paragraph to end of 30.3.1.1 [thread.thread.id] +

+ +
template <> struct hash<thread::id>;
+
+
+An explicit specialization of the class template hash (20.8.15 [unord.hash]) +shall be provided for the type thread::id. +
+
+ + + + + +
+

892. Forward_list issues...

+

Section: 23.3.3.5 [forwardlist.ops] Status: NAD Editorial + Submitter: Ed Smith-Rowland Opened: 2008-09-15 Last modified: 2010-10-29

+

View all other issues in [forwardlist.ops].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+I was looking at the latest draft on forward_list. Especially the splice methods. +

+

+The first one splices a whole list after a given iterator in this. The name is splice_after. +I think in 23.3.3.5 [forwardlist.ops] paragraph 40 +change: +

+
+Effect: Insert the contents of x before after position, ... +
+ +

+A deeper issue involves the complexity. forward_list has no size and we +don't know when we've reached the end except to walk up to it. To +splice we would need to hook the end of the source list to the item +after position in this list. This would involve walking length of the +source list until we got to the last dereference-able element in source. +There's no way we could do this in O(1) unless we stored a bogus end in +forward_list. +

+

+OTOH, the last version of splice_after with iterator ranges we could do +in O(1) because we know how to hook the end of the source range to ... +

+

+Unless I'm misconceiving the whole thing. Which is possible. I'll look at it again. +

+

+I'm pretty sure about the first part though. +

+ +

[ +San Francisco: +]

+ + +
+

+This issue is more complicated than it looks. +

+

+paragraph 47: replace each (first, last) with (first, last] +

+

+add a statement after paragraph 48 that complexity is O(1) +

+

+remove the complexity statement from the first overload of splice_after +

+

+We may have the same problems with other modifiers, like erase_after. +Should it require that all iterators in the range (position, last] be +dereferenceable? +

+

+We do, however, like the proposed changes and consider them Editorial. +Move to NAD Editorial, Pending. Howard to open a new issue to handle the +problems with the complexity requirements. +

+

+Opened 897. +

+
+ + +

Proposed resolution:

+

+In 23.3.3.5 [forwardlist.ops] paragraph 40 +change: +

+
+Effect: Insert the contents of x before after position, ... +
+ + + + + +
+

895. "Requires:" on std::string::at et al

+

Section: 17.5.1.4 [structure.specifications] Status: Dup + Submitter: James Dennett Opened: 2008-09-16 Last modified: 2010-10-29

+

View all other issues in [structure.specifications].

+

View all issues with Dup status.

+

Duplicate of: 625

+

Discussion:

+

+Per discussion, we need an issue open to cover looking at "Requires" +clauses which are not constraints on user code, such as that on +std::basic_string::at. +

+ +

[ +2009-07 Frankfurt +]

+ + +
+ Alan to address in paper. +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

897. Forward_list issues... Part 2

+

Section: 23.3.3.4 [forwardlist.modifiers] Status: NAD Editorial + Submitter: Howard Hinnant Opened: 2008-09-22 Last modified: 2010-10-29

+

View all other issues in [forwardlist.modifiers].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+This issue was split off from 892 at the request of the LWG. +

+ +

[ +San Francisco: +]

+ + +
+

+This issue is more complicated than it looks. +

+

+paragraph 47: replace each (first, last) with (first, last] +

+

+add a statement after paragraph 48 that complexity is O(1) +

+

+remove the complexity statement from the first overload of splice_after +

+

+We may have the same problems with other modifiers, like erase_after. +Should it require that all iterators in the range (position, last] be +dereferenceable? +

+
+ +

+There are actually 3 issues here: +

+ +
    +
  1. +

    +What value should erase_after return? With list, code often +looks like: +

    +
    for (auto i = l.begin(); i != l.end();)
+{
+    // inspect *i and decide if you want to erase it
+    // ...
+    if (I want to erase *i)
+        i = l.erase(i);
+    else
+        ++i;
+}
+
    +

    +I.e. the iterator returned from erase is useful for setting up the +logic for operating on the next element. For forward_list this might +look something like: +

    +
    auto i = fl.before_begin();
+auto ip1 = i;
+for (++ip1; ip1 != fl.end(); ++ip1)
+{
+    // inspect *(i+1) and decide if you want to erase it
+    // ...
+    if (I want to erase *(i+1))
+        i = fl.erase_after(i);
+    else
+        ++i;
+    ip1 = i;
+}
+
    +

    +In the above example code, it is convenient if erase_after returns +the element prior to the erased element (range) instead of the element +after the erase element (range). +

    +

    +Existing practice: +

    +
      +
    • SGI slist returns an iterator referencing the element after the erased range.
      • +
    • CodeWarrior slist returns an iterator referencing the element before the erased range.
      • +
    +

    +There is not a strong technical argument for either solution over the other. +

    +
    2. + +
  2. +

    +With all other containers, operations always work on the range +[first, last) and/or prior to the given position. +

    +

    +With forward_list, operations sometimes work on the range +(first, last] and/or after the given position. +

    +

    +This is simply due to the fact that in order to operate on +*first (with forward_list) one needs access to +*(first-1). And that's not practical with +forward_list. So the operating range needs to start with (first, +not [first (as the current working paper says). +

    +

    +Additionally, if one is interested in splicing the range (first, last), +then (with forward_list), one needs practical (constant time) access to +*(last-1) so that one can set the next field in this node to +the proper value. As this is not possible with forward_list, one must +specify the last element of interest instead of one past the last element of +interest. The syntax for doing this is to pass (first, last] instead +of (first, last). +

    +

    +With erase_after we have a choice of either erasing the range +(first, last] or (first, last). Choosing the latter +enables: +

    +
    x.erase_after(pos, x.end());
+
    + +

    +With the former, the above statement is inconvenient or expensive due to the lack +of constant time access to x.end()-1. However we could introduce: +

    + +
    iterator erase_to_end(const_iterator position);
+
    + +

    +to compensate. +

    + +

    +The advantage of the former ((first, last]) for erase_after +is a consistency with splice_after which uses (first, last] +as the specified range. But this either requires the addition of erase_to_end +or giving up such functionality. +

    + +
    3. + +
  3. +As stated in the discussion of 892, and reienforced by point 2 above, +a splice_after should work on the source range (first, last] +if the operation is to be Ο(1). When splicing an entire list x the +algorithm needs (x.before_begin(), x.end()-1]. Unfortunately x.end()-1 +is not available in constant time unless we specify that it must be. In order to +make x.end()-1 available in constant time, the implementation would have +to dedicate a pointer to it. I believe the design of +N2543 +intended a nominal overhead of foward_list of 1 pointer. Thus splicing +one entire forward_list into another can not be Ο(1). +
    4. +
+ +

[ +Batavia (2009-05): +]

+ +
+

+We agree with the proposed resolution. +

+

+Move to Review. +

+
+ +

[ +2009-07 Frankfurt +]

+ + +
+

+We may need a new issue to correct splice_after, because it may no +longer be correct to accept an rvalues as an argument. Merge may be +affected, too. This might be issue 1133. (Howard: confirmed) +

+

+Move this to Ready, but the Requires clause of the second form of +splice_after should say "(first, last)," not "(first, last]" (there are +three occurrences). There was considerable discussion on this. (Howard: fixed) +

+

+Alan suggested removing the "foward_last<T. Alloc>&& x" +parameter from the second form of splice_after, because it is redundant. +PJP wanted to keep it, because it allows him to check for bad ranges +(i.e. "Granny knots"). +

+

+We prefer to keep x. +

+

+Beman. Whenever we deviate from the customary half-open range in the +specification, we should add a non-normative comment to the standard +explaining the deviation. This clarifies the intention and spares the +committee much confusion in the future. +

+

+Alan to write a non-normative comment to explain the use of fully-closed ranges. +

+

+Move to Ready, with the changes described above. (Howard: awaiting note from Alan) +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial, addressed by +N2988. +
+ + + +

Proposed resolution:

+

+Wording below assumes issue 878 is accepted, but this issue is +independent of that issue. +

+ +

+Change 23.3.3.4 [forwardlist.modifiers]: +

+ +
+
iterator erase_after(const_iterator position);
+
+
+

+Requires: The iterator following position is dereferenceable. +

+

+Effects: Erases the element pointed to by the iterator following position. +

+

+Returns: An iterator pointing to the element following the one that was erased, or end() if no such +element exists +An iterator equal to position. +

+
+ + +
iterator erase_after(const_iterator position, const_iterator last);
+
+
+

+Requires: All iterators in the range +[(position,last) +are dereferenceable. +

+

+Effects: Erases the elements in the range +[(position,last). +

+

+Returns: An iterator equal to position last +

+
+
+ +

+Change 23.3.3.5 [forwardlist.ops]: +

+ +
+
void splice_after(const_iterator position, forward_list<T,Allocator>&& x);
+
+
+

+Requires: position is before_begin() or a +dereferenceable iterator in the range [begin(), end)). &x != this. +

+

+Effects: Inserts the contents of x after position, and +x becomes empty. Pointers and references to +the moved elements of x now refer to those same elements but as members of *this. +Iterators referring to the moved elements will continue to refer to their elements, +but they now behave as iterators into *this, not into x. +

+

+Throws: Nothing. +

+

+Complexity: Ο(1) Ο(distance(x.begin(), x.end())) +

+
+ +

...

+ +
void splice_after(const_iterator position, forward_list<T,Allocator>&& x, 
+                  const_iterator first, const_iterator last);
+
+
+

+Requires: position is before_begin() or a +dereferenceable iterator in the range [begin(), end)). +(first,last) is a valid range in +x, and all iterators in the range +(first,last) are dereferenceable. +position is not an iterator in the range (first,last). +

+

+Effects: Inserts elements in the range (first,last) +after position and removes the elements from x. +Pointers and references to the moved elements of x now refer to +those same elements but as members of *this. Iterators +referring to the moved elements will continue to refer to their +elements, but they now behave as iterators into *this, not into +x. +

+

+Complexity: Ο(1). +

+
+ +
+ + + + + + +
+

901. insert iterators can move from lvalues

+

Section: 24.5.2.5 [insert.iterator] Status: NAD + Submitter: Alisdair Meredith Opened: 2008-09-24 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

Addresses UK 282

+ +

+The requires clause on the const T & overloads in +back_insert_iterator/front_insert_iterator/insert_iterator mean that the +assignment operator will implicitly move from lvalues of a move-only type. +

+

+Suggested resolutions are: +

+
    +
  1. +Add another overload with a negative constraint on copy-constructible +and flag it "= delete". +
    2. +
  2. +Drop the copy-constructible overload entirely and rely on perfect +forwarding to catch move issues one level deeper. +
    3. +
  3. +This is a fundamental problem in move-syntax that relies on the +presence of two overloads, and we need to look more deeply into this +area as a whole - do not solve this issue in isolation. +
    4. +
+ +

[ +Post Summit, Alisdair adds: +]

+ + +
+

+Both comment and issue have been resolved by the adoption of +N2844 +(rvalue references safety fix) at the last meeting. +

+ +

+Suggest resolve as NAD Editorial with a reference to the paper. +

+
+ +

[ +Batavia (2009-05): +]

+ +
+We agree that this has been resolved in the latest Working Draft. +Move to NAD. +
+ + +

Proposed resolution:

+

+Recommend NAD, addressed by N2844. +

+ + + + + +
+

902. Regular is the wrong concept to constrain numeric_limits

+

Section: 18.3.1 [limits] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2008-09-24 Last modified: 2010-10-29

+

View all other issues in [limits].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses FR 32 and DE 16

+ +

+numeric_limits has functions specifically designed to return NaNs, which +break the model of Regular (via its axioms.) While floating point types +will be acceptible in many algorithms taking Regular values, it is not +appopriate for this specific API and we need a less refined constraint. +

+ +

FR 32:

+ +
+The definition of numeric_limits<> as requiring a regular +type is both conceptually wrong and operationally illogical. As we +pointed before, this mistake needs to be corrected. For example, the +template can be left unconstrained. In fact this reflects a much more +general problem with concept_maps/axioms and their interpretations. It +appears that the current text heavily leans toward experimental academic +type theory. +
+ +

DE 16:

+ +
+The class template numeric_limits should not specify the Regular concept +requirement for its template parameter, because it contains functions +returning NaN values for floating-point types; these values violate the +semantics of EqualityComparable. +
+ +

[ +Summit: +]

+ + +
+Move to Open. Alisdair and Gaby will work on a solution, along with the new +treatment of axioms in clause 14. +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

903. back_insert_iterator issue

+

Section: 24.5.2.1 [back.insert.iterator] Status: NAD + Submitter: Dave Abrahams Opened: 2008-09-19 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+I just noticed this; don't know how far the problem(?) extends or +whether it's new or existing: back_insert_iterator's operator* is not +const, so you can't dereference a const one. +

+ +

[ +Post Summit Daniel adds: +]

+ + +
+

+If done, this change should be applied for front_insert_iterator, +insert_iterator, ostream_iterator, and ostreambuf_iterator as well. +

+
+ +

[ +Batavia (2009-05): +]

+ +
+

+Alisdair notes that these all are output iterators. +Howard points out that ++*i +would no longer work if we made this change. +

+

+Move to NAD. +

+
+ +

[ +2009-05-25 Daniel adds: +]

+ + +
    +
  1. +If 1009 is accepted, OutputIterator does no longer support post increment. +
    2. +
  2. +To support backward compatibility a second overload of operator* +can be added. +Note that the HasDereference concept (and the HasDereference part of concept +Iterator) was specifically refactored to cope with optional const +qualification and +to properly reflect the dual nature of built-in operator* as of +13.5.8 [over.literal]/6. +
    3. +
+ + +

Proposed resolution:

+ + + + + +
+

905. Mutex specification questions

+

Section: 30.4.1.2.1 [thread.mutex.class] Status: Dup + Submitter: Herb Sutter Opened: 2008-09-18 Last modified: 2010-10-29

+

View all other issues in [thread.mutex.class].

+

View all issues with Dup status.

+

Duplicate of: 893

+

Discussion:

+

+A few questions on the current WP, +N2723: +

+

+30.4.1 [thread.mutex.requirements]/24 says an expression +mut.unlock() "Throws: Nothing." I'm assuming that, per 17.6.3.11 [res.on.required], errors that violate the precondition "The +calling thread shall own the mutex" opens the door for throwing an +exception anyway, such as to report unbalanced unlock operations and +unlocking from a thread that does not have ownership. Right? +

+

+30.4.1.2.1 [thread.mutex.class]/3 (actually numbered paragraph "27" +in the WP; this is just a typo I think) says +

+
+

+The behavior of a program is undefined if: +

+ +
+ +

+As already discussed, I think the second bullet should be removed, and +such a lock() or try_lock() should fail with an +exception or returning false, respectively. +

+

+A potential addition to the list would be +

+ +

+but without that the status quo text endorses the technique of the +program logically transferring ownership of a mutex to another thread +with correctness enforced by programming discipline. Was that intended? +

+ +

[ +Summit: +]

+ + +
+

+Two resolutions: "not a defect" and "duplicate", as follows: +

+ +
+ + +

Proposed resolution:

+ + + + + + +
+

906. ObjectType is the wrong concept to constrain initializer_list

+

Section: 18.9 [support.initlist] Status: NAD Concepts + Submitter: Daniel Krügler Opened: 2008-09-26 Last modified: 2010-10-29

+

View all issues with NAD Concepts status.

+

Discussion:

+

+The currently proposed constraint on initializer_list's element type +E is that is has to meet ObjectType. This is an underspecification, +because both core language and library part of initializer_list +make clear, that it references an implicitly allocated array: +

+

+8.5.4 [dcl.init.list]/4: +

+
+When an initializer list is implicitly converted to a +std::initializer_list<E>, the object passed is constructed as if the +implementation allocated an array of N elements of type E, where +N is the number of elements in the initializer list.[..] +
+ +

+18.9 [support.initlist]/2. +

+ +
+An object of type initializer_list<E> provides access to an array of +objects of type const E.[..] +
+ +

+Therefore, E needs to fulfill concept ValueType (thus excluding +abstract class types). This stricter requirement should be added +to prevent deep instantiation errors known from the bad old times, +as shown in the following example: +

+ +
// Header A: (Should concept-check even in stand-alone modus)
+
+template <DefaultConstructible T>
+requires MoveConstructible<T>
+void generate_and_do_3(T a) {
+  std::initializer_list<T> list{T(), std::move(a), T()};
+  ...
+}
+
+void do_more();
+void do_more_or_less();
+
+template <DefaultConstructible T>
+requires MoveConstructible<T>
+void more_generate_3() {
+  do_more();
+  generate_and_do_3(T());
+}
+
+template <DefaultConstructible T>
+requires MoveConstructible<T>
+void something_and_generate_3() {
+  do_more_or_less();
+  more_generate_3();
+}
+
+// Test.cpp
+
+#include "A.h"
+
+class Abstract {
+public:
+  virtual ~Abstract();
+  virtual void foo() = 0; // abstract type
+  Abstract(Abstract&&){} // MoveConstructible
+  Abstract(){} // DefaultConstructible
+};
+
+int main() {
+  // The restricted template *accepts* the argument, but
+  // causes a deep instantiation error in the internal function
+  // generate_and_do_3:
+  something_and_generate_3<Abstract>();
+}
+
+ +

+The proposed stricter constraint does not minimize the aim to +support more general containers for which ObjectType would be +sufficient. If such an extended container (lets assume it's still a +class template) provides a constructor that accepts an initializer_list +only this constructor would need to be restricted on ValueType: +

+ +
template<ObjectType T>
+class ExtContainer {
+public:
+  requires ValueType<T>
+  ExtContainer(std::initializer_list<T>);
+  ...
+};
+
+ +

[ +Batavia (2009-05): +]

+ +
+Move to Tentatively Ready. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Need to look at again without concepts. +
+ + + +

Proposed resolution:

+
    +
  1. +In 18.9 [support.initlist]/p.1 replace in "header <initializer_list> synopsis" +the constraint "ObjectType" in the template parameter list by the +constraint "ValueType". +
    2. +
+ + + + + + +
+

908. Deleted assignment operators for atomic types must be volatile

+

Section: X [atomics.types] Status: NAD Editorial + Submitter: Anthony Williams Opened: 2008-09-26 Last modified: 2010-10-29

+

View all other issues in [atomics.types].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses US 90

+ +

+The deleted copy-assignment operators for the atomic types are not +marked as volatile in N2723, whereas the assignment operators from the +associated non-atomic types are. e.g. +

+
atomic_bool& operator=(atomic_bool const&) = delete;
+atomic_bool& operator=(bool) volatile;
+
+ +

+This leads to ambiguity when assigning a non-atomic value to a +non-volatile instance of an atomic type: +

+
atomic_bool b;
+b=false;
+
+ +

+Both assignment operators require a standard conversions: the +copy-assignment operator can use the implicit atomic_bool(bool) +conversion constructor to convert false to an instance of +atomic_bool, or b can undergo a qualification conversion in order to +use the assignment from a plain bool. +

+ +

+This is only a problem once issue 845 is applied. +

+ +

[ +Summit: +]

+ +
+Move to open. Assign to Lawrence. Related to US 90 comment. +
+ +

[ +2009-08-17 Handled by +N2925. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+

+Add volatile qualification to the deleted copy-assignment operator of +all the atomic types: +

+ +
atomic_bool& operator=(atomic_bool const&) volatile = delete;
+atomic_itype& operator=(atomic_itype const&) volatile = delete;
+
+ +

+etc. +

+

+This will mean that the deleted copy-assignment operator will require +two conversions in the above example, and thus be a worse match than +the assignment from plain bool. +

+ + + + + +
+

910. Effects of MoveAssignable

+

Section: 20.2.1 [utility.arg.requirements] Status: NAD Concepts + Submitter: Alberto Ganesh Barbati Opened: 2008-09-29 Last modified: 2010-10-29

+

View all other issues in [utility.arg.requirements].

+

View all issues with NAD Concepts status.

+

Discussion:

+

Addresses UK 150

+ +

+The description of the effect of operator= in the MoveAssignable +concept, given in paragraph 7 is: +

+ +
result_type  T::operator=(T&&  rv);  // inherited from HasAssign<T, T&&>
+
+ +
+Postconditions: the constructed T object is equivalent to the value of +rv before the assignment. [Note: there is no +requirement on the value of rv after the assignment. --end note] +
+
+ +

+The sentence contains a typo (what is the "constructed T object"?) +probably due to a cut&paste from MoveConstructible. Moreover, the +discussion of LWG issue 675 shows that the postcondition is too generic +and might not reflect the user expectations. An implementation of the +move assignment that just calls swap() would always fulfill the +postcondition as stated, but might have surprising side-effects in case +the source rvalue refers to an object that is not going to be +immediately destroyed. See LWG issue 900 for another example. Due to +the sometimes intangible nature of the "user expectation", it seems +difficult to have precise normative wording that could cover all cases +without introducing unnecessary restrictions. However a non-normative +clarification could be a very helpful warning sign that swapping is not +always the correct thing to do. +

+ +

[ +2009-05-09 Alisdair adds: +]

+ + +
+

+Issue 910 is exactly the reason BSI advanced the Editorial comment UK-150. +

+

+The post-conditions after assignment are at a minimum that the object +referenced by rv must be safely destructible, and the transaction should not +leak resources. Ideally it should be possible to simply assign rv a new +valid state after the call without invoking undefined behaviour, but any +other use of the referenced object would depend upon additional guarantees +made by that type. +

+
+ +

[ +2009-05-09 Howard adds: +]

+ + +
+

+The intent of the rvalue reference work is that the moved from rv is +a valid object. Not one in a singular state. If, for example, the moved from +object is a vector, one should be able to do anything on that moved-from +vector that you can do with any other vector. However you would +first have to query it to find out what its current state is. E.g. it might have capacity, +it might not. It might have a non-zero size, it might not. But regardless, +you can push_back on to it if you want. +

+ +

+That being said, most standard code is now conceptized. That is, the concepts +list the only operations that can be done with templated types - whether or not +the values have been moved from. +

+ +

+Here is user-written code which must be allowed to be legal: +

+
#include <vector>
+#include <cstdio>
+
+template <class Allocator>
+void
+inspect(std::vector<double, Allocator>&& v)
+{
+    std::vector<double, Allocator> result(move(v));
+    std::printf("moved from vector has %u size and %u capacity\n", v.size(), v.capacity());
+    std::printf("The contents of the vector are:\n");
+    typedef typename std::vector<double, Allocator>::iterator I;
+    for (I i = v.begin(), e = v.end(); i != e; ++i)
+        printf("%f\n", *i);
+}
+
+int main()
+{
+    std::vector<double> v1(100, 5.5);
+    inspect(move(v1));
+}
+
+ +

+The above program does not treat the moved-from vector as singular. It +only treats it as a vector with an unknown value. +

+

+I believe the current proposed wording is consistent with my view on this. +

+
+ +

[ +Batavia (2009-05): +]

+ +
+We agree that the proposed resolution +is an improvement over the current wording. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Need to look at again without concepts. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Walter will consult with Dave and Doug. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+We believe this is handled by the resolution to issue 1204, +but there is to much going on in this area to be sure. Defer for now. +
+ +

[ +2010-01-23 Moved to Tentatively NAD Concepts after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + + +

Rationale:

+

+The current MoveAssignable requirements say everything that can be said +in general. Each std-defined type has a more detailed specification of move +assignment. +

+ + +

Proposed resolution:

+

+In [concept.copymove], replace the postcondition in paragraph 7 with: +

+ +
+Postconditions: *this is equivalent to the value of rv before the +assignment. [Note: there is no requirement on the value of rv after the +assignment, but the +effect should be unsurprising to the user even in case rv is not +immediately destroyed. This may require that resources previously owned +by *this are released instead of transferred to rv. -- end note] +
+ + + + + +
+

912. Array swap needs to be conceptualized

+

Section: 25.3.3 [alg.swap] Status: NAD Concepts + Submitter: Daniel Krügler Opened: 2008-10-01 Last modified: 2010-10-29

+

View all other issues in [alg.swap].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+With the adaption of 809 +we have a new algorithm swap for C-arrays, which needs to be conceptualized. +

+ +

[ +Post Summit Daniel adds: +]

+ + +
+Recommend as NAD Editorial: The changes have already been applied to the WP +N2800. +
+ +

[ +Batavia (2009-05): +]

+ +
+Move to NAD; the changes have already been made. +
+ + +

Proposed resolution:

+

+Replace in 25.3.3 [alg.swap] before p. 3 until p. 4 by +

+ +
template <class ValueType T, size_t N>
+requires Swappable<T>
+void swap(T (&a)[N], T (&b)[N]);
+
+
+

+Requires: T shall be Swappable. +

+

+Effects: swap_ranges(a, a + N, b); +

+
+
+ + + + + + +
+

913. Superfluous requirements for replace algorithms

+

Section: 25.3.5 [alg.replace] Status: NAD Concepts + Submitter: Daniel Krügler Opened: 2008-10-03 Last modified: 2010-10-29

+

View all other issues in [alg.replace].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+(A) 25.3.5 [alg.replace]/1: +

+ +
+Requires: The expression *first = new_value shall be valid. +
+ +

+(B) 25.3.5 [alg.replace]/4: +

+ +
+Requires: The results of the expressions *first and new_value shall +be writable to the result output iterator.[..] +
+ +

+Since conceptualization, the quoted content of these clauses is covered +by the existing requirements +

+ +

+(A) OutputIterator<Iter, const T&> +

+ +

+and +

+ +

+(B) OutputIterator<OutIter, InIter::reference> && OutputIterator<OutIter, const T&> +

+ +

+resp, and thus should be removed. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+We agree with the proposed resolution. +

+

+Move to Tentatively Ready. +

+
+ + +

Proposed resolution:

+
    +
  1. +

    +Remove 25.3.5 [alg.replace]/1. +

    +
    template<ForwardIterator Iter, class T> 
+  requires OutputIterator<Iter, Iter::reference> 
+        && OutputIterator<Iter, const T&> 
+        && HasEqualTo<Iter::value_type, T> 
+  void replace(Iter first, Iter last, 
+               const T& old_value, const T& new_value); 
+
+template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred, class T> 
+  requires OutputIterator<Iter, Iter::reference> 
+        && OutputIterator<Iter, const T&> 
+        && CopyConstructible<Pred> 
+  void replace_if(Iter first, Iter last, 
+                  Pred pred, const T& new_value);
+
    +
    +1 Requires: The expression *first = new_value shall be valid. +
    +
    +
    2. +
  2. +

    +25.3.5 [alg.replace]/4: Remove the sentence "The results of the +expressions *first and +new_value shall be writable to the result output iterator.". +

    +
    template<InputIterator InIter, typename OutIter, class T> 
+  requires OutputIterator<OutIter, InIter::reference> 
+        && OutputIterator<OutIter, const T&> 
+        && HasEqualTo<InIter::value_type, T> 
+  OutIter replace_copy(InIter first, InIter last, 
+                       OutIter result, 
+                       const T& old_value, const T& new_value);
+
+template<InputIterator InIter, typename OutIter,
+         Predicate<auto, InIter::value_type> Pred, class T> 
+  requires OutputIterator<OutIter, InIter::reference> 
+        && OutputIterator<OutIter, const T&> 
+        && CopyConstructible<Pred> 
+  OutIter replace_copy_if(InIter first, InIter last, 
+                          OutIter result, 
+                          Pred pred, const T& new_value);
+
    +
    +4 Requires: The results of the expressions *first and +new_value shall be writable to the result output +iterator. The ranges [first,last) and [result,result + +(last - first)) shall not overlap. +
    +
    +
    3. +
+ + + + + +
+

914. Superfluous requirement for unique

+

Section: 25.3.9 [alg.unique] Status: NAD Concepts + Submitter: Daniel Krügler Opened: 2008-10-03 Last modified: 2010-10-29

+

View all other issues in [alg.unique].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+25.3.9 [alg.unique]/2: "Requires: The comparison function shall be an +equivalence relation." +

+ +

+The essence of this is already covered by the given requirement +

+ +
EquivalenceRelation<auto, Iter::value_type> Pred
+
+ +

+and should thus be removed. +

+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the proposed resolution. +Move to Tentatively Ready. +
+ + +

Proposed resolution:

+

+Remove 25.3.9 [alg.unique]/2 +

+ +
template<ForwardIterator Iter>
+  requires OutputIterator<Iter, Iter::reference>
+        && EqualityComparable<Iter::value_type>
+  Iter unique(Iter first, Iter last);
+
+template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred>
+  requires OutputIterator<Iter, RvalueOf<Iter::reference>::type>
+        && CopyConstructible<Pred>
+  Iter unique(Iter first, Iter last,
+               Pred pred);
+
+
+

+1 Effects: ... +

+

+2 Requires: The comparison function shall be an equivalence relation. +

+
+
+ + + + + +
+

915. minmax with initializer_list should return +pair of T, not pair of const T&

+

Section: 25.4.7 [alg.min.max] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2010-10-29

+

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

+

View all issues with NAD Editorial status.

+

Discussion:

+

+It seems that the proposed changes for +N2772 +were not clear enough in +this point: +

+ +
+25.4.7 [alg.min.max], before p.23 + p.24 + before p. 27 + p. 28 say that the return +type of the minmax overloads with an initializer_list is +pair<const T&, const T&>, +which is inconsistent with the decision for the other min/max overloads which take +a initializer_list as argument and return a T, not a const T&. +Doing otherwise for minmax would easily lead to unexpected life-time +problems by using minmax instead of min and max separately. +
+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the proposed resolution. +Move to Tentatively Ready. +
+ +

[ +2009-07 Frankfurt +]

+ + +
+Moved from Tentatively Ready to Open only because the wording needs to be +tweaked for concepts removal. +
+ +

[ +2009-08-18 Daniel adds: +]

+ + +
+Recommend NAD since the proposed changes have already been performed +as part of editorial work of +N2914. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Can't find initializer_list form of minmax anymore, only variadic +version. Seems like we had an editing clash with concepts. Leave Open, +at least until editorial issues resolved. Bring this to Editor's +attention. +
+ +

[ +2010 Pittsburgh: Pete to reapply +N2772. +]

+ + + + +

Rationale:

+Solved by reapplying +N2772. + + +

Proposed resolution:

+
    +
  1. +

    +In 25 [algorithms]/2, header <algorithm> synopsis change as indicated: +

    + +
    template<classLessThanComparable T>
+requires CopyConstructible<T>
+pair<const T&, const T&>
+minmax(initializer_list<T> t);
+
+template<class T, classStrictWeakOrder<auto, T> Compare>
+requires CopyConstructible<T>
+pair<const T&, const T&>
+minmax(initializer_list<T> t, Compare comp);
+
    +
    2. +
  2. +

    +In 25.4.7 [alg.min.max] change as indicated (Begin: Just before p.20): +

    +
    template<classLessThanComparable T>
+  requires CopyConstructible<T>
+  pair<const T&, const T&>
+  minmax(initializer_list<T> t);
+
    +
    +

    +-20- Requires: T is LessThanComparable and +CopyConstructible. +

    +

    +-21- Returns: pair<const T&, const +T&>(x, y) where x is the +smallest value and y the largest value in the initializer_list. +

    +
    + +

    [..]

    +
    template<class T, classStrictWeakOrder<auto, T> Compare>
+  requires CopyConstructible<T>
+  pair<const T&, const T&>
+  minmax(initializer_list<T> t, Compare comp);
+
    + +
    +

    +-24- Requires: type T is LessThanComparable and CopyConstructible. +

    +

    +-25- Returns: pair<const T&, const +T&>(x, y) where x is the +smallest value and y largest value in the initializer_list. +

    +
    +
    +
    3. +
+ + + + + + +
+

916. Redundant move-assignment operator of pair should be removed

+

Section: 20.3.5 [pairs] Status: NAD + Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2010-10-29

+

View all other issues in [pairs].

+

View all issues with NAD status.

+

Discussion:

+

see also 917.

+ +

+The current WP provides the following assignment operators for pair +in 20.3.5 [pairs]/1: +

+ +
    +
  1. +
    template<class U , class V>
+requires HasAssign<T1, const U&> && HasAssign<T2, const V&>
+pair& operator=(const pair<U , V>& p);
+
    +
    2. +
  2. +
    requires MoveAssignable<T1> && MoveAssignable<T2> pair& operator=(pair&& p );
+
    +
    3. +
  3. +
    template<class U , class V>
+requires HasAssign<T1, RvalueOf<U>::type> && HasAssign<T2, RvalueOf<V>::type>
+pair& operator=(pair<U , V>&& p);
+
    +
    4. +
+ +

+It seems that the functionality of (2) is completely covered by (3), therefore +(2) should be removed. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+Bill believes the extra assignment operators are necessary for resolving +ambiguities, but that does not mean it needs to be part of the specification. +

+

+Move to Open. +We recommend this be looked at in the context of the ongoing work +related to the pair templates. +

+
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Leave this open pending the removal of concepts from the WD. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD, see issue 801. +
+ + + +

Proposed resolution:

+
    +
  1. +

    +In 20.3.5 [pairs] p. 1, class pair and just before p. 13 remove the declaration: +

    + +
    requires MoveAssignable<T1> && MoveAssignable<T2> pair& operator=(pair&& p );
+
    +
    2. + +
  2. +Remove p.13+p.14 +
    3. + +
+ + + + + +
+

917. Redundant move-assignment operator of tuple should be removed

+

Section: 20.4.2.1 [tuple.cnstr] Status: NAD + Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2010-10-29

+

View all other issues in [tuple.cnstr].

+

View all issues with NAD status.

+

Discussion:

+

see also 916.

+

+N2770 (and thus now the WP) removed the +non-template move-assignment operator from tuple's class definition, +but the latter individual member description does still provide this +operator. Is this (a) an oversight and can it (b) be solved as part of an +editorial process? +

+ +

[ +Post Summit Daniel provided wording. +]

+ + +

[ +Batavia (2009-05): +]

+ +
+

+We believe that the proposed resolution's part 1 is editorial. +

+

+Regarding part 2, we either remove the specification as proposed, +or else add back the declaration to which the specification refers. +Alisdair and Bill prefer the latter. +It is not immediately obvious whether the function is intended to be present. +

+

+We recommend that the Project Editor restore the missing declaration +and that we keep part 2 of the issue alive. +

+

+Move to Open. +

+
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Leave this open pending the removal of concepts from the WD. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD, see issue 801. +
+ + + +

Proposed resolution:

+
    +
  1. +

    +In 20.4.2 [tuple.tuple], class tuple just before member swap please +change as indicated: +

    +

    [ +This fixes an editorial loss between N2798 to N2800 +]

    + +
    template <class... UTypes>
+requires HasAssign<Types, const UTypes&>...
+tuple& operator=(const pair<UTypes...>&);
+
+template <class... UTypes>
+requires HasAssign<Types, RvalueOf<UTypes>::type>...
+tuple& operator=(pair<UTypes...>&&);
+
    +
    2. +
  2. +

    +In 20.4.2.1 [tuple.cnstr], starting just before p. 11 please remove +as indicated: +

    + +
    requires MoveAssignable<Types>... tuple& operator=(tuple&& u);
+
    +
    +

    +-11- Effects: Move-assigns each element of u to the corresponding +element of *this. +

    +

    +-12- Returns: *this. +

    +
    +
    +
    3. +
+ + + + + +
+

918. Swap for tuple needs to be conceptualized

+

Section: 20.4.2.3 [tuple.swap] Status: NAD Concepts + Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2010-10-29

+

View all issues with NAD Concepts status.

+

Discussion:

+

+Issue 522 was accepted after tuple had been conceptualized, +therefore this step needs to be completed. +

+ +

[ +Post Summit Daniel adds +]

+ + +
+This is now NAD Editorial (addressed by +N2844) +except for item 3 in the proposed wording. +
+ +

[ +2009-05-01 Daniel adds: +]

+ + +
+As of the recent WP +(N2857), +this issue is now completely covered by editorial +changes (including the third bullet), therefore I unconditionally recommend +NAD. +
+ +

[ +Batavia (2009-05): +]

+ +
+

+We observed that all the proposed changes have already been applied to the +Working Draft, rendering this issue moot. +

+

+Move to NAD. +

+
+ + + +

Proposed resolution:

+
    +
  1. +

    +In both 20.4.1 [tuple.general]/2 and 20.4.2.9 [tuple.special] change +

    + +
    template <class Swappable... Types>
+void swap(tuple<Types...>& x, tuple<Types...>& y);
+
    + +
    2. + +
  2. +

    +In 20.4.2 [tuple.tuple], class tuple definition and in +20.4.2.3 [tuple.swap], change +

    + +
    requires Swappable<Types>...void swap(tuple&);
+
    + +
    3. + +
  3. +

    +In 20.4.2.3 [tuple.swap] remove the current requires-clause, which says: +

    + +
    +Requires: Each type in Types shall be Swappable +
    +
    4. + +
+ + + + + + +
+

919. (forward_)list specialized remove algorithms are over constrained

+

Section: 23.3.3.5 [forwardlist.ops], 23.3.4.4 [list.ops] Status: NAD + Submitter: Daniel Krügler Opened: 2008-10-06 Last modified: 2010-10-29

+

View all other issues in [forwardlist.ops].

+

View all issues with NAD status.

+

Discussion:

+

+The signatures of forwardlist::remove and list::remove +defined in 23.3.3.5 [forwardlist.ops] before 11 + 23.3.4.4 [list.ops] before 15: +

+ +
requires EqualityComparable<T> void remove(const T& value);
+
+ +

+are asymmetric to their predicate variants (which only require +Predicate, not EquivalenceRelation) and with the free algorithm +remove (which only require HasEqualTo). Also, nothing in the +pre-concept WP +N2723 +implies that EqualityComparable should +be the intended requirement. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+We agree with the proposed resolution, +but would like additional input from concepts experts. +

+

+Move to Review. +

+
+ +

[ +2009-07-21 Alisdair adds: +]

+ + +
+Current rationale and wording for this issue is built around concepts. I +suggest the issue reverts to Open status. I believe there is enough of +an issue to review after concepts are removed from the WP to re-examine +the issue in Santa Cruz, rather than resolve as NAD Concepts. +
+ +

[ +2009-10-10 Daniel adds: +]

+ + +
+Recommend NAD: The concept-free wording as of +N2960 +has no longer the +over-specified requirement +EqualityComparable for the remove function that uses ==. In fact, now +the same test conditions exists +as for the free algorithm remove (25.3.8 [alg.remove]). The error was +introduced in the process of conceptifying. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD, solved by the removal of concepts. +
+ + + +

Proposed resolution:

+
    +
  1. +

    +Replace in 23.3.3.5 [forwardlist.ops] before 11 and in 23.3.4.4 [list.ops] before 15 +

    + +
    requires EqualityComparable<T> HasEqualTo<T, T> void remove(const T& value);
+
    +
    2. +
+ + + + + + +
+

923. atomics with floating-point

+

Section: 29 [atomics] Status: NAD Editorial + Submitter: Herb Sutter Opened: 2008-10-17 Last modified: 2010-10-29

+

View other active issues in [atomics].

+

View all other issues in [atomics].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Right now, C++0x doesn't have atomic<float>. We're thinking of adding +the words to support it for TR2 (note: that would be slightly +post-C++0x). If we need it, we could probably add the words. +

+

+Proposed resolutions: Using atomic<FP>::compare_exchange (weak or +strong) should be either: +

+ +
    +
  1. +ill-formed, or +
    2. +
  2. +well-defined. +
    3. +
+ +

+I propose Option 1 for C++0x for expediency. If someone wants to argue +for Option 2, they need to say what exactly they want compare_exchange +to mean in this case (IIRC, C++0x doesn't even assume IEEE 754). +

+ +

[ +Summit: +]

+ + +
+Move to open. Blocked until concepts for atomics are addressed. +
+ +

[ +Post Summit Anthony adds: +]

+ + +
+

+Recommend NAD. C++0x does have std::atomic<float>, and both +compare_exchange_weak and compare_exchange_strong are well-defined in +this case. Maybe change the note in 29.6 [atomics.types.operations] paragraph 20 to: +

+ +
+

+[Note: The effect of the compare-and-exchange operations is +

+
if (!memcmp(object,expected,sizeof(*object)))
+    *object = desired;
+else
+    *expected = *object;
+
+ +

+This may result in failed comparisons for values that compare equal if +the underlying type has padding bits or alternate representations of +the same value. -- end note] +

+
+ +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+

+Change the note in 29.6 [atomics.types.operations] paragraph 20 to: +

+ +
+

+[Note: The effect of the compare-and-exchange operations is +

+
if (*object == *expected !memcmp(object,expected,sizeof(*object)))
+    *object = desired;
+else
+    *expected = *object;
+
+ +

+This may result in failed comparisons for values that compare equal if +the underlying type has padding bits or alternate representations of +the same value. -- end note] +

+
+ + + + + + +
+

924. structs with internal padding

+

Section: 29 [atomics] Status: NAD Editorial + Submitter: Herb Sutter Opened: 2008-10-17 Last modified: 2010-10-29

+

View other active issues in [atomics].

+

View all other issues in [atomics].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Right now, the compare_exchange_weak loop should rapidly converge on the +padding contents. But compare_exchange_strong will require a bit more +compiler work to ignore padding for comparison purposes. +

+

+Note that this isn't a problem for structs with no padding, and we do +already have one portable way to ensure that there is no padding that +covers the key use cases: Have elements be the same type. I suspect that +the greatest need is for a structure of two pointers, which has no +padding problem. I suspect the second need is a structure of a pointer +and some form of an integer. If that integer is intptr_t, there will be +no padding. +

+

+Related but separable issue: For unused bitfields, or other unused +fields for that matter, we should probably say it's the programmer's +responsibility to set them to zero or otherwise ensure they'll be +ignored by memcmp. +

+ +

+Proposed resolutions: Using +atomic<struct-with-padding>::compare_exchange_strong should be either: +

+ +
    +
  1. +ill-formed, or +
    2. +
  2. +well-defined. +
    3. +
+ +

+I propose Option 1 for C++0x for expediency, though I'm not sure how to +say it. I would be happy with Option 2, which I believe would mean that +compare_exchange_strong would be implemented to avoid comparing padding +bytes, or something equivalent such as always zeroing out padding when +loading/storing/comparing. (Either implementation might require compiler +support.) +

+ +

[ +Summit: +]

+ + +
+Move to open. Blocked until concepts for atomics are addressed. +
+ +

[ +Post Summit Anthony adds: +]

+ + +
+The resoultion of LWG 923 should resolve this issue as well. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

926. Sequentially consistent fences, relaxed operations and modification order

+

Section: 29.3 [atomics.order] Status: NAD Editorial + Submitter: Anthony Williams Opened: 2008-10-19 Last modified: 2010-10-29

+

View all other issues in [atomics.order].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses UK 313

+ +

+There was an interesting issue raised over on comp.programming.threads +today regarding the following example +

+ +
// Thread 1:
+x.store(1, memory_order_relaxed);           // SX
+atomic_thread_fence(memory_order_seq_cst);  // F1
+y.store(1, memory_order_relaxed);           // SY1
+atomic_thread_fence(memory_order_seq_cst);  // F2
+r1 = y.load(memory_order_relaxed);          // RY
+
+// Thread 2:
+y.store(0, memory_order_relaxed);          // SY2
+atomic_thread_fence(memory_order_seq_cst); // F3
+r2 = x.load(memory_order_relaxed);         // RX
+
+ +

+is the outcome r1 == 0 and r2 == 0 possible? +

+

+I think the intent is that this is not possible, but I am not sure the +wording guarantees that. Here is my analysis: +

+

+Since all the fences are SC, there must be a total order between them. +F1 must be before F2 in that order since they are in +the same thread. Therefore F3 is either before F1, +between F1 and F2 or after F2. +

+

+If F3 is after F2, then we can apply 29.3 [atomics.order]p5 from +N2798: +

+ +
+For atomic operations A and B on an atomic object +M, where A modifies M and B takes +its value, if there are memory_order_seq_cst fences X +and Y such that A is sequenced before X, +Y is sequenced before B, and X precedes +Y in S, then B observes either the effects of +A or a later modification of M in its modification +order. +
+ +

+In this case, A is SX, B is RX, the +fence X is F2 and the fence Y is F3, +so RX must see 1. +

+

+If F3 is before F2, this doesn't apply, but +F3 can therefore be before or after F1. +

+

+If F3 is after F1, the same logic applies, but this +time the fence X is F1. Therefore again, RX +must see 1. +

+

+Finally we have the case that F3 is before F1 +in the SC ordering. There are now no guarantees about RX, and +RX can see r2==0. +

+

+We can apply 29.3 [atomics.order]p5 again. This time, +A is SY2, B is RY, X is +F3 and Y is F1. Thus RY must observe +the effects of SY2 or a later modification of y in its +modification order. +

+

+Since SY1 is sequenced before RY, RY must +observe the effects of SY1 or a later modification of +y in its modification order. +

+

+In order to ensure that RY sees (r1==1), we must see +that SY1 is later in the modification order of y than +SY2. +

+

+We're now skating on thin ice. Conceptually, SY2 happens-before +F3, F3 is SC-ordered before F1, F1 +happens-before SY1, so SY1 is later in the +modification order M of y, and RY must see +the result of SY1 (r1==1). However, I don't think the +words are clear on that. +

+ +

[ +Post Summit Hans adds: +]

+ + +
+

+In my (Hans') view, our definition of fences will always be weaker than +what particular hardware will guarantee. Memory_order_seq_cst fences +inherently don't guarantee sequential consistency anyway, for good +reasons (e.g. because they can't enforce a total order on stores). + Hence I don't think the issue demonstrates a gross failure to achieve +what we intended to achieve. The example in question is a bit esoteric. + Hence, in my view, living with the status quo certainly wouldn't be a +disaster either. +

+

+In any case, we should probably add text along the lines of the +following between p5 and p6 in 29.3 [atomics.order]: +

+
+[Note: Memory_order_seq_cst only ensures sequential consistency for a +data-race-free program that uses exclusively memory_order_seq_cst +operations. Any use of weaker ordering will invalidate this guarantee +unless extreme care is used. In particular, memory_order_seq_cst fences +only ensure a total order for the fences themselves. They cannot, in +general, be used to restore sequential consistency for atomic operations +with weaker ordering specifications.] +
+ +

+Also see thread beginning at c++std-lib-23271. +

+ +
+ +

[ +Herve's correction: +]

+ +
+

+Minor point, and sorry for the knee jerk reaction: I admit to having +no knowledge of Memory_order_seq_cst, but my former boss (John Lakos) +has ingrained an automatic introspection on the use of "only". I +think you meant: +

+ +
+[Note: Memory_order_seq_cst ensures sequential consistency only +for . . . . In particular, memory_order_seq_cst fences ensure a +total order only for . . . +
+

+Unless, of course, Memory_order_seq_cst really do nothing but ensure +sequential consistency for a data-race-free program that uses +exclusively memory_order_seq_cst operations. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+

+Add a new paragraph after 29.3 [atomics.order]p5 that says +

+ +
+For atomic operations A and B on an atomic object +M, where A and B modify M, if there +are memory_order_seq_cst fences X and Y such +that A is sequenced before X, Y is sequenced +before B, and X precedes Y in S, +then B occurs later than A in the modifiction order of +M. +
+ + + + + +
+

927. Dereferenceable should be HasDereference

+

Section: X [allocator.concepts] Status: NAD Concepts + Submitter: Pablo Halpern Opened: 2008-10-23 Last modified: 2010-10-29

+

View all issues with NAD Concepts status.

+

Discussion:

+

+X [allocator.concepts] contains a reference to a concept named +Dereferenceable. No such concept exists. +

+ +

[ +Daniel adds 2009-02-14: +]

+ + +
+The proposal given in the paper +N2829 +would automatically resolve this issue. +
+ + +

[ +Batavia (2009-05): +]

+ +
+

+This particular set of changes has already been made. +There are two related changes later on (and possibly also an earlier Example); +these can be handled editorially. +

+

+Move to NAD Editorial. +

+
+ + +

Proposed resolution:

+

+Change all uses of the concept Dereferenceable to +HasDereference in X [allocator.concepts]. +

+ + + + + +
+

928. Wrong concepts used for tuple's comparison operators

+

Section: 20.4.2.7 [tuple.rel] Status: NAD Concepts + Submitter: Joe Gottman Opened: 2008-10-28 Last modified: 2010-10-29

+

View all other issues in [tuple.rel].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+In the latest working draft for C++0x, tuple's operator== and operator< +are declared as +

+ +
template<class... TTypes, class... UTypes> 
+  requires EqualityComparable<TTypes, UTypes>... 
+  bool operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+ +

+and +

+ +
template<class... TTypes, class... UTypes> 
+  requires LessThanComparable<TTypes, UTypes>... 
+  bool operator<(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+ +

+But the concepts EqualityComparable and LessThanComparable only take one +parameter, not two. Also, even if LessThanComparable could take two +parameters, the definition of tuple::operator<() should also require +

+ +
LessThanComparable<UTypes, TTypes>... // (note the order) 
+
+ +

+since the algorithm for tuple::operator< is the following (pseudo-code) +

+ +
for (size_t N = 0; N < sizeof...(TTypes); ++N) { 
+    if (get<N>(t) < get<N>(u) return true; 
+    else if ((get<N>(u) < get<N>(t)) return false; 
+} 
+
+return false; 
+
+ +

+Similar problems hold for tuples's other comparison operators. +

+ +

[ +Post Summit: +]

+ + +
+Recommend Tentatively Ready. +
+ + + +

Proposed resolution:

+

+In 20.4.1 [tuple.general] and 20.4.2.7 [tuple.rel] change: +

+ +
template<class... TTypes, class... UTypes>
+  requires EqualityComparableHasEqualTo<TTypes, UTypes>...
+  bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
+template<class... TTypes, class... UTypes>
+  requires LessThanComparableHasLess<TTypes, UTypes>... && HasLess<UTypes, TTypes>...
+  bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
+template<class... TTypes, class... UTypes>
+  requires EqualityComparableHasEqualTo<TTypes, UTypes>...
+  bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
+template<class... TTypes, class... UTypes>
+  requires LessThanComparableHasLess<UTTypes, TUTypes>... && HasLess<UTypes, TTypes>...
+  bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
+template<class... TTypes, class... UTypes>
+  requires LessThanComparableHasLess<UTTypes, TUTypes>... && HasLess<UTypes, TTypes>...
+  bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
+template<class... TTypes, class... UTypes>
+  requires LessThanComparableHasLess<TTypes, UTypes>... && HasLess<UTypes, TTypes>...
+  bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
+ + + + + +
+

930. Access to std::array data as built-in array type

+

Section: 23.3.1 [array] Status: NAD + Submitter: Niels Dekker Opened: 2008-11-17 Last modified: 2010-10-29

+

View all other issues in [array].

+

View all issues with NAD status.

+

Discussion:

+ +

+The Working Draft (N2798) allows access to the elements of +std::array by its data() member function: +

+ +
+ +
23.2.1.4 array::data [array.data]
+
 T *data();
+ const T *data() const;
+
+
  1. + Returns: elems. +
+
+ +

+Unfortunately, the result of std::array::data() cannot be bound +to a reference to a built-in array of the type of array::elems. +And std::array provides no other way to get a reference to +array::elems. +This hampers the use of std::array, for example when trying to +pass its data to a C style API function: +

+ +
 // Some C style API function. 
+ void set_path( char (*)[MAX_PATH] );
+
+ std::array<char,MAX_PATH> path;
+ set_path( path.data() );  // error
+ set_path( &(path.data()) );  // error
+
+ +

+Another example, trying to pass the array data to an instance of another +C++ class: +

+ +
 // Represents a 3-D point in space.
+ class three_d_point {
+ public:
+   explicit three_d_point(const double (&)[3]); 
+ };
+
+ const std::array<double,3> coordinates = { 0, 1, 2 };
+ three_d_point point1( coordinates.data() );  // error.
+ three_d_point point2( *(coordinates.data()) );  // error.
+
+ +

+A user might be tempted to use std::array::elems instead, but +doing so isn't recommended, because std::array::elems is "for +exposition only". Note that Boost.Array users might already use +boost::array::elems, as its documentation doesn't explicitly +state that boost::array::elems is for exposition only: +http://www.boost.org/doc/libs/1_36_0/doc/html/boost/array.html +

+

+I can think of three options to solve this issue: +

+
  1. +Remove the words "exposition only" from the definition of +std::array::elems, as well as the note saying that "elems is +shown for exposition only." +
  2. +Change the signature of std::array::data(), so that it would +return a reference to the built-in array, instead of a pointer to its +first element. +
  3. +Add extra member functions, returning a reference to the built-in array. +
+

+Lawrence Crowl wrote me that it might be better to leave +std::array::elems "for exposition only", to allow alternate +representations to allocate the array data dynamically. This might be +of interest to the embedded community, having to deal with very limited +stack sizes. +

+

+The second option, changing the return type of +std::array::data(), would break backward compatible to current +Boost and TR1 implementations, as well as to the other contiguous +container (vector and string) in a very subtle way. +For example, the following call to std::swap currently swap two +locally declared pointers (data1, data2), for any container +type T that has a data() member function. When +std::array::data() is changed to return a reference, the +std::swap call may swap the container elements instead. +

+ +
 template <typename T>
+ void func(T& container1, T& container2)
+ {
+   // Are data1 and data2 pointers or references?
+   auto data1 = container1.data();
+   auto data2 = container2.data();
+
+   // Will this swap two local pointers, or all container elements?
+   std::swap(data1, data2);
+ }
+
+ +

+The following concept is currently satisfied by all contiguous +containers, but it no longer is for std::array, when +array::data() +is changed to return a reference (tested on ConceptGCC Alpha 7): +

+ +
 auto concept ContiguousContainerConcept<typename T>
+ {
+   typename value_type = typename T::value_type;
+   const value_type * T::data() const;
+ }
+
+ +

+Still it's worth considering having std::array::data() return a +reference, because it might be the most intuitive option, from a user's +point of view. Nicolai Josuttis (who wrote boost::array) +mailed me that he very much prefers this option. +

+

+Note that for this option, the definition of data() would also +need to be revised for zero-sized arrays, as its return type cannot be a +reference to a zero-sized built-in array. Regarding zero-sized array, +data() could throw an exception. Or there could be a partial +specialization of std::array where data() returns +T* or gets removed. +

+

+Personally I prefer the third option, adding a new member function to +std::array, overloaded for const and non-const access, +returning a reference to the built-in array, to avoid those compatible +issues. I'd propose naming the function std::array::c_array(), +which sounds intuitive to me. Note that boost::array already +has a c_array() member, returning a pointer, but Nicolai told +me that this one is only there for historical reasons. (Otherwise a name +like std::array::native_array() or +std::array::builtin_array() would also be fine with me.) +According to my proposed resolution, a zero-sized std::array does not need +to have c_array(), while it is still required to have +data() functions. +

+ +

[ +Post Summit: +]

+ + +
+ +

+Alisdair: Don't like p4 suggesting implementation-defined behaviour. +

+

+Walter: What about an explicit conversion operator, instead of adding +the new member function? +

+

+Alisdair: Noodling about: +

+
template<size_t N, ValueType T>
+struct array
+{
+  T elems[N];
+
+// fantasy code starts here
+
+// crazy decltype version for grins only
+//requires True<(N>0)>
+//explict operator decltype(elems) & () { return elems; }
+
+// conversion to lvalue ref
+requires True<(N>0)>
+explict operator T(&)[N] () & { return elems; }
+
+// conversion to const lvalue ref
+requires True<(N>0)>
+explict operator const T(&)[N] () const & { return elems; }
+
+// conversion to rvalue ref using ref qualifiers
+requires True<(N>0)>
+explict operator T(&&)[N] () && { return elems; }
+
+// fantasy code ends here
+
+explicit operator bool() { return true; }
+};
+
+ +

+This seems legal but odd. Jason Merrill says currently a CWG issue 613 +on the non-static data member that fixes the error that current G++ +gives for the non-explicit, non-conceptualized version of this. Verdict +from human compiler: seems legal. +

+

+Some grumbling about zero-sized arrays being allowed and supported. +

+

+Walter: Would this address the issue? Are we inclined to go this route? +

+

+Alan: What would usage look like? +

+
// 3-d point in space
+struct three_d_point
+{
+  explicit three_d_point(const double (&)[3]);
+};
+
+void sink(double*);
+
+const std::array<double, 3> coordinates = { 0, 1, 2 };
+three_d_point point1( coordinates.data() ); //error
+three_d_point point2( *(coordinates.data()) ); // error
+three_d_point point3( coordinates ); // yay!
+
+sink(cooridinates); // error, no conversion
+
+ +

+Recommended Open with new wording. Take the required clause and add the +explicit conversion operators, not have a typedef. At issue still is use +decltype or use T[N]. In favour of using T[N], even though use of +decltype is specially clever. +

+ +
+ +

[ +Post Summit, further discussion in the thread starting with c++std-lib-23215. +]

+ + +

[ +2009-07 post-Frankfurt (Saturday afternoon group): +]

+ + +
+

+The idea to resolve the issue by adding explicit conversion operators +was abandoned, because it would be inconvenient to use, especially when +passing the array to a template function, as mentioned by Daniel. So we +reconsidered the original proposed resolution, which appeared +acceptable, except for its proposed changes to 23.3.1.7 [array.zero], which +allowed c_array_type and c_array() to be absent for a zero-sized array. +Alisdair argued that such wording would disallow certain generic use +cases. New wording for 23.3.1.7 [array.zero] was agreed upon (Howard: and +is reflected in the proposed resolution). +

+

+Move to Review +

+
+ +

[ +2009-07-31 Alisdair adds: +]

+ + +
+

+I will be unhappy voting the proposed resolution for 930 past review +until we have implementation experience with reference qualifiers. +Specifically, I want to understand the impact of the missing overload +for const && (if any.) +

+ +

+If we think the issue is important enough it might be worthwhile +stripping the ref qualifiers for easy progress next meeting, and opening +yet another issue to put them back with experience. +

+ +

+Recommend deferring any decision on splitting the issue until we get LWG +feedback next meeting - I may be the lone dissenting voice if others are +prepared to proceed without it. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD. There was not enough consensus that this was sufficiently +useful. There are known other ways to do this, such as small inline +conversion functions. +
+ + + +

Proposed resolution:

+

+Add to the template definition of array, 23.3.1 [array]/3: +

+ +
+

+typedef T c_array_type[N];
+c_array_type & c_array() &;
+c_array_type && c_array() &&;
+const c_array_type & c_array() const &;
+
+
+
+ +

+Add the following subsection to 23.3.1 [array], after 23.3.1.4 [array.data]: +

+ +
+
23.2.1.5 array::c_array [array.c_array]
+ 

+c_array_type & c_array() &;
+c_array_type && c_array() &&;
+const c_array_type & c_array() const &;
+
+
+

+Returns: elems. +

+
+ +
+ + + +

+Change Zero sized arrays 23.3.1.7 [array.zero]: +

+ +
+ +

-2- ...

+ +

+The type c_array_type is unspecified for a zero-sized array. +

+ +

+-3- The effect of calling c_array(), front(), or +back() for a zero-sized array is implementation defined. +

+
+ + + + + + +
+

933. Unique_ptr defect

+

Section: 20.9.9.2.5 [unique.ptr.single.modifiers] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2008-11-27 Last modified: 2010-10-29

+

View all other issues in [unique.ptr.single.modifiers].

+

View all issues with NAD Future status.

+

Discussion:

+

+If we are supporting stateful deleters, we need an overload for +reset that +takes a deleter as well. +

+ +
void reset( pointer p, deleter_type d);
+
+ +

+We probably need two overloads to support move-only deleters, and +this +sounds uncomfortably like the two constructors I have been ignoring +for +now... +

+ +

[ +Batavia (2009-05): +]

+ +
+

+Howard comments that we have the functionality via move-assigment. +

+

+Move to Open. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD Future. +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

935. clock error handling needs to be specified

+

Section: 20.11.5 [time.clock] Status: NAD Future + Submitter: Beman Dawes Opened: 2008-11-24 Last modified: 2010-10-29

+

View all issues with NAD Future status.

+

Discussion:

+

+Each of the three clocks specified in Clocks 20.11.5 [time.clock] +provides the member function: +

+ +
static time_point now();
+
+ +

+The semantics specified by Clock requirements 20.11.1 [time.clock.req] +make no mention of error handling. Thus the function may throw bad_alloc +or an implementation-defined exception (17.6.4.12 [res.on.exception.handling] +paragraph 4). +

+ +

+Some implementations of these functions on POSIX, Windows, and +presumably on other operating systems, may fail in ways only detectable +at runtime. Some failures on Windows are due to supporting chipset +errata and can even occur after successful calls to a clock's now() +function. +

+ +

+These functions are used in cases where exceptions are not appropriate +or where the specifics of the exception or cause of error need to be +available to the user. See +N2828, +Library Support for hybrid error +handling (Rev 1), for more specific discussion of use cases. Thus some change in +the interface of now is required. +

+ +

+The proposed resolution has been implemented in the Boost version of the +chrono library. No problems were encountered. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+We recommend this issue be deferred until the next Committee Draft +has been issued and the prerequisite paper has been accepted. +

+

+Move to Open. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD future. Too late to make this change without having already +accepted the hybrid error handling proposal. +
+ + + +

Proposed resolution:

+

+Accept the proposed wording of +N2828, +Library Support for hybrid error handling (Rev 1). +

+ +

+Change Clock requirements 20.11.1 [time.clock.req] as indicated: +

+ +
+

+-2- In Table 55 C1 and C2 denote clock types. t1 and +t2 are values returned by C1::now() where the call +returning t1 happens before (1.10) the call returning t2 and +both of these calls happen before C1::time_point::max(). +ec denotes an object of type error_code +(19.5.2.1 [syserr.errcode.overview]). +

+ + + + + + + + + + + + + + + + + + + + + + + + +
Table 55 -- Clock requirements
ExpressionReturn typeOperational semantics
.........
C1::now()C1::time_pointReturns a time_point object representing the current point in time. +
C1::now(ec)C1::time_pointReturns a time_point object representing the current point in time. +
+
+ +

+Change Class system_clock 20.11.5.1 [time.clock.system] as indicated: +

+ +
static time_point now(error_code& ec=throws());
+
+ +

+Change Class monotonic_clock X [time.clock.monotonic] as indicated: +

+ +
static time_point now(error_code& ec=throws());
+
+ +

+Change Class high_resolution_clock 20.11.5.3 [time.clock.hires] as indicated: +

+ +
static time_point now(error_code& ec=throws());
+
+ + + + + + +
+

936. Mutex type overspecified

+

Section: 30.4.1 [thread.mutex.requirements] Status: NAD Future + Submitter: Pete Becker Opened: 2008-12-05 Last modified: 2010-10-29

+

View all other issues in [thread.mutex.requirements].

+

View all issues with NAD Future status.

+

Duplicate of: 961

+

Discussion:

+ + + +

+30.4.1 [thread.mutex.requirements] describes the requirements for a type to be +a "Mutex type". A Mutex type can be used as the template argument for +the Lock type that's passed to condition_variable_any::wait (although +Lock seems like the wrong name here, since Lock is given a different +formal meaning in 30.4.2 [thread.lock]) and, although the WD doesn't quite say +so, as the template argument for lock_guard and unique_lock. +

+ +

+The requirements for a Mutex type include: +

+ + + +

+Also, a Mutex type "shall not be copyable nor movable". +

+ +

+The latter requirement seems completely irrelevant, and the three +requirements on return types are tighter than they need to be. For +example, there's no reason that lock_guard can't be instantiated with a +type that's copyable. The rule is, in fact, that lock_guard, etc. won't +try to copy objects of that type. That's a constraint on locks, not on +mutexes. Similarly, the requirements for void return types are +unnecessary; the rule is, in fact, that lock_guard, etc. won't use any +returned value. And with the return type of bool, the requirement should +be that the return type is convertible to bool. +

+ +

[ +Summit: +]

+ + +
+

+Move to open. Related to conceptualization and should probably be tackled as part of that. +

+ +
+ +

[ +Post Summit Anthony adds: +]

+ + +
+

+Section 30.4.1 [thread.mutex.requirements] conflates the +requirements on a generic Mutex type (including user-supplied mutexes) +with the requirements placed on the standard-supplied mutex types in an +attempt to group everything together and save space. +

+

+When applying concepts to chapter 30, I suggest that the concepts +Lockable and TimedLockable embody the requirements for +*use* of a mutex type as required by +unique_lock/lock_guard/condition_variable_any. These should be +relaxed as Pete describes in the issue. The existing words in 30.4.1 [thread.mutex.requirements] are requirements on all of +std::mutex, std::timed_mutex, +std::recursive_mutex and std::recursive_timed_mutex, +and should be rephrased as such. +

+
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

937. Atomics for standard typedef types

+

Section: 29 [atomics] Status: NAD Editorial + Submitter: Clark Nelson Opened: 2008-12-05 Last modified: 2010-10-29

+

View other active issues in [atomics].

+

View all other issues in [atomics].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses US 89

+ +
+

+The types in the table "Atomics for standard typedef types" should be +typedefs, not classes. These semantics are necessary for compatibility +with C. +

+ +

+Change the classes to typedefs. +

+
+ +

+N2427 +specified different requirements for atomic analogs of fundamental +integer types (such as atomic_int) and for atomic analogs of <cstdint> +typedefs (such as atomic_size_t). Specifically, atomic_int et al. were +specified to be distinct classes, whereas atomic_size_t et al. were +specified to be typedefs. Unfortunately, in applying +N2427 +to the WD, that distinction was erased, and the atomic analog of every <cstdint> +typedef is required to be a distinct class. +

+ +

+It shouldn't be required that the atomic analog of every <cstdint> +typedef be a typedef for some fundamental integer type. After all, +<cstdint> is supposed to provide standard names for extended integer +types. So there was a problem in +N2427, +which certainly could have been +interpreted to require that. But the status quo in the WD is even worse, +because it's unambiguously wrong. +

+ +

+What is needed are words to require the existence of a bunch of type +names, without specifying whether they are class names or typedef names. +

+ +

[ +Summit: +]

+ + +
+

+Change status to NAD, editorial. See US 89 comment notes above. +

+

+Direct the editor to turn the types into typedefs as proposed in the +comment. Paper approved by committee used typedefs, this appears to have +been introduced as an editorial change. Rationale: for compatibility +with C. +

+
+ + +

Proposed resolution:

+

+

+ + + + + +
+

940. std::distance

+

Section: 24.4.4 [iterator.operations] Status: NAD Editorial + Submitter: Thomas Opened: 2008-12-14 Last modified: 2010-10-29

+

View all other issues in [iterator.operations].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 270

+ +

+Regarding the std::distance - function, 24.4.4 [iterator.operations] +/ 4 says: +

+
+Returns the +number of increments or decrements needed to get from first to last. +
+

+This sentence is completely silent about the sign of the return value. +24.4.4 [iterator.operations] / 1 gives more information about the +underlying operations, but +again no inferences about the sign can be made. +Strictly speaking, that is taking that sentence literally, I think this +sentence even implies a positive return value in all cases, as the +number of increments or decrements is clearly a ratio scale variable, +with a natural zero bound. +

+

+Practically speaking, my implementations did what common sense and +knowledge based on pointer arithmetic forecasts, namely a positive sign +for increments (that is, going from first to last by operator++), and a +negative sign for decrements (going from first to last by operator--). +

+

+Here are my two questions: +

+

+First, is that paragraph supposed to be interpreted in the way what I +called 'common sense', that is negative sign for decrements ? I am +fairly sure that's the supposed behavior, but a double-check here in +this group can't hurt. +

+

+Second, is the present wording (2003 standard version - no idea about +the draft for the upcoming standard) worth an edit to make it a bit more +sensible, to mention the sign of the return value explicitly ? +

+ +

[ +Daniel adds: +]

+ + +
+

+My first thought was that resolution 204 would already cover the +issue report, but it seems that current normative wording is in +contradiction to that resolution: +

+ +

+Referring to +N2798, +24.4.4 [iterator.operations]/ p.4 says: +

+ +
+Effects: Returns the number of increments or decrements needed to get +from first to last. +
+ +

+IMO the part " or decrements" is in contradiction to p. 5 which says +

+ +
+Requires: last shall be reachable from first. +
+ +

+because "reachable" is defined in X [iterator.concepts]/7 as +

+ +
+An iterator j is called reachable from an iterator i if and only if +there is a finite +sequence of applications of the expression ++i that makes i == j.[..] +
+ +

+Here is wording that would be consistent with this definition of "reachable": +

+ +

+Change 24.4.4 [iterator.operations] p4 as follows: +

+ +
+Effects: Returns the number of increments or decrements +needed to get from first to last. +
+ +
+ +

+Thomas adds more discussion and an alternative view point +here. +

+ +

[ +Summit: +]

+ + +
+The proposed wording below was verbally agreed to. Howard provided. +
+ +

[ +Batavia (2009-05): +]

+ +
+

+Pete reports that a recent similar change has been made +for the advance() function. +

+

+We agree with the proposed resolution. +Move to Tentatively Ready. +

+
+ +

[ +2009-07 Frankfurt +]

+ + +
+Moved from Tentatively Ready to Open only because the wording needs to be +tweaked for concepts removal. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Leave Open pending arrival of a post-Concepts WD. +
+ +

[ +2009-10-14 Daniel provided de-conceptified wording. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+Move to Ready, replacing the Effects clause in the proposed wording with +"If InputIterator meets the requirements of random access iterator then +returns (last - first), otherwise returns the number of increments +needed to get from first to list.". +
+ +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Editorial. Rationale added below. +
+ + + +

Rationale:

+

+Solved by N3066. +

+ + +

Proposed resolution:

+
    +
  1. +

    +Change 24.2.7 [random.access.iterators], Table 105 as indicated [This change is not +essential but it simplifies the specification] for the row with +expression "b - a" +and the column Operational semantics: +

    + +
    (a < b) ? distance(a,b)
+: -distance(b,a)
+
    +
    2. + +
  2. +

    +Change 24.4.4 [iterator.operations]/4+5 as indicated: +

    + +
    template<class InputIterator>
+  typename iterator_traits<InputIterator>::difference_type
+    distance(InputIterator first, InputIterator last);
+
    +
    +

    +4 Effects: If InputIterator meets the requirements +of random access iterator then returns (last - first), +otherwise Rreturns the number of increments +or decrements needed to get from first to +last. +

    + +

    +5 Requires: If InputIterator meets the requirements +of random access iterator then last shall be reachable from +first or first shall be reachable from last, +otherwise last shall be reachable from first. +

    +
    +
    +
    3. +
+ + + + + + + + + +
+

941. Ref-qualifiers for assignment operators

+

Section: 17 [library] Status: NAD + Submitter: Niels Dekker Opened: 2008-12-18 Last modified: 2010-10-29

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD status.

+

Discussion:

+

+The assignment and equality operators = and == are easily confused, just +because of their visual similarity, and in this case a simple typo can cause +a serious bug. When the left side of an operator= is an rvalue, it's +highly unlikely that the assignment was intended by the programmer: +

+
if ( func() = value )  // Typical typo: == intended!
+
+

+Built-in types don't support assignment to an rvalue, but unfortunately, +a lot of types provided by the Standard Library do. +

+

+Fortunately the language now offers a syntax to prevent a certain member +function from having an rvalue as *this: by adding a ref-qualifier (&) +to the member function declaration. Assignment operators are explicitly +mentioned as a use case of ref-qualifiers, in "Extending Move Semantics +To *this (Revision 1)", +N1821 by Daveed +Vandevoorde and Bronek Kozicki +

+

+Hereby I would like to propose adding ref-qualifiers to all appropriate +assignment operators in the library. +

+ +

[ +Batavia (2009-05): +]

+ +
+Move to Open. +We recommend this be deferred until after the next Committee Draft. +
+ +

[ +Frankfurt 2009-07: +]

+ + +
+

+The LWG declined to move forward with +N2819. +

+

+Moved to NAD. +

+
+ + +

Proposed resolution:

+

+A proposed resolution is provided by the paper on this subject, +N2819, +Ref-qualifiers for assignment operators of the Standard Library +

+ + + + + +
+

942. Atomics synopsis typo

+

Section: 29 [atomics] Status: Dup + Submitter: Holger Grund Opened: 2008-12-19 Last modified: 2010-10-29

+

View other active issues in [atomics].

+

View all other issues in [atomics].

+

View all issues with Dup status.

+

Duplicate of: 880

+

Discussion:

+ + + +

+I'm looking at 29 [atomics] and can't really make sense of a couple of things. +

+

+Firstly, there appears to be a typo in the <cstdatomic> synopsis: +

+ +
+

+The atomic_exchange overload taking an atomic_address +is missing the second parameter: +

+ +
void* atomic_exchange(volatile atomic_address*);
+
+ +

+should be +

+ +
void* atomic_exchange(volatile atomic_address*, void*);
+
+ +

+Note, that this is not covered by 880 "Missing atomic exchange parameter", +which only talks about the atomic_bool. +

+
+ + + +

Proposed resolution:

+

+Change the synopsis in 29 [atomics]/2: +

+ +
void* atomic_exchange(volatile atomic_address*, void*);
+
+ + + + + + +
+

944. atomic<bool> derive from atomic_bool?

+

Section: 29.5 [atomics.types.generic] Status: NAD Editorial + Submitter: Holger Grund Opened: 2008-12-19 Last modified: 2010-10-29

+

View all other issues in [atomics.types.generic].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+I think it's fairly obvious that atomic<bool> is supposed to be derived +from atomic_bool (and otherwise follow the atomic<integral> interface), +though I think the current wording doesn't support this. I raised this +point along with atomic<floating-point> privately with Herb and I seem +to recall it came up in the resulting discussion on this list. However, +I don't see anything on the current libs issue list mentioning this +problem. +

+ +

+29.5 [atomics.types.generic]/3 reads +

+ +
+There are full specializations over the integral types on the atomic +class template. For each integral type integral in the second column of +table 121 or table 122, the specialization atomic<integral> shall be +publicly derived from the corresponding atomic integral type in the +first column of the table. These specializations shall have trivial +default constructors and trivial destructors. +
+ +

+Table 121 does not include (atomic_bool, bool), +so that this should probably be mentioned explicitly in the quoted paragraph. +

+ +

[ +Summit: +]

+ + +
+Move to open. Lawrence will draft a proposed resolution. Also, ask +Howard to fix the title. +
+ +

[ +Post Summit Anthony provided proposed wording. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+

+Replace paragraph 3 in 29.5 [atomics.types.generic] with +

+ +
+-3- There are full specializations over the integral types on the atomic +class template. For each integral type integral in the second column of +table 121 or table 122, the specialization atomic<integral> shall be +publicly derived from the corresponding atomic integral type in the first +column of the table. +In addition, the specialization atomic<bool> +shall be publicly derived from atomic_bool. +These specializations shall have trivial default +constructors and trivial destructors. +
+ + + + + +
+

945. system_clock::rep not specified

+

Section: 20.11.5.1 [time.clock.system] Status: NAD Editorial + Submitter: Pete Becker Opened: 2008-12-19 Last modified: 2010-10-29

+

View all other issues in [time.clock.system].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In 20.11.5.1 [time.clock.system], the declaration of system_clock::rep says "see +below", but there is nothing below that describes it. +

+ +

[ +Howard adds: +]

+ + +
+

+This note refers to: +

+ +
+-2- system_clock::duration::min() < system_clock::duration::zero() shall be true. +
+ +

+I.e. this is standardeze for "system_clock::rep is signed". +Perhaps an editorial note along the lines of: +

+ +
+-2- system_clock::duration::min() < system_clock::duration::zero() +shall be true. [Note: system_clock::rep shall be signed. -- end note]. +
+ +

+? +

+ +
+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the direction of the proposed resolution. +Move to NAD Editorial. +
+ + + +

Proposed resolution:

+

+Add a note to 20.11.5.1 [time.clock.system], p2: +

+
+-2- system_clock::duration::min() < system_clock::duration::zero() +shall be true. [Note: system_clock::rep shall be signed. -- end note]. +
+ + + + + +
+

946. duration_cast improperly specified

+

Section: 20.11.3.7 [time.duration.cast] Status: NAD + Submitter: Pete Becker Opened: 2008-12-20 Last modified: 2010-10-29

+

View all other issues in [time.duration.cast].

+

View all issues with NAD status.

+

Discussion:

+20.11.3.7 [time.duration.cast]/3: + +
+.... All intermediate computations shall be +carried out in the widest possible representation... . +
+ +

+So ignoring +floating-point types for the moment, all this arithmetic has to be done +using the implementation's largest integral type, even if both arguments +use int for their representation. This seems excessive. And it's not at +all clear what this means if we don't ignore floating-point types. +

+ +

+This issue is related to 952. +

+ +

[ +Howard adds: +]

+ + +
+

+The intent of this remark is that intermediate computations are carried out +using: +

+ +
common_type<typename ToDuration::rep, Rep, intmax_t>::type
+
+ +

+The Remark was intended to be clarifying prose supporting the rather algorithmic description +of the previous paragraph. I'm open to suggestions. Perhaps the entire paragraph +3 (Remarks) would be better dropped? +

+
+ +

[ +Batavia (2009-05): +]

+ +
+

+We view this as a specific case of issue 952, +and should be resolved when that issue is resolved. +

+

+Move to NAD. +

+
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

952. Various threading bugs #2

+

Section: 20.11.3.7 [time.duration.cast] Status: NAD Editorial + Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2010-10-29

+

View all other issues in [time.duration.cast].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+20.11.3.7 [time.duration.cast] specifies an implementation and imposes +requirements in text (and the implementation doesn't satisfy all of the +text requirements). Pick one. +

+ +

+This issue is related to 946. +

+ +

[ +2009-05-10 Howard adds: +]

+ + +
+

+The Remarks paragraph is an English re-statement of the preceeding +Returns clause. It was meant to be clarifying and motivating, not +confusing. I'm not aware with how the Remarks contradicts the Returns clause +but I'm ok with simply removing the Remarks. +

+
+ +

[ +Batavia (2009-05): +]

+ +
+

+Pete suggests that this could be resolved +by rephrasing the Remarks to Notes. +

+

+Move to NAD Editorial. +

+
+ + +

Proposed resolution:

+

+

+ + + + + +
+

955. Various threading bugs #5

+

Section: 20.11.1 [time.clock.req] Status: NAD + Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2010-10-29

+

View all other issues in [time.clock.req].

+

View all issues with NAD status.

+

Discussion:

+

+20.11.1 [time.clock.req] requires that a clock type have a member +typedef named time_point that names an instantiation of the +template time_point, and a member named duration that +names an instantiation of the template duration. This mixing of +levels is confusing. The typedef names should be different from the +template names. +

+ +

[ +Post Summit, Anthony provided proposed wording. +]

+ + +

[ +2009-05-04 Howard adds: +]

+ + +
+

+The reason that the typedef names were given the same name as the class templates +was so that clients would not have to stop and think about whether they were +using the clock's native time_point / duration or the class +template directly. In this case, one person's confusion is another person's +encapsulation. The detail that sometimes one is referring to the clock's +native types, and sometimes one is referring to an independent type is +purposefully "hidden" because it is supposed to be an unimportant +detail. It can be confusing to have to remember when to type duration +and when to type duration_type, and there is no need to require the +client to remember something like that. +

+ +

+For example, here is code that I once wrote in testing out the usability of +this facility: +

+ +
template <class Clock, class Duration>
+void do_until(const std::chrono::time_point<Clock, Duration>& t)
+{
+    typename Clock::time_point now = Clock::now();
+    if (t > now)
+    {
+        typedef typename std::common_type
+        <
+            Duration,
+            typename std::chrono::system_clock::duration
+        >::type CD;
+        typedef std::chrono::duration<double, std::nano> ID;
+
+        CD d = t - now;
+        ID us = duration_cast<ID>(d);
+        if (us < d)
+            ++us;
+        ...
+    }
+}
+
+ +

+I see no rationale to require the client to append _type to some +of those declarations. It seems overly burdensome on the author of do_until: +

+ +
template <class Clock, class Duration>
+void do_until(const std::chrono::time_point<Clock, Duration>& t)
+{
+    typename Clock::time_point_type now = Clock::now();
+    if (t > now)
+    {
+        typedef typename std::common_type
+        <
+            Duration,
+            typename std::chrono::system_clock::duration_type
+        >::type CD;
+        typedef std::chrono::duration<double, std::nano> ID;
+
+        CD d = t - now;
+        ID us = duration_cast<ID>(d);
+        if (us < d)
+            ++us;
+        ...
+    }
+}
+
+ +

+Additionally I'm fairly certain that this suggestion hasn't been implemented. +If it had, it would have been discovered that it is incomplete. time_point +also has a nested type (purposefully) named duration. +

+
+That is, the current proposed wording would put the WP into an inconsistent state. +
+

+In contrast, +the current WP has been implemented and I've received very favorable feedback +from people using this interface in real-world code. +

+ +
+ +

[ +Batavia (2009-05): +]

+ +
+

+Bill agrees that distinct names should be used for distinct kinds of entities. +

+

+Walter would prefer not to suffix type names, +especially for such well-understood terms as "duration". +

+

+Howard reminds us that the proposed resolution is incomplete, per his comment +in the issue. +

+

+Move to Open. +

+
+ +

[ +2009-06-07 Howard adds: +]

+ + +
+

+Not meaning to be argumentative, but we have a decade of positive experience +with the precedent of using the same name for the nested type as an external +class representing an identical concept. +

+ +
template<class Category, class T, class Distance = ptrdiff_t,
+         class Pointer = T*, class Reference = T&>
+struct iterator
+{
+    ...
+};
+
+template <BidirectionalIterator Iter>
+class reverse_iterator
+{
+    ...
+};
+
+template <ValueType T, Allocator Alloc = allocator<T> >
+    requires NothrowDestructible<T>
+class list
+{
+public:
+    typedef implementation-defined     iterator;
+    ...
+    typedef reverse_iterator<iterator> reverse_iterator;
+    ...
+};
+
+ +

+I am aware of zero complaints regarding the use of iterator +and reverse_iterator as nested types of the containers despite these +names also having related meaning at namespace std scope. +

+ +

+Would we really be doing programmers a favor by renaming these nested types? +

+ +
template <ValueType T, Allocator Alloc = allocator<T> >
+    requires NothrowDestructible<T>
+class list
+{
+public:
+    typedef implementation-defined     iterator_type;
+    ...
+    typedef reverse_iterator<iterator> reverse_iterator_type;
+    ...
+};
+
+ +

+I submit that such design contributes to needless verbosity which ends up +reducing readability. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD. No concensus for changing the WP. +
+ + + +

Proposed resolution:

+

+Change 20.11 [time]: +

+ +
...
+template <class Clock, class Duration = typename Clock::duration_type> class time_point;
+...
+
+ +

+Change 20.11.1 [time.clock.req]: +

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Table 45 -- Clock requirements
ExpressionReturn typeOperational semantics
.........
C1::duration_typechrono::duration<C1::rep, C1::period>The native duration type of the clock.
C1::time_point_typechrono::time_point<C1> or chrono::time_point<C2, C1::duration_type<The native time_point type of the clock. Different clocks may share a time_point_type +definition if it is valid to +compare their time_point_types by +comparing their respective +duration_types. C1 and C2 shall +refer to the same epoch.
.........
C1::now()C1::time_point_typeReturns a time_point_type object +representing the current point +in time. +
+
+ +

+Change 20.11.5.1 [time.clock.system]: +

+ +
+

+-1- Objects of class system_clock represent wall clock time from the system-wide realtime clock. +

+ +
class system_clock { 
+public: 
+  typedef see below rep; 
+  typedef ratio<unspecified, unspecified> period; 
+  typedef chrono::duration<rep, period> duration_type; 
+  typedef chrono::time_point<system_clock> time_point_type; 
+  static const bool is_monotonic = unspecified ; 
+
+  static time_point_type now(); 
+
+  // Map to C API 
+  static time_t to_time_t (const time_point_type& t); 
+  static time_point_type from_time_t(time_t t); 
+};
+
+ +

+-2- system_clock::duration_type::min() < system_clock::duration_type::zero() shall be true. +

+ +
time_t to_time_t(const time_point_type& t);
+
+ +
+-3- Returns: A time_t object that represents the same +point in time as t when both values are truncated to the +coarser of the precisions of time_t and time_point_type. +
+ +
time_point_type from_time_t(time_t t);
+
+ +
+-4- Returns: A time_point_type object that represents the same point +in time as t when both values are truncated to the coarser of the +precisions of time_t and time_point_type. +
+
+ +

+Change X [time.clock.monotonic]: +

+ +
class monotonic_clock { 
+public: 
+  typedef unspecified                                rep; 
+  typedef ratio<unspecified , unspecified>           period; 
+  typedef chrono::duration<rep, period>              duration_type; 
+  typedef chrono::time_point<unspecified , duration_type> time_point_type; 
+  static const bool is_monotonic =                   true; 
+
+  static time_point_type now();
+};
+
+ +

+Change 20.11.5.3 [time.clock.hires]: +

+ +
class high_resolution_clock { 
+public: 
+  typedef unspecified                                rep; 
+  typedef ratio<unspecified , unspecified>           period; 
+  typedef chrono::duration<rep, period>              duration_type; 
+  typedef chrono::time_point<unspecified , duration_type> time_point_type; 
+  static const bool is_monotonic =                   true; 
+
+  static time_point_type now();
+};
+
+ + + + + + +
+

958. Various threading bugs #8

+

Section: 30.5.1 [thread.condition.condvar] Status: NAD Editorial + Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2010-10-29

+

View all other issues in [thread.condition.condvar].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+30.5.1 [thread.condition.condvar]: the specification for wait_for +with no predicate has an effects clause that says it calls wait_until, +and a returns clause that sets out in words how to determine the return +value. Is this description of the return value subtly different from the +description of the value returned by wait_until? Or should the effects +clause and the returns clause be merged? +

+ +

[ +Summit: +]

+ + +
+Move to open. Associate with LWG 859 and any other monotonic-clock +related issues. +
+ +

[ +2009-08-01 Howard adds: +]

+ + +
+I believe that 859 (currently Ready) addresses this issue, and +that this issue should be marked NAD, solved by 859 (assuming +it moves to WP). +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD Editorial, solved by resolution of Issue 859. +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

959. Various threading bugs #9

+

Section: 30.5.1 [thread.condition.condvar] Status: NAD + Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2010-10-29

+

View all other issues in [thread.condition.condvar].

+

View all issues with NAD status.

+

Discussion:

+

+30.5.1 [thread.condition.condvar]: condition_variable::wait_for +is required to compute the absolute time by adding the duration value to +chrono::monotonic_clock::now(), but monotonic_clock is not required to +exist. +

+ +

[ +Summit: +]

+ + +
+Move to open. Associate with LWG 859 and any other monotonic-clock +related issues. +
+ +

[ +2009-08-01 Howard adds: +]

+ + +
+I believe that 859 (currently Ready) addresses this issue, and +that this issue should be marked NAD, solved by 859 (assuming +it moves to WP). +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Leave open, but expect to be fixed by N2969 revision that Detlef is writing. +
+ +

[ +2009-11-18 Moved to Tentatively NAD after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + + + +

Proposed resolution:

+

+

+ + +

Rationale:

+

+condition_variable::wait_for no longer refers to +monotonic_clock, so this issue is moot. +

+ + + + + +
+

961. Various threading bugs #11

+

Section: 30.4.1 [thread.mutex.requirements] Status: NAD Future + Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2010-10-29

+

View all other issues in [thread.mutex.requirements].

+

View all issues with NAD Future status.

+

Duplicate of: 936

+

Discussion:

+

+30.4.1 [thread.mutex.requirements] describes required member +functions of mutex types, and requires that they throw exceptions under +certain circumstances. This is overspecified. User-defined types can +abort on such errors without affecting the operation of templates +supplied by standard-library. +

+ +

[ +Summit: +]

+ +
+Move to open. Related to conceptualization and should probably be +tackled as part of that. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+

+Would be OK to leave it as is for time constraints, could loosen later. +

+ +

+Mark as NAD Future. +

+
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

969. What happened to Library Issue 475?

+

Section: 25.2.4 [alg.foreach] Status: NAD Editorial + Submitter: Stephan T. Lavavej Opened: 2009-01-12 Last modified: 2010-10-29

+

View all other issues in [alg.foreach].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Library Issue 475 has CD1 status, but the non-normative note in +N2723 +was removed in +N2798 +(25.2.4 [alg.foreach] in both drafts). +

+ +

[ +Batavia (2009-05): +]

+ +
+Move to NAD Editorial. +
+ + +

Proposed resolution:

+

+Restore the non-normative note. It might need to be expressed in terms of concepts. +

+ + + + + +
+

971. Spurious diagnostic conversion function

+

Section: 19.5.2.5 [syserr.errcode.nonmembers] Status: NAD + Submitter: Beman Dawes Opened: 2009-01-19 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+Anthony Williams raised the question in c++std-lib-22987 "why is there +std::make_error_code(std::errc)? What purpose does this serve?" +

+

+The function make_error_code(errc e) is not required, since +make_error_condition(errc e) is the function that is needed for errc +conversions. make_error_code(errc e) appears to be a holdover from my +initial confusion over the distinction between POSIX and operating +systems that conform to the POSIX spec. +

+ +

[ +Post Summit: +]

+ + +
+Recommend Review. +
+ +

[ +Batavia (2009-05): +]

+ +
+The designer of the facility (Christopher Kohlhoff) +strongly disagrees that there is an issue here, +and especially disagrees with the proposed resolution. +Bill would prefer to be conservative and not apply this proposed resolution. +Move to Open, and recommend strong consideration for NAD status. +
+ +

[ +2009-05-21 Beman adds: +]

+ + +
+My mistake. Christopher and Bill are correct and the issue should be +NAD. The function is needed by users. +
+ +

[ +2009-07-21 Christopher Kohlhoff adds rationale for make_error_code: +]

+ + +
+

+Users (and indeed library implementers) may need to use the +errc codes in portable code. For example: +

+ +
void do_foo(error_code& ec)
+{
+#if defined(_WIN32)
+  // Windows implementation ...
+#elif defined(linux)
+  // Linux implementation ...
+#else
+  // do_foo not supported on this platform
+  ec = make_error_code(errc::not_supported);
+#endif
+}
+
+
+ +

[ +2009 Santa Cruz: +]

+ + +
+Moved to NAD. +
+ + + +

Proposed resolution:

+

+Change System error support 19.5 [syserr], Header <system_error> +synopsis, as indicated: +

+ +
error_code make_error_code(errc e);
+error_condition make_error_condition(errc e);
+
+ +

+Delete from Class error_code non-member functions +19.5.2.5 [syserr.errcode.nonmembers]: +

+ +
error_code make_error_code(errc e);
+
+
+Returns: error_code(static_cast<int>(e), +generic_category). +
+
+ + + + + + +
+

972. The term "Assignable" undefined but still in use

+

Section: 17 [library] Status: NAD Editorial + Submitter: Niels Dekker Opened: 2009-01-07 Last modified: 2010-10-29

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Previous versions of the Draft had a table, defining the Assignable +requirement. For example +N2134 +Table 79, "Assignable requirements". But I guess the term "Assignable" +is outdated by now, because the current Committee Draft provides +MoveAssignable, CopyAssignable, and TriviallyCopyAssignable concepts +instead. And as far as I can see, it no longer has a definition of +Assignable. (Please correct me if I'm wrong.) Still the word +"Assignable" is used in eight places in the Draft, +N2800. +

+ +

+Are all of those instances of "Assignable" to be replaced by "CopyAssignable"? +

+ +

[ +Batavia (2009-05): +]

+ +
+Move to NAD Editorial. +
+ + +

Proposed resolution:

+ +

+Change Exception Propagation 18.8.5 [propagation]: +

+
+exception_ptr shall be DefaultConstructible, CopyConstructible, +CopyAssignable and EqualityComparable. +
+ +

+Change Class template reference_wrapper 20.8.4 [refwrap]: +

+
+reference_wrapper<T> is a CopyConstructible and CopyAssignable wrapper around a reference to an object of type T. +
+

+Change Placeholders 20.8.10.1.3 [func.bind.place]: +

+
+It is implementation defined whether placeholder types are CopyAssignable. CopyAssignable placeholders' copy assignment operators shall not throw exceptions. +
+

+Change Class template shared_ptr 20.9.10.2 [util.smartptr.shared]: +

+
+Specializations of shared_ptr shall be CopyConstructible, CopyAssignable, and LessThanComparable... +
+

+Change Class template weak_ptr 20.9.10.3 [util.smartptr.weak]: +

+
+Specializations of weak_ptr shall be CopyConstructible, CopyAssignable, and LessThanComparable... +
+

+Change traits typedefs 21.2.2 [char.traits.typedefs] (note: including deletion of reference to 23.1!): +

+
+Requires: state_type shall meet the requirements of CopyAssignable (23.1), CopyConstructible (20.1.8), and DefaultConstructible types. +
+

+Change Class seed_seq 26.5.7.1 [rand.util.seedseq] (note again: including deletion of reference to 23.1!): +

+
+In addition to the requirements set forth below, instances of +seed_seq shall meet the requirements of CopyConstructible (20.1.8) and of CopyAssignable (23.1). +
+ +

+Note: The proposed resolution of this issue does not deal with the +instance of the term "Assignable" in D.12.1 [auto.ptr], as this is dealt +with more specifically by LWG 973, "auto_ptr characteristics", submitted +by Maarten Hilferink. +

+ + + + + + +
+

973. auto_ptr characteristics

+

Section: D.12.1 [auto.ptr] Status: NAD Editorial + Submitter: Maarten Hilferink Opened: 2009-01-21 Last modified: 2010-10-29

+

View all other issues in [auto.ptr].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+I think that the Note of D.12.1 [auto.ptr], paragraph 3 needs a rewrite +since "Assignable" is no longer defined as a concept. +The relationship of auto_ptr with the new CopyAssignable, MoveAssignable, + and MoveConstructible concepts should be clarified. +Furthermore, since the use of auto_ptr is depreciated anyway, + we can also omit a description of its intended use. +

+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the intent of the proposed resolution. +Move to NAD Editorial. +
+ + +

Proposed resolution:

+

+Change D.12.1 [auto.ptr], paragraph 3: +

+ +
+The auto_ptr provides a semantics of strict ownership. An +auto_ptr owns the ob ject 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 ob ject at +the same time the behavior of the program is undefined. [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. + +Instances of auto_ptr shall +meet the MoveConstructible and MoveAssignable +requirements, but do not meet the CopyConstructible and +CopyAssignable requirements. +-- end note] +
+ + + + + +
+

976. Class template std::stack should be movable

+

Section: 23.5.3.1 [stack.defn] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2009-02-01 Last modified: 2010-10-29

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The synopsis given in 23.5.3.1 [stack.defn] does not show up +

+ +
requires MoveConstructible<Cont> stack(stack&&);
+requires MoveAssignable<Cont> stack& operator=(stack&&);
+
+ +

+although the other container adaptors do provide corresponding +members. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+We agree with the proposed resolution. +

+

+Move to Tentatively Ready. +

+
+ +

[ +2009-07 Frankfurt +]

+ + +
+Moved from Tentatively Ready to Open only because the wording needs to be +tweaked for concepts removal. +
+ +

[ +2009-08-18 Daniel updates the wording and Howard sets to Review. +]

+ + +

[ +2009-08-23 Howard adds: +]

+ + +
+1194 also adds these move members using an editorially different +style. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark NAD Editorial, solved by issue 1194. +
+ + + +

Proposed resolution:

+

+In the class stack synopsis of 23.5.3.1 [stack.defn] insert: +

+ +
template <class T, class Container = deque<T> >
+class stack {
+  [..]
+  explicit stack(const Container&);
+  explicit stack(Container&& = Container());
+  stack(stack&& s) : c(std::move(s.c)) {}
+  stack& operator=(stack&& s) { c = std::move(s.c); return *this; }
+  [..]
+};
+
+ + + + + + + + +
+

977. insert iterators inefficient for expensive to move types

+

Section: 24.5.2 [insert.iterators] Status: NAD + Submitter: Howard Hinnant Opened: 2009-02-02 Last modified: 2010-10-29

+

View all other issues in [insert.iterators].

+

View all issues with NAD status.

+

Discussion:

+

+The new concepts for the insert iterators mandate an extra copy when +inserting an lvalue: +

+ +
requires CopyConstructible<Cont::value_type>
+  back_insert_iterator<Cont>& 
+  operator=(const Cont::value_type& value);
+
+
+-1- Effects: push_back(*container, Cont::value_type(value)); +
+
+ +

+The reason is to convert value into an rvalue because the current +BackInsertionContainer concept only handles push_back-ing +rvalues: +

+ +
concept BackInsertionContainer<typename C> : Container<C> { 
+  void push_back(C&, value_type&&); 
+}
+
+ +

+Without the conversion of value to an rvalue, the assignment operator +fails to concept check. +

+ +

+A solution is to modify the BackInsertionContainer concept so that +the client can pass in the parameter type for push_back similar to +what is already done for the OutputIterator concept: +

+ +
concept BackInsertionContainer<typename C, typename Value = C::value_type&&>
+  : Container<C> { 
+     void push_back(C&, Value); 
+}
+
+ +

+This allows the assignment operator to be adjusted appropriately: +

+ +
requires BackInsertionContainer<Cont, Cont::value_type const&> &&
+         CopyConstructible<Cont::value_type>
+  back_insert_iterator<Cont>& 
+  operator=(const Cont::value_type& value);
+
+
+-1- Effects: push_back(*container, value); +
+
+ +

[ +We may want to propagate this fix to other concepts such as StackLikeContainer. +]

+ + +

[ +Solution and wording collaborated on by Doug and Howard. +]

+ + +

[ +Batavia (2009-05): +]

+ +
+

+Howard notes that "these operations behaved efficiently until concepts were added." +

+

+Alisdair is uncertain that the proposed resolution is syntactically correct. +

+

+Move to Open, and recommend the issue be deferred until after the next +Committee Draft is issued. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD, solved by the removal of concepts. +
+ + + +

Proposed resolution:

+

+Change [container.concepts.free]: +

+ +
+
concept FrontInsertionContainer<typename C, typename Value = C::value_type&&>
+    : Container<C> { 
+  void push_front(C&, value_type&& Value); 
+
+  axiom FrontInsertion(C c, value_type Value x) { 
+    x == (push_front(c, x), front(c)); 
+  } 
+}
+
+ +

...

+ +
concept BackInsertionContainer<typename C, typename Value = C::value_type&&>
+    : Container<C> { 
+  void push_back(C&, value_type&& Value); 
+}
+
+ +

...

+ +
concept InsertionContainer<typename C, typename Value = C::value_type&&>
+    : Container<C> { 
+  iterator insert(C&, const_iterator, value_type&& Value); 
+
+  axiom Insertion(C c, const_iterator position, value_type Value v) { 
+    v == *insert(c, position, v); 
+  } 
+}
+
+ +
+ +

+Change [container.concepts.member]: +

+ +
+
auto concept MemberFrontInsertionContainer<typename C, typename Value = C::value_type&&>
+    : MemberContainer<C> { 
+  void C::push_front(value_type&& Value); 
+
+  axiom MemberFrontInsertion(C c, value_type Value x) { 
+    x == (c.push_front(x), c.front()); 
+  } 
+}
+
+ +

...

+ +
auto concept MemberBackInsertionContainer<typename C, typename Value = C::value_type&&>
+    : MemberContainer<C> { 
+  void C::push_back(value_type&& Value); 
+}
+
+ +

...

+ +
auto concept MemberInsertionContainer<typename C, typename Value = C::value_type&&>
+    : MemberContainer<C> { 
+  iterator C::insert(const_iterator, value_type&& Value); 
+
+  axiom MemberInsertion(C c, const_iterator position, value_type Value v) { 
+    v == *c.insert(position, v); 
+  } 
+}
+
+
+ +

+Change [container.concepts.maps]: +

+ +
+
template <MemberFrontInsertionContainer C, typename Value = C::value_type&&> 
+concept_map FrontInsertionContainer<C, Value> { 
+  typedef Container<C>::value_type value_type;
+
+  void push_front(C& c, value_type&& Value v) { c.push_front(static_cast<value_type&& Value>(v)); } 
+}
+
+ +

...

+ +
template <MemberBackInsertionContainer C, typename Value = C::value_type&&> 
+concept_map BackInsertionContainer<C, Value> { 
+  typedef Container<C>::value_type value_type;
+
+  void push_back(C& c, value_type&& Value v) { c.push_back(static_cast<value_type&& Value>(v)); } 
+}
+
+ +

...

+ +
template <MemberInsertionContainer C, typename Value = C::value_type&&> 
+concept_map InsertionContainer<C, Value> { 
+  typedef Container<C>::value_type value_type;
+  Container<C>::iterator insert(C& c, Container<C>::const_iterator i, value_type&& Value v) 
+  { return c.insert(i, static_cast<value_type&& Value>(v)); } 
+}
+
+ +
+ +

+Change 24.5.2.1 [back.insert.iterator]: +

+ +
template <BackInsertionContainer Cont> 
+class back_insert_iterator {
+  ...
+  requires BackInsertionContainer<Cont, const Cont::value_type&>
+           CopyConstructible<Cont::value_type>
+    back_insert_iterator<Cont>& 
+      operator=(const Cont::value_type& value);
+  ...
+
+ +

+Change 24.5.2.2.2 [back.insert.iter.op=]: +

+ +
+
requires BackInsertionContainer<Cont, const Cont::value_type&>
+         CopyConstructible<Cont::value_type>
+  back_insert_iterator<Cont>& 
+    operator=(const Cont::value_type& value);
+
+
+-1- Effects: push_back(*container, Cont::value_type(value)); +
+
+ +

+Change 24.5.2.3 [front.insert.iterator]: +

+ +
template <FrontInsertionContainer Cont> 
+class front_insert_iterator {
+  ...
+  requires FrontInsertionContainer<Cont, const Cont::value_type&>
+           CopyConstructible<Cont::value_type>
+    front_insert_iterator<Cont>& 
+      operator=(const Cont::value_type& value);
+  ...
+
+ +

+Change 24.5.2.4.2 [front.insert.iter.op=]: +

+ +
+
requires FrontInsertionContainer<Cont, const Cont::value_type&>
+         CopyConstructible<Cont::value_type>
+  front_insert_iterator<Cont>& 
+    operator=(const Cont::value_type& value);
+
+
+-1- Effects: push_front(*container, Cont::value_type(value)); +
+
+ +

+Change 24.5.2.5 [insert.iterator]: +

+ +
template <InsertionContainer Cont> 
+class insert_iterator {
+  ...
+  requires InsertionContainer<Cont, const Cont::value_type&>
+           CopyConstructible<Cont::value_type>
+    insert_iterator<Cont>& 
+      operator=(const Cont::value_type& value);
+  ...
+
+ +

+Change 24.5.2.6.2 [insert.iter.op=]: +

+ +
+
requires InsertionContainer<Cont, const Cont::value_type&>
+         CopyConstructible<Cont::value_type>
+  insert_iterator<Cont>& 
+    operator=(const Cont::value_type& value);
+
+
+

+-1- Effects: +

+
iter = insert(*container, iter, Cont::value_type(value)); 
+++iter;
+
+
+
+ + + + + + +
+

979. Bad example

+

Section: 24.5.3 [move.iterators] Status: NAD Editorial + Submitter: Howard Hinnant Opened: 2009-02-03 Last modified: 2010-10-29

+

View all issues with NAD Editorial status.

+

Discussion:

+

+24.5.3 [move.iterators] has an incorrect example: +

+ +
+

+-2- [Example: +

+ +
set<string> s; 
+// populate the set s 
+vector<string> v1(s.begin(), s.end());          // copies strings into v1 
+vector<string> v2(make_move_iterator(s.begin()), 
+                  make_move_iterator(s.end())); // moves strings into v2
+
+ +

+-- end example] +

+
+ +

+One can not move from a set because the iterators return const +references. +

+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the proposed resolution. Move to NAD Editorial. +
+ + + +

Proposed resolution:

+

+Change 24.5.3 [move.iterators]/2: +

+ +
+

+-2- [Example: +

+ +
setlist<string> s; 
+// populate the setlist s 
+vector<string> v1(s.begin(), s.end());          // copies strings into v1 
+vector<string> v2(make_move_iterator(s.begin()), 
+                  make_move_iterator(s.end())); // moves strings into v2
+
+ +

+-- end example] +

+
+ + + + + +
+

980. mutex lock() missing error conditions

+

Section: 30.4.1 [thread.mutex.requirements] Status: NAD + Submitter: Ion Gaztańaga Opened: 2009-02-07 Last modified: 2010-10-29

+

View all other issues in [thread.mutex.requirements].

+

View all issues with NAD status.

+

Discussion:

+

+POSIX 2008 adds two return values for pthread_mutex_xxxlock(): +EOWNERDEAD (owner_dead) and ENOTRECOVERABLE +(state_not_recoverable). In the first case the mutex is locked, +in the second case the mutex is not locked. +

+ +

+Throwing an exception in the first case can be incompatible with the use +of Locks, since the Lock::owns_lock() will be false when the lock is +being destroyed. +

+ +

+Consider: +

+ +
//Suppose mutex.lock() throws "owner_dead"
+unique_lock ul(&mutex);
+//mutex left locked if "owner_dead" is thrown
+
+ +

+Throwing an exception with owner_dead might be also undesirable if +robust-mutex support is added to C++ and the user has the equivalent of +pthread_mutex_consistent() to notify the user has fixed the corrupted +data and the mutex state should be marked consistent. +

+ +
    +
  1. +For state_not_recoverable add it to the list of Error conditions: +
    2. +
  2. +For owner_dead, no proposed resolution. +
    3. +
+ +

[ +Summit: +]

+ + +
+Not a defect. Handling these error conditions is an implementation +detail and must be handled below the C++ interface. +
+ + + +

Proposed resolution:

+ +

+Add to 30.4.1 [thread.mutex.requirements], p12: +

+ +
+

+-12- Error conditions: +

+ + +
+ + + + + +
+

988. Reflexivity meaningless?

+

Section: X [concept.comparison] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-02-24 Last modified: 2010-10-29

+

View all other issues in [concept.comparison].

+

View all issues with NAD status.

+

Discussion:

+

+X [concept.comparison] p2: +

+

+Due to the subtle meaning of == inside axioms, the Reflexivity axiom does +not do anything as written. It merely states that a value is substitutable +with itself, rather than asserting a property of the == operator. +

+ + +Original proposed resolution: + + +

+Change the definition of Reflexivity in X [concept.comparison]: +

+ +
axiom Reflexivity(T a) { (a == a) == true; }
+
+ +

[ +Post Summit: +]

+ + +
+

+Alisdair: I was wrong. +

+

+Recommend NAD. +

+
+ + + +

Proposed resolution:

+

+NAD. +

+ + + + + +
+

989. late_check and library

+

Section: 17 [library] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-02-24 Last modified: 2010-10-29

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+The example in 6.9p2 shows how late_check blocks inhibit concept_map lookup +inside a constrained context, and so inhibit concept map adaption by users +to meet template requirements. +

+

+Do we need some text in clause 17 prohibitting use of late_check in library +template definitions unless otherwise documented? +

+ +

[ +Doug adds: +]

+ + +
+We need something like this, but it should be a more general statement +about implementations respecting the concept maps provided by the +user. Use of late_check is one way in which implementations can +subvert the concept maps provided by the user, but there are other +ways as well ("pattern-based" overloading, tricks with "auto" concept +maps and defaulted associated type arguments). +
+ +

[ +Batavia (2009-05): +]

+ +
+Move to Open, pending proposed wording from Alisdair and/or Doug for further review. +
+ + +

Proposed resolution:

+ + + + + +
+

992. Response to UK 169

+

Section: 17.6.1.1 [contents] Status: NAD + Submitter: P.J. Plauger Opened: 2009-03-03 Last modified: 2010-10-29

+

View all other issues in [contents].

+

View all issues with NAD status.

+

Discussion:

+

Addresses UK 169

+

+This phrasing contradicts later freedom to implement the C standard +library portions in the global namespace as well as std. (17.6.2.3p4) +

+ +

[ +Batavia (2009-05): +]

+ +
+The proposed wording seems to go too far. +Move back to Open. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+

+Howard to add NB reference to the description of this issue. +

+

+Move to NAD. This comment is informative and not normative by the use of +the word "are" instead of the word "shall." +

+

+A note linking to Annex D would help clarify the intention, here. +

+

+Robert to Open a separate issue proposing that the standard C headers be +undeprecated, for the purpose of clarifying the standard. +

+
+ +

[ +2009-07-22 Bill modified the proposed wording with a clarifying footnote. +]

+ + + + +

Proposed resolution:

+

+Add a footnote to 17.6.1.1 [contents], p2: +

+ +
+

+-2- All library entities except macros, operator new and operator +delete are defined within the namespace std or namespaces +nested within namespace std*. +

+ +

+*The C standard library headers D.7 [depr.c.headers] also define +names within the global namespace, while the C++ headers for +C library facilities 17.6.1.2 [headers] may also define names within +the global namespace. +

+
+ + + + + + +
+

995. Operational Semantics Unclear

+

Section: 17.5.1.3 [structure.requirements] Status: NAD + Submitter: David Abrahams Opened: 2009-03-06 Last modified: 2010-10-29

+

View all issues with NAD status.

+

Discussion:

+

+As a practical matter there's disagreement on the meaning of operational +semantics. If the text in 17.5.1.3 [structure.requirements]p4 isn't +clear, it should be clarified. However, it's not clear whether the +disagreement is merely due to people not being aware of the text. +

+ +

[ +Batavia (2009-05): +]

+ +
+Agree with the recommended NAD resolution. +
+ + +

Proposed resolution:

+

+Recommend NAD. The text in 17.5.1.3 [structure.requirements] is +perfectly clear. +

+ + + + + +
+

996. Move operation not well specified

+

Section: 17 [library] Status: NAD + Submitter: David Abrahams Opened: 2009-03-06 Last modified: 2010-10-29

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD status.

+

Discussion:

+

+There are lots of places in the standard where we talk about "the move +constructor" but where we mean "the move operation," i.e. T( move( x ) ). +

+

+We also don't account for whether that operation modifies x or not, and +we need to. +

+ +

[ +Batavia (2009-05): +]

+ +
+Move to Open, pending proposed wording from Dave for further +review. +
+ + + +

[ +2010 Rapperswil: +]

+ + +
+Move to NAD. We define what we expect from a moved-from object in Table 34 [movesconstructible]. +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

1000. adjacent_find is over-constrained

+

Section: 25.2.8 [alg.adjacent.find] Status: NAD Concepts + Submitter: Chris Jefferson Opened: 2009-03-09 Last modified: 2010-10-23

+

View all other issues in [alg.adjacent.find].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+Addresses UK 296 +

+ +

+adjacent_find in C++03 allows an arbitrary predicate, but in C++0x +EqualityComparable/EquivalenceRelation is required. This forbids a +number of use cases, including: +

+
+ + + + + + + + + +
+adjacent_find(begin, end, less<double>) + +Find the first +place where a range is not ordered in decreasing order - in use to check +for sorted ranges. +
+adjacent_find(begin, end, DistanceBiggerThan(6) ) ) + +Find the first +place in a range where values differ by more than a given value - in use +to check an algorithm which produces points in space does not generate +points too far apart. +
+
+ +

+A number of books use predicate which are not equivalence relations in +examples, including "Thinking in C++" and "C++ Primer". +

+ +

+Adding the requirement that the predicate is an EquivalenceRelation +does not appear to open up any possibility for a more optimised algorithm. +

+ + + +

Proposed resolution:

+

+Change the definition of adjacent_find in the synopsis of 25 [algorithms] +and 25.2.8 [alg.adjacent.find] to: +

+ +
template<ForwardIterator Iter> 
+  requires EqualityComparableHasEqualTo<Iter::value_type, Iter::value_type>
+  Iter adjacent_find(Iter first, Iter last);
+
+template<ForwardIterator Iter, EquivalenceRelationPredicate<auto, Iter::value_type, Iter::value_type> Pred> 
+  requires CopyConstructible<Pred> 
+  Iter adjacent_find(Iter first, Iter last, Pred pred);
+
+ + + + + +
+

1001. Pointers, concepts and headers

+

Section: 17 [library] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-10 Last modified: 2010-10-23

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses UK 78

+ +

+Related to 1063. +

+ +

+This is effectively an extension of LWG issue 343. +

+

+We know there is an increasing trend (encouraged by conformance testers and +some users) that each library header should supply no more than required to +satisfy the synopsis in the standard. This is typically achieved by +breaking larger headers into smaller subsets, and judicious use of forward +declarations. +

+

+If we apply this policy to C++0x (per +N2800) +it will be very surprising for +people using library algorithms over ranges defined by pointers that they +must #include <iterator_concepts> for their code to compile again. That is +because pointers do not satisfy any of the iterator concepts without the +concept_map supplied in this header. +

+

+Therefore, I suggest we should require all library headers that make use of +iterator concepts are specifically required to #include <iterator_concepts>. +

+

+At a minimum, the list of headers would be: (assuming all are constrained by +concepts) +

+
algorithm
+array
+deque
+forward_list
+initializer_list
+iterator
+locale
+list
+map
+memory          // if 1029 is adopted
+memory_concepts
+numeric
+random
+regex
+set
+string
+tuple
+unordered_map
+unordered_set
+utility
+vector
+
+ +

[ +Ganesh adds: +]

+ + +
+

+The same problems exists for <memory_concepts> and +<container_concepts>. +

+

+In order to compile <vector> you just need the +definitions of the concepts in <memory_concepts>, the +concept maps defined there are not necessary. Yet, from the user point +of view, if the concept map template for AllocatableElement are +not in scope, <vector> is pretty useless. Same for +<tuple> and ConstructibleWithAllocator. +

+

+Similarly, <queue> is not very useful if the concept map +template for QueueLikeContainer is not in scope, although the +definition of concept alone is theoretically sufficient. +

+

+There's a pattern here: if a concept has concept maps "attached", they +should never be separated. +

+
+ +

[ +Beman provided the proposed resolution for the May 2009 mailing. He +comments: +]

+ + +
+ +

Initially I tried to specify exactly what header should include what other +headers. This was verbose, error prone, hard to maintain, and appeared to add +little value compared to just stating the general rule.

+ +
+ +

[ +Batavia (2009-05): +]

+ +
+

+Pete believes the proposed wording overconstrains implementers. +Instead of specifying the mechanism, +he prefers a solution that spells out what needs to be declared, +rather than how those declarations are to be provided, +e.g., +

+
+A C++ header shall provide the names +that are required to be defined in that header. +
+

+Bill suggests approaching the wording from a programmer's perspective. +We may want to consider promising that certain widely-used headers +(e.g., the concept headers) are included when needed by other headers. +He feels, however, there is nothing broken now, +although we may want to consider "something nicer." +

+

+Move to Open status. +

+ +
+ +

[ +2009-06-16 Beman updated the proposed resolution: +]

+ + +
+ +
+ +

[ +2009-07-15 Beman updated the proposed resolution: +]

+ + +

[ +2009-07-17 Beman updated the proposed resolution based on feedback from the LWG in Frankfurt: +]

+ + +
+ +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+

+Revised Proposed Resolution: +

+

+A C++ header may include other C++ headers. A C++ header shall provide +the declarations and definitions that appear in its synopsis (3.2 +[basic.def.odr]). A C++ header shown in its synopsis as including other +C++ headers shall provide the declarations and definitions that appear +in the synopses of those other headers. +

+

+Alisdair: Does this address the BSI comment? +

+

+Beman: There were several overlapping comments. I tried to handle them +all with one resolution. +

+

+Alisdair: I'd prefer to see this closed as NAD and have this resolution +be the subject of some other, new issue. +

+

+Move to NAD Concepts. Howard to open a new issue (1178) in Ready state with the +Proposed Resolution above. Beman will write up a discussion for the new +issue. +

+
+ + + +

Proposed resolution:

+

Change 17.6.4.2 [res.on.headers], Headers, paragraph 1, as indicated:

+ +
+ +

+A C++ header may include other C++ +headers.[footnote] A C++ header shall provide +the declarations and definitions that appear in its synopsis +(3.2 [basic.def.odr]). A C++ header shown in its synopsis as including +other C++ headers shall provide the same declarations and definitions as +if those other headers were included. +

+ +

[footnote] C++ headers must include a C++ header that contains + any needed definition (3.2).

+
+ + + + + + +
+

1002. Response to UK 170

+

Section: 17.6.1.2 [headers] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [headers].

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses UK 170

+ +

+One of goals of C++0x is to make language easier to teach and for +'incidental' programmers. The fine-grained headers of the C++ library +are valuable in large scale systems for managing dependencies and +optimising build times, but overcomplicated for simple development and +tutorials. Add additional headers to support the whole library through a +single include statement. +

+ +

[ +Batavia (2009-05): +]

+ +
+We do not all agree that this is an issue, +but we agree that if it needs solving this is the right way to do it. +Move to Tentatively Ready. +
+ +

[ +2009-07-06 Beman notes: +]

+ + +
+

+This issue +adds a header <std>. +

+

+There is a paper to be looked at, +N2905 +Aggregation headers, that adds +a header <std-all> that is the same thing except it excludes +deprecated headers. +N2905 +also proposes a second aggregation header. +

+

+Seems like this issue should be held in abeyance until the LWG has had +a chance to look at N2905. +

+
+ +

[ +2009-07-06 Howard: I've pulled this issue back to Review. +]

+ + +

[ +2009-07 Frankfurt +]

+ + +
+No consensus for change. +
+ + + +

Proposed resolution:

+

+Insert a new paragraph in 17.6.1.2 [headers] between p4 and p5 +

+
+An additional header <std> shall have the effect of +supplying the entire standard library. [Note: for example, it +might be implemented as a file with an #include statement for each of the +headers listed in tables 13 and 14. -- end note] +
+ + + + + +
+

1003. Response to JP 23

+

Section: 17.6.1.3 [compliance] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [compliance].

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses JP 23

+ +

+There is a freestanding implementation including +<type_traits>, <array>, +<ratio>, lately added to Table 13, C++ library headers. +Programmers think them useful and hope that these headers are also added +to Table 15, C++ headers for freestanding implementations, that shows +the set of headers which a freestanding implementation shall include at +least. +

+ +

Original proposed resolution

+ +

+Add <type_traits>, <array>, +<ratio> to Table 15. +

+ +

[ +Summit: +]

+ + +
+

+ The <array> header has far too many dependencies to require for a +free-standing implementation. +

+

+The <ratio> header would be useful, has no dependencies, but is not +strictly necessary. +

+

+The <type_traits> header is fundamentally a core language facility with a +library interface, so should be supported. +

+ +

+(it is anticipated the resolution will come via an update to paper +N2814) +(see also LWG 833) +

+
+ +

[ +Batavia (2009-05): +]

+ +
+Leave in Review status pending a paper on freestanding implementations +by Martin Tasker. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+

+Move this to NAD. +

+

+We considered all of the listed headers, and found a compelling case +only for the inclusion of <type_traits> in the list of headers required +of a freestanding implementation. +

+

+See Martin Tasker's paper +Fixing Freestanding +which provides the wording to include <type_traits> into freestanding +implementations. +

+
+ + + +

Proposed resolution:

+

+Add <type_traits> to Table 15. +

+ + + + + + +
+

1005. numeric_limits partial specializations not concept enabled

+

Section: 18.3.1.1 [numeric.limits] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses JP 26

+ +

+numeric_limits [partial specializations] does not use concept. +

+ +

[ +Summit: +]

+ + +
+Alisdair will provide a soltion as part of treatment of axioms and LWG 902. +
+ +

[ +Post Summit: +]

+ + +
+Alisdair recommends NAD as the partial specializations are already +constrained by requirements on the primary template. +
+ +

[ +Batavia (2009-05): +]

+ +
+The Working Draft does not in general repeat a primary template's constraints +in any specializations. +Move to NAD. +
+ +

[ +2009-05-25 Howard adds: +]

+ + +
+A c++std-lib thread starting at c++std-lib-23880 has cast doubt that NAD is the +correct resolution of this issue. Indeed the discussion also casts doubt that +the current proposed wording is the correct resolution as well. Personally I'm +inclined to reset the status to Open. However I'm reverting the status to +that which it had prior to the Batavia recommendation. I'm setting back to Review. +
+ + +

Proposed resolution:

+

+Change 18.3.1.1 [numeric.limits]: +

+ +
template<class Regular T> class numeric_limits<const T>;
+template<class Regular T> class numeric_limits<volatile T>;
+template<class Regular T> class numeric_limits<const volatile T>;
+
+ + + + + + +
+

1007. throw_with_nested not concept enabled

+

Section: 18.8.6 [except.nested] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [except.nested].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses JP 29

+ +

+throw_with_nested does not use concept. +

+ +

[ +Summit: +]

+ + +
+Agreed. +
+ + + +

Proposed resolution:

+ +

+Alisdair initially proposed wording in +N2619. +

+

+We are awaiting an updated paper based on feedback from the San Francisco +review. +

+ + + + + +
+

1008. nested_exception wording unclear

+

Section: 18.8.6 [except.nested] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [except.nested].

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses JP 31

+ +

+It is difficult to understand in which case nested_exception is applied. +

+ +

[ +Summit: +]

+ + +
+Alisdair will add an example in an update to +N2619. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+It doesn't appear that N2619 really addresses this. Alisdair to propose wording. +
+ +

[ +2010 Pittsburgh: +]

+ + +
+Mark issue 1008 as NAD, the type is adequately described. +
+ + + +

Rationale:

+

+nested_exception is intended to be inherited from by exception classes +that are to be thrown during the handling of another exception, i.e. +when translating from one exception type to another. nested_exception +allows the originally thrown exception to be easily retained in that +scenario. +

+ + +

Proposed resolution:

+ + + + + +
+

1009. InputIterator post-increment dangerous

+

Section: 24.2.2 [iterator.iterators] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses UK 251

+ +

+The post-increment operator is dangerous for a general InputIterator. +The multi-pass guarantees that make it meaningful are defined as part of +the ForwardIterator refinement. Any change will affect only constrained +templates that have not yet been written, so should not break existing +user iterators which remain free to add these operations. This change +will also affect the generalised OutputIterator, although there is no +percieved need for the post-increment operator in this case either. +

+ +

[ +2009-07-28 Alisdair adds: +]

+ + +
+We still think the issue is relevant, but needs totally rewording in +non-concept language. We would like to see the issue retained as Open, +rather than deferred as NAD Concepts. Review status is no longer +appropriate. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD. Without concepts we do not feel that input iterator post increment +is broken. +
+ + + +

Proposed resolution:

+

+Change 24.2.2 [iterator.iterators]: +

+ +
concept Iterator<typename X> : Semiregular<X> { 
+  MoveConstructible reference = typename X::reference; 
+  MoveConstructible postincrement_result;
+
+  requires HasDereference<postincrement_result>;
+
+  reference operator*(X&&); 
+  X& operator++(X&); 
+  postincrement_result operator++(X&, int);
+}
+
+ +

...

+
postincrement_result operator++(X& r, int);
+
+ +
+-3- Effects: equivalent to { X tmp = r; ++r; return tmp; }. +
+ +
+ +

+Change 24.2.3 [input.iterators]: +

+ +
+
concept InputIterator<typename X> : Iterator<X>, EqualityComparable<X> { 
+  ObjectType value_type = typename X::value_type; 
+  MoveConstructible pointer = typename X::pointer; 
+
+  SignedIntegralLike difference_type = typename X::difference_type; 
+
+  requires IntegralType<difference_type> 
+        && Convertible<reference, const value_type &>; 
+        && Convertible<pointer, const value_type*>; 
+
+  requires Convertible<HasDereference<postincrement_result>::result_type, const value_type&>;
+
+  pointer operator->(const X&); 
+}
+
+
+ +

+Change 24.2.4 [output.iterators]: +

+ +
+
auto concept OutputIterator<typename X, typename Value> { 
+  requires Iterator<X>; 
+
+  typename reference = Iterator<X>::reference; 
+  typename postincrement_result = Iterator<X>::postincrement_result;
+  requires SameType<reference, Iterator<X>::reference> 
+        && SameType<postincrement_result, Iterator<X>::postincrement_result>
+        && Convertible<postincrement_result, const X&>
+        && HasAssign<reference, Value> 
+        && HasAssign<HasDereference<postincrement_result>::result_type, Value>;
+}
+
+
+ +

+Change 24.2.5 [forward.iterators]: +

+ +

[ +See 1084 which is attempting to change this same area in a compatible +way. +]

+ + +
+
concept ForwardIterator<typename X> : InputIterator<X>, Regular<X> { 
+  requires Convertible<postincrement_result, const X&>;
+
+  MoveConstructible postincrement_result;
+  requires HasDereference<postincrement_result>
+        && Convertible<HasDereference<postincrement_result>::result_type, const value_type&>;
+
+  postincrement_result operator++(X&, int);
+
+  axiom MultiPass(X a, X b) { 
+    if (a == b) *a == *b; 
+    if (a == b) ++a == ++b; 
+  } 
+}
+
+ +
+

-4- ...

+
+ +
postincrement_result operator++(X& r, int);
+
+ +
+

+-5- Effects: equivalent to { X tmp = r; ++r; return tmp; }. +

+
+ +
+ + + + + + +
+

1010. operator-= should use default in concept

+

Section: 24.2.7 [random.access.iterators] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [random.access.iterators].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses UK 263

+ +

+This requirement on operator-= would be better expressed as a default +implementation in the concept, with a matching axiom. +

+ +

[ +Batavia (2009-05): +]

+ +
+The proposed resolution should also remove +paragraph 5 and the declaration that precedes it. +Further, we should provide an axiom +that captures the desired semantics. +This may be a broader policy to be applied. +Move to Open. +
+ + +

Proposed resolution:

+

+Change 24.2.7 [random.access.iterators]: +

+ +
concept RandomAccessIterator<typename X> : BidirectionalIterator<X>, LessThanComparable<X> {
+  ...
+  X& operator-=(X& x, difference_type n) { return x += -n; }
+  ...
+}
+
+ + + + + + +
+

1013. Response to UK 305

+

Section: 25.4.7 [alg.min.max] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

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

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 305

+ +

+The negative requirement on IsSameType is a hold-over from an earlier +draught with a variadic template form of min/max algorith. It is no +longer necessary. +

+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the proposed resolution. +Move to Tentatively Ready. +
+ +

[ +2009-07 Frankfurt +]

+ + +
+We believe this is NAD, but this needs to be reviewed against the +post-remove-concepts draft. +
+ + + +

Proposed resolution:

+

+Change 25 [algorithms]: +

+ +
template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  const T& min(const T& a, const T& b, Compare comp);
+...
+template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  const T& max(const T& a, const T& b, Compare comp);
+...
+template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
+
+ +

+Change 25.4.7 [alg.min.max], p1, p9 and p17: +

+ +
template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  const T& min(const T& a, const T& b, Compare comp);
+...
+template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  const T& max(const T& a, const T& b, Compare comp);
+...
+template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
+
+ + + + + + +
+

1015. Response to UK 199

+

Section: X [concept.transform] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [concept.transform].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses UK 199

+ +

+The requirement that programs do not supply concept_maps should +probably be users do not supply their own concept_map +specializations. The program will almost certainly supply +concept_maps - the standard itself supplies a specialization +for RvalueOf references. Note that the term program is +defined in 3.5 [basic.link]p1 and makes no account of the +standard library being treated differently to user written code. +

+ +

[ +2009-05-09 Alisdair adds: +]

+ + +
+

+The same problem is present in the words added for the +LvalueReference/RvalueReference concepts last meeting. +

+

+With three subsections requiring the same constraint, I'm wondering if there +is a better way to organise this section. +Possible 20.2.1 -> 20.2.3 belong in the fundamental concepts clause in + [concept.support]? While they can be implemented purely as a +library feature without additional compiler support, they are pretty +fundamental and we want the same restriction on user-concept maps as is +mandated there. +

+
+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the issue, +but believe the wording needs further improvement. +We want to investigate current definitions for nomenclature such as +"user" and "program." +Move to Open pending the recommended investigation. +
+ + +

Proposed resolution:

+

+Change X [concept.transform] p2: +

+ +
+-2- A program user shall not provide concept maps for +any concept in 20.1.1. +
+ +

+Change [concept.true] p2: +

+ +
+-2- Requires: a program user shall not +provide a concept map for the True concept. +
+ +

+Change [concept.classify] p2: +

+ +
+-2- Requires: a programuser shall not provide concept +maps for any concept in this section. +
+ + + + + + +
+

1016. Response to JP 33

+

Section: X [concept.comparison] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [concept.comparison].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses JP 33

+ +

+LessThanComparable and EqualityComparable don't correspond to NaN. +

+ +

Original proposed resolution:

+ +

+Apply concept_map to these concepts at FloatingPointType. +

+ +

[ +Post Summit, Alisdair adds: +]

+ + +
+

+I don't understand the proposed resolution - there is no such thing as a +'negative' concept_map, and these concepts are auto concepts that match +float/double etc. Also not clear how we are supposed to match values to +concepts. +

+

+Recommend NAD and treat as a subset of issue 902. +

+
+ + + +

Proposed resolution:

+

+Recommend NAD. +

+ + + + + +
+

1017. Response to US 66

+

Section: X [concept.regular] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses US 66

+ +

+Application of the Regular concept to floating-point types appears to be +controversial (see long discussion on std-lib reflector). +

+ +

Original proposed resolution:

+ +

+State that the Regular concept does not apply to floating-point types. +

+ +

[ +Summit: +]

+ + +
+

+Recommend that we handle the same as JP 33 / 1016. +

+
+ +

[ +Post Summit, Alisdair adds: +]

+ + +
+

+Recommend Open, and review after resolution of 902 and revised axiom +feature. +

+
+ + + +

Proposed resolution:

+ + + + + +
+

1018. Response to US 70

+

Section: 20.7 [meta] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [meta].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses US 70

+ +

+Specifications now expressed via narrative text are more accurately and +clearly expressed via executable code. +

+

+Wherever concepts are available that directly match this section's type +traits, express the traits in terms of the concepts instead of via +narrative text. Where the type traits do not quite match the +corresponding concepts, bring the two into alignment so as to avoid two +nearly-identical notions. +

+ +

[ +Summit: +]

+ + +
+

+We think that this is a good idea, but it requires a lot of work. If someone +submits a paper proposing specific changes, we would be happy to review it +at the next meeting. +

+
+ + + +

Proposed resolution:

+ + + + + +
+

1020. Response to UK 204

+

Section: 20.7.7.6 [meta.trans.other] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [meta.trans.other].

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses UK 204

+ +

+It is not possible to create a variant union based on a parameter pack +expansion, e.g. to implement a classic discriminated union template. +

+ +

Original proposed resolutuion:

+ +

+Restore aligned_union template that was removed by LWG issue 856. +

+ +

[ +Summit: +]

+ + +
+Agree. The need for aligned_union is compelling enough to reinstate. +
+ +

[ +Post Summit, Alisdair adds: +]

+ + +
+paper +N2843 +proposes an extension to the [[align]] attribute +that further diminishes the need for this template. Recommend NAD. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark NAD as suggested. +
+ + + +

Proposed resolution:

+ + + + + +
+

1022. Response to UK 212

+

Section: 20.9.11 [util.dynamic.safety] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [util.dynamic.safety].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 212

+ +

+The pointer-safety API is nothing to do with smart pointers, so does not +belong in 20.9.10 [util.smartptr]. In fact it is a set of language +support features are really belongs in clause 18 [language.support], with the contents declared in a header that +deals with language-support of memory management. +

+ +

[ +Summit: +]

+ + +
+Agree in principle, but not with the proposed resolution. We believe it +belongs either a subsection of either 20 [utilities] or 20.9 [memory] as part of the general reorganization of 20 [utilities]. The declaration should stay in +<memory>. +
+ + + +

Proposed resolution:

+ + + + + +
+

1023. Response to DE 22

+

Section: 20.8.14.2 [func.wrap.func] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [func.wrap.func].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses DE 22

+ +

Related to issue 1114.

+ +

+The conditions for deriving from std::unary_function and +std::binary_function are unclear: The condition would also be satisfied if +ArgTypes were std::vector<T1>, because it (arguably) +"contains" T1. +

+ +

[ +Summit: +]

+ + +
+Agree. std::reference_wrapper has the same structure, and we +suggest that std::function be presented in the same way as +std::reference_wrapper. +
+ +

[ +2009-05-09 Alisdair adds: +]

+ + +
+Phrasing should be "publicly and +unambiguously derived from" and probably back in reference_wrapper too. Updated +wording supplied. +
+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the proposed wording. +Move to NAD Editorial. +
+ + +

Proposed resolution:

+

+(no changes to <functional> synopsis required) +

+ +

+Change synopsis in Class template function 20.8.14.2 [func.wrap.func]: +

+ +
template<Returnable R, CopyConstructible... ArgTypes> 
+class function<R(ArgTypes...)> 
+  : public unary_function<T1, R>      // iff sizeof...(ArgTypes) == 1 and see below
+                                      // ArgTypes contains T1
+  : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and see below
+                                      // ArgTypes contains T1 and T2
+{
+   ...
+
+ +

+Add new p1/p2 before 20.8.14.2.1 [func.wrap.func.con]: +

+ +
+

+The template instantiation function<R(T1)> shall be publicly and +unambiguously derived from +std::unary_function<T1,R> if and only if the template type parameter +is a function type taking one argument of type T1 and returning R. +

+ +

+The template instantiation function<R(T1,T2)> shall be publicly and +unambiguously derived from +std::binary_function<T1,T2,R> if and only if the template type +parameter is a function type taking two arguments of type T1 and T2 and +returning R. +

+ +
explicit function();
+
+
+ + + + + + +
+

1024. Response to JP 39

+

Section: 20.8.14.2 [func.wrap.func] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [func.wrap.func].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses JP 39

+ +

+There are no requires corresponding to F of std::function. +

+ +

[ +2009-05-01 Daniel adds: +]

+ + +
+1070 removes the second constructor. +
+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the proposed resolution. +Move to Tentatively Ready. +If issue 1070 is accepted, +the changes to the second constructor +in this issue are moot. +
+ +

[ +2009-07 Frankfurt: +]

+ + +
+Constructors have no definition. +
+ + + +

Proposed resolution:

+

+Correct as follows in 20.8.14.2 [func.wrap.func] (class definition) +

+ +
 template<class F, Allocator Alloc>
+   requires ConstructibleWithAllocator<F, Alloc>
+     && call=Callable<F, ArgTypes...>
+     && Convertible<call::result_type, R>
+   function(allocator_arg_t, const Alloc&, F);
+ template<class F, Allocator Alloc>
+   requires ConstructibleWithAllocator<F,Alloc>
+     && call=Callable<F, ArgTypes...>
+     && Convertible<call::result_type, R>
+   function(allocator_arg_t, const Alloc&, F&&);
+
+ + + + + + +
+

1025. Response to UK 208

+

Section: 20.8.15 [unord.hash] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [unord.hash].

+

View all issues with NAD Future status.

+

Discussion:

+ +

Addresses UK 208

+ +

+std::hash should be implemented for much more of the standard +library. In particular for pair, tuple and all the +standard containers. +

+ + + +

Proposed resolution:

+ + + + + +
+

1026. Response to UK 209

+

Section: 20.9 [memory] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [memory].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses UK 209

+ +

+Smart pointers cannot be used in constrained templates. +

+ +

[ +Summit: +]

+ + +
+We look forward to a paper on this topic. We recommend no action until a +paper is available. We understand that a paper is forthcoming. +
+ +

[ +Peter Dimov adds: +]

+ + +
+shared_ptr<T> and weak_ptr<T> support all +types T for which T* is valid. In other words, a +possible (partial) resolution is to change class T to +PointeeType T for shared_ptr, weak_ptr and +possibly enable_shared_from_this. +
+ + + +

Proposed resolution:

+ + + + + +
+

1027. Response to UK 213

+

Section: 20.9.5 [default.allocator] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses UK 213

+ +

+std::allocator should be constrained to simplify its use on constrained +contexts. This library component models allocation from free store via the +new operator so choose constraints to +match. The Allocator concept allows for a wider variety of allocators that +users may choose to supply if their allocation model does not require +operator new, without impacting the +requirements of this template. +

+ +

+Suggested direction: +

+

+The primary allocator template should be constrained to require +ObjectType<T> and FreeStoreAllocatable<T>. +Further operations to be constrained as required. +

+ +

[ +Summit: +]

+ + +
+Agree as stated. A future paper will address additional related issues. +
+ + + +

Proposed resolution:

+ + + + + +
+

1028. Response to UK 214

+

Section: 20.9.6 [storage.iterator] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses UK 214

+ +

+raw_storage_iterator needs constraining as an iterator adaptor to be safely +used in constrained templates +

+ +

[ +Summit: +]

+ + +
+We look forward to a paper on this topic. We recommend no action until a +paper is available. +
+ +

[ +Post Summit Alisdair provided wording and rationale. +]

+ + + + +

Proposed resolution:

+

+20.9 [memory] p2 +

+

+Update the synopsis for <memory> +

+
// 20.7.8, raw storage iterator:
+template <class ForwardIterator OutputIterator, class ObjectType T> 
+  requires OutputIterator< OutIter, T >
+    class raw_storage_iterator;
+
+template <ForwardIterator OutIter, ObjectType T> 
+  requires OutputIterator< OutIter, T >
+  concept_map Iterator<raw_storage_iterator< OutIter, T > > { }
+
+ + +

+20.9.6 [storage.iterator] p1 +

+

+Replace class template definition with: +

+
namespace std { 
+  template <class ForwardIterator OutputIterator, class ObjectType T> 
+    requires OutputIterator< OutIter, T >
+  class raw_storage_iterator 
+    : public iterator<output_iterator_tag,void,void,void,void> { 
+  public: 
+    explicit raw_storage_iterator(OutputIterator x); 
+
+    raw_storage_iterator<OutputIterator,T>& operator*(); 
+    raw_storage_iterator<OutputIterator,T>& operator=(const T& element); 
+    raw_storage_iterator<OutputIterator,T>& operator++(); 
+    raw_storage_iterator<OutputIterator,T> operator++(int); 
+  }; 
+
+  template <ForwardIterator OutIter, ObjectType T> 
+    requires OutputIterator< OutIter, T >
+    concept_map Iterator<raw_storage_iterator< OutIter, T > > { }
+}
+
+ + +

Rationale:

+

+raw_storage_iterator has to adapt a ForwardIterator, +rather than just an InputIterator for two reasons: +

+ +
    +
  1. +The initial iterator passed by value is expected to remain valid, +pointing to the initialized region of memory. +
    2. +
  2. +to avoid breaking the declaration of post-increment operator which would +require some kind of proxy formulation to support generalised InputIterators. +
    3. +
+ + + + + + +
+

1029. Response to UK 210

+

Section: 20.9.8 [specialized.algorithms] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [specialized.algorithms].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses UK 210

+ +

Related to 582

+ +

+Specialized algorithms for memory managenment need requirements to be +easily usable in constrained templates. +

+ +

[ +Summit: +]

+ + +
+We look forward to a paper on this topic. We recommend no action until a +paper is available. +
+ +

[ +Post Summit Alisdair provided wording. +]

+ + +

[ +Post Summit: +]

+ + +
+

+Daniel adds: +

+ +
+
    +
  1. +I suggest Size should require IntegralLike and not UnsignedIntegralLike, +because otherwise simple int-literals could not be provided as arguments +and it would conflict with other algorithms that only require IntegralLike. +
    2. +
  2. +

    +The current for-loop-test relies on evaluation in boolean context which is +not provided by ArithmeticLike and it's refinements. I propose to change the +corresponding for-loop-headers to: +

    +
      +
    1. +for uninitialized_copy_n: for ( ; n > Size(0); ++result, ++first, --n) { +
      2. +
    2. +for uninitialized_fill_n: for (; n > Size(0); ++first, --n) { +
      3. +
    +
    3. +
+
+ +

+Alisdair adds: +

+
+For the record I agree with Daniel's suggestion. +
+ +
+ + + +

Proposed resolution:

+

+20.9 [memory] p2 +

+

+Update the synopsis for <memory> +

+
template <class InputIterator InIter,
+         class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
+   requires ForwardIterator<OutIter>
+   ForwardIterator OutIter
+   uninitialized_copy(InputIterator InIter first, InputIterator InIter last, 
+                      ForwardIterator OutIter result);
+
+template <class InputIterator InIter,
+          class IntegralLike Size,
+          class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
+  requires ForwardIterator<OutIter>
+  ForwardIterator OutIter
+  uninitialized_copy_n(InputIterator InIter first, Size n, 
+                       ForwardIterator OutIter result);
+
+template <class ForwardIterator Iter, class ObjectType T>
+  requires Constructible< Iter::value_type, const T& >
+  void uninitialized_fill(ForwardIterator Iter first, ForwardIterator Iter last, 
+                          const T& x);
+
+template <class ForwardIterator Iter, class IntegralLike Size, class ObjectType T> 
+  requires Constructible< Iter::value_type, const T& >
+  void
+  uninitialized_fill_n(ForwardIterator Iter first, Size n, const T& x);
+
+ +

+Update as follows: +

+ +

+uninitialized_copy 20.9.8.2 [uninitialized.copy] +

+ +
template <class InputIterator InIter,
+         class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
+   requires ForwardIterator<OutIter>
+   ForwardIterator OutIter
+   uninitialized_copy(InputIterator InIter first, InputIterator InIter last, 
+                      ForwardIterator OutIter result);
+
+ +
+

+-1- Effects: +

+
for (; first != last; ++result, ++first)  {
+   new (static_cast<void*>(&*result))
+       typename iterator_traits<ForwardIterator> OutIter::value_type(*first);
+}
+
+ +

+-2- Returns: result +

+ +
+ +
template <class InputIterator InIter,
+          class IntegralLike Size,
+          class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
+  requires ForwardIterator<OutIter>
+  ForwardIterator OutIter
+  uninitialized_copy_n(InputIterator InIter first, Size n, 
+                       ForwardIterator OutIter result);
+
+ +
+

+-3- Effects: +

+
for ( ; n > Size(0); ++result, ++first, --n) {
+   new (static_cast<void*>(&*result))
+       typename iterator_traits<ForwardIterator> OutIter::value_type(*first);
+}
+
+

+-4- Returns: result +

+
+ +
+ + +

+uninitialized_fill 20.9.8.3 [uninitialized.fill] +

+ +
template <class ForwardIterator Iter, class ObjectType T>
+  requires Constructible< Iter::value_type, const T& >
+  void uninitialized_fill(ForwardIterator Iter first, ForwardIterator Iter last, 
+                          const T& x);
+
+ +
+

+-1- Effects: +

+
for (; first != last; ++first) {
+   new ( static_cast<void*>( &*first) ) 
+       typename iterator_traits<ForwardIterator> Iter::value_type(x);
+}
+
+
+
+ + +

+uninitialized_fill_n 20.9.8.4 [uninitialized.fill.n] +

+ +
template <class ForwardIterator Iter, class IntegralLike Size, class ObjectType T> 
+  requires Constructible< Iter::value_type, const T& >
+  void
+  uninitialized_fill_n(ForwardIterator Iter first, Size n, const T& x);
+
+ +
+

+-1- Effects: +

+
for (; n-- > Size(0); ++first, --n) {
+   new ( static_cast<void*>( &*first) ) 
+       typename iterator_traits<ForwardIterator> Iter::value_type(x);
+}
+
+
+
+ + + + + + +
+

1031. Response to US 78

+

Section: 20.9.10.2 [util.smartptr.shared] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [util.smartptr.shared].

+

View all issues with NAD Future status.

+

Discussion:

+ +

Addresses US 78

+ +

+There is presently no way to convert directly from a shared_ptr to a +unique_ptr. Add an interface that performs the conversion. +

+ +

[ +Summit: +]

+ + +
+We look forward to a paper on this topic. We recommend no action until a +paper is available. We believe that the shared pointer must use the default +deleter for the conversion to succeed. +
+ +

[ +Peter Dimov adds: +]

+ + +
+This is basically a request for shared_ptr<>::release in +disguise, with all the associated problems. Not a good idea. +
+ +

[ +2009-07 post-Frankfurt: +]

+ + +
+

+The rationale for the omission of a release() member function from shared_ptr is given in: +http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/shared_ptr.htm +

+

+The implementation of such a member is non-trivial (and maybe +impossible), because it would need to account for the deleter. +

+
+ +

[ +2009-07-26 Howard sets to Tentatively NAD Future. +]

+ + +
+

+I took an online poll and got 3 votes for NAD and 3 for NAD Future. Personally +I prefer NAD Future as this does refer to an extension that could conceivably be +considered beyond C++0X. +

+ +

+However such an extension would need to solve a couple of problems: +

+ +
    +
  1. What is the interface for such a conversion when the shared_ptr does +not have unique ownership? Throw an exception? Create a null unique_ptr? +Undefined behavior? +
    2. + +
  2. +

    +How does one handle custom deleters given to the shared_ptr constructor? +

    +

    +I do not believe it is possible to implement a general answer to this question. +The shared_ptr deleter is a run time (or construction time) characteristic. +The unique_ptr deleter is a compile time characteristic. In general one +can not know to what type of unqiue_ptr you are converting to. +

    +

    +One answer is for the user of the conversion to specify the deleter type and perhaps +throw an exception if the specification turns out to be incorrect. +

    +

    +Another answer is for the conversion to only be valid when the underlying deleter +is default_delete. We would probalby need to specify that this is indeed the +underlying deleter of a shared_ptr when a custom deleter is not given in +the constructor. +

    +
    3. +
+ +

+At any rate, there are non-trivial design issues which would need to be implemented +and tested in the field for usability prior to standardization. +

+
+ +

[ +2009 Santa Cruz: +]

+ + +
+Moved to NAD Future. +
+ + + +

Proposed resolution:

+ + + + + +
+

1032. Response to JP 45

+

Section: 20.11 [time] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2010-10-23

+

View all other issues in [time].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses JP 45

+ +

+Rep, Period, Clock and Duration +don't correspond to concept. +

+
template <class Rep, class Period = ratio<1>> class duration; 
+template <class Clock, class Duration = typename Clock::duration> class time_point; 
+
+

+Make concept for Rep, Period, Clock and Duration. +Fix 20.11 [time] and wait_until +and wait_for's template parameter at 30 [thread]. +

+ +

[ +Summit: +]

+ + +
+We agree that this section needs concepts. We look forward to a paper on +this topic. We recommend no action until a paper is available. +
+ + + +

Proposed resolution:

+ + + + + +
+

1035. Response to UK 226

+

Section: 23.2.1 [container.requirements.general] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View other active issues in [container.requirements.general].

+

View all other issues in [container.requirements.general].

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses UK 226

+ +

+<array> must be added to this list. In particular it +doesn't satisfy: - no swap() function invalidates any +references, pointers, or iterators referring to the elements of the +containers being swapped. and probably doesn't satisfy: - no +swap() function throws an exception. +

+

+If <array> remains a container, this will have to also +reference array, which will then have to say which of these +points it satisfies. +

+ +

[ +Summit: +]

+ + +
+Agree. The proposed resolution is incomplete. Further work required. +
+ +

[ +2009-05-01 Daniel adds: +]

+ + +
+Issue 1099 also suggests +adding move constructor to this. +
+ +

[ +2009-07 post-Frankfurt: +]

+ + +
+Howard is to draft a note that explains what happens to references. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD. No consensus for change. +
+ + + +

[ +2009-08-01 Howard provided wording. +]

+ + +

Proposed resolution:

+

+Add a paragraph to 23.3.1.2 [array.special]: +

+ +
template <Swappable T, size_t N> void swap(array<T,N>& x, array<T,N>& y);
+
+
+

+Effects: +

+
swap_ranges(x.begin(), x.end(), y.begin());
+
+ +

+[Note: +Outstanding iterators, references and pointers may be invalidated. +— end note] +

+
+
+ + + + + +
+

1036. Response to UK 231

+

Section: 23.2.3 [sequence.reqmts] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View all other issues in [sequence.reqmts].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses UK 231

+ +

+p9-p11 are redundant now that Concepts define what it means to be an +Iterator and guide overload resolution accordingly. +

+ +

[ +Summit: +]

+ + +
+Agree with issue and change to 23.2.3 [sequence.reqmts]. The +changes required to 21 [strings] will be part of the general +concept support for that clause. +
+ + + +

Proposed resolution:

+

+Strike 23.2.3 [sequence.reqmts]p9-11. Make sure std::basic_string +has constraints similar to +std::vector to meet this old guarantee. +

+ + + + + +
+

1041. Response to UK 239

+

Section: 23.2.4 [associative.reqmts] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View other active issues in [associative.reqmts].

+

View all other issues in [associative.reqmts].

+

View all issues with NAD Future status.

+

Discussion:

+ +

Addresses UK 239

+ +

+It is not possible to take a move-only key out of an unordered +container, such as (multi)set or +(multi)map, or the new unordered containers. +

+ +

+Add below a.erase(q), a.extract(q), with the following notation: +

+

+a.extract(q)>, Return type pair<key, iterator> +Extracts the element pointed to by q and erases it from the +set. Returns a pair containing the value pointed to by +q and an iterator pointing to the element immediately +following q prior to the element being erased. If no such +element exists,returns a.end(). +

+ +

[ +Summit: +]

+ + +
+We look forward to a paper on this topic. We recommend no action until a +paper is available. The paper would need to address exception safety. +
+ +

[ +Post Summit Alisdair adds: +]

+ + +
+Would value_type be a better return type than key_type? +
+ +

[ +2009-07 post-Frankfurt: +]

+ + +
+Leave Open. Alisdair to contact Chris Jefferson about this. +
+ +

[ +2009-09-20 Howard adds: +]

+ + +
+See the 2009-09-19 comment of 839 for an API which +accomplishes this functionality and also addresses several other use +cases which this proposal does not. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD Future. No consensus to make the change at this time. +
+ + + +

Proposed resolution:

+

+In 23.2.4 [associative.reqmts] Table 85, add: +

+ +
+ + + + + + + + + + + + + + + + + + +
Table 85 -- Associative container requirements (in addition to container)
ExpressionReturn typeAssertion/note
pre-/post-condition		Complexity
a.erase(q).........
a.extract(q)pair<key_type, iterator>Extracts the element pointed to by q and erases it from the set. +Returns a pair containing the value pointed to by q and an iterator +pointing to the element immediately following q prior to the element being +erased. If no such element +exists, returns a.end().amortized constant
+
+ +

+In 23.2.5 [unord.req] Table 87, add: +

+ +
+ + + + + + + + + + + + + + + + + + +
Table 87 -- Unordered associative container requirements (in addition to container)
ExpressionReturn typeAssertion/note
pre-/post-condition		Complexity
a.erase(q).........
a.extract(q)pair<key_type, iterator>Extracts the element pointed to by q and erases it from the set. +Returns a pair containing the value pointed to by q and an iterator +pointing to the element immediately following q prior to the element being +erased. If no such element +exists, returns a.end().amortized constant
+
+ + + + + +
+

1042. Response to UK 244

+

Section: 23.3 [sequences] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View all other issues in [sequences].

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses UK 244

+ +

+The validity of the expression &a[n] == &a[0] + n is contingent on +operator& doing the "right thing" (as captured by the CopyConstructible +requirements in table 30 in C++2003). However this constraint has been +lost in the Concepts of C++0x. This applies to vector and array (it +actually applies to string also, but that's a different chapter, so I'll +file a separate comment there and cross-reference). +

+ +

+Suggested solution: +

+ +

+Define a ContiguousStrorage and apply it to +vector, array and string. +

+ +

[ +Summit: +]

+ + +
+Agree with the issue but not the details of the proposed solution. Walter to +provide wording for the new concept. +
+ +

[ +Post Summit Alisdair adds: +]

+ + +
+Another LWG subgroup wondered if this concept +should extend to complex<T>, and so not be built on the container concept at +all? +
+ +

[ +2009-07 post-Frankfurt: +]

+ + +
+Leave Open, pending a post-Concepts Working Draft. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark issue 1042 as NAD, in rationale state that this was solved by removal of concepts. +
+ + + +

Proposed resolution:

+

+Add to <container_concepts> synopsis in [container.concepts] +

+ +
concept< typename C > ContiguousStorageContainer see below;
+
+ +

+Add a new section to the end of [container.concepts] +

+ +
+

+23.1.6.x ContiguousStorageContainer concept [container.concepts.contiguous] +

+ +
concept ContiguousStorageContainer< typename C >
+  : Container<C>
+{
+  value_type* data(C&);
+
+  axiom Contiguity(C& c, size_type i) {
+    if( i < size(c) ) {
+         addressof( * (data(c) + i) )
+      == addressof( * advance(data(c), i) );
+    }
+  }
+}
+
+ +

+The ContiguousStorageContainer concept describes a container whose elements +are allocated in a single region of memory, and are stored sequentially +without intervening padding other than to meet alignment requirements. +For example, the elements may be stored in a +single array of suitable length. +

+ +
value_type * data( C& );
+
+ +
+Returns: a pointer to the first element in the region of storage. +Result is unspecified for an empty container. +
+ +
+ +

+Change 23.3.1 [array] p1: +

+ +
+-1- The header <array> defines a class template for +storing fixed-size sequences of objects. An array supports +random access iterators. An instance of array<T, N> +stores N elements of type T, so that size() == +N is an invariant. The elements of an array are stored +contiguously, meaning that if a is an +array<T, N> then it obeys the identity &a[n] +== &a[0] + n for all 0 <= n < N +satisfies the concept ContiguousStorageContainer< array<T, +N>>. +
+ +

+Add to the synopsis in 23.3.1 [array]: +

+ +
    ...
+    T * data(); 
+    const T * data() const; 
+  };
+
+  template< typename T, size_t N >
+    concept_map ContiguousStorageContainer< array<T, N>> {};
+} 
+
+ +

+Change 23.4.1 [vector] p1: +

+ +
+A vector is a sequence container that supports random access +iterators. In addition, it supports (amortized) constant time insert and +erase operations at the end; insert and erase in the middle take linear +time. Storage management is handled automatically, though hints can be +given to improve efficiency. The elements of a vector are stored +contiguously, meaning that if v is a +vector<T, Alloc> (where T is some +type other than bool), then it obeys the +identity &v[n] == &v[0] + n for all 0 <= n < +v.size() satisfies the concept ContiguousStorageContainer< +vector< T, Alloc>>. +
+ +

+Add at the end of the synopsis in 23.4.1 [vector] p2: +

+ +
template< typename T, typename A >
+  requires !SameType< T, bool >
+  concept_map ContiguousStorageContainer< vector<T, A>> {};
+
+ + + +

Rationale:

+Solved by removal of concepts. + + + + + +
+

1043. Response to US 91

+

Section: 29.6 [atomics.types.operations] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View other active issues in [atomics.types.operations].

+

View all other issues in [atomics.types.operations].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses US 91

+ +

+It is unclear whether or not a failed compare_exchange is a RMW operation +(as used in 1.10 [intro.multithread]). +

+ +

+Suggested solution: +

+ +

+Make failing compare_exchange operations not be RMW. +

+ +

[ +Anthony Williams adds: +]

+ + +
+In 29.6 [atomics.types.operations] p18 it says that "These +operations are atomic read-modify-write operations" (final sentence). +This is overly restrictive on the implementations of +compare_exchange_weak and compare_exchange_strong on platforms without a +native CAS instruction. +
+ + +

[ +Summit: +]

+ + +
+Group agrees with the resolution as proposed by Anthony Williams in the attached note. +
+ +

[ +Batavia (2009-05): +]

+ +
+We recommend the proposed resolution be reviewed +by members of the Concurrency Subgroup. +
+ +

[ +2009-07 post-Frankfurt: +]

+ + +
+This is likely to be addressed by Lawrence's upcoming paper. He will +adopt the proposed resolution. +
+ +

[ +2009-08-17 Handled by +N2925. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+

+Change 29.6 [atomics.types.operations] p18: +

+ +
+-18- Effects: Atomically, compares the value pointed to by +object or by this for equality with that in +expected, and if true, replaces the value pointed to by +object or by this with desired, and if false, updates +the value in expected with the value pointed to by +object or by this. Further, if the comparison is true, +memory is affected according to the value of success, and if the +comparison is false, memory is affected according to the value of +failure. When only one memory_order argument is +supplied, the value of success is order, and the value +of failure is order except that a value of +memory_order_acq_rel shall be replaced by the value +memory_order_acquire and a value of +memory_order_release shall be replaced by the value +memory_order_relaxed. If the comparison is true, +Tthese operations are atomic +read-modify-write operations (1.10). +If the comparison is false, these +operations are atomic load operations. +
+ + + + + + +
+

1046. Response to UK 329

+

Section: 30.6 [futures] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View all other issues in [futures].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 329

+ +

+future, promise and packaged_task provide a +framework for creating future values, but a simple function to tie all +three components together is missing. Note that we only need a *simple* +facility for C++0x. Advanced thread pools are to be left for TR2. +

+ +

+Simple Proposal: +

+ +

+Provide a simple function along the lines of: +

+
template< typename F, typename ... Args >
+  requires Callable< F, Args... >
+    future< Callable::result_type > async( F&& f, Args && ... ); 
+
+ +

+Semantics are similar to creating a thread object with a packaged_task +invoking f with forward<Args>(args...) +but details are left unspecified to allow different scheduling and thread +spawning implementations. +

+

+It is unspecified whether a task submitted to async is run on its own thread +or a thread previously used for another async task. If a call to async +succeeds, it shall be safe to wait for it from any thread. +

+

+The state of thread_local variables shall be preserved during async calls. +

+

+No two incomplete async tasks shall see the same value of +this_thread::get_id(). +

+

+[Note: this effectively forces new tasks to be run on a new thread, or a +fixed-size pool with no queue. If the +library is unable to spawn a new thread or there are no free worker threads +then the async call should fail. --end note] +

+ +

[ +Summit: +]

+ + +
+

+The concurrency subgroup has revisited this issue and decided that it +could be considered a defect according to the Kona compromise. A task +group was formed lead by Lawrence Crowl and Bjarne Stroustrup to write a +paper for Frankfort proposing a simple asynchronous launch facility +returning a future. It was agreed that the callable must be run on a +separate thread from the caller, but not necessarily a brand-new thread. +The proposal might or might not allow for an implementation that uses +fixed-size or unlimited thread pools. +

+

+Bjarne in c++std-lib-23121: I think that what we agreed was that to +avoid deadlock async() would almost certainly be specified to launch in +a different thread from the thread that executed async(), but I don't +think it was a specific design constraint. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Proposed resolution: see +N2996 +(Herb's and Lawrence's paper on Async). Move state to NAD editorial. +
+ + + +

Proposed resolution:

+ + + + + +
+

1047. Response to UK 334

+

Section: 30.6.6 [futures.unique_future] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View all other issues in [futures.unique_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 334

+ +

+Behaviour of get() is undefined if calling get() while +not is_ready(). The intent is that get() is a blocking +call, and will wait for the future to become ready. +

+ +

[ +Summit: +]

+ + +
+

+Agree, move to Review. +

+
+ +

[ +2009-04-03 Thomas J. Gritzan adds: +]

+ + +
+

+This issue also applies to shared_future::get(). +

+ +

+Suggested wording: +

+ +

+Add a paragraph to 30.6.7 [futures.shared_future]: +

+ +
void shared_future<void>::get() const;
+
+
+Effects: If is_ready() would return false, block on the asynchronous +result associated with *this. +
+
+
+ +

[ +Batavia (2009-05): +]

+ +
+It is not clear to us that this is an issue, +because the proposed resolution's Effects clause seems to duplicate +information already present in the Synchronization clause. +Keep in Review status. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2997. +
+ + + +

Proposed resolution:

+

+Add a paragraph to 30.6.6 [futures.unique_future]: +

+ +
R&& unique_future::get(); 
+R& unique_future<R&>::get(); 
+void unique_future<void>::get();
+
+
+

Note:...

+

+Effects: If is_ready() would return false, +block on the asynchronous result associated with *this. +

+

+Synchronization: if *this is associated with a +promise object, the completion of set_value() or +set_exception() to that promise happens before (1.10) +get() returns. +

+
+
+ + + + + +
+

1048. Response to UK 335

+

Section: 30.6.6 [futures.unique_future] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View all other issues in [futures.unique_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 335

+ +

+std::unique_future is MoveConstructible, so you can transfer the +association with an asynchronous result from one instance to another. +However, there is no way to determine whether or not an instance has +been moved from, and therefore whether or not it is safe to wait for it. +

+ +
std::promise<int> p;
+std::unique_future<int> uf(p.get_future());
+std::unique_future<int> uf2(std::move(uf));
+uf.wait(); // oops, uf has no result to wait for. 
+
+ +

+Suggest we add a waitable() function to unique_future +(and shared_future) akin to std::thread::joinable(), +which returns true if there is an associated result to wait for +(whether or not it is ready). +

+ +

+Then we can say: +

+ +
if(uf.waitable()) uf.wait();
+
+ +

[ +Summit: +]

+ + +
+

+Create an issue. Requires input from Howard. Probably NAD. +

+
+ +

[ +Post Summit, Howard thows in his two cents: +]

+ + +
+

+Here is a copy/paste of my last prototype of unique_future which was +several years ago. At that time I was calling unique_future future: +

+ +
template <class R>
+class future
+{
+public:
+    typedef R result_type;
+private:
+    future(const future&);// = delete;
+    future& operator=(const future&);// = delete;
+
+    template <class R1, class F1> friend class prommise;
+public:
+    future();
+    ~future();
+
+    future(future&& f);
+    future& operator=(future&& f);
+
+    void swap(future&& f);
+
+    bool joinable() const;
+    bool is_normal() const;
+    bool is_exceptional() const;
+    bool is_ready() const;
+
+    R get();
+
+    void join();
+    template <class ElapsedTime>
+        bool timed_join(const ElapsedTime&);
+};
+
+ +

+shared_future had a similar interface. I intentionally reused +the thread interface where possible to lessen the learning +curve std::lib clients will be faced with. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2997. +
+ + + +

Proposed resolution:

+ + + + + +
+

1049. Response to UK 339

+

Section: 30.6.5 [futures.promise] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View other active issues in [futures.promise].

+

View all other issues in [futures.promise].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 339

+ +

+Move assignment is goiing in the wrong direction, assigning from +*this to the passed rvalue, and then returning a reference to +an unusable *this. +

+ +

[ +Summit: +]

+ + +
+

+Agree, move to Review. +

+
+ +

[ +Batavia (2009-05): +]

+ +
+We recommend deferring this issue until after Detlef's paper (on futures) +has been issued. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2997. +
+ + + +

Proposed resolution:

+

+Strike 30.6.5 [futures.promise] p6 and change p7: +

+ +
promise& operator=(promise&& rhs);
+
+
+

+-6- Effects: move assigns its associated state to rhs. +

+

+-7- Postcondition: *this has no associated +state. associated state of *this is the same as the +associated state of rhs before the call. rhs has no +associated state. +

+
+
+ + + + + + +
+

1050. Response to UK 340

+

Section: 30.6.5 [futures.promise] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View other active issues in [futures.promise].

+

View all other issues in [futures.promise].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 340

+ +

+There is an implied postcondition for get_future() that the state of the +promise is transferred into the future leaving the promise with no +associated state. It should be spelled out. +

+ +

[ +Summit: +]

+ + +
+

+Agree, move to Review. +

+
+ +

[ +2009-04-03 Thomas J. Gritzan adds: +]

+ + +
+

+promise::get_future() must not invalidate the state of the promise object. +

+

+A promise is used like this: +

+
promise<int> p; 
+unique_future<int> f = p.get_future(); 
+// post 'p' to a thread that calculates a value 
+// use 'f' to retrieve the value. 
+
+

+So get_future() must return an object that shares the same associated +state with *this. +

+

+But still, this function should throw an future_already_retrieved error +when it is called twice. +

+

+packaged_task::get_future() throws std::bad_function_call if its future +was already retrieved. It should throw +future_error(future_already_retrieved), too. +

+

+Suggested resolution: +

+

+Replace p12/p13 30.6.5 [futures.promise]: +

+
+

+-12- Throws: future_error if *this has no associated state +the future has already been retrieved. +

+

+-13- Error conditions: future_already_retrieved if *this +has no associated state +the future associated with +the associated state has already been retrieved. +

+

+Postcondition: The returned object and *this share the associated state. +

+
+

+Replace p14 30.6.10 [futures.task]: +

+
+

+-14- Throws: std::bad_function_call future_error if the future associated with +the task has already been retrieved. +

+ +

+Error conditions: future_already_retrieved if the future associated with +the task has already been retrieved. +

+

+Postcondition: The returned object and *this share the associated task. +

+
+
+ +

[ +Batavia (2009-05): +]

+ +
+Keep in Review status +pending Detlef's forthcoming paper on futures. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2997. +
+ + + +

Proposed resolution:

+

+Add after p13 30.6.5 [futures.promise]: +

+ +
unique_future<R> get_future();
+
+
+

+-13- ... +

+

+Postcondition: *this has no associated state. +

+
+
+ + + + + + +
+

1051. Response to UK 279

+

Section: 24.5.1.3.12 [reverse.iter.opindex], 24.5.3.3.12 [move.iter.op.index] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses UK 279

+ +

+The reason the return type became unspecified is LWG issue 386. This +reasoning no longer applies as there are at least two ways to get the right +return type with the new language facilities added since the previous +standard. +

+ +

+Proposal: Specify the return type using either decltype or the Iter concept_map. +

+ +

[ +Summit: +]

+ + +
+

+Under discussion. This is a general question about all iterator +adapters. +

+
+ +

[ +Howard adds post Summit: +]

+ + +
+I am requesting test cases to demonstrate a position. +
+ +

[ +2009-07-24 Daniel adds: +]

+ + +
+

+I recommend NAD. Without concepts we can no longer +restrict this member in a trivial way. Using decltype the +declaration would be along the lines of +

+
static const Iter& __base(); // not defined
+auto operator[](difference_type n) const -> decltype(__base()[-n-1]);
+
+ +

+but once reverse_iterator is instantiated for some given type +Iter which cannot form a well-formed expression __base()[-n-1] +this would cause an ill-formed function declaration, diagnostic +required, and no silent SFINAE elimination. +

+ +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Moved to NAD. +
+ +

[ +2009-10-22 Daniel adds: +]

+ + +
+

+IMO, my original comment regarding ill-formedness of the described +construction is still correct, but I must add that I should weaken my +assertion "Without concepts we can no longer restrict this member in +a trivial way". +

+ +

+In fact with the existence of default template arguments for function +templates it is not too hard to implement this like as follows, which +shows that we can indeed simulate to some sense constrained +member functions in C++0x. +

+ +

+My example does not really proof that the specification is easy, but +it should be possible. I assume that the implementation would not +be ABI compatible, though. +

+ +

+It is now your own decision how to proceed ;-) +

+ +
#include <type_traits>
+#include <cstddef>
+
+template<class T>
+typename std::add_rvalue_reference<T>::type declval();
+
+template<class It>
+struct reverse_iterator {
+    It base;
+    
+    typedef std::ptrdiff_t difference_type;
+    
+    template<class U = It, class Res =
+     decltype(declval<const U&>()[declval<difference_type>()])
+    >
+    Res operator[](difference_type n) const  {
+        return base[-n-1];
+    }    
+};
+
+struct MyIter {
+};
+
+int main() {
+    reverse_iterator<int*> ri;
+    ri[0] = 2;
+    reverse_iterator<MyIter> ri2;
+}
+
+ +

+The above declaration could be simplified, but the ideal solution +

+ +
template<class U = It>
+  decltype(declval<const U&>()[declval<difference_type>()])
+     operator[](difference_type n) const;
+
+ +

+does not work yet on gcc 4.4.1. +

+ +
+ + + + +

Proposed resolution:

+ + + + + +
+

1052. Response to UK 281

+

Section: 24.5.1.3.5 [reverse.iter.opref] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View all issues with NAD Future status.

+

Discussion:

+ +

Addresses UK 281

+ +

+The current specification for return value for reverse_iterator::operator-> +will always be a true pointer type, but reverse_iterator supports proxy +iterators where the pointer type may be some kind of 'smart pointer'. +

+ +

[ +Summit: +]

+ + +
+

+move_iterator avoids this problem by returning a value of the wrapped +Iterator type. +study group formed to come up with a suggested resolution. +

+

+move_iterator solution shown in proposed wording. +

+
+ +

[ +2009-07 post-Frankfurt: +]

+ + +
+Howard to deconceptize. Move to Review after that happens. +
+ +

[ +2009-08-01 Howard deconceptized: +]

+ + +
+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+

+We can't think of any reason we can't just define reverse +iterator's pointer types to be the same as the underlying iterator's +pointer type, and get it by calling the right arrow directly. +

+

+Here is the proposed wording that was replaced: +

+
template <class Iterator> 
+class reverse_iterator { 
+  ...
+  typedef typename iterator_traits<Iterator>::pointer pointer;
+
+ +

+Change 24.5.1.3.5 [reverse.iter.opref]: +

+ +
pointer operator->() const;
+
+
+Returns: +
&(operator*());
+this->tmp = current;
+--this->tmp;
+return this->tmp;
+
+
+
+
+ +

[ +2010-03-03 Daniel opens: +]

+ + +
+
    + +
  1. +There is a minor problem with the exposition-only declaration of the private +member deref_tmp which is modified in a const member function (and the +same problem occurs in the specification of operator*). The fix is to +make it a mutable member. +
    2. + +
  2. +

    +The more severe problem is that the resolution for some reasons +does not explain in the rationale why it was decided to differ from +the suggested fix (using deref_tmp instead of tmp) in the +[ 2009-10 Santa Cruz] comment: +

    + +
    this->deref_tmp = current;
+--this->deref_tmp;
+return this->deref_tmp;
+
    + +

    +combined with the change of +

    + +
    typedef typename iterator_traits<Iterator>::pointer pointer;
+
    + +

    +to +

    + +
    typedef Iterator pointer;
+
    + +

    +The problem of the agreed on wording is that the following rather +typical example, that compiled with the wording before 1052 had +been applied, won't compile anymore: +

    + +
    #include <iterator>
+#include <utility>
+
+int main() {
+  typedef std::pair<int, double> P;
+  P op;
+  std::reverse_iterator<P*> ri(&op + 1);
+  ri->first; // Error
+}
+
    + +

    +Comeau online returns (if a correspondingly changed +reverse_iterator is used): +

    + +
    "error: expression must have class type
+     return deref_tmp.operator->();
+            ^
+         detected during instantiation of "Iterator
+                   reverse_iterator<Iterator>::operator->() const [with
+                   Iterator=std::pair<int, double> *]""
+
    + +

    +Thus the change will break valid, existing code based +on std::reverse_iterator. +

    + +
    3. + +
+ +

+IMO the suggestion proposed in the comment is a necessary fix, which harmonizes +with the similar specification of std::move_iterator and properly +reflects the recursive nature of the evaluation of operator-> +overloads. +

+ +

+Suggested resolution: +

+ +
    + +
  1. +

    +In the class template reverse_iterator synopsis of 24.5.1.1 [reverse.iterator] change as indicated: +

    + +
    namespace std {
+template <class Iterator>
+class reverse_iterator : public
+             iterator<typename iterator_traits<Iterator>::iterator_category,
+             typename iterator_traits<Iterator>::value_type,
+             typename iterator_traits<Iterator>::difference_type,
+             typename iterator_traits<Iterator>::pointer,
+             typename iterator_traits<Iterator>::reference> {
+public:
+  [..]
+  typedef typename iterator_traits<Iterator>::pointer pointer;
+  [..]
+protected:
+  Iterator current;
+private:
+  mutable Iterator deref_tmp; // exposition only
+};
+
    +
    2. + +
  2. +Change 24.5.1.3.5 [reverse.iter.opref]/1 as indicated: + +
    pointer operator->() const;
+
    + +
    +1 Returns Effects: &(operator*()). +
    deref_tmp = current;
+--deref_tmp;
+return deref_tmp;
+
    +
    +
    + +
    3. + +
+ +
+ +

[ +2010 Pittsburgh: +]

+ + +
+

+We prefer to make to use a local variable instead of deref_tmp within +operator->(). And although this means that the mutable +change is no longer needed, we prefer to keep it because it is needed for +operator*() anyway. +

+ +

+Here is the proposed wording that was replaced: +

+ +
+

+Change 24.5.1.3.5 [reverse.iter.opref]: +

+ +
pointer operator->() const;
+
+ +
+ +Returns: +
&(operator*());
+deref_tmp = current;
+--deref_tmp;
+return deref_tmp::operator->();
+
+ +
+
+ + +
+
+ +

[ +2010-03-10 Howard adds: +]

+ + +
+

+Here are three tests that the current proposed wording passes, and no +other solution I've seen passes all three: +

+ +
    +
  1. +

    +Proxy pointer support: +

    +
    #include <iterator>
+#include <cassert>
+
+struct X { int m; };
+
+X x;
+
+struct IterX {
+    typedef std::bidirectional_iterator_tag iterator_category;
+    typedef X& reference;
+    struct pointer
+    {
+        pointer(X& v) : value(v) {}
+        X& value;
+        X* operator->() const {return &value;}
+    };
+    typedef std::ptrdiff_t difference_type;
+    typedef X value_type;
+    // additional iterator requirements not important for this issue
+    
+    reference operator*() const { return x; }
+    pointer operator->() const { return pointer(x); }
+    IterX& operator--() {return *this;}
+
+};
+
+int main()
+{
+    std::reverse_iterator<IterX> ix;
+    assert(&ix->m == &(*ix).m);
+}
+
    +
    2. +
  2. +

    +Raw pointer support: +

    +
    #include <iterator>
+#include <utility>
+
+int main() {
+  typedef std::pair<int, double> P;
+  P op;
+  std::reverse_iterator<P*> ri(&op + 1);
+  ri->first; // Error
+}
+
    +
    3. +
  3. +

    +Caching iterator support: +

    +
    #include <iterator>
+#include <cassert>
+
+struct X { int m; };
+
+struct IterX {
+    typedef std::bidirectional_iterator_tag iterator_category;
+    typedef X& reference;
+    typedef X* pointer;
+    typedef std::ptrdiff_t difference_type;
+    typedef X value_type;
+    // additional iterator requirements not important for this issue
+    
+    reference operator*() const { return value; }
+    pointer operator->() const { return &value; }
+    IterX& operator--() {return *this;}
+
+private:
+    mutable X value;
+};
+
+int main()
+{
+    std::reverse_iterator<IterX> ix;
+    assert(&ix->m == &(*ix).m);
+}
+
    +
    4. +
+
+ +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Future, rationale added. +
+ + + + +

Rationale:

+

+The LWG did not reach a consensus for a change to the WP. +

+ + +

Proposed resolution:

+ +
    + +
  1. +

    +In the class template reverse_iterator synopsis of 24.5.1.1 [reverse.iterator] change as indicated: +

    + +
    namespace std {
+template <class Iterator>
+class reverse_iterator : public
+             iterator<typename iterator_traits<Iterator>::iterator_category,
+             typename iterator_traits<Iterator>::value_type,
+             typename iterator_traits<Iterator>::difference_type,
+             typename iterator_traits<Iterator&>::pointer,
+             typename iterator_traits<Iterator>::reference> {
+public:
+  [..]
+  typedef typename iterator_traits<Iterator&>::pointer pointer;
+  [..]
+protected:
+  Iterator current;
+private:
+  mutable Iterator deref_tmp; // exposition only
+};
+
    +
    2. + +
  2. +Change 24.5.1.3.5 [reverse.iter.opref]/1 as indicated: + +
    pointer operator->() const;
+
    + +
    +1 Returns Effects: &(operator*()). +
    deref_tmp = current;
+--deref_tmp;
+return deref_tmp;
+
    +
    +
    + +
    3. + +
+ + + + + + + + + + +
+

1053. Response to UK 295

+

Section: 25 [algorithms] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View all other issues in [algorithms].

+

View all issues with NAD Future status.

+

Discussion:

+ +

Addresses UK 295

+ +

+There is a level of redundancy in the library specification for many +algorithms that can be eliminated with the combination of concepts and +default parameters for function templates. Eliminating redundancy simplified +specification and reduces the risk of introducing accidental +inconsistencies. +

+

+Proposed resolution: Adopt +N2743. +

+ +

[ +Summit: +]

+ + +
+

+NAD, this change would break code that takes the address of an +algorithm. +

+
+ +

[ +Post Summit Alisdair adds: +]

+ + +
+

+Request 'Open'. The issues in the paper go beyond just reducing +the number of signatures, but cover unifying the idea of the ordering +operation used by algorithms, containers and other library components. At +least, it takes a first pass at the problem. +

+ +

+For me (personally) that was the more important part of the paper, and not +clearly addressed by the Summit resolution. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Too inventive, too late, would really need a paper. Moved to NAD Future. +
+ + + +

Proposed resolution:

+ + + + + +
+

1056. Must all Engines and Distributions be Streamable?

+

Section: 26.5 [rand] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View all other issues in [rand].

+

View all issues with NAD status.

+

Discussion:

+ +

+Both the concepts RandomNumberEngine and RandomNumberDistribution have +requirements to be InputStreamable and OutputStreamable. +

+

+I have no problems leaving the WP in an inconsistent state on the best-faith +assumption these concepts will be provided later, however disagree with the +proposers that these constraints are not separable, orthogonal to the basic +concepts of generating random number distributions. +

+

+These constraints should be dropped, and applied to specific algorithms as +needed. +

+

+If a more refined concept (certainly deemed useful by the proposers) is +proposed there is no objection, but the basic concept should not require +persistence via streaming. +

+ +

[ +Batavia (2009-05): +]

+ +
+Move to Open. +
+ +

[ +2009-05-31 Alisdair adds: +]

+ + +
+

+Working on constraining the stream iterators, I have a few more observations +to make on the concepts proposed while constraining the random number +facility. +

+

+While I still believe the concerns are orthogonal, I don't believe the +existing constraints go far enough either! The goal we want to achieve is +not that a RandomNumberEngine / RandomNumberDistribution supports the stream +operators, but that it is Serializable. I.e. there is a relationship +between the insert and extract operations that guarantees to restore the +state of the original object. This implies a coupling of the concepts +together in a broader concept (Serializable) with at least one axiom to +assert the semantics. +

+

+One problem is that istream and ostream may be fundamentally different +types, although we can hook a relation if we are prepared to drop down to +the char type and char_traits template parameters. Doing so ties us to a +form of serialization that demands implementation via the std iostreams +framework, which seems overly prescriptive. I believe the goal is generally +to support serialization without regard to how it is expressed - although +this is getting even more inventive in terms of concepts we do not have +today. +

+
+ +

[ +2009-11-03 Alisdair adds: +]

+ + +
+

+I can't find the record in the wiki minutes, but it was agreed at both +Frankfurt and Santa Cruz that this issue is NAD. +

+

+The agreement in SC was that I would provide you with the rationale (see +below) to include when moving to NAD. +

+
+ +

[ +2009-11-03 Howard adds: +]

+ + +
+Moved to Tentatively NAD after 5 positive votes on c++std-lib. +
+ + +

Proposed resolution:

+ + +

Rationale:

+

+The issue suggests a more refined concept should be used if we want to +require streaming, to separate concerns from the basic +RandomNumberEngine behaviour. In Frankfurt it was observed +that RandomNumberEngine is that more refined concept, +and the basic concept used in the framework is +UniformRandomNumberGenerator, which it refines. +

+ +

+We concur, and expect this to have no repurcussions re-writing this +clause now concepts are removed. +

+ + + + + +
+

1057. RandomNumberEngineAdaptor

+

Section: 26.5 [rand] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View all other issues in [rand].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

+The RandomNumberEngineAdaptor concept breaks precedent in the +way the library has been specified by grouping requirements into a +concept that is never actually used in the library. +

+

+This is undoubtedly a very helpful device for documentation, but we are not +comfortable with the precedent - especially as we have rejected national +body comments on the same grounds. +

+

+Suggest either removing the concept, or providing an algorithm/type that +requires this concept in their definition (such as a factory function to +create new engines). +

+

+The preference is to create a single new algorithm and retain the value of +the existing documentation. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+Walter points out that it is unlikely that any algorithm would ever +require this concept, but that the concept nonetheless is useful as +documentation, and (via concept maps) as a means of checking specific adapters. +

+

+Alisdair disagrees as to the concept's value as documentation. +

+

+Marc points out that the RandomNumberDistribution +is also a concept not used elsewhere in the Standard. +

+

+Pete agrees that a policy of not inventing concepts +that aren't used in the Standard is a good starting point, +but should not be used as a criterion for rejecting a concept. +

+

+Move to Open. +

+
+ + +

Proposed resolution:

+ + + + + +
+

1058. New container issue

+

Section: 23.2.3 [sequence.reqmts] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-10-23

+

View all other issues in [sequence.reqmts].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

+Sequence containers 23.2.3 [sequence.reqmts]: +

+ +

+The return value of new calls added to table 83 are not specified. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+We agree with the proposed resolution. +

+

+Move to NAD Editorial. +

+
+ + +

Proposed resolution:

+

+Add after p6 23.2.3 [sequence.reqmts]: +

+ +
+

+-6- ... +

+

+The iterator returned from a.insert(p,rv) points to the copy of rv +inserted into a. +

+

+The iterator returned from a.emplace(p, args) points to the new +element constructed from args inserted into a. +

+
+ + + + + +
+

1059. Usage of no longer existing FunctionType concept

+

Section: 20.8.14.2 [func.wrap.func] Status: NAD Concepts + Submitter: Daniel Krügler Opened: 2009-03-13 Last modified: 2010-10-23

+

View all other issues in [func.wrap.func].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+Due to a deliberate core language decision, the earlier called +"foundation" concept std::FunctionType had been removed in +N2773 +shortly +before the first "conceptualized" version of the WP +(N2798) +had been +prepared. This caused a break of the library, which already used this +concept in the adapted definition of std::function +(20.8 [function.objects]/2, header <functional> synopsis and +20.8.14.2 [func.wrap.func]). +

+

+A simple fix would be to either (a) make std::function's primary template +unconstrained or to (b) add constraints based on existing (support) concepts. +A more advanced fix would (c) introduce a new library concept. +

+

+The big disadvantage of (a) is, that users can define templates which +cause compiler errors during instantiation time because of under-constrainedness +and would thus violate the basic advantage of constrained +code. +

+

+For (b), the ideal constraints for std::function's template parameter would +be one which excludes everything else but the single provided partial +specialization that matches every "free function" type (i.e. any function +type w/o cv-qualifier-seq and w/o ref-qualifier). +Expressing such a type as as single requirement would be written as +

+
template<typename T>
+requires ReferentType<T> // Eliminate cv void and function types with cv-qual-seq
+                         //   or ref-qual (depending on core issue #749)
+      && PointeeType<T>  // Eliminate reference types
+      && !ObjectType<T>  // Eliminate object types
+
+

+Just for completeness approach (c), which would make sense, if the +library has more reasons to constrain for free function types: +

+
auto concept FreeFunctionType<typename T>
+  : ReferentType<T>, PointeeType<T>, MemberPointeeType<T>
+{
+  requires !ObjectType<T>;
+}
+
+

+I mention that approach because I expect that free function types belong +to the most natural type categories for every days coders. Potential +candidates in the library are addressof and class template packaged_task. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+Alisdair would prefer to have a core-supported FunctionType concept +in order that any future changes be automatically correct +without need for a library solution to catch up; +he points to type traits as a precedent. +Further, he believes that a published concept can't in the future +be changed. +

+

+Bill feels this category of entity would change sufficiently slowly +that he would be willing to take the risk. +

+

+Of the discussed solutions, we tend toward option (c). +We like the idea of having a complete taxonomy of native types, +and perhaps erred in trimming the set. +

+

+We would like to have this issue reviewed by Core and would like +their feedback. Move to Open. +

+
+ + +

Proposed resolution:

+
    +
  1. +

    +Change in 20.8 [function.objects]/2, Header <functional> synopsis: +

    +
    // 20.6.16 polymorphic function wrappers:
+class bad_function_call;
+template<FunctionTypeReferentType F>
+requires PointeeType<F> && !ObjectType<F>
+class function; // undefined
+
    +
    2. +
  2. +

    +Change in 20.8.14.2 [func.wrap.func]: +

    +
    namespace std {
+template<FunctionTypeReferentType F>
+requires PointeeType<F> && !ObjectType<F>
+class function; // undefined
+
    +
    3. +
+ + + + + +
+

1060. Embedded nulls in NTBS

+

Section: 17.5.2.1.4.1 [byte.strings] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-13 Last modified: 2010-10-23

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

+Definition of null-terminated sequences allow for embedded nulls. This is +surprising, and probably not supportable with the intended use cases. +

+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the issue, but believe this can be handled editorially. +Move to NAD Editorial. +
+ + + +

Proposed resolution:

+ + + + + +
+

1061. Bad indexing for tuple access to pair (Editorial?)

+

Section: 20.3.5.4 [pair.astuple] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-13 Last modified: 2010-10-23

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

+The definition of get implies that get must return the second element if +given a negative integer. +

+ +

[ +Batavia (2009-05): +]

+ +
+Move to NAD Editorial. +
+ + + +

Proposed resolution:

+

+20.3.5.4 [pair.astuple] p5: +

+ +
template<int size_t I, class T1, class T2> 
+  requires True<(I < 2)> 
+  const P& get(const pair<T1, T2>&);
+
+
+ + + + + + +
+

1062. Missing insert_iterator for stacks/queues

+

Section: 24.5.2 [insert.iterators] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-13 Last modified: 2010-10-23

+

View all other issues in [insert.iterators].

+

View all issues with NAD status.

+

Discussion:

+ +

+It is odd that we have an iterator to insert into a vector, but not an +iterator to insert into a vector that is adapted as a stack. The standard +container adapters all have a common interface to push and pop so it should +be simple to create an iterator adapter to complete the library support. +

+ +

+We should provide an AdaptedContainer concept supporting push and pop +operations. Create a new insert iterator and factory function that inserts +values into the container by calling push. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+Walter recommends NAD Future. +

+

+Move to Open, and recommend deferring the issue until after the next +Committee Draft is issued. +

+
+ +

[ +2009-07-29 Howard moves to Tentatively NAD Future. +]

+ + +
+A poll on the LWG reflector voted unanimously to move this issue to Tentatively NAD Future. +
+ +

[ +2009 Santa Cruz: +]

+ + +
+Moved to NAD. The intent of these adapters are to restrict the interfaces. +
+ + + +

Proposed resolution:

+ + + + + +
+

1063. 03 iterator compatibilty

+

Section: X [iterator.backward] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-15 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

+Which header must a user #include to obtain the library-supplied +concept_maps declared in this paragraph? +

+ +

+This is important information, as existing user code will break if this +header is not included, and we should make a point of mandating this header +is #include-d by library headers likely to make use of it, notably +<algorithm>. See issue 1001 for more details. +

+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the direction of the proposed resolution. +Move to Tentatively Ready. +
+ +

[ +2009-07 Frankfurt +]

+ + +
+We believe this is NAD Concepts, but this needs to be reviewed against the +post-remove-concepts draft. +
+ + +

Proposed resolution:

+

Change [depr.lib.iterator.primitives], Iterator primitives, as +indicated:

+ +
+

To simplify the use of iterators and provide backward compatibility with + previous C++ Standard Libraries, + the library provides several classes and functions. Unless otherwise + specified, these classes and functions shall be defined in header <iterator>.

+
+

Change X [iterator.backward], Iterator backward compatibility, as +indicated:

+
+

The library provides concept maps that allow iterators specified with + iterator_traits to interoperate with + algorithms that require iterator concepts. These concept maps shall be + defined in the same header that defines the iterator. [Example:

+
+ + + + + +
+

1064. Response to UK 152

+

Section: 17.3.18 [defns.obj.state] Status: NAD + Submitter: Howard Hinnant Opened: 2009-03-15 Last modified: 2010-10-23

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses UK 152

+ +

+Object state is using a definition of object (instance of a class) from +outside the standard, rather than the 'region of storage' definiton in +1.8 [intro.object]p1 +

+ +

[ +Summit: +]

+ +
+We think we're removing this; See X [func.referenceclosure.cons]. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD. This will not affect user or implementer code +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

1067. simplified wording for inner_product

+

Section: 26.7 [numeric.ops] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-17 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

+One of the motivating examples for introducing requirements-aliases was to +simplify the wording of the inner_product requirements. As the paper +adopting the feature and constrained wording for the library went through in +the same meeting, it was not possible to make the change at the time. The +simpler form should be adopted now though. Similarly, most the other +numerical algorithms can benefit from a minor cleanup. +

+

+Note that in each case, the second more generalised form of the algorithm +does not benefit, as there are already named constraints supplied by the +template type parameters. +

+ +

[ +2009-05-02 Daniel adds: +]

+ + +
+

+one part of the suggested resolution suggests the removal of the +MoveConstructible<T> requirement from +inner_product. According to 26.7.2 [inner.product] +

+ +
+Computes its result by initializing the accumulator acc with the +initial value init +
+ +

+this step requires at least MoveConstructible. +

+ +

+Therefore I strongly suggest to take this removal back (Note also +that the corresponding overload with a functor argument still has +the same MoveConstructible<T> requirement). +

+
+ +

[ +Batavia (2009-05): +]

+ +
+

+We agree with the proposed resolution as amended by Daniel's suggestion +to restore MoveConstructible, +reflected in the updated proposed resolution below. +

+

+Move to Tentatively Ready. +

+
+ + +

Proposed resolution:

+

+Change in 26.7 [numeric.ops] and 26.7.1 [accumulate]: +

+ +
template <InputIterator Iter, MoveConstructible T>
+ requires add = HasPlus<T, Iter::reference>
+       && HasAssign<T, HasPlus<T, Iter::reference> add::result_type>
+ T accumulate(Iter first, Iter last, T init);
+
+ +

+Change in 26.7 [numeric.ops] and 26.7.2 [inner.product]: +

+ +
template <InputIterator Iter1, InputIterator Iter2, MoveConstructible T>
+  requires mult = HasMultiply<Iter1::reference, Iter2::reference>
+        && add = HasPlus<T, HasMultiply<Iter1::reference, Iter2::reference> mult::result_type>
+        && HasAssign< 
+             T,
+             HasPlus<T,
+                     HasMultiply<Iter1::reference, Iter2::reference>::result_type> add::result_type>
+  T inner_product(Iter1 first1, Iter1 last1, Iter2 first2, T init);
+
+ +

+Change in 26.7 [numeric.ops] and 26.7.3 [partial.sum]: +

+ +
template <InputIterator InIter, OutputIterator<auto, const InIter::value_type&> OutIter>
+  requires add = HasPlus<InIter::value_type, InIter::reference>
+        && HasAssign<InIter::value_type,
+                     HasPlus<InIter::value_type, InIter::reference> add::result_type>
+        && Constructible<InIter::value_type, InIter::reference>
+  OutIter partial_sum(InIter first, InIter last, OutIter result);
+
+ +

+Change in 26.7 [numeric.ops] and 26.7.4 [adjacent.difference]: +

+ +
template <InputIterator InIter, OutputIterator<auto, const InIter::value_type&> OutIter>
+  requires sub = HasMinus<InIter::value_type, InIter::value_type>
+        && Constructible<InIter::value_type, InIter::reference>
+        && OutputIterator<OutIter, HasMinus<InIter::value_type, InIter::value_type> sub::result_type>
+        && MoveAssignable<InIter::value_type>
+  OutIter adjacent_difference(InIter first, InIter last, OutIter result);
+
+ + + + + + +
+

1068. class random_device should be movable

+

Section: 26.5.6 [rand.device] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-18 Last modified: 2010-10-23

+

View all other issues in [rand.device].

+

View all issues with NAD status.

+

Discussion:

+ +

+class random_device should be movable. +

+ +

[ +Batavia (2009-05): +]

+ +
+Move to Open, and recommend this issue be deferred until after the next +Committee Draft is issued. +
+ +

[ +2009-10 post-Santa Cruz: +]

+ + +
+Leave open. Walter to provide drafting as part of his planned paper. +
+ +

[ +2010 Pittsburgh: Moved to NAD. +]

+ + + + +

Rationale:

+

+WP is correct as written. +

+ + +

Proposed resolution:

+ + + + + +
+

1069. class seed_seq should support efficient move operations

+

Section: 26.5.7.1 [rand.util.seedseq] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-03-18 Last modified: 2010-10-23

+

View all other issues in [rand.util.seedseq].

+

View all issues with NAD status.

+

Discussion:

+ +

+class seed_seq should support efficient move operations. +

+ +

[ +Batavia (2009-05): +]

+ +
+Move to Open, and recommend this issue be deferred until after the next +Committee Draft is issued. +
+ +

[ +2009-10 post-Santa Cruz: +]

+ + +
+Leave open. Walter to provide drafting as part of his planned paper. +
+ +

[ +2010 Pittsburgh: +]

+ + +
+seed_seq is explicitly not copyable, so, much like LWG issue +1068, LWG issue 1069 could be marked NAD to be consistent +with this. +
+ + + +

Proposed resolution:

+ + + + + +
+

1072. Is std::hash a constrained template or not?

+

Section: 20.8.15 [unord.hash] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-19 Last modified: 2010-10-23

+

View all other issues in [unord.hash].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

+Is std::hash a constrained template or not? +

+

+According to Class template hash 20.8.15 [unord.hash], the definition is: +

+ +
template <class T>
+struct hash : public std::unary_function<T, std::size_t> {
+  std::size_t operator()(T val) const;
+};
+
+ +

+And so unconstrained. +

+

+According to the <functional> synopsis in p2 Function objects +20.8 [function.objects] the template is declared as: +

+ +
template <ReferentType T> struct hash;
+
+ +

+which would make hash a constrained template. +

+ +

[ +2009-03-22 Daniel provided wording. +]

+ + +

[ +Batavia (2009-05): +]

+ +
+

+Alisdair is not certain that Daniel's proposed resolution is sufficient, +and recommends we leave the hash template unconstrained for now. +

+

+Recommend that the Project Editor make the constrained declaration consistent +with the definition in order to make the Working Paper internally consistent, +and that the issue then be revisited. +

+

+Move to Open. +

+
+ + +

Proposed resolution:

+ +

+[To the editor: This resolution is merge-compatible to the +resolution of 1078] +

+ +
    +
  1. +

    +In 20.8 [function.objects]/2, header <functional> synopsis, change as indicated: +

    + +
    // 20.6.17, hash function base template:
+template <ReferentType T> struct hash; // undefined
+
    +
    2. +
  2. +

    +In 20.8.15 [unord.hash]/1 change as indicated: +

    +
    namespace std {
+ template <class T>
+ struct hash : public std::unary_function<T, std::size_t> {
+ std::size_t operator()(T val) const;
+ };
+ template <ReferentType T> struct hash; // undefined
+}
+
    +
    3. +
  3. +

    +In 20.8.15 [unord.hash]/2 change as indicated: +

    + +
    +-2- For all library-provided specializations, the template +instantiation hash<T> + shall provide a public operator() with return type std::size_t to +satisfy the concept + requirement Callable<const hash<T>, const T&>. If T is an object +type or reference to + object, hash<T> shall be publicly derived from +std::unary_function<T, std::size_t>. + The return value of operator() is unspecified, except that +equal arguments + shall yield the same result. operator() shall not throw exceptions. +
    +
    4. +
  4. +

    +In 18.7 [support.rtti]/1, header <typeinfo> synopsis change as indicated: +

    +
    namespace std {
+  class type_info;
+  class type_index;
+  template <classReferentType T> struct hash;
+
    +
    5. +
+ + + + + +
+

1074. concept map broken by N2840

+

Section: X [allocator.element.concepts] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-19 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

+p7 Allocator-related element concepts X [allocator.element.concepts] +

+ +

+The changes to the AllocatableElement concept mean this concept_map +specialization no longer matches the original concept: +

+ +
template <Allocator Alloc, class T, class ... Args>
+  requires HasConstructor<T, Args...>
+    concept_map AllocatableElement<Alloc, T, Args&&...> {
+      void construct_element(Alloc& a, T* t, Args&&... args) {
+        Alloc::rebind<T>(a).construct(t, forward(args)...);
+      }
+    }
+
+ +

[ +2009-03-23 Pablo adds: +]

+ + +
+Actually, this is incorrect, +N2840 +says. "In section +X [allocator.element.concepts] paragraph 8, modify the definition of the +AllocatableElement concept and eliminate the related concept map:" but +then neglects to include the red-lined text of the concept map that was +to be eliminated. Pete also missed this, but I caught it he asked me to +review his edits. Pete's updated WP removes the concept map entirely, +which was the original intent. The issue is, therefore, moot. Note, as +per my presentation of +N2840 +in summit, construct() no longer has a +default implementation. This regrettable fact was deemed (by David +Abrahams, Doug, and myself) to be preferable to the complexity of +providing a default implementation that would not under-constrain a more +restrictive allocator (like the scoped allocators). +
+ +

[ +2009-05-01 Daniel adds: +]

+ +
+

+it seems to me that #1074 should be resolved as a NAD, because the +current WP has already removed the previous AllocatableElement concept map. +It introduced auto concept AllocatableElement instead, but as of +X [allocator.element.concepts]/7 this guy contains now +

+
requires FreeStoreAllocatable<T>;
+void Alloc::construct(T*, Args&&...);
+
+
+ +

[ +Batavia (2009-05): +]

+ +
+

+The affected code is no longer part of the Working Draft. +

+

+Move to NAD. +

+
+ + +

Proposed resolution:

+

+Change X [allocator.element.concepts]: +

+ +
template <Allocator Alloc, class T, class ... Args>
+  requires HasConstructor<T, Args...>
+    concept_map AllocatableElement<Alloc, T, Args&&...> {
+      void construct_element(Alloc& a, T* t, Args&&... args) {
+        Alloc::rebind<T>(a).construct(t, forward(args)...);
+      }
+    }
+
+ + + + + + +
+

1076. unary/binary_negate need constraining and move support

+

Section: 20.8.9 [negators] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-03-20 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+

+The class templates unary/binary_negate need constraining and move support. +

+

+Ideally these classes would be deprecated, allowing unary/binary_function to +also be deprecated. However, until a generic negate adaptor is introduced +that can negate any Callable type, they must be supported so should be +constrained. Likewise, they should be movable, and support adopting a +move-only predicate type. +

+

+In order to preserve ABI compatibility, new rvalue overloads are supplied in +preference to changing the existing pass-by-const-ref to pass-by-value. +

+

+Do not consider the issue of forwarding mutable lvalues at this point, +although remain open to another issue on the topic. +

+ +

[ +2009-05-01 Daniel adds: +]

+ +
+

+IMO the currently proposed resolution needs some updates +because it is ill-formed at several places: +

+ +
    +
  1. +

    +In concept AdaptableUnaryFunction change +

    +
    typename X::result_type;
+typename X::argument_type;
+
    +

    +to +

    +
    Returnable result_type = typename X::result_type;
+typename argument_type = typename X::argument_type;
+
    +

    +[The replacement "Returnable result_type" instead of "typename +result_type" is non-editorial, but maybe you prefer that as well] +

    +
    2. +
  2. +

    +In concept AdaptableBinaryFunction change +

    +
    typename X::result_type;
+typename X::first_argument_type;
+typename X::second_argument_type;
+
    +

    +to +

    +
    Returnable result_type = typename X::result_type;
+typename first_argument_type = typename X::first_argument_type;
+typename second_argument_type = typename X::second_argument_type;
+
    +

    +[The replacement "Returnable result_type" instead of "typename +result_type" is non-editorial, but maybe you prefer that as well.] +

    +
    3. + +
  3. +

    +In class unary/binary_function +

    +
      +
    1. +I suggest to change "ReturnType" to "Returnable" in both cases. +
      2. +
    2. +I think you want to replace the remaining occurrences of "Predicate" by "P" +(in both classes in copy/move from a predicate) +
      3. +
    +
    4. +
  4. +

    +I think you need to change the proposed signatures of not1 and not2, because +they would still remain unconstrained: To make them constrained at least a +single requirement needs to be added to enable requirement implication. This +could be done via a dummy ("requires True<true>") or just explicit as follows: +

    +
      +
    1. +
      template <AdaptableUnaryFunction P>
+requires Predicate< P, P::argument_type>
+unary_negate<P> not1(const P&& pred);
+template <AdaptableUnaryFunction P>
+requires Predicate< P, P::argument_type >
+unary_negate<P> not1(P&& pred);
+
      +
      +-3- Returns: unary_negate<P>(pred). +
      +
      +

      +[Don't we want a move call for the second overload as in +

      +
      unary_negate<P>(std::move(pred))
+
      +

      +in the Returns clause ?] +

      +
      2. +
    2. +
      template <AdaptableBinaryFunction P>
+requires Predicate< P, P::first_argument_type, P::second_argument_type >
+binary_negate<P> not2(const P& pred);
+template <AdaptableBinaryFunction P>
+requires Predicate< P, P::first_argument_type, P::second_argument_type >
+binary_negate<P> not2(P&& pred);
+
      +

      +-5- Returns: binary_negate<P>(pred). +

      +

      +[Don't we want a move call for the second overload as in +

      +
      binary_negate<P>(std::move(pred))
+
      +

      +in the Returns clause ?] +

      +
      3. +
    +
    5. +
+
+ +

[ +Batavia (2009-05): +]

+ +
+

+There is concern that complicating the solution +to preserve the ABI seems unnecessary, +since we're not in general preserving the ABI. +

+

+We would prefer a separate paper consolidating all Clause 20 +issues that are for the purpose of providing constrained versions +of the existing facilities. +

+

+Move to Open. +

+
+ +

[ +2009-10 post-Santa Cruz: +]

+ + +
+Leave open pending the potential move constructor paper. Note that +we consider the "constraining" part NAD Concepts. +
+ +

[ +2010-01-31 Alisdair removes the current proposed wording from the proposed +wording section because it is based on concepts. That wording is proposed here: +]

+ + +
+

+Add new concepts where appropriate:: +

+ +
auto concept AdaptableUnaryFunction< typename X > {
+  typename X::result_type;
+  typename X::argument_type;
+}
+
+auto concept AdaptableBinaryFunction< typename X > {
+  typename X::result_type;
+  typename X::first_argument_type;
+  typename X::second_argument_type;
+}
+
+ +

+Revise as follows: +

+ +

+Base X [base] (Only change is constrained Result) +

+ +
+

+-1- The following classes are provided to simplify the typedefs of the +argument and result types: +

+
namespace std {
+  template <class Arg, class ReturnType Result>
+  struct unary_function {
+     typedef Arg    argument_type;
+     typedef Result result_type;
+  };
+
+  template <class Arg1, class Arg2, class ReturnType Result>
+  struct binary_function {
+     typedef Arg1   first_argument_type;
+     typedef Arg2   second_argument_type;
+     typedef Result result_type;
+  };
+}
+
+ +

+Negators 20.8.9 [negators]: +

+ +
+

+-1- Negators not1 and not2 take a unary and a binary predicate, +respectively, and return their complements (5.3.1). +

+ +
template <class AdaptableUnaryFunction Predicate>
+  requires Predicate< P, P::argument_type >
+  class unary_negate
+    : public unary_function<typename Predicate::argument_type,bool> {
+  public:
+    unary_negate(const unary_negate & ) = default;
+    unary_negate(unary_negate && );
+
+    requires CopyConstructible< P >
+       explicit unary_negate(const Predicate& pred); 
+    requires MoveConstructible< P >
+       explicit unary_negate(Predicate && pred);
+
+    bool operator()(const typename Predicate::argument_type& x) const;
+  };
+
+
+-2 operator() returns !pred(x). +
+ +
template <class Predicate>
+  unary_negate<Predicate> not1(const Predicate&amp; pred);
+template <class Predicate>
+  unary_negate<Predicate> not1(Predicate&& pred);
+
+
+-3- Returns: unary_negate<Predicate>(pred). +
+ +
template <class AdaptableBinaryFunction Predicate >
+  requires Predicate< P, P::first_argument_type, P::second_argument_type >
+  class binary_negate
+    : public binary_function<typename Predicate::first_argument_type,
+                              typename Predicate::second_argument_type, bool> {
+  public:
+    biary_negate(const binary_negate & ) = default;
+    binary_negate(binary_negate && );
+
+    requires CopyConstructible< P >
+       explicit binary_negate(const Predicate& pred);
+    requires MoveConstructible< P >
+       explicit binary_negate(const Predicate& pred);
+
+    bool operator()(const typename Predicate::first_argument_type& x,
+                    const typename Predicate::second_argument_type& y) const;
+  };
+
+
+-4- operator() returns !pred(x,y). +
+ +
template <class Predicate>
+  binary_negate<Predicate> not2(const Predicate& pred);
+template <class Predicate>
+  binary_negate<Predicate> not2(Predicate&& pred);
+
+ +
+-5- Returns: binary_negate<Predicate>(pred). +
+
+ +
+ + +

[ +2010 Rapperswil: +]

+ + +
+Move to NAD Concepts. The move-semantic part has been addressed by a core language change, which implicitly generates appropriate move constructors and move-assignment operators. +
+ + + +

Proposed resolution:

+ + + + + +
+

1077. Nonesense tuple declarations

+

Section: 20.4.2 [tuple.tuple] Status: NAD Editorial + Submitter: Pete Becker Opened: 2009-03-20 Last modified: 2010-10-23

+

View all other issues in [tuple.tuple].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Class template tuple 20.4.2 [tuple.tuple]: +

+ +
template <class... UTypes>
+  requires Constructible<Types, const UTypes&>...
+template <class... UTypes>
+  requires Constructible<Types, RvalueOf<UTypes>::type>...
+
+ +

+Somebody needs to look at this and say what it should be. +

+ +

[ +2009-03-21 Daniel provided wording. +]

+ + +

[ +Batavia (2009-05): +]

+ +
+The resolution looks correct; move to NAD Editorial. +
+ + +

Proposed resolution:

+

+In 20.4.2 [tuple.tuple], class tuple, change as indicated: +

+ +
template <class... UTypes>
+  requires Constructible<Types, const UTypes&>...
+  tuple(const pair<UTypes...>&);
+template <class... UTypes>
+  requires Constructible<Types, RvalueOf<UTypes>::type>...
+  tuple(pair<UTypes...>&&);
+
+ +

+[NB.: The corresponding prototypes do already exist in 20.4.2.1 [tuple.cnstr]/7+8] +

+ + + + + +
+

1078. DE-17: Remove class type_index

+

Section: 20.13 [type.index] Status: NAD Concepts + Submitter: Doug Gregor Opened: 2009-03-20 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses DE 17

+ +

+DE-17: +

+

+The class type_index should be removed; it provides no additional +functionality beyond providing appropriate concept maps. +

+ +

[ +2009-03-31 Peter adds: +]

+ + +
+

+It is not true, in principle, that std::type_index provides no utility +compared to bare std::type_info*. +

+

+std::type_index can avoid the lifetime issues with type_info when the +DLL that has produced the type_info object is unloaded. A raw +type_info* does not, and cannot, provide any protection in this case. +A type_index can (if the implementor so chooses) because it can wrap a +smart (counted or even cloning) pointer to the type_info data that is +needed for name() and before() to work. +

+
+ + + +

Proposed resolution:

+

Modify the header <typeinfo> synopsis in + 18.7 [support.rtti]p1 as follows:

+ +
namespace std { 
+  class type_info; 
+  class type_index;
+  template <class T> struct hash;
+  template<> struct hash<type_indexconst type_info *> : public std::unary_function<type_indexconst type_info *, size_t> {
+    size_t operator()(type_indexconst type_info * indext) const;
+  };
+  concept_map LessThanComparable<const type_info *> see below
+  class bad_cast; 
+  class bad_typeid;
+}
+
+ +

Add the following new subsection

+
+

+18.7.1.1 Template specialization hash<const type_info *> +[type.info.hash]

+ +
size_t operator()(const type_info *x) const;
+
+
    +
  1. Returns: x->hash_code()
    2. +
+
+ +

Add the following new subsection

+
+

18.7.1.2 type_info concept map [type.info.concepts]

+ + +
concept_map LessThanComparable<const type_info *> {
+  bool operator<(const type_info *x, const type_info *y) { return x->before(*y); }
+  bool operator<=(const type_info *x, const type_info *y) { return !y->before(*x); }
+  bool operator>(const type_info *x, const type_info *y) { return y->before(*x); }
+  bool operator>=(const type_info *x, const type_info *y) { return !x->before(*y); }
+}
+
+
    +
  1. Note: provides a well-defined ordering among + type_info const pointers, which makes such pointers + usable in associative containers (23.4).
    2. +
+
+ +

Remove section 20.13 [type.index]

+ + + + + +
+

1080. Concept ArithmeticLike should provide explicit boolean conversion

+

Section: X [concept.arithmetic] Status: NAD Concepts + Submitter: Daniel Krügler Opened: 2009-03-21 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+

+Astonishingly, the current concept ArithmeticLike as specified in +X [concept.arithmetic] does not provide explicit conversion +to bool although this is a common property of arithmetic types +(4.12 [conv.bool]). Recent proposals that introduced such types +(integers of arbitrary precision, +n2143, +decimals +n2732 +indirectly +via conversion to long long) also took care of such a feature. +

+

+Adding such an explicit conversion associated function would also +partly solve a currently invalid effects clause in library, which bases +on this property, 24.2.7 [random.access.iterators]/2: +

+
{ difference_type m = n;
+ if (m >= 0) while (m--) ++r;
+ else while (m++) --r;
+ return r; }
+
+ +

+Both while-loops take advantage of a contextual conversion to bool +(Another problem is that the >= comparison uses the no +longer supported existing implicit conversion from int to IntegralLike). +

+ +Original proposed resolution: +
    +
  1. +

    +In X [concept.arithmetic], add to the list of less refined +concepts one further concept: +

    + +
    concept ArithmeticLike<typename T>
+  : Regular<T>, LessThanComparable<T>, HasUnaryPlus<T>, HasNegate<T>,
+    HasPlus<T, T>, HasMinus<T, T>, HasMultiply<T, T>, HasDivide<T, T>,
+    HasPreincrement<T>, HasPostincrement<T>, HasPredecrement<T>,
+    HasPostdecrement<T>,
+    HasPlusAssign<T, const T&>, HasMinusAssign<T, const T&>,
+    HasMultiplyAssign<T, const T&>,
+    HasDivideAssign<T, const T&>, ExplicitlyConvertible<T, bool> {
+
    +
    2. +
  2. +

    +In 24.2.7 [random.access.iterators]/2 change the current effects clause +as indicated [The proposed insertion fixes the problem that the previous +implicit construction from integrals has been changed to an explicit +constructor]: +

    +
    { difference_type m = n;
+ if (m >= difference_type(0)) while (m--) ++r;
+ else while (m++) --r;
+ return r; }
+
    +
    3. +
+ +

[ +Batavia (2009-05): +]

+ +
+

+We agree that arithmetic types ought be convertible to bool, +and we therefore agree with the proposed resolution's paragraph 1. +

+

+We do not agree that the cited effects clause is invalid, +as it expresses intent rather than specific code. +

+

+Move to Review, pending input from concepts experts. +

+
+ + + +

Proposed resolution:

+

+In X [concept.arithmetic], add to the list of less refined +concepts one further concept: +

+ +
concept ArithmeticLike<typename T>
+  : Regular<T>, LessThanComparable<T>, HasUnaryPlus<T>, HasNegate<T>,
+    HasPlus<T, T>, HasMinus<T, T>, HasMultiply<T, T>, HasDivide<T, T>,
+    HasPreincrement<T>, HasPostincrement<T>, HasPredecrement<T>,
+    HasPostdecrement<T>,
+    HasPlusAssign<T, const T&>, HasMinusAssign<T, const T&>,
+    HasMultiplyAssign<T, const T&>,
+    HasDivideAssign<T, const T&>, ExplicitlyConvertible<T, bool> {
+
+ + + + + +
+

1081. Response to UK 216

+

Section: 21 [strings] Status: NAD Concepts + Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2010-10-23

+

View all other issues in [strings].

+

View all issues with NAD Concepts status.

+

Discussion:

+

Addresses UK 216, JP 46, JP 48

+ +

+All the containers use concepts for their iterator usage, exect for +basic_string. This needs fixing. +

+ +

+Use concepts for iterator template parameters throughout the chapter. +

+ +

[ +Summit: +]

+ +
+NB comments to be handled by Dave Abrahams and Howard Hinnant with +advice from PJP: UK216 (which duplicates) JP46, JP48. JP46 supplies +extensive proposed wording; start there. +
+ + +

Proposed resolution:

+ + + + + +
+

1082. Response to JP 49

+

Section: 22 [localization] Status: NAD Concepts + Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2010-10-23

+

View all other issues in [localization].

+

View all issues with NAD Concepts status.

+

Discussion:

+

Addresses JP 49

+ +

+codecvt does not use concept. For example, create CodeConvert +concept and change as follows. +

+ +
template<CodeConvert Codecvt, class Elem = wchar_t>
+  class wstring_convert {
+
+ +

[ +Summit: +]

+ +
+To be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger. +
+ + +

Proposed resolution:

+ + + + + +
+

1083. Response to JP 52, 53

+

Section: 22 [localization] Status: NAD Concepts + Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2010-10-23

+

View all other issues in [localization].

+

View all issues with NAD Concepts status.

+

Discussion:

+

Addresses JP 52, JP 53

+ +

+InputIterator does not use concept. +

+ +

+OutputIterator does not use concept. +

+ +

+Comments include proposed wording. +

+ +

[ +Summit: +]

+ +
+To be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger. +
+ + +

Proposed resolution:

+ + + + + +
+

1084. Response to UK 250

+

Section: 24.2.5 [forward.iterators] Status: NAD Concepts + Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2010-10-23

+

View all other issues in [forward.iterators].

+

View all issues with NAD Concepts status.

+

Discussion:

+

Addresses UK 250

+ +

+A default implementation should be supplied for the post-increment +operator to simplify implementation of iterators by users. +

+ +

+Copy the Effects clause into the concept description as the default +implementation. Assumes a default value for postincrement_result +

+ +

[ +Summit: +]

+ +
+Howard will open an issue. +
+ +

[ +2009-06-07 Daniel adds: +]

+ + +
+This issue cannot currently be resolved as suggested, because +that would render auto-detection of the return type +postincrement_result invalid, see [concept.map.assoc]/4+5. The +best fix would be to add a default type to that associated type, but +unfortunately any default type will prevent auto-deduction of types of +associated functions as quoted above. A corresponding core issue +is in preparation. +
+ + +

Proposed resolution:

+

[ +This wording assumes the acceptance of UK 251 / 1009. Both +wordings change the same paragraphs. +]

+ + +

+Change 24.2.5 [forward.iterators]: +

+ +
+
concept ForwardIterator<typename X> : InputIterator<X>, Regular<X> { 
+
+  MoveConstructible postincrement_result;
+  requires HasDereference<postincrement_result>
+        && Convertible<HasDereference<postincrement_result>::result_type, const value_type&>;
+
+  postincrement_result operator++(X& r, int); {
+     X tmp = r;
+     ++r;
+     return tmp;
+  }
+
+  axiom MultiPass(X a, X b) { 
+    if (a == b) *a == *b; 
+    if (a == b) ++a == ++b; 
+  } 
+}
+
+ + + + + + +
+

1085. Response to UK 258

+

Section: 24.2.6 [bidirectional.iterators] Status: NAD Concepts + Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2010-10-23

+

View all other issues in [bidirectional.iterators].

+

View all issues with NAD Concepts status.

+

Discussion:

+

Addresses UK 258

+ +

+A default implementation should be supplied for the post-decrement +operator to simplify implementation of iterators by users. +

+ +

+Copy the Effects clause into the concept description as the default +implementation. Assumes a default value for postincrement_result +

+ +

[ +Summit: +]

+ +
+Howard will open an issue. +
+ +

[ +2009-06-07 Daniel adds: +]

+ + +
+This issue cannot currently be resolved as suggested, because +that would render auto-detection of the return type +postdecrement_result invalid, see 1084. +
+ + +

Proposed resolution:

+ +

+Change 24.2.6 [bidirectional.iterators]: +

+ +
+
concept BidirectionalIterator<typename X> : ForwardIterator<X> { 
+  MoveConstructible postdecrement_result; 
+  requires HasDereference<postdecrement_result> 
+        && Convertible<HasDereference<postdecrement_result>::result_type, const value_type&> 
+        && Convertible<postdecrement_result, const X&>; 
+  X& operator--(X&); 
+  postdecrement_result operator--(X& r, int); {
+     X tmp = r;
+     --r;
+     return tmp;
+  }
+}
+
+ + + + + + +
+

1086. Response to UK 284

+

Section: 24.6 [stream.iterators] Status: NAD Concepts + Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+

Addresses UK 284

+ +

+The stream iterators need constraining with concepts/requrires clauses. +

+ +

[ +Summit: +]

+ +
+We agree. To be handled by Howard, Martin and PJ. +
+ + +

Proposed resolution:

+ + + + + +
+

1087. Response to UK 301

+

Section: 25.3.5 [alg.replace] Status: NAD Concepts + Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2010-10-23

+

View all other issues in [alg.replace].

+

View all issues with NAD Concepts status.

+

Discussion:

+

Addresses UK 301

+ +

+replace and replace_if have the requirement: OutputIterator<Iter, +Iter::reference> Which implies they need to copy some values in the +range the algorithm is iterating over. This is not however the case, the +only thing that happens is const T&s might be copied over existing +elements (hence the OutputIterator<Iter, const T&>. +

+ +

+Remove OutputIterator<Iter, Iter::reference> from replace +and replace_if. +

+ +

[ +Summit: +]

+ +
+We agree. To be handled by Howard. +
+ + +

Proposed resolution:

+

+Change in [algorithms.syn] and 25.3.5 [alg.replace]: +

+ +
template<ForwardIterator Iter, class T> 
+  requires OutputIterator<Iter, Iter::reference> 
+        && OutputIterator<Iter, const T&> 
+        && HasEqualTo<Iter::value_type, T> 
+  void replace(Iter first, Iter last, 
+               const T& old_value, const T& new_value); 
+
+template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred, class T> 
+  requires OutputIterator<Iter, Iter::reference> 
+        && OutputIterator<Iter, const T&> 
+        && CopyConstructible<Pred> 
+  void replace_if(Iter first, Iter last,
+                  Pred pred, const T& new_value);
+
+ + + + + +
+

1088. Response to UK 342

+

Section: 30.6.5 [futures.promise] Status: NAD Editorial + Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2010-10-23

+

View other active issues in [futures.promise].

+

View all other issues in [futures.promise].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses UK 342

+ +

+std::promise is missing a non-member overload of swap. This is +inconsistent with other types that provide a swap member function. +

+ +

+Add a non-member overload void swap(promise&& x,promise&& y){ x.swap(y); } +

+ +

[ +Summit: +]

+ +
+Create an issue. Move to review, attention: Howard. Detlef will also +look into it. +
+ +

[ +Post Summit Daniel provided wording. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2997. +
+ + + +

Proposed resolution:

+
    +
  1. +

    +In 30.6.5 [futures.promise], before p.1, immediately after class template +promise add: +

    +
    
+template <class R>
+void swap(promise<R>& x, promise<R>& y);
+
+
    +
    2. +
  2. +

    +Change 30.6.5 [futures.promise]/10 as indicated (to fix a circular definition): +

    +
    +

    +-10- Effects: swap(*this, other)Swaps the associated state +of *this and other +

    +

    +Throws: Nothing. +

    +
    +
    3. +
  3. +

    +After the last paragraph in 30.6.5 [futures.promise] add the following +prototype description: +

    +
    
+template <class R>
+void swap(promise<R>& x, promise<R>& y);
+
    +
    +

    +Effects: x.swap(y) +

    +

    +Throws: Nothing. +

    +
    +
    +
    4. + +
+ + + + + + +
+

1090. Missing description of packaged_task member swap, missing non-member swap

+

Section: 30.6.10 [futures.task] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2009-03-22 Last modified: 2010-10-23

+

View all other issues in [futures.task].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Class template packaged_task in 30.6.10 [futures.task] shows a member swap +declaration, but misses to +document it's effects (No prototype provided). Further on this class +misses to provide a non-member +swap. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+Alisdair notes that paragraph 2 of the proposed resolution has already been +applied in the current Working Draft. +

+

+We note a pending future-related paper by Detlef; +we would like to wait for this paper before proceeding. +

+

+Move to Open. +

+
+ +

[ +2009-05-24 Daniel removed part 2 of the proposed resolution. +]

+ + +

[ +2009-10 post-Santa Cruz: +]

+ + +
+Move to Tentatively Ready, removing bullet 3 from the proposed +resolution but keeping the other two bullets. +
+ +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Editorial. Rationale added below. +
+ + + +

Rationale:

+

+Solved by N3058. +

+ + +

Proposed resolution:

+
    +
  1. +

    +In 30.6.10 [futures.task], immediately after the definition of class +template packaged_task add: +

    +
    
+template<class R, class... Argtypes>
+void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&);
+
+
    +
    2. +
+ +
    + +
  1. +

    +At the end of 30.6.10 [futures.task] (after p. 20), add add the following +prototype description: +

    + +
    
+template<class R, class... Argtypes>
+void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y);
+
    +
    +

    +Effects: x.swap(y) +

    +

    +Throws: Nothing. +

    +
    +
    +
    2. +
+ + + + + +
+

1091. Multimap description confusing

+

Section: 23.6.2.2 [multimap.modifiers] Status: NAD + Submitter: LWG Opened: 2009-03-22 Last modified: 2010-10-23

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses UK 246

+

+The content of this sub-clause is purely trying to describe in words the +effect of the requires clauses on these operations, now that we have +Concepts. As such, the description is more confusing than the signature +itself. The semantic for these functions is adequately covered in the +requirements tables in 23.2.4 [associative.reqmts]. +

+ +

[ +Beman adds: +]

+ + +
+Pete is clearly right that +this one is technical rather than editorial. +
+ +

[ +Batavia (2009-05): +]

+ +
+

+We agree with the proposed resolution. +

+

+Move to Review. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD, solved by removing concepts. +
+ + + +

Proposed resolution:

+

+Strike 23.6.2.2 [multimap.modifiers] entirely +(but do NOT strike these signatures from the class template definition!). +

+ + + + + +
+

1092. Class template integral_constant should be a constrained template

+

Section: 20.7.3 [meta.help] Status: NAD Concepts + Submitter: Daniel Krügler Opened: 2009-03-22 Last modified: 2010-10-23

+

View all other issues in [meta.help].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+A first step to change the type traits predicates to constrained templates is to +constrain their common base template integral_constant. This can be done, +without enforcing depending classes to be constrained as well, but not +vice versa +without brute force late_check usages. The following proposed resolution depends +on the resolution of LWG issue 1019. +

+ +

[ +Batavia (2009-05): +]

+ +
+Move to Open, pending a paper that looks at constraints +for the entirety of the type traits +and their relationship to the foundation concepts. +We recommend this be deferred +until after the next Committee Draft is issued. +
+ + +

Proposed resolution:

+
    +
  1. +

    +In 20.7.2 [meta.type.synop], Header <type_traits> +synopsis change as indicated: +

    +
    namespace std {
+// 20.5.3, helper class:
+template <classIntegralConstantExpressionType T, T v> struct integral_constant;
+
    +
    2. +
  2. +

    +In 20.7.3 [meta.help] change as indicated: +

    +
    template <classIntegralConstantExpressionType T, T v>
+struct integral_constant {
+  static constexpr T value = v;
+  typedef T value_type;
+  typedef integral_constant<T,v> type;
+  constexpr operator value_type() { return value; }
+};
+
    +
    3. +
+ + + + + +
+

1093. Multiple definitions for random_shuffle algorithm

+

Section: 25.3.12 [alg.random.shuffle] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-03-22 Last modified: 2010-10-23

+

View all other issues in [alg.random.shuffle].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

+There are a couple of issues with the declaration of the random_shuffle +algorithm accepting a random number engine. +

+ +
    +
  1. +The Iterators must be shuffle iterators, yet this requirement is missing. +
    2. +
  2. +The RandomNumberEngine concept is now provided by the random number +library +(n2836) +and the placeholder should be removed. +
    3. +
+ +

[ +2009-05-02 Daniel adds: +]

+ + +
+

+this issue completes adding necessary requirement to the +third new random_shuffle overload. The current suggestion is: +

+ +
template<RandomAccessIterator Iter, UniformRandomNumberGenerator Rand>
+requires ShuffleIterator<Iter>
+void random_shuffle(Iter first, Iter last, Rand&& g);
+
+ +

+IMO this is still insufficient and I suggest to add the requirement +

+
Convertible<Rand::result_type, Iter::difference_type>
+
+

+to the list (as the two other overloads already have). +

+ +

+Rationale: +

+ +
+

+Its true that this third overload is somewhat different from the remaining +two. Nevertheless we know from UniformRandomNumberGenerator, that +it's result_type is an integral type and that it satisfies +UnsignedIntegralLike<result_type>. +

+

+To realize it's designated task, the algorithm has to invoke the +Callable aspect of g and needs to perform some algebra involving +it's min()/max() limits to compute another index value that +at this point is converted into Iter::difference_type. This is so, +because 24.2.7 [random.access.iterators] uses this type as argument +of it's algebraic operators. Alternatively consider the equivalent +iterator algorithms in 24.4.4 [iterator.operations] with the same result. +

+

+This argument leads us to the conclusion that we also need +Convertible<Rand::result_type, Iter::difference_type> here. +

+
+ +
+ +

[ +Batavia (2009-05): +]

+ +
+

+Alisdair notes that point (ii) has already been addressed. +

+

+We agree with the proposed resolution to point (i) +with Daniel's added requirement. +

+

+Move to Review. +

+
+ +

[ +2009-06-05 Daniel updated proposed wording as recommended in Batavia. +]

+ + +

[ +2009-07-28 Alisdair adds: +]

+ + +
+Revert to Open, with a note there is consensus on direction but the +wording needs updating to reflect removal of concepts. +
+ +

[ +2009-10 post-Santa Cruz: +]

+ + +
+Leave Open, Walter to work on it. +
+ +

[ +2010 Pittsburgh: Moved to NAD Editorial, solved by +N3056. +]

+ + + + +

Rationale:

+

+Solved by +N3056. +

+ + +

Proposed resolution:

+

+Change in [algorithms.syn] and 25.3.12 [alg.random.shuffle]: +

+ +
concept UniformRandomNumberGenerator<typename Rand> { }
+template<RandomAccessIterator Iter, UniformRandomNumberGenerator Rand>
+  requires ShuffleIterator<Iter> &&
+  Convertible<Rand::result_type, Iter::difference_type>
+  void random_shuffle(Iter first, Iter last, Rand&& g);
+
+ + + + + + +
+

1096. unconstrained rvalue ref parameters

+

Section: 17 [library] Status: NAD Concepts + Submitter: David Abrahams Opened: 2009-03-21 Last modified: 2010-10-23

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+TODO: Look at all cases of unconstrained rvalue ref parameters and check +that concept req'ts work when T deduced as reference. +

+ +

+ We found some instances where that was not done correctly and we figure + the possibility of deducing T to be an lvalue reference was probably + overlooked elsewhere. +

+ +

[ +Batavia (2009-05): +]

+ +
+Move to Open, pending proposed wording from Dave for further review. +
+ + +

Proposed resolution:

+

+

+ + + + + +
+

1099. Various issues

+

Section: 17 [library] Status: NAD + Submitter: David Abrahams Opened: 2009-03-21 Last modified: 2010-10-23

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD status.

+

Discussion:

+

+Notes +

+
+

+[2009-03-21 Sat] p. 535 at the top we need MoveConstructible V1, +MoveConstructible V2 (where V1,V2 are defined on 539). Also make_tuple +on 550 +

+ +
+

+CD-1 reads: +

+ +
template <MoveConstructible T1, MoveConstructible T2> 
+pair<V1, V2> make_pair(T1&&, T2&&); 
+
+ +

+Actually I'm guessing we need something like MoveConstructible<V1,T1>, +i.e. "V1 can be constructed from an rvalue of type T1." +

+ +

+Ditto for make_tuple +

+
+ +

+[2009-03-21 Sat] p1183 thread ctor, and in general, we need a way to +talk about "copiable from generalized rvalue ref argument" for cases +where we're going to forward and copy. +

+
+

+ This issue may well be quite large. Language in para 4 about "if + an lvalue" is wrong because types aren't expressions. +

+ +
+

+Maybe we should define the term "move" so we can just say in the +effects, "f is moved into the newly-created thread" or something, and +agree (and ideally document) that saying "f is moved" implies +

+ +
F x(move(f))
+
+ +

+is required to work. That would cover both ctors at once. +

+
+ +

+ p1199, call_once has all the same issues. +

+
+

+[2009-03-21 Sat] p869 InputIterator pointer type should not be required +to be convertible to const value_type*, rather it needs to have a +operator-> of its own that can be used for the value type. +

+ +
+This one is serious and unrelated to the move issue. +
+ +

+[2009-03-21 Sat] p818 stack has the same problem with default ctor. +

+

+[2009-03-21 Sat] p816 priority_queue has the same sorts of problems as queue, only more so +

+
   requires MoveConstructible<Cont> 
+     explicit priority_queue(const Compare& x = Compare(), Cont&& = Cont()); 
+
+

+ Don't require MoveConstructible when default constructing Cont. + Also missing semantics for move ctor. +

+
+

+ [2009-03-21 Sat] Why are Allocators required to be CopyConstructible as + opposed to MoveConstructible? +

+

+ [2009-03-21 Sat] p813 queue needs a separate default ctor (Cont needn't + be MoveConstructible). No documented semantics for move c'tor. Or + *any* of its 7 ctors! +

+

+ [2009-03-21 Sat] std::array should have constructors for C++0x, + consequently must consider move construction. +

+ +

[ +2009-05-01 Daniel adds: +]

+ + +
+This could be done as part of 1035, which already handles +deviation of std::array from container tables. +
+ +

+ [2009-03-21 Sat] p622 all messed up. +

+
+

+ para 8 "implementation-defined" is the wrong term; should be "see + below" or something. +

+

+ para 12 "will be selected" doesn't make any sense because we're not + talking about actual arg types. +

+

+ paras 9-13 need to be totally rewritten for concepts. +

+
+ +

+ [2009-03-21 Sat] Null pointer comparisons (p587) have all become + unconstrained. Need to fix that +

+

+ [2009-03-21 Sat] mem_fun_t etc. definition doesn't match declaration. + We think CopyConstructible is the right reqt. +

+

+ make_pair needs Constructible<V1, T1&&> requirements! +

+

+ make_tuple needs something similar +

+

+ tuple bug in synopsis: +

+
   template <class... UTypes>
+   requires Constructible<Types, const UTypes&>...
+   template <class... UTypes>
+   requires Constructible<Types, RvalueOf<UTypes>::type>...
+
+

+ Note: removal of MoveConstructible requirements in std::function makes + these routines unconstrained! +

+
+ +

[ +2009-05-02 Daniel adds: +]

+ + +
+This part of the issue is already covered by 1077. +
+ +

+ these unique_ptr constructors are broken [ I think this is covered in "p622 all messed up" ] +

+
 unique_ptr(pointer p, implementation-defined d);
+ unique_ptr(pointer p, implementation-defined d);
+
+

+ multimap range constructor should not have MoveConstructible<value_type> requirement. +

+
+ same with insert(..., P&&); multiset has the same issue, as do + unordered_multiset and unordered_multimap. Review these! +
+ +
+ +

[ +Batavia (2009-05): +]

+ +
+Move to Open, pending proposed wording from Dave for further review. +
+ +

[ +2009-10 post-Santa Cruz: +]

+ + +
+Tentatively NAD. We are not sure what has been addressed and what hasn't. +Recommend closing unless someone sorts this out into something more readable. +
+ + + +

Rationale:

+

+The issue(s) at hand not adequately communicated. +

+ + +

Proposed resolution:

+

+

+ + + + + +
+

1101. unique requirements

+

Section: 25.3.9 [alg.unique] Status: NAD Editorial + Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2010-10-23

+

View all other issues in [alg.unique].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+From Message c++std-core-14160 Howard wrote: +

+ +
+It was the intent of the rvalue reference proposal for unique to only require MoveAssignable: +N1860. +
+ +

+And Pete replied: +

+ +
+That was overridden by the subsequent changes made for concepts in +N2573, +which reimposed the C++03 requirements. +
+ +

+My impression is that this overwrite was a simple (unintentional) mistake. +Wording below to correct it. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+Howard notes this issue resolves a discrepancy between the synopsis +and the description. +

+

+Move to NAD Editorial. +

+
+ + +

Proposed resolution:

+

+Change 25.3.9 [alg.unique]: +

+ +
template<ForwardIterator Iter> 
+  requires OutputIterator<Iter, RvalueOf<Iter::reference>::type> 
+        && EqualityComparable<Iter::value_type> 
+  Iter unique(Iter first, Iter last); 
+
+template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred> 
+  requires OutputIterator<Iter, RvalueOf<Iter::reference>::type> 
+        && CopyConstructible<Pred> 
+  Iter unique(Iter first, Iter last, Pred pred);
+
+ +

+Note that the synopsis in [algorithms.syn] is already correct. +

+ + + + + + +
+

1102. std::vector's reallocation policy still unclear

+

Section: 23.4.1.2 [vector.capacity] Status: NAD + Submitter: Daniel Krügler Opened: 2009-04-20 Last modified: 2010-10-23

+

View all other issues in [vector.capacity].

+

View all issues with NAD status.

+

Discussion:

+

+I have the impression that even the wording of current draft +N2857 +does insufficiently express the intent of vector's +reallocation strategy. This has produced not too old library +implementations which release memory in the clear() function +and even modern articles about C++ programming cultivate +the belief that clear is allowed to do exactly this. A typical +example is something like this: +

+ +
const int buf_size = ...;
+std::vector<T> buf(buf_size);
+for (int i = 0; i < some_condition; ++i) {
+  buf.resize(buf_size);
+  write_or_read_data(buf.data());
+  buf.clear(); // Ensure that the next round get's 'zeroed' elements
+}
+
+

+where still the myth is ubiquitous that buf might be +allowed to reallocate it's memory *inside* the for loop. +

+

+IMO the problem is due to the fact, that +

+ +
    +
  1. +the actual memory-reallocation stability of std::vector +is explained in 23.4.1.2 [vector.capacity]/3 and /6 which +are describing just the effects of the reserve +function, but in many examples (like above) there +is no explicit call to reserve involved. Further-more +23.4.1.2 [vector.capacity]/6 does only mention insertions +and never mentions the consequences of erasing +elements. +
    2. +
  2. +

    +the effects clause of std::vector's erase overloads in +23.4.1.4 [vector.modifiers]/4 is silent about capacity changes. This +easily causes a misunderstanding, because the counter +parting insert functions described in 23.4.1.4 [vector.modifiers]/2 +explicitly say, that +

    +
    +Causes reallocation if the new size is greater than the +old capacity. If no reallocation happens, all the iterators +and references before the insertion point remain valid. +
    +

    +It requires a complex argumentation chain about four +different places in the standard to provide the - possibly +weak - proof that calling clear() also does never change +the capacity of the std::vector container. Since std::vector +is the de-facto replacement of C99's dynamic arrays this +type is near to a built-in type and it's specification should +be clear enough that usual programmers can trust their +own reading. +

    +
    3. +
+ +

[ +Batavia (2009-05): +]

+ +
+

+Bill believes paragraph 1 of the proposed resolution is unnecessary +because it is already implied (even if tortuously) by the current wording. +

+

+Move to Review. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD. Rationale: there is no consensus to clarify the standard, +general consensus that the standard is correct as written. +
+ + + +

Proposed resolution:

+

[ +This is a minimum version. I also +suggest that the wording explaining the allocation strategy +of std::vector in 23.4.1.2 [vector.capacity]/3 and /6 is moved into +a separate sub paragraph of 23.4.1.2 [vector.capacity] before +any of the prototype's are discussed, but I cannot provide +reasonable wording changes now +]

+ + +
    +
  1. +

    +Change 23.4.1.2 [vector.capacity]/6 as follows: +

    +
    +It is guaranteed that no reallocation takes place during +insertions or erasures that happen after a call +to reserve() until the time when an insertion would make +the size of the vector greater than the value of capacity(). +
    +
    2. +
  2. +

    +Change 23.4.1.4 [vector.modifiers]/4 as follows: +

    +
    +Effects: The capacity shall remain unchanged and no reallocation shall +happen. +Invalidates iterators and references at or after the point +of the erase. +
    +
    3. +
+ + + + + +
+

1105. Shouldn't Range be an auto concept

+

Section: X [iterator.concepts.range] Status: NAD Concepts + Submitter: David Abrahams Opened: 2009-04-23 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

[ +2009-04-26 Herb adds: +]

+ + +
+

+Here's a common example: We have many ISV customers who have built lots of +in-house STL-like containers. Imagine that, for the past ten years, the user +has been happily using his XYZCorpContainer<T> that has begin() and end() +and an iterator typedef, and indeed satisfies nearly all of Container, +though maybe not quite all just like valarray. The user upgrades to a +range-enabled version of a library, and now lib_algo( xyz.begin(), xyz.end()); +no longer works -- compiler error. +

+

+Even though XYZCorpContainer matches the pre-conceptized version of the +algorithm, and has been working for years, it appears the user has to write +at least this: +

+
template<class T> concept_map Range<XYZCorpContainer<T>> {};
+
+template<class T> concept_map Range<const XYZCorpContainer<T>> {};
+
+

+Is that correct? +

+

+But he may actually have to write this as we do for initializer list: +

+
template<class T>
+concept_map Range<XYZCorpContainer<T>> {
+   typedef T* iterator;
+   iterator begin(XYZCorpContainer<T> c) { return c.begin(); }
+   iterator end(XYZCorpContainer<T> c) { return c.end(); }
+};
+
+template<class T>
+concept_map Range<const XYZCorpContainer<T>> {
+   typedef T* iterator;
+   iterator begin(XYZCorpContainer<T> c) { return c.begin(); }
+   iterator end(XYZCorpContainer<T> c) { return c.end(); }
+};
+
+ +
+ +

[ +2009-04-28 Alisdair adds: +]

+ + +
+

+I recommend NAD, although remain concerned about header organisation. +

+

+A user container will satisfy the MemberContainer concept, which IS auto. +There is a concept_map for all MemberContainers to Container, and then a +further concept_map for all Container to Range, so the stated problem is not +actually true. User defined containers will automatically match the Range +concept without explicitly declaring a concept_map. +

+

+The problem is that they should now provide an additional two headers, +<iterator_concepts> and <container_concepts>. + The only difference from +making Range an auto concept would be this reduces to a single header, +<iterator_concepts>. +

+

+I am strongly in favour of any resolution that tackles the issue of +explicitly requiring concept headers to make these concept maps available. +

+
+ +

[ +Batavia (2009-05): +]

+ +
+

+We observe there is a recent paper by Bjarne that overlaps this issue. +

+

+Alisdair continues to recommend NAD. +

+

+Move to Open, and recommend the issue be deferred until after the next +Committee Draft is issued. +

+
+ + +

Proposed resolution:

+ + + + + +
+

1106. Multiple exceptions from connected shared_future::get()?

+

Section: 30.6.7 [futures.shared_future] Status: NAD Editorial + Submitter: Thomas J. Gritzan Opened: 2009-04-03 Last modified: 2010-10-23

+

View all other issues in [futures.shared_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+It is not clear, if multiple threads are waiting in a +shared_future::get() call, if each will rethrow the stored exception. +

+

+Paragraph 9 reads: +

+
+Throws: the stored exception, if an exception was stored and not +retrieved before. +
+

+The "not retrieved before" suggests that only one exception is thrown, +but one exception for each call to get() is needed, and multiple calls +to get() even on the same shared_future object seem to be allowed. +

+

+I suggest removing "and not retrieved before" from the Throws paragraph. +I recommend adding a note that explains that multiple calls on get() are +allowed, and each call would result in an exception if an exception was +stored. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+We note there is a pending paper by Detlef +on such future-related issues; +we would like to wait for his paper before proceeding. +

+

+Alisdair suggests we may want language to clarify that this +get() function can be called from several threads +with no need for explicit locking. +

+

+Move to Open. +

+
+ +

[ +2010-01-23 Moved to Tentatively NAD Editorial after 5 positive votes on +c++std-lib. +]

+ + + + +

Rationale:

+

+Resolved by paper +N2997. +

+ + +

Proposed resolution:

+

+Change 30.6.7 [futures.shared_future]: +

+ +
const R& shared_future::get() const; 
+R& shared_future<R&>::get() const; 
+void shared_future<void>::get() const;
+
+
+

...

+

+-9- Throws: the stored exception, if an exception was stored and not retrieved before. + +[Note: Multiple calls on get() are +allowed, and each call would result in an exception if an exception was +stored. — end note] + +

+
+
+ + + + + + +
+

1107. constructor shared_future(unique_future) by value?

+

Section: 30.6.7 [futures.shared_future] Status: NAD Editorial + Submitter: Thomas J. Gritzan Opened: 2009-04-03 Last modified: 2010-10-23

+

View all other issues in [futures.shared_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In the shared_future class definition in 30.6.7 [futures.shared_future] +the move constructor +that constructs a shared_future from an unique_future receives the +parameter by value. In paragraph 3, the same constructor receives it as +const value. +

+ +

+I think that is a mistake and the constructor should take a r-value +reference: +

+ +
shared_future(unique_future<R>&& rhs);
+
+ +

[ +Batavia (2009-05): +]

+ +
+

+We agree with the proposed resolution. +

+

+Move to Tentatively Ready. +

+
+ +

[ +2009-07-05 Daniel notes: +]

+ + +
+The proposed change has already been incorported into the current working draft +N2914. +
+ + +

Proposed resolution:

+

+Change the synopsis in 30.6.7 [futures.shared_future]: +

+ +
shared_future(unique_future<R>&& rhs);
+
+ +

+Change the definition of the constructor in 30.6.7 [futures.shared_future]: +

+ +
shared_future(const unique_future<R>&& rhs);
+
+ + + + + + +
+

1109. std::includes should require CopyConstructible predicate

+

Section: 25.4.5.1 [includes] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-04-28 Last modified: 2010-10-23

+

View all other issues in [includes].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+All the set operation algorithms require a CopyConstructible predicate, with +the exception of std::includes. This looks like a typo as much as anything, +given the general library requirement that predicates are copy +constructible, and wording style of other set-like operations. +

+ +

[ +Batavia (2009-05): +]

+ +
+We agree with the proposed resolution. +Move to NAD Editorial. +
+ + +

Proposed resolution:

+

+Change [algorithms.syn] and 25.4.5.1 [includes]: +

+ +
template<InputIterator Iter1, InputIterator Iter2,
+         typename CopyConstructible Compare>
+  requires Predicate<Compare, Iter1::value_type, Iter2::value_type>
+        && Predicate<Compare, Iter2::value_type, Iter1::value_type>
+  bool includes(Iter1 first1, Iter1 last1,
+                Iter2 first2, Iter2 last2,
+                Compare comp);
+
+ + + + + +
+

1111. associative containers underconstrained

+

Section: 23.6 [associative] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-04-29 Last modified: 2010-10-23

+

View all other issues in [associative].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+According to table 87 (n2857) the expression X::key_equal for an unordered +container shall return a value of type Pred, where Pred is an equivalence +relation. +

+ +

+However, all 4 containers constrain Pred to be merely a Predicate, +and not EquivalenceRelation. +

+ +

[ +Batavia (2009-05): +]

+ +
+

+We agree with the proposed resolution. +

+

+Move to Review. +

+
+ + +

Proposed resolution:

+

+For ordered containers, replace +

+
Predicate<auto, Key, Key> Compare = less<Key>
+
+

+with +

+
StrictWeakOrder<auto, Key, Key> Compare = less<Key>
+
+ +

+For unordered containers, replace +

+
Predicate<auto, Key, Key> Compare = less<Key>
+
+

+with +

+
EquivalenceRelation<auto, Key, Key> Compare = less<Key>
+
+

+As in the following declarations: +

+ +
+

+Associative containers 23.6 [associative] +

+

+ 1 Headers <map> and <set>: +

+

+ Header <map> synopsis +

+
   namespace std {
+     template <ValueType Key, ValueType T,
+               PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+               Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+       requires NothrowDestructible<Key> && NothrowDestructible<T>
+             && CopyConstructible<Compare>
+             && AllocatableElement<Alloc, Compare, const Compare&>
+             && AllocatableElement<Alloc, Compare, Compare&&>
+     class map;
+
+     ...
+
+     template <ValueType Key, ValueType T,
+               PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+               Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+       requires NothrowDestructible<Key> && NothrowDestructible<T>
+             && CopyConstructible<Compare>
+             && AllocatableElement<Alloc, Compare, const Compare&>
+             && AllocatableElement<Alloc, Compare, Compare&&>
+     class multimap;
+
+     ...
+
+   }
+
+ +

+ Header <set> synopsis +

+
   namespace std {
+     template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+               Allocator Alloc = allocator<Key> >
+       requires NothrowDestructible<Key> && CopyConstructible<Compare>
+             && AllocatableElement<Alloc, Compare, const Compare&>
+             && AllocatableElement<Alloc, Compare, Compare&&>
+     class set;
+
+     ...
+
+     template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+               Allocator Alloc = allocator<Key> >
+       requires NothrowDestructible<Key> && CopyConstructible<Compare>
+             && AllocatableElement<Alloc, Compare, const Compare&>
+             && AllocatableElement<Alloc, Compare, Compare&&>
+     class multiset;
+
+     ...
+
+   }
+
+ +

+ 23.4.1p2 Class template map [map] +

+
 namespace std {
+   template <ValueType Key, ValueType T,
+             PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && CopyConstructible<Compare>
+           && AllocatableElement<Alloc, Compare, const Compare&>
+           && AllocatableElement<Alloc, Compare, Compare&&>
+   class map {
+     ...
+   };
+ }
+
+ + +

+ 23.4.2p2 Class template multimap [multimap] +

+
 namespace std {
+   template <ValueType Key, ValueType T,
+             PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && CopyConstructible<Compare>
+           && AllocatableElement<Alloc, Compare, const Compare&>
+           && AllocatableElement<Alloc, Compare, Compare&&>
+   class multimap {
+     ...
+   };
+ }
+
+ + +

+ 23.4.3p2 Class template set [set] +

+
 namespace std {
+   template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+             Allocator Alloc = allocator<Key> >
+     requires NothrowDestructible<Key> && CopyConstructible<Compare>
+           && AllocatableElement<Alloc, Compare, const Compare&>
+           && AllocatableElement<Alloc, Compare, Compare&&>
+   class set {
+     ...
+   };
+ }
+
+ + +

+ 23.4.4p2 Class template multiset [multiset] +

+
 namespace std {
+   template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+             Allocator Alloc = allocator<Key> >
+     requires NothrowDestructible<Key> && CopyConstructible<Compare>
+           && AllocatableElement<Alloc, Compare, const Compare&>
+           && AllocatableElement<Alloc, Compare, Compare&&>
+   class multiset {
+     ...
+   };
+ }
+
+ +

+ 23.5 Unordered associative containers [unord] +

+

+ 1 Headers <unordered_map> and <unordered_set>: +

+

+ Header <unordered_map> synopsis +

+
 namespace std {
+   // 23.5.1, class template unordered_map:
+   template <ValueType Key,
+             ValueType T,
+             Callable<auto, const Key&> Hash = hash<Key>,
+             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+     class unordered_map;
+
+   // 23.5.2, class template unordered_multimap:
+   template <ValueType Key,
+             ValueType T,
+             Callable<auto, const Key&> Hash = hash<Key>,
+             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+     class unordered_multimap;
+
+   ...
+ }
+
+ +

+ Header <unordered_set> synopsis +

+
 namespace std {
+   // 23.5.3, class template unordered_set:
+   template <ValueType Value,
+             Callable<auto, const Value&> Hash = hash<Value>,
+             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
+             Allocator Alloc = allocator<Value> >
+     requires NothrowDestructible<Value>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+     class unordered_set;
+
+   // 23.5.4, class template unordered_multiset:
+   template <ValueType Value,
+             Callable<auto, const Value&> Hash = hash<Value>,
+             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
+             Allocator Alloc = allocator<Value> >
+     requires NothrowDestructible<Value>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+     class unordered_multiset;
+
+   ...
+ }
+
+ +

+ 23.5.1p3 Class template unordered_map [unord.map] +

+
 namespace std {
+   template <ValueType Key,
+             ValueType T,
+             Callable<auto, const Key&> Hash = hash<Key>,
+             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+   class unordered_map
+   {
+     ...
+   };
+ }
+
+ +

+ 23.5.2p3 Class template unordered_multimap [unord.multimap] +

+
 namespace std {
+   template <ValueType Key,
+             ValueType T,
+             Callable<auto, const Key&> Hash = hash<Key>,
+             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+   class unordered_multimap
+   {
+     ...
+   };
+ }
+
+ +

+ 23.5.3p3 Class template unordered_set [unord.set] +

+
 namespace std {
+   template <ValueType Value,
+             Callable<auto, const Value&> Hash = hash<Value>,
+             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
+             Allocator Alloc = allocator<Value> >
+     requires NothrowDestructible<Value>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+   class unordered_set
+   {
+     ...
+   };
+ }
+
+

+ 23.5.4p3 Class template unordered_multiset [unord.multiset] +

+
 namespace std {
+   template <ValueType Value,
+             Callable<auto, const Value&> Hash = hash<Value>,
+             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
+             Allocator Alloc = allocator<Value> >
+     requires NothrowDestructible<Value>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+   class unordered_multiset
+   {
+     ...
+   };
+ }
+
+ +
+ + + + + + +
+

1112. bitsets and new style for loop

+

Section: 20.5 [template.bitset] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2009-05-06 Last modified: 2010-10-23

+

View all other issues in [template.bitset].

+

View all issues with NAD Future status.

+

Discussion:

+

+Std::bitset is a homogeneous container-like sequence of bits, yet it does +not model the Range concept so cannot be used with the new for-loop syntax. +It is the only such type in the library that does NOT support the new for +loop. +

+

+The obvious reason is that bitset does not support iterators. +

+

+At least two reasonable solutions are available: +

+
    +
  1. +Add an iterator interface to bitset, bringing its interface close to that +of std::array +
    2. +
  2. +Provide an unspecified concept_map for Range<bitset>. +
    3. +
+

+The latter will still need some kind of iterator-like adapter for bitset, +but gives implementers greater freedom on the details. E.g. begin/end return +some type that simply invokes operator[] on the object it wraps, and +increments its index on operator++. A vendor can settle for InputIterator +support, rather than wrapping up a full RandomAccessIterator. +

+

+I have a mild preference for option (ii) as I think it is less work to +specify at this stage of the process, although (i) is probably more useful +in the long run. +

+

+Hmm, my wording looks a little woolly, as it does not say what the element +type of the range is. Do I get a range of bool, bitset<N>::reference, or +something else entirely? +

+

+I guess most users will assume the behaviour of reference, but expect to +work with bool. Bool is OK for read-only traversal, but you really need to +take a reference to a bitset::reference if you want to write back. +

+ +

[ +Batavia (2009-05): +]

+ +
+Move to Open. +We further recommend this be deferred until after the next Committee Draft. +
+ +

[ +2009-05-25 Alisdair adds: +]

+ + +
+

+I just stumbled over the Range concept_map for valarray and this should +probably set the precedent on how to write the wording. +

+ +

[ +Howard: I've replaced the proposed wording with Alisdair's suggestion. +]

+ + +
+ +

[ +2009-07-24 Daniel modifies the proposed wording for non-concepts. +]

+ + +

[ +2009-10 post-Santa Cruz: +]

+ + +
+Mark as Tentatively NAD Future due to the loss of concepts. +
+ + + +

Rationale:

+

+All concepts-related text has been removed from the draft. +

+ + +

Proposed resolution:

+
    +
  1. +

    +Modify the section 20.5 [template.bitset] <bitset> synopsis by adding +the following at the end of the synopsis: +

    +
    
+// XX.X.X bitset range access [bitset.range]
+template<size_t N> unspecified-1 begin(bitset<N>&);
+template<size_t N> unspecified-2 begin(const bitset<N>&);
+template<size_t N> unspecified-1 end(bitset<N>&);
+template<size_t N> unspecified-2 end(const bitset<N>&);
+
+
    +
    2. +
  2. +

    +Add a new section "bitset range access" [bitset.range] +after the current section 20.5.4 [bitset.operators] with the following series of +paragraphs: +

    +
    +

    + +1. In the begin and end function templates that follow, unspecified-1 +is a type that meets the requirements of a mutable random access +iterator (24.2.7 [random.access.iterators]) whose value_type is bool and +whose reference type is bitset<N>::reference. +unspecified-2 is a type that meets the requirements of a constant +random access iterator (24.2.7 [random.access.iterators]) whose value_type +is bool and whose reference type is bool. + +

    +
    
+template<size_t N> unspecified-1 begin(bitset<N>&);
+template<size_t N> unspecified-2 begin(const bitset<N>&);
+
+
    +
    +2. Returns: an iterator referencing the first bit in the bitset. +
    + +
    
+template<size_t N> unspecified-1 end(bitset<N>&);
+template<size_t N> unspecified-2 end(const bitset<N>&);
+
    + +
    +3. Returns: an iterator referencing one past the last bit in the +bitset. +
    +
    +
    3. +
+ + + + + + + + + + + + +
+

1115. va_copy missing from Standard macros table

+

Section: C.2 [diff.library] Status: NAD Editorial + Submitter: Miles Zhao Opened: 2009-05-23 Last modified: 2010-10-23

+

View all other issues in [diff.library].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In "Table 122 -- Standard macros" of C.2 [diff.library], which lists the 56 macros +inherited from C library, va_copy seems to be missing. But in +"Table 21 -- Header <cstdarg> synopsis" (18.10 [support.runtime]), there is. +

+ +

[ +2009-10 post-Santa Cruz: +]

+ + +
+Mark as Tentatively NAD Editorial, if Pete disagrees, Howard +will move to Tentatively Ready +
+ + + +

Proposed resolution:

+

+Add va_copy to Table 122 -- Standard macros in C.2 [diff.library]. +

+ + + + + +
+

1119. tuple query APIs do not support references

+

Section: 20.4.2.5 [tuple.helper] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-05-23 Last modified: 2010-10-23

+

View all other issues in [tuple.helper].

+

View all issues with NAD status.

+

Discussion:

+

+The tuple query APIs tuple_size and +tuple_element do not support references-to-tuples. This can be +annoying when a template deduced a parameter type to be a reference, +which must be explicitly stripped with remove_reference before calling +these APIs. +

+

+I am not proposing a resolution at this point, as there is a +combinatorial explosion with lvalue/rvalue references and +cv-qualification (see previous issue) that suggests some higher +refactoring is in order. This might be something to kick back over to +Core/Evolution. +

+

+Note that we have the same problem in numeric_limits. +

+ +

[ +2009-10 post-Santa Cruz: +]

+ + +
+Move to Open. Alisdair to provide wording. +
+ + +

[ +2010 Rapperswil: +]

+ + +
+Move to NAD. This is an extension after the FCD, without a clear motivation. May consider as NAD Future if motivating examples come forward. +
+ + + +

Proposed resolution:

+ + + + + +
+

1120. New type trait - remove_all

+

Section: 20.7 [meta] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2009-05-23 Last modified: 2010-10-23

+

View all other issues in [meta].

+

View all issues with NAD Future status.

+

Discussion:

+

+Sometimes it is necessary to remove all qualifiers from a type before +passing on to a further API. A good example would be calling the +tuple query APIs tuple_size or tuple_element +with a deduced type inside a function template. If the deduced type is +cv-qualified or a reference then the call will fail. The solution is to +chain calls to +remove_cv<remove_reference<T>::type>::type, and +note that the order matters. +

+

+Suggest it would be helpful to add a new type trait, +remove_all, that removes all top-level qualifiers from a type +i.e. cv-qualification and any references. Define the term in such a way +that if additional qualifiers are added to the language, then +remove_all is defined as stripping those as well. +

+ +

[ +2009-10-14 Daniel adds: +]

+ + +
+remove_all seems too generic, a possible alternative matching +the current naming style could be remove_cv_reference or +remove_reference_cv. It should also be considered whether this +trait should also remove 'extents', or pointer 'decorations'. Especially +if the latter situations are considered as well, it might be easier to +chose the name not in terms of what it removes (which might be +a lot), but in terms of it creates. In this case I could think +of e.g. extract_value_type. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Future. +
+ + + +

Proposed resolution:

+ + + + + +
+

1121. Support for multiple arguments

+

Section: 20.6.2 [ratio.arithmetic] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2009-05-25 Last modified: 2010-10-23

+

View all other issues in [ratio.arithmetic].

+

View all issues with NAD Future status.

+

Discussion:

+

+Both add and multiply could sensibly be called with more than two arguments. +The variadic template facility makes such declarations simple, and is likely +to be frequently wrapped by end users if we do not supply the variant +ourselves. +

+

+We deliberately ignore divide at this point as it is not transitive. +Likewise, subtract places special meaning on the first argument so I do not +suggest extending that immediately. Both could be supported with analogous +wording to that for add/multiply below. +

+

+Note that the proposed resolution is potentially incompatible with that +proposed for 921, although the addition of the typedef to ratio would be +equally useful. +

+ +

[ +2009-10-30 Alisdair adds: +]

+ + +
+

+The consensus of the group when we reviewed this in Santa Cruz was that +921 would proceed to Ready as planned, and the +multi-paramater add/multiply templates should be renamed as +ratio_sum and ratio_product to avoid the problem +mixing template aliases with partial specializations. +

+ +

+It was also suggested to close this issue as NAD Future as it does not +correspond directly to any NB comment. NBs are free to submit a +specific comment (and re-open) in CD2 though. +

+ +

+Walter Brown also had concerns on better directing the order of +evaluation to avoid overflows if we do proceed for 0x rather than TR1, +so wording may not be complete yet. +

+ +

[ +Alisdair updates wording. +]

+ + +
+ +

[ +2009-10-30 Howard: +]

+ + +
+Moved to Tentatively NAD Future after 5 positive votes on c++std-lib. +
+ + + +

Rationale:

+

+Does not have sufficient support at this time. May wish to reconsider for a +future standard. +

+ + +

Proposed resolution:

+ +

+Add the following type traits to p3 20.6 [ratio] +

+ +
// ratio arithmetic
+template <class R1, class R2> struct ratio_add;
+template <class R1, class R2> struct ratio_subtract;
+template <class R1, class R2> struct ratio_multiply;
+template <class R1, class R2> struct ratio_divide;
+template <class R1, class ... RList> struct ratio_sum;
+template <class R1, class ... RList> struct ratio_product;
+
+ +

+after 20.6.2 [ratio.arithmetic] p1: add +

+ +
template <class R1, class ... RList> struct ratio_sum; // declared, never defined
+
+template <class R1> struct ratio_sum<R1> : R1 {};
+
+ +
+Requires: R1 is a specialization of class template ratio +
+ +
template <class R1, class R2, class ... RList> 
+ struct ratio_sum<R1, R2, RList...>
+   : ratio_add< R1, ratio_sum<R2, RList...>> {
+};
+
+ +
+Requires: R1 and each element in parmater pack +RList is a specialization of class template ratio +
+
+ +

+after 20.6.2 [ratio.arithmetic] p3: add +

+ +
template <class R1, class ... RList> struct ratio_product; // declared, never defined
+
+template <class R1> struct ratio_product<R1> : R1 {};
+
+ +
+Requires: R1 is a specialization of class template ratio +
+ +
template <class R1, class R2, class ... RList> 
+ struct ratio_sum<R1, R2, RList...>
+   : ratio_add< R1, ratio_product<R2, RList...>> {
+};
+
+ +
+Requires: R1 and each element in parmater pack +RList is a specialization of class template ratio +
+
+ + + + + + + + +
+

1124. Invalid definition of concept RvalueOf

+

Section: X [concept.transform] Status: NAD Concepts + Submitter: Daniel Krügler Opened: 2009-05-28 Last modified: 2010-10-23

+

View all other issues in [concept.transform].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+A recent news group +article +points to several defects in the +specification of reference-related concepts. +

+

+One problem of the concept RvalueOf as currently defined in +X [concept.transform]: +

+ +
concept RvalueOf<typename T> {
+ typename type = T&&;
+ requires ExplicitlyConvertible<T&,type> && Convertible<T&&,type>;
+}
+
+template<typename T> concept_map RvalueOf<T&> {
+ typedef T&& type;
+}
+
+ +

+is that if T is an lvalue-reference, the requirement +Convertible<T&&,type> isn't satisfied for +lvalue-references, because after reference-collapsing in the concept +definition we have Convertible<T&,type> in this case, +which isn't satisfied in the concept map template and also is not the +right constraint either. I think that the reporter is right that +SameType requirements should do the job and that we also should +use the new RvalueReference concept to specify a best matching +type requirement. +

+ + +

Proposed resolution:

+

+In X [concept.transform] before p. 4 change as indicated: +

+ +
auto concept RvalueOf<typename T> {
+  typenameRvalueReference type = T&&;
+  requires ExplicitlyConvertible<T&, type> && Convertible<T&&, type>SameType<T&, type&>;
+}
+
+ + + + + +
+

1125. ostream_iterator does not work with movable types

+

Section: 24.6.2.2 [ostream.iterator.ops] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-05-28 Last modified: 2010-10-23

+

View all issues with NAD status.

+

Discussion:

+

+ostream_iterator has not been updated to support moveable types, in a +similar manner to the insert iterators. +Note that this is not a problem for ostreambuf_iterator, as the types it is +restricted to dealing with do not support extra-efficient moving. +

+ +

[ +2009-11-10 Howard adds: +]

+ + +
+Moved to Tentatively NAD after 5 positive votes on c++std-lib. Rationale +added below. +
+ + +

Proposed resolution:

+

+Add second operator= overload to class template ostream_iterator +in 24.6.2 [ostream.iterator], para 2: +

+ +
ostream_iterator<T,charT,traits>& operator=(const T& value);
+ostream_iterator<T,charT,traits>& operator=(T&& value);
+
+ +

+Add a new paragraph: in 24.6.2.2 [ostream.iterator.ops]: +

+ +
+
ostream_iterator& operator=(T&& value);
+
+
+

+-2- Effects: +

+
*out_stream << std::move(value);
+if(delim != 0)
+  *out_stream << delim;
+return (*this);
+
+
+
+ + + +

Rationale:

+

+Several objections to move forward with this issue were voiced in the thread +starting with c++std-lib-25438. Among them is that we know of no motivating +use case to make streaming rvalues behave differently than streaming const +lvalues. +

+ + + + + +
+

1127. rvalue references and iterator traits

+

Section: 24.4.1 [iterator.traits] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-05-28 Last modified: 2010-10-23

+

View all other issues in [iterator.traits].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+The deprecated support for iterator_traits and legacy (unconstrained) +iterators features the (exposition only) concept: +

+ +
concept IsReference<typename T> { } // exposition only
+template<typename T> concept_map IsReference<T&> { }
+
+

+Now this looks exactly like the LvalueReference concept recently added to +clause 20, so I wonder if we should use that instead? +Then I consider the lack of rvalue-reference support, which means that +move_iterator would always flag as merely supporting the input_iterator_tag +category. This suggests we retain the exposition concept, but add a second +concept_map to support rvalue references. +

+

+I would suggest adding the extra concept_map is the right way forward, but +still wonder if the two exposition-only concepts in this clause might be +worth promoting to clause 20. That question might better be answered with a +fuller investigation of type_trait/concept unification though. +

+ + +

Proposed resolution:

+

+In Iterator traits 24.4.1 [iterator.traits] para 4 add: +

+ +
concept IsReference<typename T> { } // exposition only
+template<typename T> concept_map IsReference<T&> { }
+template<typename T> concept_map IsReference<T&&> { }
+
+ + + + + + +
+

1128. Missing definition of iterator_traits<T*>

+

Section: X [iterator.syn] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-05-28 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+

+The <iterator> header synopsis declares a partial specialization of +iterator_traits to support pointers, X [iterator.syn]. The implication +is that specialization will be described in D10, yet it did not follow the +rest of the deprecated material into this clause. +

+

+However, this is not as bad as it first seems! +There are partial specializations of iterator_traits for types that satisfy +the various Iterator concepts, and there are concept_maps for pointers to +explicitly support the RandomAccessIterator concept, so the required +template will be present - just not in the manner advertised. +

+

+I can see two obvious solutions: +

+ +
    +
  1. +Restore the iterator_traits<T*> partial specialization in D.10 +
    2. +
  2. +Remove the declaration of iterator_traits<T*> from 24.3 synopsis +
    3. +
+

+I recommend option (ii) in the wording below +

+

+Option (ii) could be extended to strike all the declarations of deprecated +material from the synopsis, as it is effectively duplicating D.10 anyway. +This is the approach taken for deprecated library components in the 98/03 +standards. This is probably a matter best left to the Editor though. +

+ + +

Proposed resolution:

+

+In X [iterator.syn] strike: +

+ +
template<class T> struct iterator_traits<T*>;
+
+ + + + + + +
+

1129. istream(buf)_iterator should support literal sentinel value

+

Section: 24.6.1.1 [istream.iterator.cons], 24.6.3 [istreambuf.iterator] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-05-30 Last modified: 2010-10-23

+

View all other issues in [istream.iterator.cons].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+istream_iterator and istreambuf_iterator should support literal sentinel +values. The default constructor is frequently used to terminate ranges, and +could easily be a literal value for istreambuf_iterator, and +istream_iterator when iterating value types. A little more work using a +suitably sized/aligned char-array for storage (or an updated component like +boost::optional proposed for TR2) would allow istream_iterator to support +constexpr default constructor in all cases, although we might leave this +tweak as a QoI issue. Note that requiring constexpr be supported also +allows us to place no-throw guarantees on this constructor too. +

+ +

[ +2009-06-02 Daniel adds: +]

+ + +
+

+I agree with the usefulness of the issue suggestion, but we need +to ensure that istream_iterator can satisfy be literal if needed. +Currently this is not clear, because 24.6.1 [istream.iterator]/3 declares +a copy constructor and a destructor and explains their semantic in +24.6.1.1 [istream.iterator.cons]/3+4. +

+

+The prototype semantic specification is ok (although it seems +somewhat redundant to me, because the semantic doesn't say +anything interesting in both cases), but for support of trivial class +types we also need a trivial copy constructor and destructor as of +9 [class]/6. The current non-informative specification of these +two special members suggests to remove their explicit declaration +in the class and add explicit wording that says that if T is +trivial a default constructed iterator is also literal, alternatively it +would be possible to mark both as defaulted and add explicit +(memberwise) wording that guarantees that they are trivial. +

+

+Btw.: I'm quite sure that the istreambuf_iterator additions to +ensure triviality are not sufficient as suggested, because the +library does not yet give general guarantees that a defaulted +special member declaration makes this member also trivial. +Note that e.g. the atomic types do give a general statement! +

+

+Finally there is a wording issue: There does not exist something +like a "literal constructor". The core language uses the term +"constexpr constructor" for this. +

+

+Suggestion: +

+
    +
  1. +

    +Change 24.6.1 [istream.iterator]/3 as indicated: +

    +
    constexpr istream_iterator();
+istream_iterator(istream_type& s);
+istream_iterator(const istream_iterator<T,charT,traits,Distance>& x) = default;
+~istream_iterator() = default;
+
    +
    2. +
  2. +

    +Change 24.6.1.1 [istream.iterator.cons]/1 as indicated: +

    +
    constexpr istream_iterator();
+
    +
    +-1- Effects: Constructs the end-of-stream iterator. If T is a literal type, +then this constructor shall be a constexpr constructor. +
    +
    +
    3. +
  3. +

    +Change 24.6.1.1 [istream.iterator.cons]/3 as indicated: +

    +
    istream_iterator(const istream_iterator<T,charT,traits,Distance>& x) = default;
+
    +
    +-3- Effects: Constructs a copy of x. If T is a literal type, then +this constructor shall be a trivial copy constructor. +
    +
    +
    4. +
  4. +

    +Change 24.6.1.1 [istream.iterator.cons]/4 as indicated: +

    + +
    ~istream_iterator() = default;
+
    +
    +-4- Effects: The iterator is destroyed. If T is a literal type, then +this destructor shall be a trivial +destructor. +
    +
    +
    5. +
  5. +

    +Change 24.6.3 [istreambuf.iterator] before p. 1 as indicated: +

    + +
    constexpr istreambuf_iterator() throw();
+istreambuf_iterator(const istreambuf_iterator&)  throw() = default;
+~istreambuf_iterator()  throw() = default;
+
    +
    6. +
  6. +

    +Change 24.6.3 [istreambuf.iterator]/1 as indicated: +

    +
    +[..] The default constructor istreambuf_iterator() and the constructor +istreambuf_iterator(0) both +construct an end of stream iterator object suitable for use as an +end-of-range. All +specializations of istreambuf_iterator shall have a trivial copy +constructor, a constexpr default +constructor and a trivial destructor. +
    +
    7. +
+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2994. +
+ + + +

Proposed resolution:

+

+24.6.1 [istream.iterator] para 3 +

+ +
constexpr istream_iterator();
+
+ +

+24.6.1.1 [istream.iterator.cons] +

+ +
constexpr istream_iterator();
+
+
+-1- Effects: Constructs the end-of-stream iterator. +If T is a literal type, then this constructor shall +be a literal constructor. +
+
+ +

+24.6.3 [istreambuf.iterator] +

+ +
constexpr istreambuf_iterator() throw();
+
+ + + + + + +
+

1132. JP-30: nested exceptions

+

Section: 18.8.6 [except.nested] Status: NAD + Submitter: Seiji Hayashida Opened: 2009-06-01 Last modified: 2010-10-23

+

View all other issues in [except.nested].

+

View all issues with NAD status.

+

Discussion:

+

Addresses JP 30

+ +

+C++0x nested_exception cannot handle a structured exception well. The +following codes show two types of tree structured exception handling. +

+

+The first one is based on nested_exception in C++0x, +while the second one is based on my library trickerr.h (in Japanese). +http://tricklib.com/cxx/dagger/trickerr.h +

+

+Assume that Function A() calls two sub functions A_a() and A_b(), both might +throw tree structured exceptions, and A_b() must be called even if A_a() +throws an exception. +

+

+List A (code of tree structured exception handling based on nested_exception +in C++0x) +

+ +
void A()
+{
+    try
+    {
+        std::vector<exception_ptr> exception_list;
+        try
+        {
+            // A_a() does a similar processing as A().
+            A_a();
+        }
+        catch(...)
+        {
+            exception_list.push_back(current_exception());
+        }
+
+        // ***The processing A() has to do even when A_a() fails. ***
+        try
+        {
+            // A_b() does a similar processing as A().
+            A_b();
+        }
+        catch(...)
+        {
+            exception_list.push_back(current_exception());
+        }
+        if (!exception_list.empty())
+        {
+            throw exception_list;
+        }
+    }
+    catch(...)
+    {
+        throw_with_nested(A_exception("someone error"));
+    }
+}
+void print_tree_exception(exception_ptr e, const std::string & indent ="")
+{
+    const char * indent_unit = " ";
+    const char * mark = "- ";
+    try
+    {
+        rethow_exception(e);
+    }
+    catch(const std::vector<exception_ptr> e)
+    {
+        for(std::vector<exception_ptr>::const_iterator i = e.begin(); i!=e.end(); ++i)
+        {
+            print_tree_exception(i, indent);
+        }
+    }
+    catch(const std::nested_exception  e)
+    {
+        print_tree_exception(evil_i(e), indent +indent_unit);
+    }
+    catch(const std::exception e)
+    {
+        std::cout << indent << mark << e.what() << std::endl;
+    }
+    catch(...)
+    {
+        std::cout << indent << mark << "unknown exception" << std::endl;
+    }
+}
+int main(int, char * [])
+{
+    try
+    {
+        A();
+    }
+    catch()
+    {
+        print_tree_exception(current_exception());
+    }
+    return EXIT_SUCCESS;
+}
+
+ +

+List B ( code of tree structured exception handling based on trickerr.h. ) +"trickerr.h" (in Japanese), refer to: +http://tricklib.com/cxx/dagger/trickerr.h. +

+ +
void A()
+{
+    tricklib::error_listener_type error_listener;
+    // A_a() is like A(). A_a() can throw tree structured exception.
+    A_a();
+
+    // *** It must do process so that A_a() throws exception in A(). ***
+    // A_b() is like A(). A_b() can throw tree structured exception.
+    A_b();
+
+    if (error_listener.has_error()) // You can write this "if block" in destructor
+                                    //  of class derived from error_listener_type.
+    {
+        throw_error(new A_error("someone error",error_listener.listener_off().extract_pending_error()));
+    }
+}
+void print_tree_error(const tricklib::error_type &a_error, const std::string & indent = "")
+{
+    const char * indent_unit = " ";
+    const char * mark = "- ";
+
+    tricklib::error_type error = a_error;
+    while(error)
+    {
+        std::cout << indent << mark << error->message << std::endl;
+        if (error->children)
+        {
+            print_tree_error(error->children, indent +indent_unit);
+        }
+        error = error->next;
+    }
+}
+int main(int, char * [])
+{
+    tricklib::error_thread_power error_thread_power_on; // This object is necessary per thread.
+
+    try
+    {
+        A();
+    }
+    catch(error_type error)
+    {
+        print_tree_error(error);
+    }
+    catch(...)
+    {
+        std::cout << "- unknown exception" << std::endl;
+    }
+    return EXIT_SUCCESS;
+}
+
+ +

+Prospect +

+

+We will focus on the method A() since the other methods, also main(), occur +only once respectively. +

+ + + +

+According to the above observation, we cannot help concluding that it is not +so easy to use the nested_exception handling as a tree structured exception +handling mechanism in a practical sense. +

+

+This text is based on the web page below (in Japanese). +http://d.hatena.ne.jp/wraith13/20081231/1230715424 +

+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD. The committee agrees that nested_exception is not a good +match for this usage model. The committee did not see a way of improving +this within the timeframe allowed. +
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

1139. Thread support library not concept enabled

+

Section: 30 [thread] Status: NAD Concepts + Submitter: LWG Opened: 2009-06-15 Last modified: 2010-10-23

+

View all other issues in [thread].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses US 93, JP 79, UK 333, JP 81

+ +

+The thread chapter is not concept enabled. +

+ + + +

Proposed resolution:

+ + + + + +
+

1140. Numerics library not concept enabled

+

Section: 26 [numerics] Status: NAD Concepts + Submitter: LWG Opened: 2009-06-15 Last modified: 2010-10-23

+

View all other issues in [numerics].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses US 84

+ +

+The numerics chapter is not concept enabled. +

+ +

+The portion of this comment dealing with random numbers was resolved by +N2836, +which was accepted in Summit. +

+ + + +

Proposed resolution:

+ + + + + +
+

1141. Input/Output library not concept enabled

+

Section: 27 [input.output] Status: NAD Concepts + Submitter: LWG Opened: 2009-06-15 Last modified: 2010-10-23

+

View all other issues in [input.output].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses US 85, JP 67, JP 68, JP 69, JP 72, UK 308

+ +

+The input/output chapter is not concept enabled. +

+ + + +

Proposed resolution:

+ + + + + +
+

1142. Regular expressions library not concept enabled

+

Section: 28 [re] Status: NAD Concepts + Submitter: LWG Opened: 2009-06-15 Last modified: 2010-10-23

+

View all other issues in [re].

+

View all issues with NAD Concepts status.

+

Discussion:

+ +

Addresses US 86, UK 309, UK 310

+ +

+The regular expressions chapter is not concept enabled. +

+ + + +

Proposed resolution:

+ + + + + +
+

1143. Atomic operations library not concept enabled

+

Section: 29 [atomics] Status: NAD Editorial + Submitter: LWG Opened: 2009-06-15 Last modified: 2010-10-23

+

View other active issues in [atomics].

+

View all other issues in [atomics].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses US 87, UK 311

+ +

+The atomics chapter is not concept enabled. +

+ +

+Needs to also consider issues 923 and 924. +

+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+ + + + + +
+

1145. inappropriate headers for atomics

+

Section: 29 [atomics] Status: NAD Editorial + Submitter: LWG Opened: 2009-06-16 Last modified: 2010-10-23

+

View other active issues in [atomics].

+

View all other issues in [atomics].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 312

+ +

+The contents of the <stdatomic.h> header are not listed anywhere, +and <cstdatomic> is listed as a C99 header in chapter 17. +If we intend to use these for compatibility with a future C standard, +we should not use them now. +

+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+

+Remove <cstdatomic> from the C99 headers in table 14. +Add a new header <atomic> to the headers in table 13. +Update chapter 29 to remove reference to <stdatomic.h> +and replace the use of <cstdatomic> with <atomic>. +

+

[ +If and when WG14 adds atomic operations to C +we can add corresponding headers to table 14 with a TR. +]

+ + + + + + +
+

1146. "lockfree" does not say enough

+

Section: 29.4 [atomics.lockfree] Status: NAD Editorial + Submitter: Jeffrey Yasskin Opened: 2009-06-16 Last modified: 2010-10-23

+

View all other issues in [atomics.lockfree].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses US 88

+ +

+The "lockfree" facilities do not tell the programmer enough. +

+ +

+There are 2 problems here. +First, at least on x86, +it's less important to me whether some integral types are lock free +than what is the largest type I can pass to atomic and have it be lock-free. +For example, if long longs are not lock-free, +ATOMIC_INTEGRAL_LOCK_FREE is probably 1, +but I'd still be interested in knowing whether longs are always lock-free. +Or if long longs at any address are lock-free, +I'd expect ATOMIC_INTEGRAL_LOCK_FREE to be 2, +but I may actually care whether I have access to +the cmpxchg16b instruction. +None of the support here helps with that question. +(There are really 2 related questions here: +what alignment requirements are there for lock-free access; +and what processor is the program actually running on, +as opposed to what it was compiled for?) +

+ +

+Second, having atomic_is_lock_free only apply to individual objects +is pretty useless +(except, as Lawrence Crowl points out, +for throwing an exception when an object is unexpectedly not lock-free). +I'm likely to want to use its result to decide what algorithm to use, +and that algorithm is probably going to allocate new memory +containing atomic objects and then try to act on them. +If I can't predict the lock-freedom of the new object +by checking the lock-freedom of an existing object, +I may discover after starting the algorithm that I can't continue. +

+ +

[ +2009-06-16 Jeffrey Yasskin adds: +]

+ + +
+

+To solve the first problem, I think 2 macros would help: +MAX_POSSIBLE_LOCK_FREE_SIZE and MAX_GUARANTEED_LOCK_FREE_SIZE, +which expand to the maximum value of sizeof(T) for which atomic may +(or will, respectively) use lock-free operations. +Lawrence points out that this +"relies heavily on implementations +using word-size compare-swap on sub-word-size types, +which in turn requires address modulation." +He expects that to be the end state anyway, so it doesn't bother him much. +

+ +

+To solve the second, +I think one could specify that equally aligned objects of the same type +will return the same value from atomic_is_lock_free(). +I don't know how to specify "equal alignment". +Lawrence suggests an additional function, atomic_is_always_lock_free(). +

+
+ +

[ +2009-10-22 Benjamin Kosnik: +]

+ + +
+

+In the evolution discussion of N2925, "More Collected Issues with +Atomics," there is an action item with respect to +LWG 1146, US 88 +

+ +

+This is stated in the paper as: +

+

+Relatedly, Mike Sperts will create an issue to propose adding a traits +mechanism to check the compile-time properties through a template +mechanism rather than macros +

+ +

+Here is my attempt to do this. I don't believe that a separate trait is +necessary for this, and that instead atomic_integral::is_lock_free can +be re-purposed with minimal work as follows. +

+ +

[ +Howard: Put Benjamin's wording in the proposed wording section. +]

+ + +
+ +

[ +2009-10-22 Alberto Ganesh Barbati: +]

+ + +
+

+Just a thought... wouldn't it be better to use a scoped enum instead of +plain integers? For example: +

+ +
enum class is_lock_free
+{
+    never = 0, sometimes = 1, always = 2;
+};
+
+ +

+if compatibility with C is deemed important, we could use an unscoped +enum with suitably chosen names. It would still be more descriptive +than 0, 1 and 2. +

+ +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+

+Header <cstdatomic> synopsis [atomics.synopsis] +

+ +

+Edit as follows: +

+ +
namespace std {
+...
+// 29.4, lock-free property
+#define ATOMIC_INTEGRAL_LOCK_FREE unspecified
+#define ATOMIC_CHAR_LOCK_FREE unspecified
+#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
+#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
+#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
+#define ATOMIC_SHORT_LOCK_FREE unspecified
+#define ATOMIC_INT_LOCK_FREE unspecified
+#define ATOMIC_LONG_LOCK_FREE unspecified
+#define ATOMIC_LLONG_LOCK_FREE unspecified
+#define ATOMIC_ADDRESS_LOCK_FREE unspecified
+
+ +

+Lock-free Property 29.4 [atomics.lockfree] +

+ +

+Edit the synopsis as follows. +

+ +
namespace std {
+   #define ATOMIC_INTEGRAL_LOCK_FREE unspecified
+   #define ATOMIC_CHAR_LOCK_FREE unspecified
+   #define ATOMIC_CHAR16_T_LOCK_FREE unspecified
+   #define ATOMIC_CHAR32_T_LOCK_FREE unspecified
+   #define ATOMIC_WCHAR_T_LOCK_FREE unspecified
+   #define ATOMIC_SHORT_LOCK_FREE unspecified
+   #define ATOMIC_INT_LOCK_FREE unspecified
+   #define ATOMIC_LONG_LOCK_FREE unspecified
+   #define ATOMIC_LLONG_LOCK_FREE unspecified
+   #define ATOMIC_ADDRESS_LOCK_FREE unspecified
+}
+
+ +

+Edit paragraph 1 as follows. +

+ +
+The ATOMIC_...._LOCK_FREE macros ATOMIC_INTEGRAL_LOCK_FREE and ATOMIC_ADDRESS_LOCK_FREE indicate the general lock-free +property of integral and address atomic the corresponding atomic integral types, with the +signed and unsigned variants grouped together. +The properties also apply to the corresponding specializations of the atomic template. +A value of 0 +indicates that the types are never lock-free. A value of 1 +indicates that the types are sometimes lock-free. A value of 2 +indicates that the types are always lock-free. +
+ +

+Operations on Atomic Types 29.6 [atomics.types.operations] +

+ +

+Edit as follows. +

+ +
void static constexpr bool A::is_lock_free() const volatile;
+
+
+Returns: True if the object's types's operations are lock-free, false +otherwise. + +[Note: In the same way that <limits> +std::numeric_limits<short>::max() is related to +<limits.h> __LONG_LONG_MAX__, <atomic> +std::atomic_short::is_lock_free is related to +<stdatomic.h> and ATOMIC_SHORT_LOCK_FREE — +end note] + +
+
+ + + + + + +
+

1147. non-volatile atomic functions

+

Section: 29.6 [atomics.types.operations] Status: NAD Editorial + Submitter: Jeffrey Yasskin Opened: 2009-06-16 Last modified: 2010-10-23

+

View other active issues in [atomics.types.operations].

+

View all other issues in [atomics.types.operations].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses US 90

+ +

+The C++0X draft +declares all of the functions dealing with atomics (section 29.6 [atomics.types.operations]) +to take volatile arguments. +Yet it also says (29.4-3), +

+ +
+

+[ Note: Many operations are volatile-qualified. +The "volatile as device register" semantics have not changed in the standard. +This qualification means that volatility is preserved +when applying these operations to volatile objects. +It does not mean that operations on non-volatile objects become volatile. +Thus, volatile qualified operations on non-volatile objects +may be merged under some conditions. —end note ] +

+
+ +

+I was thinking about how to implement this in gcc, +and I believe that we'll want to overload most of the functions +on volatile and non-volatile. +Here's why: +

+ +

+To let the compiler take advantage of the permission +to merge non-volatile atomic operations and reorder atomics in certain, +we'll need to tell the compiler backend +about exactly which atomic operation was used. +So I expect most of the functions of the form atomic_<op>_explicit() +(e.g. atomic_load_explicit, atomic_exchange_explicit, +atomic_fetch_add_explicit, etc.) +to become compiler builtins. +A builtin can tell whether its argument was volatile or not, +so those functions don't really need extra explicit overloads. +However, I don't expect that we'll want to add builtins +for every function in chapter 29, +since most can be implemented in terms of the _explicit free functions: +

+ +
class atomic_int {
+  __atomic_int_storage value;
+ public:
+  int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
+    // &value has type "volatile __atomic_int_storage*".
+    atomic_fetch_add_explicit(&value, increment, order);
+  }
+  ...
+};
+
+ +

+But now this always calls +the volatile builtin version of atomic_fetch_add_explicit(), +even if the atomic_int wasn't declared volatile. +To preserve volatility and the compiler's permission to optimize, +I'd need to write: +

+ +
class atomic_int {
+  __atomic_int_storage value;
+ public:
+  int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
+    atomic_fetch_add_explicit(&value, increment, order);
+  }
+  int fetch_add(int increment, memory_order order = memory_order_seq_cst) {
+    atomic_fetch_add_explicit(&value, increment, order);
+  }
+  ...
+};
+
+ +

+But this is visibly different from the declarations in the standard +because it's now overloaded. +(Consider passing &atomic_int::fetch_add as a template parameter.) +

+ +

+The implementation may already have permission to add overloads +to the member functions: +

+ +
+

+17.6.4.5 [member.functions] An implementation may declare additional non-virtual +member function signatures within a class:
+... +

+ +
+ +

+but I don't see an equivalent permission to add overloads to the free functions. +

+ +

[ +2009-06-16 Lawrence adds: +]

+ + +
+

+I recommend allowing non-volatile overloads. +

+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2992. +
+ + + +

Proposed resolution:

+ + + + + +
+

1148. Wrong argument type of I/O stream manipulators setprecision() +and setw()

+

Section: 27.7 [iostream.format] Status: NAD + Submitter: Marc Steinbach Opened: 2009-06-20 Last modified: 2010-10-23

+

View all other issues in [iostream.format].

+

View all issues with NAD status.

+

Discussion:

+

+The header <iomanip> synopsis in 27.7 [iostream.format] specifies +

+
T5 setprecision(int n);
+T6 setw(int n);
+
+ +

+The argument types should be streamsize, as in class ios_base +(see 27.5.2 [ios.base]): +

+
streamsize precision() const;
+streamsize precision(streamsize prec);
+streamsize width() const;
+streamsize width(streamsize wide);
+
+ +

+(Editorial: 'wide' should probably be renamed as 'width', or maybe just 'w'.) +

+ +

[ +2009-07-29 Daniel clarified wording. +]

+ + +

[ +2009 Santa Cruz: +]

+ + +
+

+No concensus for this change. There was some interest in doing the opposite +fix: Change the streamsize in <ios> to int. +But ultimately there was no concensus for that change either. +

+
+ + + +

Proposed resolution:

+
    +
  1. +

    +In 27.7 [iostream.format], header <iomanip> synopsis change as indicated: +

    + +
    T5 setprecision(intstreamsize n);
+T6 setw(intstreamsize n);
+
    +
    2. + +
  2. +

    +In 27.7.3 [std.manip], just before p. 6 change as indicated: +

    + +
    unspecified setprecision(intstreamsize n);
+
    +
    3. + +
  3. +

    +In 27.7.3 [std.manip], just before p. 7 change as indicated: +

    + +
    unspecified setw(intstreamsize n);
+
    +
    4. +
+ + + + + + + + +
+

1149. Reformulating NonemptyRange axiom

+

Section: X [rand.concept.urng] Status: NAD Concepts + Submitter: Walter Brown Opened: 2009-06-25 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+

+In X [rand.concept.urng], we have the following: +

+
concept UniformRandomNumberGenerator<typename G> : Callable<G> {
+  ...
+  axiom NonemptyRange(G& g) {
+    G::min() < G::max();
+  }
+  ...
+}
+
+ +

+Since the parameter G is in scope throughout the concept, there is no +need for the axiom to be further parameterized, and so the axiom can be +slightly simplified as: +

+ +
axiom NonemptyRange()  {
+  G::min() < G::max();
+}
+
+ +

+We can further reformulate so as to avoid any axiom machinery as: +

+ +
requires True< G::min() < G::max() >;
+
+ +

+This is not only a simpler statement of the same requirement, but also +forces the requirement to be checked. +

+ +

[ +Post-Rapperswil: +]

+ + +
+Moved to Tentatively Ready after 5 positive votes on c++std-lib. +
+ + +

Proposed resolution:

+

+In X [rand.concept.urng], replace the NonemptyRange axiom by: +

+ +
axiom NonemptyRange(G& g) { 
+   G::min() < G::max(); 
+}
+requires True< G::min() < G::max() >;
+
+ + + + + + +
+

1150. wchar_t, char16_t and char32_t filenames

+

Section: 27.9.1.14 [fstream] Status: NAD Future + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View all issues with NAD Future status.

+

Discussion:

+

Addresses JP 73

+ +

Description

+

It is a problem + from C++98, fstream cannot appoint a filename of wide + character string(const wchar_t and const wstring&).

+

Suggestion

+

Add + interface corresponding to wchar_t, char16_t and char32_t.

+ +

[ +2009-07-01 Alisdair notes that this is a duplicate of 454 which has more +in-depth rationale. +]

+ + +

[ +2009-09-21 Daniel adds: +]

+ + +
+I suggest to mark this issue as NAD Future with the intend to +solve the issue with a single file path c'tor template assuming +a provision of a TR2 filesystem library. +
+ +

[ +2009 Santa Cruz: +]

+ + +
+NAD Future. This is a duplicate of 454. +
+ + + +

Proposed resolution:

+ + + + + +
+

1153. Standard library needs review for constructors to be +explicit to avoid treatment as initializer-list constructor

+

Section: 17 [library], 30 [thread], D [depr] Status: NAD + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses DE 2

+ +

Description

+

Marking a constructor with explicit has semantics + even for a constructor with zero or several parameters: + Such a constructor cannot be used with list-initialization + in a copy-initialization context, see 13.3.1.7 [over.match.list]. The + standard library apparently has not been reviewed for + marking non-single-parameter constructors as explicit.

+

Suggestion

+

Consider marking zero-parameter and multi-parameter + constructors explicit in classes that have at least one + constructor marked explicit and that do not have an + initializer-list constructor.

+ +

Notes

+

Robert Klarer to address this one.

+ +

[ +2009 Santa Cruz: +]

+ + +
+Move to "Open". Robert Klarer has promised to provide wording. +
+ +

[ +2010 Pittsburgh: Moved to NAD, rationale added below. +]

+ + + + +

Rationale:

+

+We are unaware of any cases where initializer lists cause problem in this +context, but if problems arise in the future the issue can be reopened. +

+ + +

Proposed resolution:

+ + + + + +
+

1154. complex should accept integral types

+

Section: 26.4 [complex.numbers] Status: NAD Future + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View all other issues in [complex.numbers].

+

View all issues with NAD Future status.

+

Discussion:

+ +

Addresses FR 35

+ +

Description

+

Instantiations of the class + template complex<> have to be allowed for integral + types, to reflect existing practice and ISO standards + (LIA-III).

+ +

Suggestion

+ +

[ +2009-10-26 Proposed wording in +N3002. +]

+ + +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Future. Rationale added. +
+ + + +

Rationale:

+

+There is no consensus for making this change at this time. +

+ + +

Proposed resolution:

+Adopt +N3002. + + + + + +
+

1155. Reference should be to C99

+

Section: C.2 [diff.library] Status: NAD Editorial + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View all other issues in [diff.library].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses FR 38

+ +

Description

+

What is ISO/IEC 1990:9899/DAM + 1? My guess is that's a typo for ISO/IEC + 9899/Amd.1:1995 which I'd + have expected to be referenced here (the tables + make reference to things + which were introduced by Amd.1).

+

Suggestion

+

One need probably a reference + to the document which introduce char16_t and + char32_t in C (ISO/IEC TR 19769:2004?).

+

Notes

+

Create issue. Document in question should be C99, not C90+amendment1. The + rest of the section requires careful review for completeness. Example <cstdint> + 18.4.1 [cstdint.syn]. Assign to C liasons.

+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Already fixed. +
+ + + +

Proposed resolution:

+ + + + + +
+

1156. Constraints on bitmask and enumeration types to be tightened

+

Section: 17.5.2.1.2 [enumerated.types], 17.5.2.1.3 [bitmask.types] Status: NAD + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses UK 165

+ +

Description

+

Constraints on + bitmask and enumeration types were supposed to be tightened + up as part of the motivation for the constexpr feature - + see paper + N2235 + for details

+

Suggestion

+

Adopt wording in line with the motivation + described in + N2235

+

Notes

+

Robert Klarer to review

+ +

[ +2009 Santa Cruz: +]

+ + +
+Move to Open. Ping Robert Klarer to provide wording, using N2235 as +guidance. +
+ +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD. Rationale added. +
+ + + +

Rationale:

+

+UK NB did not sufficiently describe how to resolve their comment, and +therefore we cannot make a change for the FCD. If a resolution were +provided in the future, we would be happy to apply it. +

+ + +

Proposed resolution:

+ + + + + +
+

1160. future_error public constructor is 'exposition only'

+

Section: 30.6.3 [futures.future_error] Status: NAD Editorial + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 331

+ +

Description

+

Not clear what + it means for a public constructor to be 'exposition only'. + If the intent is purely to support the library calling this + constructor then it can be made private and accessed + through friendship. Otherwise it should be documented for + public consumption.

+

Suggestion

+

Declare the constructor as private with a + note about intended friendship, or remove the + exposition-only comment and document the semantics.

+

Notes

+

Create an issue. Assigned to Detlef. Suggested resolution probably makes + sense.

+ +

[ +2009-07 Frankfurt +]

+ + +
+Pending a paper from Anthony Williams / Detleff Volleman. +
+ +

[ +2009-10-14 Pending paper: +N2967. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2997. +
+ + + +

Proposed resolution:

+ + + + + +
+

1161. Unnecessary unique_future limitations

+

Section: 30.6.6 [futures.unique_future] Status: NAD Editorial + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View all other issues in [futures.unique_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 336

+ +

Description

+ +

It is possible + to transfer ownership of the asynchronous result from one + unique_future instance to another via the move-constructor. + However, it is not possible to transfer it back, and nor is + it possible to create a default-constructed unique_future + instance to use as a later move target. This unduly limits + the use of unique_future in code. Also, the lack of a + move-assignment operator restricts the use of unique_future + in containers such as std::vector - vector::insert requires + move-assignable for example.

+

Suggestion

+

Add a default constructor with the + semantics that it creates a unique_future with no + associated asynchronous result. Add a move-assignment + operator which transfers ownership.

+

Notes

+

Create an issue. Detlef will look into it.

+ +

[ +2009-07 Frankfurt +]

+ + +
+Pending a paper from Anthony Williams / Detleff Volleman. +
+ +

[ +2009-10-14 Pending paper: +N2967. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2997. +
+ + + +

Proposed resolution:

+ + + + + +
+

1162. shared_future should support an efficient move constructor

+

Section: 30.6.7 [futures.shared_future] Status: NAD Editorial + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View all other issues in [futures.shared_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 337

+ +

Description

+

shared_future + should support an efficient move constructor that can avoid + unnecessary manipulation of a reference count, much like + shared_ptr

+

Suggestion

+

Add a move constructor

+

Notes

+

Create an issue. Detlef will look into it.

+ +

[ +2009-07 Frankfurt +]

+ + +
+Pending a paper from Anthony Williams / Detleff Volleman. +
+ +

[ +2009-10-14 Pending paper: +N2967. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2997. +
+ + + +

Proposed resolution:

+ + + + + +
+

1163. shared_future is inconsistent with shared_ptr

+

Section: 30.6.7 [futures.shared_future] Status: NAD Editorial + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View all other issues in [futures.shared_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 338

+ +

Description

+ +

shared_future is currently + CopyConstructible, but not CopyAssignable. This is + inconsistent with shared_ptr, and will surprise users. + Users will then write work-arounds to provide this + behaviour. We should provide it simply and efficiently as + part of shared_future. Note that since the shared_future + member functions for accessing the state are all declared + const, the original usage of an immutable shared_future + value that can be freely copied by multiple threads can be + retained by declaring such an instance as "const + shared_future".

+

Suggestion

+

Remove "=delete" + from the copy-assignment operator of shared_future. Add a + move-constructor shared_future(shared_future&& + rhs), and a move-assignment operator shared_future& + operator=(shared_future&& rhs). The postcondition + for the copy-assignment operator is that *this has the same + associated state as rhs. The postcondition for the + move-constructor and move assignment is that *this has the + same associated as rhs had before the + constructor/assignment call and that rhs has no associated + state.

+

Notes

+

Create an issue. Detlef will look into it.

+ +

[ +2009-07 Frankfurt +]

+ + +
+Pending a paper from Anthony Williams / Detleff Volleman. +
+ +

[ +2009-10-14 Pending paper: +N2967. +]

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2997. +
+ + + +

Proposed resolution:

+ + + + + +
+

1164. promise::swap should pass by rvalue reference

+

Section: 30.6.5 [futures.promise] Status: NAD + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View other active issues in [futures.promise].

+

View all other issues in [futures.promise].

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses UK 341

+ +

Description

+

promise::swap accepts its parameter by lvalue reference. This is +inconsistent with other types that provide a swap member function, +where those swap functions accept an rvalue reference

+ +

Suggestion

+

Change promise::swap to take an rvalue reference.

+ +

Notes

+

Create an issue. Detlef will look into it. Probably ready as it.

+ +

[ +2009-07 Frankfurt +]

+ + +
+NAD, by virtue of the changed rvalue rules and swap signatures from Summit. +
+ + + +

Proposed resolution:

+ + + + + +
+

1165. Unneeded promise move constructor

+

Section: 30.6.5 [futures.promise] Status: NAD Editorial + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View other active issues in [futures.promise].

+

View all other issues in [futures.promise].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses UK 343

+ +

Description

+

The move constructor of a std::promise + object does not need to allocate any memory, so the + move-construct-with-allocator overload of the constructor + is superfluous.

+

Suggestion

+

Remove the + constructor with the signature template <class + Allocator> promise(allocator_arg_t, const Allocator& + a, promise& rhs);

+

Notes

+

Create an issue. Detlef will look into it. Will solicit feedback from Pablo. + Note that “rhs” argument should also be an rvalue reference in any case.

+ +

[ +2009-07 Frankfurt +]

+ + +
+Pending a paper from Anthony Williams / Detleff Volleman. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Solved by +N2997. +
+ + + +

Proposed resolution:

+ + + + + +
+

1166. Allocator-specific move/copy break model of move-constructor and + move-assignment

+

Section: X [allocator.propagation], X [allocator.propagation.map], 23 [containers] Status: NAD Editorial + Submitter: LWG Opened: 2009-06-28 Last modified: 2010-10-23

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

Addresses US 77

+ +

Description

+

Allocator-specific move and copy behavior for containers + (N2525) complicates a little-used and already-complicated + portion of the standard library (allocators), and breaks + the conceptual model of move-constructor and + move-assignment operations on standard containers being + efficient operations. The extensions for allocator-specific + move and copy behavior should be removed from the working + paper.

+

With the + introduction of rvalue references, we are teaching + programmers that moving from a standard container (e.g., a + vector<string>) is an efficient, constant-time + operation. The introduction of N2525 removed that + guarantee; depending on the behavior of four different + traits (20.8.4), the complexity of copy and move operations + can be constant or linear time. This level of customization + greatly increases the complexity of standard containers, + and benefits only a tiny fraction of the C++ community.

+

Suggestion

+ +

Remove 20.8.4.

+ +

Remove 20.8.5.

+ +

Remove all references to the facilities in + 20.8.4 and 20.8.5 from clause 23.

+ + +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Addressed by +N2982. +
+ + + +

Proposed resolution:

+ + + + + +
+

1167. pair<T,U> doesn't model LessThanComparable in unconstrained code even if + T and U do.

+

Section: 20.3.5 [pairs] Status: NAD Concepts + Submitter: Dave Abrahams Opened: 2009-07-01 Last modified: 2010-10-23

+

View all other issues in [pairs].

+

View all issues with NAD Concepts status.

+

Discussion:

+

+LessThanComparable requires (and provides default + implementations for) <=,>, and >=. However, the defaults + don't take effect in unconstrained code. +

+

+Still, it's a problem to have types acting one way in +constrained code and another in unconstrained code, except in cases of +syntax adaptation. It's also inconsistent with the containers, which +supply all those operators. +

+

+Totally Unbiased +Suggested Resolution: +

+

+accept the exported concept maps proposal and + change the way this stuff is handled to use an + explicit exported concept map rather than nested + function templates +

+

+e.g., remove from the body of std::list +

+
template <LessThanComparable T, class Allocator> 
+bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y); 
+template <LessThanComparable T, class Allocator> 
+bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y); 
+template <LessThanComparable T, class Allocator> 
+bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y); 
+template <LessThanComparable T, class Allocator> 
+bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y); 
+
+

+and add this concept_map afterwards: +

+
template <LessThanComparable T, class Allocator> 
+export concept_map LessThanComparable<list<T,Allocator> >
+{
+    bool operator<(const list<T,Allocator>& x, const list<T,Allocator>& y);
+}
+
+

+do similarly for std::pair. While you're at it, do the same for +operator== and != everywhere, and seek out other such opportunities. +

+

+Alternative Resolution: keep the ugly, complex specification and add the + missing operators to std::pair. +

+ + +

Proposed resolution:

+ + + + + +
+

1168. Odd wording for bitset equality operators

+

Section: 20.5.2 [bitset.members] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-07-02 Last modified: 2010-10-23

+

View all other issues in [bitset.members].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The following wording seems a little unusual to me: +

+

+p42/43 20.5.2 [bitset.members] +

+ +
+
bool operator==(const bitset<N>& rhs) const;
+
+
+-42- Returns: A nonzero value if the value of each bit in +*this equals the value of the corresponding bit in +rhs. +
+
bool operator!=(const bitset<N>& rhs) const;
+
+
+-43- Returns: A nonzero value if !(*this == rhs). +
+
+ +

+"A nonzero value" may be well defined as equivalent to the literal 'true' +for Booleans, but the wording is clumsy. I suggest replacing "A nonzero value" +with the literal 'true' (in appropriate font) in each case. +

+ +

[ +2009-07-24 Alisdair recommends NAD Editorial. +]

+ + +

[ +2009-07-27 Pete adds: +]

+ + +
+It's obviously editorial. There's no need for further discussion. +
+ +

[ +2009-07-27 Howard sets to NAD Editorial. +]

+ + + + +

Proposed resolution:

+

+Change 20.5.2 [bitset.members] p42-43: +

+ +
+
bool operator==(const bitset<N>& rhs) const;
+
+
+-42- Returns: A nonzero value true if the value of each bit in +*this equals the value of the corresponding bit in +rhs. +
+
bool operator!=(const bitset<N>& rhs) const;
+
+
+-43- Returns: A nonzero value true if !(*this == rhs). +
+
+ + + + + + +
+

1172. select_on_container_(copy|move)_construction over-constrained

+

Section: X [allocator.concepts.members] Status: NAD Editorial + Submitter: Alberto Ganesh Barbati Opened: 2009-07-08 Last modified: 2010-10-23

+

View all issues with NAD Editorial status.

+

Discussion:

+

+I believe the two functions +select_on_container_(copy|move)_construction() are over-constrained. For +example, the return value of the "copy" version is (see +X [allocator.concepts.members]/21): +

+
+Returns: x if the allocator should propagate from the existing +container to the new container on copy construction, otherwise X(). +
+

+Consider the case where a user decides to provide an explicit concept +map for Allocator to adapt some legacy allocator class, as he wishes to +provide customizations that the LegacyAllocator concept map template +does not provide. Now, although it's true that the legacy class is +required to have a default constructor, the user might have reasons to +prefer a different constructor to implement +select_on_container_copy_construction(). However, the current wording +requires the use of the default constructor. +

+

+Moreover, it's not said explicitly that x is supposed to be the +allocator of the existing container. A clarification would do no harm. +

+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Editorial. Addressed by +N2982. +
+ + + +

Proposed resolution:

+

+Replace X [allocator.concepts.members]/21 with: +

+ +
X select_on_container_copy_construction(const X& x);
+
+

+-21- Returns: x if the allocator should propagate from the existing +container to the new container on copy construction, otherwise X(). +an allocator object to be used by the new container on copy +construction. [Note: x is the allocator of the existing container that +is being copied. The most obvious choices for the return value are x, if +the allocator should propagate from the existing container, and X(). +— end note] +

+
+ +

+Replace X [allocator.concepts.members]/25 with: +

+ +
X select_on_container_move_construction(X&& x);
+
+

+-25- Returns: move(x) if the allocator should propagate from the existing +container to the new container on move construction, otherwise X(). +an allocator object to be used by the new container on move +construction. [Note: x is the allocator of the existing container that +is being moved. The most obvious choices for the return value are move(x), if +the allocator should propagate from the existing container, and X(). +— end note] +

+
+ + + + + + +
+

1173. "Equivalence" wishy-washiness

+

Section: 17 [library] Status: NAD Future + Submitter: David Abrahams Opened: 2009-07-14 Last modified: 2010-11-24

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD Future status.

+

Discussion:

+

+Issue: The CopyConstructible requirements are wishy-washy. It requires +that the copy is "equivalent" to the original, but "equivalent" is never +defined. +

+

+I believe this to be an example of a more general lack of rigor around +copy and assignment, although I haven't done the research to dig up all +the instances. +

+

+It's a problem because if you don't know what CopyConstructible means, +you also don't know what it means to copy a pair of CopyConstructible +types. It doesn't prevent us from writing code, but it is a hole in our +ability to understand the meaning of copy. +

+

+Furthermore, I'm pretty sure that vector's copy constructor doesn't +require the elements to be EqualityComparable, so that table is actually +referring to some ill-defined notion of equivalence when it uses ==. +

+ +

[ +2009 Santa Cruz: +]

+ + +
+Move to "Open". Dave is right that this is a big issue. Paper D2987 +("Defining Move Special Member Functions", Bjarne Stroustrup and +Lawrence Crowl) touches on this but does not solve it. This issue is +discussed in Elements of Programming. +
+ + +

[ +2010 Rapperswil: +]

+ + +
+This issue is quite vague, so it is difficult to know if and when it has been resolved. + +John Lakos wrote a paper covering this area a while back, and there is a real interest in providing some sort of clean-up in the future. + +We need a more clearly draughted issues with an addressable set of concerns, ideally with a paper proposing a resolution, but for a future revision of the standard. + +Move to Tentatively NAD Future. +
+ +

[ +Moved to NAD Future at 2010-11 Batavia +]

+ + + + +

Proposed resolution:

+ + + + + +
+

1176. Make thread constructor non-variadic

+

Section: 30.3.1.2 [thread.thread.constr] Status: NAD + Submitter: Howard Hinnant Opened: 2009-07-18 Last modified: 2010-10-23

+

View all other issues in [thread.thread.constr].

+

View all issues with NAD status.

+

Discussion:

+

+The variadic thread constructor is causing controversy, e.g. +N2901. +This issue has been created as a placeholder for this course of action. +

+ +
template <class F, class ...Args> thread(F&& f, Args&&... args);
+
+ +

+See 929 for wording which specifies an rvalue-ref signature but +with "decay behavior", but using variadics. +

+ +

[ +2009-11-17 Moved to Tentatively NAD after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + + +

Proposed resolution:

+

+

+ + +

Rationale:

+

+The (tentative) concensus of the LWG is to keep the variadic thread constructor. +

+ + + + + +
+

1179. Probably editorial in [structure.specifications]

+

Section: 17.5.1.4 [structure.specifications] Status: NAD Editorial + Submitter: Robert Klarer Opened: 2009-07-21 Last modified: 2010-10-23

+

View all other issues in [structure.specifications].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+While reviewing 971 I noted that 17.5.1.4 [structure.specifications]/7 says: +

+ +
+-7- Error conditions specify conditions where a function may fail. The +conditions are listed, together with a suitable explanation, as the enum +class errc constants (19.5) that could be used as an argument to +function make_error_condition (19.5.3.6). +
+ +

+This paragraph should mention make_error_code or the text "that +could be used as an argument to function make_error_condition +(19.5.3.6)" should be deleted. I believe this is editorial. +

+ +

[ +2009-07-21 Chris adds: +]

+ + +
+

+I'm not convinced there's a problem there, because as far as the "Error +conditions" clauses are concerned, make_error_condition() is used by a +user to test for the condition, whereas make_error_code is not. For +example: +

+ +
void foobar(error_code& ec = throws());
+
+ +

+ Error conditions: +

+
+permission_denied - Insufficient privilege to perform operation. +
+ +

+When a user writes: +

+ +
error_code ec;
+foobar(ec);
+if (ec == errc::permission_denied)
+   ...
+
+ +

+the implicit conversion errc->error_condition makes the if-test +equivalent to: +

+ +
if (ec == make_error_condition(errc::permission_denied))
+
+ +

+On the other hand, if the user had written: +

+ +
if (ec == make_error_code(errc::permission_denied))
+
+ +

+the test is now checking for a specific error code. The test may +evaluate to false even though foobar() failed due to the documented +error condition "Insufficient privilege". +

+
+ +

[ +2009 Santa Cruz: +]

+ + +
+

+NAD Editorial. +

+

+What the WP says right now is literally true: these codes can be used as +an argument to make_error_condition. (It is also true that they can be +used as an argument to make_error_code, which the WP doesn't say.) Maybe +it would be clearer to just delete "that could be used as an argument to +function make_error_condition", since that fact is already implied by +other things that we say. We believe that this is editorial. +

+
+ + + +

Proposed resolution:

+

+

+ + + + + +
+

1184. Feature request: dynamic bitset

+

Section: 23.4.1 [vector] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2009-07-29 Last modified: 2010-10-23

+

View all other issues in [vector].

+

View all issues with NAD Future status.

+

Discussion:

+

+Opened at Alisdair's request, steming from 96. +Alisdair recommends NAD Future. +

+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Future. We want a heap allocated bitset, but we don't have one today and +don't have time to add one. +
+ + + +

Proposed resolution:

+ + + + + +
+

1185. iterator categories and output iterators

+

Section: 24.2 [iterator.requirements] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-07-31 Last modified: 2010-10-23

+

View all other issues in [iterator.requirements].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+(wording relative to +N2723 +pending new working paper) +

+ +

+According to p3 24.2 [iterator.requirements], Forward iterators, +Bidirectional iterators and Random Access iterators all satisfy the +requirements for an Output iterator: +

+ +
+XXX iterators satisfy all the requirements of the input and output iterators +and can be used whenever either kind is specified ... +
+ +

+Meanwhile, p4 goes on to contradict this: +

+ +
+Besides its category, a forward, bidirectional, or random access +iterator can also be mutable or constant... +
+ +
+... Constant iterators do not satisfy the requirements for output iterators +
+ +

+The latter seems to be the overriding concern, as the iterator tag +hierarchy does not define forward_iterator_tag as multiply derived from +both input_iterator_tag and output_iterator_tag. +

+ +

+The work on concepts for iterators showed us that output iterator really +is fundamentally a second dimension to the iterator categories, rather +than part of the linear input -> forward -> bidirectional -> +random-access sequence. It would be good to clear up these words to +reflect that, and separately list output iterator requirements in the +requires clauses for the appropriate algorithms and operations. +

+ +

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

+ + + + +

Rationale:

+

+Solved by +N3066. +

+ + +

Proposed resolution:

+ + + + + +
+

1186. Forward list could model a stack

+

Section: 23.5.3 [stack] Status: NAD Concepts + Submitter: Alisdair Meredith Opened: 2009-07-31 Last modified: 2010-10-23

+

View all issues with NAD Concepts status.

+

Discussion:

+

+The library template forward_list could easily model the idea of a +stack, where the operations work on the front of the list rather than +the back. However, the standard library stack adaptor cannot support +this. +

+ +

+It would be relatively easy to write a partial specialization for stack +to support forward_list, but that opens the question of which header to +place it in. A much better solution would be to add a concept_map for +the StackLikeContainer concept to the <forward_list> header and then +everything just works, including a user's own further uses in a +stack-like context. +

+ +

+Therefore while I am submitting the issue now so that it is on record, I +strongly recommend we resolve as "NAD Concepts" as any non-concepts +based solution will be inferior to the final goal, and the feature is +not so compelling it must be supported ahead of the concepts-based +library. +

+ +

[ +2009-11-02 Howard adds: +]

+ + +
+Moved to Tentatively NAD Concepts after 5 positive votes on c++std-lib. +
+ + +

Rationale:

+

+Any non-concepts based solution will be inferior to the final goal, and the +feature is not so compelling it must be supported ahead of the concepts-based +library. +

+ + + +

Proposed resolution:

+ + + + + +
+

1188. Unordered containers should have a minimum load factor as well as a maximum

+

Section: 23.2.5 [unord.req], 23.7 [unord] Status: NAD Future + Submitter: Matt Austern Opened: 2009-08-10 Last modified: 2010-11-24

+

View other active issues in [unord.req].

+

View all other issues in [unord.req].

+

View all issues with NAD Future status.

+

Discussion:

+

+Unordered associative containers have a notion of a maximum load factor: +when the number of elements grows large enough, the containers +automatically perform a rehash so that the number of elements per bucket +stays below a user-specified bound. This ensures that the hash table's +performance characteristics don't change dramatically as the size +increases. +

+ +

+For similar reasons, Google has found it useful to specify a minimum +load factor: when the number of elements shrinks by a large enough, the +containers automatically perform a rehash so that the number of elements +per bucket stays above a user-specified bound. This is useful for two +reasons. First, it prevents wasting a lot of memory when an unordered +associative container grows temporarily. Second, it prevents amortized +iteration time from being arbitrarily large; consider the case of a hash +table with a billion buckets and only one element. (This was discussed +even before TR1 was published; it was TR issue 6.13, which the LWG +closed as NAD on the grounds that it was a known design feature. +However, the LWG did not consider the approach of a minimum load +factor.) +

+ +

+The only interesting question is when shrinking is allowed. In principle +the cleanest solution would be shrinking on erase, just as we grow on +insert. However, that would be a usability problem; it would break a +number of common idioms involving erase. Instead, Google's hash tables +only shrink on insert and rehash. +

+ +

+The proposed resolution allows, but does not require, shrinking in +rehash, mostly because a postcondition for rehash that involves the +minimum load factor would be fairly complicated. (It would probably have +to involve a number of special cases and it would probably have to +mention yet another parameter, a minimum bucket count.) +

+ +

+The current behavior is equivalent to a minimum load factor of 0. If we +specify that 0 is the default, this change will have no impact on +backward compatibility. +

+ + +

[ +2010 Rapperswil: +]

+ + +
+This seems to a useful extension, but is too late for 0x. + +Move to Tentatively NAD Future. +
+ +

[ +Moved to NAD Future at 2010-11 Batavia +]

+ + + + +

Proposed resolution:

+

+Add two new rows, and change rehash's postcondition in the unordered +associative container requirements table in 23.2.5 [unord.req]: +

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Table 87 — Unordered associative container requirements +(in addition to container)
ExpressionReturn typeAssertion/note pre-/post-conditionComplexity
+a.min_load_factor() + +float + +Returns a non-negative number that the container attempts to keep the +load factor greater than or equal to. The container automatically +decreases the number of buckets as necessary to keep the load factor +above this number. + +constant +
a.min_load_factor(z)voidPre: z shall be non-negative. Changes the container's minimum +load factor, using z as a hint. [Footnote: the minimum +load factor should be significantly smaller than the maximum. +If z is too large, the implementation may reduce it to a more sensible value.] + +constant +
a.rehash(n)void +Post: a.bucket_count() >= n, and a.size() <= a.bucket_count() +* a.max_load_factor(). [Footnote: It is intentional that the +postcondition does not mention the minimum load factor. +This member function is primarily intended for cases where the user knows +that the container's size will increase soon, in which case the container's +load factor will temporarily fall below a.min_load_factor().] + +a.bucket_cout > a.size() / a.max_load_factor() and a.bucket_count() +>= n. + + +Average case linear in a.size(), worst case quadratic. +
+
+ +

+Add a footnote to 23.2.5 [unord.req] p12: +

+ +
+

+The insert members shall not affect the validity of references to +container elements, but may invalidate all iterators to the container. +The erase members shall invalidate only iterators and references to the +erased elements. +

+ +
+[A consequence of these requirements is that while insert may change the +number of buckets, erase may not. The number of buckets may be reduced +on calls to insert or rehash.] +
+
+ +

+Change paragraph 13: +

+ +
+The insert members shall not affect the validity of iterators if +(N+n) < z * B zmin * B <= (N+n) <= zmax * B, +where N is the number of elements in +the container prior to the insert operation, n is the number of +elements inserted, B is the container's bucket count, +zmin is the container's minimum load factor, +and zmax is the container's maximum load factor. +
+ +

+Add to the unordered_map class synopsis in section 23.7.1 [unord.map], +the unordered_multimap class synopsis +in 23.7.2 [unord.multimap], the unordered_set class synopsis in +23.7.3 [unord.set], and the unordered_multiset class synopsis +in 23.7.4 [unord.multiset]: +

+ +

+float min_load_factor() const;
+void min_load_factor(float z);
+
+ +

+In 23.7.1.1 [unord.map.cnstr], 23.7.2.1 [unord.multimap.cnstr], 23.7.3.1 [unord.set.cnstr], and +23.7.4.1 [unord.multiset.cnstr], change: +

+ +
+... max_load_factor() returns 1.0 and +min_load_factor() returns 0. +
+ + + + + +
+

1190. Setting the maximum load factor should return the previous value

+

Section: 23.2.5 [unord.req], 23.7 [unord] Status: NAD + Submitter: Matt Austern Opened: 2009-08-10 Last modified: 2010-11-24

+

View other active issues in [unord.req].

+

View all other issues in [unord.req].

+

View all issues with NAD status.

+

Discussion:

+

+The unordered associative container requirements table specifies that +a.set_max_load_factor(z) has return type void. However, there is a +useful piece of information to return: the previous value. Users who +don't need it can always ignore it. +

+ + +

[ +2010 Rapperswil: +]

+ + +
+The benefit seems minor, while breaking with the getter/setter idiom these overloads support. + +Move to Tentatively NAD. +
+ +

[ +Moved to NAD at 2010-11 Batavia +]

+ + + + +

Proposed resolution:

+

+In the unordered associative container requirements table, change: +

+ +
+ + + + + + + + + + + + + + + +
Table 87 — Unordered associative container requirements +(in addition to container)
ExpressionReturn typeAssertion/note pre-/post-conditionComplexity
a.max_load_factor(z)void floatPre: z shall be positive. Changes the container's maximum +load load factor, using z as a hint. +Returns: the previous value of +a.max_load_factor(). + +constant +
+
+ +

+Change the return type of set_max_load_factor +in the class synopses in 23.7.1 [unord.map], 23.7.2 [unord.multimap], 23.7.3 [unord.set], +and 23.7.4 [unord.multiset]. +

+ +

+If issue 1188 is also accepted, make the same changes for +min_load_factor. +

+ + + + + +
+

1196. move semantics undefined for priority_queue

+

Section: 23.5.2.1 [priqueue.cons] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-08-19 Last modified: 2010-10-23

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The class template priority_queue declares signatures for a move +constructor and move assignment operator in its class definition. +However, it does not provide a definition (unlike std::queue, and +proposed resolution for std::stack.) Nor does it provide a text clause +specifying their behaviour. +

+ +

[ +2009-08-23 Daniel adds: +]

+ + +
+1194 provides wording that solves this issue. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark NAD Editorial, solved by issue 1194. +
+ + + +

Proposed resolution:

+ + + + + +
+

1200. "surprising" char_traits<T>::int_type requirements

+

Section: 21.2.2 [char.traits.typedefs] Status: NAD + Submitter: Sean Hunt Opened: 2009-09-03 Last modified: 2010-11-24

+

View all other issues in [char.traits.typedefs].

+

View all issues with NAD status.

+

Discussion:

+

+The footnote for int_type in 21.2.2 [char.traits.typedefs] says that +

+ +
+If eof() +can be held in char_type then some iostreams implementations may give +surprising results. +
+ +

+This implies that int_type should be a superset of +char_type. However, the requirements for char16_t and char32_t define +int_type to be equal to int_least16_t and int_least32_t respectively. +int_least16_t is likely to be the same size as char_16_t, which may lead +to surprising behavior, even if eof() is not a valid UTF-16 code unit. +The standard should not prescribe surprising behavior, especially +without saying what it is (it's apparently not undefined, just +surprising). The same applies for 32-bit types. +

+ +

+I personally recommend that behavior be undefined if eof() is a member +of char_type, and another type be chosen for int_type (my personal +favorite has always been a struct {bool eof; char_type c;}). +Alternatively, the exact results of such a situation should be defined, +at least so far that I/O could be conducted on these types as long as +the code units remain valid. Note that the argument that no one streams +char16_t or char32_t is not really valid as it would be perfectly +reasonable to use a basic_stringstream in conjunction with UTF character +types. +

+ +

[ +2009-10-28 Ganesh provides two possible resolutions and expresses a preference +for the second: +]

+ + +
+
    +
  1. +

    +Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with: +

    + +
    +The member eof() shall return an implementation-defined +constant that cannot appear as a valid UTF-16 code unit +UINT_LEAST16_MAX [Note: this value is guaranteed to +be a permanently reserved UCS-2 code position if UINT_LEAST16_MAX == +0xFFFF and it's not a UCS-2 code position otherwise — end +note]. +
    + +

    +Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with: +

    + +
    +The member eof() shall return an implementation-defined constant that +cannot appear as a Unicode code point + +UINT_LEAST32_MAX [Note: this value is guaranteed to be a +permanently reserved UCS-4 code position if UINT_LEAST32_MAX == +0xFFFFFFFF and it's not a UCS-4 code position otherwise — end +note]. +
    +
    2. +
  2. +

    +In 21.2.3.2 [char.traits.specializations.char16_t], in the +definition of char_traits<char16_t> replace the definition of nested +typedef int_type with: +

    + +
    namespace std {
+  template<> struct char_traits<char16_t> {
+    typedef char16_t         char_type;
+    typedef uint_least16_t uint_fast16_t int_type;
+     ...
+
    + +

    +Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with: +

    + +
    +The member eof() shall return an implementation-defined +constant that cannot appear as a valid UTF-16 code unit +UINT_FAST16_MAX [Note: this value is guaranteed to +be a permanently reserved UCS-2 code position if UINT_FAST16_MAX == +0xFFFF and it's not a UCS-2 code position otherwise — end +note]. +
    + +

    +In 21.2.3.3 [char.traits.specializations.char32_t], in the +definition of char_traits<char32_t> replace the definition of nested +typedef int_type with: +

    + +
    namespace std {
+  template<> struct char_traits<char32_t> {
+    typedef char32_t         char_type;
+    typedef uint_least32_t uint_fast32_t int_type;
+     ...
+
    + +

    +Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with: +

    + +
    +The member eof() shall return an implementation-defined constant that +cannot appear as a Unicode code point + +UINT_FAST32_MAX [Note: this value is guaranteed to be a +permanently reserved UCS-4 code position if UINT_FAST32_MAX == +0xFFFFFFFF and it's not a UCS-4 code position otherwise — end +note]. +
    +
    3. +
+
+ + +

[ +2010 Rapperswil: +]

+ + +
+This seems an overspecification, and it is not clear what problem is being solved - these values can be used portably by using the named functions; there is no need for the value itself to be portable. + +Move to Tentatively NAD. +
+ +

[ +Moved to NAD at 2010-11 Batavia +]

+ + + + +

Proposed resolution:

+

+

+ + + + + +
+

1201. Do we always want to unwrap ref-wrappers in make_tuple

+

Section: 20.4.2.4 [tuple.creation], 20.3.5 [pairs] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2009-09-05 Last modified: 2010-10-23

+

View all other issues in [tuple.creation].

+

View all issues with NAD Future status.

+

Discussion:

+

+Spotting a recent thread on the boost lists regarding collapsing +optional representations in optional<optional<T>> instances, I wonder if +we have some of the same issues with make_tuple, and now make_pair? +

+ +

+Essentially, if my generic code in my own library is handed a +reference_wrapper by a user, and my library in turn delegates some logic +to make_pair or make_tuple, then I am going to end up with a pair/tuple +holding a real reference rather than the intended reference wrapper. +

+ +

+There are two things as a library author I can do at this point: +

+ +
    +
  1. +document my library also has the same reference-wrapper behaviour as +std::make_tuple +
    2. +
  2. +roll my own make_tuple that does not unwrap rereferences, a lost +opportunity to re-use the standard library. +
    3. +
+ +

+(There may be some metaprogramming approaches my library can use to wrap +the make_tuple call, but all will be significantly more complex than +simply implementing a simplified make_tuple.) +

+ +

+Now I don't propose we lose this library facility, I think unwrapping +references will be the common behaviour. However, we might want to +consider adding another overload that does nothing special with +ref-wrappers. Note that we already have a second overload of make_tuple +in the library, called tie. +

+ +

[ +2009-09-30 Daniel adds: +]

+ + +
+

+I suggest to change the currently proposed paragraph for +make_simple_pair +

+ +
template<typename... Types>
+  pair<typename decay<Types>::type...> make_simple_pair(Types&&... t);
+
+
+

+Type requirements: sizeof...(Types) == 2. +Remarks: The program shall be ill-formed, if +sizeof...(Types) != 2. +

+

+... +

+
+
+ +

+or alternatively (but with a slightly different semantic): +

+ +
+
+Remarks: If sizeof...(Types) != 2, this function shall not +participate in overload resolution. +
+
+ +

+to follow a currently introduced style and because the library does +not have yet a specific "Type requirements" element. If such thing +would be considered as useful this should be done as a separate +issue. Given the increasing complexity of either of these wordings +it might be preferable to use the normal two-argument-declaration +style again in either of the following ways: +

+ +
    +
  1. +
    template<class T1, class T2>
+pair<typename decay<T1>::type, typename decay<T2>::type>
+make_simple_pair(T1&& t1, T2&& t2);
+
    +
    2. +
  2. +
    template<class T1, class T2>
+pair<V1, V2> make_simple_pair(T1&& t1, T2&& t2);
+
    +
    +Let V1 be typename decay<T1>::type and V2 be +typename decay<T2>::type. +
    +
    3. +
+ +
+ +

[ +2009-10 post-Santa Cruz: +]

+ + +
+Mark as Tentatively NAD Future. +
+ + + +

Rationale:

+

+Does not have sufficient support at this time. May wish to reconsider for a +future standard. +

+ + +

Proposed resolution:

+

+Add the following function to 20.3.5 [pairs] and signature in +appropriate synopses: +

+ +
template<typename... Types>
+  pair<typename decay<Types>::type...> make_simple_pair(Types&&... t);
+
+
+

+Type requirements: sizeof...(Types) == 2. +

+

+Returns: pair<typename decay<Types>::type...>(std::forward<Types>(t)...). +

+
+
+ +

[ +Draughting note: I chose a variadic representation similar to make_tuple +rather than naming both types as it is easier to read through the +clutter of metaprogramming this way. Given there are exactly two +elements, the committee may prefer to draught with two explicit template +type parameters instead +]

+ + +

+Add the following function to 20.4.2.4 [tuple.creation] and +signature in appropriate synopses: +

+ +
template<typename... Types>
+  tuple<typename decay<Types>::type...> make_simple_tuple(Types&&... t);
+
+
+

+Returns: tuple<typename decay<Types>::type...>(std::forward<Types>(t)...). +

+
+
+ + + + + +
+

1202. integral_constant needs a spring clean

+

Section: 20.7.3 [meta.help] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-09-05 Last modified: 2010-10-23

+

View all other issues in [meta.help].

+

View all issues with NAD status.

+

Discussion:

+

+The specification of integral_constant has been inherited +essentially unchanged from TR1: +

+ +
template <class T, T v>
+struct integral_constant {
+  static const T value = v;
+  typedef T value_type;
+  typedef integral_constant<T,v> type;
+};
+
+ +

+In light of 0x language changes there are several things we might +consider changing, notably the form of specification for value. +

+ +

+The current form requires a static data member have storage allocated +for it, where we could now implement without this using the new enum +syntax: +

+ +
template <class T, T v>
+struct integral_constant {
+  enum : T { value = v };
+  typedef T value_type;
+  typedef integral_constant type;
+};
+
+ +

+The effective difference between these two implementation is: +

+ +
    +
  1. +No requirement to allocate storage for data member (which we hope but do +not guarantee compilers strip today) +
    2. + +
  2. +You can no longer take the address of the constant as +&integral_constant<T,v>::value; +
    3. +
+ +

+Also note the editorial change to drop the explicit qualification of +integral_constant in the typedef type. This makes it quite clear we +mean the current instantiation, and cannot be mistaken for a recursive +metaprogram. +

+ +

+Even if we don't mandate this implementation, it would be nice to give +vendors freedom under QoI to choose their preferred representation. +

+ +

+The other side of this issue is if we choose to retain the static +constant form. In that case we should go further and insist on +constexpr, much like we did throughout numeric_limits: +

+ +
template <class T, T v>
+struct integral_constant {
+  static constexpr T value = v;
+  typedef T value_type;
+  typedef integral_constant type;
+};
+
+ +

+[Footnote] It turns out constexpr is part of the Tentatively Ready +resolution for 1019. I don't want to interfere with that issue, but +would like a new issue to consider if the fixed-base enum implementation +should be allowed. +

+ +

[ +2009-09-05 Daniel adds: +]

+ + +
+

+I think that the suggested resolution is incomplete and +may have some possible unwanted side-effects. To understand +why, note that integral_constant is completely specified +by code in 20.7.3 [meta.help]. While this is usually considered +as a good thing, let me give a possible user-defined +specialization that would break given the suggested changes: +

+ +
enum NodeColor { Red, Black };
+
+std::integral_constant<NodeColor, Red> red;
+
+ +

+The reason why that breaks is due to the fact that +current core language rules does only allow integral +types as enum-bases, see 7.2 [dcl.enum]/2. +

+ +

+So, I think that we cannot leave the implementation the +freedom to decide which way they would like to provide +the implementation, because that is easily user-visible +(I don't speak of addresses, but of instantiation errors), +therefore if applied, this should be either specified or +wording must be added that gives a note about this +freedom of implementation. +

+ +

+Another possible disadvantage seems to me that user-expectations +are easy to disappoint if they see a failure +of the test +

+ +
assert(typeid(std::integral_constant<int, 0>::value) == typeid(int));
+
+ +

+or of +

+ +
static_assert(std::is_same<decltype(std::integral_constant<int, 0>::value), const int>::value, "Bad library");
+
+ +
+ +

[ +2010-01-14 Moved to Tentatively NAD after 5 positive votes on c++std-lib. +]

+ + + + +

Rationale:

+

+We think that the suggested resolution is incomplete and may have some possible +unwanted side-effects. (see Daniel's 2009-09-05 comment for details). +

+ + +

Proposed resolution:

+ + + + + +
+

1203. More useful rvalue stream insertion

+

Section: 27.7.2.9 [ostream.rvalue], 27.7.1.6 [istream.rvalue] Status: NAD Future + Submitter: Howard Hinnant Opened: 2009-09-06 Last modified: 2010-10-23

+

View all issues with NAD Future status.

+

Discussion:

+

+27.7.2.9 [ostream.rvalue] was created to preserve the ability to insert +into (and extract from 27.7.1.6 [istream.rvalue]) rvalue streams: +

+ +
template <class charT, class traits, class T>
+  basic_ostream<charT, traits>&
+  operator<<(basic_ostream<charT, traits>&& os, const T& x);
+
+
+

+1 Effects: os << x +

+

+2 Returns: os +

+
+
+ +

+This is good as it allows code that wants to (for example) open, write to, and +close an ofstream all in one statement: +

+ +
std::ofstream("log file") << "Some message\n";
+
+ +

+However, I think we can easily make this "rvalue stream helper" even easier to +use. Consider trying to quickly create a formatted string. With the current +spec you have to write: +

+ +
std::string s = static_cast<std::ostringstream&>(std::ostringstream() << "i = " << i).str();
+
+ +

+This will store "i = 10" (for example) in the string s. Note +the need to cast the stream back to ostringstream& prior to using +the member .str(). This is necessary because the inserter has cast +the ostringstream down to a more generic ostream during the +insertion process. +

+ +

+I believe we can re-specify the rvalue-inserter so that this cast is unnecessary. +Thus our customer now has to only type: +

+ +
std::string s = (std::ostringstream() << "i = " << i).str();
+
+ +

+This is accomplished by having the rvalue stream inserter return an rvalue of +the same type, instead of casting it down to the base class. This is done by +making the stream generic, and constraining it to be an rvalue of a type derived +from ios_base. +

+ +

+The same argument and solution also applies to the inserter. This code has been +implemented and tested. +

+ +

[ +2009 Santa Cruz: +]

+ + +
+NAD Future. No concensus for change. +
+ + + +

Proposed resolution:

+

+Change 27.7.1.6 [istream.rvalue]: +

+ +
template <class charT, class traits Istream, class T>
+  basic_istream<charT, traits>& Istream&&
+  operator>>(basic_istream<charT, traits> Istream&& is, T& x);
+
+
+

+1 Effects: is >> x +

+

+2 Returns: std::move(is) +

+

+3 Remarks: This signature shall participate in overload resolution if +and only if Istream is not an lvalue reference type and is derived from +ios_base. +

+
+
+ +

+Change 27.7.2.9 [ostream.rvalue]: +

+ +
template <class charT, class traits Ostream, class T>
+  basic_ostream<charT, traits>& Ostream&&
+  operator<<(basic_ostream<charT, traits> Ostream&& os, const T& x);
+
+
+

+1 Effects: os << x +

+

+2 Returns: std::move(os) +

+

+3 Remarks: This signature shall participate in overload resolution if +and only if Ostream is not an lvalue reference type and is derived from +ios_base. +

+
+
+ + + + + + +
+

1210. iterator reachability should not require a container

+

Section: 24.2 [iterator.requirements] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-09-18 Last modified: 2010-10-23

+

View all other issues in [iterator.requirements].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+p6 Iterator requirements 24.2 [iterator.requirements] +

+ +
+An iterator j is called reachable from an iterator i if and only if +there is a finite sequence of applications of the expression ++i that +makes i == j. If j is reachable from i, they refer to the same +container. +
+ +

+A good example would be stream iterators, which do not refer to a +container. Typically, the end iterator from a range of stream iterators +will compare equal for many such ranges. I suggest striking the second +sentence. +

+ +

+An alternative wording might be: +

+ +
+If j is reachable from i, and both i and +j are dereferencable iterators, then they refer to the same +range. +
+ +

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

+ + + + +

Rationale:

+

+Solved by +N3066. +

+ + +

Proposed resolution:

+

+Change 24.2 [iterator.requirements], p6: +

+ +
+An iterator j is called reachable from an iterator +i if and only if there is a finite sequence of applications of +the expression ++i that makes i == j. If +j is reachable from i, they refer to the same +container. +
+ + + + + +
+

1211. move iterators should be restricted as input iterators

+

Section: 24.5.3.1 [move.iterator] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-09-18 Last modified: 2010-10-23

+

View all other issues in [move.iterator].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+I contend that while we can support both bidirectional and random access +traversal, the category of a move iterator should never be better than +input_iterator_tag. +

+ +

+The contentious point is that you cannot truly have a multipass property +when values are moved from a range. This is contentious if you view a +moved-from object as still holding a valid value within the range. +

+ +

+The second reason comes from the Forward Iterator requirements table: +

+ +
+

+Forward iterators 24.2.5 [forward.iterators] +

+ +

+Table 102 -- Forward iterator requirements +

+ +
+For expression *a the return type is: +"T& if X is mutable, otherwise const T&" +
+
+ +

+There is a similar constraint on a->m. +

+ +

+There is no support for rvalue references, nor do I believe their should +be. Again, opinions may vary but either this table or the definition of +move_iterator need updating. +

+ +

+Note: this requirement probably need updating anyway if we wish to +support proxy iterators but I am waiting to see a new working paper +before filing that issue. +

+ +

[ +2009-10 post-Santa Cruz: +]

+ + +
+Move to Open. Howard to put his rationale mentioned above into the issue +as a note. +
+ +

[ +2009-10-26 Howard adds: +]

+ + +
+

+vector::insert(pos, iter, iter) is significantly more effcient when +iter is a random access iterator, as compared to when it is an +input iterator. +

+ +

+When iter is an input iterator, the best algorithm +is to append the inserted range to the end of the vector using +push_back. This may involve several reallocations before the input +range is exhausted. After the append, then one can use std::rotate +to place the inserted range into the correct position in the vector. +

+ +

+But when iter is a random access iterator, the best algorithm +is to first compute the size of the range to be inserted (last - first), +do a buffer reallocation if necessary, scoot existing elements in the vector +down to make the "hole", and then insert the new elements directly to their correct +place. +

+ +
+The insert-with-random-access-iterators algorithm is considerably more efficient +than the insert-with-input-iterators algorithm +
+ +

+Now consider: +

+ +
vector<A> v;
+//  ... build up a large vector of A ...
+vector<A> temp;
+//  ... build up a large temporary vector of A to later be inserted ...
+typedef move_iterator<vector<A>::iterator> MI;
+//  Now insert the temporary elements:
+v.insert(v.begin() + N, MI(temp.begin()), MI(temp.end()));
+
+ +

+A major motivation for using move_iterator in the above example is the +expectation that A is cheap to move but expensive to copy. I.e. the +customer is looking for high performance. If we allow vector::insert +to subtract two MI's to get the distance between them, the customer enjoys +substantially better performance, compared to if we say that vector::insert +can not subtract two MI's. +

+ +

+I can find no rationale for not giving this performance boost to our customers. +Therefore I am strongly against restricting move_iterator to the +input_iterator_tag category. +

+ +

+I believe that the requirement that forward +iterators have a dereference that returns an lvalue reference to cause unacceptable +pessimization. For example vector<bool>::iterator also does not return +a bool& on dereference. Yet I am not aware of a single vendor that +is willing to ship vector<bool>::iterator as an input iterator. +Everyone classifies it as a random access iterator. Not only does this not +cause any problems, it prevents significant performance problems. +

+ +
+ +

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

+ + + + +

Rationale:

+

+Solved by +N3066. +

+ + +

Proposed resolution:

+

+Class template move_iterator 24.5.3.1 [move.iterator] +

+ +
namespace std {
+template <class Iterator>
+class move_iterator {
+public:
+ ...
+ typedef typename iterator_traits<Iterator>::iterator_category input_iterator_tag iterator_category;
+
+ + + + + +
+

1212. result of post-increment/decrement operator

+

Section: 24.2 [iterator.requirements] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2009-09-18 Last modified: 2010-10-23

+

View all other issues in [iterator.requirements].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Forward iterator and bidirectional iterator place different requirements on the result of post-increment/decrement operator. The same form should be used in each case. +

+ +

+Merging row from: +

+ +
Table 102 -- Forward iterator requirements
+Table 103 -- Bidirectional iterator requirements
+
+    r++ : convertible to const X&
+    r-- : convertible to const X&
+    
+    *r++ : T& if X is mutable, otherwise const T&
+    *r-- : convertible to T
+
+ +

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

+ + + + +

Rationale:

+

+Solved by +N3066. +

+ + +

Proposed resolution:

+ + + + + +
+

1217. Quaternion support

+

Section: 26.4 [complex.numbers] Status: NAD Future + Submitter: Ted Shaneyfelt Opened: 2009-09-26 Last modified: 2010-10-23

+

View all other issues in [complex.numbers].

+

View all issues with NAD Future status.

+

Discussion:

+

+Concerning mathematically proper operation of the type: +

+ +
complex<complex<T> >
+
+ +

+Generally accepted mathematical semantics of such a construct correspond +to quaternions through Cayly-Dickson construct +

+ +
(w+xi) + (y+zi) j
+
+ +

+The proper implementation seems straightforward by adding a few +declarations like those below. I have included operator definition for +combining real scalars and complex types, as well, which seems +appropriate, as algebra of complex numbers allows mixing complex and +real numbers with operators. It also allows for constructs such as +complex<double> i=(0,1), x = 12.34 + 5*i; +

+ +

+Quaternions are often used in areas such as computer graphics, where, +for example, they avoid the problem of Gimbal lock when rotating objects +in 3D space, and can be more efficient than matrix multiplications, +although I am applying them to a different field. +

+ +
/////////////////////////ALLOW OPERATORS TO COMBINE REAL SCALARS AND COMPLEX VALUES /////////////////////////
+template<typename T,typename S> complex<T> operator+(const complex<T> x,const S a) {
+    complex<T> result(x.real()+a, x.imag());
+    return result;
+}
+template<typename T,typename S> complex<T> operator+(const S a,const complex<T> x) {
+    complex<T> result(a+x.real(), x.imag());
+    return result;
+}
+template<typename T,typename S> complex<T> operator-(const complex<T> x,const S a) {
+    complex<T> result(x.real()-a, x.imag());
+    return result;
+}
+template<typename T,typename S> complex<T> operator-(const S a,const complex<T> x) {
+    complex<T> result(a-x.real(), x.imag());
+    return result;
+}
+template<typename T,typename S> complex<T> operator*(const complex<T> x,const S a) {
+    complex<T> result(x.real()*a, x.imag()*a);
+    return result;
+}
+template<typename T,typename S> complex<T> operator*(const S a,const complex<T> x) {
+    complex<T> result(a*x.real(), a*x.imag());
+    return result;
+}
+
+/////////////////////////PROPERLY IMPLEMENT QUATERNION SEMANTICS/////////////////////////
+template<typename T> double normSq(const complex<complex<T> >q) {
+    return q.real().real()*q.real().real()
+         + q.real().imag()*q.real().imag()
+         + q.imag().real()*q.imag().real()
+         + q.imag().imag()*q.imag().imag();
+}
+template<typename T> double norm(const complex<complex<T> >q) {
+    return sqrt(normSq(q));
+}
+/////// Cayley-Dickson Construction
+template<typename T> complex<complex<T> > conj(const complex<complex<T> > x) {
+    complex<complex<T> > result(conj(x.real()),-x.imag());
+    return result;
+}
+template<typename T> complex<complex<T> > operator*(const complex<complex<T> > ab,const complex<complex<T> > cd) {
+    complex<T> re(ab.real()*cd.real()-conj(cd.imag())*ab.imag());
+    complex<T> im(cd.imag()*ab.real()+ab.imag()*conj(cd.real()));
+    complex<complex<double> > q(re,im);
+    return q;
+}
+//// Quaternion division
+template<typename S,typename T> complex<complex<T> > operator/(const complex<complex<T> > q,const S a) {
+    return q * (1/a);
+}
+template<typename S,typename T> complex<complex<T> > operator/(const S a,const complex<complex<T> > q) {
+    return a*conj(q)/normSq(q);
+}
+template<typename T> complex<complex<T> > operator/(const complex<complex<T> > n, const complex<complex<T> > d) {
+    return n * (conj(d)/normSq(d));
+}
+
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Future. There is no consensus or time to move this into C++0X. +
+ + + +

Proposed resolution:

+ + + + + +
+

1219. unique_lock::lock and resource_deadlock_would_occur

+

Section: 30.4.2.2.2 [thread.lock.unique.locking] Status: Dup + Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2010-10-23

+

View all other issues in [thread.lock.unique.locking].

+

View all issues with Dup status.

+

Duplicate of: 1159

+

Discussion:

+ + + +

+unique_lock::lock and friends raise +"resource_deadlock_would_occur -- if the current thread already +owns the mutex (i.e., on entry, owns is true)." 1) +The current thread owning a mutex is not the same as any particular +unique_lock::owns being true. 2) There's no need to +raise this exception for a recursive_mutex if owns is +false. 3) If owns is true, we need to raise some +exception or the unique_lock will lose track of whether to unlock itself +on destruction, but "deadlock" isn't it. For (3), s/bool owns/int +ownership_level/ would fix it. +

+ +

[ +2009-11-11 Alisdair notes that this issue is very closely related to 1159, +if not a dup. +]

+ + +

[ +2009-11-14 Moved to Tentatively Dup after 5 positive votes on c++std-lib. +]

+ + + + +

Proposed resolution:

+ + + + + +
+

1223. condition_variable_any lock matching?

+

Section: 30.5.2 [thread.condition.condvarany] Status: NAD + Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2010-10-23

+

View all other issues in [thread.condition.condvarany].

+

View all issues with NAD status.

+

Discussion:

+

+For condition_variable_any, must all lock arguments to concurrent wait calls +"match" in some way, similar to the requirement in +30.5.1 [thread.condition.condvar] that lock.mutex() returns the same +value for each of the lock arguments supplied by all concurrently +waiting threads (via wait or timed_wait)? +

+ +

[ +2010-02-12 Moved to Tentatively NAD after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + + + +

Rationale:

+

+The rationale is that it doesn't matter, and you can't check: the lock types may +be different, or the same and user-defined, so the implementation must provide +internal synchronization anyway. +

+ + +

Proposed resolution:

+ + + + + +
+

1224. condition_variable_any support for recursive mutexes?

+

Section: 30.5.2 [thread.condition.condvarany] Status: NAD + Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2010-10-23

+

View all other issues in [thread.condition.condvarany].

+

View all issues with NAD status.

+

Discussion:

+

+For condition_variable_any, are recursive mutexes allowed? (I think "no") +

+ +

[ +2009-11-17 Moved to Tentatively NAD after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + + +

Proposed resolution:

+ + +

Rationale:

+

+condition_variable_any::wait accepts any type of mutex. It calls +unlock precisely once on entry and lock precisely once on +exit. It is up to the user to ensure that this provides the required +synchronization. Use of a recursive mutex is safe if either its lock count is 1, +so after the single unlock it can be acquired by another thread, or another +mechanism is used to synchronize the data. +

+ + + + + +
+

1225. C++0x result_of issue

+

Section: X [func.ret] Status: NAD Editorial + Submitter: Sebastian Gesemann Opened: 2009-10-05 Last modified: 2010-10-23

+

View all other issues in [func.ret].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+I think the text about std::result_of could be a little more precise. +Quoting from +N2960... +

+ +
+

+X [func.ret] Function object return types +

+ +
template<class> class result_of;
+
+template<class Fn, class... ArgTypes>
+class result_of<Fn(ArgTypes...)> {
+public:
+  typedef see below type;
+};
+
+ +

+Given an rvalue fn of type Fn and values t1, t2, +..., tN of types T1, T2, ... TN in ArgTypes +respectivly, the type member is the result type of the +expression fn(t1,t2,...,tN). the values ti are lvalues +when the corresponding type Ti is an lvalue-reference type, and +rvalues otherwise. +

+
+ +

+This text doesn't seem to consider lvalue reference types for Fn. +Also, it's not clear whether this class template can be used for +"SFINAE" like std::enable_if. Example: +

+ +
template<typename Fn, typename... Args>
+typename std::result_of<Fn(Args...)>::type
+apply(Fn && fn, Args && ...args)
+{
+  // Fn may be an lvalue reference, too
+  return std::forward<Fn>(fn)(std::forward<Args>(args)...);
+}
+
+ +

+Either std::result_of<...> can be instantiated and simply may not have +a typedef "type" (-->SFINAE) or instantiating the class template for +some type combinations will be a "hard" compile-time error. +

+ +

[ +2010-02-14 Daniel adds: +]

+ + +
+This issue should be considered resolved by 1255 and 1270. The wish to change result_of into a compiler-support +trait was beyond the actual intention of the submitter Sebastian. +
+ +

[ +2010 Pittsburgh: Moved to NAD Editorial, rationale added below. +]

+ + + + +

Rationale:

+

+Solved by 1270. +

+ + +

Proposed resolution:

+ +

[ +These changes will require compiler support +]

+ + +

+Change X [func.ret]: +

+ +
template<class> class result_of; // undefined
+
+template<class Fn, class... ArgTypes>
+class result_of<Fn(ArgTypes...)> {
+public:
+  typedef see below type;
+};
+
+ +

+Given an rvalue fn of type Fn and values t1, t2, +..., tN of types T1, T2, ... TN in ArgTypes +respectivly, the type member is the result type of the +expression fn(t1,t2,...,tN). the values ti are lvalues +when the corresponding type Ti is an lvalue-reference type, and +rvalues otherwise. +

+ +

+The class template result_of shall meet the requirements of a +TransformationTrait: Given the types Fn, T1, T2, ..., TN every +template specialization result_of<Fn(T1,T2,...,TN)> shall define the +member typedef type equivalent to decltype(RE) if and only if +the expression RE +

+ +

+value<Fn>() ( value<T1>(), value<T2>(), ... value<TN>()  )
+
+ +

+would be well-formed. Otherwise, there shall be no member typedef +type defined. +

+ +
+ +

[ +The value<> helper function is a utility Daniel Krügler +proposed in +N2958. +]

+ + + + + + +
+

1226. Incomplete changes of #890

+

Section: 30.6.2 [futures.errors] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2009-10-05 Last modified: 2010-10-23

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Defect issue 890 overlooked to adapt the future_category from +30.6.1 [futures.overview] and 30.6.2 [futures.errors]: +

+ +
extern const error_category* const future_category;
+
+ +

+which should be similarly transformed into function form. +

+ +

[ +2009-10-27 Howard: +]

+ + +
+Moved to Tentatively Ready after 5 positive votes on c++std-lib. +
+ +

[ +2009-11-11 Daniel adds: +]

+ + +
+

+I just observe that the proposed resolution of this issue +is incomplete and needs to reworded. The problem is that the +corresponding declarations +

+ +
constexpr error_code make_error_code(future_errc e);
+constexpr error_condition make_error_condition(future_errc e);
+
+ +

+as constexpr functions are incompatible to the requirements of constexpr +functions given their specified implementation. Note that the incompatibility +is not a result of the modifications proposed by the issue resolution, +but already existed within the +N2960 +state where we have +

+ +
extern const error_category* const future_category;
+
+ +

+combined with +

+ +
constexpr error_code make_error_code(future_errc e);
+
+
+3 Returns: error_code(static_cast<int>(e), *future_category). +
+ +
constexpr error_code make_error_condition(future_errc e);
+
+
+4 Returns: error_condition(static_cast<int>(e), *future_category). +
+
+ +

+Neither is any of the constructors of error_code and error_condition +constexpr, nor does the expression *future_category satisfy the +requirements for a constant expression (5.19 [expr.const]/2 bullet 6 in +N3000). +

+ +

+The simple solution is just to remove the constexpr qualifiers for both +functions, which makes sense, because none of the remaining make_error_* +overloads in the library is constexpr. One might consider to realize that +those make_* functions could satisfy the constexpr requirements, but this +looks not like an easy task to me, because it would need to rely on a not +yet existing language feature. If such a change is wanted, a new issue +should be opened after the language extension approval (if at all) [1]. +

+ +

+If no-one complaints I would like to ask Howard to add the following +modifications to this issue, alternatively a new issue could be opened but I +don't know what the best solution is that would cause as little overhead +as possible. +

+

+What-ever the route is, the following is my proposed resolution for this issue +interaction part of the story: +

+ +
+

+In 30.6.1 [futures.overview]/1, Header <future> synopsis and +in 30.6.2 [futures.errors]/3+4 +change as indicated: +

+ +
constexpr error_code make_error_code(future_errc e);
+constexpr error_condition make_error_condition(future_errc e);
+
+
+ +

+[1] Let me add that we have a related NAD issue here: 832 +so the chances for realization are little IMO. +

+ +

[ +Howard: I've updated the proposed wording as Daniel suggests and set to Review. +]

+ +
+ +

[ +2009-11-13 Moved to Tentatively Ready after 5 positive votes on c++std-lib. +]

+ + +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Editorial. Rationale added below. +
+ + + +

Rationale:

+

+Solved by N3058. +

+ + +

Proposed resolution:

+
    +
  1. +

    +Change in 30.6.1 [futures.overview], header <future> synopsis: +

    + +
    extern const error_category&* const future_category();
+
    +
    2. + +
  2. +

    +In 30.6.1 [futures.overview]/1, Header <future> synopsis +change as indicated: +

    + +
    constexpr error_code make_error_code(future_errc e);
+constexpr error_condition make_error_condition(future_errc e);
+
    +
    3. + +
  3. +

    +Change in 30.6.2 [futures.errors]: +

    + +
    extern const error_category&* const future_category();
+
    + +
    +

    +1- future_category shall point to a statically initialized object +of a type derived from class error_category. +

    +

    +1- Returns: A reference to an object of a type +derived from class error_category. +

    +
    + +
    constexpr error_code make_error_code(future_errc e);
+
    + +
    +3 Returns: error_code(static_cast<int>(e), +*future_category()). +
    + +
    constexpr error_codecondition make_error_condition(future_errc e);
+
    + +
    +4 Returns: error_condition(static_cast<int>(e), +*future_category()). +
    +
    +
    4. +
+ + + + + +
+

1228. User-specialized nothrow type traits

+

Section: 20.7.4.3 [meta.unary.prop] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-10-07 Last modified: 2010-10-23

+

View all other issues in [meta.unary.prop].

+

View all issues with NAD status.

+

Discussion:

+

+According to p1 20.7.2 [meta.type.synop]: +

+ +
+The behavior of a program that adds specializations for any of the class +templates defined in this subclause is undefined unless otherwise +specified. +
+ +

+I believe we should 'otherwise specify' for the nothrow traits, are +these are exactly the use cases where the end user actually has more +information than the compiler. +

+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Moved to Open. Definitely need to give the users the ability to ensure +that the traits give the right answers. Unsure we want to give them the +ability to say this in more than one way. Believes the noexcept proposal +already gives this. +
+ +

[ +2010 Pittsburgh: Moved to NAD, rationale added below. +]

+ + + + +

Rationale:

+

+We believe the solution offered by +N3050 +is superior. +

+ + +

Proposed resolution:

+

+Add the following comment: +

+ +
+user specialization permitted to derive from std::true_type when the +operation is known not to throw. +
+ +

+to the following traits in 20.7.4.3 [meta.unary.prop] Table 43 Type +property predicates. +

+ +

[ +This may require a new Comments column +]

+ + +
has_nothrow_default_constructor
+has_nothrow_copy_constructor
+has_nothrow_assign
+
+ + + + + +
+

1229. error_code operator= typo

+

Section: 19.5.2.3 [syserr.errcode.modifiers] Status: NAD + Submitter: Stephan T. Lavavej Opened: 2009-10-08 Last modified: 2010-10-23

+

View all issues with NAD status.

+

Discussion:

+

+N2960 +19.5.2.1 [syserr.errcode.overview] and 19.5.2.3 [syserr.errcode.modifiers] say: +

+ +
 
+template <class ErrorCodeEnum>
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type&
+    operator=(ErrorCodeEnum e);
+
+ +

+They should say: +

+ +
 
+template <class ErrorCodeEnum>
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type&
+    operator=(ErrorCodeEnum e);
+
+ +

+Or (I prefer this form): +

+ +
 
+template <class ErrorCodeEnum>
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code&>::type
+    operator=(ErrorCodeEnum e);
+
+ +

+This is because enable_if is declared as (20.7.7.6 [meta.trans.other]): +

+ +
 
+template <bool B, class T = void> struct enable_if;
+
+ +

+So, the current wording makes operator= return +void&, which is not good. +

+ +

+19.5.2.3 [syserr.errcode.modifiers]/4 says +

+ +
+Returns: *this. +
+

+which is correct. +

+ +

+Additionally, +

+ +

+19.5.3.1 [syserr.errcondition.overview]/1 says: +

+ +
 
+template<typename ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>, error_code>::type &
+    operator=( ErrorConditionEnum e );
+
+ +

+Which contains several problems (typename versus class +inconsistency, lack of ::value, error_code instead of +error_condition), while 19.5.3.3 [syserr.errcondition.modifiers] says: +

+ +
 
+template <class ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::type&
+    operator=(ErrorConditionEnum e);
+
+ +

+Which returns void&. They should both say: +

+ +
 
+template <class ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type&
+    operator=(ErrorConditionEnum e);
+
+ +

+Or (again, I prefer this form): +

+ +
 
+template <class ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition&>::type
+    operator=(ErrorConditionEnum e);
+
+ +

+Additionally, 19.5.3.3 [syserr.errcondition.modifiers] lacks a +"Returns: *this." paragraph, which is presumably +necessary. +

+ +

[ +2009-10-18 Beman adds: +]

+ + +
+The proposed resolution for issue 1237 makes this issue +moot, so it should become NAD. +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD, solved by 1237. +
+ + + +

Proposed resolution:

+ +

+Change 19.5.2.1 [syserr.errcode.overview] and 19.5.2.3 [syserr.errcode.modifiers]: +

+ +
template <class ErrorCodeEnum>
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code&>::type&
+    operator=(ErrorCodeEnum e);
+
+ +

+Change 19.5.3.1 [syserr.errcondition.overview]: +

+ +
template<typename class ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_conditionde&>::type &
+    operator=( ErrorConditionEnum e );
+
+ +

+Change 19.5.3.3 [syserr.errcondition.modifiers]: +

+ +
template <class ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition&>::type&
+    operator=(ErrorConditionEnum e);
+
+
+

+Postcondition: *this == make_error_condition(e). +

+

+Returns: *this. +

+

+Throws: Nothing. +

+
+
+ + + + + + +
+

1230. mem_fn and variadic templates

+

Section: 20.8.13 [func.memfn] Status: Dup + Submitter: Alisdair Meredith Opened: 2009-10-09 Last modified: 2010-10-23

+

View all other issues in [func.memfn].

+

View all issues with Dup status.

+

Duplicate of: 920

+

Discussion:

+ + + +

+Since we have removed the entry in B [implimits] for the +library-specific limit for number of arguments passed to +function/tuple/etc. I believe we need to update the +spec for mem_fn to reflect this. +

+ +

+The "Remarks: Implementations may implement mem_fn as a set of +overloaded function templates." no longer holds, as we cannot create an +arbitrary number of such overloads. I believe we should strike the +remark and add a second signature: +

+ +
template<class R, class T, typename ... ArgTypes>
+  unspecified mem_fn(R (T::*pm)(ArgTypes...));
+
+ +

+I believe we need two signatures as pointer-to-data-member and +pointer-to-member-function-taking-no-args appear to use subtly different +syntax. +

+ +

[ +920 as a similar proposed resolution. +]

+ + + +

Proposed resolution:

+Add to 20.8 [function.objects] and 20.8.13 [func.memfn]: + + +
template<class R, class T> unspecified mem_fn(R T::* pm)
+
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...));
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile);
+
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...)&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile&);
+
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...)&&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const&&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile&&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile&&);
+
+ +

+Strike 20.8.13 [func.memfn], p5: +

+ +
+Remarks: Implementations may implement mem_fn as a set +of overloaded function templates. +
+ + + + +
+

1232. Still swap's with rvalue-references

+

Section: 17 [library] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2009-10-11 Last modified: 2010-10-23

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The current library contains still rvalue reference-swaps that seem to be +overlooked in the process of switching back to lvalue-ref swaps. +

+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Editor accepts as NAD Editorial. +
+ + + +

Proposed resolution:

+
    +
  1. +

    +Change 20.3.5 [pairs]/1 as indicated: +

    + +
    template <class T1, class T2>
+struct pair {
+  ...
+  void swap(pair&& p);
+};
+
    +
    2. + +
  2. +

    +Change 20.3.5 [pairs] before p. 17 as indicated: +

    + +
    void swap(pair&& p);
+
    + +
    3. + +
  3. + +

    +Change 20.3.5 [pairs] before p. 21 as indicated: +

    + +
    template<class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>& y);
+template<class T1, class T2> void swap(pair<T1, T2>&& x, pair<T1, T2>& y);
+template<class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>&& y);
+
    + +
    4. + +
  4. +

    +Change 20.4.1 [tuple.general]/2, header <tuple> synopsis, as indicated: +

    + +
    // 20.5.2.9, specialized algorithms:
+template <class... Types>
+void swap(tuple<Types...>& x, tuple<Types...>& y);
+template <class... Types>
+void swap(tuple<Types...>&& x, tuple<Types...>& y);
+template <class... Types>
+void swap(tuple<Types...>& x, tuple<Types...>&& y);
+
    + +
    5. + +
  5. +

    +Change 20.4.2 [tuple.tuple] as indicated: +

    + +
    // 20.5.2.3, tuple swap
+void swap(tuple&&)
+
    + +
    6. + +
  6. +

    +Change 20.4.2.3 [tuple.swap] before 1 as indicated: +

    + +
    void swap(tuple&& rhs);
+
    + +
    7. + +
  7. +

    +Change 20.8 [function.objects]/2, header <functional> synopsis, as indicated: +

    + +
    template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
+template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&&, function<R(ArgTypes...)>&);
+template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)&&);
+
    + +
    8. + +
  8. +

    +Change 20.8.14.2 [func.wrap.func], as indicated: +

    + +
    // 20.7.15.2.2, function modifiers:
+void swap(function&&);
+template<class F, class A> void assign(F, const A&);
+
+[..]
+
+// 20.7.15.2.7, specialized algorithms:
+template <class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
+template <class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&&, function<R(ArgTypes...)>&);
+template <class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&&);
+
    + +
    9. + +
  9. +

    +Change 20.8.14.2.7 [func.wrap.func.alg] before 1 as indicated: +

    + +
    template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2);
+template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&& f1, function<R(ArgTypes...)>& f2);
+template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>&& f2);
+
    + +
    10. + +
  10. +

    +Change 20.9.10.2 [util.smartptr.shared]/1 as indicated: +

    + +
    // 20.8.12.2.4, modifiers:
+void swap(shared_ptr&& r);
+
+[..]
+
+// 20.8.12.2.9, shared_ptr specialized algorithms:
+template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b);
+template<class T> void swap(shared_ptr<T>&& a, shared_ptr<T>& b);
+template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>&& b);
+
    + +
    11. + +
  11. +

    +Change 21.3 [string.classes]/1, header <string> synopsis, as indicated: +

    + +
    // 21.4.8.8: swap
+template<class charT, class traits, class Allocator>
+void swap(basic_string<charT,traits,Allocator>& lhs, basic_string<charT,traits,Allocator>& rhs);
+template<class charT, class traits, class Allocator>
+void swap(basic_string<charT,traits,Allocator>&& lhs, basic_string<charT,traits,Allocator>& rhs);
+template<class charT, class traits, class Allocator>
+void swap(basic_string<charT,traits,Allocator>& lhs, basic_string<charT,traits,Allocator>&& rhs);
+
    + +
    12. + +
  12. +

    +Change 23.3 [sequences]/1, header <deque> synopsis, as indicated: +

    + +
    template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
+
    + +
    13. + +
  13. +

    +Change 23.3 [sequences]/1, header <list> synopsis, as indicated: +

    + +
    template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
+
    + +
    14. + +
  14. +

    +Change 23.3 [sequences]/1, header <queue> synopsis, as indicated: +

    + +
    template <class T, class Allocator>
+void swap(queue<T, Container>& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>&& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>& x, queue<T, Container>&& y);
+
+template <class T, class Container = vector<T>, class Compare = less<typename Container::value_type> >
+class priority_queue;
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>&& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>&& y);
+
    + +
    15. + +
  15. +

    +Change 23.3 [sequences]/1, header <stack> synopsis, as indicated: +

    + +
    template <class T, class Container>
+void swap(stack<T, Container>& x, stack<T, Container>& y);
+template <class T, class Container>
+void swap(stack<T, Container>&& x, stack<T, Container>& y);
+template <class T, class Container>
+void swap(stack<T, Container>& x, stack<T, Container>&& y);
+
    + +
    16. + +
  16. +

    +Change 23.3 [sequences]/1, header <vector> synopsis, as indicated: +

    + +
    template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
+
    + +
    17. + +
  17. +

    +Change 23.3.2 [deque]/2 as indicated: +

    + +
    iterator erase(const_iterator position);
+iterator erase(const_iterator first, const_iterator last);
+void swap(deque<T,Allocator>&&);
+void clear();
+
+[..]
+
+// specialized algorithms:
+template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
+
    + +
    18. + +
  18. +

    +Change 23.3.2.4 [deque.special] as indicated: +

    + +
    template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
+
    + +
    19. + +
  19. +

    +Change 23.3.3 [forwardlist]/2 as indicated: +

    + +
    iterator erase_after(const_iterator position);
+iterator erase_after(const_iterator position, iterator last);
+void swap(forward_list<T,Allocator>&&);
+
+[..]
+
+// 23.3.3.6 specialized algorithms:
+template <class T, class Allocator>
+void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(forward_list<T,Allocator>&& x, forward_list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>&& y);
+
    + +
    20. + +
  20. +

    +Change 23.3.3.6 [forwardlist.spec] as indicated: +

    + +
    template <class T, class Allocator>
+void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(forward_list<T,Allocator>&& x, forward_list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>&& y);
+
    + +
    21. + +
  21. +

    +Change 23.3.4 [list]/2 as indicated: +

    + +
    iterator erase(const_iterator position);
+iterator erase(const_iterator position, const_iterator last);
+void swap(list<T,Allocator>&&);
+void clear();
+
+[..]
+
+// specialized algorithms:
+template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
+
    + +
    22. + +
  22. +

    +Change 23.3.4.5 [list.special] as indicated: +

    + +
    template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
+
    + +
    23. + +
  23. +

    +Change 23.5.1.1 [queue.defn] as indicated: +

    + +
    void swap(queue&& q) { c.swap(q.c); }
+
+[..]
+
+template <class T, class Container>
+void swap(queue<T, Container>& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>&& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>& x, queue<T, Container>&& y);
+
    + +
    24. + +
  24. +

    +Change 23.5.1.5 [queue.special] as indicated: +

    + +
    template <class T, class Container>
+void swap(queue<T, Container>& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>&& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>& x, queue<T, Container>&& y);
+
    + +
    25. + +
  25. +

    +Change 23.5.2 [priority.queue]/1 as indicated: +

    + +
    void swap(priority_queue&&);
+
+// no equality is provided
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>&& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>&& y);
+
    + +
    26. + +
  26. +

    +Change 23.5.2.4 [priqueue.special] as indicated: +

    + +
    template <class T, class Container, Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, Compare>
+void swap(priority_queue<T, Container, Compare>&& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>&& y);
+
    + +
    27. + +
  27. +

    +Change 23.5.3.1 [stack.defn] as indicated: +

    + +
    void swap(stack&& s) { c.swap(s.c); }
+
+[..]
+
+template <class T, class Allocator>
+void swap(stack<T,Allocator>& x, stack<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(stack<T,Allocator>&& x, stack<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(stack<T,Allocator>& x, stack<T,Allocator>&& y);
+
    + + +
    28. + +
  28. +

    +Change 23.5.3.5 [stack.special] as indicated: +

    + +
    template <class T, class Container>
+void swap(stack<T, Container>& x, stack<T, Container>& y);
+template <class T, class Container>
+void swap(stack<T, Container>&& x, stack<T, Container>& y);
+template <class T, class Container>
+void swap(stack<T, Container>& x, stack<T, Container>&& y);
+
    + +
    29. + +
  29. +

    +Change 23.4.1 [vector]/2 as indicated: +

    + +
    void swap(vector<T,Allocator>&&);
+void clear();
+
+[..]
+
+// specialized algorithms:
+template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
+
    + +
    30. + +
  30. +

    +Change 23.4.1.2 [vector.capacity] before p. 8 as indicated: +

    + +
    void swap(vector<T,Allocator>&& x);
+
    + +
    31. + +
  31. +

    +Change 23.4.1.5 [vector.special] as indicated: +

    + +
    template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
+
    + +
    32. + +
  32. +

    +Change 23.4.2 [vector.bool]/1 as indicated: +

    + +
    iterator erase(const_iterator first, const_iterator last);
+void swap(vector<bool,Allocator>&&);
+static void swap(reference x, reference y);
+
    + +
    33. + +
  33. +

    +Change 23.6 [associative]/1, header <map> synopsis as indicated: +

    + +
    template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator&& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator& x, map<Key,T,Compare,Allocator>&& y);
+
+[..]
+
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator&& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator& x, multimap<Key,T,Compare,Allocator>&& y);
+
    + +
    34. + +
  34. +

    +Change 23.6 [associative]/1, header <set> synopsis as indicated: +

    + +
    template <class Key, class Compare, class Allocator>
+void swap(set<Key,Compare,Allocator>& x, set<Key,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(set<Key,T,Compare,Allocator&& x, set<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(set<Key,T,Compare,Allocator& x, set<Key,T,Compare,Allocator>&& y);
+
+[..]
+
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multiset<Key,T,Compare,Allocator&& x, multiset<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multiset<Key,T,Compare,Allocator& x, multiset<Key,T,Compare,Allocator>&& y);
+
    + +
    35. + +
  35. +

    +Change 23.6.1 [map]/2 as indicated: +

    + +
    iterator erase(const_iterator first, const_iterator last);
+void swap(map<Key,T,Compare,Allocator>&&);
+void clear();
+
+[..]
+
+// specialized algorithms:
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator&& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator& x, map<Key,T,Compare,Allocator>&& y);
+
    + +
    36. + +
  36. +

    +Change 23.6.1.5 [map.special] as indicated: +

    + +
    template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator>&& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>&& y);
+
    + +
    37. + +
  37. +

    +Change 23.6.2 [multimap]/2 as indicated: +

    + +
    iterator erase(const_iterator first, const_iterator last);
+void swap(multimap<Key,T,Compare,Allocator>&&);
+void clear();
+
+[..]
+
+// specialized algorithms:
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator&& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator& x, multimap<Key,T,Compare,Allocator>&& y);
+
    + +
    38. + +
  38. +

    +Change 23.6.2.4 [multimap.special] as indicated: +

    + +
    template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator>&& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>&& y);
+
    + +
    39. + +
  39. +

    +Change 23.6.3 [set]/2 and 23.6.3.2 [set.special] as indicated: (twice!) +

    + +
    // specialized algorithms:
+template <class Key, class Compare, class Allocator>
+void swap(set<Key,Compare,Allocator>& x, set<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(set<Key,Compare,Allocator&& x, set<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(set<Key,Compare,Allocator& x, set<Key,Compare,Allocator>&& y);
+
    + +
    40. + +
  40. +

    +Change 23.6.4 [multiset]/2 as indicated: +

    + +
    iterator erase(const_iterator first, const_iterator last);
+void swap(multiset<Key,Compare,Allocator>&&);
+void clear();
+
+[..]
+
+// specialized algorithms:
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator&& x, multiset<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator& x, multiset<Key,Compare,Allocator>&& y);
+
    + +
    41. + +
  41. +

    +Change 23.6.4.2 [multiset.special] as indicated: +

    + +
    template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator>&& x, multiset<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>&& y);
+
    + +
    42. +
+ + + + + +
+

1233. Missing unique_ptr signatures in synopsis

+

Section: 20.9 [memory] Status: NAD Editorial + Submitter: Daniel Krügler Opened: 2009-10-11 Last modified: 2010-10-23

+

View all other issues in [memory].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Related to 296. Some unique_ptr signatures are missing +from the synopsis in 20.9 [memory]. +

+ +

[ +2009-11-04 Howard adds: +]

+ + +
+Moved to Tentatively NAD Editorial. The editor has adopted the fix. +
+ + +

Proposed resolution:

+

+Add in 20.9 [memory], Header <memory> synopsis +missing declarations as shown below: +

+ +
// 20.8.11 Class unique_ptr:
+template <class X> class default_delete;
+template<class T> struct default_delete<T[]>;
+template <class X, class D = default_delete<T>> class unique_ptr;
+template<class T, class D> class unique_ptr<T[], D>;
+
+template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y);
+
+template<class T1, class D1, class T2, class D2>
+bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+template<class T1, class D1, class T2, class D2>
+bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+template<class T1, class D1, class T2, class D2>
+bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+template<class T1, class D1, class T2, class D2>
+bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+template<class T1, class D1, class T2, class D2>
+bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+template<class T1, class D1, class T2, class D2>
+bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+
+ + + + + +
+

1235. Issue with C++0x random number proposal

+

Section: X [rand.concept.dist] Status: NAD Future + Submitter: Matthias Troyer Opened: 2009-10-12 Last modified: 2010-10-23

+

View all issues with NAD Future status.

+

Discussion:

+

+There exist optimized, vectorized vendor libraries for the creation of +random number generators, such as Intel's MKL [1] and AMD's ACML [2]. In +timing tests we have seen a performance gain of a factor of up to 80 +(eighty) compared to a pure C++ implementation (in Boost.Random) when +using these generator to generate a sequence of normally distributed +random numbers. In codes dominated by the generation of random numbers +(we have application codes where random number generation is more than +50% of the CPU time) this factor 80 is very significant. +

+ +

+To make use of these vectorized generators, we use a C++ class modeling +the RandomNumberEngine concept and forwarding the generation of random +numbers to those optimized generators. For example: +

+ +
namespace mkl {
+ class mt19937 {.... };
+}
+
+ +

+For the generation of random variates we also want to dispatch to +optimized vectorized functions in the MKL or ACML libraries. See this +example: +

+ +
mkl::mt19937 eng;
+std::normal_distribution<double> dist;
+
+double n = dist(eng);
+
+ +

+Since the variate generation is done through the operator() of the +distribution there is no customization point to dispatch to Intel's or +AMD's optimized functions to generate normally distributed numbers based +on the mt19937 generator. Hence, the performance gain of 80 cannot be +achieved. +

+ +

+Contrast this with TR1: +

+ +
mkl::mt19937 eng;
+std::tr1::normal_distribution<double> dist;
+std::tr1::variate_generator<mkl::mt19937,std::tr1::normal_distribution<double> > rng(eng,dist);
+double n = rng();
+
+ +

+This - admittedly much uglier from an aestethic point of view - design +allowed optimization by specializing the variate_generator template for +mkl::mt19937: +

+ +
namespace std { namespace tr1 {
+
+template<>
+class variate_generator<mkl::mt19937,std::tr1::normal_distribution<double> > { .... };
+
+} }
+
+ +

+A similar customization point is missing in the C++0x design and +prevents the optimized vectorized version to be used. +

+ +

+Suggested resolution: +

+ +

+Add a customization point to the distribution concept. Instead of the +variate_generator template this can be done through a call to a +free function generate_variate found by ADL instead of +operator() of the distribution: +

+ +
template <RandomNumberDistribution, class RandomNumberEngine>
+typename RandomNumberDistribution ::result_type
+generate_variate(RandomNumberDistribution const& dist, RandomNumberEngine& eng);
+
+ +

+This function can be overloaded for optimized enginges like +mkl::mt19937. +

+ +

[ +2009-10 Santa Cruz: +]

+ + +
+NAD Future. No time to add this feature for C++0X. +
+ + + +

Proposed resolution:

+ + + + + +
+

1236. reserved identifiers in programs not using the library

+

Section: 17 [library] Status: NAD + Submitter: Sean Hunt Opened: 2009-10-13 Last modified: 2010-10-23

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD status.

+

Discussion:

+

+I wasn't sure whether to consider this a library or a language issue, +because the issue is I think it's incorrectly categorized as being part +of the library, so I thought I'd send a message to both of you and let +you sort it out. +

+ +

+Most reserved identifiers are treated as unilaterally available to the +implementation, such as to implement language extensions, or provide +macros documenting its functionality. However, the requirements for +reserved identifers are in 17.6.3.3 [reserved.names], which are a +subsection of 17.6.3 [constraints]. 17.6.3.1 [constraints.overview] appears only to apply to "C++ programs +that use the facilities of the C++ standard library", meaning that, in +theory, all implementations are erroneous in having any non-standard +identifiers predefined for programs that do not, at some point, include +a standard library header. +

+ +

+Furthermore, it's unclear whether the use of certain identifiers is UB +or results in an ill-formed program. In particular, 17.6.3.3.1 [macro.names] uses a "shall not", where 17.6.3.3.2 [global.names] says that names are "reserved to the +implementation". 17.6.3.3 [reserved.names] seems only to cover the +instance of a name being described as "reserved", so are implementations +required to diagnose a program that performs, as an example, "#undef +get"? +

+ +

[ +2009 Santa Cruz: +]

+ + +
+Move to NAD. There may in theory be multiple interpretations possible, +but there's no evidence that this causes any genuine problems or +uncertainty about what implementations are allowed to do. We do not +believe this rises to the level of a defect. +
+ + + +

Proposed resolution:

+ + + + + +
+

1238. defining algorithms taking iterator for range

+

Section: 25 [algorithms] Status: NAD Future + Submitter: Alisdair Meredith Opened: 2009-10-15 Last modified: 2010-10-23

+

View all other issues in [algorithms].

+

View all issues with NAD Future status.

+

Discussion:

+

+The library has many algorithms that take a source range represented by +a pair of iterators, and the start of some second sequence given by a +single iterator. Internally, these algorithms will produce undefined +behaviour if the second 'range' is not as large as the input range, but +none of the algorithms spell this out in Requires clauses, and there is +no catch-all wording to cover this in clause 17 or the front matter of +25. +

+ +

+There was an attempt to provide such wording in paper +n2944 +but this +seems incidental to the focus of the paper, and getting the wording of +this issue right seems substantially more difficult than the simple +approach taken in that paper. Such wording will be removed from an +updated paper, and hopefully tracked via the LWG issues list instead. +

+ +

+It seems there are several classes of problems here and finding wording +to solve all in one paragraph could be too much. I suspect we need +several overlapping requirements that should cover the desired range of +behaviours. +

+ +

+Motivating examples: +

+ +

+A good initial example is the swap_ranges algorithm. Here there is a +clear requirement that first2 refers to the start of a valid range at +least as long as the range [first1, last1). n2944 tries to solve this +by positing a hypothetical last2 iterator that is implied by the +signature, and requires distance(first2,last2) < distance(first1,last1). + This mostly works, although I am uncomfortable assuming that last2 is +clearly defined and well known without any description of how to obtain +it (and I have no idea how to write that). +

+ +

+A second motivating example might be the copy algorithm. Specifically, +let us image a call like: +

+ +
copy(istream_iterator<int>(is),istream_iterator(),ostream_iterator<int>(os));
+
+ +

+In this case, our input iterators are literally simple InputIterators, +and the destination is a simple OutputIterator. In neither case am I +happy referring to std::distance, in fact it is not possible for the +ostream_iterator at all as it does not meet the requirements. However, +any wording we provide must cover both cases. Perhaps we might deduce +last2 == ostream_iterator<int>{}, but that might not always be valid for +user-defined iterator types. I can well imagine an 'infinite range' +that writes to /dev/null and has no meaningful last2. +

+ +

+The motivating example in n2944 is std::equal, and that seems to fall somewhere between the +two. +

+ +

+Outlying examples might be partition_copy that takes two output +iterators, and the _n algorithms where a range is specified by a +specific number of iterations, rather than traditional iterator pair. +We should also not accidentally apply inappropriate constraints to +std::rotate which takes a third iterator that is not intended to be a +separate range at all. +

+ +

+I suspect we want some wording similar to: +

+ +
+For algorithms that operate on ranges where the end iterator of the +second range is not specified, the second range shall contain at least +as many elements as the first. +
+ +

+I don't think this quite captures the intent yet though. I am not sure +if 'range' is the right term here rather than sequence. More awkwardly, +I am not convinced we can describe an Output sequence such as produce by +an ostream_iterator as "containing elements", at least not as a +precondition to the call before they have been written. +

+ +

+Another idea was to describe require that the trailing iterator support +at least distance(input range) applications of operator++ and may be +written through the same number of times if a mutable/output iterator. +

+ +

+We might also consider handling the case of an output range vs. an input +range in separate paragraphs, if that simplifies how we describe some of +these constraints. +

+ +

[ +2009-11-03 Howard adds: +]

+ + +
+Moved to Tentatively NAD Future after 5 positive votes on c++std-lib. +
+ + +

Rationale:

+

+Does not have sufficient support at this time. May wish to reconsider for a +future standard. +

+ + +

Proposed resolution:

+ + + + + +
+

1239. Defect report

+

Section: 20.7.4.3 [meta.unary.prop] Status: NAD Editorial + Submitter: David Abrahams Opened: 2009-10-16 Last modified: 2010-10-23

+

View all other issues in [meta.unary.prop].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Table 43 defines a number of traits that yield true for arrays of class +types with the trait's property, but not arrays of other types with that +property. For example, has_trivial_default_constructor: +

+ +
+T is a trivial type (3.9) or a class type with a trivial default +constructor (12.1) or an array of such a class type. +
+ +

[ +2009-10 post-Santa Cruz: +]

+ + +
+

+An array of a trivial type is a trivial type. +

+

+Mark as Tentatively NAD Editorial. The wording is OK as is, +since an array of a trivial type is a trivial type, but the wording as +proposed might be clearer. +

+
+ + + +

Rationale:

+

+The wording is OK as is, since an array of a trivial type is a trivial type. +Project editor may wish to accept the suggested wording as editorial. +

+ + +

Proposed resolution:

+

+Change all the traits in question following this pattern: +

+ +
+T is a trivial type (3.9) or a class type with a trivial default + constructor (12.1), or an array of such a class type. +
+ +

+i.e., add a comma and delete a "class." +

+ + + + + +
+

1242. Enable SCARY iterators

+

Section: 23 [containers] Status: NAD Future + Submitter: Herb Sutter Opened: 2009-10-21 Last modified: 2010-10-23

+

View all other issues in [containers].

+

View all issues with NAD Future status.

+

Discussion:

+

+See +N2980. +

+ + +

Proposed resolution:

+ + + + + +
+

1243. Missing operator+= (initializer_list<T>) for valarray

+

Section: 26.6.2.6 [valarray.cassign] Status: NAD + Submitter: Daniel Krügler Opened: 2009-10-22 Last modified: 2010-10-23

+

View all other issues in [valarray.cassign].

+

View all issues with NAD status.

+

Discussion:

+

Addresses JP 64

+ +

+During the additions of initializer_list overloads +basic_string added +

+ +
basic_string& operator+=(initializer_list<charT>);
+
+ +

+but +

+ +
valarray<T>& operator+= (initializer_list<T>);
+
+ +

+was not defined. +

+ +

[ +Daniel adds on opening: +]

+ + +
+Recommend NAD. The operator+= overload of basic_string +behaves as-if calling append, which is completely different in +meaning as the existing operator+= overloads in +valarray which just sum the value or values to the existing +elements. The suggestion to add a corresponding append function to +valarray was not considered as appropriate and the request was +withdrawn (c++std-lib-24968). +
+ +

[ +2009-10 Santa Cruz: +]

+ + +
+Mark as NAD. Request has been withdrawn by NB. +
+ + + +

Proposed resolution:

+

+Add to 26.6.2.6 [valarray.cassign]: +

+ +
valarray<T>& operator+= (initializer_list<T>);
+
+ + + + + +
+

1244. wait_*() in *future for synchronous functions

+

Section: 30.6 [futures] Status: NAD Editorial + Submitter: Detlef Vollmann Opened: 2009-10-22 Last modified: 2010-10-23

+

View all other issues in [futures].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+With the addition of async(), a future might be +associated with a function that is not running in a different thread but +is stored to by run synchronously on the get() call. It's not +clear what the wait() functions should do in this case. +

+ +

+Suggested resolution: +

+ +

+Throw an exception. +

+ +

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

+ + + + +

Rationale:

+

+Solved by +N3058. +

+ + +

Proposed resolution:

+ + + + + +
+

1246. vector::resize() missing efficiency guarantee

+

Section: 23.4.1.2 [vector.capacity] Status: NAD + Submitter: David Abrahams Opened: 2009-10-24 Last modified: 2010-10-23

+

View all other issues in [vector.capacity].

+

View all issues with NAD status.

+

Discussion:

+

+If v is a vector, I think repeated calls to +v.resize( v.size() + 1 ) should be amortized O(1), but it's not +clear that's true from the text of the standard: +

+ +
void resize(size_type sz);
+
+
+Effects: If sz < size(), equivalent to erase(begin() + sz, end());. If +size() < sz, appends sz - size() default constructed elements to the +sequence. +
+
+ +

+Seems to me if we used push_back instead of appends, we might be giving +the guarantee I'd like. Thoughts? +

+ +

[ +2009-11-10 Howard adds: +]

+ + +
+Moved to Tentatively NAD after 5 positive votes on c++std-lib. Rationale added +below. +
+ + + +

Proposed resolution:

+

+In 23.4.1.2 [vector.capacity]/10, change +

+ +
void resize(size_type sz);
+
+
+Effects: If sz < size(), equivalent to erase(begin() + sz, end());. If +size() < sz, appends sz - size() default constructed elements to the +sequence +equivalent to sz - size() consecutive evaluations of push_back(T()). +
+
+ + + +

Rationale:

+

+The description in terms of push_back led some to believe that +one could expect the exact same growth pattern from both resize and +push_back (e.g.) which could lead to sub-optimal implementations. +Additionally, 23.4.1 [vector], p1 includes a statement that this container +"supports (amortized) constant time insert and erase operations at the end;", +therefore addressing the concern of this issue. +

+ + + + + +
+

1248. Equality comparison for unordered containers

+

Section: 23.7 [unord] Status: NAD Editorial + Submitter: Herb Sutter Opened: 2009-10-25 Last modified: 2010-10-23

+

View all other issues in [unord].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+See +N2986. +

+ +

[ +2010-01-22 Alisdair Opens. +]

+ + +

[ +2010-01-24 Alisdair provides wording. +]

+ + +

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

+ + + + +

Rationale:

+

+Solved by +N3068. +

+ + +

Proposed resolution:

+

+Apply paper +N2986. +

+ + + + + +
+

1251. move constructing basic_stringbuf

+

Section: 27.8.1.1 [stringbuf.cons] Status: NAD + Submitter: Martin Sebor Opened: 2009-10-29 Last modified: 2010-10-23

+

View all other issues in [stringbuf.cons].

+

View all issues with NAD status.

+

Discussion:

+

+I just came across issue 1204 -- Global permission to move, which +seems to address the concern raised by the example in c++std-lib-25030. +

+

+IIUC, the example violates the permission to assume that arguments +bound to rvalue references are unnamed temporaries granted to +implementations by the resolution of issue 1204 - Global permission +to move. +

+ +

+I.e., the ostringstream(ostringstream &&rhs) ctor can leave the rhs +pointers pointing to the newly constructed object's buffer just as +long as the dtor doesn't change or invalidate the buffer. The caller +may not make any assumptions about rhs after the move beyond it being +safe to destroy or reassign. +

+ +

+So unless I misunderstood something, I still think the basic_stringbuf +move ctor is overspecified. Specifically, I think the third sentence +in the Effects clause and the last 6 bullets in the Postconditions +clause can, and IMO should, be stricken. +

+ +

[ +2010-01-31 Moved to Tentatively NAD after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + + +

Rationale:

+

+The sense of 1251 appears to be that the basic_stringbuf move +constructor offers more guarantees than the minimum. This is true, and quite +correct. The additional words guarantee that the internal buffer has genuinely +transferred from one object to another, and further operations on the original +will not affect the buffer of the newly created object. This is a very +important guarantee, much as we see that a moved-from unique_ptr is +guaranteed to be empty. +

+ + +

Proposed resolution:

+

+Strike from 27.8.1.1 [stringbuf.cons]: +

+ +
basic_stringbuf(basic_stringbuf&& rhs);
+
+
+

+Effects: Move constructs from the rvalue rhs. It is +implementation-defined whether the sequence pointers in *this +(eback(), gptr(), egptr(), pbase(), +pptr(), epptr()) obtain the values which rhs +had. Whether they do or not, *this and rhs reference +separate buffers (if any at all) after the construction. The openmode, +locale and any other state of rhs is also copied. +

+ +

+Postconditions: Let rhs_p refer to the state of +rhs just prior to this construction and let rhs_a +referto the state of rhs just after this construction. +

+
    +
  • +str() == rhs_p.str() +
    • +
  • +gptr() - eback() == rhs_p.gptr() - rhs_p.eback() +
    • +
  • +egptr() - eback() == rhs_p.egptr() - rhs_p.eback() +
    • +
  • +pptr() - pbase() == rhs_p.pptr() - rhs_p.pbase() +
    • +
  • +epptr() - pbase() == rhs_p.epptr() - rhs_p.pbase() +
    • +
  • +if (eback()) eback() != rhs_a.eback() +
    • +
  • +if (gptr()) gptr() != rhs_a.gptr() +
    • +
  • +if (egptr()) egptr() != rhs_a.egptr() +
    • +
  • +if (pbase()) pbase() != rhs_a.pbase() +
    • +
  • +if (pptr()) pptr() != rhs_a.pptr() +
    • +
  • +if (epptr()) epptr() != rhs_a.epptr() +
    • +
+
+
+ + + + + + +
+

1259. Should initializer-list constructors move elements?

+

Section: 23.2.3 [sequence.reqmts] Status: NAD + Submitter: Sean Hunt Opened: 2009-11-05 Last modified: 2010-10-23

+

View all other issues in [sequence.reqmts].

+

View all issues with NAD status.

+

Discussion:

+

+According to 23.2.3 [sequence.reqmts], X(il) is +equivalent to X(il.begin(), il.end()). Should it instead be +equivalent to X(move_iterator(il.begin()), +move_iterator(il.end())) so that needless copies are not made? This +doesn't seem ideal either - it may make more sense to provide two +overloads for the constructor, one for move and one for copy. +

+ +

[ +2009-11-10 Howard adds: +]

+ + +
+I've moved this issue to Tentatively NAD after 5 positive votes on c++std-lib, +and added a rationale below. +
+ + +

Proposed resolution:

+

+

+ + +

Rationale:

+

+There is no consensus at this time within EWG or CWG to make the +required language changes. Therefore this is not something that the LWG +can even consider. Should such language changes be made for a future +standard, no doubt there would need to be an accompanying library impact +survey. +

+ + + + + +
+

1263. missing swap overloads for regex

+

Section: 28.4 [re.syn] Status: NAD + Submitter: Howard Hinnant Opened: 2009-11-12 Last modified: 2010-10-23

+

View all issues with NAD status.

+

Discussion:

+ +

Addresses: UK 314

+ +

+In Message c++std-lib-25529, Alisdair writes: +

+ +
+

+UK comment 314 +requests rvalue swap overloads in a couple of places they +were missed. +

+ +

+We have in general reverted to the single swap signature taking lvalue +references, which could be seen as the alternative solution to +UK 314, +bringing consistency to the standard <g> +

+ +

+Either way, I no longer expect to see any work to resolve this comment - +the work is complete and it should be either marked Rejected, or +Accepted with Modifications (namely, removing all other rvalue swaps!) +

+
+ +

[ +Moved to Tentatively NAD after 5 positive votes on c++std-lib. +]

+ + + +

Proposed resolution:

+ + +

Rationale:

+

+We have in general reverted to the single swap signature taking +lvalue references, which could be seen as the alternative solution to +UK 314, bringing consistency to the standard. +

+ + + + + +
+

1265. longjmp and destructors

+

Section: 18.10 [support.runtime] Status: NAD + Submitter: Sean Hunt Opened: 2009-11-16 Last modified: 2010-10-23

+

View all other issues in [support.runtime].

+

View all issues with NAD status.

+

Discussion:

+

+18.10 [support.runtime]/4 says that longjmp is undefined if +unwinding by the mechanism used by catch and throw would invoke any nontrivial +destructors. However, the text as written is rather vague, in particular when +dealing with catch(...): +

+ +
void foo() {
+  jump_buf buf;
+  non_trivial_dtor n1; // 1
+  if (!setjmp(buf)) {
+    non_trivial_dtor n2; // 2
+    try {
+      longjmp(buf, 1);
+    } catch (...) {
+    }
+  }
+}
+
+ +

+My interpretation of the meaning of 18.10 [support.runtime]/4 is that +declaration 2, but not 1, would cause the longjmp to be undefined +behavior. However, it's not entirely clear from the text. Arguably, replacing +the setjmp and longjmp with catch would still cause +the destructor for n1 to be called after the unwinding, which would +lead to undefined behavior. This is clearly not an intended consequence of the +wording. However, it is probably still UB, as n1 now has +"indeterminate" value, and running its destructor on foo's exit will +cause Bad Things. +

+ +

+Declarations 2 has a more interesting issue. The catch(...) muddles up +the definition that uses throw and catch - if +longjmp() were indeed a throw, control would never return to +the setjmp. As such, n2's destructor wouldn't be called +(except by the argument for n1, which is that the destructor would be +called later as the frame was left in the normal control flow). +

+ +

+I suggest that paragraph 4 of 18.10 [support.runtime] should be replaced +with the following, or something that reads better but has the same effect: +

+ +
+The function signature longjmp(jmp_buf jbuf, int val) has more +restricted behavior in this International Standard. A call to longjmp +has undefined behavior if any non-trivial destructors would be called were the +longjmp call replaced with a throw-expression whose nearest matching +handler were a (possibly imaginary) function-try-block on the function +containing the corresponding setjmp call. +
+ +

[ +2009-11-17 Moved to Tentatively NAD after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + + +

Proposed resolution:

+

+Change 18.10 [support.runtime]/4: +

+ +
+The function signature longjmp(jmp_buf jbuf, int val) has more +restricted behavior in this International Standard. A +setjmp/longjmp call pair has undefined behavior if replacing +the setjmp and longjmp by catch and throw +would invoke any non-trivial destructors for any automatic objects. +A call to longjmp has undefined behavior if any non-trivial +destructors would be called were the longjmp call replaced with a +throw-expression whose nearest matching handler were a (possibly imaginary) +function-try-block on the function containing the corresponding setjmp +call. +
+ + +

Rationale:

+

+In the given example, it is clear that it is only n2 and not +n1 that is destroyed by the longjmp. +

+

+At this late stage in the standards process, we are focusing on issues that +impact users or implementers. Trying to rewrite complex wording just for the +sake of improved clarity is likely to do more harm than good. +

+ + + + + +
+

1266. shared_future::get and deferred async functions

+

Section: 30.6.7 [futures.shared_future] Status: NAD Editorial + Submitter: Anthony Williams Opened: 2009-11-17 Last modified: 2010-10-23

+

View all other issues in [futures.shared_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+If a shared_future is constructed with the result of an async call with a +deferred function, and two or more copies of that shared_future are created, +with multiple threads calling get(), it is not clear which thread runs the +deferred function. 30.6.7 [futures.shared_future]p22 from +N3000 +says (minus editor's note): +

+ +
+Effects: if the associated state contains a deferred function, executes +the deferred function. Otherwise, blocks until the associated state is ready. +
+ +

+In the absence of wording to the contrary, this implies that every thread that +calls wait() will execute the deferred function. +

+ +

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

+ + + + +

Rationale:

+

+Solved by +N3058. +

+ + +

Proposed resolution:

+

+Replace 30.6.7 [futures.shared_future]p22 with the following: +

+ +
+

+Effects: If the associated state +contains a deferred function, executes the deferred function. Otherwise, +blocks until the associated state is ready. +was created by a promise or packaged_task object, block +until the associated state is ready. If the associated state is associated with +a thread created for an async call (30.6.9 [futures.async]), as +if associated-thread.join(). +

+ +

+If the associated state contains a deferred function, calls to wait() +on all shared_future objects that share the same associated state are +serialized. The first call to wait() that shares a given associated +state executes the deferred function and stores the return value or exception in +the associated state. +

+ +

+Synchronization: if the associated state was created by a +promise object, the completion of set_value() or +set_exception() to that promise happens before (1.10 [intro.multithread]) wait() returns. If the associated state +was created by a packaged_task object, the completion of the associated +task happens before wait() returns. If the associated state is +associated with a thread created for an async call (30.6.9 [futures.async]), the completion of the associated thread happens-before +wait() returns. +

+ +

+If the associated state contained a deferred function, the invocation of the +deferred function happens-before any call to wait() on a +future that shares that state returns. +

+
+ + + + + +
+

1269. Associated state doesn't account for async

+

Section: 30.6.4 [futures.state] Status: NAD Editorial + Submitter: Anthony Williams Opened: 2009-11-18 Last modified: 2010-10-23

+

View other active issues in [futures.state].

+

View all other issues in [futures.state].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The current description of the associated state in 30.6.4 [futures.state] +does not allow for futures created by an async call. The description +therefore needs to be extended to cover that. +

+ +

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

+ + + + +

Rationale:

+

+Solved by +N3058. +

+ + +

Proposed resolution:

+

+Add a new sentence to 30.6.4 [futures.state] p2: +

+ +
+2 This associated state consists of some state information and some +(possibly not yet evaluated) result, which can be a (possibly +void) value or an exception. If the associated state was created +by a call to async (30.6.9 [futures.async]) then it may also +contain a deferred function or an associated thread. +
+ +

+Add an extra bullet to 30.6.4 [futures.state] p3: +

+ +
+

+The result of an associated state can be set by calling: +

+ +
+ + + + + +
+

1272. confusing declarations of promise::set_value

+

Section: 30.6.5 [futures.promise] Status: NAD Editorial + Submitter: Jonathan Wakely Opened: 2009-11-22 Last modified: 2010-10-23

+

View other active issues in [futures.promise].

+

View all other issues in [futures.promise].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The definitions of promise::set_value need tidying up, the +synopsis says: +

+ +
// setting the result
+void set_value(const R& r);
+void set_value(see below);
+
+ +

+Why is the first one there? It implies it is always present for all +specialisations of promise, which is not true. +

+ +

+The definition says: +

+ +
void set_value(const R& r);
+void promise::set_value(R&& r);
+void promise<R&>::set_value(R& r);
+void promise<void>::set_value();
+
+ +

+The lack of qualification on the first one again implies it's present +for all specialisations, again not true. +

+ +

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

+ + + + +

Rationale:

+

+Solved by +N3058. +

+ + +

Proposed resolution:

+

+Change the synopsis in 30.6.5 [futures.promise]: +

+ +
// setting the result
+void set_value(const R& r);
+void set_value(see below);
+
+ +

+And the definition be changed by qualifying the first signature: +

+ +
void promise::set_value(const R& r);
+void promise::set_value(R&& r);
+void promise<R&>::set_value(R& r);
+void promise<void>::set_value();
+
+ + + + + +
+

1273. future::valid should be callable on an invalid future

+

Section: 30.6.6 [futures.unique_future] Status: NAD Editorial + Submitter: Jonathan Wakely Opened: 2009-11-22 Last modified: 2010-10-23

+

View all other issues in [futures.unique_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+30.6.6 [futures.unique_future]/3 says: +

+ +
+The effect of calling any member function other than the destructor or +the move-assignment operator on a future object for which valid() == +false is undefined. +
+ +

+This means calling future::valid() is undefined unless it will +return true, so you can only use it if you know the answer! +

+ +

[ +2009-12-08 Moved to Tentatively Ready after 5 positive votes on c++std-lib. +]

+ + +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Editorial. Rationale added below. +
+ + + +

Rationale:

+

+Solved by N3058. +

+ + +

Proposed resolution:

+

+Change 30.6.6 [futures.unique_future]/3: +

+ +
+The effect of calling any member function other than the +destructor, or the move-assignment operator, or +valid, on a future object for which valid() +== false is undefined. +
+ + + + + + +
+

1274. atomic_future constructor

+

Section: 30.6.8 [futures.atomic_future] Status: NAD Editorial + Submitter: Jonathan Wakely Opened: 2009-11-22 Last modified: 2010-10-23

+

View all other issues in [futures.atomic_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In 30.6.8 [futures.atomic_future] this constructor: +

+ +
atomic_future(future<R>&&);
+
+ +

+is declared in the synopsis, but not defined. Instead +n2997 +defines: +

+ +
atomic_future(const future<R>&& rhs);
+
+ +

+and +n3000 +defines +

+ +
atomic_future(atomic_future<R>&& rhs);
+
+ +

+both of which are wrong. The constructor definition should be changed +to match the synopsis. +

+ +

[ +2009-12-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib. +]

+ + +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Editorial. Rationale added below. +
+ + + +

Rationale:

+

+Solved by N3058. +

+ + +

Proposed resolution:

+

+Adjust the signature above 30.6.8 [futures.atomic_future]/6 like so: +

+ +
atomic_future(atomic_future<R>&& rhs);
+
+ + + + + +
+

1275. creating and setting futures

+

Section: 30.6 [futures] Status: NAD Editorial + Submitter: Jonathan Wakely Opened: 2009-11-22 Last modified: 2010-10-23

+

View all other issues in [futures].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+30.6.6 [futures.unique_future]/1 should be updated to mention +async. +

+ +

+30.6.7 [futures.shared_future]/1 should also be updated for +async. That paragraph also says +

+ +
+... Its value or exception can be set by use of a +shared_future, promise (30.6.5 [futures.promise]), or packaged_task (30.6.10 [futures.task]) object that shares the same associated state. +
+ +

+How can the value be set by a shared_future? +

+ +

+30.6.8 [futures.atomic_future]/1 says +

+ +
+An atomic_future object can only be created by use of a +promise (30.6.5 [futures.promise]) or +packaged_task (30.6.10 [futures.task]) object. +
+ +

+which is wrong, it's created from a std::future, which could +have been default-cosntructed. That paragraph should be closer to the +text of 30.6.7 [futures.shared_future]/1, and should also mention +async. +

+ +

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

+ + + + +

Rationale:

+

+Solved by +N3058. +

+ + +

Proposed resolution:

+ + + + + +
+

1281. CopyConstruction and Assignment between ratios having the same normalized form

+

Section: 20.6.1 [ratio.ratio] Status: NAD Editorial + Submitter: Vicente Juan Botet Escribá Opened: 2009-12-07 Last modified: 2010-11-24

+

View all other issues in [ratio.ratio].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+CopyConstruction and Assignment between ratios having the same +normalized form. Current +N3000 +do not allows to copy-construct or assign ratio instances of +ratio classes having the same normalized form. +

+ +

+Two ratio classes ratio<N1,D1> and +ratio<N2,D2> have the same normalized form if +

+ +
ratio<N1, D1>::num == ratio<N2, D2>::num &&
+ratio<N1, D1>::den == ratio<N2, D2>::den
+
+ +

+This simple example +

+ +
ratio<1,3> r1;
+ratio<3,9> r2;
+r1 = r2; // (1)
+
+ +

+fails to compile in (1). Other example +

+ +
ratio<1,3> r1;
+ratio_subtract<ratio<2,3>, ratio<1,3>>::type r2;
+r1 = r2;  
+
+ +

+The nested type of ratio_subtract<ratio<2,3>, +ratio<1,3>> could be ratio<3,9> so the compilation +could fail. It could also be ratio<1,3> and the compilation +succeeds. +

+ +

+In 20.6.2 [ratio.arithmetic] 3 and similar clauses +

+ +
+3 The nested typedef type shall be a synonym for ratio<T1, +T2> where T1 has the value R1::num * R2::den - R2::num * +R1::den and T2 has the value R1::den * R2::den. +
+ +

+the meaning of synonym let think that the result shall be a normalized +ratio equivalent to ratio<T1, T2>, but there is not an +explicit definition of what synonym means in this context. +

+ +

+Additionally we should add a typedef for accessing the normalized +ratio, and change 20.6.2 [ratio.arithmetic] to return only this +normalized result. +

+ +

[ +2010 Pittsburgh: +]

+ + +
+

+There is no consensus to add the converting copy constructor or converting copy +assignment operator. However there was consensus to add the typedef. +

+ +

+Proposed wording modified. Original proposed wording preserved here. Moved to +Review. +

+ +
+

+Make ratio default constructible, copy-constructible and assignable +from any ratio which has the same reduced form. +

+ +

+Add to 20.6.1 [ratio.ratio] synopsis +

+ +
template <intmax_t N, intmax_t D = 1>
+class ratio {
+public:
+  static constexpr intmax_t num;
+  static constexpr intmax_t den;
+
+  typedef ratio<num, den> type;
+
+  ratio() = default;
+  template <intmax_t N2, intmax_t D2>
+    ratio(const ratio<N2, D2>&);
+  template <intmax_t N2, intmax_t D2>
+    ratio& operator=(const ratio<N2, D2>&);
+};
+
+ +

+Add to 20.6.1 [ratio.ratio]: +

+ +
+

+Two ratio classes ratio<N1,D1> and ratio<N2,D2> +have the same reduced form if ratio<N1,D1>::type is the same +type as ratio<N2,D2>::type +

+ +
+ +

+Add a new section: [ratio.cons] +

+ +
+

+Construction and assignment [ratio.cons] +

+ +
template <intmax_t N2, intmax_t D2>
+  ratio(const ratio<N2, D2>& r);
+
+ +
+

+Effects: Constructs a ratio object. +

+

+Remarks: This constructor shall not participate in overload resolution +unless r has the same reduced form as *this. +

+
+ +
template <intmax_t N2, intmax_t D2>
+  ratio& operator=(const ratio<N2, D2>& r);
+
+ +
+

+Effects: None. +

+

+Returns: *this. +

+

+Remarks: This operator shall not participate in overload resolution +unless r has the same reduced form as *this. +

+
+ +
+ +

+Change 20.6.2 [ratio.arithmetic] +

+ +
+

+Implementations may use other algorithms to compute these values. If overflow +occurs, a diagnostic shall be issued. +

+ +
template <class R1, class R2> struct ratio_add {
+  typedef see below type;
+};
+
+ +
+The nested typedef type shall be a synonym for ratio<T1, +T2>::type where T1 has the value R1::num * +R2::den + R2::num * R1::den and T2 has the value R1::den * +R2::den. +
+ +
template <class R1, class R2> struct ratio_subtract {
+  typedef see below type;
+};
+
+ +
+The nested typedef type shall be a synonym for ratio<T1, +T2>::type where T1 has the value R1::num * +R2::den - R2::num * R1::den and T2 has the value R1::den * +R2::den. +
+ +
template <class R1, class R2> struct ratio_multiply {
+  typedef see below type;
+};
+
+ +
+The nested typedef type shall be a synonym for ratio<T1, +T2>::type where T1 has the value R1::num * +R2::num and T2 has the value R1::den * R2::den. +
+ +
template <class R1, class R2> struct ratio_divide {
+  typedef see below type;
+};
+
+ +
+The nested typedef type shall be a synonym for ratio<T1, +T2>::type where T1 has the value R1::num * +R2::den and T2 has the value R1::den * R2::num. +
+ +
+ +
+ +
+ +

[ +2010-03-27 Howard adds: +]

+ + +
+

+Daniel brought to my attention the recent addition of the typedef type +to the FCD +N3092: +

+ +
typedef ratio type;
+
+ +

+This issue was discussed in Pittsburgh, and the decision there was to accept the +typedef as proposed and move to Review. Unfortunately the issue was accidently +applied to the FCD, and incorrectly. The FCD version of the typedef refers to +ratio<N, D>, but the typedef is intended to refer to +ratio<num, den> which in general is not the same type. +

+ +

+I've updated the wording to diff against +N3092. +

+ +
+ +

[Batavia: NAD Editorial - see rationale below]

+ + + + +

Rationale:

Already fixed in working draft + +

Proposed resolution:

+

+Add to 20.6.1 [ratio.ratio] synopsis +

+ +
template <intmax_t N, intmax_t D = 1>
+class ratio {
+public:
+  static constexpr intmax_t num;
+  static constexpr intmax_t den;
+
+  typedef ratio<num, den> type;
+};
+
+ + + + + + +
+

1282. A proposal to add std::split algorithm

+

Section: 25 [algorithms] Status: NAD Future + Submitter: Igor Semenov Opened: 2009-12-07 Last modified: 2010-10-23

+

View all other issues in [algorithms].

+

View all issues with NAD Future status.

+

Discussion:

+
    + +
  1. +

    +Motivation and Scope +

    +

    +Splitting strings into parts by some set of delimiters is an often task, but +there is no simple and generalized solution in C++ Standard. Usually C++ +developers use std::basic_stringstream<> to split string into +parts, but there are several inconvenient restrictions: +

    + +
      +
    • +we cannot explicitly assign the set of delimiters; +
      • +
    • +this approach is suitable only for strings, but not for other types of +containers; +
      • +
    • +we have (possible) performance leak due to string instantiation. +
      • +
    +
    2. + +
  2. +

    +Impact on the Standard +

    +

    +This algorithm doesn't interfere with any of current standard algorithms. +

    +
    3. + +
  3. +

    +Design Decisions +

    +

    +This algorithm is implemented in terms of input/output iterators. Also, there is +one additional wrapper for const CharType * specified delimiters. +

    +
    4. + +
  4. +

    +Example implementation +

    +
    template< class It, class DelimIt, class OutIt >
+void split( It begin, It end, DelimIt d_begin, DelimIt d_end, OutIt out )
+{
+   while ( begin != end )
+   {
+       It it = std::find_first_of( begin, end, d_begin, d_end );
+       *out++ = std::make_pair( begin, it );
+       begin = std::find_first_of( it, end, d_begin, d_end,
+           std::not2( std::equal_to< typename It::value_type >() ) );
+   }
+}
+
+template< class It, class CharType, class OutIt >
+void split( It begin, It end, const CharType * delim, OutIt out )
+{
+   split( begin, end, delim, delim + std::strlen( delim ), out );
+}
+
    +
    5. + +
  5. +

    +Usage +

    +
    std::string ss( "word1 word2 word3" );
+std::vector< std::pair< std::string::const_iterator, std::string::const_iterator > > v;
+split( ss.begin(), ss.end(), " ", std::back_inserter( v ) );
+
+for ( int i = 0; i < v.size(); ++i )
+{
+   std::cout << std::string( v[ i ].first, v[ i ].second ) << std::endl;
+}
+// word1
+// word2
+// word3
+
    +
    6. + +
+ +

[ +2010-01-22 Moved to Tentatively NAD Future after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + + +

Rationale:

+

+The LWG is not considering completely new features for standardization at this +time. We would like to revisit this good suggestion for a future TR and/or +standard. +

+ + +

Proposed resolution:

+

+Add to the synopsis in 25.1 [algorithms.general]: +

+ +
template< class ForwardIterator1, class ForwardIterator2, class OutputIterator >
+  void split( ForwardIterator1 first, ForwardIterator1 last,
+              ForwardIterator2 delimiter_first, ForwardIterator2 delimiter_last,
+              OutputIterator result );
+
+template< class ForwardIterator1, class CharType, class OutputIterator >
+  void split( ForwardIterator1 first, ForwardIterator1 last,
+              const CharType * delimiters, OutputIterator result );
+
+ +

+Add a new section [alg.split]: +

+ +
template< class ForwardIterator1, class ForwardIterator2, class OutputIterator >
+  void split( ForwardIterator1 first, ForwardIterator1 last,
+              ForwardIterator2 delimiter_first, ForwardIterator2 delimiter_last,
+              OutputIterator result );
+
+ +
+

+1. Effects: splits the range [first, last) into parts, using any +element of [delimiter_first, delimiter_last) as a delimiter. Results +are pushed to output iterator in the form of std::pair<ForwardIterator1, +ForwardIterator1>. Each of these pairs specifies a maximal subrange of +[first, last) which does not contain a delimiter. +

+

+2. Returns: nothing. +

+

+3. Complexity: Exactly last - first assignments. +

+
+ +
template< class ForwardIterator1, class CharType, class OutputIterator >
+  void split( ForwardIterator1 first, ForwardIterator1 last,
+              const CharType * delimiters, OutputIterator result );
+
+ +
+

+1. Effects: split the range [first, last) into parts, using any +element of delimiters (interpreted as zero-terminated string) as a +delimiter. Results are pushed to output iterator in the form of +std::pair<ForwardIterator1, ForwardIterator1>. Each of these +pairs specifies a maximal subrange of [first, last) which does not +contain a delimiter. +

+

+2. Returns: nothing. +

+

+3. Complexity: Exactly last - first assignments. +

+
+ +
+ + + + + +
+

1289. Generic casting requirements for smart pointers

+

Section: 20.3 [utility] Status: NAD Future + Submitter: Ion Gaztańaga Opened: 2009-12-14 Last modified: 2010-11-24

+

View all other issues in [utility].

+

View all issues with NAD Future status.

+

Discussion:

+

+In section 20.2.5 [allocator.requirements], Table 40 — Allocator requirements, +the following expression is required for allocator pointers: +

+ +
+ + + + + + + + + + + + + + +
Table 40 — Allocator requirements
ExpressionReturn typeAssertion/note
pre-/post-condition		Default
static_cast<X::pointer>(w)X::pointerstatic_cast<X::pointer>(w) == p 
+
+ +

+To achieve this expression, a smart pointer writer must introduce an explicit +conversion operator from smart_ptr<void> to +smart_ptr<T> so that +static_cast<pointer>(void_ptr) is a valid expression. +Unfortunately this explicit conversion weakens the safety of a smart pointer +since the following expression (invalid for raw pointers) would become valid: +

+ +
smart_ptr<void> smart_v = ...;
+smart_ptr<T> smart_t(smart_v);
+
+ +

+On the other hand, shared_ptr also defines its own casting functions in +20.9.10.2.10 [util.smartptr.shared.cast], and although it's unlikely that a +programmer will use shared_ptr as allocator::pointer, having +two different ways to do the same cast operation does not seem reasonable. A +possible solution would be to replace static_cast<X::pointer>(w) +expression with a user customizable (via ADL) +static_pointer_cast<value_type>(w), and establish the +xxx_pointer_cast functions introduced by shared_ptr as the +recommended generic casting utilities of the standard. +

+ +

+Unfortunately, we've experienced problems in Boost when trying to establish +xxx_pointer_cast as customization points for generic libraries (http://objectmix.com/c/40424-adl-lookup-explicit-template-parameters.html) +because these casting functions are called with explicit template parameters and +the standard says in 14.8.1 [temp.arg.explicit] p.8 "Explicit template +argument specification": +

+ +
+8 ...But when a function template with explicit template arguments is used, the +call does not have the correct syntactic form unless there is a function +template with that name visible at the point of the call. If no such name is +visible, the call is not syntactically well-formed and argument-dependent lookup +does not apply. +
+ +

+So we can do this: +

+ +
template<class BasePtr>
+void generic_ptr_swap(BasePtr p)
+{
+  //ADL customization point
+  swap(p, p);
+  //...
+}
+
+ +

+but not the following: +

+ +
template<class BasePtr>
+void generic_ptr_algo(BasePtr p)
+{
+  typedef std::pointer_traits<BasePtr>::template
+     rebind<Derived> DerivedPtr;
+  DerivedPtr dp = static_pointer_cast<Derived>(p);
+}
+
+ +

+The solution to make static_pointer_cast a customization point is to +add a generic declaration (no definition) of static_pointer_cast in a +namespace (like std) and apply "using +std::static_pointer_cast" declaration to activate ADL: +

+ +
namespace std{
+
+template<typename U, typename T>
+unspecified
+static_pointer_cast(T&&) = delete;
+
+}
+
+template<class BasePtr>
+void generic_ptr_algo(BasePtr p)
+{
+  typedef std::pointer_traits<BasePtr>::template
+     rebind<Derived> DerivedPtr;
+
+  //ADL applies because static_pointer_cast is made
+  //  visible according to [temp.arg.explicit]/8
+  using std::static_pointer_cast;
+
+  DerivedPtr dp = static_pointer_cast<Derived>(p);
+
+  //...
+}
+
+ +

+A complete solution will need also the definition of +static_pointer_cast for raw pointers, and this definition has been +present in Boost (http://www.boost.org/boost/ +pointer_cast.hpp) for years. +

+ +

[ +2010-03-26 Daniel made editorial adjustments to the proposed wording. +]

+ + +

[ +Moved to NAD Future at 2010-11 Batavia +]

+ +
+This is a new feature rather than a defect. +It can be added later: "this is such a hairy area that people will put up with changes" +
+ + + +

Proposed resolution:

+

+Add to section 20.3 [utility] Utility components, Header +<utility> synopsis: +

+ +
// 20.3.X, generic pointer cast functions
+
+template<typename U, typename T>
+unspecified
+static_pointer_cast(T&&) = delete;
+
+template<typename U, typename T>
+unspecified
+dynamic_pointer_cast(T&&) = delete;
+
+template<typename U, typename T>
+unspecified
+const_pointer_cast(T&&) = delete;
+
+//Overloads for raw pointers
+template<typename U, typename T>
+auto static_pointer_cast(T* t) -> decltype(static_cast<U*>(t));
+
+template<typename U, typename T>
+auto dynamic_pointer_cast(T* t) -> decltype(dynamic_cast<U*>(t));
+
+template<typename U, typename T>
+auto const_pointer_cast(T* t) -> decltype(const_cast<U*>(t));
+
+ +

+Add to section 20.3 [utility] Utility components, a new subclause +20.3.X Pointer cast utilities [pointer.cast]: +

+ +
+

+20.3.X Pointer cast utilities [pointer.cast] +

+ +

+1 The library defines generic pointer casting function templates so that template code +can explicitly make these names visible and activate argument-dependent lookup +for pointer cast calls. +

+ +
//Generic declarations
+template<typename U, typename T>
+unspecified
+static_pointer_cast(T&&) = delete;
+
+template<typename U, typename T>
+unspecified
+dynamic_pointer_cast(T&&) = delete;
+
+template<typename U, typename T>
+unspecified
+const_pointer_cast(T&&) = delete;
+
+ +

+2 The library also defines overloads of these functions for raw pointers. +

+ +
//Overloads for raw pointers
+template<typename U, typename T>
+auto static_pointer_cast(T* t) -> decltype(static_cast<U*>(t));
+
+ +
+Returns: static_cast<U*>(t) +
+ +
template<typename U, typename T>
+auto dynamic_pointer_cast(T* t) -> decltype(dynamic_cast<U*>(t));
+
+ +
+Returns: dynamic_cast<U*>(t) +
+ +
template<typename U, typename T>
+auto const_pointer_cast(T* t) -> decltype(const_cast<U*>(t));
+
+ +
+Returns: const_cast<U*>(t) +
+ +

+[Example: +

+ +
#include <utility> //static_pointer_cast
+#include <memory>  //pointer_traits
+
+class Base{};
+class Derived : public Base{};
+
+template<class BasePtr>
+void generic_pointer_code(BasePtr b)
+{
+   typedef std::pointer_traits<BasePtr>::template
+      rebind<Derived> DerivedPtr;
+
+   using std::static_pointer_cast;
+   //ADL applies now that static_pointer_cast is visible
+   DerivedPtr d = static_pointer_cast<Derived>(b);
+}
+
+ +

+— end example] +

+ +
+ +

+Replace in section 20.2.5 [allocator.requirements] Table 40 — Allocator +requirements, the following table entries for allocator pointers: +

+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
Table 40 — Allocator requirements
ExpressionReturn typeAssertion/note
pre-/post-condition		Default
static_pointer_cast<X::pointerT>(w)X::pointerstatic_pointer_cast<X::pointerT>(w) == p 
static_pointer_cast<X::const_pointerconst T>(w)X::const_pointerstatic_pointer_cast<X::const_pointerconst T>(z) == q 
+
+ + + + + + +
+

1291. exceptions thrown during promise::set_value

+

Section: 30.6.5 [futures.promise] Status: NAD Editorial + Submitter: Jonathan Wakely Opened: 2009-12-18 Last modified: 2010-10-23

+

View other active issues in [futures.promise].

+

View all other issues in [futures.promise].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+In 30.6.5 [futures.promise] +

+ +

+Does promise<R>::set_value return normally if the copy/move +constructor of R throws? +

+ +

+The exception could be caught and set using +promise<R>::set_exception, or it could be allowed to leave the +set_value call, but it's not clear which is intended. I suggest the +exception should not be caught. +

+ +

+N.B. This doesn't apply to promise<R&>::set_value or +promise<void>::set_value because they don't construct a new +object. +

+ +

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

+ + + + +

Rationale:

+

+Solved by +N3058. +

+ + +

Proposed resolution:

+

+Change 30.6.5 [futures.promise]/18: +

+ +
+18 Throws: future_error if its associated state is already +ready or, for the first version an exception thrown by the copy constructor +of R, or for the second version an exception thrown by the move +constructor of R. +
+ + + + + +
+

1296. map and multimap value_compare overspecified

+

Section: 23.6.1 [map] Status: NAD + Submitter: Alisdair Meredith Opened: 2009-12-22 Last modified: 2010-10-23

+

View all other issues in [map].

+

View all issues with NAD status.

+

Discussion:

+

+The container class templates map and multimap both contain a +nested type called value_compare, that is used to compare the +value_type pair elements, an adaptor of the user-supplied comparison +function-like object. +

+ +

+I believe these types are over-specified, as we require a distinct type for each +template, even though the allocator plays no part in the comparator, and +map and multimap value_compare classes could easily be shared. + The benefits are similar to the SCARY iterator proposal (although on a much +smaller scale!) but unlike SCARY, this is not a QoI issue today but actively +prohibited. +

+ +

+If the value_compare classes were marked 'exposition only', a vendor +would be free to experiment with implementations that do not produce so many +template instantiations with negligible impact on conforming programs. (There +is a minor risk that programs could no longer portably overload functions taking +value_compare types. This scenario is extremely unlikely outside +conformance suites.) +

+ +

+(Note that there are no similar problems for unordered maps, nor any of the set +variants) +

+ +

[ +2010-01-31 Moved to Tentatively NAD after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + +

Rationale:

+

+The value_compare specification is an unfortunate bit from the past +that we have to live with. Fortunately vendors can work around the problems +mentioned in this issue. +

+ + + + +

Proposed resolution:

+

+p2 23.6.1 [map]: +Above the declaration of class value_compare in the map synopsis, add: +

+ +
template <class Key, class T, class Compare = less<Key>,
+          class Allocator = allocator<pair<const Key, T> > >
+class map {
+public:
+  // types:
+  ...
+  // exposition only.
+  class value_compare
+    : public binary_function<value_type,value_type,bool> {
+    ...
+
+ + + +

+p2 23.6.2 [multimap]: +Above the declaration of class value_compare in the map synopsis, add: +

+ +
template <class Key, class T, class Compare = less<Key>,
+          class Allocator = allocator<pair<const Key, T> > >
+class multimap {
+public:
+  // types:
+  ...
+  // exposition only.
+  class value_compare
+    : public binary_function<value_type,value_type,bool> {
+    ...
+
+ + + + + +
+

1300. circular definition of promise::swap

+

Section: 30.6.5 [futures.promise] Status: NAD Editorial + Submitter: Jonathan Wakely Opened: 2009-12-26 Last modified: 2010-10-23

+

View other active issues in [futures.promise].

+

View all other issues in [futures.promise].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+30.6.5 [futures.promise]/12 defines the effects of +promise::swap(promise&) as +

+ +
void swap(promise& other);
+
+
+12 Effects: swap(*this, other) +
+
+ +

+and 30.6.5 [futures.promise]/25 defines swap(promise<R&>, +promise<R>&) as +

+ +
template <class R>
+  void swap(promise<R>& x, promise<R>& y);
+
+
+25 Effects: x.swap(y). +
+
+ +

[ +2010-01-13 Daniel added "Throws: Nothing." +]

+ + +

[ +2010-01-14 Moved to Tentatively Ready after 5 positive votes on c++std-lib. +]

+ + +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Editorial. Rationale added below. +
+ + + +

Rationale:

+

+Solved by N3058. +

+ + +

Proposed resolution:

+

+Change 30.6.5 [futures.promise] paragraph 12 +

+ +
void swap(promise& other);
+
+
+

+12 Effects: swap(*this, other) Exchanges the +associated +states of *this and other. +

+

+13 ... +

+

+Throws: Nothing. +

+
+
+ + + + + + +
+

1301. clear() and assignment

+

Section: 23.2.3 [sequence.reqmts] Status: NAD Editorial + Submitter: Nicolai Josuttis Opened: 2010-01-01 Last modified: 2010-10-23

+

View all other issues in [sequence.reqmts].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+I propose that clear() be defined to be equivalent to +erase(begin(),end()) except not using copy or move of elements. +

+ +
+

+To: C++ libraries mailing list
+Message c++std-lib-26465 +

+ +

+and specifiying as post: size()==0 might also not be appropriate +because forward-Lists provide no size(), this it should be: +post: empty()==true +

+ +

+Bjarne Stroustrup schrieb/wrote: +

+ +
+

+To: C++ libraries mailing list
+Message c++std-lib-26458 +

+ +

+in table 94 we define clear() as: +

+ +
a.clear() void erase(begin(), end())
+post: size() == 0
+
+ +

+Now erase requires assignment (MoveAssignable) which makes +sense if we have to move an element, but why should that be required from +clear() where all elements are destroyed? +

+
+
+ +

[ +2010-01-23 Alisdiar provides wording. +]

+ + +

[ +2010-01-30 Moved to Tentatively Ready after 5 positive votes on c++std-lib. +]

+ + +

[ +2010-01-30 Daniel opens: +]

+ + +
+

+First, I read the newly proposed spec for clear() that it does in +general not invalidate a previous past-the-end iterator value, but +deque says in 23.3.2.3 [deque.modifiers] for the semantics of +erase that erasures at the end will invalidate the past-the-end +iterator. With removal of a direct binding between clear() and +erase() there seem to be some fixes necessary. One way to fix that +would be to mention in Table 94 that this "may also invalidate the past-the-end +iterator" and then to mention for all specific containers where this does not +happen, the exception, [1] e.g. in std::vector. std::vector +has no own specification of clear() and one aspect of the closed issue +1102 was to realize just that (indirectly via erase). IMO +we should now add an extra specification for clear(). Btw.: +std::vector::erase reads to me that it would invalidate previous +past-the-end values (and that seems correct in general). +

+

+Before I will provide explicit wording, I would like to +discuss these points. +

+ +

+[1] std::list does fortunately specify that clear does not invalidate +the past-the-end iterator. +

+
+ +

[ +2010-02-08 Moved to Tentatively NAD Editorial after 5 positive votes on c++std-lib. +Rationale added below. +]

+ + + + +

Rationale:

+

+Solved as proposed by LWG 704. +

+ + +

Proposed resolution:

+ +

+Change 23.2.1 [container.requirements.general]/10: +

+ +
+

+Unless otherwise specified (see 23.2.4.1, 23.2.5.1, 23.3.2.3, and 23.3.6.4) all +container types defined in this Clause meet the following additional +requirements: +

+ + + +
+ +

+Replace the following words from Table 94 — Sequence container +requirements (in addition to container) in 23.2.3 [sequence.reqmts]: +

+ +
+ + + + + + + + + + + + + +
Table 94 — Sequence container requirements (in addition to +container)
ExpressionReturn typeAssertion/note
pre-/post-condition
a.clear()voiderase(begin(), end())
+Destroys all elements in the container a. Invalidates all references, +pointers, and iterators referring to the elements of a and may +invalidate the past-the-end iterator.
+post: size() == 0 a.empty() == true.
+
+ +

+Add a new paragraph after 23.3.3.4 [forwardlist.modifiers]/23: +

+ +
void clear();
+
+ +
+

+23 Effects: Erases all elements in the range [begin(),end()). +

+

+Remarks: Does not invalidate past-the-end iterators. +

+
+
+ + + + + + +
+

1302. different emplace semantics for sequence and associated containers

+

Section: 23.2.4 [associative.reqmts], 23.2.5 [unord.req] Status: NAD + Submitter: Nicolai Josuttis Opened: 2010-01-03 Last modified: 2010-10-23

+

View other active issues in [associative.reqmts].

+

View all other issues in [associative.reqmts].

+

View all issues with NAD status.

+

Discussion:

+

+According to the new naming scheme introduced with +N2680 +

+ +
vector<T> v;
+v.emplace(v.begin(),x,y,z)
+
+ +

+now has a different semantics than +

+ +
set<T> s;
+s.emplace(s.begin(),x,y,z);
+
+ +

+While the version for vectors takes the first argument as position and +the remaining for construction, the version for sets takes all +arguments for construction. +

+ +

+IMO, this is a serious design mistake for a couple of reasons: +

+ + + +

+I consider this to be a serious design penalty because once this +is specified we can't fix that without breaking backward compatibility. +

+ +

+However, we have two choices for a fix: +

+ + + +

[ +2010 Pittsburgh: Moved to NAD, rationale added below. +]

+ + + + +

Rationale:

+

+There was no consensus to make this change. +

+ + +

Proposed resolution:

+

In 23.2.5 [unord.req], change:

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Table 96 — Associative container requirements (in addition to + container)
expressionReturn typeAssertion/note pre-/post-conditionPost-condition
...
a_uniq.emplace_value(args)pair<iterator, bool>inserts a T object t constructed with std::forward<Args>(args)...
+ if and only if there is no element in the container with key equivalent + to the key of t.
+ The bool component of the returned pair is true if and only if the insertion + takes place, and the iterator component of the pair points to the element + with key equivalent to the key of t.		logarithmic
a_eq.emplace_value(args)iteratorinserts a T object t constructed with std::forward<Args>(args)... + and returns the iterator pointing to the newly inserted element.logarithmic
a.emplace_hint(p,args)iteratorequivalent to + a.emplace_value(std::forward<Args>(args)...). + Return value is an iterator pointing to the element with the key + equivalent to the newly inserted element. The const_iterator p is a hint + pointing to where the search should start. Implementations are permitted + to ignore the hint. logarithmic in general, but amortized + constant if the element is inserted right after p
...
+ +
+

In 23.2.5 [unord.req], change:

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Table 98 — Unordered associative container requirements (in + addition to container)
expressionReturn typeAssertion/note pre-/post-conditionPost-condition
...
a_uniq.emplace_value(args)pair<iterator, bool>inserts a T object t constructed with std::forward<Args>(args)... if + and only if there is no element in the container with key equivalent to + the key of t. The bool component of the returned pair is true if and only + if the insertion takes place, and the iterator component of the pair points + to the element with key equivalent to the key of t.Average case O(1), worst case O(a_uniq.size()).
a_eq.emplace_value(args)iteratorinserts a T object t constructed with std::forward<Args>(args)... + and returns the iterator pointing to the newly inserted element.Average case O(1), worst case O(a_eq.size()).
a.emplace_hint(p,args)iteratorequivalent to + a.emplace_value(std::forward<Args>(args)...). + Return value is an iterator pointing to the element with the key + equivalent to the newly inserted element. The const_iterator p is a hint + pointing to where the search should start. Implementations are permitted + to ignore the hint. Average case O(1), worst case + O(a.size()).
...
+
+ +

+In 23.6.1 [map], 23.6.3 [set], 23.7.1 [unord.map], 23.7.3 [unord.set], change: +

+
+

// modifiers:
+ template <class... Args> pair<iterator, bool> emplace_value(Args&&... + args);
+ template <class... Args> iterator emplace_hint(const_iterator + position, Args&&... args);

+
+ +

+In 23.6.2 [multimap], 23.6.4 [multiset], 23.7.2 [unord.multimap], 23.7.4 [unord.multiset], change: +

+
+

// modifiers:
template <class... Args> iterator emplace_value(Args&&... + args);
+ template <class... Args> iterator emplace_hint(const_iterator position, + Args&&... args);
+

+
+ + + + + +
+

1304. missing preconditions for shared_future

+

Section: 30.6.7 [futures.shared_future] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2010-01-23 Last modified: 2010-10-23

+

View all other issues in [futures.shared_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

+The revised futures package in the current working paper simplified the +is_ready/has_exception/has_value set of APIs, replacing them with a +single 'valid' method. This method is used in many places to signal pre- and +post- conditions, but that edit is not complete. Each method on a +shared_future that requires an associated state should have a +pre-condition that valid() == true. +

+ +

[ +2010-01-28 Moved to Tentatively Ready after 5 positive votes on c++std-lib. +]

+ + +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Editorial. Rationale added below. +
+ + + +

Rationale:

+

+Solved by N3058. +

+ + +

Proposed resolution:

+

+Insert the following extra paragraphs: +

+ +

+In 30.6.7 [futures.shared_future] +

+ +
shared_future();
+
+
+

+4 Effects: constructs ... +

+ +

+Postcondition: valid() == false. +

+ +

+Throws: nothing. +

+
+
+ +
void wait() const;
+
+
+ +

+Requires: valid() == true. +

+ +

+22 Effects: if the associated ... +

+
+
+ +
template <class Rep, class Period>
+  bool wait_for(const chrono::duration<Rep, Period>& rel_time) const;
+
+
+ +

+Requires: valid() == true. +

+ +

+23 Effects: if the associated ... +

+
+
+ +
template <class Clock, class Duration>
+  bool wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
+
+
+ +

+Requires: valid() == true. +

+ +

+25 Effects: blocks until ... +

+
+
+ + + + + + +
+

1305. preconditions for atomic_future

+

Section: 30.6.8 [futures.atomic_future] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2010-01-23 Last modified: 2010-10-23

+

View all other issues in [futures.atomic_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+ +

+The revised futures package in the current working paper simplified the +is_ready/has_exception/has_value set of APIs, replacing them with a +single 'valid' method. This method is used in many places to signal pre- and +post- conditions, but that edit is not complete. +

+ +

+Atomic future retains the extended earlier API, and provides defined, +synchronized behaviour for all calls. However, some preconditions and throws +clauses are missing, which can easily be built around the new valid() +api. Note that for consistency, I suggest is_ready/has_exception/has_value +throw an exception if valid() is not true, rather than +return false. I think this is implied by the existing pre-condition on +is_ready. +

+ +

[ +2010-01-23 See discussion starting with Message c++std-lib-26666. +]

+ + +

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

+ + + + +

Rationale:

+

+Solved by +N3058. +

+ + +

Proposed resolution:

+

+Insert the following extra paragraphs: +

+ +

+In 30.6.8 [futures.atomic_future] +

+ +
bool is_ready() const;
+
+
+

+17 Precondition Requires: valid() == true. +

+ +

+18 Returns: true only if the associated state is ready. +

+ +

+Throws: future_error with an error condition of +no_state if the precondition is not met. +

+ +
+
+ +
bool has_exception() const;
+
+
+ +

+Requires: valid() == true. +

+ +

+19 Returns: true only if the associated state is ready and +contains an exception. +

+ +

+Throws: future_error with an error condition of +no_state if the precondition is not met. +

+ +
+
+ +
bool has_value() const;
+
+
+ +

+Requires: valid() == true. +

+ +

+20 Returns: true only if the associated state is ready and +contains a value. +

+ +

+Throws: future_error with an error condition of +no_state if the precondition is not met. +

+ +
+
+ +
void wait() const;
+
+
+ +

+Requires: valid() == true. +

+ +

+22 Effects: blocks until ... +

+ +

+Throws: future_error with an error condition of +no_state if the precondition is not met. +

+ +
+
+ +
template <class Rep, class Period>
+  bool wait_for(const chrono::duration<Rep, Period>& rel_time) const;
+
+
+ +

+Requires: valid() == true. +

+ +

+23 Effects: blocks until ... +

+ +

+24 Returns: true only if ... +

+ +

+Throws: future_error with an error condition of +no_state if the precondition is not met. +

+ +
+
+ +
template <class Clock, class Duration>
+  bool wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
+
+
+ +

+Requires: valid() == true. +

+ +

+25 Effects: blocks until ... +

+ +

+26 Returns: true only if ... +

+ +

+Throws: future_error with an error condition of +no_state if the precondition is not met. +

+ +
+
+ + + + + + +
+

1308. Concerns about initializer_list overloads of min, +max, and minmax

+

Section: 25.4.7 [alg.min.max] Status: NAD + Submitter: Niels Dekker Opened: 2010-02-02 Last modified: 2010-10-23

+

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

+

View all issues with NAD status.

+

Discussion:

+

+In San Francisco, June 2008, N2722 +was adopted, replacing the variadic templates min, max, and +minmax by overloads that have an initializer_list<T> +parameter. The paper showed benchmark results wherein initializer_list +versions of min appeared to outperform the corresponding variadic +template. Unfortunately, in October 2009 a very serious error was detected in +the benchmark. (c++std-lib-25210). +In fact, an initializer_list<T> version of min often +appears to perform worse than the corresponding variadic template, +especially when T has an expensive copy constructor (c++std-lib-25253, +http://www.xs4all.nl/~nd/dekkerware/issues/n2772_fix). +

+

+IMO, the biggest problem of the initializer_list overloads is that they +pass and return T objects by value. Which has the following +consequences: +

+ +
    +
  1. +They require that T is CopyConstructible. IMO that is too much of a +constraint for a generic, general purpose function like +std::min<T>. +
    2. +
  2. +They potentially throw an exception, even if T's less-than-operator +throws nothing. (And of course, less-than typically throws nothing.) +
    3. +
  3. +They are inconsistent with C++03 std::min and std::max. +Consider the subtle difference between const T& c1 = min(a,b); and +const T& c2 = min({a,b}); (c++std-lib-25265) +
    4. +
  4. +They do not conveniently support use cases that need to have a reference to the +minimum or maximum object itself, rather than just a copy. +
    5. +
  5. +They potentially perform badly: possibly O(n), when the arguments +themselves have a size of n. +
    6. +
+ +

+In the future, this problem might be solvable by using an +initializer_list of const references, instead: +

+
const T& min(initializer_list<const T&>);
+const T& max(initializer_list<const T&>);
+pair<const T&, const T&> minmax(initializer_list<const T&>);
+
+ +

+It is unlikely that C++0x will support initializer_list<const +T&>, but technically it seems possible to add such a language +feature after C++0x (c++std-core-15428). +

+

+Variadic templates of min, max, and minmax, as +proposed by N2551 +(Sylvain Pion), do have some other advantages over initializer_list +overloads: +

+
    +
  1. +It is likely that those variadic templates can be declared constexpr, +now that +CWG issue #991 is in drafting status. +
    2. +
  2. +They provide complete compile-time protection against accidentally passing zero +arguments. +
    3. +
+ +

+Unfortunately, the variadic templates of min, max, and +minmax may still need further improvement, before having them in the +Standard Library. Especially the optional Compare parameter appears to +be a concern. So for this moment I recommend to keep both versions out of C++0x, +and postpone further discussion until after C++0x. +

+ +

[ +2010 Pittsburgh: Discussed and the LWG still prefers the initializer list +solution of +N2772. +]

+ + + + +

Rationale:

+We prefer the solution of +N2772 +which will be reapplied. + + +

Proposed resolution:

+

+Remove both variadic templates and initializer_list overloads of +min, max, and minmax from the synopsis in +25.1 [algorithms.general] and from 25.4.7 [alg.min.max]. +

+ +
+

[ +Note: This proposed resolution will resolve LWG 915 as NAD. +]

+ +
+ + + + + +
+

1311. multi-pass property of Forward Iterator underspecified

+

Section: 24.2.5 [forward.iterators] Status: NAD Editorial + Submitter: Alisdair Meredith Opened: 2010-02-07 Last modified: 2010-10-23

+

View all other issues in [forward.iterators].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The following example demonstrates code that would meet the guarantees of a +Forward Iterator, but only permits a single traversal of the underlying +sequence: +

+ +
template< typename ForwardIterator>
+struct bad_iterator {
+  shared_ptr<ForwardIterator> impl;
+
+  bad_iterator( ForwardIterator iter ) {
+     : impl{new ForwardIterator{iter} } 
+     {
+  }
+
+  auto operator*() const -> decltype(*ForwardIterator{}) {
+     return **impl;
+  }
+
+  auto operator->() const -> ForwardIterator {
+     return *impl;
+  }
+
+  auto operator==(bad_iterator const & rhs) {
+     return impl == rhs.impl;
+  }
+
+  auto operator++() {
+     ++(*imp);
+  }
+  // other operations as necessary...
+};
+
+ +

+Here, we use shared_ptr to wrap a forward iterator, so all iterators +constructed from the same original iterator share the same 'value', and +incrementing any one copy increments all others. +

+ +

+There is a missing guarantee, expressed by the following code sequence +

+ +
FwdIter x = seq.begin();  // obtain forward iterator from a sequence
+FwdIter y = x;            // copy the iterator
+assert(x == y);           // iterators must be the same
+++x;                      // increment *just one* iterator
+assert(x != y);           // iterators *must now be different*
+++y;                      // increment the other iterator
+assert(x == y);           // now the iterators must be the same again
+
+ +

+That inequality in the middle is an essential guarantee. Note that this list is +simplified, as each assertion should also note that they refer to exactly the +same element (&*x == &*y) but I am not complicating the issue +with tests to support proxy iterators, or value types overloading unary +operator+. +

+ +

+I have not yet found a perverse example that can meet this additional +constraint, and not meet the multi-pass expectations of a Forward Iterator +without also violating other Forward Iterator requirements. +

+ +

+Note that I do not yet have standard-ready wording to resolve the problem, as +saying this neatly and succinctly in 'standardese' is more difficult. +

+ +

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

+ + + + +

Rationale:

+

+Solved by +N3066. +

+ + +

Proposed resolution:

+ + + + + +
+

1313. Seed sequence's param function not useful for pure output iterator

+

Section: 26.5.7.1 [rand.util.seedseq] Status: NAD + Submitter: Daniel Krügler Opened: 2010-02-07 Last modified: 2010-10-23

+

View all other issues in [rand.util.seedseq].

+

View all issues with NAD status.

+

Discussion:

+

+The Seed sequence requirements (26.5.1.2 [rand.req.seedseq]) require the +existence of a member function +

+ +
template<typename OutputIterator>
+void param(OutputIterator ob);
+
+ +

+The fact that this function returns void instead of the value of +ob after accepting the sequence data leads to the same problem as in +issue 865 - In case of pure output iterators there is no way to +serialize further data into that data sink. +

+ +

[ +2010-02-07 Howard adds: +]

+ + +
+At the time this issue was opened, the suggested changes are with respect to an +anticipated draft which does not yet exist. +
+ +

[ +2010 Pittsburgh: +]

+ + +
+No technical counterarguments, but it is simply too late in the process +to make this change at this point. +
+ + +

Proposed resolution:

+
    +
  1. +

    +In Table 109 — Seed sequence requirements, expression "r.param(ob)" +change the
    +Return type entry: +

    + +
    voidOutputIterator
+
    +
    2. + +
  2. +

    +In 26.5.7.1 [rand.util.seedseq], class seed_seq synopsis change +

    + +
    template<class OutputIterator>
+voidOutputIterator param(OutputIterator dest) const;
+
    +
    3. + +
+ + + + + + +
+

1314. NULL and nullptr

+

Section: 18.2 [support.types] Status: NAD + Submitter: Sean Hunt Opened: 2010-02-07 Last modified: 2010-10-23

+

View all other issues in [support.types].

+

View all issues with NAD status.

+

Discussion:

+

+Currently, the 18.2 [support.types]/3 allows NULL to be any +null pointer constant. The footnote marks that 0 or 0L might be appropriate. +However, this definition also allows the implementation to define NULL +to be nullptr. This may lead to overload and conversion issues more +serious than with the C++98 version: +

+ +
void f(void*);
+void f(int);
+
+void g()
+{
+ // calls f(int) if NULL is integral
+ // calls f(void*) if NULL is nullptr
+ f(NULL);
+}
+
+ +

+Possible resolutions: +

+ + +

+Making NULL nullptr would improve code correctness, and +breaking backwards compatibility shouldn't be a huge concern as NULL +shouldn't be used except as a null pointer constant anyways. +

+ +

[ +2010-02-10 Chris provided wording. +]

+ + +

[ +2010 Pittsburgh: Moved to NAD, rationale added below. +]

+ + + + +

Rationale:

+

+The LWG discussed the proposed resolution and several other options. There was +no concensus to make this or any other changes. +

+ + +

Proposed resolution:

+

+18.2 [support.types] +

+ +
+

+3 The macro NULL is defined to be nullptr. is +an implementation-defined C++ null pointer constant in this International +Standard (4.10).196 +

+ +

+196) Possible definitions include 0 and 0L, but not +(void*)0. +

+
+ +

+20.9.13 [c.malloc] +

+ +
+7 The contents are the same as the Standard C library header +<string.h>, with the change to memchr() specified in +21.6 and the macro NULL defined to be nullptr. +
+ + +

+20.12 [date.time] +

+ +
+2 The contents are the same as the Standard C library header +<time.h>.232 except the macro +NULL, which is defined to be nullptr. The functions +asctime, ctime, gmtime, and localtime are +not required to avoid data races (17.6.4.8). +
+ + +

+22.6 [c.locales] +

+ +
+2 The contents are the same as the Standard C library header +<locale.h> except the macro NULL, which is defined +to be nullptr. +
+ +

+C.2.2.4 [diff.null] +

+ +
+1 The macro NULL, defined in any of <clocale>, +<cstddef>, <cstdio>, <cstdlib>, +<cstring>, <ctime>, or <cwchar>, is +nullptr an implementation-defined C++ null pointer constant in +this International Standard (18.2). +
+ + + + + + +
+

1315. return type of async

+

Section: 30.6.9 [futures.async] Status: NAD Editorial + Submitter: Jonathan Wakely Opened: 2009-02-09 Last modified: 2010-10-23

+

View all other issues in [futures.async].

+

View all issues with NAD Editorial status.

+

Discussion:

+

+Both overloads of async return future<typename +F::result_type> which requires that F has a nested type. This +prevents async being used with function pointers and makes the example +in 30.6.9 [futures.async] invalid. I believe this is unintentional. +

+ +

+The proposed resolution also addresses editorial issues with the +launch_policy function parameter. +

+ +

+For the first overload it is not sufficient to return future<typename +result_of<F(ArgTypes...)>::type>. Calling async(launch::xxx, +foo, bar) performs argument deduction on both async overloads, +which for the first overload attempts to instantiate result_of<launch(F, +ArgTypes...)>, which is invalid. SFINAE must be used to prevent that. +

+ +

[ +2010-02-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib. +]

+ + +

[ +2010-02-12 Daniel opens: +]

+ + +
+

+[..] if decay<F>::type is of type std::launch. +

+

+or +

+

+[..] if remove_cv<remove_reference<F>::type>::type is of +type std::launch. +

+ +

+The latter is the more specific form, but the former is equivalent to +the latter for all cases that can occur here. I suggest to use the +former for simplicity, but expect that implementations can effectively +use the latter. + +

+
+ +

[ +2010-02-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib. +]

+ + +

[ +2010 Pittsburgh: +]

+ + +
+Moved to NAD Editorial. Rationale added below. +
+ + + +

Rationale:

+

+Solved by N3058. +

+ + +

Proposed resolution:

+

+In 30.6.1 [futures.overview] paragraph 1: +

+ +
template <class F, class... Args>
+  future<typename F::result_type>
+  future<typename result_of<F(Args...)>::type>
+  async(F&& f, Args&&... args);
+template <class F, class... Args>
+  future<typename F::result_type>
+  future<typename result_of<F(Args...)>::type>
+  async(launch policy, F&& f, Args&&... args);
+
+ +

+In 30.6.9 [futures.async] before paragraph 1 +

+ +
template <class F, class... Args>
+  future<typename F::result_type>
+  future<typename result_of<F(Args...)>::type>
+  async(F&& f, Args&&... args);
+template <class F, class... Args>
+  future<typename F::result_type>
+  future<typename result_of<F(Args...)>::type>
+  async(launch policy, F&& f, Args&&... args);
+
+
+

...

+

+Remarks: The first signature shall not participate in overload resolution +if decay<F>::type is std::launch. +

+
+
+ + + + + + +
+

1317. make_hash

+

Section: 20.8.15 [unord.hash] Status: NAD Future + Submitter: Nicolai M. Josuttis Opened: 2010-02-10 Last modified: 2010-10-23

+

View all other issues in [unord.hash].

+

View all issues with NAD Future status.

+

Discussion:

+

+Currently, the library lacks a convenient way to provide a hash function that +can be used with the provided unordered containers to allow the usage of non +trivial element types. +

+ +

+While we can easily declare an +

+ +
std::unordered_set<int>
+
+ +

+or +

+ +
std::unordered_set<std::string>
+
+ +

+we have no easy way to declare an unordered_set for a user defined +type. IMO, this is a big obstacle to use unordered containers in practice. Note +that in Java, the wide usage of HashMap is based on the fact that there +is always a default hash function provided. +

+ +

+Of course, a default hash function implies the risk to provide poor hash +functions. But often even poor hash functions are good enough. +

+ +

+While I really would like to see a default hash function, I don't propose it +here because this would probably introduce a discussion that's too big for this +state of C++0x. +

+ +

+However, I strongly suggest at least to provide a convenience variadic template +function make_hash<>() to allow an easy definition of a (possibly +poor) hash function. +

+ +

+As a consequence for a user-defined type such as +

+ +
class Customer {
+   friend class CustomerHash;
+   private:
+     string firstname;
+     string lastname;
+     long   no;
+   ...
+ };
+
+ +

+would allow to specify: +

+ +
class CustomerHash : public std::unary_function<Customer, std::size_t>
+{
+  public:
+    std::size_t operator() (const Customer& c) const  {
+       return make_hash(c.firstname,c.lastname,c.no);
+    }
+};
+
+ +

+instead of: +

+ +
class CustomerHash : public std::unary_function<Customer, std::size_t>
+{
+  public:
+    std::size_t operator() (const Customer& c) const  {
+       return std::hash<std::string>()(c.firstname) +
+              std::hash<std::string>()(c.lastname) +
+              std::hash<long>()(c.no);
+    }
+};
+
+ +

+Note that, in principle, we can either specify that +

+ +
+make_hash returns the sum of a call of +std::hash<T>()(x) for each argument x of type +T +
+ +

+or we can specify that +

+ +
+make_hash provides a hash value for each argument, for which a +std::hash() function is provided +
+ +

+with the possible note that the hash value may be poor or only a good hash value +if the ranges of all passed arguments is equally distributed. +

+ +

+For my convenience, I propose wording that describes +the concrete implementation. +

+ +

[ +2010 Pittsburgh: Moved to NAD Editorial, rationale added below. +]

+ + + + +

Rationale:

+

+There is no consensus to make this change at this time. +

+ + +

Proposed resolution:

+

+In Function objects 20.8 [function.objects] +in paragraph 2 at the end of the Header <functional> synopsis +insert: +

+ +
// convenience functions
+template <class T>
+  size_t make_hash (const T&);
+template <class T, class... Types>
+  size_t make_hash (const T&, const Types&...);
+
+ +

+In Class template hash 20.8.15 [unord.hash] +add: +

+ +
+

+20.7.16.1 Hash creation functions [hash.creation] +

+ +
template <class T>
+  size_t make_hash (const T& val);
+
+ +
+Returns: hash<T>()(val); +
+ +
template <class T, class... Types>
+  size_t make_hash (const T& val, const Types&... args);
+
+ +
+Returns: hash<T>()(val) + std::make_hash(args...) +
+ +
+ + + + + + +
+

1329. Data races on vector<bool>

+

Section: 23.2.2 [container.requirements.dataraces] Status: NAD Editorial + Submitter: Jeffrey Yaskin Opened: 2010-03-09 Last modified: 2010-10-23

+

View all issues with NAD Editorial status.

+

Discussion:

+

+The common implementation of vector<bool> is as an +unsynchronized bitfield. The addition of 23.2.2 [container.requirements.dataraces]/2 would require either a +change in representation or a change in access synchronization, both of +which are undesireable with respect to compatibility and performance. +

+ +

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

+ + + + +

Rationale:

+

+Solved by +N3069. +

+ + +

Proposed resolution:

+

+Container data races 23.2.2 [container.requirements.dataraces] +

+ +

+Paragraph 1 is unchanged as follows: +

+ +
+1 For purposes of avoiding data races (17.6.4.8), implementations shall +consider the following functions to be const: +begin, end, rbegin, +rend, front, back, +data, find, lower_bound, +upper_bound, equal_range, and, except in +associative containers, operator[]. +
+ +

+Edit paragraph 2 as follows: +

+ +
+2 Notwithstanding (17.6.4.8), implementations are required to avoid data +races when the contents of the contained object in different elements in +the same sequence, excepting vector<bool>, +are modified concurrently. +
+ +

+Edit paragraph 3 as follows: +

+ +
+3 [Note: +For a vector<int> x with a size greater than one, +x[1] = 5 and *x.begin() = 10 +can be executed concurrently without a data race, +but x[0] = 5 and *x.begin() = 10 +executed concurrently may result in a data race. +As an exception to the general rule, +for a vector<bool> y, +y[i] = true may race with y[j] = true. +—end note] +
+ + + + + + +
+

1331. incorporate move special member functions into library

+

Section: 17 [library] Status: NAD + Submitter: Martin Sebor Opened: 2010-03-10 Last modified: 2010-11-29

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with NAD status.

+

Discussion:

+

+Review the library portion of the spec and incorporate the newly added +core feature Move Special Member Functions (N3044). +

+ +

Rationale:

+2010 Batavia: This has now been done to a large extent. + + + + +

Proposed resolution:

+ + + + + +
+

1350. [FCD] Implicit contructors accidentally made some library types move-only

+

Section: 17 [library] Status: Dup + Submitter: Switzerland Opened: 2010-08-25 Last modified: 2010-10-25

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with Dup status.

+

Duplicate of: 1421

+

Discussion:

+

Addresses CH-15

+

+Due to the new rules about implicit copy and move +constructors some library facilities are now move-only. +

+ +

[ +Resolution proposed by ballot comment +]

+ +

+Make them copyable again. +

+ + +

Proposed resolution:

+ + + + + +
+

1351. [FCD] Replace dynamic exception specifications with noexcept

+

Section: 17 [library] Status: Dup + Submitter: Switzerland Opened: 2010-08-25 Last modified: 2010-10-25

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with Dup status.

+

Duplicate of: 1344

+

Discussion:

+ +

Addresses CH-16

+

+Dynamic exception specifications are deprecated. +Deprecated features shouldn't be used in the Standard. +

+ +

[ +Resolution proposed by ballot comment +]

+ +

+Replace dynamic exception specifications with noexcept. +

+ + +

Proposed resolution:

+ + + + + +
+

1352. [FCD] Apply noexcept where library specification says "Throws: Nothing"

+

Section: 17 [library] Status: Dup + Submitter: Switzerland Opened: 2010-08-25 Last modified: 2010-10-25

+

View other active issues in [library].

+

View all other issues in [library].

+

View all issues with Dup status.

+

Duplicate of: 1346

+

Discussion:

+ +

Addresses CH-17

+

+The introduction of noexcept makes "Throws: Nothing" clauses looking strange. +

+ +

[ +Resolution proposed by ballot comment +]

+ +

+Consider replacing "Throws: Nothing." clause by +the respective noexcept specification. +

+ + + +

Proposed resolution:

+ + + + + +
+

1359. [FCD] Add <tuple> and <utility> to freestanding implementations

+

Section: 17.6.1.3 [compliance] Status: NAD + Submitter: BSI Opened: 2010-08-25 Last modified: 2010-11-29

+

View all other issues in [compliance].

+

View all issues with NAD status.

+

Discussion:

+

Addresses GB-56

+

+The <utility> header provides support for several +important C++ idioms with move, forward and swap. +Likewise, declval will be frequently used like a type trait. +In order to complete cycles introduced by std::pair, the +<tuple> header should also be made available. This is a +similarly primitive set of functionality, with no dependency +of a hosted environment, but does go beyond the minimal +set of functionality otherwise suggested by the +freestanding libraries. +

+

+Alternatively, split the move/forward/swap/declval +functions out of <utility> and into a new primitive header, +requiring only that of freestanding implementation. +

+ +

[ +Summary of Rapperswil discusions +]

+ +

+The preference of the meeting was to extract the rvalue-reference related utilities and swap into a freestanding header, but there was no clear preference for a name. Howard suggested simply dropping them into <type_traits> as both these utilities and type traits are used pretty much everywhere in the library implementation, it is the most convenient place to keep them (from an implementer's perspective). +

+ +

+Poll: Two-way: New header for forward, move, swap, move_with_noexcept and declval vs. calling out forward, move, swap, move_with_noexcept and declval as freestanding explicitly? + +SF new header: 4 WF new header: 3 WF call out as freestanding: 1 SF call out as freestanding: 2 + +Alisdair: Willing to write up both solutions, give us some time to think on it. + +Action: Need an issue and proposed wording for GB 56 - Alisdair to draft both options as in the last poll. +

+ +

[ +Resolution proposed by ballot comment +]

+ +
+

+Add <utility> and <tuple> to table 15, headers +required for a free-standing implementation. +

+
+ +

[ +2010-Batavia: +]

+ +

+Closed as NAD, reversing the decision at Rapperswil. +

+

+The consensus was that +any freestanding implementation is going to feel compelled to offer the important +features of <utility> even if we do not make them a freestanding +requirement; breaking out additional small headers may have additional costs at +compile time, and while the critical move-related functions could migrate +to <type_traits>, the header name is far from appealing; adding the +whole of <utility> starts to drag in dependencies on <tuple> +and <memory>, so we prefer to place the burden of slicing or supporting +this whole header on free-standing vendors. +

+ + + +

Proposed resolution:

+ + +

Rationale:

No consensus for a change at this time. + + + + + +
+

1361. [FCD] Does use of std::size_t in a header imply that typedef name is available to users?

+

Section: 17.6.2 [using] Status: NAD + Submitter: BSI Opened: 2010-08-25 Last modified: 2010-11-29

+

View all issues with NAD status.

+

Discussion:

+

Addresses GB-58

+

+It is not clear whether a library header specified in terms +of a typedef name makes that same typedef name +available for use, or if it simply requires that the specified +type is an alias of the same type, and so the typedef name +cannot be used without including the specific header that +defines it. For example, is the following code required to +be accepted: +

+
#include <vector>
+std::size_t x = 0;
+
+

+Most often, this question concerns the typedefs defined in +header <cstddef> +

+ +

[ +Resolution proposed by ballot comment: +]

+ +

+Add a paragraph under 17.6.2 [using] clarifying whether +or not headers specified in terms of std::size_t can +be used to access the typedef size_t, or whether +the header <cstddef> must be included to reliably +use this name. +

+

[Batavia: NAD - see rationale below]

+ + + + +

Proposed resolution:

+ +

Rationale:

The standard is correct as written. + + + + +
+

1373. [FCD] Customizable traits should have their own headers

+

Section: 20.3 [utility] Status: NAD + Submitter: BSI Opened: 2010-08-25 Last modified: 2010-11-29

+

View all other issues in [utility].

+

View all issues with NAD status.

+

Discussion:

+

Addresses GB-79

+

+The library provides several traits mechanisms intended a +customization points for users. Typically, they are +declared in headers that are growing quite large. This is +not a problem for standard library vendors, who can +manage their internal file structure to avoid large +dependencies, but can be a problem for end users who +have no option but to include these large headers. +

+ +

[ +2010 Rapperswil +]

+ +

+There was no enthusiasm for touching char_traits or regex_traits. +Consensus to move iterator_traits, allocator_traits +and pointer_traits to their own respective headers once wording supplied. +

+ +

[ +2010 Rapperswil +]

+ +

+After some discussion, consensus is that moving these features into separate +headers does not buy much in practice, as the larger headers will inevitably +be included anyway. Resolve as NAD. +

+ +

[ +Resolution proposed in ballot comment +]

+ +

+Move the following traits classes into their own +headers, and require the existing header to +#include the traits header to support backwards +compatibility: +

+
iterator_traits (plus the iterator tag-types)
+allocator_traits
+pointer_traits
+char_traits
+regex_traits
+
+ +

[ +2010 Batavia: +]

+ +

+Closed as NAD with the rationale below. +

+ + + +

Rationale:

+This suggest is not a defect, as the likely benefit is small, if any, +compared to the cost of not just implementating the feature, but also +explaining/teaching it. + + +

Proposed resolution:

+ + + + + +
+

1375. [FCD] reference_type should not have been removed from the +allocator requirements

+

Section: 20.2.5 [allocator.requirements] Status: Dup + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-04

+

View all other issues in [allocator.requirements].

+

View all issues with Dup status.

+

Duplicate of: 1318

+

Discussion:

+ +

Addresses US-87

+

+reference_type should not have been removed from the +allocator requirements. Even if it is always the same as +value_type&, it is an important customization point for +extensions and future features. +

+ + +

Proposed resolution:

+

+In [allocator.requirements] Table 42 - Allocotor Requirements, +Add a row (after value_type) with columns: +

+
+Expression: X::reference_type
+Return type: T&
+Assertion/note...: (empty)
+Default: T&
+
+

+[allocator.traits]: +

+
namespace std {
+  template <class Alloc> struct allocator_traits {
+    typedef Alloc allocator_type;
+    
+    typedef typename Alloc::value_type value_type;
+
+    typedef see below   pointer;
+    typedef see below   const_pointer;
+    typedef see below   void_pointer;
+    typedef see below   const_void_pointer;
+    typedef value_type& reference_type;
+
+ +Add reference_type to +allocator_traits template, defaulted to +value_type&. + + + + + +
+

1376. [FCD] Allocator interface is not backward compatible

+

Section: 20.2.5 [allocator.requirements] Status: NAD + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-29

+

View all other issues in [allocator.requirements].

+

View all issues with NAD status.

+

Discussion:

+

Addresses US-88

+

+Allocator interface is not backward compatible. +

+ +

[ +Resolution proposed by ballot comment +]

+ +

+See Appendix 1 - Additional Details +

+ +

[ +2010-10-24 Daniel adds: +]

+ + +
+n3165 provides an alternative resolution. +
+ +

[ +2910 Batavia: +]

+ +

+Closed as NAD - withdrawn by the submitter. +

+ + +

Proposed resolution:

+See n3165 + + +

Rationale:

Withdrawn by the submitter. + + + + +
+

1395. [FCD] Ballot Comment JP-32

+

Section: 20.7.6 [meta.rel] Status: NAD Editorial + Submitter: Japan Opened: 2010-08-25 Last modified: 2010-11-29

+

View all other issues in [meta.rel].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses JP-32

+

+Representations of reference link are not unified. +Most reference links to clause (table) number, say X, are +in the form "Clause X" ("Table X") capitalized, and +subsection Y.Y.Y is referenced with its number only in the +form "Y.Y.Y". Whether they are parenthesized or not +depends on the context. +However there are some notations "(Z)" consisting of only +a number Z in parentheses to confer Clause or Table +number Z. +

+ + +

Proposed resolution:

+Change "(10)" to "(Clause 10)". + + + + + +
+

1398. [FCD] Users should be able to specialize functors without depending on whole <functional> header

+

Section: 20.8 [function.objects] Status: NAD + Submitter: BSI Opened: 2010-08-25 Last modified: 2010-11-29

+

View all other issues in [function.objects].

+

View all issues with NAD status.

+

Discussion:

+

Addresses GB-96

+

+The function templates hash, less and equal_to +are important customization points for user-defined types to +be supported by several standard containers. These are +accessed through the <functional> header which has +grown significantly larger in C++0x, exposing many more +facilities than a user is likely to need through there own +header, simply to declare the necessary specialization. +There should be a smaller header available for users to +make the necessary customization. +

+ +

[ +Resolution proposed by ballot comment +]

+ +

+Provide a tiny forwarding header for important +functor types in the <functional> header that a +user may want to specialize. This should contain +the template declaration for equal_to, hash and +less. +

+ +

[ +Rapperswill summary +]

+ +

Alisdair: Would recommend NAD unless someone takes the issue.

+ +

Daniel: Volunteers to write a paper for this.

+ +

[ +2010-11-07 Daniel provides a paper available on the Batavia document list +]

+ + +

[ +2010 Batavia: +]

+ +

+Closed as NAD - the consensus was that forwarding headers such as +<iosfwd> do not bring the expected benefits, and are +not widely used (to the surprise of some active users in the room!). +Without real experience reporting a benefit, there is no further interest +in pursuing this issue as an extension - hence NAD rather than NAD Future. +

+ + + +

Rationale:

No consensus to make a change + +

Proposed resolution:

+See paper "Forwarding <functional> functor templates" +on the Batavia LWG document list + + + + + +
+

1406. [FCD] Support hashing smart-pointers based on owner

+

Section: 20.9.10.2 [util.smartptr.shared] Status: NAD Future + Submitter: Japan Opened: 2010-08-25 Last modified: 2010-11-29

+

View all other issues in [util.smartptr.shared].

+

View all issues with NAD Future status.

+

Discussion:

+

Addresses JP-5

+

+Hash support based on ownership sharing should be +supplied for shared_ptr and weak_ptr. +For two shared_ptr objects p and q, two distinct +equivalence relations can be defined. One is based on +equivalence of pointer values, which is derived from the +expression p.get() == q.get() (hereafter called address based +equivalence relation), the other is based on +equivalence of ownership sharing, which is derived from +the expression !p.owner_before(q) && !q.owner_before(p) +(hereafter called ownership-based equivalence relation). +These two equivalence relations are independent in +general. For example, a shared_ptr object created by the +constructor of the signature shared_ptr(shared_ptr<U> +const &, T *) could reveal a difference between these two +relations. Therefore, hash support based on each +equivalence relation should be supplied for shared_ptr. +However, while the standard library provides the hash +support for address-based one (20.9.11.6 paragraph 2), it +lacks the hash support for ownership-based one. In +addition, associative containers work well in combination +with the shared_ptr's ownership-based comparison but +unordered associative containers don't. This is +inconsistent. +

+

+For the case of weak_ptr, hash support for the ownership based +equivalence relation can be safely defined on +weak_ptrs, and even on expired ones. The absence of +hash support for the ownership-based equivalence +relation is fatal, especially for expired weak_ptrs. And the +absence of such hash support precludes some quite +effective use-cases, e.g. erasing the unordered_map entry +of an expired weak_ptr key from a customized deleter +supplied to shared_ptrs. +

+

+Hash support for the ownership-based equivalence +relation cannot be provided by any user-defined manner +because information about ownership sharing is not +available to users at all. Therefore, the only way to provide +ownership-based hash support is to offer it intrusively by +the standard library. +

+

+As far as we know, such hash support is implementable. +Typical implementation of such hash function could return +the hash value of the pointer of the counter object that is +internally managed by shared_ptr and weak_ptr. +

+ +

[2010 Rapperswil:]

+ +
+

No consensus to make this change at this time.

+
+ + +

Proposed resolution:

+

+Add the following non-static member functions to +shared_ptr and weak_ptr class template; +

+

+Update [util.smartptr.shared], 20.9.11.2 paragraph 1 +

+
namespace std{
+template<class T> class shared_ptr {
+public:
+...
+  size_t owner_hash() const;
+...
+};
+}
+
+

+Update [util.smartptr.weak], 20.9.11.3 paragraph 1 +

+
namespace std{
+template<class T> class weak_ptr {
+public:
+...
+  size_t owner_hash() const;
+...
+};
+}
+
+

+These functions satisfy the following +requirements. Let p and q be objects of either +shared_ptr or weak_ptr, H be a hypothetical +function object type that satisfies the hash +requirements ([hash.requirements], 20.2.4) and h be an object of the +type H. The expression p.owner_hash() behaves +as if it were equivalent to the expression h(p). In +addition, h(p) == h(q) must become true if p and +q share ownership. +

+ + + + + +
+

1411. [FCD] Add a compile-time flag to detect monotonic_clock

+

Section: X [time.clock.monotonic] Status: Dup + Submitter: DIN Opened: 2010-08-25 Last modified: 2010-10-26

+

View all other issues in [time.clock.monotonic].

+

View all issues with Dup status.

+

Duplicate of: 1410

+

Discussion:

+ +

Addresses DE-20

+ +The library component monotonic_clock is conditionally +supported, but no compile-time flag exists that allows +user-code to query its existence. Further-on there exist no +portable means to simulate such a query. (To do so, user +code would be required to add types to namespace +std::chrono.) + + +

Proposed resolution:

+Provide a compile-time flag (preferably a macro) +that can be used to query the existence of +monotonic_clock. + + + + + +
+

1415. [FCD] iterator stability bans the short-string optimization

+

Section: 23.2.1 [container.requirements.general] Status: NAD Editorial + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-04

+

View other active issues in [container.requirements.general].

+

View all other issues in [container.requirements.general].

+

View all issues with NAD Editorial status.

+

Discussion:

+Requirements on iterators swapping allegiance would +disallow the small-string optimization. + +

[ +Resolved in Rapperswil by paper N3108. +]

+ + + + +

Proposed resolution:

+Add an exclusion for basic_string to the sentence +beginning “Every iterator referring to an +element...”. Add a sentence to 21.4.6.8/2 saying +that iterators and references to string elements +remain valid, but it is not specified whether they +refer to the same string or the other string. + + + + + +
+

1419. [FCD] Ballot Comment US-117

+

Section: 23.3.3 [forwardlist] Status: NAD Editorial + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-04

+

View all other issues in [forwardlist].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses US-117

+ +forward_list::erase_after should return an iterator. + +

[ +Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102. +]

+ + + + +

Proposed resolution:

+See Appendix 1 - Additional Details + + + + + +
+

1422. [FCD] vector<bool> iterators are not random access

+

Section: 23.4.2 [vector.bool] Status: NAD Future + Submitter: BSI Opened: 2010-08-25 Last modified: 2010-11-29

+

View all other issues in [vector.bool].

+

View all issues with NAD Future status.

+

Discussion:

+

Addresses GB-118

+

+vector<bool> iterators are not random access iterators +because their reference type is a special class, and not +bool &. All standard libary operations taking iterators +should treat this iterator as if it was a random access iterator, rather +than a simple input iterator. +

+ +

[ +Resolution proposed in ballot comment +]

+ +

+Either revise the iterator requirements to support proxy iterators +(restoring functionality that was lost when the Concept facility was +removed) or add an extra paragraph to the vector<bool> +specification requiring the library to treat vector<bool> +iterators as-if they were random access iterators, despite having the wrong +reference type. +

+ +

[ +Rapperswil Review +]

+ +

+The consensus at Rapperswil is that it is too late for full support for +proxy iterators, but requiring the library to respect vector&;t;bool> +iterators as-if they were random access would be preferable to flagging +this container as deliberately incompatible with standard library algorithms. +

+

+Alisdair to write the note, which may become normative Remark depending +on the preferences of the project editor. +

+ +

[ +Post-Rapperswil Alisdair provides wording +]

+ +

+Initial wording is supplied, deliberately using Note in preference to +Remark although the author notes his preference for Remark. The +issue of whether iterator_traits<vector<bool>>::iterator_category +is permitted to report random_access_iterator_tag or must report +input_iterator_tag is not addressed. +

+ +

[ +Old Proposed Resolution: +]

+ +
+

+Insert a new paragraph into 23.4.2 [vector.bool] between p4 and p5: +

+
+[Note All functions in the library that take a pair of iterators to +denote a range shall treat vector<bool> iterators as-if they were +random access iterators, even though the reference type is not a +true reference.-- end note] +
+
+ +

[ +2010-11 Batavia: +]

+ +
+Closed as NAD Future, because the current iterator categories cannot correctly describe +vector<bool>::iterator. But saying that they are Random Access Iterators +is also incorrect, because it is not too hard to create a corresponding test that fails. +We should deal with the more general proxy iterator problem in the future, and see no +benefit to take a partial workaround specific to vector<bool> now. +
+ + + +

Proposed resolution:

+ + +

Rationale:

+No consensus to make this change at this time. + + + + + +
+

1433. [FCD] Ballot Comment GB-119

+

Section: 25.3.12 [alg.random.shuffle] Status: Dup + Submitter: BSI Opened: 2010-08-25 Last modified: 2010-10-23

+

View all other issues in [alg.random.shuffle].

+

View all issues with Dup status.

+

Duplicate of: 1432

+

Discussion:

+

Addresses GB-119

+ +The functions random_shuffle and shuffle both take +arguments providing a source of randomness, but one +take its argument by rvalue reference, and the other +requires an lvalue reference. The technical merits of which +form of argument passing should be settled for this +specific case, and a single preferred form used +consistently. + + +

Proposed resolution:

+[DEPENDS ON WHETHER RVALUE OR +LVALUE REFERENCE IS THE PREFERRED +FORM] + + + + + +
+

1434. [FCD] Ballot Comment US-122

+

Section: 25.4.7 [alg.min.max] Status: NAD Editorial + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-04

+

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

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses US-122

+ +It was the LWG's intent in Pittsburgh that N2772 be +applied to the WP. + +

[ +Resolved in Rapperswil by paper N3106. +]

+ + + + +

Proposed resolution:

+Apply N2772 to the WP. + + + + + +
+

1442. [FCD] "happens-before" should be "synchronizes-with"

+

Section: 30 [thread] Status: NAD Editorial + Submitter: Canada Opened: 2010-08-25 Last modified: 2010-11-18

+

View all other issues in [thread].

+

View all issues with NAD Editorial status.

+

Duplicate of: 1443

+

Discussion:

+

Addresses CA-9, GB-122

+ +

[CA-9:]

+ + +Imposed happens-before edges should be in +synchronizes-with
+Each use of the words "happens-before" should be +replaced with the words "synchronizes-with" in the +following sentences:
+27.2.3p2
+30.3.1.2p6
+30.3.1.5p7
+30.6.4p7
+30.6.9p5
+30.6.10.1p23
+Rationale: Happens-before is defined in 1.10p11 in a way +that (deliberately) does not make it explicitly transitively +closed. Adding edges to happens-before directly, as in +27.2.3p2 etc., does not provide transitivity with +sequenced-before or any other existing happens-before +edge. This lack of transitivity seems to be unintentional. + +

[GB-122]

+ + +

At various points in the standard new edges are added to +happens-before, for example 27.2.3:2 adds happens-before edges between +writes and reads from a stream:

+ +

If one thread makes a library call a that writes a value to a +stream and, as a result, another thread reads this value from the +stream through a library call b such that this does not result in a +data race, then a happens before b.

+ +

Happens-before is defined in 1.10:11 in a deliberate way that makes it +not explicitly transitively closed. Adding edges to happens-before +directly, as in 27.2.3:2, does not provide transitivity with +sequenced-before or any other existing happens-before edge. This lack +of transitivity seems to be unintentional. In order to achieve +transitivity we suggest each edge be added to +inter-thread-happens-before as a synchronises-with edge (as per +conversation with Hans Boehm). In the standard, each use of the words +"happens-before" should be replaced with the words "synchronizes-with" +in the following sentences:

+ +

27.2.3:2, +30.3.1.2:6, +30.3.1.5:7, +30.6.4:7, +30.6.9:5, +30.6.10.1:23

+ +

Proposed resolution:

+ +

[Beman provided specific wording for the proposed resolution.]

+ + +

Change 27.2.3 Thread Safety [iostreams.threadsafety] paragraph 2:

+ +

If one thread makes a library call a that writes a value to a stream and, as a result, another thread reads this value from the stream through a library call b such that this does not result in a data race, then a happens before synchronizes with b.

+ +

Change 30.3.1.2 thread constructors [thread.thread.constr] paragraph 6:

+ +

Synchronization: The invocation of the constructor happens before synchronizes with the invocation of the copy of f.

+ +

Change 30.3.1.5 thread members [thread.thread.member] paragraph 7:

+ +

Synchronization: The completion of the thread represented by *this happens before synchronizes with (1.10) join() returns returning. [ Note: Operations on *this are not synchronized. --end note ]

+ +

Change 30.6.4 Associated asynchronous state [futures.state] paragraph 7:

+ +

Calls to functions that successfully set the stored result of an associated asynchronous state synchronize +with (1.10) calls to functions successfully detecting the ready state resulting from that setting. The storage of the result (whether normal or exceptional) into the associated asynchronous state happens before synchronizes with (1.10) that state is being set to ready.

+ +

Change 30.6.9 Function template async [futures.async] paragraph 5:

+ +

Synchronization: the invocation of async happens before synchronizes with (1.10) the invocation of f. [ Note: this +statement applies even when the corresponding future object is moved to another thread. --end +note ] If the invocation is not deferred, a call to a waiting function on an asynchronous return object +that shares the associated asynchronous state created by this async call shall block until the associated +thread has completed. If the invocation is not deferred, the join() on the created thread happens before synchronizes with +(1.10) the first function that successfully detects the ready status of the associated asynchronous +state returns or before the function that gives up the last reference to the associated asynchronous +state returns, whichever happens first. If the invocation is deferred, the completion of the invocation +of the deferred function happens before synchronizes with the calls to the waiting functions return.

+ +

Change 30.6.10.1 packaged_task member functions [futures.task.members] paragraph 23:

+ +

Synchronization: a successful call to operator() synchronizes with (1.10) a call to any member function of a future, shared_future, or atomic_future object that shares the associated asynchronous +state of *this. The completion of the invocation of the stored task and the storage of the result +(whether normal or exceptional) into the associated asynchronous state happens before synchronizes with (1.10) the +state is being set to ready. [ Note: operator() synchronizes and serializes with other functions through the +associated asynchronous state. —end note ]

+ + + + + + +
+

1443. [FCD] Imposed happens-before edges are not made transitive

+

Section: 30 [thread] Status: Dup + Submitter: BSI Opened: 2010-08-25 Last modified: 2010-10-27

+

View all other issues in [thread].

+

View all issues with Dup status.

+

Duplicate of: 1442

+

Discussion:

+ + +

Addresses GB-122

+ +

At various points in the standard new edges are added to +happens-before, for example 27.2.3:2 adds happens-before edges between +writes and reads from a stream:

+ +

If one thread makes a library call a that writes a value to a +stream and, as a result, another thread reads this value from the +stream through a library call b such that this does not result in a +data race, then a happens before b.

+ +

Happens-before is defined in 1.10:11 in a deliberate way that makes it +not explicitly transitively closed. Adding edges to happens-before +directly, as in 27.2.3:2, does not provide transitivity with +sequenced-before or any other existing happens-before edge. This lack +of transitivity seems to be unintentional. In order to achieve +transitivity we suggest each edge be added to +inter-thread-happens-before as a synchronises-with edge (as per +conversation with Hans Boehm). In the standard, each use of the words +"happens-before" should be replaced with the words "synchronizes-with" +in the following sentences:

+ +

27.2.3:2, +30.3.1.2:6, +30.3.1.5:7, +30.6.4:7, +30.6.9:5, +30.6.10.1:23

+ + +

Proposed resolution:

+Request the concurrency working group to +determine if changes are needed + + + + + +
+

1444. [FCD] OFF_T is not defined

+

Section: 27.5.3.2 [fpos.operations] Status: Dup + Submitter: BSI Opened: 2010-08-25 Last modified: 2010-10-28

+

View all other issues in [fpos.operations].

+

View all issues with Dup status.

+

Duplicate of: 1414

+

Discussion:

+ +

Addresses GB-123

+ +Several rows in table 124 specify a Return type of +'OFF_T', which does not appear to be a type defined in +this standard. + + +

Proposed resolution:

+Resolve outstanding references to the removed +type 'OFF_T'. + + + + + +
+

1446. [FCD] Move and swap for I/O streams

+

Section: 27.7 [iostream.format] Status: NAD + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-29

+

View all other issues in [iostream.format].

+

View all issues with NAD status.

+

Discussion:

+

Addresses US-138

+ +For istreams and ostreams, the move-constructor does +not move-construct, the move-assignment operator does +not move-assign, and the swap function does not swap +because these operations do not manage the rdbuf() +pointer. Useful applications of these operations are +prevented both by their incorrect semantics and because +they are protected. + +

[ +Resolution proposed by ballot comment: +]

+ +

+In short: reverse the resolution of issue 900, then +change the semantics to move and swap the +rdbuf() pointer. Add a new protected constructor +that takes an rvalue reference to a stream and a +pointer to a streambuf, a new protected assign() +operator that takes the same arguments, and a +new protected partial_swap() function that doesn't +swap rdbuf(). +See Appendix 1 - Additional Details +

+ +

[ +2010-10-24 Daniel adds: +]

+ + +
+Accepting n3179 would solve this issue. +
+ +

[ +2010-11 Batavia +]

+ +

+Closed as NAD. +

+
+The Library Working Group reviewed n3179 and +concluded that this change alone was not sufficient, as it would require changes to some of the derived stream types in the library. +The preference is to not make such a broad fix, and retain the current semantics. This is closed as NAD rather than NAD future as it +will be difficult to rename the new functions introduced in the C++0x revision of the standard at a later date. +
+ + + +

Proposed resolution:

+ + + + + +
+

1451. [FCD] regex should support allocators

+

Section: 28.8 [re.regex] Status: Dup + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-04

+

View all other issues in [re.regex].

+

View all issues with Dup status.

+

Duplicate of: 1396

+

Discussion:

+ +

Addresses US-141

+ +std::basic_regex should have an allocator for all the +reasons that a std::string does. For example, I can use +boost::interprocess to put a string or vector in shared +memory, but not a regex. + + +

Proposed resolution:

+Add allocators to regexes; see paper N3171 +in the pre-Batavia mailing. + + + + + +
+

1454. [FCD] Ensure C compatibility for atomics

+

Section: 29 [atomics] Status: Dup + Submitter: BSI Opened: 2010-08-25 Last modified: 2010-10-29

+

View other active issues in [atomics].

+

View all other issues in [atomics].

+

View all issues with Dup status.

+

Duplicate of: 1455

+

Discussion:

+ +

Addresses GB-128

+

+WG14 has made some late changes to their specification +of atomics, and care should be taken to ensure that we +retain a common subset of language/library syntax to +declare headers that are portable to both languages. +Ideally, such headers would not require users to define +their own macros, especially not macros that map to +keywords (which remains undefined behaviour) +

+ + +

[ +Resolution proposed by ballot comment +]

+ +

+Depends on result of the review of WG14 work, +which is expected to be out to ballot during the +time wg21 is resolving its own ballot comments. +Liaison may also want to file comments in WG14 +to ensure compatibity from both sides. +

+ + +

Proposed resolution:

+ + + + + +
+

1458. [FCD] Overlapping evaluations are allowed

+

Section: 29.3 [atomics.order] Status: Dup + Submitter: BSI Opened: 2010-08-25 Last modified: 2010-10-26

+

View all other issues in [atomics.order].

+

View all issues with Dup status.

+

Duplicate of: 1459

+

Discussion:

+ +

Addresses GB-131

+ +29.4 [atomics.lockfree] p.8 states: +

+An atomic store shall only store a value that has been computed +from constants and program input values by a finite sequence of +program evaluations, such that each evaluation observes the values +of variables as computed by the last prior assignment in the +sequence. +

+

+... but 1.9 [intro.execution] p.13 states: +

+

+If A is not sequenced before B and B is not sequenced before A, +then A and B are unsequenced. [ Note: The execution of unsequenced +evaluations can overlap. — end note ] +

+

+Overlapping executions can make it impossible to construct the sequence +described in 29.4 [atomics.lockfree] p.8. We are not sure of the intention here and do not +offer a suggestion for change, but note that 29.4 [atomics.lockfree] p.8 is the condition +that prevents out-of-thin-air reads. +

+ + +

Proposed resolution:

+Request the concurrency working group to +determine if changes are needed. Consider +changing the use of "sequence" in 29.4 [atomics.lockfree] + + + + + +
+

1463. [FCD] Inconsistent value assignment for atomic_bool

+

Section: 29.5.1 [atomics.types.integral] Status: Dup + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-04

+

View all other issues in [atomics.types.integral].

+

View all issues with Dup status.

+

Duplicate of: 1462

+

Discussion:

+ +

Addresses US-157

+ +atomic_bool has a volatile assignment operator but not a +non-volatile operator. The other integral types have both. + + +

Proposed resolution:

+Add a non-volatile assignment operator to atomic_bool. + + + + + +
+

1470. [FCD] "Same-ness" curiosities

+

Section: 29.6 [atomics.types.operations] Status: Dup + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-04

+

View other active issues in [atomics.types.operations].

+

View all other issues in [atomics.types.operations].

+

View all issues with Dup status.

+

Duplicate of: 1474

+

Discussion:

+

Addresses US-165

+ +According to 29.6 [atomics.types.operations] p. 23: +

+“is the same that same as that of” is not grammatical (and is not clear) +

+ + + +

Proposed resolution:

+ + + + + +
+

1471. [FCD] Default constructor of atomics needs specification

+

Section: 29.6 [atomics.types.operations] Status: NAD Editorial + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-18

+

View other active issues in [atomics.types.operations].

+

View all other issues in [atomics.types.operations].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses US-168

+ +29.6 [atomics.types.operations] around p. 4: The definition of the default constructor needs exposition. + + +

Proposed resolution:

+Insert a new general prototype description following the current 29.6 [atomics.types.operations] p. 3 as indicated: +

+

+
+3 [Note: Many operations are volatile-qualified. The “volatile as device register” semantics have not changed +in the standard. This qualification means that volatility is preserved when applying these operations to +volatile objects. It does not mean that operations on non-volatile objects become volatile. Thus, volatile +qualified operations on non-volatile objects may be merged under some conditions. -- end note] +
+
A::A() = default;
+
+? Effects: Leaves the atomic object in an uninitialized state. +[Note: These semantics ensure compatiblity with C. -- end note] +
+
constexpr A::A(C desired);
+[..]
+
+ + + + + +
+

1472. [FCD] Incorrect semantics of atomic_init

+

Section: 29.6 [atomics.types.operations] Status: NAD Editorial + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-12

+

View other active issues in [atomics.types.operations].

+

View all other issues in [atomics.types.operations].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses US-171

+ +As of 29.6 [atomics.types.operations] p. 7: +

+The atomic_init definition "Non-atomically assigns the +value" is not quite correct, as the atomic_init purpose is +initialization. + + +

Proposed resolution:

+Change 29.6 [atomics.types.operations] p. 7 as indicated: +
void atomic_init(volatile A *object, C desired);
+void atomic_init(A *object, C desired);
+
+7 Effects: Non-atomically assigns the value desired to *objectInitializes *object with value +desired. Concurrent access from another thread, even via an atomic operation, constitutes a data race. +[Note: This function should only be applied to objects that have been default constructed. These semantics ensure +compatibility with C. — end note] +
+ + + + + +
+

1473. [FCD] Incomplete memory order specifications

+

Section: 29.6 [atomics.types.operations] Status: NAD + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-29

+

View other active issues in [atomics.types.operations].

+

View all other issues in [atomics.types.operations].

+

View all issues with NAD status.

+

Discussion:

+

Addresses US-172

+ +As of 29.6 [atomics.types.operations] p. 9, 13, 17, 20: +

+The order specifications are incomplete because the non-_explicit +functions do not have such parameters. +

+Add a new sentence: "If the program does not specify an order, it shall be +memory_order_seq_cst." Or perhaps: "The non-_explicit +non-member functions shall affect memory as though they were _explicit with +memory_order_seq_cst." + + +

[ +2010 Batavia +]

+ +

+The Concurrency subgroup reviewed this, and deemed it NAD according to +29.6 [atomics.types.operations] paragraph 2, bullet 4. +

+ +

Rationale:

The working paper is correct as written. + + + +

Proposed resolution:

+
    +
  1. Change 29.6 [atomics.types.operations] p. 9 as indicated: +
    void atomic_store(volatile A* object, C desired);
+void atomic_store(A* object, C desired);
+void atomic_store_explicit(volatile A *object, C desired, memory_order order);
+void atomic_store_explicit(A* object, C desired, memory_order order);
+void A::store(C desired, memory_order order = memory_order_seq_cst) volatile;
+void A::store(C desired, memory_order order = memory_order_seq_cst);
+
    +8 Requires: The order argument shall not be memory_order_consume, memory_order_acquire, nor +memory_order_acq_rel. +

    +9 Effects: Atomically replaces the value pointed to by object or by this with the value of desired. +Memory is affected according to the value of order. If the program does not specify an order, it shall be +memory_order_seq_cst. +

    +
    2. +
  2. Change 29.6 [atomics.types.operations] p. 13 as indicated: +
    C atomic_load(const volatile A* object);
+C atomic_load(const A* object);
+C atomic_load_explicit(const volatile A* object, memory_order);
+C atomic_load_explicit(const A* object, memory_order);
+C A::load(memory_order order = memory_order_seq_cst) const volatile;
+C A::load(memory_order order = memory_order_seq_cst) const;
+
    +12 Requires: The order argument shall not be memory_order_release nor memory_order_acq_rel. +

    +13 Effects: Memory is affected according to the value of order. If the program does not specify an order, it shall be +memory_order_seq_cst. +

    +14 Returns: Atomically returns the value pointed to by object or by this. +

    +
    3. +
  3. Change 29.6 [atomics.types.operations] p. 17 as indicated: +
    C atomic_exchange(volatile A* object, C desired);
+C atomic_exchange(A* object, C desired);
+C atomic_exchange_explicit(volatile A* object, C desired, memory_order);
+C atomic_exchange_explicit(A* object, C desired, memory_order);
+C A::exchange(C desired, memory_order order = memory_order_seq_cst) volatile;
+C A::exchange(C desired, memory_order order = memory_order_seq_cst);
+
    +17 Effects: Atomically replaces the value pointed to by object or by this with desired. Memory +is affected according to the value of order. These operations are atomic read-modify-write operations +(1.10). If the program does not specify an order, it shall be memory_order_seq_cst. +

    +18 Returns: Atomically returns the value pointed to by object or by this immediately before the effects. +

    +
    4. +
  4. Change 29.6 [atomics.types.operations] p. 20 as indicated: +
    bool atomic_compare_exchange_weak(volatile A* object, C * expected, C desired);
+bool atomic_compare_exchange_weak(A* object, C * expected, C desired);
+bool atomic_compare_exchange_strong(volatile A* object, C * expected, C desired);
+bool atomic_compare_exchange_strong(A* object, C * expected, C desired);
+bool atomic_compare_exchange_weak_explicit(volatile A* object, C * expected, C desired,
+  memory_order success, memory_order failure);
+bool atomic_compare_exchange_weak_explicit(A* object, C * expected, C desired,
+  memory_order success, memory_order failure);
+bool atomic_compare_exchange_strong_explicit(volatile A* object, C * expected, C desired,
+  memory_order success, memory_order failure);
+bool atomic_compare_exchange_strong_explicit(A* object, C * expected, C desired,
+  memory_order success, memory_order failure);
+bool A::compare_exchange_weak(C & expected, C desired,
+  memory_order success, memory_order failure) volatile;
+bool A::compare_exchange_weak(C & expected, C desired,
+  memory_order success, memory_order failure);
+bool A::compare_exchange_strong(C & expected, C desired,
+  memory_order success, memory_order failure) volatile;
+bool A::compare_exchange_strong(C & expected, C desired,
+  memory_order success, memory_order failure);
+bool A::compare_exchange_weak(C & expected, C desired,
+  memory_order order = memory_order_seq_cst) volatile;
+bool A::compare_exchange_weak(C & expected, C desired,
+  memory_order order = memory_order_seq_cst);
+bool A::compare_exchange_strong(C & expected, C desired,
+  memory_order order = memory_order_seq_cst) volatile;
+bool A::compare_exchange_strong(C & expected, C desired,
+  memory_order order = memory_order_seq_cst);
+
    +19 Requires: The failure argument shall not be memory_order_release nor memory_order_acq_rel. +The failure argument shall be no stronger than the success argument. +

    +20 Effects: Atomically, compares the contents of the memory pointed to by object or by this for equality +with that in expected, and if true, replaces the contents of the memory pointed to by object or by +this with that in desired, and if false, updates the contents of the memory in expected with the +contents of the memory pointed to by object or by this. Further, if the comparison is true, memory +is affected according to the value of success, and if the comparison is false, memory is affected +according to the value of failure. When only one memory_order argument is supplied, the value of +success is order, and the value of failure is order except that a value of +memory_order_acq_rel shall be replaced by the value memory_order_acquire and a value of +memory_order_release shall be replaced by the value memory_order_relaxed. If +the program does not specify an order, it shall be memory_order_seq_cst. If the operation returns true, +these operations are atomic read-modify-write operations (1.10). Otherwise, these operations are atomic load operations. +

    +[..] +

    +
    5. +
+ + + + + +
+

1475. [FCD] weak compare-and-exchange confusion II

+

Section: 29.6 [atomics.types.operations] Status: Dup + Submitter: Switzerland Opened: 2010-08-25 Last modified: 2010-10-29

+

View other active issues in [atomics.types.operations].

+

View all other issues in [atomics.types.operations].

+

View all issues with Dup status.

+

Duplicate of: 1474

+

Discussion:

+

Addresses CH-23

+ +29.6 [atomics.types.operations] p. 23: The first sentence has non-English syntax. + +

[ +Resolution proposed in ballot comment: +]

+ + +

+Change to "The weak compare-and-exchange +operations may fail spuriously, that is, return false +while leaving the contents of memory pointed to +by expected unchanged." +

+ + +

Proposed resolution:

+ + + + + +
+

1476. [FCD] Ballot Comment US-177

+

Section: 29.6 [atomics.types.operations] Status: Dup + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-07

+

View other active issues in [atomics.types.operations].

+

View all other issues in [atomics.types.operations].

+

View all issues with Dup status.

+

Duplicate of: 1474

+

Discussion:

+ +

Addresses US-177

+ +The first sentence of this paragraph doesn't make sense. + +

[ +Resolution proposed in ballot comment +]

+ +

+Figure out what it's supposed to say, and say it. +

+ + +

Proposed resolution:

+ + + + + +
+

1477. [FCD] weak compare-and-exchange confusion III

+

Section: 29.6 [atomics.types.operations] Status: Dup + Submitter: BSI Opened: 2010-08-25 Last modified: 2010-10-31

+

View other active issues in [atomics.types.operations].

+

View all other issues in [atomics.types.operations].

+

View all issues with Dup status.

+

Duplicate of: 1474

+

Discussion:

+

Addresses GB-135

+ +The first sentence of 29.6 [atomics.types.operations] p.23 was changed by n2992 but +now makes no sense: "that is, return false while leaving +the contents of memory pointed to by expected before the +operation is the same that same as that of the object and +the same as that of expected after the operation." +There's a minor editorial difference between n2992 ("is +that same as that" vs "is the same that same as that") but +neither version makes sense. +Also, the remark talks about "object" which should +probably be "object or this" to cover the member functions +which have no object parameter. + +

[ +Resolution proposed in ballot comment: +]

+ +

+Fix the Remark to say whatever was intended. +

+ + + +

Proposed resolution:

+ + + + + +
+

1483. [FCD] __STDCPP_THREADS spelling

+

Section: 30.3 [thread.threads] Status: NAD Editorial + Submitter: DIN Opened: 2010-08-25 Last modified: 2010-10-26

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses DE-23

+ +Predefined macros usually start and end with two +underscores, see 16.8 and FDIS 29124 = WG21 N3060 +clause 7. __STDCPP_THREADS should blend in. + +

[ +Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102. +]

+ + + + +

Proposed resolution:

+Change the macro name to +__STDCPP_THREADS__. + + + + + +
+

1484. [FCD] Need a way to join a thread with a timeout

+

Section: 30.3.1 [thread.thread.class] Status: NAD Future + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-29

+

View all issues with NAD Future status.

+

Discussion:

+

Addresses US-183

+ +There is no way to join a thread with a timeout. + +

[ +Resolution proposed by ballot comment: +]

+ +
+Add join_for and join_until. Or decide one should +never join a thread with a timeout since pthread_join doesn't have a +timeout version. +
+ +

[ +2010 Batavia +]

+ +

+The concurrency working group deemed this an extension beyond the scope of C++0x. +

+

Rationale:

The LWG does not wish to make a change at this time. + + + +

Proposed resolution:

+ + + + + +
+

1488. [FCD] Improve interoperability between +the C++0x and C1x threads APIs

+

Section: 30.4 [thread.mutex] Status: NAD Future + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-29

+

View all other issues in [thread.mutex].

+

View all issues with NAD Future status.

+

Discussion:

+

Addresses US-185

+ +Cooperate with WG14 to improve interoperability between +the C++0x and C1x threads APIs. In particular, C1x +mutexes should be conveniently usable with a C++0x +lock_guard. Performance overheads for this combination +should be considered. + +

[ +Resolution proposed by ballot comment: +]

+ +
+Remove C++0x timed_mutex and +timed_recursive_mutex if that facilitates +development of more compatible APIs. +
+ +

[ +2010 Batavia +]

+ +

+The concurrency sub-group reviewed the options, and decided that closer harmony should wait until both standards are published. +

+ +

Rationale:

+The LWG does not wish to make any change at this time. + + + + +

Proposed resolution:

+ + + + + +
+

1489. [FCD] unlock functions and unlock +mutex requirements are inconsistent

+

Section: 30.4 [thread.mutex] Status: NAD Editorial + Submitter: Switzerland Opened: 2010-08-25 Last modified: 2010-11-12

+

View all other issues in [thread.mutex].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses CH-26

+ +Specifications of unlock member functions and unlock +mutex requirements are inconsistent wrt to exceptions and +pre- and postconditions. + +

[ +Resolution proposed by ballot comment: +]

+ +
+unlock should specifiy the precondition that the +current thread "owns the lock", this will make calls +without holding the locks "undefined behavior". +unlock in [mutex.requirements] should either be +noexcept(true) or be allowed to throw +system_error like unique_lock::unlock, or the latter +should be nothrow(true) and have the precondition +owns == true. +Furthermore unique_lock's postcondition is wrong +in the case of a recursive mutex where owns +might stay true, when it is not the last unlock +needed to be called. +
+ + + +

Proposed resolution:

+ + + + + +
+

1493. [FCD] Add mutex, recursive_mutex, is_locked function

+

Section: 30.4.1 [thread.mutex.requirements] Status: NAD Future + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-29

+

View all other issues in [thread.mutex.requirements].

+

View all issues with NAD Future status.

+

Discussion:

+

Addresses US-189

+ +mutex and recursive_mutex should have an is_locked() +member function. is_locked allows a user to test a lock +without acquiring it and can be used to implement a lightweight +try_try_lock. + +

[ +Resolution proposed by ballot comment: +]

+ +
+Add a member function: +
bool is_locked() const;
+
+to std::mutex and std::recursive_mutex. These +functions return true if the current thread would +not be able to obtain a mutex. These functions do +not synchronize with anything (and, thus, can +avoid a memory fence). +
+ +

[ +2010 Batavia +]

+ +

+The Concurrency subgroup reviewed this issue and deemed it to be an extension to be handled after publishing C++0x. +

+ +

Rationale:

The LWG does not wish to make a change at this time. + + + +

Proposed resolution:

+ + + + + +
+

1495. [FCD] Condition variable wait_for return insufficient

+

Section: 30.5 [thread.condition] Status: NAD Editorial + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-12

+

View all other issues in [thread.condition].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses US-191

+ +The condition variable wait_for returning cv_status is insufficient. + +

[ +Resolution proposed by ballot comment: +]

+ +
+Return a duration of timeout remaining instead. +See Appendix 1 of n3141 - Additional Details, p. 211 +
+ + + +

Proposed resolution:

+ + + + + +
+

1496. [FCD] condition_variable not implementable

+

Section: 30.5.1 [thread.condition.condvar] Status: NAD Editorial + Submitter: Switzerland Opened: 2010-08-25 Last modified: 2010-11-12

+

View all other issues in [thread.condition.condvar].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses CH-28

+ +Requiring wait_until makes it impossible to implement +condition_variable correctly using respective objects +provided by the operating system (i.e. implementing the +native_handle() function) on many platforms (e.g. POSIX, +Windows, MacOS X) or using the same object as for the +condition variable proposed for C. + +

[ +Resolution proposed by ballot comment: +]

+ +
+Remove the wait_until functions or make them at least conditionally supported. +
+ + +

Proposed resolution:

+ + + + + +
+

1499. [FCD] Condition variables preclude wakeup optimization

+

Section: 30.5 [thread.condition] Status: NAD Future + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-29

+

View all other issues in [thread.condition].

+

View all issues with NAD Future status.

+

Discussion:

+

Addresses US-193

+ +Condition variables preclude a wakeup optimization. + +

[ +Resolution proposed by ballot comment: +]

+ + +
+Change condition_variable to allow such +optimization. See Appendix 1 - Additional Details +
+ +

[ +2010 Batavia +]

+ +

+The Concurrency subgroup reviewed the issue, and deemed it an extension to be handled after C++0x. +

+ +

Rationale:

The LWG does not wish to make the change at this time. + + + +

Proposed resolution:

+ + + + + +
+

1500. [FCD] Consider removal of native_handle()

+

Section: 30.5.2 [thread.condition.condvarany] Status: NAD Editorial + Submitter: Switzerland Opened: 2010-08-25 Last modified: 2010-10-28

+

View all other issues in [thread.condition.condvarany].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses CH-32

+ +Given that the lock type can be something the underlying +doesn't know 'native_handle()' is probably +unimplementable on essentially all platforms. + +

[ +Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102. +]

+ + + + +

Proposed resolution:

+Consider the removal of 'native_handle()'. + + + + + +
+

1506. [FCD] set_exception with a null pointer

+

Section: 30.6.5 [futures.promise] Status: NAD Editorial + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-04

+

View other active issues in [futures.promise].

+

View all other issues in [futures.promise].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses US-198

+ +promise::set_exception can be called with a null pointer, +but none of the descriptions of the get() functions for the +three types of futures say what happens for this case. + +

[ +Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102. +]

+ + + + +

Proposed resolution:

+Add the following sentence to the end of +30.6.5/22: The behavior of a program that calls +set_exception with a null pointer is undefined. + + + + + +
+

1509. [FCD] No restriction on calling future::get more than once

+

Section: 30.6.8 [futures.atomic_future] Status: NAD Editorial + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-12

+

View all other issues in [futures.atomic_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses US-202

+

+The note in this paragraph says "unlike future, calling get +more than once on the same atomic_future object is well +defined and produces the result again." There is nothing +in future that says anything negative about calling get +more than once. +

+ +

[ +Resolution proposed by ballot comment: +]

+ +

+Remove this note, or add words to the +requirements for future that reflect what this note +says. +

+ + +

Proposed resolution:

+ + + + + +
+

1510. [FCD] Should be undefined behaviour to call atomic_future operations unless valid()

+

Section: 30.6.8 [futures.atomic_future] Status: NAD Editorial + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-12

+

View all other issues in [futures.atomic_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses US-203

+

+Both future and shared_future specify that calling most +member functions on an object for which valid() == false +produces undefined behavior. There is no such statement +for atomic_future. +

+ +

[ +Resolution proposed by ballot comment: +]

+ +

+Add a new paragraph after 30.6.8 [futures.atomic_future]/2 with the same words as +30.6.7 [futures.shared_future]/3. +

+ +

[ +2010-11-02 Daniel translates proposed changes into specific deltas and comments: +]

+ + +
+While applying the wording, I notice that 30.6.7 [futures.shared_future]/3 does +speak of the move-assignment operator, and not of the copy-assignment operator. +atomic_future obviously needs this to be true for the copy-assignment operator, +but I strongly assume that shared_future needs to mention both special member +assignment operators in this paragraph. To keep this consistent, the following P/R also +provides wording to fix the corresponding location for shared_future. +
+ + + +

Proposed resolution:

+
    +
  1. Change 30.6.7 [futures.shared_future]/3 as indicated: +
    +3 The effect of calling any member function other than the destructor, the +copy-assignment operator, the move-assignment operator, or valid() +on a shared_future object for which valid() == false is undefined. +
    +
    2. +
  2. Following 30.6.8 [futures.atomic_future]/2, add a new paragraph: +
    +? The effect of calling any member function other than the destructor, the copy-assignment operator, or valid() +on a atomic_future object for which valid() == false is undefined. +
    +
    3. +
+ + + + + +
+

1511. [FCD] Synchronize the move-constructor for atomic_future

+

Section: 30.6.8 [futures.atomic_future] Status: NAD Editorial + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-12

+

View all other issues in [futures.atomic_future].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses US-204

+

+According to the definition of atomic_future, all members +of atomic_future are synchronizing except constructors. +However, it would probably be appropriate for a move +constructor to be synchronizing on the source object. If +not, the postconditions on paragraphs 7-8, might not be +satisfied. This may be applicable if a collection of futures +are being doled out to a set of threads that process their +value. +

+ +

[ +Resolution proposed by ballot comment: +]

+ +

+Make the move constructor for atomic future lock +the source +

+ + + +

Proposed resolution:

+ + + + + +
+

1512. [FCD] Conflict in spec: block or join?

+

Section: 30.6.9 [futures.async] Status: NAD Editorial + Submitter: INCITS Opened: 2010-08-25 Last modified: 2010-11-12

+

View all other issues in [futures.async].

+

View all issues with NAD Editorial status.

+

Discussion:

+

Addresses US-205

+

+30.6.9 [futures.async] p. 3: The third sentence says +"If the invocation is not deferred, a call to a waiting function +on an asynchronous return object that shares the associated asynchronous state +created by this async call shall block until the associated +thread has completed." The next sentence says "If the +invocation is not deferred, the join() on the created +thread..." Blocking until a thread completes is not +necessarily a join. +

+ +

[ +Resolution proposed by ballot comment: +]

+ +

+Decide whether the requirement is to block until +finished or to call join, and rewrite to match. +

+ + + +

Proposed resolution:

+ + + + + + + + \ No newline at end of file -- cgit v1.2.3