| Doc. no. | N2873=09-0063 |
| Date: | 2009-05-01 |
| Project: | Programming Language C++ |
| Reply to: | Howard Hinnant <howard.hinnant@gmail.com> |
Reference ISO/IEC IS 14882:2003(E)
Also see:
The purpose of this document is to record the status of issues which have come before the Library Working Group (LWG) of the ANSI (J16) and ISO (WG21) C++ Standards Committee. Issues represent potential defects in the ISO/IEC IS 14882:2003(E) document.
This document contains only library issues which are actively being considered by the Library Working Group. That is, issues which have a status of New, Open, Ready, and Review. See Library Defect Reports List for issues considered defects and Library Closed Issues List for issues considered closed.
The issues in these lists are not necessarily formal ISO Defect Reports (DR's). While some issues will eventually be elevated to official Defect Report status, other issues will be disposed of in other ways. See Issue Status.
Prior to Revision 14, library issues lists existed in two slightly different versions; a Committee Version and a Public Version. Beginning with Revision 14 the two versions were combined into a single version.
This document includes [bracketed italicized notes] as a reminder to the LWG of current progress on issues. Such notes are strictly unofficial and should be read with caution as they may be incomplete or incorrect. Be aware that LWG support for a particular resolution can quickly change if new viewpoints or killer examples are presented in subsequent discussions.
For the most current official version of this document see http://www.open-std.org/jtc1/sc22/wg21/. Requests for further information about this document should include the document number above, reference ISO/IEC 14882:2003(E), and be submitted to Information Technology Industry Council (ITI), 1250 Eye Street NW, Washington, DC 20005.
Public information as to how to obtain a copy of the C++ Standard, join the standards committee, submit an issue, or comment on an issue can be found in the comp.std.c++ FAQ.
New - The issue has not yet been reviewed by the LWG. Any Proposed Resolution is purely a suggestion from the issue submitter, and should not be construed as the view of LWG.
Open - The LWG has discussed the issue but is not yet ready to move the issue forward. There are several possible reasons for open status:
A Proposed Resolution for an open issue is still not be construed as the view of LWG. Comments on the current state of discussions are often given at the end of open issues in an italic font. Such comments are for information only and should not be given undue importance.
Dup - The LWG has reached consensus that the issue is a duplicate of another issue, and will not be further dealt with. A Rationale identifies the duplicated issue's issue number.
NAD - The LWG has reached consensus that the issue is not a defect in the Standard.
NAD Editorial - The LWG has reached consensus that the issue can either be handled editorially, or is handled by a paper (usually linked to in the rationale).
NAD Future - In addition to the regular status, the LWG believes that this issue should be revisited at the next revision of the standard.
Review - Exact wording of a Proposed Resolution is now available for review on an issue for which the LWG previously reached informal consensus.
Tentatively Ready - The issue has been reviewed online, but not in a meeting, and some support has been formed for the proposed resolution. Tentatively Ready issues may be moved to Ready and forwarded to full committee within the same meeting. Unlike Ready issues they will be reviewed in subcommittee prior to forwarding to full committee.
Ready - The LWG has reached consensus that the issue is a defect in the Standard, the Proposed Resolution is correct, and the issue is ready to forward to the full committee for further action as a Defect Report (DR).
DR - (Defect Report) - The full J16 committee has voted to forward the issue to the Project Editor to be processed as a Potential Defect Report. The Project Editor reviews the issue, and then forwards it to the WG21 Convenor, who returns it to the full committee for final disposition. This issues list accords the status of DR to all these Defect Reports regardless of where they are in that process.
TC1 - (Technical Corrigenda 1) - The full WG21 committee has voted to accept the Defect Report's Proposed Resolution as a Technical Corrigenda. Action on this issue is thus complete and no further action is possible under ISO rules.
CD1 - (Committee Draft 2008) - The full WG21 committee has voted to accept the Defect Report's Proposed Resolution into the Fall 2008 Committee Draft.
TRDec - (Decimal TR defect) - The LWG has voted to accept the Defect Report's Proposed Resolution into the Decimal TR. Action on this issue is thus complete and no further action is expected.
WP - (Working Paper) - The proposed resolution has not been accepted as a Technical Corrigendum, but the full WG21 committee has voted to apply the Defect Report's Proposed Resolution to the working paper.
Pending - This is a status qualifier. When prepended to a status this indicates the issue has been processed by the committee, and a decision has been made to move the issue to the associated unqualified status. However for logistical reasons the indicated outcome of the issue has not yet appeared in the latest working paper.
Issues are always given the status of New when they first appear on the issues list. They may progress to Open or Review while the LWG is actively working on them. When the LWG has reached consensus on the disposition of an issue, the status will then change to Dup, NAD, or Ready as appropriate. Once the full J16 committee votes to forward Ready issues to the Project Editor, they are given the status of Defect Report ( DR). These in turn may become the basis for Technical Corrigenda (TC), or are closed without action other than a Record of Response (RR ). The intent of this LWG process is that only issues which are truly defects in the Standard move to the formal ISO DR status.
Section: 23.3.6 [vector] Status: Open Submitter: AFNOR Opened: 1998-10-07 Last modified: 2009-03-13
View all other issues in [vector].
View all issues with Open 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.
[ 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.
Proposed resolution:
[ 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. ]
Section: 24.6.3.5 [istreambuf.iterator::equal] Status: Open Submitter: Nathan Myers Opened: 1998-10-15 Last modified: 2009-03-13
View all issues with Open 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.2 [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.
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.
Section: 27.8 [string.streams], 27.9 [file.streams] Status: Open Submitter: Angelika Langer Opened: 1999-02-22 Last modified: 2008-03-14
View all other issues in [string.streams].
View all issues with Open 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. ]
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.
Section: 22.4.1.4 [locale.codecvt] Status: Open Submitter: Angelika Langer Opened: 1999-03-18 Last modified: 2009-03-09
View other active issues in [locale.codecvt].
View all other issues in [locale.codecvt].
View all issues with Open 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.
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.
Section: 23.2.3 [sequence.reqmts] Status: Open Submitter: Andrew Koenig Opened: 1999-06-28 Last modified: 2009-05-01
View other active issues in [sequence.reqmts].
View all other issues in [sequence.reqmts].
View all issues with Open status.
Discussion:
Suppose that c and c1 are sequential containers and i is an iterator that refers to an element of c. Then I can insert a copy of c1's elements into c ahead of element i by executing
c.insert(i, c1.begin(), c1.end());
If c is a vector, it is fairly easy for me to find out where the newly inserted elements are, even though i is now invalid:
size_t i_loc = i - c.begin(); c.insert(i, c1.begin(), c1.end());
and now the first inserted element is at c.begin()+i_loc and one
past the last is at c.begin()+i_loc+c1.size().
But what if c is a list? I can still find the location of one past the last inserted element, because i is still valid. To find the location of the first inserted element, though, I must execute something like
for (size_t n = c1.size(); n; --n) --i;
because i is now no longer a random-access iterator.
Alternatively, I might write something like
bool first = i == c.begin(); list<T>::iterator j = i; if (!first) --j; c.insert(i, c1.begin(), c1.end()); if (first) j = c.begin(); else ++j;
which, although wretched, requires less overhead.
But I think the right solution is to change the definition of insert
so that instead of returning void, it returns an iterator that refers
to the first element inserted, if any, and otherwise is a copy of its
first argument.
[ Summit: ]
Reopened by Alisdair.
[ Post Summit Alisdair adds: ]
In addition to the original rationale for C++03, this change also gives a consistent interface for all container insert operations i.e. they all return an iterator to the (first) inserted item.
Proposed wording provided.
Proposed resolution:
Table 83 -- Sequence container requirements (in addition to container) Expression Return type Assertion/note pre-/post-condition a.insert(p,n,t) voiditeratorInserts n copies of t before p. a.insert(p,i,j) voiditeratorEach iterator in the range [i,j) shall be dereferenced exactly once. pre: i and j are not iterators into a. Inserts copies of elements in [i, j) before p a.insert(p,il) voiditeratora.insert(p, il.begin(), il.end()).
Add after p6 23.2.3 [sequence.reqmts]:
-6- ...
The iterator returned from a.insert(p,n,t) points to the copy of the first element inserted into a, or p if n == 0.
The iterator returned from a.insert(p,i,j) points to the copy of the first element inserted into a, or p if i == j.
The iterator returned from a.insert(p,il) points to the copy of the first element inserted into a, or p if il is empty.
p9 23.2.6.1 [container.concepts.free] change return type from void to iterator:
concept RangeInsertionContainer<typename C, typename Iter> : InsertionContainer<C> {
requires InputIterator<Iter>;
void iterator insert(C&, const_iterator position, Iter first, Iter last);
}
p9 23.2.6.2 [container.concepts.member] change return type from void to iterator:
auto concept MemberRangeInsertionContainer<typename C, typename Iter> : MemberInsertionContainer<C> {
requires InputIterator<Iter>;
void iterator C::insert(const_iterator position, Iter first, Iter last);
}
p8 23.2.6.3 [container.concepts.maps] change return type from void to iterator, add return statement:
template <MemberRangeInsertionContainer C, InputIterator Iter>
concept_map RangeInsertionContainer<C, Iter> {
void iterator insert(C& c, Container<C>::const_iterator i, Iter first, Iter last)
{ return c.insert(i, first, last); }
}
p2 23.3.2 [deque] Update class definition, change return type from void to iterator:
requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T>voiditerator insert(const_iterator position, size_type n, const T& x); template <InputIterator Iter> requires AllocatableElement<Alloc, T, Iter::reference> && MoveAssignable<T>voiditerator insert(const_iterator position, Iter first, Iter last); requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T>voiditerator insert(const_iterator position, initializer_list<T>);
23.3.2.3 [deque.modifiers] change return type from void to iterator on following declarations:
requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T>voiditerator insert(const_iterator position, size_type n, const T& x); template <InputIterator Iter> requires AllocatableElement<Alloc, T, Iter::reference> && MoveAssignable<T>voiditerator insert(const_iterator position, Iter first, Iter last);
Add the following (missing) declaration
requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T> iterator insert(const_iterator position, initializer_list<T>);
23.3.3 [forwardlist] Update class definition, change return type from void to iterator:
requires AllocatableElement<Alloc, T, const T&>voiditerator insert_after(const_iterator position, initializer_list<T> il); requires AllocatableElement<Alloc, T, const T&>voiditerator insert_after(const_iterator position, size_type n, const T& x); template <InputIterator Iter> requires AllocatableElement<Alloc, T, Iter::reference>voiditerator insert_after(const_iterator position, Iter first, Iter last);
p8 23.3.3.4 [forwardlist.modifiers] change return type from void to iterator:
requires AllocatableElement<Alloc, T, const T&>voiditerator insert_after(const_iterator position, size_type n, const T& x);
Add paragraph:
Returns: position.
p10 23.3.3.4 [forwardlist.modifiers] change return type from void to iterator:
template <InputIterator Iter> requires AllocatableElement<Alloc, T, Iter::reference>voiditerator insert_after(const_iterator position, Iter first, Iter last);
Add paragraph:
Returns: position.
p12 23.3.3.4 [forwardlist.modifiers] change return type from void to iterator on following declarations:
requires AllocatableElement<Alloc, T, const T&>voiditerator insert_after(const_iterator position, initializer_list<T> il);
change return type from void to iterator on following declarations:
p2 23.3.4 [list] Update class definition, change return type from void to iterator:
requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T>voiditerator insert(const_iterator position, size_type n, const T& x); template <InputIterator Iter> requires AllocatableElement<Alloc, T, Iter::reference> && MoveAssignable<T>voiditerator insert(const_iterator position, Iter first, Iter last); requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T>voiditerator insert(const_iterator position, initializer_list<T>);
23.3.4.3 [list.modifiers] change return type from void to iterator on following declarations:
requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T>voiditerator insert(const_iterator position, size_type n, const T& x); template <InputIterator Iter> requires AllocatableElement<Alloc, T, Iter::reference> && MoveAssignable<T>voiditerator insert(const_iterator position, Iter first, Iter last);
Add the following (missing) declaration
requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T> iterator insert(const_iterator position, initializer_list<T>);
p2 23.3.6 [vector]
Update class definition, change return type from void to iterator:
requires AllocatableElement<Alloc, T, T&&> && MoveAssignable<T>voiditerator insert(const_iterator position, T&& x); requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T>voiditerator insert(const_iterator position, size_type n, const T& x); template <InputIterator Iter> requires AllocatableElement<Alloc, T, Iter::reference> && MoveAssignable<T>voiditerator insert(const_iterator position, Iter first, Iter last); requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T>voiditerator insert(const_iterator position, initializer_list<T>);
23.3.6.4 [vector.modifiers] change return type from void to iterator on following declarations:
requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T>voiditerator insert(const_iterator position, size_type n, const T& x); template <InputIterator Iter> requires AllocatableElement<Alloc, T, Iter::reference> && MoveAssignable<T>voiditerator insert(const_iterator position, Iter first, Iter last);
Add the following (missing) declaration
requires AllocatableElement<Alloc, T, const T&> && MoveAssignable<T> iterator insert(const_iterator position, initializer_list<T>);
p1 23.3.7 [vector.bool] Update class definition, change return type from void to iterator:
voiditerator insert (const_iterator position, size_type n, const bool& x); template <InputIterator Iter> requires Convertible<Iter::reference, bool>voiditerator insert(const_iterator position, Iter first, Iter last);voiditerator insert(const_iterator position, initializer_list<bool> il);
p5 21.4 [basic.string] Update class definition, change return type from void to iterator:
voiditerator insert(const_iterator p, size_type n, charT c); template<class InputIterator>voiditerator insert(const_iterator p, InputIterator first, InputIterator last);voiditerator insert(const_iterator p, initializer_list<charT>);
p13 21.4.6.4 [string::insert] change return type from void to iterator:
voiditerator insert(const_iterator p, size_type n, charT c);
Add paragraph:
Returns: an iterator which refers to the copy of the first inserted character, or p if n == 0.
p15 21.4.6.4 [string::insert] change return type from void to iterator:
template<class InputIterator>voiditerator insert(const_iterator p, InputIterator first, InputIterator last);
Add paragraph:
Returns: an iterator which refers to the copy of the first inserted character, or p if first == last.
p17 21.4.6.4 [string::insert] change return type from void to iterator:
voiditerator insert(const_iterator p, initializer_list<charT> il);
Add paragraph:
Returns: an iterator which refers to the copy of the first inserted character, or p if il is empty.
Rationale:
[ The following was the C++98/03 rationale and does not necessarily apply to the proposed resolution in the C++0X time frame: ]
The LWG believes this was an intentional design decision and so is not a defect. It may be worth revisiting for the next standard.
Section: 25.5.7 [alg.min.max] Status: Open Submitter: Mark Rintoul Opened: 1999-08-26 Last modified: 2008-03-14
View other active issues in [alg.min.max].
View all other issues in [alg.min.max].
View all issues with Open 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. ]
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.
Section: 25.3.5 [alg.find] Status: Open Submitter: Pablo Halpern Opened: 2000-03-06 Last modified: 2009-03-09
View all other issues in [alg.find].
View all issues with Open 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.
Proposed resolution:
In section 25.3.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".
Section: 27.6.2 [streambuf] Status: Open Submitter: Martin Sebor Opened: 2000-08-12 Last modified: 2007-01-15
View all other issues in [streambuf].
View all issues with Open 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.
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)] ]
Section: 25.3.4 [alg.foreach] Status: Open Submitter: Angelika Langer Opened: 2001-01-03 Last modified: 2006-12-27
View other active issues in [alg.foreach].
View all other issues in [alg.foreach].
View all issues with Open 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.]
Proposed resolution:
Section: 27.7 [iostream.format] Status: Open Submitter: Martin Sebor Opened: 2001-03-19 Last modified: 2006-12-27
View all other issues in [iostream.format].
View all issues with Open 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.
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.
Section: 27.7.1.3 [istream.unformatted] Status: Open Submitter: Howard Hinnant Opened: 2001-10-09 Last modified: 2007-01-15
View all other issues in [istream.unformatted].
View all issues with Open 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:
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.
Section: 17 [library] Status: Open Submitter: Martin Sebor Opened: 2001-10-09 Last modified: 2009-03-11
View other active issues in [library].
View all other issues in [library].
View all issues with Open 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.
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.
Section: 22.4.1.4 [locale.codecvt] Status: Open Submitter: Martin Sebor Opened: 2002-08-30 Last modified: 2007-01-15
View other active issues in [locale.codecvt].
View all other issues in [locale.codecvt].
View all issues with Open 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:
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.]
Proposed resolution:
Section: 27.7.2.6.1 [ostream.formatted.reqmts] Status: Open Submitter: Martin Sebor Opened: 2002-12-27 Last modified: 2007-01-15
View all issues with Open 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.]
Proposed resolution:
Rationale:
Section: 27.7.2.4 [ostream::sentry] Status: Open Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2007-07-25
View other active issues in [ostream::sentry].
View all other issues in [ostream::sentry].
View all issues with Open 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. ]
Proposed resolution:
Section: 27.7.2.4 [ostream::sentry] Status: Open Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2007-01-15
View other active issues in [ostream::sentry].
View all other issues in [ostream::sentry].
View all issues with Open 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.
Proposed resolution:
Section: 24.2 [iterator.concepts] Status: Open Submitter: Nathan Myers Opened: 2003-06-03 Last modified: 2009-03-11
View other active issues in [iterator.concepts].
View all other issues in [iterator.concepts].
View all issues with Open status.
Discussion:
I've been discussing iterator semantics with Dave Abrahams, and a surprise has popped up. I don't think this has been discussed before.
24.2 [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.
[ 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. ]
Proposed resolution:
Section: 22.4.1.1.2 [locale.ctype.virtuals] Status: Open Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2006-12-27
View all other issues in [locale.ctype.virtuals].
View all issues with Open 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.]
Proposed resolution:
Section: 27.5.2.1.6 [ios::Init] Status: Open Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2007-07-25
View all issues with Open 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. ]
Proposed resolution:
Section: 27.7.1.1.3 [istream::sentry] Status: Open Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2007-01-30
View all other issues in [istream::sentry].
View all issues with Open status.
Discussion:
27.7.1.1.3 [istream::sentry], p2 says that istream::sentry ctor prepares for input if is.good() is true. p4 then goes on to say that the ctor sets the sentry::ok_ member to true if the stream state is good after any preparation. 27.7.1.2.1 [istream.formatted.reqmts], p1 then says that a formatted input function endeavors to obtain the requested input if the sentry's operator bool() returns true. Given these requirements, no formatted extractor should ever set failbit if the initial stream rdstate() == eofbit. That is contrary to the behavior of all implementations I tested. The program below prints out eof = 1, fail = 0 eof = 1, fail = 1 on all of them.
#include <sstream>
#include <cstdio>
int main()
{
std::istringstream strm ("1");
int i = 0;
strm >> i;
std::printf ("eof = %d, fail = %d\n",
!!strm.eof (), !!strm.fail ());
strm >> i;
std::printf ("eof = %d, fail = %d\n",
!!strm.eof (), !!strm.fail ());
}
Comments from Jerry Schwarz (c++std-lib-11373):
Jerry Schwarz wrote:
I don't know where (if anywhere) it says it in the standard, but the
formatted extractors are supposed to set failbit if they don't extract
any characters. If they didn't then simple loops like
while (cin >> x);
would loop forever.
Further comments from Martin Sebor:
The question is which part of the extraction should prevent this from happening
by setting failbit when eofbit is already set. It could either be the sentry
object or the extractor. It seems that most implementations have chosen to
set failbit in the sentry [...] so that's the text that will need to be
corrected.
Pre Berlin: This issue is related to 342. If the sentry sets failbit when it finds eofbit already set, then you can never seek away from the end of stream.
Kona: Possibly NAD. If eofbit is set then good() will return false. We then set ok to false. We believe that the sentry's constructor should always set failbit when ok is false, and we also think the standard already says that. Possibly it could be clearer.
Proposed resolution:
Change 27.7.1.1.3 [istream::sentry], p2 to:
explicit sentry(basic_istream<charT,traits>& is , bool noskipws = false);-2- Effects: If is.good() is
truefalse, calls is.setstate(failbit). Otherwise prepares for formatted or unformatted input. ...
Section: 27.6.2.1 [streambuf.cons] Status: Open Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2007-01-15
View all other issues in [streambuf.cons].
View all issues with Open 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.
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.
Section: 27 [input.output] Status: Open Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2006-12-27
View all other issues in [input.output].
View all issues with Open 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).
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.]
Section: 17.5.1.2 [structure.summary] Status: Open Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2008-09-22
View all issues with Open 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.8.6.1 [allocator.members], p3,
20.8.6.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.5.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.3.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. ]
Proposed resolution:
[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. ]
Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: Open Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2007-01-15
View other active issues in [facet.num.get.virtuals].
View all other issues in [facet.num.get.virtuals].
View all issues with Open status.
Discussion:
The requirements specified in Stage 2 and reiterated in the rationale of DR 221 (and echoed again in DR 303) specify that num_get<charT>:: do_get() compares characters on the stream against the widened elements of "012...abc...ABCX+-"
An implementation is required to allow programs to instantiate the num_get template on any charT that satisfies the requirements on a user-defined character type. These requirements do not include the ability of the character type to be equality comparable (the char_traits template must be used to perform tests for equality). Hence, the num_get template cannot be implemented to support any arbitrary character type. The num_get template must either make the assumption that the character type is equality-comparable (as some popular implementations do), or it may use char_traits<charT> to do the comparisons (some other popular implementations do that). This diversity of approaches makes it difficult to write portable programs that attempt to instantiate the num_get template on user-defined types.
[Kona: the heart of the problem is that we're theoretically supposed to use traits classes for all fundamental character operations like assignment and comparison, but facets don't have traits parameters. This is a fundamental design flaw and it appears all over the place, not just in this one place. It's not clear what the correct solution is, but a thorough review of facets and traits is in order. The LWG considered and rejected the possibility of changing numeric facets to use narrowing instead of widening. This may be a good idea for other reasons (see issue 459), but it doesn't solve the problem raised by this issue. Whether we use widen or narrow the num_get facet still has no idea which traits class the user wants to use for the comparison, because only streams, not facets, are passed traits classes. The standard does not require that two different traits classes with the same char_type must necessarily have the same behavior.]
Informally, one possibility: require that some of the basic character operations, such as eq, lt, and assign, must behave the same way for all traits classes with the same char_type. If we accept that limitation on traits classes, then the facet could reasonably be required to use char_traits<charT>.
Proposed resolution:
Section: 26.6.2.4 [valarray.sub] Status: Open Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2009-05-01
View all issues with Open status.
Discussion:
The standard fails to specify the behavior of valarray::operator[](slice) and other valarray subset operations when they are passed an "invalid" slice object, i.e., either a slice that doesn't make sense at all (e.g., slice (0, 1, 0) or one that doesn't specify a valid subset of the valarray object (e.g., slice (2, 1, 1) for a valarray of size 1).
[Kona: the LWG believes that invalid slices should invoke undefined behavior. Valarrays are supposed to be designed for high performance, so we don't want to require specific checking. We need wording to express this decision.]
[ Bellevue: ]
Please note that the standard also fails to specify the behavior of slice_array and gslice_array in the valid case. Bill Plauger will endeavor to provide revised wording for slice_array and gslice_array.
[ post-Bellevue: Bill provided wording. ]
Proposed resolution:
Insert after 26.6.2.4 [valarray.sub], paragraph 1:
The member operator is overloaded to provide several ways to select sequences of elements from among those controlled by *this. The first group of five member operators work in conjunction with various overloads of operator= (and other assigning operators) to allow selective replacement (slicing) of the controlled sequence. The selected elements must exist.
The first member operator selects element off. For example:
valarray<char> v0("abcdefghijklmnop", 16); v0[3] = 'A'; // v0 == valarray<char>("abcAefghijklmnop", 16)The second member operator selects those elements of the controlled sequence designated by slicearr. For example:
valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDE", 5); v0[slice(2, 5, 3)] = v1; // v0 == valarray<char>("abAdeBghCjkDmnEp", 16)The third member operator selects those elements of the controlled sequence designated by gslicearr. For example:
valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDEF", 6); const size_t lv[] = {2, 3}; const size_t dv[] = {7, 2}; const valarray<size_t> len(lv, 2), str(dv, 2); v0[gslice(3, len, str)] = v1; // v0 == valarray<char>("abcAeBgCijDlEnFp", 16)The fourth member operator selects those elements of the controlled sequence designated by boolarr. For example:
valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABC", 3); const bool vb[] = {false, false, true, true, false, true}; v0[valarray<bool>(vb, 6)] = v1; // v0 == valarray<char>("abABeCghijklmnop", 16)The fifth member operator selects those elements of the controlled sequence designated by indarr. For example:
valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDE", 5); const size_t vi[] = {7, 5, 2, 3, 8}; v0[valarray<size_t>(vi, 5)] = v1; // v0 == valarray<char>("abCDeBgAEjklmnop", 16)The second group of five member operators each construct an object that represents the value(s) selected. The selected elements must exist.
The sixth member operator returns the value of element off. For example:
valarray<char> v0("abcdefghijklmnop", 16); // v0[3] returns 'd'The seventh member operator returns an object of class valarray<Ty> containing those elements of the controlled sequence designated by slicearr. For example:
valarray<char> v0("abcdefghijklmnop", 16); // v0[slice(2, 5, 3)] returns valarray<char>("cfilo", 5)The eighth member operator selects those elements of the controlled sequence designated by gslicearr. For example:
valarray<char> v0("abcdefghijklmnop", 16); const size_t lv[] = {2, 3}; const size_t dv[] = {7, 2}; const valarray<size_t> len(lv, 2), str(dv, 2); // v0[gslice(3, len, str)] returns // valarray<char>("dfhkmo", 6)The ninth member operator selects those elements of the controlled sequence designated by boolarr. For example:
valarray<char> v0("abcdefghijklmnop", 16); const bool vb[] = {false, false, true, true, false, true}; // v0[valarray<bool>(vb, 6)] returns // valarray<char>("cdf", 3)The last member operator selects those elements of the controlled sequence designated by indarr. For example:
valarray<char> v0("abcdefghijklmnop", 16); const size_t vi[] = {7, 5, 2, 3, 8}; // v0[valarray<size_t>(vi, 5)] returns // valarray<char>("hfcdi", 5)
Section: X [allocator.requirements], 25 [algorithms] Status: Open Submitter: Matt Austern Opened: 2003-09-20 Last modified: 2009-05-01
View other active issues in [allocator.requirements].
View all other issues in [allocator.requirements].
View all issues with Open status.
Discussion:
Clause X [allocator.requirements] paragraph 4 says that implementations are permitted to supply containers that are unable to cope with allocator instances and that container implementations may assume that all instances of an allocator type compare equal. We gave implementers this latitude as a temporary hack, and eventually we want to get rid of it. What happens when we're dealing with allocators that don't compare equal?
In particular: suppose that v1 and v2 are both objects of type vector<int, my_alloc> and that v1.get_allocator() != v2.get_allocator(). What happens if we write v1.swap(v2)? Informally, three possibilities:
1. This operation is illegal. Perhaps we could say that an implementation is required to check and to throw an exception, or perhaps we could say it's undefined behavior.
2. The operation performs a slow swap (i.e. using three invocations of operator=, leaving each allocator with its original container. This would be an O(N) operation.
3. The operation swaps both the vectors' contents and their allocators. This would be an O(1) operation. That is:
my_alloc a1(...);
my_alloc a2(...);
assert(a1 != a2);
vector<int, my_alloc> v1(a1);
vector<int, my_alloc> v2(a2);
assert(a1 == v1.get_allocator());
assert(a2 == v2.get_allocator());
v1.swap(v2);
assert(a1 == v2.get_allocator());
assert(a2 == v1.get_allocator());
[Kona: This is part of a general problem. We need a paper saying how to deal with unequal allocators in general.]
[pre-Sydney: Howard argues for option 3 in N1599. ]
[ 2007-01-12, Howard: This issue will now tend to come up more often with move constructors and move assignment operators. For containers, these members transfer resources (i.e. the allocated memory) just like swap. ]
[ Batavia: There is agreement to overload the container swap on the allocator's Swappable requirement using concepts. If the allocator supports Swappable, then container's swap will swap allocators, else it will perform a "slow swap" using copy construction and copy assignment. ]
[ 2009-04-28 Pablo adds: ]
Fixed in N2525. I argued for marking this Tentatively-Ready right after Bellevue, but there was a concern that N2525 would break in the presence of the RVO. (That breakage had nothing to do with swap, but never-the-less). I addressed that breakage in in N2840 (Summit) my means of a non-normative reference:[Note: in situations where the copy constructor for a container is elided, this function is not called. The behavior in these cases is as if select_on_container_copy_construction returned x — end note]
Proposed resolution:
Section: 24.2 [iterator.concepts], 23.2 [container.requirements] Status: Open Submitter: Andy Koenig Opened: 2003-12-16 Last modified: 2008-09-30
View other active issues in [iterator.concepts].
View all other issues in [iterator.concepts].
View all issues with Open 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. ]
Proposed resolution:
Section: 24.2.6 [random.access.iterators] Status: Open Submitter: Daniel Frey Opened: 2004-02-27 Last modified: 2009-03-13
View other active issues in [random.access.iterators].
View all other issues in [random.access.iterators].
View all issues with Open 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.6 [random.access.iterators] p5. However, the rationale in the issue already recognises that the difference_type must be signed, so this really looks 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; }
Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: Open Submitter: Martin Sebor Opened: 2004-03-16 Last modified: 2006-12-27
View other active issues in [facet.num.get.virtuals].
View all other issues in [facet.num.get.virtuals].
View all issues with Open 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.]
Proposed resolution:
Change stage 2 so that implementations are permitted to use either technique to perform the comparison:
Section: D.9.1 [auto.ptr] Status: Open Submitter: Rani Sharoni Opened: 2003-12-07 Last modified: 2007-11-15
View other active issues in [auto.ptr].
View all other issues in [auto.ptr].
View all issues with Open 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:
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. ]
Proposed resolution:
Change the synopsis in D.9.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.9.1.3 [auto.ptr.conv].
Change D.9.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.9.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.9.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.
Section: 21.4.1 [string.require] Status: Open Submitter: Daniel Frey Opened: 2004-06-10 Last modified: 2009-03-22
View other active issues in [string.require].
View all other issues in [string.require].
View all issues with Open 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.]
[ Post Summit Alisdair requests this be re-opened as several new language facilities are designed to solve exactly this kind of problem. ]
Proposed resolution:
Add to the synopsis in 21.4 [basic.string]
basic_string( nullptr_t ) = delete;
Rationale:
Recommend NAD. Relegate this functionality to debugging implementations.
Section: 18.7.1 [type.info] Status: Open Submitter: Martin Sebor Opened: 2004-06-28 Last modified: 2008-06-11
View all other issues in [type.info].
View all issues with Open status.
Discussion:
[lib.exception] specifies the following:
exception (const exception&) throw();
exception& operator= (const exception&) throw();
-4- Effects: Copies an exception object.
-5- Notes: The effects of calling what() after assignment
are implementation-defined.
First, does the Note only apply to the assignment operator? If so, what are the effects of calling what() on a copy of an object? Is the returned pointer supposed to point to an identical copy of the NTBS returned by what() called on the original object or not?
Second, is this Note intended to extend to all the derived classes in section 19? I.e., does the standard provide any guarantee for the effects of what() called on a copy of any of the derived class described in section 19?
Finally, if the answer to the first question is no, I believe it constitutes a defect since throwing an exception object typically implies invoking the copy ctor on the object. If the answer is yes, then I believe the standard ought to be clarified to spell out exactly what the effects are on the copy (i.e., after the copy ctor was called).
[Redmond: Yes, this is fuzzy. The issue of derived classes is fuzzy too.]
[ Batavia: Howard provided wording. ]
[ Bellevue: ]
Eric concerned this is unimplementable, due to nothrow guarantees. Suggested implementation would involve reference counting.
Is the implied reference counting subtle enough to call out a note on implementation? Probably not.
If reference counting required, could we tighten specification further to require same pointer value? Probably an overspecification, especially if exception classes defer evalutation of final string to calls to what().
Remember issue moved open and not resolved at Batavia, but cannot remember who objected to canvas a disenting opinion - please speak up if you disagree while reading these minutes!
Move to Ready as we are accepting words unmodified.
[ Sophia Antipolis: ]
The issue was pulled from Ready. It needs to make clear that only homogenous copying is intended to be supported. Not coping from a dervied to a base.
Proposed resolution:
Change 18.8.1 [exception] to:
exception(const exception& e) throw(); exception& operator=(const exception& e) throw();-4- Effects: Copies an exception object.
-5- Remarks: The effects of calling what() after assignment are implementation-defined.-5- Throws: Nothing. This also applies to all standard library-defined classes that derive from exception.
-7- Postcondition: strcmp(what(), e.what()) == 0. This also applies to all standard library-defined classes that derive from exception.
Section: 22.4.1.1 [locale.ctype] Status: Open Submitter: Martin Sebor Opened: 2004-07-01 Last modified: 2006-12-27
View all issues with Open status.
Discussion:
Most ctype member functions come in two forms: one that operates on a single character at a time and another form that operates on a range of characters. Both forms are typically described by a single Effects and/or Returns clause.
The Returns clause of each of the single-character non-virtual forms suggests that the function calls the corresponding single character virtual function, and that the array form calls the corresponding virtual array form. Neither of the two forms of each virtual member function is required to be implemented in terms of the other.
There are three problems:
1. One is that while the standard does suggest that each non-virtual member function calls the corresponding form of the virtual function, it doesn't actually explicitly require it.
Implementations that cache results from some of the virtual member functions for some or all values of their arguments might want to call the array form from the non-array form the first time to fill the cache and avoid any or most subsequent virtual calls. Programs that rely on each form of the virtual function being called from the corresponding non-virtual function will see unexpected behavior when using such implementations.
2. The second problem is that either form of each of the virtual functions can be overridden by a user-defined function in a derived class to return a value that is different from the one produced by the virtual function of the alternate form that has not been overriden.
Thus, it might be possible for, say, ctype::widen(c) to return one value, while for ctype::widen(&c, &c + 1, &wc) to set wc to another value. This is almost certainly not intended. Both forms of every function should be required to return the same result for the same character, otherwise the same program using an implementation that calls one form of the functions will behave differently than when using another implementation that calls the other form of the function "under the hood."
3. The last problem is that the standard text fails to specify whether one form of any of the virtual functions is permitted to be implemented in terms of the other form or not, and if so, whether it is required or permitted to call the overridden virtual function or not.
Thus, a program that overrides one of the virtual functions so that it calls the other form which then calls the base member might end up in an infinite loop if the called form of the base implementation of the function in turn calls the other form.
Lillehammer: Part of this isn't a real problem. We already talk about caching. 22.1.1/6 But part is a real problem. ctype virtuals may call each other, so users don't know which ones to override to avoid avoid infinite loops.
This is a problem for all facet virtuals, not just ctype virtuals, so we probably want a blanket statement in clause 22 for all facets. The LWG is leaning toward a blanket prohibition, that a facet's virtuals may never call each other. We might want to do that in clause 27 too, for that matter. A review is necessary. Bill will provide wording.
Proposed resolution:
Section: 24.2.3 [output.iterators] Status: Open Submitter: Chris Jefferson Opened: 2004-10-13 Last modified: 2006-12-27
View all other issues in [output.iterators].
View all issues with Open status.
Discussion:
The note on 24.1.2 Output iterators insufficently 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.]
Proposed resolution:
Section: 23 [containers], 24 [iterators], 25 [algorithms] Status: Open Submitter: Thomas Mang Opened: 2004-12-12 Last modified: 2008-02-27
View other active issues in [containers].
View all other issues in [containers].
View all issues with Open 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.
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.]
Section: 25.4.13 [alg.partitions] Status: Open Submitter: Sean Parent, Joe Gottman Opened: 2005-05-04 Last modified: 2009-05-01
View all issues with Open status.
Discussion:
Problem: The iterator requirements for partition() and stable_partition() [25.2.12] are listed as BidirectionalIterator, however, there are efficient algorithms for these functions that only require ForwardIterator that have been known since before the standard existed. The SGI implementation includes these (see http://www.sgi.com/tech/stl/partition.html and http://www.sgi.com/tech/stl/stable_partition.html).
[ 2009-04-30 Alisdair adds: ]
Now we have concepts this is easier to express!
Proposed resolution:
Add the following signature to:
Header <algorithm> synopsis 25.2 [algorithms.syn]
p3 Partitions 25.4.13 [alg.partitions]template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred> requires ShuffleIterator<Iter> && CopyConstructible<Pred> Iter partition(Iter first, Iter last, Pred pred);Update p3 Partitions 25.4.13 [alg.partitions]:
Complexity:
At most (last - first)/2 swaps. Exactly last - first applications of the predicate are done.If Iter satisfies BidirectionalIterator, at most (last - first)/2 swaps. Exactly last - first applications of the predicate are done.If Iter merely satisfied ForwardIterator at most (last - first) swaps are done. Exactly (last - first) applications of the predicate are done.
[Editorial note: I looked for existing precedent in how we might call out distinct overloads overloads from a set of constrained templates, but there is not much existing practice to lean on. advance/distance were the only algorithms I could find, and that wording is no clearer.]
Proposed resolution:
Change 25.2.12 from
template<class BidirectionalIterator, class Predicate>
BidirectionalIterator partition(BidirectionalIterato r first,
BidirectionalIterator last,
Predicate pred);
to
template<class ForwardIterator, class Predicate>
ForwardIterator partition(ForwardIterator first,
ForwardIterator last,
Predicate pred);
Change the complexity from
At most (last - first)/2 swaps are done. Exactly (last - first) applications of the predicate are done.
to
If ForwardIterator is a bidirectional_iterator, at most (last - first)/2 swaps are done; otherwise at most (last - first) swaps are done. Exactly (last - first) applications of the predicate are done.
Rationale:
Partition is a "foundation" algorithm useful in many contexts (like sorting as just one example) - my motivation for extending it to include forward iterators is foward_list - without this extension you can't partition an foward_list (without writing your own partition). Holes like this in the standard library weaken the argument for generic programming (ideally I'd be able to provide a library that would refine std::partition() to other concepts without fear of conflicting with other libraries doing the same - but that is a digression). I consider the fact that partition isn't defined to work for ForwardIterator a minor embarrassment.
[Mont Tremblant: Moved to Open, request motivation and use cases by next meeting. Sean provided further rationale by post-meeting mailing.]
Section: 22.3.1.1.1 [locale.category] Status: Open Submitter: Christopher Conrade Zseleghovski Opened: 2005-06-07 Last modified: 2008-03-13
View all other issues in [locale.category].
View all issues with Open 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.
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. ]
Section: 22.4 [locale.categories] Status: Open Submitter: P.J. Plauger Opened: 2005-06-20 Last modified: 2008-03-13
View other active issues in [locale.categories].
View all other issues in [locale.categories].
View all issues with Open 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. ]
Proposed resolution:
Section: 28 [re] Status: Open Submitter: Eric Niebler Opened: 2005-07-01 Last modified: 2008-03-13
View all other issues in [re].
View all issues with Open 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. ]
Proposed resolution:
Section: 26.7.3 [partial.sum] Status: Open Submitter: Marc Schoolderman Opened: 2006-02-06 Last modified: 2008-06-18
View all issues with Open status.
Discussion:
There are some problems in the definition of partial_sum and adjacent_difference in 26.4 [lib.numeric.ops]
Unlike accumulate and inner_product, these functions are not parametrized on a "type T", instead, 26.4.3 [lib.partial.sum] simply specifies the effects clause as;
Assigns to every element referred to by iterator i in the range [result,result + (last - first)) a value correspondingly equal to
((...(* first + *( first + 1)) + ...) + *( first + ( i - result )))
And similarly for BinaryOperation. Using just this definition, it seems logical to expect that:
char i_array[4] = { 100, 100, 100, 100 };
int o_array[4];
std::partial_sum(i_array, i_array+4, o_array);
Is equivalent to
int o_array[4] = { 100, 100+100, 100+100+100, 100+100+100+100 };
i.e. 100, 200, 300, 400, with addition happening in the result type, int.
Yet all implementations I have tested produce 100, -56, 44, -112, because they are using an accumulator of the InputIterator's value_type, which in this case is char, not int.
The issue becomes more noticeable when the result of the expression *i + *(i+1) or binary_op(*i, *i-1) can't be converted to the value_type. In a contrived example:
enum not_int { x = 1, y = 2 };
...
not_int e_array[4] = { x, x, y, y };
std::partial_sum(e_array, e_array+4, o_array);
Is it the intent that the operations happen in the input type, or in the result type?
If the intent is that operations happen in the result type, something like this should be added to the "Requires" clause of 26.4.3/4 [lib.partial.sum]:
The type of *i + *(i+1) or binary_op(*i, *(i+1)) shall meet the requirements of CopyConstructible (20.1.3) and Assignable (23.1) types.
(As also required for T in 26.4.1 [lib.accumulate] and 26.4.2 [lib.inner.product].)
The "auto initializer" feature proposed in N1894 is not required to implement partial_sum this way. The 'narrowing' behaviour can still be obtained by using the std::plus<> function object.
If the intent is that operations happen in the input type, then something like this should be added instead;
The type of *first shall meet the requirements of CopyConstructible (20.1.3) and Assignable (23.1) types. The result of *i + *(i+1) or binary_op(*i, *(i+1)) shall be convertible to this type.
The 'widening' behaviour can then be obtained by writing a custom proxy iterator, which is somewhat involved.
In both cases, the semantics should probably be clarified.
26.4.4 [lib.adjacent.difference] is similarly underspecified, although all implementations seem to perform operations in the 'result' type:
unsigned char i_array[4] = { 4, 3, 2, 1 };
int o_array[4];
std::adjacent_difference(i_array, i_array+4, o_array);
o_array is 4, -1, -1, -1 as expected, not 4, 255, 255, 255.
In any case, adjacent_difference doesn't mention the requirements on the value_type; it can be brought in line with the rest of 26.4 [lib.numeric.ops] by adding the following to 26.4.4/2 [lib.adjacent.difference]:
The type of *first shall meet the requirements of CopyConstructible (20.1.3) and Assignable (23.1) types."
[ Berlin: Giving output iterator's value_types very controversial. Suggestion of adding signatures to allow user to specify "accumulator". ]
[ Bellevue: ]
The intent of the algorithms is to perform their calculations using the type of the input iterator. Proposed wording provided.
[ Sophia Antipolis: ]
We did not agree that the proposed resolution was correct. For example, when the arguments are types (float*, float*, double*), the highest-quality solution would use double as the type of the accumulator. If the intent of the wording is to require that the type of the accumulator must be the input_iterator's value_type, the wording should specify it.
Proposed resolution:
Add to section 26.7.3 [partial.sum] paragraph 4 the following two sentences:
The type of *first shall meet the requirements of CopyConstructible? (20.1.3?) and Assignable (23.1?) types. The result of *i + *(i+1) or binary_op(*i, *(i+1)) shall be convertible to this type.
Add to section 26.7.4 [adjacent.difference] paragraph 2 the following sentence:
The type of *first shall meet the requirements of CopyConstructible? (20.1.3) and Assignable (23.1) types.
Section: TR1 5.1.1 [tr.rand.req] Status: Open Submitter: Matt Austern Opened: 2006-01-10 Last modified: 2007-10-09
View all issues with Open 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.
Proposed resolution:
Section: 27.8.1.4 [stringbuf.virtuals] Status: Open Submitter: Martin Sebor Opened: 2006-02-23 Last modified: 2007-10-10
View all other issues in [stringbuf.virtuals].
View all issues with Open status.
Discussion:
The effects of the seekpos() member function of
basic_stringbuf simply say that the function positions
the input and/or output sequences but fail to spell out exactly
how. This is in contrast to the detail in which seekoff()
is described.
Proposed resolution:
Change 27.7.1.3, p13 to read:
-13- Effects: Same as seekoff(off_type(sp), ios_base::beg, which).
Alters the stream position within the controlled sequences, if possible, to correspond to the stream position stored in sp (as described below).
If (which & ios_base::in) != 0, positions the input sequence.If (which & ios_base::out) != 0, positions the output sequence.If sp is an invalid stream position, or if the function positions neither sequence, the positioning operation fails. If sp has not been obtained by a previous successful call to one of the positioning functions (seekoff, seekpos, tellg, tellp) the effect is undefined.
[ Kona (2007): A pos_type is a position in a stream by definition, so there is no ambiguity as to what it means. Proposed Disposition: NAD ]
[ Post-Kona Martin adds: I'm afraid I disagree with the Kona '07 rationale for marking it NAD. The only text that describes precisely what it means to position the input or output sequence is in seekoff(). The seekpos() Effects clause is inadequate in comparison and the proposed resolution plugs the hole by specifying seekpos() in terms of seekoff(). ]
Section: 27.6.2.4.5 [streambuf.virt.put] Status: Open Submitter: Martin Sebor Opened: 2006-02-23 Last modified: 2007-10-09
View all issues with Open status.
Discussion:
streambuf::xsputn() is specified to have the effect of "writing up to n characters to the output sequence as if by repeated calls to sputc(c)."
Since sputc() is required to call overflow() when (pptr() == epptr()) is true, strictly speaking xsputn() should do the same. However, doing so would be suboptimal in some interesting cases, such as in unbuffered mode or when the buffer is basic_stringbuf.
Assuming calling overflow() is not really intended to be required and the wording is simply meant to describe the general effect of appending to the end of the sequence it would be worthwhile to mention in xsputn() that the function is not actually required to cause a call to overflow().
Proposed resolution:
Add the following sentence to the xsputn() Effects clause in 27.5.2.4.5, p1 (N1804):
-1- Effects: Writes up to n characters to the output sequence as if by repeated calls to sputc(c). The characters written are obtained from successive elements of the array whose first element is designated by s. Writing stops when either n characters have been written or a call to sputc(c) would return traits::eof(). It is uspecified whether the function calls overflow() when (pptr() == epptr()) becomes true or whether it achieves the same effects by other means.
In addition, I suggest to add a footnote to this function with the same text as Footnote 292 to make it extra clear that derived classes are permitted to override xsputn() for efficiency.
[ Kona (2007): We want to permit a streambuf that streams output directly to a device without making calls to sputc or overflow. We believe that has always been the intention of the committee. We believe that the proposed wording doesn't accomplish that. Proposed Disposition: Open ]
Section: TR1 8.16.4 [tr.c99.cmath.over] Status: New Submitter: Paolo Carlini Opened: 2006-03-07 Last modified: 2007-05-11
View all issues with New 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.
Proposed resolution:
Add log2 to the list of functions in TR1 8.16.4 [tr.c99.cmath.over] p1.
Section: 27.5.3 [fpos] Status: Open Submitter: Beman Dawes Opened: 2006-04-12 Last modified: 2007-10-09
View all other issues in [fpos].
View all issues with Open status.
Discussion:
There are two deficiencies related to file sizes:
The Dinkumware implementation of the Standard Library as shipped with the Microsoft compiler copes with these issues by:
fpos_t seekpos() const;
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 ]
Proposed resolution:
Section: 23.2.1 [container.requirements.general] Status: Open Submitter: Martin Sebor Opened: 2006-06-14 Last modified: 2009-05-01
View other active issues in [container.requirements.general].
View all other issues in [container.requirements.general].
View all issues with Open 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].
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
Allocatorcopyanthe allocator argument from their respective first parameters. All other constructors for these container types take anconstAllocator&argument (20.1.6), an allocator whosevalue_typeis the same as the container'svalue_type. A copy of this argumentisshall 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 theallocate()member function on a copy of the allocator object of the appropriate type New Footnote), and deallocation "as if" by callingdeallocate()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'svalue_type, and to obtain their address. All objects residing in storage allocated by a container's allocator shall be constructed "as if" by calling theconstruct()member function on a copy of the allocator object of the appropriate type. The same objects shall be destroyed "as if" by callingdestroy()on a copy of the same allocator object of the same type. The address of such objects shall be obtained "as if" by calling theaddress()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'svalue_typethe container may store at the same time. The container member functionmax_size()obtains this number from the value returned by a call toget_allocator().max_size(). In all container types defined in this clause that are parametrized onAllocator, the memberget_allocator()returns a copy of theAllocatorobject used to construct the container.258)New Footnote: This type may be different from
Allocator: it may be derived fromAllocatorviaAllocator::rebind<U>::otherfor the appropriate typeU.
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. ]
Section: 20.8.11.2 [uninitialized.copy] Status: Open Submitter: Martin Sebor Opened: 2006-06-14 Last modified: 2009-03-14
View all other issues in [uninitialized.copy].
View all issues with Open 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. ]
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.
Section: 22.4 [locale.categories] Status: Open Submitter: Martin Sebor, Paolo Carlini Opened: 2006-06-22 Last modified: 2007-10-09
View other active issues in [locale.categories].
View all other issues in [locale.categories].
View all issues with Open 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.
Proposed resolution:
We believe the intent is for all facet member functions that take an
ios_base::iostate& argument to:
err argument,
err to ios_base::goodbit prior
to any further processing,
ios_base::eofbit, or
ios_base::failbit, or both in err, as
appropriate, in response to reaching the end-of-file or on parse
error, or both.
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 ]
Section: 23.3.1 [array] Status: Open Submitter: Gennaro Prota Opened: 2006-07-18 Last modified: 2007-10-09
View other active issues in [array].
View all other issues in [array].
View all issues with Open 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
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 ]
Section: TRDecimal 3.2 [trdec.types.types] Status: Open Submitter: Daveed Vandevoorde Opened: 2006-04-05 Last modified: 2009-05-01
View other active issues in [trdec.types.types].
View all other issues in [trdec.types.types].
View all issues with Open 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:
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.
Proposed resolution:
Section: TRDecimal 3.2 [trdec.types.types] Status: Open Submitter: Martin Sebor Opened: 2006-06-15 Last modified: 2007-01-15
View other active issues in [trdec.types.types].
View all other issues in [trdec.types.types].
View all issues with Open 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.
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. ]
Section: 21.4 [basic.string] Status: Open Submitter: Bo Persson Opened: 2006-12-05 Last modified: 2008-03-12
View other active issues in [basic.string].
View all other issues in [basic.string].
View all issues with Open 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: ]
[ 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. ]
Proposed resolution:
Section: 23.3.1 [array] Status: Open Submitter: Bo Persson Opened: 2006-12-30 Last modified: 2008-03-14
View other active issues in [array].
View all other issues in [array].
View all issues with Open 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.
Proposed resolution:
Section: 17 [library] Status: Open Submitter: Martin Sebor Opened: 2007-01-20 Last modified: 2008-09-22
View other active issues in [library].
View all other issues in [library].
View all issues with Open status.
Discussion:
Many member functions of basic_string are overloaded,
with some of the overloads taking a string argument,
others value_type*, others size_type, and
others still iterators. Often, the requirements on one of
the overloads are expressed in the form of Effects,
Throws, and in the Working Paper
(N2134)
also Remark clauses, while those on the rest of the overloads
via a reference to this overload and using a Returns clause.
The difference between the two forms of specification is that per 17.5.1.4 [structure.specifications], p3, an Effects clause specifies "actions performed by the functions," i.e., its observable effects, while a Returns clause is "a description of the return value(s) of a function" that does not impose any requirements on the function's observable effects.
Since only Notes are explicitly defined to be informative and all other paragraphs are explicitly defined to be normative, like Effects and Returns, the new Remark clauses also impose normative requirements.
So by this strict reading of the standard there are some member functions of
basic_string that are required to throw an
exception under some conditions or use specific traits members while
many other otherwise equivalent overloads, while obliged to return the
same values, aren't required to follow the exact same requirements
with regards to the observable effects.
Here's an example of this problem that was precipitated by the change from informative Notes to normative Remarks (presumably made to address 424):
In the Working Paper,
find(string, size_type) contains a
Remark clause (which is just a Note in the current
standard) requiring it to use traits::eq().
find(const charT *s, size_type pos) is specified to
return find(string(s), pos) by a Returns clause
and so it is not required to use traits::eq(). However,
the Working Paper has replaced the original informative Note
about the function using traits::length() with a
normative requirement in the form of a Remark. Calling
traits::length() may be suboptimal, for example when the
argument is a very long array whose initial substring doesn't appear
anywhere in *this.
Here's another similar example, one that existed even prior to the introduction of Remarks:
insert(size_type pos, string, size_type, size_type) is
required to throw out_of_range if pos >
size().
insert(size_type pos, string str) is specified to return
insert(pos, str, 0, npos) by a Returns clause and
so its effects when pos > size() are strictly speaking
unspecified.
I believe a careful review of the current Effects and Returns clauses is needed in order to identify all such problematic cases. In addition, a review of the Working Paper should be done to make sure that the newly introduced normative Remark clauses do not impose any undesirable normative requirements in place of the original informative Notes.
[ Batavia: Alan and Pete to work. ]
[ Bellevue: Marked as NAD Editorial. ]
[ Post-Sophia Antipolis: Martin indicates there is still work to be done on this issue. Reopened. ]
Proposed resolution:
Section: 26.6.2.1 [valarray.cons] Status: Open Submitter: Martin Sebor Opened: 2007-01-28 Last modified: 2008-06-02
View other active issues in [valarray.cons].
View all other issues in [valarray.cons].
View all issues with Open status.
Discussion:
Section 26.2 [numeric.requirements], p1 suggests that a
valarray specialization on a type T that
satisfies the requirements enumerated in the paragraph is itself a
valid type on which valarray may be instantiated
(Footnote 269 makes this clear). I.e.,
valarray<valarray<T> > is valid as long as
T is valid. However, since implementations of
valarray are permitted to initialize storage allocated by
the class by invoking the default ctor of T followed by
the copy assignment operator, such implementations of
valarray wouldn't work with (perhaps user-defined)
specializations of valarray whose assignment operator had
undefined behavior when the size of its argument didn't match the size
of *this. By "wouldn't work" I mean that it would
be impossible to resize such an array of arrays by calling the
resize() member function on it if the function used the
copy assignment operator after constructing all elements using the
default ctor (e.g., by invoking new value_type[N]) to
obtain default-initialized storage) as it's permitted to do.
Stated more generally, the problem is that
valarray<valarray<T> >::resize(size_t) isn't
required or guaranteed to have well-defined semantics for every type
T that satisfies all requirements in
26.2 [numeric.requirements].
I believe this problem was introduced by the adoption of the
resolution outlined in N0857,
Assignment of valarrays, from 1996. The copy assignment
operator of the original numerical array classes proposed in N0280,
as well as the one proposed in N0308
(both from 1993), had well-defined semantics for arrays of unequal
size (the latter explicitly only when *this was empty;
assignment of non empty arrays of unequal size was a runtime error).
The justification for the change given in N0857 was the "loss of performance [deemed] only significant for very simple operations on small arrays or for architectures with very few registers."
Since tiny arrays on a limited subset of hardware architectures are
likely to be an exceedingly rare case (despite the continued
popularity of x86) I propose to revert the resolution and make the
behavior of all valarray assignment operators
well-defined even for non-conformal arrays (i.e., arrays of unequal
size). I have implemented this change and measured no significant
degradation in performance in the common case (non-empty arrays of
equal size). I have measured a 50% (and in some cases even greater)
speedup in the case of assignments to empty arrays versus calling
resize() first followed by an invocation of the copy
assignment operator.
[ Bellevue: ]
If no proposed wording by June meeting, this issue should be closed NAD.
Proposed resolution:
Change 26.6.2.2 [valarray.assign], p1 as follows:
valarray<T>& operator=(const valarray<T>& x);-1- Each element of the
*thisarray is assigned the value of the corresponding element of the argument array.The resulting behavior is undefined ifWhen the length of the argument array is not equal to the length of the *this array.resizes*thisto make the two arrays the same length, as if by callingresize(x.size()), before performing the assignment.
And add a new paragraph just below paragraph 1 with the following text:
-2- Postcondition:
size() == x.size().
Also add the following paragraph to 26.6.2.2 [valarray.assign], immediately after p4:
-?- When the length,
Nof the array referred to by the argument is not equal to the length of*this, the operator resizes*thisto make the two arrays the same length, as if by callingresize(N), before performing the assignment.
[ pre-Sophia Antipolis, Martin adds the following compromise wording, but prefers the original proposed resolution: ]
Change 26.6.2.2 [valarray.assign], p1 as follows:
-1- Requires: size() == 0 || size() == x.size().
-2- Effects: If size() == 0 calls x.resize(x.size()) first. Each element of the *this array is assigned the value of the corresponding element of the argument array.
-3- Postcondition: size() == x.size().
Add the following paragraph to 26.6.2.2 [valarray.assign], immediately after p4:
-?- When size() == 0 and the length, N of the array referred to by the argument is not equal to the length of *this, the operator resizes *this to make the two arrays the same length, as if by calling resize(N), before performing the assignment. Otherwise, when size() > 0 and size() != N, the behavior is undefined.
[ Kona (2007): Gaby to propose wording for an alternative resolution in which you can assign to a valarray of size 0, but not to any other valarray whose size is unequal to the right hand side of the assignment. ]
Section: 23.2 [container.requirements] Status: Open Submitter: Lionel B Opened: 2007-02-01 Last modified: 2008-03-12
View other active issues in [container.requirements].
View all other issues in [container.requirements].
View all issues with Open 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.
Proposed resolution:
[ 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).
Section: X [allocator.requirements] Status: Open Submitter: Howard Hinnant Opened: 2007-02-08 Last modified: 2009-05-01
View other active issues in [allocator.requirements].
View all other issues in [allocator.requirements].
View all issues with Open status.
Discussion:
The table of allocator requirements in X [allocator.requirements] describes allocator::address as:
a.address(r) a.address(s)
where r and s are described as:
a value of type X::reference obtained by the expression *p.
and p is
a value of type X::pointer, obtained by calling a1.allocate, where a1 == a
This all implies that to get the address of some value of type T that value must have been allocated by this allocator or a copy of it.
However sometimes container code needs to compare the address of an external value of type T with an internal value. For example list::remove(const T& t) may want to compare the address of the external value t with that of a value stored within the list. Similarly vector or deque insert may want to make similar comparisons (to check for self-referencing calls).
Mandating that allocator::address can only be called for values which the allocator allocated seems overly restrictive.
[ post San Francisco: ]
Pablo recommends NAD Editorial, solved by N2768.
[ 2009-04-28 Pablo adds: ]
Tentatively-ready NAD Editorial as fixed by N2768.
Proposed resolution:
Change X [allocator.requirements]:
r : a value of type X::reference
obtained by the expression *p.s : a value of type X::const_reference
obtained by the expression *q or by conversion from a value r.
[ post Oxford: This would be rendered NAD Editorial by acceptance of N2257. ]
[ Kona (2007): This issue is section 8 of N2387. There was some discussion of it but no resolution to this issue was recorded. Moved to Open. ]
Section: 20.7.16.2 [func.wrap.func] Status: Open Submitter: Bo Persson Opened: 2007-02-25 Last modified: 2008-09-30
View other active issues in [func.wrap.func].
View all other issues in [func.wrap.func].
View all issues with Open status.
Discussion:
20.7.16.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?
Proposed resolution:
Change 20.7.16.2 [func.wrap.func]
... private: // 20.7.16.2 [func.wrap.func], undefined operators: template<class Function2>boolvoid operator==(const function<Function2>&); template<class Function2>boolvoid operator!=(const function<Function2>&); };
Change 20.7.16.2 [func.wrap.func]
template<class Function2>boolvoid operator==(const function<Function2>&); template<class Function2>boolvoid operator!=(const function<Function2>&);
Section: 24.6.3 [istreambuf.iterator] Status: Open Submitter: Niels Dekker Opened: 2007-03-25 Last modified: 2009-05-01
View all other issues in [istreambuf.iterator].
View all issues with Open status.
Discussion:
Greg Herlihy has clearly demonstrated that a user defined input iterator should have an operator->(), even if its value type is a built-in type (comp.std.c++, "Re: Should any iterator have an operator->() in C++0x?", March 2007). And as Howard Hinnant remarked in the same thread that the input iterator istreambuf_iterator doesn't have one, this must be a defect!
Based on Greg's example, the following code demonstrates the issue:
#include <iostream>
#include <fstream>
#include <streambuf>
typedef char C;
int main ()
{
std::ifstream s("filename", std::ios::in);
std::istreambuf_iterator<char> i(s);
(*i).~C(); // This is well-formed...
i->~C(); // ... so this should be supported!
}
Of course, operator-> is also needed when the value_type of istreambuf_iterator is a class.
The operator-> could be implemented in various ways. For instance, by storing the current value inside the iterator, and returning its address. Or by returning a proxy, like operator_arrow_proxy, from http://www.boost.org/boost/iterator/iterator_facade.hpp
I hope that the resolution of this issue will contribute to getting a clear and consistent definition of iterator concepts.
[ 2009-04-30 Alisdair adds: ]
Note that operator-> is now a requirement in the InputIterator concept, so this issue cannot be ignored or existing valid programs will break when compiled with an 0x library.
Proposed resolution:
Add to the synopsis in 24.6.3 [istreambuf.iterator]:
charT operator*() const; pointer operator->() const; istreambuf_iterator<charT,traits>& operator++();
Change 24.6.3 [istreambuf.iterator], p1:
The class template istreambuf_iterator reads successive characters from the streambuf for which it was constructed. operator* provides access to the current input character, if any. operator-> may return a proxy. Each time operator++ is evaluated, the iterator advances to the next input character. If the end of stream is reached (streambuf_type::sgetc() returns traits::eof()), the iterator becomes equal to the end of stream iterator value. 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.
[ Kona (2007): The proposed resolution is inconsistent because the return type of istreambuf_iterator::operator->() is specified to be pointer, but the proposed text also states that "operator-> may return a proxy." ]
[ Niels Dekker (mailed to Howard Hinnant): ]
The proposed resolution does not seem inconsistent to me. istreambuf_iterator::operator->() should have istreambuf_iterator::pointer as return type, and this return type may in fact be a proxy.
AFAIK, the resolution of 445 ("iterator_traits::reference unspecified for some iterator categories") implies that for any iterator class Iter, the return type of operator->() is Iter::pointer, by definition. I don't think Iter::pointer needs to be a raw pointer.
Still I wouldn't mind if the text "operator-> may return a proxy" would be removed from the resolution. I think it's up to the library implementation, how to implement istreambuf_iterator::operator->(). As longs as it behaves as expected: i->m should have the same effect as (*i).m. Even for an explicit destructor call, i->~C(). The main issue is just: istreambuf_iterator should have an operator->()!
Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: Open Submitter: Thomas Plum Opened: 2007-04-16 Last modified: 2008-03-12
View other active issues in [locale.money.get.virtuals].
View all other issues in [locale.money.get.virtuals].
View all issues with Open 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.
Proposed resolution:
Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: Open Submitter: Thomas Plum Opened: 2007-04-16 Last modified: 2008-01-14
View other active issues in [locale.money.get.virtuals].
View all other issues in [locale.money.get.virtuals].
View all issues with Open 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. ]
Proposed resolution:
Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: Open Submitter: Thomas Plum Opened: 2007-04-16 Last modified: 2008-01-14
View other active issues in [locale.money.get.virtuals].
View all other issues in [locale.money.get.virtuals].
View all issues with Open 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. ]
Proposed resolution:
Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: Open Submitter: John Salmon Opened: 2007-04-20 Last modified: 2009-03-12
View all other issues in [facet.num.put.virtuals].
View all issues with Open status.
Discussion:
I am trying to understand how TR1 supports hex float (%a) output.
As far as I can tell, it does so via the following:
8.15 Additions to header <locale> [tr.c99.locale]
In subclause 22.4.2.2.2 [facet.num.put.virtuals], Table 58 Floating-point conversions, after the line: floatfield == ios_base::scientific %E
add the two lines:
floatfield == ios_base::fixed | ios_base::scientific && !uppercase %a floatfield == ios_base::fixed | ios_base::scientific %A 2
[Note: The additional requirements on print and scan functions, later in this clause, ensure that the print functions generate hexadecimal floating-point fields with a %a or %A conversion specifier, and that the scan functions match hexadecimal floating-point fields with a %g conversion specifier. end note]
Following the thread, in 22.4.2.2.2 [facet.num.put.virtuals], we find:
For conversion from a floating-point type, if (flags & fixed) != 0 or if str.precision() > 0, then str.precision() is specified in the conversion specification.
This would seem to imply that when floatfield == fixed|scientific, the precision of the conversion specifier is to be taken from str.precision(). Is this really what's intended? I sincerely hope that I'm either missing something or this is an oversight. Please tell me that the committee did not intend to mandate that hex floats (and doubles) should by default be printed as if by %.6a.
[ Howard: I think the fundamental issue we overlooked was that with %f, %e, %g, the default precision was always 6. With %a the default precision is not 6, it is infinity. So for the first time, we need to distinguish between the default value of precision, and the precision value 6. ]
Proposed resolution:
[ Kona (2007): Robert volunteers to propose wording. ]
Section: 20.7.5.1 [refwrap.const] Status: Open Submitter: Peter Dimov Opened: 2007-05-10 Last modified: 2008-03-26
View all other issues in [refwrap.const].
View all issues with Open status.
Discussion:
A reference_wrapper can be constructed from an rvalue, either by using the constructor, or via cref (and ref in some corner cases). This leads to a dangling reference being stored into the reference_wrapper object. Now that we have a mechanism to detect an rvalue, we can fix them to disallow this source of undefined behavior.
Also please see the thread starting at c++std-lib-17398 for some good discussion on this subject.
Proposed resolution:
In 20.7 [function.objects], add the following two signatures to the synopsis:
template <class T> void ref(const T&& t) = delete; template <class T> void cref(const T&& t) = delete;
[ N2292 addresses the first part of the resolution but not the second. ]
[ Bellevue: Doug noticed problems with the current wording. ]
[ post Bellevue: Howard and Peter provided revised wording. ]
[ This resolution depends on a "favorable" resolution of CWG 606: that is, the "special deduction rule" is disabled with the const T&& pattern. ]
istream::operator>>(int&) brokenSection: 27.7.1.2.2 [istream.formatted.arithmetic] Status: New Submitter: Martin Sebor Opened: 2007-06-23 Last modified: 2007-06-23
View all other issues in [istream.formatted.arithmetic].
View all issues with New status.
Discussion:
From message c++std-lib-17897:
The code shown in 27.7.1.2.2 [istream.formatted.arithmetic] as the "as if"
implementation of the two arithmetic extractors that don't have a
corresponding num_get interface (i.e., the
short and int overloads) is subtly buggy in
how it deals with EOF, overflow, and other similar
conditions (in addition to containing a few typos).
One problem is that if num_get::get() reaches the EOF
after reading in an otherwise valid value that exceeds the limits of
the narrower type (but not LONG_MIN or
LONG_MAX), it will set err to
eofbit. Because of the if condition testing for
(err == 0), the extractor won't set
failbit (and presumably, return a bogus value to the
caller).
Another problem with the code is that it never actually sets the
argument to the extracted value. It can't happen after the call to
setstate() since the function may throw, so we need to
show when and how it's done (we can't just punt as say: "it happens
afterwards"). However, it turns out that showing how it's done isn't
quite so easy since the argument is normally left unchanged by the
facet on error except when the error is due to a misplaced thousands
separator, which causes failbit to be set but doesn't
prevent the facet from storing the value.
Proposed resolution:
Section: TR1 5.2.1.1 [tr.num.sf.Lnm] Status: New Submitter: Christopher Crawford Opened: 2007-06-30 Last modified: 2008-03-12
View all issues with New 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.
Proposed resolution:
Section: TR1 5.2.1.2 [tr.num.sf.Plm] Status: New Submitter: Christopher Crawford Opened: 2007-06-30 Last modified: 2008-03-12
View all issues with New 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.
Proposed resolution:
Section: 22 [localization] Status: Open Submitter: Peter Dimov Opened: 2007-07-28 Last modified: 2008-09-17
View other active issues in [localization].
View all other issues in [localization].
View all issues with Open status.
Discussion:
The POSIX "Extended API Set Part 4,"
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. ]
Proposed resolution:
Section: 20.8.13.2.5 [util.smartptr.shared.obs] Status: Open Submitter: Peter Dimov Opened: 2007-08-24 Last modified: 2008-06-18
View all other issues in [util.smartptr.shared.obs].
View all issues with Open status.
Discussion:
A discussion on comp.std.c++ has identified a contradiction in the shared_ptr specification. The note:
[ Note: this constructor allows creation of an empty shared_ptr instance with a non-NULL stored pointer. -end note ]
after the aliasing constructor
template<class Y> shared_ptr(shared_ptr<Y> const& r, T *p);
reflects the intent of N2351 to, well, allow the creation of an empty shared_ptr with a non-NULL stored pointer.
This is contradicted by the second sentence in the Returns clause of 20.8.13.2.5 [util.smartptr.shared.obs]:
T* get() const;Returns: the stored pointer. Returns a null pointer if *this is empty.
[ Bellevue: ]
Adopt option 1 and move to review, not ready.
There was a lot of confusion about what an empty shared_ptr is (the term isn't defined anywhere), and whether we have a good mental model for how one behaves. We think it might be possible to deduce what the definition should be, but the words just aren't there. We need to open an issue on the use of this undefined term. (The resolution of that issue might affect the resolution of issue 711.)
The LWG is getting more uncomfortable with the aliasing proposal (N2351) now that we realize some of its implications, and we need to keep an eye on it, but there isn't support for removing this feature at this time.
[ Sophia Antipolis: ]
We heard from Peter Dimov, who explained his reason for preferring solution 1.
Because it doesn't seem to add anything. It simply makes the behavior for p = 0 undefined. For programmers who don't create empty pointers with p = 0, there is no difference. Those who do insist on creating them presumably have a good reason, and it costs nothing for us to define the behavior in this case.
The aliasing constructor is sharp enough as it is, so "protecting" users doesn't make much sense in this particular case.
> Do you have a use case for r being empty and r being non-null?
I have received a few requests for it from "performance-conscious" people (you should be familiar with this mindset) who don't like the overhead of allocating and maintaining a control block when a null deleter is used to approximate a raw pointer. It is obviously an "at your own risk", low-level feature; essentially a raw pointer behind a shared_ptr facade.
We could not agree upon a resolution to the issue; some of us thought that Peter's description above is supporting an undesirable behavior.
Proposed resolution:
In keeping the N2351 spirit and obviously my preference, change 20.8.13.2.5 [util.smartptr.shared.obs]:
T* get() const;Returns: the stored pointer.
Returns a null pointer if *this is empty.
Alternative proposed resolution: (I won't be happy if we do this, but it's possible):
Change 20.8.13.2.1 [util.smartptr.shared.const]:
template<class Y> shared_ptr(shared_ptr<Y> const& r, T *p);Requires: If r is empty, p shall be 0.
[ Note: this constructor allows creation of an empty shared_ptr instance with a non-NULL stored pointer. -- end note ]
Section: 28.14 [re.grammar] Status: New Submitter: Stephan T. Lavavej Opened: 2007-08-31 Last modified: 2007-09-04
View all issues with New status.
Discussion:
TR1 7.13 [tr.re.grammar]/3 and C++0x WP 28.14 [re.grammar]/3 say:
The following productions within the ECMAScript grammar are modified as follows:
CharacterClass :: [ [lookahead ∉ {^}] ClassRanges ] [ ^ ClassRanges ]
This definition for CharacterClass appears to be exactly identical to that in ECMA-262.
Was an actual modification intended here and accidentally omitted, or was this production accidentally included?
Proposed resolution:
Remove this mention of the CharacterClass production.
CharacterClass :: [ [lookahead ∉ {^}] ClassRanges ] [ ^ ClassRanges ]
Section: 21.4 [basic.string] Status: Open Submitter: Bo Persson Opened: 2007-08-18 Last modified: 2008-03-12
View other active issues in [basic.string].
View all other issues in [basic.string].
View all issues with Open 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: ]
- emplace, for example, may not make sense for strings. Is also likely suboptimal
- with concepts do we need to maintain string as sequence container?
- One approach might be to say something like: string is a sequence except it doesn't have these functions
General consensus is to suggest option 2.
- basic_string already has push_back
- const_iterator parameters to insert and erase should be added to basic_string
- this leaves emplace to handle -- we have the following options:
- option 1: add it to string even though it's optional
- option 2: make emplace optional to sequences (move from table 89 to 90)
- option 3: say string not sequence (the proposal),
- option 4: add an exception to basic string wording.
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.
Section: 20.6 [meta] Status: Open Submitter: Daniel Krügler Opened: 2007-08-25 Last modified: 2009-03-14
View other active issues in [meta].
View all other issues in [meta].
View all issues with Open status.
Discussion:
Since the inclusion of constexpr in the standard draft N2369 we have a new type category "literal", which is defined in 3.9 [basic.types]/p.11:
-11- A type is a literal type if it is:
- a scalar type; or
a class type (clause 9) with
- a trivial copy constructor,
- a trivial destructor,
- at least one constexpr constructor other than the copy constructor,
- no virtual base classes, and
- all non-static data members and base classes of literal types; or
- an array of literal type.
I strongly suggest that the standard provides a type traits for literal types in 20.6.4.3 [meta.unary.prop] for several reasons:
The special problem of reason (c) is that I don't see currently a way to portably test the condition for literal class types:
- at least one constexpr constructor other than the copy constructor,
[ 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. ]
Proposed resolution:
In 20.6.2 [meta.type.synop] in the group "type properties", just below the line
template <class T> struct is_pod;
add a new one:
template <class T> struct is_literal;
In 20.6.4.3 [meta.unary.prop], table Type Property Predicates, just below the line for the is_pod property add a new line:
| Template | Condition | Preconditions |
|---|---|---|
| template <class T> struct is_literal; | T is a literal type (3.9) | T shall be a complete type, an array of unknown bound, or (possibly cv-qualified) void. |
Section: 22.3.3.2.2 [conversions.string] Status: Open Submitter: Bo Persson Opened: 2007-08-27 Last modified: 2008-09-18
View other active issues in [conversions.string].
View all other issues in [conversions.string].
View all issues with Open 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.
Proposed resolution:
Section: 28.9 [re.regex] Status: Open Submitter: Daniel Krügler Opened: 2007-08-29 Last modified: 2009-03-13
View all other issues in [re.regex].
View all issues with Open status.
Discussion:
Addresses UK 316
According to the current state of the standard draft, the class template basic_regex, as described in 28.9 [re.regex]/3, is neither MoveConstructible nor MoveAssignable. IMO it should be, because typical regex state machines tend to have a rather large data quantum and I have seen several use cases, where a factory function returns regex values, which would take advantage of moveabilities.
[ Sophia Antipolis: ]
Needs wording for the semantics, the idea is agreed upon.
[ Post Summit Daniel updated wording to reflect new "swap rules". ]
Proposed resolution:
In the class definition of basic_regex, just below 28.9 [re.regex]/3, perform the following changes:
Just after basic_regex(const basic_regex&); insert:
basic_regex(basic_regex&&);
Just after basic_regex& operator=(const basic_regex&); insert:
basic_regex& operator=(basic_regex&&);
Just after basic_regex& assign(const basic_regex& that); insert:
basic_regex& assign(basic_regex&& that);
In 28.9.2 [re.regex.construct], just after p.11 add the following new member definition:
basic_regex(basic_regex&& e);Effects: Move-constructs a basic_regex instance from e.
Postconditions: flags() and mark_count() return e.flags() and e.mark_count(), respectively, that e had before construction, leaving e in a valid state with an unspecified value.
Throws: nothing.
Also in 28.9.2 [re.regex.construct], just after p.18 add the following new member definition:
basic_regex& operator=(basic_regex&& e);Effects: Returns the result of assign(std::move(e)).
In 28.9.3 [re.regex.assign], just after p. 2 add the following new member definition:
basic_regex& assign(basic_regex&& rhs);Effects: Move-assigns a basic_regex instance from rhs and returns *this.
Postconditions: flags() and mark_count() return rhs.flags() and rhs.mark_count(), respectively, that rhs had before assignment, leaving rhs in a valid state with an unspecified value.
Throws: nothing.
Section: 28.12.4 [re.alg.replace] Status: Open Submitter: Stephan T. Lavavej Opened: 2007-09-22 Last modified: 2008-06-18
View other active issues in [re.alg.replace].
View all other issues in [re.alg.replace].
View all issues with Open 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);
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.
[ Sophia Antipolis: ]
We note that Boost already has these overloads. However, the proposed wording is provided only for 28.12.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.
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.12.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);
Section: 28.12.4 [re.alg.replace] Status: New Submitter: Stephan T. Lavavej Opened: 2007-09-22 Last modified: 2008-01-14
View other active issues in [re.alg.replace].
View all other issues in [re.alg.replace].
View all issues with New status.
Discussion:
regex_match() and regex_search() take const basic_string<charT, ST, SA>&. regex_replace() takes const basic_string<charT>&. This prevents regex_replace() from accepting basic_strings with custom traits and allocators.
Proposed resolution:
Overloads of regex_replace() taking basic_string should be additionally templated on class ST, class SA and take const basic_string<charT, ST, SA>&. Consistency with regex_match() and regex_search() would place class ST, class SA as the first template arguments; compatibility with existing code using TR1 and giving explicit template arguments to regex_replace() would place class ST, class SA as the last template arguments.
Section: 20.6.4.3 [meta.unary.prop] Status: Open Submitter: Alisdair Meredith Opened: 2007-10-10 Last modified: 2008-03-11
View other active issues in [meta.unary.prop].
View all other issues in [meta.unary.prop].
View all issues with Open 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.
Proposed resolution:
Section: 20.6.5 [meta.rel] Status: Open Submitter: Alisdair Meredith Opened: 2007-10-10 Last modified: 2008-03-11
View other active issues in [meta.rel].
View all other issues in [meta.rel].
View all issues with Open status.
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.
Proposed resolution:
Section: 23.3.7 [vector.bool] Status: Open Submitter: Alisdair Meredith Opened: 2007-10-10 Last modified: 2008-09-22
View other active issues in [vector.bool].
View all other issues in [vector.bool].
View all issues with Open 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.
Proposed resolution:
Section: 23.2 [container.requirements] Status: Open Submitter: Paolo Carlini Opened: 2007-11-11 Last modified: 2008-06-02
View other active issues in [container.requirements].
View all other issues in [container.requirements].
View all issues with Open 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.
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.
Section: 24.2 [iterator.concepts] Status: Tentatively Ready Submitter: Martin Sebor Opened: 2007-12-14 Last modified: 2009-03-09
View other active issues in [iterator.concepts].
View all other issues in [iterator.concepts].
View all issues with Tentatively Ready status.
Discussion:
Issue 278 defines the meaning of the term "invalid iterator" as one that may be singular.
Consider the following code:
std::deque<int> x, y;
std::deque<int>::iterator i = x.end(), j = y.end();
x.swap(y);
Given that swap() is required not to invalidate iterators
and using the definition above, what should be the expected result of
comparing i and j to x.end()
and y.end(), respectively, after the swap()?
I.e., is the expression below required to evaluate
to true?
i == y.end() && j == x.end()
(There are at least two implementations where the expression
returns false.)
More generally, is the definition introduced in issue 278 meant to make any guarantees about whether iterators actually point to the same elements or be associated with the same containers after a non-invalidating operation as they did before?
Here's a motivating example intended to demonstrate the importance of the question:
Container x, y ({ 1, 2}); // pseudocode to initialize y with { 1, 2 }
Container::iterator i = y.begin() + 1;
Container::iterator j = y.end();
std::swap(x, y);
std::find(i, j, 3);
swap() guarantees that i and j
continue to be valid. Unless the spec says that even though they are
valid they may no longer denote a valid range the code above must be
well-defined. Expert opinions on this differ as does the behavior of
popular implementations for some standard Containers.
[ San Francisco: ]
Pablo: add a note to the last bullet of paragraph 11 of 23.1.1 clarifying that the end() iterator doesn't refer to an element and that it can therefore be invalidated.
Proposed wording:
[Note: The end() iterator does not refer to any element and can therefore be invalidated. -- end note]Howard will add this proposed wording to the issue and then move it to Review.
[ Post Summit: ]
Lawrence: suggestion: "Note: The end() iterator does not refer to any element"
Walter: "Note: The end() iterator can nevertheless be invalidated, because it does not refer to any element."
Nick: "The end() iterator does not refer to any element. It is therefore subject to being invalidated."
Consensus: go with Nick
With that update, Recommend Tentatively Ready.
Proposed resolution:
Add to 23.2.1 [container.requirements.general], p11:
Unless otherwise specified (see 23.1.4.1, 23.1.5.1, 23.2.2.3, and 23.2.6.4) all container types defined in this Clause meet the following additional requirements:
- ...
- no swap() function invalidates any references, pointers, or iterators referring to the elements of the containers being swapped. [Note: The end() iterator does not refer to any element. It is therefore subject to being invalidated. -- end note]
Section: 23 [containers] Status: Open Submitter: Alisdair Meredith Opened: 2008-01-14 Last modified: 2008-05-11
View other active issues in [containers].
View all other issues in [containers].
View all issues with Open status.
Discussion:
It appears most containers declare but do not define a member-swap function.
This is unfortunate, as all overload the swap algorithm to call the member-swap function! (required for swappable guarantees [Table 37] and Container Requirements [Table 87])
Note in particular that Table 87 gives semantics of a.swap(b) as swap(a,b), yet for all containers we define swap(a,b) to call a.swap(b) - a circular definition.
A quick survey of clause 23 shows that the following containers provide a definition for member-swap:
array queue stack vector
Whereas the following declare it, but do not define the semantics:
deque list map multimap multiset priority_queue set unordered_map unordered_multi_map unordered_multi_set unordered_set
Suggested resolution:
Provide a definition for each of the affected containers...
[ Bellevue: ]
Move to Open and ask Alisdair to provide wording.
Proposed resolution:
Wording provided in N2590.
Section: 25.5.4 [alg.merge] Status: New Submitter: Daniel Krügler Opened: 2008-01-25 Last modified: 2009-03-14
View all issues with New status.
Discussion:
Though issue 283 has fixed many open issues, it seems that some are still open:
Both 25.3.4 [lib.alg.merge] in 14882:2003 and 25.5.4 [alg.merge] in N2461 have no Requires element and the Effects element contains some requirements, which is probably editorial. Worse is that:
[ Post Summit Alisdair adds: ]
Suggest:
(where last is equal to next(result, distance(first1, last1) + distance(first2, last2)), such that resulting range will be sorted in non-decreasing order; that is, for every iterator i in [result,last) other than result, the condition *i < *prev(i) or, respectively, comp(*i, *prev(i)) will be false.Note that this might still not be technically accurate in the case of InputIterators, depending on other resolutions working their way through the system (1011).
[ Post Summit Daniel adds: ]
If we want to use prev and next here (Note: merge is sufficiently satisfied with InputIterator) we should instead *add* more to 25 [algorithms]/6, but I can currently not propose any good wording for this.
Proposed resolution:
In 25.5.4 [alg.merge] replace p.1+ 2:
Effects:
MergesCopies all the elements of the two sorted ranges [first1,last1) and [first2,last2) into the range[result,result + (last1 - first1) + (last2 - first2))[result, last) (where last is equal to result + (last1 - first1) + (last2 - first2)), such that resulting range will be sorted in non-decreasing order; that is, for every iterator i in [result,last) other than result, the condition *i < *(i - 1) or, respectively, comp(*i, *(i - 1)) will be false.Requires: The resulting range shall not overlap with either of the original ranges.
The list will be sorted in non-decreasing order according to the ordering defined by comp; that is, for every iterator i in [first,last) other than first, the condition *i < *(i - 1) or comp(*i, *(i - 1)) will be false.
[N.B.: I attempted to reuse the wording style of inplace_merge, therefore proposing to insert ", respectively," between both predicate tests. This is no strictly necessary as other parts of <algorithm> show, just a matter of consistency]
Section: TR1 5.1.4.5 [tr.rand.eng.disc], TR1 5.1.4.6 [tr.rand.eng.xor] Status: New Submitter: John Maddock Opened: 2008-01-15 Last modified: 2009-03-15
View all issues with New 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.
Proposed resolution:
NAD Recommended.
Section: 24.6.1 [istream.iterator] Status: Open Submitter: Martin Sebor Opened: 2008-02-06 Last modified: 2009-03-14
View other active issues in [istream.iterator].
View all other issues in [istream.iterator].
View all issues with Open status.
Discussion:
Addresses UK 287
It is not clear what the initial state of an istream_iterator should be. Is _value_ initialized by reading the stream, or default/value initialized? If it is initialized by reading the stream, what happens if the initialization is deferred until first dereference, when ideally the iterator value should have been that of an end-of-stream iterator which is not safely dereferencable?
Recommendation: Specify _value_ is initialized by reading the stream, or the iterator takes on the end-of-stream value if the stream is empty.
The description of how an istream_iterator object becomes an end-of-stream iterator is a) ambiguous and b) out of date WRT issue 468:
istream_iterator reads (using operator>>) successive elements from the input stream for which it was constructed. After it is constructed, and every time ++ is used, the iterator reads and stores a value of T. If the end of stream is reached (operator void*() on the stream returns false), the iterator becomes equal to the end-of-stream iterator value. The constructor with no arguments istream_iterator() always constructs an end of stream input iterator object, which is the only legitimate iterator to be used for the end condition. The result of operator* on an end of stream is not defined. For any other iterator value a const T& is returned. The result of operator-> on an end of stream is not defined. For any other iterator value a const T* is returned. It is impossible to store things into istream iterators. The main peculiarity of the istream iterators is the fact that ++ operators are not equality preserving, that is, i == j does not guarantee at all that ++i == ++j. Every time ++ is used a new value is read.
istream::operator void*() returns null if istream::fail() is true, otherwise non-null. istream::fail() returns true if failbit or badbit is set in rdstate(). Reaching the end of stream doesn't necessarily imply that failbit or badbit is set (e.g., after extracting an int from stringstream("123") the stream object will have reached the end of stream but fail() is false and operator void*() will return a non-null value).
Also I would prefer to be explicit about calling fail() here (there is no operator void*() anymore.)
[ Summit: ]
Moved from Ready to Open for the purposes of using this issue to address NB UK 287. Martin to handle.
Proposed resolution:
Change 24.6.1 [istream.iterator]/1:
istream_iterator reads (using operator>>) successive elements from the input stream for which it was constructed. After it is constructed, and every time ++ is used, the iterator reads and stores a value of T. Ifthe end of stream is reachedthe iterator fails to read and store a value of T (operator void*()fail() on the stream returnsfalsetrue), the iterator becomes equal to the end-of-stream iterator value. The constructor with no arguments istream_iterator() always constructs an end of stream input iterator object, which is the only legitimate iterator to be used for the end condition. The result of operator* on an end of stream is not defined. For any other iterator value a const T& is returned. The result of operator-> on an end of stream is not defined. For any other iterator value a const T* is returned. It is impossible to store things into istream iterators. The main peculiarity of the istream iterators is the fact that ++ operators are not equality preserving, that is, i == j does not guarantee at all that ++i == ++j. Every time ++ is used a new value is read.
Section: 20.5 [tuple] Status: Open Submitter: Lawrence Crowl Opened: 2008-02-18 Last modified: 2008-02-27
View all other issues in [tuple].
View all issues with Open status.
Discussion:
Classes with trivial special member functions are inherently more efficient than classes without such functions. This efficiency is particularly pronounced on modern ABIs that can pass small classes in registers. Examples include value classes such as complex numbers and floating-point intervals. Perhaps more important, though, are classes that are simple collections, like pair and tuple. When the parameter types of these classes are trivial, the pairs and tuples themselves can be trivial, leading to substantial performance wins.
The current working draft make specification of trivial functions (where possible) much easer through defaulted and deleted functions. As long as the semantics of defaulted and deleted functions match the intended semantics, specification of defaulted and deleted functions will yield more efficient programs.
There are at least two cases where specification of an explicitly defaulted function may be desirable.
First, the std::pair template has a non-trivial default constructor, which prevents static initialization of the pair even when the types are statically initializable. Changing the definition to
pair() = default;
would enable such initialization. Unfortunately, the change is not semantically neutral in that the current definition effectively forces value initialization whereas the change would not value initialize in some contexts.
** Does the committee confirm that forced value initialization was the intent? If not, does the committee wish to change the behavior of std::pair in C++0x?
Second, the same default constructor issue applies to std::tuple. Furthermore, the tuple copy constructor is current non-trivial, which effectively prevents passing it in registers. To enable passing tuples in registers, the copy constructor should be make explicitly defaulted. The new declarations are:
tuple() = default; tuple(const tuple&) = default;
This changes is not implementation neutral. In particular, it prevents implementations based on pointers to the parameter types. It does however, permit implementations using the parameter types as bases.
** How does the committee wish to trade implementation efficiency versus implementation flexibility?
[ Bellevue: ]
General agreement; the first half of the issue is NAD.
Before voting on the second half, it was agreed that a "Strongly Favor" vote meant support for trivial tuples (assuming usual requirements met), even at the expense of other desired qualities. A "Weakly Favor" vote meant support only if not at the expense of other desired qualities.
Concensus: Go forward, but not at expense of other desired qualities.
It was agreed to Alisdair should fold this work in with his other pair/tuple action items, above, and that issue 801 should be "open", but tabled until Alisdair's proposals are disposed of.
Proposed resolution:
Section: 27.7.4 [ext.manip] Status: New Submitter: Daniel Krügler Opened: 2008-03-01 Last modified: 2009-03-14
View all other issues in [ext.manip].
View all issues with New status.
Discussion:
The recent draft (as well as the original proposal n2072) uses an operational semantic for get_money ([ext.manip]/4) and put_money ([ext.manip]/6), which uses
istreambuf_iterator<charT>
and
ostreambuf_iterator<charT>
resp, instead of the iterator instances, with explicitly provided traits argument (The operational semantic defined by f is also traits dependent). This is an obvious oversight because both *stream_buf c'tors expect a basic_streambuf<charT,traits> as argument.
The same problem occurs within the get_time and put_time semantic where additional to the problem we have an editorial issue in get_time (streambuf_iterator instead of istreambuf_iterator).
Proposed resolution:
In 27.7.4 [ext.manip]/4 within function f replace the first line
template <class charT, class traits, class moneyT>
void f(basic_ios<charT, traits>& str, moneyT& mon, bool intl) {
typedef istreambuf_iterator<charT, traits> Iter;
...
In 27.7.4 [ext.manip]/5 remove the first template charT parameter:
template <class charT,class moneyT> unspecified put_money(const moneyT& mon, bool intl = false);
In 27.7.4 [ext.manip]/6 within function f replace the first line
template <class charT, class traits, class moneyT>
void f(basic_ios<charT, traits>& str, const moneyT& mon, bool intl) {
typedef ostreambuf_iterator<charT, traits> Iter;
...
In 27.7.4 [ext.manip]/8 within function f replace the first line
template <class charT, class traits>
void f(basic_ios<charT, traits>& str, struct tm *tmb, const charT *fmt) {
typedef istreambuf_iterator<charT, traits> Iter;
...
In 27.7.4 [ext.manip]/10 within function f replace the first line
template <class charT, class traits>
void f(basic_ios<charT, traits>& str, const struct tm *tmb, const charT *fmt) {
typedef ostreambuf_iterator<charT, traits> Iter;
...
In 27.7 [iostream.format], Header <iomanip> synopsis change:
template <class charT,class moneyT> T8 put_money(const moneyT& mon, bool intl = false);
Section: 23.3.7 [vector.bool] Status: Open Submitter: Alisdair Meredith Opened: 2008-03-17 Last modified: 2009-03-14
View other active issues in [vector.bool].
View all other issues in [vector.bool].
View all issues with Open status.
Discussion:
vector<bool>::swap(reference, reference) has no definition.
[ San Francisco: ]
Move to Open. Alisdair to provide a resolution.
[ Post Summit Daniel provided wording. ]
Proposed resolution:
Just after 23.3.7 [vector.bool]/5 add the following prototype and description:
static void swap(reference x, reference y);
-6- Effects: Exchanges the contents of x and y as-if
bool b = x; x = y; y = b;
Section: 20.7.16.2.4 [func.wrap.func.inv] Status: Open Submitter: Alisdair Meredith Opened: 2008-03-16 Last modified: 2009-05-01
View all issues with Open status.
Discussion:
std::function and reference_closure should use "perfect forwarding" as described in the rvalue core proposal.
[ Sophia Antipolis: ]
According to Doug Gregor, as far as std::function is concerned, perfect forwarding can not be obtained because of type erasure. Not everyone agreed with this diagnosis of forwarding.
[ 2009-05-01 Howard adds: ]
Sebastian Gesemann brought to my attention that the CopyConstructible requirement on function's ArgTypes... is an unnecessary restriction.
template<Returnable R, CopyConstructible... ArgTypes> class function<R(ArgTypes...)> ...On further investigation, this complaint seemed to be the same issue as this one. I believe the reason CopyConstructible was put on ArgTypes in the first place was because of the nature of the invoke member:
template<class R, class ...ArgTypes> R function<R(ArgTypes...)>::operator()(ArgTypes... arg) const { if (f_ == 0) throw bad_function_call(); return (*f_)(arg...); }However now with rvalue-refs, "by value" no longer implies CopyConstructible (as Sebastian correctly points out). If rvalue arguments are supplied, MoveConstructible is sufficient. Furthermore, the constraint need not be applied in function if I understand correctly. Rather the client must apply the proper constraints at the call site. Therefore, at the very least, I recommend that CopyConstructible be removed from the template class function.
Furthermore we need to mandate that the invoker is coded as:
template<class R, class ...ArgTypes> R function<R(ArgTypes...)>::operator()(ArgTypes... arg) const { if (f_ == 0) throw bad_function_call(); return (*f_)(std::forward<ArgTypes>(arg)...); }Note that ArgTypes&& (the "perfect forwarding signature") is not appropriate here as this is not a deduced context for ArgTypes. Instead the client's arguments must implicitly convert to the non-deduced ArgType type. Catching these arguments by value makes sense to enable decay.
Next forward is used to move the ArgTypes as efficiently as possible, and also with minimum requirements (not CopyConstructible) to the type-erased functor. For object types, this will be a move. For reference type ArgTypes, this will be a copy. The end result must be that the following is a valid program:
#include <functional> #include <memory> #include <cassert> std::unique_ptr<int> f(std::unique_ptr<int> p, int& i) { ++i; return std::move(p); } int main() { int i = 2; std::function<std::unique_ptr<int>(std::unique_ptr<int>, int&)> g(f); std::unique_ptr<int> p = g(std::unique_ptr<int>(new int(1)), i); assert(*p == 1); assert(i == 3); }[ Tested in pre-concepts rvalue-ref-enabled compiler. ]
In the example above, the first ArgType is unique_ptr<int> and the second ArgType is int&. Both must work!
Proposed resolution:
Section: 20.7.12.1.3 [func.bind.bind] Status: Open Submitter: Stephan T. Lavavej Opened: 2008-02-08 Last modified: 2009-05-01
View other active issues in [func.bind.bind].
View all other issues in [func.bind.bind].
View all issues with Open status.
Discussion:
Library Issue 527 notes that bind(f, t1, ..., tN) should be nofail when f, t1, ..., tN have nofail copy ctors.
However, no guarantees are provided for the copy ctor of the functor returned by bind(). (It's guaranteed to have a copy ctor, which can throw implementation-defined exceptions: bind() returns a forwarding call wrapper, TR1 3.6.3/2. A forwarding call wrapper is a call wrapper, TR1 3.3/4. Every call wrapper shall be CopyConstructible, TR1 3.3/4. Everything without an exception-specification may throw implementation-defined exceptions unless otherwise specified, C++03 17.4.4.8/3.)
Should the nofail guarantee requested by Library Issue 527 be extended to cover both calling bind() and copying the returned functor?
[ Howard adds: ]
tuple construction should probably have a similar guarantee.
[ San Francisco: ]
Howard to provide wording.
[ Post Summit, Anthony provided wording. ]
Proposed resolution:
Add a new sentence to the end of paragraphs 2 and 4 of 20.7.12.1.3 [func.bind.bind]:
-2- Returns: A forwarding call wrapper g with a weak result type (20.6.2). The effect of g(u1, u2, ..., uM) shall be INVOKE(f, v1, v2, ..., vN, Callable<F cv,V1, V2, ..., VN>::result_type), where cv represents the cv-qualifiers of g and the values and types of the bound arguments v1, v2, ..., vN are determined as specified below. The copy constructor and move constructor of the forwarding call wrapper shall throw an exception if and only if the corresponding constructor of F or any of the types in BoundArgs... throw an exception.
...
-4- Returns: A forwarding call wrapper g with a nested type result_type defined as a synonym for R. The effect of g(u1, u2, ..., uM) shall be INVOKE(f, v1, v2, ..., vN, R), where the values and types of the bound arguments v1, v2, ..., vN are determined as specified below. The copy constructor and move constructor of the forwarding call wrapper shall throw an exception if and only if the corresponding constructor of F or any of the types in BoundArgs... throw an exception.
Section: 20.7.12.1.3 [func.bind.bind] Status: Review Submitter: Howard Hinnant Opened: 2008-03-17 Last modified: 2009-05-01
View other active issues in [func.bind.bind].
View all other issues in [func.bind.bind].
View all issues with Review status.
Discussion:
Addresses US 72, JP 38 and DE 21
The functor returned by bind() should have a move constructor that requires only move construction of its contained functor and bound arguments. That way move-only functors can be passed to objects such as thread.
This issue is related to issue 816.
US 72:
bind should support move-only functors and bound arguments.
JP 38:
add the move requirement for bind's return type.
For example, assume following th1 and th2,
void f(vector<int> v) { } vector<int> v{ ... }; thread th1([v]{ f(v); }); thread th2(bind(f, v));When function object are set to thread, v is moved to th1's lambda expression in a Move Constructor of lambda expression becuase th1's lambda expression has a Move Constructor. But bind of th2's return type doesn't have the requirement of Move, so it may not moved but copied.
Add the requirement of move to get rid of this useless copy.
And also, add the MoveConstructible as well as CopyConstructible.
DE 21
The specification for bind claims twice that "the values and types for the bound arguments v1, v2, ..., vN are determined as specified below". No such specification appears to exist.
[ San Francisco: ]
Howard to provide wording.
[ Post Summuit Alisdair and Howard provided wording. ]
Several issues are being combined in this resolution. They are all touching the same words so this is an attempt to keep one issue from stepping on another, and a place to see the complete solution in one place.
- bind needs to be "moved".
- 20.7.12.1.3 [func.bind.bind]/p3, p6 and p7 were accidently removed from N2798.
- Issue 929 argues for a way to pass by && for efficiency but retain the decaying behavior of pass by value for the thread constructor. That same solution is applicable here.
Proposed resolution:
Change 20.7 [function.objects] p2:
template<CopyConstructibleMoveConstructible Fn,CopyConstructibleMoveConstructible... Types> unspecified bind(Fn&&, Types&&...); template<Returnable R,CopyConstructibleMoveConstructible Fn,CopyConstructibleMoveConstructible... Types> unspecified bind(Fn&&, Types&&...);
Change 20.7.12.1.3 [func.bind.bind]:
template<CopyConstructibleMoveConstructible F,CopyConstructibleMoveConstructible... BoundArgs> unspecified bind(F&& f, BoundArgs&&... bound_args);Requires: unspecified return type shall be MoveConstructible.
-1- Requires: INVOKE(f, w1, w2, ..., wN) (20.6.2) shall be a valid expression for some values w1, w2, ..., wN, where N == sizeof...(bound_args).
-2- Returns: A forwarding call wrapper g with a weak result type (20.6.2). The effect of g(u1, u2, ..., uM) shall be INVOKE(f, v1, v2, ..., vN, Callable<F cv,V1, V2, ..., VN>::result_type), where cv represents the cv-qualifiers of g and the values and types of the bound arguments v1, v2, ..., vN are determined as specified below.
Throws: Nothing unless the constructor of F or of one of the types in the BoundArgs... pack expansion throws an exception.
template<Returnable R,CopyConstructibleMoveConstructible F,CopyConstructibleMoveConstructible... BoundArgs> unspecified bind(F&& f, BoundArgs&&... bound_args);Requires: unspecified return type shall be MoveConstructible.
-3- Requires: INVOKE(f, w1, w2, ..., wN) shall be a valid expression for some values w1, w2, ..., wN, where N == sizeof...(bound_args).
-4- Returns: A forwarding call wrapper g with a nested type result_type defined as a synonym for R. The effect of g(u1, u2, ..., uM) shall be INVOKE(f, v1, v2, ..., vN, R), where the values and types of the bound arguments v1, v2, ..., vN are determined as specified below.
Throws: Nothing unless the constructor of F or of one of the types in the BoundArgs... pack expansion throws an exception.
Let the values of bound arguments v1, v2, ..., vN and their corresponding types V1, V2, ..., VN depend on the type of the corresponding argument ti in bound_args in the call to bind and the cv-qualifiers cv of the call wrapper g as follows. Let Ti be an alias for the ith element of the pack expansion decay<BoundArgs>::type...:
- if ti is of type reference_wrapper<T> the argument is ti.get() and its type Vi is T&;
- if the value of std::is_bind_expression<Ti>::value is true the argument is ti(u1, u2, ..., uM) and its type Vi is result_of<Ti cv (U1&, U2&, ..., UM&)>::type;
- if the value j of std::is_placeholder<Ti>::value is not zero the argument is std::forward<Uj>(uj) and its type Vi is Uj&&;
- otherwise the value is ti and its type Vi is Ti cv &.
Section: 18.8.6 [except.nested] Status: Open Submitter: Alisdair Meredith Opened: 2008-03-25 Last modified: 2008-09-17
View other active issues in [except.nested].
View all other issues in [except.nested].
View all issues with Open status.
Discussion:
Looking at the wording I submitted for rethrow_if_nested, I don't think I got it quite right.
The current wording says:
template <class E> void rethrow_if_nested(const E& e);Effects: Calls e.rethrow_nested() only if e is publicly derived from nested_exception.
This is trying to be a bit subtle, by requiring e (not E) to be publicly derived from nested_exception the idea is that a dynamic_cast would be required to be sure. Unfortunately, if e is dynamically but not statically derived from nested_exception, e.rethrow_nested() is ill-formed.
[ San Francisco: ]
Alisdair was volunteered to provide wording.
Proposed resolution:
Section: X [utility.arg.requirements] Status: Tentatively Ready Submitter: James Kanze Opened: 2008-04-01 Last modified: 2009-03-09
View all other issues in [utility.arg.requirements].
View all issues with Tentatively Ready 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).Original Proposed resolution:
In X [utility.arg.requirements] change Table 33: MoveConstructible requirements [moveconstructible]:
expression post-condition T t(rv) = rvt is equivalent to the value of rv before the construction ...
In X [utility.arg.requirements] change Table 34: CopyConstructible requirements [copyconstructible]:
expression post-condition T t(u) = uthe value of u is unchanged and is equivalent to t ...
[ 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.
Proposed resolution:
Recommend close as NAD.
Section: 19.5.2.2 [syserr.errcode.overview], 20.8.13.2.8 [util.smartptr.shared.io], 22.4.8 [facets.examples], 20.3.6.3 [bitset.operators], 26.4.6 [complex.ops], 27.6 [stream.buffers], 28.10 [re.submatch] Status: Open Submitter: Alisdair Meredith Opened: 2008-04-10 Last modified: 2009-02-14
View all issues with Open status.
Discussion:
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.
Proposed resolution:
Section: 20.8.13.2.1 [util.smartptr.shared.const] Status: Open Submitter: Peter Dimov Opened: 2008-04-11 Last modified: 2009-05-01
View other active issues in [util.smartptr.shared.const].
View all other issues in [util.smartptr.shared.const].
View all issues with Open status.
Discussion:
Would anyone object to making the default constructor of shared_ptr (and weak_ptr and enable_shared_from_this) constexpr? This would enable static initialization for shared_ptr variables, eliminating another unfair advantage of raw pointers.
[ San Francisco: ]
It's not clear to us that you can initialize a pointer with the literal 0 in a constant expression. We need to ask CWG to make sure this works. Bjarne has been appointed to do this.
Core got back to us and assured as that nullptr would do the job nicely here.
[ 2009-05-01 Alisdair adds: ]
I don't believe that constexpr will buy anything in this case. shared_ptr/weak_ptr/enable_shared_from_this cannot be literal types as they have a non-trivial copy constructor. As they do not produce literal types, then the constexpr default constructor will not guarantee constant initialization, and so not buy the hoped for optimization.
I recommend referring this back to Core to see if we can get static initialization for types with constexpr constructors, even if they are not literal types. Otherwise this should be closed as NAD.
Proposed resolution:
Section: 30.4.1.1 [thread.mutex.class] Status: Review Submitter: Peter Dimov Opened: 2008-04-18 Last modified: 2009-03-09
View other active issues in [thread.mutex.class].
View all other issues in [thread.mutex.class].
View all issues with Review 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 Tusker, 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
Proposed resolution:
Change 30.4.1.1 [thread.mutex.class]:
class mutex {
public:
constexpr mutex();
...
Section: 21.2 [char.traits] Status: Open Submitter: Dietmar Kühl Opened: 2008-04-23 Last modified: 2008-06-19
View all other issues in [char.traits].
View all issues with Open 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.
Proposed resolution:
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>, andchar_traits<wchar_t>, all of which appear in the header <string> and satisfy the requirements below.
Section: 17.6.1.3 [compliance] Status: Open Submitter: Beman Dawes Opened: 2008-05-14 Last modified: 2009-03-11
View other active issues in [compliance].
View all other issues in [compliance].
View all issues with Open 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: ]
- The comment regarding reference_closure seems moot since it was just recently decided to remove that.
- 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.
Proposed resolution:
Section: 20.8.12.2 [unique.ptr.single] Status: Open Submitter: Daniel Krügler Opened: 2008-05-14 Last modified: 2008-06-19
View other active issues in [unique.ptr.single].
View all other issues in [unique.ptr.single].
View all issues with Open status.
Discussion:
Issue 673 (including recent updates by 821) proposes a useful extension point for unique_ptr by granting support for an optional deleter_type::pointer to act as pointer-like replacement for element_type* (In the following: pointer).
Unfortunately no requirements are specified for the type pointer which has impact on at least two key features of unique_ptr:
Unique_ptr specification makes great efforts to require that essentially *all* operations cannot throw and therefore adds proper wording to the affected operations of the deleter as well. If user-provided pointer-emulating types ("smart pointers") will be allowed, either *all* throw-nothing clauses have to be replaced by weaker "An exception is thrown only if pointer's {op} throws an exception"-clauses or it has to be said explicitly that all used operations of pointer are required *not* to throw. I understand the main focus of unique_ptr to be as near as possible to the advantages of native pointers which cannot fail and thus strongly favor the second choice. Also, the alternative position would make it much harder to write safe and simple template code for unique_ptr. Additionally, I assume that a general statement need to be given that all of the expressions of pointer used to define semantics are required to be well-formed and well-defined (also as back-end for 762).
[ Sophia Antipolis: ]
Howard: We maybe need a core concept PointerLike, but we don't need the arithmetic (see shared_ptr vs. vector<T>::iterator.
Howard will go through and enumerate the individual requirements wrt. pointer for each member function.
Proposed resolution:
Add the following sentence just at the end of the newly proposed 20.8.12.2 [unique.ptr.single]/p. 3:
unique_ptr<T, D>::pointer's operations shall be well-formed, shall have well defined behavior, and shall not throw exceptions.
Section: 27.5.4.2 [basic.ios.members] Status: New Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2008-05-17
View other active issues in [basic.ios.members].
View all other issues in [basic.ios.members].
View all issues with New status.
Discussion:
The fix for issue 581, now integrated into the working paper, overlooks a couple of minor problems.
First, being an unformatted function once again, flush()
is required to create a sentry object whose constructor must, among
other things, flush the tied stream. When two streams are tied
together, either directly or through another intermediate stream
object, flushing one will also cause a call to flush() on
the other tied stream(s) and vice versa, ad infinitum. The program
below demonstrates the problem.
Second, as Bo Persson notes in his
comp.lang.c++.moderated post,
for streams with the unitbuf flag set such
as std::stderr, the destructor of the sentry object will
again call flush(). This seems to create an infinite
recursion for std::cerr << std::flush;
#include <iostream>
int main ()
{
std::cout.tie (&std::cerr);
std::cerr.tie (&std::cout);
std::cout << "cout\n";
std::cerr << "cerr\n";
}
Proposed resolution:
I think an easy way to plug the first hole is to add a requires clause
to ostream::tie(ostream *tiestr) requiring the this
pointer not be equal to any pointer on the list starting
with tiestr->tie()
through tiestr()->tie()->tie() and so on. I am not
proposing that we require implementations to traverse this list,
although I think we could since the list is unlikely to be very long.
Add a Requires clause to 27.5.4.2 [basic.ios.members] withethe following text:
Requires: If(tiestr != 0)is true,tiestrmust not be reachable by traversing the linked list of tied stream objects starting fromtiestr->tie().
In addition, to prevent the infinite recursion that Bo writes about in his comp.lang.c++.moderated post, I propose to change 27.7.2.4 [ostream::sentry], p2 like so:
If((os.flags() & ios_base::unitbuf) && !uncaught_exception())is true, callsos.flush()os.rdbuf()->pubsync().
money_base::space and
money_base::none on money_get
Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: Open Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2008-09-22
View other active issues in [locale.money.get.virtuals].
View all other issues in [locale.money.get.virtuals].
View all issues with Open status.
Duplicate of: 670
Discussion:
In paragraph 2, 22.4.6.1.2 [locale.money.get.virtuals] specifies the following:
Wherespaceornoneappears in the format pattern, except at the end, optional white space (as recognized byct.is) is consumed after any required space.
This requirement can be (and has been) interpreted two mutually exclusive ways by different readers. One possible interpretation is that:
- where
money_base::spaceappears in the format, at least one space is required, and- where
money_base::noneappears in the format, space is allowed but not required.
The other is that:
where eithermoney_base::spaceormoney_base::noneappears in the format, white space is optional.
[ San Francisco: ]
Martin will revise the proposed resolution.
Proposed resolution:
I propose to change the text to make it clear that the first interpretation is intended, that is, to make following change to 22.4.6.1.2 [locale.money.get.virtuals], p2:
Whenmoney_base::spaceormoney_base::noneappears as the last element in the format pattern,except at the end, optional white space (as recognized byno white space is consumed. Otherwise, wherect.is) is consumed after any required space.money_base::spaceappears in any of the initial elements of the format pattern, at least one white space character is required. Wheremoney_base::noneappears in any of the initial elements of the format pattern, white space is allowed but not required. In either case, any required followed by all optional white space (as recognized byct.is()) is consumed. If(str.flags() & str.showbase)isfalse, ...
basic_ios::copyfmt() overly loosely specified
Section: 27.5.4.2 [basic.ios.members] Status: New Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2008-05-17
View other active issues in [basic.ios.members].
View all other issues in [basic.ios.members].
View all issues with New 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*thisthe corresponding member objects ofrhs, except that
rdstate()andrdbuf()are left unchanged;exceptions()is altered last by callingexceptions(rhs.except)- the contents of arrays pointed at by
pwordandiwordare copied not the pointers themselves
Since the rest of the text doesn't specify what the member objects
of basic_ios are this seems a little too loose.
Proposed resolution:
I propose to tighten things up by adding a Postcondition clause to the function like so:
Postconditions:
copyfmt()postconditionsElement Value 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.
Section: 24.6.1 [istream.iterator] Status: Open Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2008-10-27
View other active issues in [istream.iterator].
View all other issues in [istream.iterator].
View all issues with Open status.
Discussion:
From message c++std-lib-20003...
The description of istream_iterator in
24.6.1 [istream.iterator], p1 specifies that objects of the
class become the end-of-stream (EOS) iterators under the
following condition (see also issue 788 another problem
with this paragraph):
If the end of stream is reached (operator void*()on the stream returnsfalse), the iterator becomes equal to the end-of-stream iterator value.
One possible implementation approach that has been used in practice is
for the iterator to set its in_stream pointer to 0 when
it reaches the end of the stream, just like the default ctor does on
initialization. The problem with this approach is that
the Effects clause for operator++() says the
iterator unconditionally extracts the next value from the stream by
evaluating *in_stream >> value, without checking
for (in_stream == 0).
Conformance to the requirement outlined in the Effects clause
can easily be verified in programs by setting eofbit
or failbit in exceptions() of the associated
stream and attempting to iterate past the end of the stream: each
past-the-end access should trigger an exception. This suggests that
some other, more elaborate technique might be intended.
Another approach, one that allows operator++() to attempt
to extract the value even for EOS iterators (just as long
as in_stream is non-0) is for the iterator to maintain a
flag indicating whether it has reached the end of the stream. This
technique would satisfy the presumed requirement implied by
the Effects clause mentioned above, but it isn't supported by
the exposition-only members of the class (no such flag is shown). This
approach is also found in existing practice.
The inconsistency between existing implementations raises the question
of whether the intent of the specification is that a non-EOS iterator
that has reached the EOS become a non-EOS one again after the
stream's eofbit flag has been cleared? That is, are the
assertions in the program below expected to pass?
sstream strm ("1 ");
istream_iterator eos;
istream_iterator it (strm);
int i;
i = *it++
assert (it == eos);
strm.clear ();
strm << "2 3 ";
assert (it != eos);
i = *++it;
assert (3 == i);
Or is it intended that once an iterator becomes EOS it stays EOS until the end of its lifetime?
[ San Francisco: ]
We like the direction of the proposed resolution. We're not sure about the wording, and we need more time to reflect on it,
Move to Open. Detlef to rewrite the proposed resolution in such a way that no reference is made to exposition only members of istream_iterator.
Proposed resolution:
The discussion of this issue on the reflector suggests that the intent
of the standard is for an istreambuf_iterator that has
reached the EOS to remain in the EOS state until the end of its
lifetime. Implementations that permit EOS iterators to return to a
non-EOS state may only do so as an extension, and only as a result of
calling istream_iterator member functions on EOS
iterators whose behavior is in this case undefined.
To this end we propose to change 24.6.1 [istream.iterator], p1, as follows:
The result of operator-> on an end-of-stream is not defined. For any other iterator value aconst T*is returned. Invokingoperator++()on an end-of-stream iterator is undefined. It is impossible to store things into istream iterators...
Add pre/postconditions to the member function descriptions of istream_iterator like so:
istream_iterator();Effects: Constructs the end-of-stream iterator.
Postcondition:in_stream == 0.istream_iterator(istream_type &s);Effects: Initializesin_streamwith &s. value may be initialized during construction or the first time it is referenced.
Postcondition:in_stream == &s.istream_iterator(const istream_iterator &x);Effects: Constructs a copy ofx.
Postcondition:in_stream == x.in_stream.istream_iterator& operator++();Requires:in_stream != 0.
Effects:*in_stream >> value.istream_iterator& operator++(int);Requires:in_stream != 0.
Effects:istream_iterator tmp (*this); *in_stream >> value; return tmp;
Section: 23.4 [associative], 23.5 [unord] Status: Open Submitter: Alan Talbot Opened: 2008-05-18 Last modified: 2008-09-22
View other active issues in [associative].
View all other issues in [associative].
View all issues with Open 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.
Proposed resolution:
Section: 21.4.1 [string.require] Status: Open Submitter: Hervé Brönnimann Opened: 2008-06-05 Last modified: 2009-02-14
View other active issues in [string.require].
View all other issues in [string.require].
View all issues with Open status.
Discussion:
In March, on comp.lang.c++.moderated, I asked what were the string exception safety guarantees are, because I cannot see *any* in the working paper, and any implementation I know offers the strong exception safety guarantee (string unchanged if a member throws exception). The closest the current draft comes to offering any guarantees is 21.4 [basic.string], para 3:
The class template basic_string conforms to the requirements for a Sequence Container (23.1.1), for a Reversible Container (23.1), and for an Allocator-aware container (91). The iterators supported by basic_string are random access iterators (24.1.5).
However, the chapter 23 only says, on the topic of exceptions: 23.2 [container.requirements], para 10:
Unless otherwise specified (see 23.2.2.3 and 23.2.6.4) all container types defined in this clause meet the following additional requirements:
- if an exception is thrown by...
I take it as saying that this paragraph has *no* implication on std::basic_string, as basic_string isn't defined in Clause 23 and this paragraph does not define a *requirement* of Sequence nor Reversible Container, just of the models defined in Clause 23. In addition, LWG Issue 718 proposes to remove 23.2 [container.requirements], para 3.
Finally, the fact that no operation on Traits should throw exceptions has no bearing, except to suggest (since the only other throws should be allocation, out_of_range, or length_error) that the strong exception guarantee can be achieved.
The reaction in that group by Niels Dekker, Martin Sebor, and Bo Persson, was all that this would be worth an LWG issue.
A related issue is that erase() does not throw. This should be stated somewhere (and again, I don't think that the 23.2 [container.requirements], para 1 applies here).
[ San Francisco: ]
Implementors will study this to confirm that it is actually possible.
[ Daniel adds 2009-02-14: ]
The proposed resolution of paper N2815 interacts with this issue (the paper does not refer to this issue).
Proposed resolution:
Add a blanket statement in 21.4.1 [string.require]:
- if any member function or operator of basic_string<charT, traits, Allocator> throws, that function or operator has no effect.
- no erase() or pop_back() function throws.
As far as I can tell, this is achieved by any implementation. If I made a mistake and it is not possible to offer this guarantee, then either state all the functions for which this is possible (certainly at least operator+=, append, assign, and insert), or add paragraphs to Effects clauses wherever appropriate.
Section: 23.3.1 [array] Status: Open Submitter: Benjamin Kosnik Opened: 2008-06-05 Last modified: 2008-09-22
View other active issues in [array].
View all other issues in [array].
View all issues with Open 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.
Proposed resolution:
Add to the array synopsis in 23.3 [sequences]:
template<ValueType T, ValueType... Args> requires Convertible<Args, T>... array<T, sizeof...(Args)> make_array(Args&&... args);
Append after 23.3.1.7 [array.tuple] Tuple interface to class template array the following new section.
23.2.1.7 Convenience interface to class template array [array.tuple]
template<ValueType T, ValueType... Args> requires Convertible<Args, T>... array<T, sizeof...(Args)> make_array(Args&&... args);Returns: an array<T, sizeof...(Args)> initialized with {std::forward<T>(args)...}.
Section: 20.3.6 [template.bitset] Status: Tentatively Ready Submitter: Howard Hinnant Opened: 2008-06-18 Last modified: 2009-03-13
View all other issues in [template.bitset].
View all issues with Tentatively Ready status.
Discussion:
Issue 396 adds defaulted arguments to the to_string member, but neglects to update the three newer to_string overloads.
[ post San Francisco: ]
Daniel found problems with the wording and provided fixes. Moved from Ready to Review.
[ Post Summit: ]
Alisdair: suggest to not repeat the default arguments in B, C, D (definition of to_string members)
Walter: This is not really a definition.
Consensus: Add note to the editor: Please apply editor's judgement whether default arguments should be repeated for B, C, D changes.
Recommend Tentatively Ready.
Proposed resolution:
replace in 20.3.6 [template.bitset]/1 (class bitset)
template <class charT, class traits>
basic_string<charT, traits, allocator<charT> >
to_string(charT zero = charT('0'), charT one = charT('1')) const;
template <class charT>
basic_string<charT, char_traits<charT>, allocator<charT> >
to_string(charT zero = charT('0'), charT one = charT('1')) const;
basic_string<char, char_traits<char>, allocator<char> >
to_string(char zero = '0', char one = '1') const;
replace in 20.3.6.2 [bitset.members]/37
template <class charT, class traits> basic_string<charT, traits, allocator<charT> > to_string(charT zero = charT('0'), charT one = charT('1')) const;37 Returns: to_string<charT, traits, allocator<charT> >(zero, one).
replace in 20.3.6.2 [bitset.members]/38
template <class charT> basic_string<charT, char_traits<charT>, allocator<charT> > to_string(charT zero = charT('0'), charT one = charT('1')) const;38 Returns: to_string<charT, char_traits<charT>, allocator<charT> >(zero, one).
replace in 20.3.6.2 [bitset.members]/39
basic_string<char, char_traits<char>, allocator<char> > to_string(char zero = '0', char one = '1') const;39 Returns: to_string<char, char_traits<char>, allocator<char> >(zero, one).
Section: 20.8.12.1.1 [unique.ptr.dltr.dflt] Status: Review Submitter: Howard Hinnant Opened: 2008-06-18 Last modified: 2009-03-09
View all issues with Review status.
Discussion:
No relationship between U and T in the converting constructor for default_delete template.
Requirements: U* is convertible to T* and has_virtual_destructor<T>; the latter should also become a concept.
Rules out cross-casting.
The requirements for unique_ptr conversions should be the same as those on the deleter.
[ Howard adds 2008-11-26: ]
I believe we need to be careful to not outlaw the following use case, and I believe the current proposed wording (requires Convertible<U*, T*> && HasVirtualDestructor<T>) does so:
#include <memory> int main() { std::unique_ptr<int> p1(new int(1)); std::unique_ptr<const int> p2(move(p1)); int i = *p2; // *p2 = i; // should not compile }I've removed "&& HasVirtualDestructor<T>" from the requires clause in the proposed wording.
[ Post Summit: ]
Alisdair: This issue has to stay in review pending a paper constraining unique_ptr.
Consensus: We agree with the resolution, but unique_ptr needs to be constrained, too.
Recommend Keep in Review.
Proposed resolution:
Change 20.8.12.1.1 [unique.ptr.dltr.dflt]:
namespace std {
template <class T> struct default_delete {
default_delete();
template <class U>
requires Convertible<U*, T*>
default_delete(const default_delete<U>&);
void operator()(T*) const;
};
}
...
template <class U> requires Convertible<U*, T*> default_delete(const default_delete<U>& other);
Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Beman Dawes Opened: 2008-06-13 Last modified: 2008-09-23
View other active issues in [thread.condition.condvar].
View all other issues in [thread.condition.condvar].
View all issues with Open status.
Discussion:
The meaning of the bool returned by condition_variable::timed_wait is so obscure that even the class' designer can't deduce it correctly. Several people have independently stumbled on this issue.
It might be simpler to change the return type to a scoped enum:
enum class timeout { not_reached, reached };
That's the same cost as returning a bool, but not subject to mistakes. Your example below would be:
if (cv.wait_until(lk, time_limit) == timeout::reached ) throw time_out();
[ Beman to supply exact wording. ]
[ San Francisco: ]
There is concern that the enumeration names are just as confusing, if not more so, as the bool. You might have awoken because of a signal or a spurious wakeup, for example.
Group feels that this is a defect that needs fixing.
Group prefers returning an enum over a void return.
Howard to provide wording.
Proposed resolution:
Section: 30.5 [thread.condition] Status: Open Submitter: Pete Becker Opened: 2008-06-23 Last modified: 2009-03-22
View all issues with Open status.
Discussion:
N2661 says that there is a class named monotonic_clock. It also says that this name may be a synonym for system_clock, and that it's conditionally supported. So the actual requirement is that it can be monotonic or not, and you can tell by looking at is_monotonic, or it might not exist at all (since it's conditionally supported). Okay, maybe too much flexibility, but so be it.
A problem comes up in the threading specification, where several variants of wait_for explicitly use monotonic_clock::now(). What is the meaning of an effects clause that says
wait_until(lock, chrono::monotonic_clock::now() + rel_time)
when monotonic_clock is not required to exist?
[ San Francisco: ]
Nick: maybe instead of saying that chrono::monotonic_clock is conditionally supported, we could say that it's always there, but not necessarily supported..
Beman: I'd prefer a typedef that identifies the best clock to use for wait_for locks.
Tom: combine the two concepts; create a duration clock type, but keep the is_monotonic test.
Howard: if we create a duration_clock type, is it a typedef or an entirely true type?
There was broad preference for a typedef.
Move to Open. Howard to provide wording to add a typedef for duration_clock and to replace all uses of monotonic_clock in function calls and signatures with duration_clock.
[ Howard notes post-San Francisco: ]
After further thought I do not believe that creating a duration_clock typedef is the best way to proceed. An implementation may not need to use a time_point to implement the wait_for functions.
For example, on POSIX systems sleep_for can be implemented in terms of nanosleep which takes only a duration in terms of nanoseconds. The current working paper does not describe sleep_for in terms of sleep_until. And paragraph 2 of 30.2.4 [thread.req.timing] has the words strongly encouraging implementations to use monotonic clocks for sleep_for:
2 The member functions whose names end in _for take an argument that specifies a relative time. Implementations should use a monotonic clock to measure time for these functions.I believe the approach taken in describing the effects of sleep_for and try_lock_for is also appropriate for wait_for. I.e. these are not described in terms of their _until variants.
Proposed resolution:
Change 30.5.1 [thread.condition.condvar], p21-22:
template <class Rep, class Period> bool wait_for(unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& rel_time);Precondition: lock is locked by the calling thread, and either
- no other thread is waiting on this condition_variable object or
- lock.mutex() returns the same value for each of the lock arguments supplied by all concurrently waiting threads (via wait, wait_for or wait_until).
21 Effects:
wait_until(lock, chrono::monotonic_clock::now() + rel_time)
- Atomically calls lock.unlock() and blocks on *this.
- When unblocked, calls lock.lock() (possibly blocking on the lock) and returns.
- The function will unblock when signaled by a call to notify_one(), a call to notify_all(), by the elapsed time rel_time passing (30.2.4 [thread.req.timing]), or spuriously.
- If the function exits via an exception, lock.unlock() shall be called prior to exiting the function scope.
Postcondition: lock is locked by the calling thread.
22 Returns: false if the call is returning because the time duration specified by rel_time has elapsed, otherwise true.
Throws: std::system_error when the effects or postcondition cannot be achieved.
Error conditions:
- operation_not_permitted -- if the thread does not own the lock.
- equivalent error condition from lock.lock() or lock.unlock().
Change 30.5.1 [thread.condition.condvar], p26-p29:
template <class Rep, class Period, class Predicate> bool wait_for(unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);Precondition: lock is locked by the calling thread, and either
- no other thread is waiting on this condition_variable object or
- lock.mutex() returns the same value for each of the lock arguments supplied by all concurrently waiting threads (via wait, wait_for or wait_until).
26 Effects:
wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))
- Executes a loop: Within the loop the function first evaluates pred() and exits the loop if the result of pred() is true.
- Atomically calls lock.unlock() and blocks on *this.
- When unblocked, calls lock.lock() (possibly blocking on the lock).
- The function will unblock when signaled by a call to notify_one(), a call to notify_all(), by the elapsed time rel_time passing (30.1.4 [thread.req.timing]), or spuriously.
- If the function exits via an exception, lock.unlock() shall be called prior to exiting the function scope.
- The loop terminates when pred() returns true or when the time duration specified by rel_time has elapsed.
27 [Note: There is no blocking if pred() is initially true, even if the timeout has already expired. -- end note]
Postcondition: lock is locked by the calling thread.
28 Returns: pred()
29 [Note: The returned value indicates whether the predicate evaluates to true regardless of whether the timeout was triggered. -- end note]
Throws: std::system_error when the effects or postcondition cannot be achieved.
Error conditions:
- operation_not_permitted -- if the thread does not own the lock.
- equivalent error condition from lock.lock() or lock.unlock().
Change 30.5.2 [thread.condition.condvarany], p18-19:
template <class Lock, class Rep, class Period> bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);18 Effects:
wait_until(lock, chrono::monotonic_clock::now() + rel_time)
- Atomically calls lock.unlock() and blocks on *this.
- When unblocked, calls lock.lock() (possibly blocking on the lock) and returns.
- The function will unblock when signaled by a call to notify_one(), a call to notify_all(), by the elapsed time rel_time passing (30.2.4 [thread.req.timing]), or spuriously.
- If the function exits via an exception, lock.unlock() shall be called prior to exiting the function scope.
Postcondition: lock is locked by the calling thread.
19 Returns: false if the call is returning because the time duration specified by rel_time has elapsed, otherwise true.
Throws: std::system_error when the returned value, effects, or postcondition cannot be achieved.
Error conditions:
- equivalent error condition from lock.lock() or lock.unlock().
Change 30.5.2 [thread.condition.condvarany], p23-p26:
template <class Lock, class Rep, class Period, class Predicate> bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);Precondition: lock is locked by the calling thread, and either
- no other thread is waiting on this condition_variable object or
- lock.mutex() returns the same value for each of the lock arguments supplied by all concurrently waiting threads (via wait, wait_for or wait_until).
23 Effects:
wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))
- Executes a loop: Within the loop the function first evaluates pred() and exits the loop if the result of pred() is true.
- Atomically calls lock.unlock() and blocks on *this.
- When unblocked, calls lock.lock() (possibly blocking on the lock).
- The function will unblock when signaled by a call to notify_one(), a call to notify_all(), by the elapsed time rel_time passing (30.1.4 [thread.req.timing]), or spuriously.
- If the function exits via an exception, lock.unlock() shall be called prior to exiting the function scope.
- The loop terminates when pred() returns true or when the time duration specified by rel_time has elapsed.
24 [Note: There is no blocking if pred() is initially true, even if the timeout has already expired. -- end note]
Postcondition: lock is locked by the calling thread.
25 Returns: pred()
26 [Note: The returned value indicates whether the predicate evaluates to true regardless of whether the timeout was triggered. -- end note]
Throws: std::system_error when the effects or postcondition cannot be achieved.
Error conditions:
- operation_not_permitted -- if the thread does not own the lock.
- equivalent error condition from lock.lock() or lock.unlock().
Section: 26 [numerics] Status: Open Submitter: Lawrence Crowl Opened: 2008-06-23 Last modified: 2009-03-09
View all issues with Open status.
Discussion:
There are a number of functions that affect the floating point state. These function need to be thread-safe, but I'm unsure of the right approach in the standard, as we inherit them from C.
[ San Francisco: ]
Nick: I think we already say that these functions do not introduce data races; see 17.6.5.6/20
Pete: there's more to it than not introducing data races; are these states maintained per thread?
Howard: 21.5/14 says that strtok and strerror are not required to avoid data races, and 20.9/2 says the same about asctime, gmtime, ctime, and gmtime.
Nick: POSIX has a list of not-safe functions. All other functions are implicitly thread safe.
Lawrence is to form a group between meetings to attack this issue. Nick and Tom volunteered to work with Lawrence.
Move to Open.
[ Post Summit: ]
Hans: Sane oses seem ok. Sensible thing is implementable and makes sense.
Nick: Default wording seems to cover this? Hole in POSIX, these functions need to be added to list of thread-unsafe functions.
Lawrence: Not sufficient, not "thread-safe" per our definition, but think of state as a thread-local variable. Need something like "these functions only affect state in the current thread."
Hans: Suggest the following wording: "The floating point environment is maintained per-thread."
Walter: Any other examples of state being thread safe that are not already covered elsewhere?
Have thread unsafe functions paper which needs to be updated. Should just fold in 26.3 [cfenv] functions.
Recommend Open. Lawrence instead suggests leaving it open until we have suitable wording that may or may not include the thread local commentary.
Proposed resolution:
Section: 23.2 [container.requirements] Status: Open Submitter: Daniel Krügler Opened: 2008-06-24 Last modified: 2008-11-11
View other active issues in [container.requirements].
View all other issues in [container.requirements].
View all issues with Open status.
Discussion:
Table 89, Container requirements, defines operator== in terms of the container member function size() and the algorithm std::equal:
== is an equivalence relation. a.size() == b.size() && equal(a.begin(), a.end(), b.begin()
The new container forward_list does not provide a size member function by design but does provide operator== and operator!= without specifying it's semantic.
Other parts of the (sequence) container requirements do also depend on size(), e.g. empty() or clear(), but this issue explicitly attempts to solve the missing EqualityComparable specification, because of the special design choices of forward_list.
I propose to apply one of the following resolutions, which are described as:
Both proposal choices are discussed, the preferred choice of the author is to apply (A).
[ San Francisco: ]
There's an Option C: change the requirements table to use distance().
LWG found Option C acceptable.
Martin will draft the wording for Option C.
[ post San Francisco: ]
Martin provided wording for Option C.
Proposed resolution:
Common part:
Just betwen 23.3.3.5 [forwardlist.ops] and 23.3.3.6 [forwardlist.spec] add a new section "forwardlist comparison operators" [forwardlist.compare] (and also add the new section number to 23.3.3 [forwardlist]/2 in front of "Comparison operators"):
forwardlist comparison operators [forwardlist.compare]
Option (A):
Add to the new section [forwardlist.compare] the following paragraphs:
template <class T, class Allocator> bool operator==(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);Requires: Type T is EqualityComparable ([equalitycomparable]).
Returns: true if
for every iterator i in the range [x.begin(), E), where E == x.begin() + M and M == min(distance(x.begin(), x.end()), distance(y.begin(), y.end())), the following condition holds:
*i == *(y.begin() + (i - x.begin())).- if i == E then i == x.end() && (y.begin() + (i - x.begin())) == y.end().
- Otherwise, returns false.
Throws: Nothing unless an exception is thrown by the equality comparison.
Complexity: At most M comparisons.
template <class T, class Allocator> bool operator!=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);Returns: !(x == y).
Option (B):
Add to the new section [forwardlist.compare] the following paragraphs:
template <class T, class Allocator> bool operator==(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);Requires: Type T is EqualityComparable ([equalitycomparable]).
Returns: distance(x.begin(), x.end()) == distance(y.begin(), y.end()) && equal(x.begin(), x.end(), y.begin()).
template <class T, class Allocator> bool operator!=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y);Returns: !(x == y).
Option (C):
Change Table 91 - Container Requirements in 23.2.1 [container.requirements.general] (N2798) like so:
Change the text in the Operational Semantics column in the row for a == b as follows:
== is an equivalence relation. distance(a.begin(), a.end())a.size()== distance(b.begin(), b.end())b.size()&& equal(a.begin(), a.end(), b.begin())Change the text in the Operational Semantics column in the row for a.max_size() as follows:
distance(a.begin(), a.end())a.size()of the largest possible containerChange the text in the Operational Semantics column in the row for a.empty() as follows:
a.begin() == a.end()a.size() == 0In addition, for consistency, change the text in the Operational Semantics column in the row for a.size() as follows:
distance(a.begin(), a.end())a.end() - a.begin()
Section: 25.5.5.1 [includes] Status: New Submitter: Alisdair Meredith Opened: 2008-07-02 Last modified: 2009-03-30
View other active issues in [includes].
View all other issues in [includes].
View all issues with New status.
Discussion:
In 25.5.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.5.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.
Proposed resolution:
Recommend NAD.
Section: 27.9.1 [fstreams] Status: New Submitter: Steve Clamage Opened: 2008-07-08 Last modified: 2008-07-09
View all other issues in [fstreams].
View all issues with New 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?
Proposed resolution:
Section: 25.4.6 [alg.fill], 25.4.7 [alg.generate] Status: New Submitter: Daniel Krügler Opened: 2008-07-13 Last modified: 2009-03-15
View all issues with New status.
Discussion:
In regard to library defect 488 I found some more algorithms which unnecessarily throw away information. These are typically algorithms, which sequentially write into an OutputIterator, but do not return the final value of this output iterator. These cases are:
template<class OutputIterator, class Size, class T> void fill_n(OutputIterator first, Size n, const T& value);
template<class OutputIterator, class Size, class Generator> void generate_n(OutputIterator first, Size n, Generator gen);
In both cases the minimum requirements on the iterator are OutputIterator, which means according to the requirements of 24.2.3 [output.iterators]/2 that only single-pass iterations are guaranteed. So, if users of fill_n and generate_n have *only* an OutputIterator available, they have no chance to continue pushing further values into it, which seems to be a severe limitation to me.
[ Post Summit Daniel "conceptualized" the wording. ]
Proposed resolution:
Replace the current declaration of fill_n in 25 [algorithms]/2, header <algorithm> synopsis and in 25.4.6 [alg.fill] by
template<class Iter, IntegralLike Size, class T> requires OutputIterator<Iter, const T&>voidIter fill_n(Iter first, Size n, const T& value);
Just after the effects clause p.1 add a new returns clause saying:
Returns: For fill_n and n > Size(0), returns first + n. Otherwise returns first for fill_n.
Replace the current declaration of generate_n in 25 [algorithms]/2, header <algorithm> synopsis and in 25.4.7 [alg.generate] by
template<class Iter, IntegralLike Size, Callable Generator>
requires OutputIterator<Iter, Generator::result_type>
&& CopyConstructible<Generator>
voidIter generate_n(Iter first, Size n, Generator gen);
Just after the effects clause p.1 add a new returns clause saying:
Returns: For generate_n and n > Size(0), returns first + n. Otherwise returns first for generate_n.
Section: 26.6.2.1 [valarray.cons] Status: New Submitter: Alberto Ganesh Barbati Opened: 2008-07-20 Last modified: 2008-07-22
View other active issues in [valarray.cons].
View all other issues in [valarray.cons].
View all issues with New 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).
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 areconstructed using the default constructor for the instantiating type Tvalue-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 beconstructed using the default constructorvalue-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]
Section: 23 [containers] Status: Open Submitter: Alberto Ganesh Barbati Opened: 2008-07-22 Last modified: 2008-09-22
View other active issues in [containers].
View all other issues in [containers].
View all issues with Open status.
Discussion:
The term "default constructed" is often used in wording that predates the introduction of the concept of value-initialization. In a few such places the concept of value-initialization is more correct than the current wording (for example when the type involved can be a built-in) so a replacement is in order. Two of such places are already covered by issue 867. This issue deliberately addresses the hopefully non-controversial changes in the attempt of being approved more quickly. A few other occurrences (for example in std::tuple, std::reverse_iterator and std::move_iterator) are left to separate issues. For std::reverse_iterator, see also issue 408. This issue is related with issue 724.
[ San Francisco: ]
The list provided in the proposed resolution is not complete. James Dennett will review the library and provide a complete list and will double-check the vocabulary.
This issue relates to Issue 886 tuple construction
Proposed resolution:
Change X [utility.arg.requirements], paragraph 2:
In general, a default constructor is not required. Certain container class member function signatures specifythe default constructorT() as a default argument. T() shall be a well-defined expression (8.5 [dcl.init]) if one of those signatures is called using the default argument (8.3.6 [dcl.fct.default]).
In all the following paragraphs in clause 23 [containers], replace "default constructed" with "value-initialized (8.5 [dcl.init])":
Section: 23.2.5 [unord.req] Status: Tentatively Ready Submitter: Sohail Somani Opened: 2008-07-22 Last modified: 2009-03-09
View other active issues in [unord.req].
View all other issues in [unord.req].
View all issues with Tentatively Ready status.
Discussion:
Is there any language in the current draft specifying the behaviour of the following snippet?
unordered_set<int> s; unordered_set<int>::local_iterator it = s.end(0); // Iterate past end - the unspecified part it++;
I don't think there is anything about s.end(n) being considered an iterator for the past-the-end value though (I think) it should be.
[ San Francisco: ]
We believe that this is not a substantive change, but the proposed change to the wording is clearer than what we have now.
[ Post Summit: ]
Recommend Tentatively Ready.
Proposed resolution:
Change Table 97 "Unordered associative container requirements" in 23.2.5 [unord.req]:
Table 97: Unordered associative container requirements expression return type assertion/note pre/post-condition complexity b.begin(n) local_iterator
const_local_iterator for const b.Pre: n shall be in the range [0,b.bucket_count()). Note: [b.begin(n), b.end(n)) is a valid range containing all of the elements in the nth bucket.b.begin(n) returns an iterator referring to the first element in the bucket. If the bucket is empty, then b.begin(n) == b.end(n).Constant b.end(n) local_iterator
const_local_iterator for const b.Pre: n shall be in the range [0, b.bucket_count()). b.end(n) returns an iterator which is the past-the-end value for the bucket. Constant
Section: 3.9.1 [basic.fundamental] Status: Open Submitter: Travis Vitek Opened: 2008-06-30 Last modified: 2009-03-21
View all issues with Open 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 14.10.4 [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...
- 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 asstd::ptrdiff_tin the<cstdint>header (18.1)...
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. X [allocator.requirements] table 40...
Table 40: Allocator requirements
expression return type assertion/note/pre/post-condition X::size_type unsigned integral typeunsigned integer typea type that can represent the size of the largest object in the allocation model. X::difference_type signed integral typesigned integer typea 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.6.6.3 [meta.trans.sign] table 48...
Table 48: Sign modifications
Template Comments template <class T> struct make_signed; If Tnames a (possibly cv-qualified)signed integral typesigned integer type (3.9.1) then the member typedeftypeshall name the typeT; otherwise, ifTnames a (possibly cv-qualified)unsigned integral typeunsigned integer type thentypeshall name the correspondingsigned integral typesigned integer type, with the same cv-qualifiers asT; otherwise,typeshall name thesigned integral typesigned integer type with the smallest rank (4.13) for whichsizeof(T) == sizeof(type), with the same cv-qualifiers asT. Requires:Tshall be a (possibly cv-qualified) integral type or enumeration but not abooltype.template <class T> struct make_unsigned; If Tnames a (possibly cv-qualified)unsigned integral typeunsigned integer type (3.9.1) then the member typedeftypeshall name the typeT; otherwise, ifTnames a (possibly cv-qualified)signed integral typesigned integer type thentypeshall name the correspondingunsigned integral typeunsigned integer type, with the same cv-qualifiers asT; otherwise,typeshall name theunsigned integral typeunsigned integer type with the smallest rank (4.13) for whichsizeof(T) == sizeof(type), with the same cv-qualifiers asT. Requires:Tshall be a (possibly cv-qualified) integral type or enumeration but not abooltype.
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
State stdio 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
State stdio 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
expression return type operational semantics assertion/note/pre/post-condition complexity X::difference_type signed integral typesigned integer typeis identical to the difference type of X::iterator and X::const_iterator compile time X::size_type unsigned integral typeunsigned integer typesize_type can represent any non-negative value of difference_type compile time
24.2 [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 iteratorsisupport the expression*i, resulting in a value of some class, enumeration, or built-in typeT, called the value type of the iterator. All output iterators support the expression*i = owhereois a value of some type that is in the set of types that are writable to the particular iterator type ofi. All iteratorsifor which the expression(*i).mis well-defined, support the expressioni->mwith the same semantics as(*i).m. For every iterator typeXfor which equality is defined, there is a correspondingsigned integral typesigned 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 parameterUIntTypeshall denote anunsigned integral typeunsigned integer type large enough to store values as large asm - 1. If the template parametermis 0, the modulusmused throughout this section 26.4.3.1 isnumeric_limits<result_type>::max()plus 1. [Note: The result need not be representable as a value of typeresult_type. --end note] Otherwise, the following relations shall hold:a < mandc < m.
Same rationale as the previous change. X [rand.adapt.xor] paragraph 6...
BothEngine1::result_typeandEngine2::result_typeshall 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:RandomAccessIteratorshall meet the requirements of a random access iterator (24.1.5) such thatiterator_traits<RandomAccessIterator>::value_typeshall denote anunsigned 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: Forsigned 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.
Section: 21.4 [basic.string] Status: Open Submitter: Daniel Krügler Opened: 2008-08-22 Last modified: 2008-09-18
View other active issues in [basic.string].
View all other issues in [basic.string].
View all issues with Open status.
Discussion:
During the Sophia Antipolis meeting it was decided to split-off some parts of the n2647 ("Concurrency modifications for basic_string") proposal into a separate issue, because these weren't actually concurrency-related. The here proposed changes refer to the recent update document n2668 and attempt to take advantage of the stricter structural requirements.
Indeed there exists some leeway for more guarantees that would be very useful for programmers, especially if interaction with transactionary or exception-unaware C API code is important. This would also allow compilers to take advantage of more performance optimizations, because more functions can have throw() specifications. This proposal uses the form of "Throws: Nothing" clauses to reach the same effect, because there already exists a different issue in progress to clean-up the current existing "schizophrenia" of the standard in this regard.
Due to earlier support for copy-on-write, we find the following unnecessary limitations for C++0x:
The proposed resolution is split into a main part (A) and a secondary part (B) (earlier called "Adjunct Adjunct Proposal"). (B) extends (A) by also making access to index position size() of the at() overloads a no-throw operation. This was separated, because this part is theoretically observable in specifically designed test programs.
[ San Francisco: ]
We oppose part 1 of the issue but hope to address size() in issue 877.
We do not support part B. 4 of the issue because of the breaking API change.
We support part A. 2 of the issue.
On support part A. 3 of the issue:
Pete's broader comment: now that we know that basic_string will be a block of contiguous memory, we should just rewrite its specification with that in mind. The expression of the specification will be simpler and probably more correct as a result.
Proposed resolution:
In 21.4.4 [string.capacity], just after p. 1 add a new paragraph:
Throws: Nothing.
In 21.4.5 [string.access] replace p. 1 by the following 4 paragraghs:
Requires: pos ≤ size().
Returns: If pos < size(), returns *(begin() + pos). Otherwise, returns a reference to a charT() that shall not be modified.
Throws: Nothing.
Complexity: Constant time.
In 21.4.7.1 [string.accessors] replace the now common returns clause of c_str() and data() by the following three paragraphs:
Returns: A pointer p such that p+i == &operator[](i) for each i in [0, size()].
Throws: Nothing.
Complexity: Constant time.
In 21.4.5 [string.access] replace p.2 and p.3 by:
Requires: pos ≤ size()
Throws: out_of_range if pos > size().
Section: 17 [library] Status: Open Submitter: Martin Sebor Opened: 2008-08-23 Last modified: 2008-09-18
View other active issues in [library].
View all other issues in [library].
View all issues with Open 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.
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.
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.
Section: 23.3.3 [forwardlist] Status: Tentatively Ready Submitter: Martin Sebor Opened: 2008-08-23 Last modified: 2009-03-09
View all issues with Tentatively Ready status.
Discussion:
forward_list member functions that take a forward_list::iterator (denoted position in the function signatures) argument have the following precondition:
Requires: position is dereferenceable or equal to before_begin().
I believe what's actually intended is this:
Requires: position is in the range [before_begin(), end()).
That is, when it's dereferenceable, position must point into *this, not just any forward_list object.
[ San Francisco: ]
Robert suggested alternate proposed wording which had large support.
[ Post Summit: ]
Walter: "position is before_begin() or a dereferenceable": add "is" after the "or"
With that minor update, Recommend Tentatively Ready.
Proposed resolution:
Change the Requires clauses [forwardlist] , p21, p24, p26, p29, and, 23.3.3.5 [forwardlist.ops], p39, p43, p47 as follows:
Requires: position is before_begin() or is a dereferenceable iterator in the range [begin(), end))or equal to before_begin(). ...
Section: 29 [atomics] Status: Review Submitter: Alexander Chemeris Opened: 2008-08-24 Last modified: 2009-03-22
View other active issues in [atomics].
View all other issues in [atomics].
View all issues with Review 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.
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);
Section: 29 [atomics] Status: Open Submitter: Lawrence Crowl Opened: 2008-08-24 Last modified: 2009-03-22
View other active issues in [atomics].
View all other issues in [atomics].
View all issues with Open 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.
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);
Section: 20.8.13.2.1 [util.smartptr.shared.const] Status: Open Submitter: Peter Dimov Opened: 2008-08-30 Last modified: 2008-09-18
View other active issues in [util.smartptr.shared.const].
View all other issues in [util.smartptr.shared.const].
View all issues with Open status.
Discussion:
We've changed shared_ptr<Y> to not convert to shared_ptr<T> when Y* doesn't convert to T* by resolving issue 687. This only fixed the converting copy constructor though. N2351 later added move support, and the converting move constructor is not constrained.
[ San Francisco: ]
We might be able to move this to NAD, Editorial once shared_ptr is conceptualized, but we want to revisit this issue to make sure.
Proposed resolution:
We need to change the Requires clause of the move constructor:
shared_ptr(shared_ptr&& r); template<class Y> shared_ptr(shared_ptr<Y>&& r);Requires:For the second constructor Y* shall be convertible to T*.The second constructor shall not participate in overload resolution unless Y* is convertible to T*.
in order to actually make the example in 687 compile (it now resolves to the move constructor).
Section: 23 [containers] Status: Open Submitter: Alisdair Meredith Opened: 2008-09-10 Last modified: 2009-03-11
View other active issues in [containers].
View all other issues in [containers].
View all issues with Open status.
Discussion:
Note in particular that Table 90 "Container Requirements" gives semantics of a.swap(b) as swap(a,b), yet for all containers we define swap(a,b) to call a.swap(b) - a circular definition.
[ San Francisco: ]
Robert to propose a resolution along the lines of "Postcondition: "a = b, b = a" This will be a little tricky for the hash containers, since they don't have operator==.
[ Post Summit Anthony Williams provided proposed wording. ]
Proposed resolution:
In table 80 in section 23.2.1 [container.requirements.general], replace the postcondition of a.swap(b) with the following:
Table 80 -- Container requirements Expression Return type Operational semantics Assertion/note pre-/post-conidtion Complexity ... ... ... ... ... a.swap(b); void swap(a,b)Exchange the contents of a and b as-if
X u=std::move(a);
a=std::move(b);
b=std::move(u);(Note A)
Remove the reference to swap from the paragraph following the table.
Notes: the algorithmsswap(),equal() and lexicographical_compare() are defined in Clause 25. ...
Section: 20.8.13.2.4 [util.smartptr.shared.mod] Status: Open Submitter: Jonathan Wakely Opened: 2008-09-15 Last modified: 2009-03-11
View all issues with Open status.
Discussion:
#include <memory>
#include <cassert>
struct A { };
struct B : A { };
int main()
{
std::shared_ptr<A> pa(new A);
std::shared_ptr<B> pb(new B);
std::swap<A>(pa, pb); // N.B. no argument deduction
assert( pa.get() == pb.get() );
return 0;
}
Is this behaviour correct (I believe it is) and if so, is it unavoidable, or not worth worrying about?
This calls the lvalue/rvalue swap overload for shared_ptr:
template<class T> void swap( shared_ptr<T> & a, shared_ptr<T> && b );
silently converting the second argument from shared_ptr<B> to shared_ptr<A> and binding the rvalue ref to the produced temporary.
This is not, in my opinion, a shared_ptr problem; it is a general issue with the rvalue swap overloads. Do we want to prevent this code from compiling? If so, how?
Perhaps we should limit rvalue args to swap to those types that would benefit from the "swap trick". Or, since we now have shrink_to_fit(), just eliminate the rvalue swap overloads altogether. The original motivation was:
N1690.vector<A> v = ...; ... swap(v, vector<A>(v));
Proposed resolution:
Recommend NAD Editorial, fixed by N2844.
Section: 20.3.3 [pairs] Status: Open Submitter: Alisdair Meredith Opened: 2008-09-15 Last modified: 2008-09-23
View other active issues in [pairs].
View all other issues in [pairs].
View all issues with Open status.
Discussion:
20.2.3 pairs
Missing assignemnt operator:
template<class U , class V>
requires CopyAssignable<T1, U> && CopyAssignable<T2, V>
pair& operator=(pair<U , V> const & p );
Well, that's interesting. This assignment operator isn't in the current working paper, either. Perhaps we deemed it acceptable to build a temporary of type pair from pair<U, V>, then move-assign from that temporary?
It sounds more like an issue waiting to be opened, unless you want to plug it now. As written we risk moving from lvalues.
[ San Francisco: ]
Would be NAD if better ctors fixed it.
Related to 811.
[ post San Francisco: ]
Possibly NAD Editorial, solved by N2770.
Proposed resolution:
Section: 20.5.2.1 [tuple.cnstr] Status: Open Submitter: Alisdair Meredith Opened: 2008-09-15 Last modified: 2008-09-22
View other active issues in [tuple.cnstr].
View all other issues in [tuple.cnstr].
View all issues with Open status.
Discussion:
20.5.2.1 [tuple.cnstr]:
Effects: Default initializes each element.
Could be clarified to state each "non-trivial" element. Otherwise we have a conflict with Core deinfition of default initialization - trivial types do not get initialized (rather than initialization having no effect)
I'm going to punt on this one, because it's not an issue that's related to concepts. I suggest bringing it to Howard's attention on the reflector.
[ San Francisco: ]
Text in draft doesn't mean anything, changing to "non-trivial" makes it meaningful.
We prefer "value initializes". Present implementations use value-initialization. Users who don't want value initialization have alternatives.
Request resolution text from Alisdair.
This issue relates to Issue 868 default construction and value-initialization.
Proposed resolution:
Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2009-03-09
View other active issues in [thread.condition.condvar].
View all other issues in [thread.condition.condvar].
View all issues with Open 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; typename Clock::time_point c_entry = Clock::now(); system_clock::time_point s_entry = system_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.
Proposed resolution:
Section: 30.3.2 [thread.thread.this] Status: Tentatively Ready Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2009-03-09
View all issues with Tentatively Ready status.
Discussion:
I never thought I'd say this, but this_thread::yield seems to be too strong in specification. The issue is that some systems distinguish between yielding to another thread in the same process and yielding to another process. Given that the C++ standard only talks about a single program, one can infer that the specification allows yielding only to another thread within the same program. Posix has no facility for that behavior. Can you please file an issue to weaken the wording. Perhaps "Offers the operating system the opportunity to reschedule."
[ Post Summit: ]
Recommend move to Tentatively Ready.
Proposed resolution:
Change 30.3.2 [thread.thread.this]/3:
void this_thread::yield();Effects: Offers theoperating systemimplementation the opportunity to reschedule.another thread.
Section: 30.3.1.1 [thread.thread.id] Status: Open Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2009-03-11
View all other issues in [thread.thread.id].
View all issues with Open 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.7 [function.objects], 20.7.17 [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, Alisdiar 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.7 [function.objects] does not mention hash< thread::id > nor hash< error_code >, although their existence is implied by 20.7.17 [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.
Proposed resolution:
Move to NAD.
Section: 19.5.1 [syserr.errcat] Status: Tentatively Ready Submitter: Beman Dawes Opened: 2008-09-14 Last modified: 2009-03-09
View all issues with Tentatively Ready status.
Discussion:
The static const error_category objects generic_category and system_category in header <system_error> are currently declared:
const error_category& get_generic_category(); const error_category& get_system_category(); static const error_category& generic_category = get_generic_category(); static const error_category& system_category = get_system_category();
This formulation has several problems:
IO streams uses a somewhat different formulation for iostream_category, but still suffer much the same problems.
The original plan was to eliminate these problems by applying the C++0x constexpr feature. See LWG issue 832. However, that approach turned out to be unimplementable, since it would require a constexpr object of a class with virtual functions, and that is not allowed by the core language.
The proposed resolution was developed as an alternative. It mitigates the above problems by removing initialization from the visible interface, allowing implementations flexibility.
Implementation experience:
Prototype implementations of the current WP interface and proposed resolution interface were tested with recent Codegear, GCC, Intel, and Microsoft compilers on Windows. The code generated by the Microsoft compiler was studied at length; the WP and proposal versions generated very similar code. For both versions the compiler did make use of static initialization; apparently the compiler applied an implicit constexpr where useful, even in cases where constexpr would not be permitted by the language!
Acknowledgements:
Martin Sebor, Chris Kohlhoff, and John Lakos provided useful ideas and comments on initialization issues.
[ San Francisco: ]
Martin: prefers not to create more file-scope static objects, and would like to see get_* functions instead.
[Pre-Summit:]
Beman: The proposed resolution has been reworked to remove the file-scope static objects, per Martin's suggestions. The get_ prefix has been eliminated from the function names as no longer necessary and to conform with standard library naming practice.
[ Post Summit: ]
Agreement that this is wise and essential, text provided works and has been implemented. Seems to be widespread consensus. Move to Tentative Ready.
Proposed resolution:
Change 17.6.4.12 [value.error.codes] Value of error codes as indicated:
Certain functions in the C++ standard library report errors via a std::error_code (19.4.2.2) object. That object's category() member shall return
a reference tostd::system_category()for errors originating from the operating system, or a reference to an implementation-defined error_category object for errors originating elsewhere. The implementation shall define the possible values of value() for each of these error categories. [Example: For operating systems that are based on POSIX, implementations are encouraged to define thestd::system_category()values as identical to the POSIX errno values, with additional values as defined by the operating system's documentation. Implementations for operating systems that are not based on POSIX are encouraged to define values identical to the operating system's values. For errors that do not originate from the operating system, the implementation may provide enums for the associated values --end example]
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 storage-class-specifier const error_category& generic_category = get_generic_category(); static storage-class-specifier const error_category& system_category = get_system_category();
Change 19.5.1.5 [syserr.errcat.objects] Error category objects as indicated:
const error_category&get_generic_category();Returns: A reference to an 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".
const error_category&get_system_category();Returns: A reference to an 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.3 [syserr.errcode.constructors] Class error_code constructors as indicated:
error_code();Effects: Constructs an object of type error_code.
Postconditions:
val_ == 0andcat_ == &system_category().
Change 19.5.2.4 [syserr.errcode.modifiers] Class error_code modifiers as indicated:
void clear();Postconditions:
value() == 0andcategory() == system_category().
Change 19.5.2.6 [syserr.errcode.nonmembers] Class error_code non-member functions as indicated:
error_code make_error_code(errc e);Returns:
error_code(static_cast<int>(e), generic_category()).
Change 19.5.3.3 [syserr.errcondition.constructors] Class error_condition constructors as indicated:
error_condition();Effects: Constructs an object of type
error_condition.Postconditions:
val_ == 0andcat_ == &generic_category().
Change 19.5.3.4 [syserr.errcondition.modifiers] Class error_condition modifiers as indicated:
void clear();Postconditions:
value() == 0andcategory() == generic_category().
Change 19.5.3.6 [syserr.errcondition.nonmembers] Class error_condition non-member functions as indicated:
error_condition make_error_condition(errc e);Returns: error_condition(static_cast<int>(e), generic_category()).
Change 27.5 [iostreams.base] Iostreams base classes, Header <ios> synopsis as indicated:
concept_map ErrorCodeEnum<io_errc> { };
error_code make_error_code(io_errc e);
error_condition make_error_condition(io_errc e);
storage-class-specifier const error_category& iostream_category();
Change 27.5.2.1.1 [ios::failure] Class ios_base::failure, paragraph 2 as indicated:
When throwing ios_base::failure exceptions, implementations should provide values of ec that identify the specific reason for the failure. [ Note: Errors arising from the operating system would typically be reported as system_category() errors with an error value of the error number reported by the operating system. Errors arising from within the stream library would typically be reported as error_code(io_errc::stream, iostream_category()). --end note ]
Change 27.5.5.5 [error.reporting] Error reporting as indicated:
error_code make_error_code(io_errc e);Returns:
error_code(static_cast<int>(e), iostream_category()).error_condition make_error_condition(io_errc e);Returns:
error_condition(static_cast<int>(e), iostream_category()).storage-class-specifierconst error_category& iostream_category();The implementation shall initialize iostream_category. Its storage-class-specifier may be static or extern. It is unspecified whether initialization is static or dynamic (3.6.2). If initialization is dynamic, it shall occur before completion of the dynamic initialization of the first translation unit dynamically initialized that includes header <system_error>.
Returns: A reference to an 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 "iostream".
Section: 30.3.1.2 [thread.thread.constr], 30.4.5.2 [thread.once.callonce] Status: Open Submitter: Peter Dimov Opened: 2008-09-15 Last modified: 2009-03-22
View other active issues in [thread.thread.constr].
View all other issues in [thread.thread.constr].
View all issues with Open status.
Discussion:
I notice that the vararg overloads of std::thread and std::call_once (N2723 30.3.1.2 [thread.thread.constr] and 30.4.5.2 [thread.once.callonce]) are no longer specified in terms of std::bind; instead, some of the std::bind wording has been inlined into the specification.
There are two problems with this.
First, the specification (and implementation) in terms of std::bind allows, for example:
std::thread th( f, 1, std::bind( g ) );
which executes f( 1, g() ) in a thread. This can be useful. The "inlined" formulation changes it to execute f( 1, bind(g) ) in a thread.
Second, assuming that we don't want the above, the specification has copied the wording
INVOKE(func, w1, w2, ..., wN) (20.6.2) shall be a valid expression for some values w1, w2, ..., wN
but this is not needed since we know that our argument list is args; it should simply be
INVOKE(func, args...) (20.6.2) shall be a valid expression
[ Summit: ]
Move to open.
[ Post Summit Anthony provided proposed wording. ]
Proposed resolution:
Change paragraph 4 of 30.3.1.2 [thread.thread.constr] to:
template <class F> explicit thread(F f); template <class F, class ...Args> thread(F&& f, Args&&... args);-4- Requires: F and each Ti in Args shall be CopyConstructible if an lvalue and otherwise MoveConstructible. INVOKE(f,w1, w2, ..., wNargs...) (20.6.2) shall be a valid expressionfor some values w1, w2, ..., wN, where N == sizeof...(Args).
Change paragraph 1 of 30.4.5.2 [thread.once.callonce] to:
template<class Callable, class ...Args> void call_once(once_flag& flag, Callable func, Args&&... args);-1- Requires: The template parameters Callable> and each Ti in Args shall be CopyConstructible if an lvalue and otherwise MoveConstructible. INVOKE(func,w1, w2, ..., wNargs...) (20.6.2) shall be a valid expressionfor some values w1, w2, ..., wN, where N == sizeof...(Args).
Section: 30.4.1.1 [thread.mutex.class] Status: Open Submitter: Peter Dimov Opened: 2008-09-15 Last modified: 2009-03-22
View other active issues in [thread.mutex.class].
View all other issues in [thread.mutex.class].
View all issues with Open status.
Duplicate of: 905
Discussion:
30.4.1.1 [thread.mutex.class]/27 (in N2723) says that the behavior is undefined if:
I don't believe that this is right. Calling lock() or try_lock() on a locked mutex is well defined in the general case. try_lock() is required to fail and return false. lock() is required to either throw an exception (and is allowed to do so if it detects deadlock) or to block until the mutex is free. These general requirements apply regardless of the current owner of the mutex; they should apply even if it's owned by the current thread.
Making double lock() undefined behavior probably can be justified (even though I'd still disagree with the justification), but try_lock() on a locked mutex must fail.
[ Summit: ]
Move to open. Proposed resolution:
- In 30.4.1 [thread.mutex.requirements] paragraph 12, change the error condition for resource_deadlock_would_occur to: "if the implementation detects that a deadlock would occur"
- Strike 30.4.1.1 [thread.mutex.class] paragraph 3 bullet 2 "a thread that owns a mutex object calls lock() or try_lock() on that object, or"
Proposed resolution:
In 30.4.1 [thread.mutex.requirements] paragraph 12 change:
- ...
- resource_deadlock_would_occur -- if the
current thread already owns the mutex and is able to detect itimplementation detects that a deadlock would occur.- ...
Strike 30.4.1.1 [thread.mutex.class] paragraph 3 bullet 2:
-3- The behavior of a program is undefined if:
- ...
a thread that owns a mutex object calls lock() or try_lock() on that object, or- ...
Section: 17.5.1.4 [structure.specifications] Status: Open Submitter: James Dennett Opened: 2008-09-16 Last modified: 2009-03-11
View other active issues in [structure.specifications].
View all other issues in [structure.specifications].
View all issues with Open status.
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.
Proposed resolution:
Section: 20.8.13.2 [util.smartptr.shared] Status: Open Submitter: Hans Boehm Opened: 2008-09-16 Last modified: 2008-09-25
View other active issues in [util.smartptr.shared].
View all other issues in [util.smartptr.shared].
View all issues with Open status.
Discussion:
It is unclear whether shared_ptr is thread-safe in the sense that multiple threads may simultaneously copy a shared_ptr. However this is a critical piece of information for the client, and it has significant impact on usability for many applications. (Detlef Vollman thinks it is currently clear that it is not thread-safe. Hans Boehm thinks it currently requires thread safety, since the use_count is not an explicit field, and constructors and assignment take a const reference to an existing shared_ptr.)
Pro thread-safety:
Many multi-threaded usages are impossible. A thread-safe version can be used to destroy an object when the last thread drops it, something that is often required, and for which we have no other easy mechanism.
Against thread-safety:
The thread-safe version is well-known to be far more expensive, even if used by a single thread. Many applications, including all single-threaded ones, do not care.
[ San Francisco: ]
Beman: this is a complicated issue, and would like to move this to Open and await comment from Peter Dimov; we need very careful and complete rationale for any decision we make; let's go slow
Detlef: I think that shared_ptr should not be thread-safe.
Hans: When you create a thread with a lambda, it in some cases makes it very difficult for the lambda to reference anything in the heap. It's currently ambiguous as to whether you can use a shared_ptr to get at an object.
Leave in Open. Detlef will submit an alternative proposed resolution that makes shared_ptr explicitly unsafe.
A third option is to support both threadsafe and non-safe share_ptrs, and to let the programmer decide which behavior they want.
Beman: Peter, do you support the PR?
Peter:
Yes, I support the proposed resolution, and I certainly oppose any attempts to make shared_ptr thread-unsafe.
I'd mildly prefer if
[Note: This is true in spite of that fact that such functions often modify use_count() --end note]is changed to
[Note: This is true in spite of that fact that such functions often cause a change in use_count() --end note](or something along these lines) to emphasise that use_count() is not, conceptually, a variable, but a return value.
Proposed resolution:
Make it explicitly thread-safe, in this weak sense, as I believe was intended:
Insert in 20.8.13.2 [util.smartptr.shared], before p5:
For purposes of determining the presence of a data race, member functions do not modify const shared_ptr and const weak_ptr arguments, nor any objects they refer to. [Note: This is true in spite of that fact that such functions often cause a change in use_count() --end note]
On looking at the text, I'm not sure we need a similar disclaimer anywhere else, since nothing else has the problem with the modified use_count(). I think Howard arrived at a similar conclusion.
Section: 23.3.3.4 [forwardlist.modifiers] Status: New Submitter: Howard Hinnant Opened: 2008-09-22 Last modified: 2008-09-24
View all issues with New 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:
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:
There is not a strong technical argument for either solution over the other.
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.
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 existsAn 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).
Section: 23.3.3.5 [forwardlist.ops] Status: New Submitter: Arch Robison Opened: 2008-09-08 Last modified: 2009-03-29
View other active issues in [forwardlist.ops].
View all other issues in [forwardlist.ops].
View all issues with New status.
Discussion:
I ran across a small contradiction in working draft n2723.
23.3.3 [forwardlist]p2: A forward_list satisfies all of the requirements of a container (table 90), except that the size() member function is not provided.
23.3.3.5 [forwardlist.ops]p57: Complexity: At most size() + x.size() - 1 comparisons.
Presumably 23.3.3.5 [forwardlist.ops]p57 needs to be rephrased to not use size(), or note that it is used there only for sake of notational convenience.
[ 2009-03-29 Beman provided proposed wording. ]
Proposed resolution:
Change 23.3.3.5 [forwardlist.ops], forward_list operations, paragraph 19, merge complexity as indicated:
Complexity: At mostsize() + x.size()distance(begin(), end()) + distance(x.begin(), x.end()) - 1 comparisons.
Section: 20.8.13.2.2 [util.smartptr.shared.dest] Status: Review Submitter: Peter Dimov Opened: 2008-09-18 Last modified: 2009-03-10
View all other issues in [util.smartptr.shared.dest].
View all issues with Review status.
Discussion:
James Dennett, message c++std-lib-22442:
The wording below addresses one case of this, but opening an issue to address the need to sanity check uses of the term "pointer" in 20.8.13.2 [util.smartptr.shared] would be a good thing.
There's one more reference, in ~shared_ptr; we can apply your suggested change to it, too. That is:
Change 20.8.13.2.2 [util.smartptr.shared.dest]/1 second bullet from:
Otherwise, if *this owns a pointer p and a deleter d, d(p) is called.
to:
Otherwise, if *this owns an object p and a deleter d, d(p) is called.
[ Post Summit: ]
Recommend Review.
Proposed resolution:
Change 20.8.13.2.2 [util.smartptr.shared.dest]/1 second bullet:
- ...
- Otherwise, if *this owns
a pointeran object p and a deleter d, d(p) is called.
Section: 27.9.1.8 [ifstream.assign] Status: New Submitter: Niels Dekker Opened: 2008-09-20 Last modified: 2008-09-24
View all issues with New status.
Discussion:
It appears that we have an issue similar to issue 675 regarding the move-assignment of stream types. For example, when assigning to an std::ifstream, ifstream1, it seems preferable to close the file originally held by ifstream1:
ifstream1 = std::move(ifstream2);
The current Draft (N2723) specifies that the move-assignment of stream types like ifstream has the same effect as a swap:
Assign and swap 27.9.1.8 [ifstream.assign]
basic_ifstream& operator=(basic_ifstream&& rhs);Effects: swap(rhs).
Proposed resolution:
Section: 24.7.5 [insert.iterator] Status: Review Submitter: Alisdair Meredith Opened: 2008-09-24 Last modified: 2009-03-13
View all issues with Review 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:
[ 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.
Proposed resolution:
Recommend NAD, addressed by N2844.
Section: 18.3.1 [limits] Status: Open Submitter: Alisdair Meredith Opened: 2008-09-24 Last modified: 2009-03-11
View all other issues in [limits].
View all issues with Open 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:
Section: 24.7.1 [back.insert.iterator] Status: New Submitter: Dave Abrahams Opened: 2008-09-19 Last modified: 2009-03-12
View all issues with New 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.
Proposed resolution:
Section: 20.7.4 [func.ret] Status: Tentatively Ready Submitter: Jonathan Wakely Opened: 2008-09-10 Last modified: 2009-03-09
View all issues with Tentatively Ready status.
Discussion:
The WP and TR1 have the same text regarding the argument types of a result_of expression:
The values ti are lvalues when the corresponding type Ti is a reference type, and rvalues otherwise.
I read this to mean that this compiles:
typedef int (*func)(int&); result_of<func(int&&)>::type i = 0;
even though this doesn't:
int f(int&); f( std::move(0) );
Should the text be updated to say "when Ti is an lvalue-reference type" or am I missing something?
I later came up with this self-contained example which won't compile, but I think it should:
struct X {
void operator()(int&);
int operator()(int&&);
} x;
std::result_of< X(int&&) >::type i = x(std::move(0));
[ Post Summit: ]
Recommend Tentatively Ready.
Proposed resolution:
Change 20.7.4 [func.ret], p1:
... The values ti are lvalues when the corresponding type Ti is an lvalue-reference type, and rvalues otherwise.
Section: 18.9 [support.initlist] Status: New Submitter: Daniel Krügler Opened: 2008-09-26 Last modified: 2009-03-14
View all issues with New 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>);
...
};
Proposed resolution:
Section: 20.3.6.2 [bitset.members] Status: Review Submitter: Daniel Krügler Opened: 2008-09-26 Last modified: 2009-03-09
View all other issues in [bitset.members].
View all issues with Review status.
Discussion:
The current standard 14882::2003(E) as well as the current draft N2723 have in common a contradiction of the operational semantics of member function test 20.3.6.2 [bitset.members]/56-58 and the immutable member operator[] overload 20.3.6.2 [bitset.members]/64-66 (all references are defined in terms of N2723):
bool test(size_t pos) const;
Requires: pos is valid
Throws: out_of_range if pos does not correspond to a valid bit position.
Returns: true if the bit at position pos in *this has the value one.
constexpr bool operator[](size_t pos) const;
Requires: pos shall be valid.
Throws: nothing.
Returns: test(pos).
Three interpretations:
The problem became worse, because issue 720 recently voted into WP argued that member test logically must be a constexpr function, because it was used to define the semantics of another constexpr function (the operator[] overload).
Three alternatives are proposed, corresponding to the three bullets (A), (B), and (C), the author suggests to follow proposal (C).
Proposed alternatives:Remove the constexpr specifier in front of operator[] overload and undo that of member test (assuming 720 is accepted) in both the class declaration 20.3.6 [template.bitset]/1 and in the member description before 20.3.6.2 [bitset.members]/56 and before /64 to read:
constexprbool test(size_t pos) const; ..constexprbool operator[](size_t pos) const;
Change the throws clause of p. 65 to read:
Throws:nothingout_of_range if pos does not correspond to a valid bit position.
Replace the throws clause p. 57 to read:
Throws:out_of_range if pos does not correspond to a valid bit positionnothing.
Undo the addition of the constexpr specifier to the test member function in both class declaration 20.3.6 [template.bitset]/1 and in the member description before 20.3.6.2 [bitset.members]/56, assuming that 720 was applied.
constexprbool test(size_t pos) const;
Change the returns clause p. 66 to read:
Returns:test(pos)true if the bit at position pos in *this has the value one, otherwise false.
[ Post Summit: ]
Lawrence: proposed resolutions A, B, C are mutually exclusive.
Recommend Review with option C.
Proposed resolution:
Undo the addition of the constexpr specifier to the test member function in both class declaration 20.3.6 [template.bitset]/1 and in the member description before 20.3.6.2 [bitset.members]/56, assuming that 720 was applied.
constexprbool test(size_t pos) const;
Change the returns clause p. 66 to read:
Returns:test(pos)true if the bit at position pos in *this has the value one, otherwise false.
Section: 29.5 [atomics.types] Status: Open Submitter: Anthony Williams Opened: 2008-09-26 Last modified: 2009-03-22
View all other issues in [atomics.types].
View all issues with Open 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.
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.
Section: 28.13.2 [re.tokiter] Status: Review Submitter: Daniel Krügler Opened: 2008-09-26 Last modified: 2009-03-13
View all other issues in [re.tokiter].
View all issues with Review status.
Discussion:
Addresses UK 319
Construction of a regex_token_iterator (28.13.2 [re.tokiter]/6+) usually requires the provision of a sequence of integer values, which can currently be done via a std::vector<int> or a C array of int. Since the introduction of initializer_list in the standard it seems much more reasonable to provide a corresponding constructor that accepts an initializer_list<int> instead. This could be done as a pure addition or one could even consider replacement. The author suggests the replacement strategy (A), but provides an alternative additive proposal (B) as a fall-back, because of the handiness of this range type:
Proposed resolution:
In 28.13.2 [re.tokiter]/6 and the list 28.13.2.1 [re.tokiter.cnstr]/10-11 change the constructor declaration:
template <std::size_t N>regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,const int (&submatches)[N]initializer_list<int> submatches, regex_constants::match_flag_type m = regex_constants::match_default);
In 28.13.2.1 [re.tokiter.cnstr]/12 change the 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.begin(),&submatches.end()+ N).
In 28.13.2 [re.tokiter]/6 and the list 28.13.2.1 [re.tokiter.cnstr]/10-11 insert the following constructor declaration between the already existing ones accepting a std::vector and a C array of int, resp.:
regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
const regex_type& re,
initializer_list<int> submatches,
regex_constants::match_flag_type m =
regex_constants::match_default);
In 28.13.2.1 [re.tokiter.cnstr]/12 change the last sentence
The third and fourth constructor initializesthe member subs to hold a copy of the sequence of integer values pointed to by the iterator range [&submatches,&submatches + N) and [submatches.begin(),submatches.end()), respectively.
Section: 20.2.9 [concept.copymove] Status: New Submitter: Alberto Ganesh Barbati Opened: 2008-09-29 Last modified: 2008-09-29
View all issues with New status.
Discussion:
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.
Proposed resolution:
In 20.2.9 [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]
Section: 27.7.1 [input.streams], 27.7.2 [output.streams] Status: New Submitter: Alberto Ganesh Barbati Opened: 2008-09-29 Last modified: 2008-09-30
View all issues with New status.
Discussion:
Class template basic_istream, basic_ostream and basic_iostream implements public move constructors, move assignment operators and swap method and free functions. This might induce both the user and the compiler to think that those types are MoveConstructible, MoveAssignable and Swappable. However, those class templates fail to fulfill the user expectations. For example:
std::ostream os(std::ofstream("file.txt"));
assert(os.rdbuf() == 0); // buffer object is not moved to os, file.txt has been closed
std::vector<std::ostream> v;
v.push_back(std::ofstream("file.txt"));
v.reserve(100); // causes reallocation
assert(v[0].rdbuf() == 0); // file.txt has been closed!
std::ostream&& os1 = std::ofstream("file1.txt");
os1 = std::ofstream("file2.txt");
os1 << "hello, world"; // still writes to file1.txt, not to file2.txt!
std::ostream&& os1 = std::ofstream("file1.txt");
std::ostream&& os2 = std::ofstream("file2.txt");
std::swap(os1, os2);
os1 << "hello, world"; // writes to file1.txt, not to file2.txt!
This is because the move constructor, the move assignment operator and swap are all implemented through calls to std::basic_ios member functions move() and swap() that do not move nor swap the controlled stream buffers. That can't happen because the stream buffers may have different types.
Notice that for basic_streambuf, the member function swap() is protected. I believe that is correct and all of basic_istream, basic_ostream, basic_iostream should do the same as the move ctor, move assignment operator and swap member function are needed by the derived fstreams and stringstreams template. The free swap functions for basic_(i|o|io)stream templates should be removed for the same reason.
Proposed resolution:
27.7.1.1 [istream]: make the following member functions protected:
basic_istream(basic_istream&& rhs); basic_istream& operator=(basic_istream&& rhs); void swap(basic_istream&& rhs);
Ditto: remove the three swap free functions signatures
// swap: template <class charT, class traits> void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y); template <class charT, class traits> void swap(basic_istream<charT, traits>&& x, basic_istream<charT, traits>& y); template <class charT, class traits> void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>&& y);
27.7.1.1.2 [istream.assign]: remove paragraph 4
template <class charT, class traits> void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y); template <class charT, class traits> void swap(basic_istream<charT, traits>&& x, basic_istream<charT, traits>& y); template <class charT, class traits> void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>&& y);Effects: x.swap(y).
27.7.1.5 [iostreamclass]: make the following member function protected:
basic_iostream(basic_iostream&& rhs); basic_iostream& operator=(basic_iostream&& rhs); void swap(basic_iostream&& rhs);
Ditto: remove the three swap free functions signatures
template <class charT, class traits> void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y); template <class charT, class traits> void swap(basic_iostream<charT, traits>&& x, basic_iostream<charT, traits>& y); template <class charT, class traits> void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>&& y);
27.7.1.5.3 [iostream.assign]: remove paragraph 3
template <class charT, class traits> void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y); template <class charT, class traits> void swap(basic_iostream<charT, traits>&& x, basic_iostream<charT, traits>& y); template <class charT, class traits> void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>&& y);Effects: x.swap(y).
27.7.2.1 [ostream]: make the following member function protected:
basic_ostream(basic_ostream&& rhs); basic_ostream& operator=(basic_ostream&& rhs); void swap(basic_ostream&& rhs);
Ditto: remove the three swap free functions signatures
// swap: template <class charT, class traits> void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y); template <class charT, class traits> void swap(basic_ostream<charT, traits>&& x, basic_ostream<charT, traits>& y); template <class charT, class traits> void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>&& y);
27.7.2.3 [ostream.assign]: remove paragraph 13 (The paragraphs seems to be misnumbered in the whole section 27.7.2 [output.streams] in N2723. The paragraph to remove is the one that describes the three swap free functions).
template <class charT, class traits> void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y); template <class charT, class traits> void swap(basic_ostream<charT, traits>&& x, basic_ostream<charT, traits>& y); template <class charT, class traits> void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>&& y);Effects: x.swap(y).
Section: 25.4.3 [alg.swap] Status: New Submitter: Daniel Krügler Opened: 2008-10-01 Last modified: 2009-03-14
View all other issues in [alg.swap].
View all issues with New 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.
Proposed resolution:
Replace in 25.4.3 [alg.swap] before p. 3 until p. 4 by
template <classValueType 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);
Section: 25.4.5 [alg.replace] Status: New Submitter: Daniel Krügler Opened: 2008-10-03 Last modified: 2009-03-14
View other active issues in [alg.replace].
View all other issues in [alg.replace].
View all issues with New status.
Discussion:
(A) 25.4.5 [alg.replace]/1:
Requires: The expression *first = new_value shall be valid.
(B) 25.4.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.
Proposed resolution:
Remove 25.4.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.
25.4.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.
Section: 25.4.9 [alg.unique] Status: New Submitter: Daniel Krügler Opened: 2008-10-03 Last modified: 2008-10-03
View other active issues in [alg.unique].
View all other issues in [alg.unique].
View all issues with New status.
Discussion:
25.4.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.
Proposed resolution:
Remove 25.4.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.
Section: 25.5.7 [alg.min.max] Status: New Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2009-03-14
View other active issues in [alg.min.max].
View all other issues in [alg.min.max].
View all issues with New status.
Discussion:
It seems that the proposed changes for N2772 were not clear enough in this point:
25.5.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.
Proposed resolution:
In 25 [algorithms]/2, header <algorithm> synopsis change as indicated:
template<classLessThanComparable T> requires CopyConstructible<T> pair<constT&,constT&> minmax(initializer_list<T> t); template<class T,classStrictWeakOrder<auto, T> Compare> requires CopyConstructible<T> pair<constT&,constT&> minmax(initializer_list<T> t, Compare comp);
In 25.5.7 [alg.min.max] change as indicated (Begin: Just before p.20):
template<classLessThanComparable T> requires CopyConstructible<T> pair<constT&,constT&> minmax(initializer_list<T> t);
-20- Requires: T is LessThanComparable and CopyConstructible.-21- Returns: pair<
constT&,constT&>(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<constT&,constT&> minmax(initializer_list<T> t, Compare comp);
-24- Requires: type T is LessThanComparable and CopyConstructible.-25- Returns: pair<
constT&,constT&>(x, y) where x is the smallest value and y largest value in the initializer_list.
Section: 20.3.3 [pairs] Status: New Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2009-03-14
View other active issues in [pairs].
View all other issues in [pairs].
View all issues with New status.
Discussion:
The current WP provides the following assignment operators for pair in 20.3.3 [pairs]/1:
template<class U , class V> requires HasAssign<T1, const U&> && HasAssign<T2, const V&> pair& operator=(const pair<U , V>& p);
requires MoveAssignable<T1> && MoveAssignable<T2> pair& operator=(pair&& p );
template<class U , class V> requires HasAssign<T1, RvalueOf<U>::type> && HasAssign<T2, RvalueOf<V>::type> pair& operator=(pair<U , V>&& p);
It seems that the functionality of (2) is completely covered by (3), therefore (2) should be removed.
Proposed resolution:
In 20.3.3 [pairs] p. 1, class pair and just before p. 13 remove the declaration:
requires MoveAssignable<T1> && MoveAssignable<T2> pair& operator=(pair&& p );
Section: 20.5.2.1 [tuple.cnstr] Status: New Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2009-03-14
View other active issues in [tuple.cnstr].
View all other issues in [tuple.cnstr].
View all issues with New status.
Discussion:
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. ]
Proposed resolution:
In 20.5.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...>&&);
In 20.5.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.
Section: 20.5.2.6 [tuple.swap] Status: New Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2009-03-14
View all issues with New 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.
Proposed resolution:
In both 20.5.1 [tuple.general]/2 and 20.5.2.7 [tuple.special] change
template <classSwappable... Types> void swap(tuple<Types...>& x, tuple<Types...>& y);
In 20.5.2 [tuple.tuple], class tuple definition and in 20.5.2.6 [tuple.swap], change
requires Swappable<Types>...void swap(tuple&);
In 20.5.2.6 [tuple.swap] remove the current requires-clause, which says:
Requires: Each type in Types shall be Swappable
Section: 23.3.3.5 [forwardlist.ops], 23.3.4.4 [list.ops] Status: New Submitter: Daniel Krügler Opened: 2008-10-06 Last modified: 2008-10-06
View other active issues in [forwardlist.ops].
View all other issues in [forwardlist.ops].
View all issues with New 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.
Proposed resolution:
Replace in 23.3.3.5 [forwardlist.ops] before 11 and in 23.3.4.4 [list.ops] before 15
requiresEqualityComparable<T>HasEqualTo<T, T> void remove(const T& value);
Section: 20.7.15 [func.memfn] Status: New Submitter: Bronek Kozicki Opened: 2008-10-06 Last modified: 2009-03-13
View all issues with New status.
Discussion:
Daniel Krügler wrote:
Shouldn't above list be completed for &- and &&-qualified member functions This would cause to add:
template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) &&); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const &&); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &&); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);
yes, absolutely. Thanks for spotting this. Without this change mem_fn cannot be initialized from pointer to ref-qualified member function. I believe semantics of such function pointer is well defined.
[ Post Summit Daniel provided wording. ]
Proposed resolution:
In 20.7 [function.objects]/2, header <functional> synopsis, just after the section "// 20.6.15, member function adaptors::" add the following declarations to the existing list:
template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) &&); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const &&); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &&); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);
In 20.7.15 [func.memfn] add the following declarations to the existing list:
template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) &&); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const &&); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &&); template<Returnable R, class T, CopyConstructible... Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);
The following text, most notably p.2 and p.3 which discuss influence of the cv-qualification on the definition of the base class's first template parameter remains unchanged.
Section: 20.4.1 [ratio.ratio] Status: Open Submitter: Pablo Halpern Opened: 2008-10-07 Last modified: 2009-03-09
View all issues with Open status.
Discussion:
The compile-time functions that operate on ratio<N,D> require the cumbersome and error-prone "evaluation" of a type member using a meta-programming style that predates the invention of template aliases. Thus, multiplying three ratios a, b, and c requires the expression:
ratio_multiply<a, ratio_multiply<b, c>::type>::type
The simpler expression:
ratio_multiply<a, ratio_multiply<b, c>>
Could be used by if template aliases were employed in the definitions.
[ Post Summit: ]
Jens: not a complete proposed resolution: "would need to make similar change"
Consensus: We agree with the direction of the issue.
Recommend Open.
Proposed resolution:
(based on October, 2008 WP, N2798)
In section 20.4.1 [ratio.ratio], modify the ratio template as follows:
template <intmax_t N, intmax_t D = 1>
class ratio {
public:
typedef ratio type;
static const intmax_t num;
static const intmax_t den;
};
In section 20.4.2 [ratio.arithmetic], modify the template ratio_add as follows:
template <class R1, class R2>structusing ratio_add = see below;{typedef see below} type;};Thenested typedeftype ratio_add<R1,R2> 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.
We would need to make a similar change (struct to using/=) to the synopsis and to each of the other operations described in 20.4.2 [ratio.arithmetic]. Note the addition of type to the ratio template. This typedef allows the previous style to remain valid and permits the use of transitional library implementations for C++03 compilers.
Section: B [implimits] Status: Tentatively Ready Submitter: Sohail Somani Opened: 2008-10-11 Last modified: 2009-03-13
View all issues with Tentatively Ready status.
Discussion:
Addresses DE 24
With respect to the section 20.7.12.1.4 [func.bind.place]:
TR1 dropped some suggested implementation quantities for the number of placeholders. The purpose of this defect is to put these back for C++0x.
[ Post Summit: ]
Original proposed resolution:see DE 24
Recommend applying the proposed resolution from DE 24, with that Tentatively Ready.
Add 20.7.12.1.4 [func.bind.place]/2:
While the exact number of placeholders (_M) is implementation defined, this number shall be at least 10.
Proposed resolution:
Add to B [implimits]:
Section: 29 [atomics] Status: Open Submitter: Herb Sutter Opened: 2008-10-17 Last modified: 2009-05-01
View other active issues in [atomics].
View all other issues in [atomics].
View all issues with Open 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:
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]
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]
Section: 29 [atomics] Status: Open Submitter: Herb Sutter Opened: 2008-10-17 Last modified: 2009-03-22
View other active issues in [atomics].
View all other issues in [atomics].
View all issues with Open 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:
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.
Proposed resolution:
Section: 20.8.13.2.1 [util.smartptr.shared.const] Status: New Submitter: Rodolfo Lima Opened: 2008-10-12 Last modified: 2008-10-19
View other active issues in [util.smartptr.shared.const].
View all other issues in [util.smartptr.shared.const].
View all issues with New status.
Discussion:
The current working draft (N2798), section 20.8.13.2.1 [util.smartptr.shared.const] declares shared_ptr's constructor that takes a rvalue reference to unique_ptr and auto_ptr as being explicit, affecting several valid smart pointer use cases that would take advantage of this conversion being implicit, for example:
class A;
std::unique_ptr<A> create();
void process(std::shared_ptr<A> obj);
int main()
{
process(create()); // use case #1
std::unique_ptr<A> uobj = create();
process(std::move(uobj)); // use case #2
return 0;
}
If unique_ptr to shared_ptr conversions are explicit, the above lines should be written:
process(std::shared_ptr<A>(create())); // use case #1 process(std::shared_ptr<A>(std::move(uobj))); // use case #2
The extra cast required doesn't seems to give any benefits to the user, nor protects him of any unintended conversions, this being the raison d'etre of explicit constructors.
It seems that this constructor was made explicit to mimic the conversion from auto_ptr in pre-rvalue reference days, which accepts both lvalue and rvalue references. Although this decision was valid back then, C++0x allows the user to express in a clear and non verbose manner when he wants move semantics to be employed, be it implicitly (use case 1) or explicitly (use case 2).
Proposed resolution:
In both 20.8.13.2 [util.smartptr.shared] paragraph 1 and 20.8.13.2.1 [util.smartptr.shared.const] change:
template <class Y>explicitshared_ptr(auto_ptr<Y> &&r); template <class Y, class D>explicitshared_ptr(unique_ptr<Y, D> &&r);
Section: 29.3 [atomics.order] Status: Open Submitter: Anthony Williams Opened: 2008-10-19 Last modified: 2009-03-22
View all other issues in [atomics.order].
View all issues with Open 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.
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.
Section: 20.8.2.2 [allocator.concepts] Status: New Submitter: Pablo Halpern Opened: 2008-10-23 Last modified: 2009-02-14
View all issues with New status.
Discussion:
20.8.2.2 [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.
Proposed resolution:
Change all uses of the concept Dereferenceable to HasDereference in 20.8.2.2 [allocator.concepts].
Section: 20.5.2.5 [tuple.rel] Status: Tentatively Ready Submitter: Joe Gottman Opened: 2008-10-28 Last modified: 2009-03-09
View all other issues in [tuple.rel].
View all issues with Tentatively Ready 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.5.1 [tuple.general] and 20.5.2.5 [tuple.rel] change:
template<class... TTypes, class... UTypes> requiresEqualityComparableHasEqualTo<TTypes, UTypes>... bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&); template<class... TTypes, class... UTypes> requiresLessThanComparableHasLess<TTypes, UTypes>... && HasLess<UTypes, TTypes>... bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&); template<class... TTypes, class... UTypes> requiresEqualityComparableHasEqualTo<TTypes, UTypes>... bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&); template<class... TTypes, class... UTypes> requiresLessThanComparableHasLess<UTTypes,TUTypes>... && HasLess<UTypes, TTypes>... bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&); template<class... TTypes, class... UTypes> requiresLessThanComparableHasLess<UTTypes,TUTypes>... && HasLess<UTypes, TTypes>... bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&); template<class... TTypes, class... UTypes> requiresLessThanComparableHasLess<TTypes, UTypes>... && HasLess<UTypes, TTypes>... bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);
Section: 30.3.1.2 [thread.thread.constr] Status: Review Submitter: Anthony Williams Opened: 2008-10-23 Last modified: 2009-03-13
View other active issues in [thread.thread.constr].
View all other issues in [thread.thread.constr].
View all issues with Review status.
Discussion:
Addresses UK 323
The thread constructor for starting a new thread with a function and arguments is overly constrained by the signature requiring rvalue references for func and args and the CopyConstructible requirements for the elements of args. The use of an rvalue reference for the function restricts the potential use of a plain function name, since the type of the bound parameter will be deduced to be a function reference and decay to pointer-to-function will not happen. This therefore complicates the implementation in order to handle a simple case. Furthermore, the use of rvalue references for args prevents the array to pointer decay. Since arrays are not CopyConstructible or even MoveConstructible, this essentially prevents the passing of arrays as parameters. In particular it prevents the passing of string literals. Consequently a simple case such as
void f(const char*); std::thread t(f,"hello");
is ill-formed since the type of the string literal is const char[6].
By changing the signature to take all parameters by value we can eliminate the CopyConstructible requirement and permit the use of arrays, as the parameter passing semantics will cause the necessary array-to-pointer decay. They will also cause the function name to decay to a pointer to function and allow the implementation to handle functions and function objects identically.
The new signature of the thread constructor for a function and arguments is thus:
template<typename F,typename... Args> thread(F,Args... args);
Since the parameter pack Args can be empty, the single-parameter constructor that takes just a function by value is now redundant.
[ Howard adds: ]
I agree with everything Anthony says in this issue. However I believe we can optimize in such a way as to get the pass-by-value behavior with the pass-by-rvalue-ref performance. The performance difference is that the latter removes a move when passing in an lvalue.
This circumstance is very analogous to make_pair (20.3.3 [pairs]) where we started with passing by const reference, changed to pass by value to get pointer decay, and then changed to pass by rvalue reference, but modified with decay<T> to retain the pass-by-value behavior. If we were to apply the same solution here it would look like:
template <class F> explicit thread(F f);template <class F, class ...Args> thread(F&& f, Args&&... args);-4- Requires: F and each Ti in Args shall be
CopyConstructible if an lvalue and otherwiseMoveConstructible. INVOKE(f, w1, w2, ..., wN) (20.7.2 [func.require]) shall be a valid expression for some values w1, w2, ... , wN, where N == sizeof...(Args).-5- Effects: Constructs an object of type thread
and executes INVOKE(f, t1, t2, ..., tN) in a new thread of execution, where t1, t2, ..., tN are the values in args.... Constructs the following objects in memory which is accessible to a new thread of execution as if:typename decay<F>::type g(std::forward<F>(f)); tuple<typename decay<Args>::type...> w(std::forward<Args>(args)...);The new thread of execution executes INVOKE(g, wi...) where the wi... refers to the elements stored in the tuple w. Any return value from g is ignored.
If f terminates with an uncaught exception, std::terminate() shall be called.If the evaluation of INVOKE(g, wi...) terminates with an uncaught exception, std::terminate() shall be called [Note: std::terminate() could be called before entering g. -- end note]. Any exception thrown before the evaluation of INVOKE has started shall be catchable in the calling thread.Text referring to when terminate() is called was contributed by Ganesh.
Proposed resolution:
Modify the class definition of std::thread in 30.3.1 [thread.thread.class] to remove the following signature:
template<class F> explicit thread(F f);template<class F, class ... Args> explicit thread(F&& f, Args&& ... args);
Modify 30.3.1.2 [thread.thread.constr] to replace the constructors prior to paragraph 4 with the single constructor as above. Replace paragraph 4 - 6 with the following:
-4- Requires: F and each Ti in Args shall be
CopyConstructible if an lvalue and otherwiseMoveConstructible. INVOKE(f, w1, w2, ..., wN) (20.7.2 [func.require]) shall be a valid expression for some values w1, w2, ... , wN, where N == sizeof...(Args).-5- Effects: Constructs an object of type thread
and executes INVOKE(f, t1, t2, ..., tN) in a new thread of execution, where t1, t2, ..., tN are the values in args.... Constructs the following objects:typename decay<F>::type g(std::forward<F>(f)); tuple<typename decay<Args>::type...> w(std::forward<Args>(args)...);and executes INVOKE(g, wi...) in a new thread of execution. These objects shall be destroyed when the new thread of execution completes. Any return value from g is ignored.
If f terminates with an uncaught exception, std::terminate() shall be called.If the evaluation of INVOKE(g, wi...) terminates with an uncaught exception, std::terminate() shall be called [Note: std::terminate() could be called before entering g. -- end note]. Any exception thrown before the evaluation of INVOKE has started shall be catchable in the calling thread.-6- Synchronization: The invocation of the constructor happens before the invocation of
fg.
Section: 23.3.1 [array] Status: Open Submitter: Niels Dekker Opened: 2008-11-17 Last modified: 2009-05-01
View other active issues in [array].
View all other issues in [array].
View all issues with Open 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;
- 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:
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 conversionRecommended 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. ]
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.
Add to Zero sized arrays 23.3.1.6 [array.zero]:
4. The presence of c_array_type and c_array() and their semantics are implementation defined, for a zero-sized array.
Section: 20.6.4.3 [meta.unary.prop] Status: Tentatively Ready Submitter: Yechezkel Mett Opened: 2008-11-04 Last modified: 2009-03-09
View other active issues in [meta.unary.prop].
View all other issues in [meta.unary.prop].
View all issues with Tentatively Ready status.
Discussion:
The draft (N2798) says in 20.6.4.3 [meta.unary.prop] Table 44:
Table 44 -- Type property queries Template Value template <class T, unsigned I = 0> struct extent; If T is not an array type (8.3.4), or if it has rank less than I, or if I is 0 and T has type "array of unknown bound of U", then 0; otherwise, the size of the I'th dimension of T
Firstly it isn't clear from the wording if I is 0-based or 1-based ("the I'th dimension" sort of implies 1-based). From the following example it is clear that the intent is 0-based, in which case it should say "or if it has rank less than or equal to I".
Sanity check:
The example says assert((extent<int[2], 1>::value) == 0);
Here the rank is 1 and I is 1, but the desired result is 0.
[ Post Summit: ]
Do not use "size" or "value", use "bound". Also, move the cross-reference to 8.3.4 to just after "bound".
Recommend Tentatively Ready.
Proposed resolution:
In Table 44 of 20.6.4.3 [meta.unary.prop], third row, column "Value", change the cell content:
Table 44 -- Type property queries Template Value template <class T, unsigned I = 0> struct extent; If T is not an array type (8.3.4), or if it has rank less than or equal to I, or if I is 0 and T has type "array of unknown bound of U", then 0; otherwise, thesizebound (8.3.4) of the I'th dimension of T, where indexing of I is zero-based.
[ Wording supplied by Daniel. ]
Section: 20.8.12.2.1 [unique.ptr.single.ctor] Status: Tentatively Ready Submitter: Howard Hinnant Opened: 2008-11-26 Last modified: 2009-03-12
View other active issues in [unique.ptr.single.ctor].
View all other issues in [unique.ptr.single.ctor].
View all issues with Tentatively Ready status.
Discussion:
Addresses US 79
20.8.12.2.1 [unique.ptr.single.ctor]/5 no longer requires for D not to be a pointer type. I believe this restriction was accidently removed when we relaxed the completeness reuqirements on T. The restriction needs to be put back in. Otherwise we have a run time failure that could have been caught at compile time:
{
unique_ptr<int, void(*)(void*)> p1(malloc(sizeof(int))); // should not compile
} // p1.~unique_ptr() dereferences a null function pointer
unique_ptr<int, void(*)(void*)> p2(malloc(sizeof(int)), free); // ok
[ Post Summit: ]
Recommend Tentatively Ready.
Proposed resolution:
Change 20.8.12.2.1 [unique.ptr.single.ctor]/5:
unique_ptr(pointer p);Requires: D shall not be a pointer type (diagnostic required). D shall be default constructible, and that construction shall not throw an exception.
Section: 20.8.12.2.5 [unique.ptr.single.modifiers] Status: New Submitter: Alisdair Meredith Opened: 2008-11-27 Last modified: 2008-12-03
View other active issues in [unique.ptr.single.modifiers].
View all other issues in [unique.ptr.single.modifiers].
View all issues with New 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 uncomfortable like the two constructors I have been ignoring for now...
Proposed resolution:
Section: 20.9.3 [time.duration] Status: Review Submitter: Terry Golubiewski Opened: 2008-11-30 Last modified: 2009-03-12
View all issues with Review status.
Discussion:
Addresses US 81
duration is missing operator%. This operator is convenient for computing where in a time frame a given duration lies. A motivating example is converting a duration into a "broken-down" time duration such as hours::minutes::seconds:
class ClockTime
{
typedef std::chrono::hours hours;
typedef std::chrono::minutes minutes;
typedef std::chrono::seconds seconds;
public:
hours hours_;
minutes minutes_;
seconds seconds_;
template <class Rep, class Period>
explicit ClockTime(const std::chrono::duration<Rep, Period>& d)
: hours_ (std::chrono::duration_cast<hours> (d)),
minutes_(std::chrono::duration_cast<minutes>(d % hours(1))),
seconds_(std::chrono::duration_cast<seconds>(d % minutes(1)))
{}
};
[ Summit: ]
Agree except that there is a typo in the proposed resolution. The member operators should be operator%=.
Proposed resolution:
Add to the synopsis in 20.9 [time]:
template <class Rep1, class Period, class Rep2> duration<typename common_type<Rep1, Rep2>::type, Period> operator%(const duration<Rep1, Period>& d, const Rep2& s); template <class Rep1, class Period1, class Rep2, class Period2> typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
Add to the synopsis of duration in 20.9.3 [time.duration]:
template <class Rep, class Period = ratio<1>>
class duration {
public:
...
duration& operator%=(const rep& rhs);
duration& operator%=(const duration& d);
...
};
Add to 20.9.3.3 [time.duration.arithmetic]:
duration& operator%=(const rep& rhs);Effects: rep_ %= rhs.
Returns: *this.
duration& operator%=(const duration& d);Effects: rep_ %= d.count().
Returns: *this.
Add to 20.9.3.5 [time.duration.nonmember]:
template <class Rep1, class Period, class Rep2> duration<typename common_type<Rep1, Rep2>::type, Period> operator%(const duration<Rep1, Period>& d, const Rep2& s);Requires: Rep2 shall be implicitly convertible to CR(Rep1, Rep2) and Rep2 shall not be an instantiation of duration. Diagnostic required.
Returns: duration<CR, Period>(d) %= s.
template <class Rep1, class Period1, class Rep2, class Period2> typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);Returns: common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type(lhs) %= rhs.
Section: 20.9.5 [time.clock] Status: New Submitter: Beman Dawes Opened: 2008-11-24 Last modified: 2009-02-05
View all issues with New status.
Discussion:
Each of the three clocks specified in Clocks 20.9.5 [time.clock] provides the member function:
static time_point now();
The semantics specified by Clock requirements 20.9.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.10 [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.
Proposed resolution:
Accept the proposed wording of N2828, Library Support for hybrid error handling (Rev 1).
Change Clock requirements 20.9.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.2 [syserr.errcode.overview]).
Table 55 -- Clock requirements Expression Return type Operational semantics ... ... ... C1::now() C1::time_point Returns a time_point object representing the current point in time. C1::now(ec) C1::time_point Returns a time_point object representing the current point in time.
Change Class system_clock 20.9.5.1 [time.clock.system] as indicated:
static time_point now(error_code& ec=throws());
Change Class monotonic_clock 20.9.5.2 [time.clock.monotonic] as indicated:
static time_point now(error_code& ec=throws());
Change Class high_resolution_clock 20.9.5.3 [time.clock.hires] as indicated:
static time_point now(error_code& ec=throws());
Section: 30.4.1 [thread.mutex.requirements] Status: Open Submitter: Pete Becker Opened: 2008-12-05 Last modified: 2009-03-22
View other active issues in [thread.mutex.requirements].
View all other issues in [thread.mutex.requirements].
View all issues with Open status.
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.3 [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.
- The intention is not only to place a constraint on what types such as lock_guard may do with mutex types, but on what any code, including user code, may do with mutex types. Thus the constraints as they are apply to the mutex types themselves, not the current users of mutex types in the standard.
- This is a low priority issue; the wording as it is may be overly restrictive but this may not be a real issue.
[ 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:
Section: 20.8.12.1.2 [unique.ptr.dltr.dflt1] Status: Review Submitter: Howard Hinnant Opened: 2008-12-07 Last modified: 2009-03-10
View all issues with Review status.
Discussion:
Consider:
derived* p = new derived[3]; std::default_delete<base[]> d; d(p); // should fail
Currently the marked line is a run time failure. We can make it a compile time failure by "poisoning" op(U*).
[ Post Summit: ]
Recommend Review.
Proposed resolution:
Add to 20.8.12.1.2 [unique.ptr.dltr.dflt1]:
namespace std {
template <class T> struct default_delete<T[]> {
void operator()(T*) const;
template <class U> void operator()(U*) const = delete;
};
}
Section: 20.7.6 [identity.operation] Status: New Submitter: Alisdair Meredith Opened: 2008-12-11 Last modified: 2008-12-14
View all issues with New status.
Discussion:
std::indentity takes an argument of type T const & and returns a result of T const &.
Unfortunately, this signature will accept a value of type other than T that is convertible-to-T, and then return a reference to the dead temporary. The constraint in the concepts version simply protects against returning reference-to-void.
Solutions:
i/ Return-by-value, potentially slicing bases and rejecting non-copyable types
ii/ Provide an additional overload:
template< typename T > template operator( U & ) = delete;This seems closer on intent, but moves beyond the original motivation for the operator, which is compatibility with existing (non-standard) implementations.
iii/ Remove the operator() overload. This restores the original definition of the identity, although now effectively a type_trait rather than part of the perfect forwarding protocol.
iv/ Remove std::identity completely, it's original reason to exist is replaced with the IdentityOf concept.
My own preference is somewhere between (ii) and (iii) - although I stumbled over the issue with a specific application hoping for resolution (i)!
Proposed resolution:
Section: 24.4 [iterator.operations] Status: Review Submitter: Thomas Opened: 2008-12-14 Last modified: 2009-03-13
View other active issues in [iterator.operations].
View all other issues in [iterator.operations].
View all issues with Review status.
Discussion:
Addresses UK 270
Regarding the std::distance - function, 24.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 [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 [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 24.2 [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 [iterator.operations] p4 as follows:
Effects: Returns the number of incrementsor decrementsneeded 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.
Proposed resolution:
Change 24.4 [iterator.operations]:
template <InputIterator Iter> Iter::difference_type distance(Iter first, Iter last);template <RandomAccessIterator Iter> Iter::difference_type distance(Iter first, Iter last);-4- Effects: Returns the number of increments
or decrementsneeded to get from first to last.-5- Requires: last shall be reachable from first.
template <RandomAccessIterator Iter> Iter::difference_type distance(Iter first, Iter last);-6- Effects: Returns the number of increments or decrements needed to get from first to last.
-7- Requires: last shall be reachable from first or first shall be reachable from last.
Section: 17 [library] Status: New Submitter: Niels Dekker Opened: 2008-12-18 Last modified: 2009-02-02
View other active issues in [library].
View all other issues in [library].
View all issues with New 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.
Proposed resolution:
A proposed resolution is provided by the paper on this subject, N2819, Ref-qualifiers for assignment operators of the Standard Library
Section: 29.5.2 [atomics.types.address] Status: Review Submitter: Holger Grund Opened: 2008-12-19 Last modified: 2009-03-22
View all issues with Review status.
Discussion:
There is a row in "Table 122 - Atomics for standard typedef types" in 29.5.1 [atomics.types.integral] with atomic_ssize_t and ssize_t. Unless, I'm missing something ssize_t is not defined by the standard.
[ Summit: ]
Move to review. Proposed resolution: Remove the typedef. Note: ssize_t is a POSIX type.
Proposed resolution:
Remove the row containing ssize_t from Table 119 "Atomics for standard typedef types" in 29.5.2 [atomics.types.address].
Section: 29.5.3 [atomics.types.generic] Status: Open Submitter: Holger Grund Opened: 2008-12-19 Last modified: 2009-03-22
View all other issues in [atomics.types.generic].
View all issues with Open 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.3 [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. ]
Proposed resolution:
Replace paragraph 3 in 29.5.3 [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.
Section: 20.9.5.1 [time.clock.system] Status: New Submitter: Pete Becker Opened: 2008-12-19 Last modified: 2009-03-11
View other active issues in [time.clock.system].
View all other issues in [time.clock.system].
View all issues with New status.
Discussion:
In 20.9.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].?
Proposed resolution:
Add a note to 20.9.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].
Section: 20.9.3.7 [time.duration.cast] Status: New Submitter: Pete Becker Opened: 2008-12-20 Last modified: 2008-12-22
View other active issues in [time.duration.cast].
View all other issues in [time.duration.cast].
View all issues with New status.
Discussion:
20.9.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.
[ Howard adds: ]
The intent of this remark is that intermediate computations are carried out using:
common_type<typename ToDuration::rep, Rep, intmax_t>::typeThe 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?
Proposed resolution:
Section: 20.9.3.5 [time.duration.nonmember] Status: New Submitter: Pete Becker Opened: 2008-12-20 Last modified: 2009-01-20
View all other issues in [time.duration.nonmember].
View all issues with New status.
Discussion:
In 20.9.3.5 [time.duration.nonmember], paragraph 8 says that calling dur / rep when rep is an instantiation of duration requires a diagnostic. That's followed by an operator/ that takes two durations. So dur1 / dur2 is legal under the second version, but requires a diagnostic under the first.
[ Howard adds: ]
Please see the thread starting with c++std-lib-22980 for more information.
Proposed resolution:
Section: 20.4.2 [ratio.arithmetic] Status: Tentatively Ready Submitter: Howard Hinnant Opened: 2008-12-26 Last modified: 2009-03-09
View all issues with Tentatively Ready status.
Discussion:
N2800, 20.4.2 [ratio.arithmetic] lacks a paragraph from the proposal N2661:
ratio arithmetic [ratio.arithmetic]
... If the implementation is unable to form the indicated ratio due to overflow, a diagnostic shall be issued.
The lack of a diagnostic on compile-time overflow is a significant lack of functionality. This paragraph could be put back into the WP simply editorially. However in forming this issue I realized that we can do better than that. This paragraph should also allow alternative formulations which go to extra lengths to avoid overflow when possible. I.e. we should not mandate overflow when the implementation can avoid it.
For example:
template <class R1, class R2> struct ratio_multiply { typedef see below} type;The nested typedef type shall be a synonym for ratio<T1, T2> where T1 has the value R1::num * R2::num and T2 has the value R1::den * R2::den.
Consider the case where intmax_t is a 64 bit 2's complement signed integer, and we have:
typedef std::ratio<0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF0> R1; typedef std::ratio<8, 7> R2; typedef std::ratio_multiply<R1, R2>::type RT;
According to the present formulation the implementaiton will multiply 0x7FFFFFFFFFFFFFFF * 8 which will result in an overflow and subsequently require a diagnostic.
However if the implementation is first allowed to divde 0x7FFFFFFFFFFFFFFF by 7 obtaining 0x1249249249249249 / 1 and divide 8 by 0x7FFFFFFFFFFFFFF0 obtaining 1 / 0x0FFFFFFFFFFFFFFE, then the exact result can then be computed without overflow:
[0x7FFFFFFFFFFFFFFF/0x7FFFFFFFFFFFFFF0] * [8/7] = [0x1249249249249249/0x0FFFFFFFFFFFFFFE]
Example implmentation which accomplishes this:
template <class R1, class R2>
struct ratio_multiply
{
private:
typedef ratio<R1::num, R2::den> _R3;
typedef ratio<R2::num, R1::den> _R4;
public:
typedef ratio<__ll_mul<_R3::num, _R4::num>::value,
__ll_mul<_R3::den, _R4::den>::value> type;
};
[ Post Summit: ]
Recommend Tentatively Ready.
Proposed resolution:
Add a paragraph prior to p1 in 20.4.2 [ratio.arithmetic]:
Implementations may use other algorithms to compute the indicated ratios to avoid overflow. If overflow occurs, a diagnostic shall be issued.
Section: 20.8.13.4 [util.smartptr.ownerless] Status: Tentatively Ready Submitter: Thomas Plum Opened: 2008-12-30 Last modified: 2009-03-10
View all issues with Tentatively Ready status.
Discussion:
20.8.13.4 [util.smartptr.ownerless] (class template owner_less) says that operator()(x,y) shall return x.before(y).
However, shared_ptr and weak_ptr have an owner_before() but not a before(), and there's no base class to provide a missing before().
Being that the class is named owner_less , I'm guessing that "before()" should be "owner_before()", right?
[ Herve adds: ]
Agreed with the typo, it should be "shall return x.owner_before(y)".
[ Post Summit: ]
Recommend Tentatively Ready.
Proposed resolution:
Change 20.8.13.4 [util.smartptr.ownerless] p2:
-2- operator()(x,y) shall return x.owner_before(y). [Note: ...
Section: 20.8.12.2.1 [unique.ptr.single.ctor] Status: Review Submitter: Howard Hinnant Opened: 2009-01-07 Last modified: 2009-03-10
View other active issues in [unique.ptr.single.ctor].
View all other issues in [unique.ptr.single.ctor].
View all issues with Review status.
Discussion:
unique_ptr's of array type should not convert to unique_ptr's which do not have an array type.
struct Deleter
{
void operator()(void*) {}
};
int main()
{
unique_ptr<int[], Deleter> s;
unique_ptr<int, Deleter> s2(std::move(s)); // should not compile
}
[ Post Summit: ]
Walter: Does the "diagnostic required" apply to both arms of the "and"?
Tom Plum: suggest to break into several sentences
Walter: suggest "comma" before the "and" in both places
Recommend Review.
Proposed resolution:
Change 20.8.12.2.1 [unique.ptr.single.ctor]:
template <class U, class E> unique_ptr(unique_ptr<U, E>&& u);-20- Requires: If D is not a reference type, construction of the deleter D from an rvalue of type E shall be well formed and shall not throw an exception. If D is a reference type, then E shall be the same type as D (diagnostic required). unique_ptr<U, E>::pointer shall be implicitly convertible to pointer (diagnostic required). U shall not be an array type (diagnostic required). [Note: These requirements imply that T and U are complete types. -- end note]
Change 20.8.12.2.3 [unique.ptr.single.asgn]:
template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u);-6- Requires: Assignment of the deleter D from an rvalue D shall not throw an exception. unique_ptr<U, E>::pointer shall be implicitly convertible to pointer (diagnostic required). U shall not be an array type (diagnostic required). [Note: These requirements imply that T and U are complete types. -- end note]
Section: 20.9.2.1 [time.traits.is_fp] Status: New Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-01-19
View all issues with New status.
Discussion:
20.9.2.1 [time.traits.is_fp] says that the type Rep "is assumed to be ... a class emulating an integral type." What are the requirements for such a type?
Proposed resolution:
Section: 20.9.3.7 [time.duration.cast] Status: New Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-01-19
View other active issues in [time.duration.cast].
View all other issues in [time.duration.cast].
View all issues with New status.
Discussion:
20.9.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.
Proposed resolution:
Section: 20.9.1 [time.clock.req] Status: New Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-01-19
View other active issues in [time.clock.req].
View all other issues in [time.clock.req].
View all issues with New status.
Discussion:
20.9.1 [time.clock.req] says that a clock's rep member is "an arithmetic type or a class emulating an arithmetic type." What are the requirements for such a type?
Proposed resolution:
Section: 20.9.1 [time.clock.req] Status: New Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-01-19
View other active issues in [time.clock.req].
View all other issues in [time.clock.req].
View all issues with New status.
Discussion:
Table 55 -- Clock Requirements (in 20.9.1 [time.clock.req])
Proposed resolution:
Section: 20.9.1 [time.clock.req] Status: New Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-11
View other active issues in [time.clock.req].
View all other issues in [time.clock.req].
View all issues with New status.
Discussion:
20.9.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. ]
Proposed resolution:
Change 20.9 [time]:
... template <class Clock, class Duration = typename Clock::duration_type> class time_point; ...
Change 20.9.1 [time.clock.req]:
Table 45 -- Clock requirements Expression Return type Operational semantics ... ... ... C1::duration_type chrono::duration<C1::rep, C1::period> The native duration type of the clock. C1::time_point_type chrono::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_type Returns a time_point_type object representing the current point in time.
Change 20.9.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 20.9.5.2 [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.9.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();
};
Section: 20.9.1 [time.clock.req] Status: New Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-01-19
View other active issues in [time.clock.req].
View all other issues in [time.clock.req].
View all issues with New status.
Discussion:
20.9.1 [time.clock.req] uses the word "native" in several places, but doesn't define it. What is a "native duration"?
Proposed resolution:
Section: 20.9.5.1 [time.clock.system] Status: New Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-11
View other active issues in [time.clock.system].
View all other issues in [time.clock.system].
View all issues with New status.
Discussion:
20.9.5.1 [time.clock.system]: to_time_t is overspecified. It requires truncation, but should allow rounding. For example, suppose a system has a clock that gives times in milliseconds, but time() rounds those times to the nearest second. Then system_clock can't use any resolution finer than one second, because if it did, truncating times between half a second and a full second would produce the wrong time_t value.
[ Post Summit Anthony Williams provided proposed wording. ]
Proposed resolution:
In 20.9.5.1 [time.clock.system] replace paragraphs 3 and 4 with:
time_t to_time_t(const time_point& t);-3- Returns: A time_t object that represents the same point in time as t when both values aretruncatedrestricted to the coarser of the precisions of time_t and time_point. It is implementation defined whether values are rounded or truncated to the required precision.time_point from_time_t(time_t t);-4- Returns: A time_point object that represents the same point in time as t when both values aretruncatedrestricted to the coarser of the precisions of time_t and time_point. It is implementation defined whether values are rounded or truncated to the required precision.
Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22
View other active issues in [thread.condition.condvar].
View all other issues in [thread.condition.condvar].
View all issues with Open 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.
Proposed resolution:
Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22
View other active issues in [thread.condition.condvar].
View all other issues in [thread.condition.condvar].
View all issues with Open 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.
Proposed resolution:
Section: 30.4.1 [thread.mutex.requirements] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-27
View other active issues in [thread.mutex.requirements].
View all other issues in [thread.mutex.requirements].
View all issues with Open status.
Discussion:
30.4.1 [thread.mutex.requirements]: paragraph 4 is entitled "Error conditions", but according to 17.5.1.4 [structure.specifications], "Error conditions:" specifies "the error conditions for error codes reported by the function." It's not clear what this should mean when there is no function in sight.
[ Summit: ]
Move to open.
[ Beman provided proposed wording. ]
Proposed resolution:
Change 30.4.1 [thread.mutex.requirements] Mutex requirements, paragraph 4 as indicated:
-4-
Error conditions:The error conditions for error codes, if any, reported by member functions of type Mutex shall be:
- not_enough_memory -- if there is not enough memory to construct the mutex object.
- resource_unavailable_try_again -- if any native handle type manipulated is not available.
- operation_not_permitted -- if the thread does not have the necessary permission to change the state of the mutex object.
- device_or_resource_busy -- if any native handle type manipulated is already locked.
- invalid_argument -- if any native handle type manipulated as part of mutex construction is incorrect.
Section: 30.4.1 [thread.mutex.requirements] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22
View other active issues in [thread.mutex.requirements].
View all other issues in [thread.mutex.requirements].
View all issues with Open status.
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.
Proposed resolution:
Section: 30.4.3.2.2 [thread.lock.unique.locking] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22
View all issues with Open status.
Discussion:
30.4.3.2.2 [thread.lock.unique.locking]: unique_lock::lock is required to throw an object of type std::system_error "when the postcondition cannot be achieved." The postcondition is owns == true, and this is trivial to achieve. Presumably, the requirement is intended to mean something more than that.
[ Summit: ]
Move to open.
[ Beman has volunteered to provide proposed wording. ]
Proposed resolution:
Section: 30.3.1.5 [thread.thread.member] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22
View other active issues in [thread.thread.member].
View all other issues in [thread.thread.member].
View all issues with Open status.
Discussion:
30.3.1.5 [thread.thread.member]: thread::detach is required to throw an exception if the thread is "not a detachable thread". "Detachable" is never defined.
[ Howard adds: ]
Due to a mistake on my part, 3 proposed resolutions appeared at approximately the same time. They are all three noted below in the discussion.
[ Summit, proposed resolution: ]
In 30.3.1.5 [thread.thread.member] change:
void detach();...
-14- Error conditions:
- no_such_process -- if the thread is not
avalidthread.- invalid_argument -- if the thread is not
a detachablejoinablethread.
[ Post Summit, Jonathan Wakely adds: ]
A thread is detachable if it is joinable. As we've defined joinable, we can just use that.
This corresponds to the pthreads specification, where pthread_detach fails if the thread is not joinable:
EINVAL: The implementation has detected that the value specified by thread does not refer to a joinable thread.Jonathan recommends this proposed wording:
In 30.3.1.5 [thread.thread.member] change:
void detach();...
-14- Error conditions:
- ...
- invalid_argument -- not a
detachablejoinable thread.
[ Post Summit, Anthony Williams adds: ]
This is covered by the precondition that joinable() be true.
Anthony recommends this proposed wording:
In 30.3.1.5 [thread.thread.member] change:
void detach();...
-14- Error conditions:
- ...
invalid_argument -- not a detachable thread.
Proposed resolution:
Section: 30.5.2 [thread.condition.condvarany] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22
View all issues with Open status.
Discussion:
The requirements for the constructor for condition_variable has several error conditions, but the requirements for the constructor for condition_variable_any has none. Is this difference intentional?
[ Summit: ]
Move to open, pass to Howard. If this is intentional, a note may be helpful. If the error conditions are to be copied from condition_variable, this depends on LWG 965.
[ Post Summit Howard adds: ]
The original intention (N2447) was to let the OS return whatever errors it was going to return, and for those to be translated into exceptions, for both condition_variable and condition_variable_any. I have not received any complaints about specific error conditions from vendors on non-POSIX platforms, but such complaints would not surprise me if they surfaced.
Proposed resolution:
Section: 30.5.1 [thread.condition.condvar] Status: Review Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22
View other active issues in [thread.condition.condvar].
View all other issues in [thread.condition.condvar].
View all issues with Review status.
Discussion:
30.5.1 [thread.condition.condvar]: the constructor for condition_variable throws an exception with error code device_or_resource_busy "if attempting to initialize a previously-initialized but as of yet undestroyed condition_variable." How can this occur?
[ Summit: ]
Move to review. Proposed resolution: strike the device_or_resource_busy error condition from the constructor of condition_variable.
- This is a POSIX error that cannot occur in this interface because the C++ interface does not separate declaration from initialization.
Proposed resolution:
Change 30.5.1 [thread.condition.condvar] p3:
- ...
device_or_resource_busy -- if attempting to initialize a previously-initialized but as of yet undestroyed condition_variable.
Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22
View other active issues in [thread.condition.condvar].
View all other issues in [thread.condition.condvar].
View all issues with Open status.
Discussion:
30.5.1 [thread.condition.condvar]: condition_variable::wait and condition_variable::wait_until both have a postcondition that lock is locked by the calling thread, and a throws clause that requires throwing an exception if this postcondition cannot be achieved. How can the implementation detect that this lock can never be obtained?
[ Summit: ]
Move to open. Requires wording. Agreed this is an issue, and the specification should not require detecting deadlocks.
Proposed resolution:
Section: 30.3.1.2 [thread.thread.constr] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22
View other active issues in [thread.thread.constr].
View all other issues in [thread.thread.constr].
View all issues with Open status.
Discussion:
the error handling for the constructor for condition_variable distinguishes lack of memory from lack of other resources, but the error handling for the thread constructor does not. Is this difference intentional?
[ Beman has volunteered to provide proposed wording. ]
Proposed resolution:
Section: 30.4.1 [thread.mutex.requirements] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22
View other active issues in [thread.mutex.requirements].
View all other issues in [thread.mutex.requirements].
View all issues with Open status.
Discussion:
30.4.1 [thread.mutex.requirements]: several functions are required to throw exceptions "if the thread does not have the necessary permission ...". "The necessary permission" is not defined.
[ Summit: ]
Move to open.
[ Beman has volunteered to provide proposed wording. ]
Proposed resolution:
Section: 25.3.4 [alg.foreach] Status: New Submitter: Stephan T. Lavavej Opened: 2009-01-12 Last modified: 2009-01-20
View other active issues in [alg.foreach].
View all other issues in [alg.foreach].
View all issues with New status.
Discussion:
Library Issue 475 has CD1 status, but the non-normative note in N2723 was removed in N2798 (25.3.4 [alg.foreach] in both drafts).
Proposed resolution:
Restore the non-normative note. It might need to be expressed in terms of concepts.
Section: 20.8.11.1 [object.addressof] Status: Review Submitter: Howard Hinnant Opened: 2009-01-16 Last modified: 2009-03-10
View other active issues in [object.addressof].
View all other issues in [object.addressof].
View all issues with Review status.
Discussion:
20.8.11.1 [object.addressof] specifies:
template <ObjectType T> T* addressof(T& r); template <ObjectType T> T* addressof(T&& r);
The two signatures are ambiguous when the argument is an lvalue. The second signature seems not useful: what does it mean to take the address of an rvalue?
[ Post Summit: ]
Recommend Review.
Proposed resolution:
Change 20.8.11.1 [object.addressof]:
template <ObjectType T> T* addressof(T& r);template <ObjectType T> T* addressof(T&& r);
Section: 19.5.2.6 [syserr.errcode.nonmembers] Status: Review Submitter: Beman Dawes Opened: 2009-01-19 Last modified: 2009-03-09
View all issues with Review 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.
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.6 [syserr.errcode.nonmembers]:
error_code make_error_code(errc e);Returns: error_code(static_cast<int>(e), generic_category).
Section: 17 [library] Status: New Submitter: Niels Dekker Opened: 2009-01-07 Last modified: 2009-01-22
View other active issues in [library].
View all other issues in [library].
View all issues with New 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"?
Proposed resolution:
Change Exception Propagation 18.8.5 [propagation]:
exception_ptr shall be DefaultConstructible, CopyConstructible, CopyAssignable and EqualityComparable.
Change Class template reference_wrapper 20.7.5 [refwrap]:
reference_wrapper<T> is a CopyConstructible and CopyAssignable wrapper around a reference to an object of type T.
Change Placeholders 20.7.12.1.4 [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.8.13.2 [util.smartptr.shared]:
Specializations of shared_ptr shall be CopyConstructible, CopyAssignable, and LessThanComparable...
Change Class template weak_ptr 20.8.13.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.9.1 [auto.ptr], as this is dealt with more specifically by LWG 973, "auto_ptr characteristics", submitted by Maarten Hilferink.
Section: D.9.1 [auto.ptr] Status: New Submitter: Maarten Hilferink Opened: 2009-01-21 Last modified: 2009-01-21
View other active issues in [auto.ptr].
View all other issues in [auto.ptr].
View all issues with New status.
Discussion:
I think that the Note of D.9.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.
Proposed resolution:
Change D.9.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]
Section: 20.9.3.1 [time.duration.cons] Status: New Submitter: Howard Hinnant Opened: 2009-01-21 Last modified: 2009-01-21
View all issues with New status.
Discussion:
The following code should not compile because it involves implicit truncation errors (against the design philosophy of the duration library).
duration<double> d(3.5); duration<int> i = d; // implicit truncation, should not compile
This intent was codified in the example implementation which drove this proposal but I failed to accurately translate the code into the specification in this regard.
Proposed resolution:
Change 20.9.3.1 [time.duration.cons], p4:
template <class Rep2, class Period2> duration(const duration<Rep2, Period2>& d);-4- Requires: treat_as_floating_point<rep>::value shall be true or both ratio_divide<Period2, period>::type::den shall be 1 and treat_as_floating_point<Rep2>::value shall be false. Diagnostic required. [Note: This requirement prevents implicit truncation error when converting between integral-based duration types. Such a construction could easily lead to confusion about the value of the duration. -- end note]
Section: 20.6.5 [meta.rel] Status: Review Submitter: Daniel Krügler Opened: 2009-01-25 Last modified: 2009-03-13
View other active issues in [meta.rel].
View all other issues in [meta.rel].
View all issues with Review status.
Discussion:
Addresses UK 206The current specification of std::is_convertible (reference is draft N2798) is basically defined by 20.6.5 [meta.rel]/4:
In order to instantiate the template is_convertible<From, To>, the following code shall be well formed:
template <class T> typename add_rvalue_reference<T>::type create(); To test() { return create<From>(); }[Note: This requirement gives well defined results for reference types, void types, array types, and function types. --end note]
The first sentence can be interpreted, that e.g. the expression
std::is_convertible<double, int*>::value
is ill-formed because std::is_convertible<double, int*> could not be instantiated, or in more general terms: The wording requires that std::is_convertible<X, Y> cannot be instantiated for otherwise valid argument types X and Y if X is not convertible to Y.
This semantic is both unpractical and in contradiction to what the last type traits paper N2255 proposed:
If the following test function is well formed code b is true, else it is false.
template <class T> typename add_rvalue_reference<T>::type create(); To test() { return create<From>(); }[Note: This definition gives well defined results for reference types, void types, array types, and function types. --end note]
[ Post Summit: ]
Jens: Checking that code is well-formed and then returning true/false sounds like speculative compilation. John Spicer would really dislike this. Please find another wording suggesting speculative compilation.
Recommend Open.
[ Post Summit, Howard adds: ]
Original proposed wording:John finds the following wording clearer:
Template Condition Comments template <class From, class To>
struct is_convertible;see below From and To shall be complete types, arrays of unknown bound, or (possibly cv-qualified) void types. Given the following function prototype:
template <class T> typename add_rvalue_reference<T>::type create();is_convertible<From, To>::value shall be true if the return expression in the following code would be well-formed, including any implicit conversions to the return type of the function, else is_convertible<From, To>::value shall be false.
To test() { return create<From>(); }
In 20.6.5 [meta.rel]/4 change:
In order to instantiate the template is_convertible<From, To>, the following code shall be well formedIf the following code is well formed is_convertible<From, To>::value is true, otherwise false:[..]
Proposed resolution:
In 20.6.5 [meta.rel] change:
Template Condition Comments ... ... ... template <class From, class To>
struct is_convertible;The code set out below shall be well formed.see belowFrom and To shall be complete types, arrays of unknown bound, or (possibly cv-qualified) void types. -4-
In order to instantiate the template is_convertible<From, To>, the following code shall be well formed:Given the following function prototype:template <class T> typename add_rvalue_reference<T>::type create();is_convertible<From, To>::value inherits either directly or indirectly from true_type if the return expression in the following code would be well-formed, including any implicit conversions to the return type of the function, else is_convertible<From, To>::value inherits either directly or indirectly from false_type.
To test() { return create<From>(); }[Note: This requirement gives well defined results for reference types, void types, array types, and function types. -- end note]
Section: 23.3.5.3.1 [stack.defn] Status: New Submitter: Daniel Krügler Opened: 2009-02-01 Last modified: 2009-02-03
View all issues with New status.
Discussion:
The synopsis given in 23.3.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.
Proposed resolution:
In the class stack synopsis of 23.3.5.3.1 [stack.defn] insert:
template <ObjectType T, StackLikeContainer Cont = deque<T> >
requires SameType<Cont::value_type, T>
&& NothrowDestructible<Cont>
class stack {
public:
...
requires CopyConstructible<Cont> explicit stack(const Cont&);
requires MoveConstructible<Cont> explicit stack(Cont&& = Cont());
requires MoveConstructible<Cont> stack(stack&&);
requires MoveAssignable<Cont> stack& operator=(stack&&);
template <class Alloc>
requires Constructible<Cont, const Alloc&>
explicit stack(const Alloc&);
...
};
[Remark: This change should be done in sync with the resolution of paper N2819]
Section: 24.7 [insert.iterators] Status: New Submitter: Howard Hinnant Opened: 2009-02-02 Last modified: 2009-02-03
View other active issues in [insert.iterators].
View all other issues in [insert.iterators].
View all issues with New 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. ]
Proposed resolution:
Change 23.2.6.1 [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_typeValue 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_typeValue v) { v == *insert(c, position, v); } }
Change 23.2.6.2 [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_typeValue 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_typeValue v) { v == *c.insert(position, v); } }
Change 23.2.6.3 [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.7.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.7.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.7.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.7.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.7.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.7.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;
Section: 20.7.17 [unord.hash] Status: New Submitter: Alisdair Meredith Opened: 2009-02-02 Last modified: 2009-02-02
View other active issues in [unord.hash].
View all other issues in [unord.hash].
View all issues with New status.
Discussion:
I don't see an open issue on supporting std::hash for smart pointers (unique_ptr and shared_ptr at least).
It seems reasonable to at least expect support for the smart pointers, especially as they support comparison for use in ordered associative containers.
Proposed resolution:
Section: 24.5.3 [move.iterators] Status: New Submitter: Howard Hinnant Opened: 2009-02-03 Last modified: 2009-02-03
View all issues with New 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.
Proposed resolution:
Change 24.5.3 [move.iterators]/2:
-2- [Example:
setlist<string> s; // populate thesetlist 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]
Section: 23.2.5 [unord.req] Status: New Submitter: Daniel Krügler Opened: 2009-02-08 Last modified: 2009-02-08
View other active issues in [unord.req].
View all other issues in [unord.req].
View all issues with New status.
Discussion:
Refering to N2800 all container requirements tables (including those for associative containers) provide useful member function overloads accepting std::initializer_list as argument, the only exception is Table 87. There seems to be no reason for not providing them, because 23.5 [unord] is already initializer_list-aware. For the sake of library interface consistency and user-expectations corresponding overloads should be added to the table requirements of unordered containers as well.
Proposed resolution:
In 23.2.5 [unord.req]/9 insert:
... [q1, q2) is a valid range in a, il designates an object of type initializer_list<value_type>, t is a value of type X::value_type, ...
In 23.2.5 [unord.req], Table 87 insert:
Table 87 - Unordered associative container requirements (in addition to container) Expression Return type Assertion/note
pre-/post-conditionComplexity X(i, j)
X a(i, j)X ... ... X(il) X Same as X(il.begin(), il.end()). Same as X(il.begin(), il.end()). ... ... ... ... a = b X ... ... a = il X& a = X(il); return *this; Same as a = X(il). ... ... ... ... a.insert(i, j) void ... ... a.insert(il) void Same as a.insert(il.begin(), il.end()). Same as a.insert(il.begin(), il.end()).
Section: 23.2.4 [associative.reqmts] Status: New Submitter: Daniel Krügler Opened: 2009-02-08 Last modified: 2009-05-01
View other active issues in [associative.reqmts].
View all other issues in [associative.reqmts].
View all issues with New status.
Discussion:
According to N2800, the associative container requirements table 85 says that assigning an initializer_list to such a container is of constant complexity, which is obviously wrong.
Proposed resolution:
In 23.2.4 [associative.reqmts], Table 85 change:
Table 85 - Associative container requirements (in addition to container) Expression Return type Assertion/note
pre-/post-conditionComplexity a = il X& a = X(il);
return *this;constantSame as a = X(il).
Section: 20.8.12.2 [unique.ptr.single] Status: New Submitter: Howard Hinnant Opened: 2009-02-10 Last modified: 2009-05-01
View other active issues in [unique.ptr.single].
View all other issues in [unique.ptr.single].
View all issues with New status.
Discussion:
Dave brought to my attention that when a unique_ptr has a non-const reference type deleter, move constructing from it, even when the unique_ptr containing the reference is an rvalue, could have surprising results:
D d(some-state); unique_ptr<A, D&> p(new A, d); unique_ptr<A, D> p2 = std::move(p); // has d's state changed here?
I agree with him. It is the unique_ptr that is the rvalue, not the deleter. When the deleter is a reference type, the unique_ptr should respect the "lvalueness" of the deleter.
Thanks Dave.
Proposed resolution:
Change 20.8.12.2.1 [unique.ptr.single.ctor], p20-21
template <class U, class E> unique_ptr(unique_ptr<U, E>&& u);-20- Requires: If
DE is not a reference type, construction of the deleter D from an rvalue of type E shall be well formed and shall not throw an exception. Otherwise E is a reference type and construction of the deleter D from an lvalue of type E shall be well formed and shall not throw an exception. If D is a reference type, then E shall be the same type as D (diagnostic required). unique_ptr<U, E>::pointer shall be implicitly convertible to pointer. [Note: These requirements imply that T and U are complete types. -- end note]-21- Effects: Constructs a unique_ptr which owns the pointer which u owns (if any). If the deleter E is not a reference type,
itthis deleter is move constructed from u's deleter, otherwisethe referencethis deleter is copy constructed from u.'s deleter. After the construction, u no longer owns a pointer. [Note: The deleter constructor can be implemented with std::forward<DE>. -- end note]
Change 20.8.12.2.3 [unique.ptr.single.asgn], p1-3
unique_ptr& operator=(unique_ptr&& u);-1- Requires: If the deleter D is not a reference type,
Aassignment of the deleter D from an rvalue D shall not throw an exception. Otherwise the deleter D is a reference type, and assignment of the deleter D from an lvalue D shall not throw an exception.-2- Effects: reset(u.release()) followed by an
moveassignment fromu's deleter to this deleterstd::forward<D>(u.get_deleter()).-3- Postconditions: This unique_ptr now owns the pointer which u owned, and u no longer owns it.
[Note: If D is a reference type, then the referenced lvalue deleters are move assigned. -- end note]
Change 20.8.12.2.3 [unique.ptr.single.asgn], p6-7
template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u);Requires: If the deleter E is not a reference type,
Aassignment of the deleter D from an rvalueDE shall not throw an exception. Otherwise the deleter E is a reference type, and assignment of the deleter D from an lvalue E shall not throw an exception. unique_ptr<U, E>::pointer shall be implicitly convertible to pointer. [Note: These requirements imply that T and U> are complete types. -- end note]Effects: reset(u.release()) followed by an
moveassignment fromu's deleter to this deleterstd::forward<E>(u.get_deleter()).If either D or E is a reference type, then the referenced lvalue deleter participates in the move assignment.
Section: 27.9.2 [c.files] Status: New Submitter: Howard Hinnant Opened: 2009-02-12 Last modified: 2009-02-12
View all issues with New status.
Discussion:
The C standard says about <inttypes.h>:
C++ implementations should define these macros only when __STDC_FORMAT_MACROSis defined before <inttypes.h> is included.
The C standard has a similar note about <stdint.h>. For <cstdint> we adopted a "thanks but no thanks" policy and documented that fact in 18.4.1 [cstdint.syn]:
... [Note: The macros defined by <stdint> are provided unconditionally. In particular, the symbols __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS (mentioned in C99 footnotes 219, 220, and 222) play no role in C++. -- end note]
I recommend we put a similar note in 27.9.2 [c.files] regarding <cinttypes>.
Proposed resolution:
Add to 27.9.2 [c.files]:
Table 112 describes header <cinttypes>. [Note: The macros defined by <cintypes> are provided unconditionally. In particular, the symbol __STDC_FORMAT_MACROS (mentioned in C99 footnotes 182) plays no role in C++. -- end note]
Section: 23.2.1 [container.requirements.general] Status: New Submitter: Rani Sharoni Opened: 2009-02-12 Last modified: 2009-02-15
View other active issues in [container.requirements.general].
View all other issues in [container.requirements.general].
View all issues with New status.
Discussion:
Introduction
This proposal is meant to resolve potential regression of the N2800 draft, see next section, and to relax the requirements for containers of types with throwing move constructors.
The basic problem is that some containers operations, like push_back, have a strong exception safety guarantee (i.e. no side effects upon exception) that are not achievable when throwing move constructors are used since there is no way to guarantee revert after partial move. For such operations the implementation can at most provide the basic guarantee (i.e. valid but unpredictable) as it does with multi copying operations (e.g. range insert).
For example, vector<T>::push_back() (where T has a move constructor) might resize the vector and move the objects to the new underlying buffer. If move constructor throws it might not be possible to recover the throwing object or to move the old objects back to the original buffer.
The current draft is explicit by disallowing throwing move for some operations (e.g. vector<>::reserve) and not clear about other operations mentioned in 23.2.1 [container.requirements.general]/10 (e.g. single element insert): it guarantees strong exception safety without explicitly disallowing a throwing move constructor.
Regression
This section only refers to cases in which the contained object is by itself a standard container.
Move constructors of standard containers are allowed to throw and therefore existing operations are broken, compared with C++03, due to move optimization. (In fact existing implementations like Dinkumware are actually throwing).
For example, vector< list<int> >::reserve yields undefined behavior since list<int>'s move constructor is allowed to throw. On the other hand, the same operation has strong exception safety guarantee in C++03.
There are few options to solve this regression:
Option 1 is suggested by proposal N2815 but it might not be applicable for existing implementations for which containers default constructors are throwing.
Option 2 limits the usage significantly and it's error prone by allowing zombie objects that are nothing but destructible (e.g. no clear() is allowed after move). It also potentially complicates the implementation by introducing special state.
Option 3 is possible, for example, using default construction and swap instead of move for standard containers case. The implementation is also free to provide special hidden operation for non throwing move without forcing the user the cope with the limitation of option-2 when using the public move.
Option 4 impact the efficiency in all use cases due to rare throwing move.
The proposed wording will imply option 1 or 3 though option 2 is also achievable using more wording. I personally oppose to option 2 that has impact on usability.
Relaxation for user types
Disallowing throwing move constructors in general seems very restrictive since, for example, common implementation of move will be default construction + swap so move will throw if the default constructor will throw. This is currently the case with the Dinkumware implementation of node based containers (e.g. std::list) though this section doesn't refer to standard types.
For throwing move constructors it seem that the implementation should have no problems to provide the basic guarantee instead of the strong one. It's better to allow throwing move constructors with basic guarantee than to disallow it silently (compile and run), via undefined behavior.
There might still be cases in which the relaxation will break existing generic code that assumes the strong guarantee but it's broken either way given a throwing move constructor since this is not a preserving optimization.
Proposed resolution:
23.2.1 [container.requirements.general] paragraph 10 add footnote:
-10- Unless otherwise specified (see 23.1.4.1, 23.1.5.1, 23.2.2.3, and 23.2.6.4) all container types defined in this Clause meet the following additional requirements:
- ...
[Note: for compatibility with C++ 2003, when "no effect" is required, standard containers should not use the value_type's throwing move constructor when the contained object is by itself a standard container. -- end note]
23.2.5.1 [unord.req.except] change paragraph 2 to say:
-2- For unordered associative containers, if an exception is thrown by any operation other than the container's hash function from within an insert() function inserting a single element, the insert() function has no effect unless the exception is thrown by the contained object move constructor.
-4- For unordered associative containers, if an exception is thrown from within a rehash() function other than by the container's hash function or comparison function, the rehash() function has no effect unless the exception is thrown by the contained object move constructor.
23.3.2.3 [deque.modifiers] change paragraph 2 to say:
-2- Remarks: If an exception is thrown other than by the copy constructor, move constructor or assignment operator of T there are no effects. If an exception is thrown by push_back() or emplace_back() function, that function has no effects unless the exception is thrown by the move constructor of T.
23.3.2.3 [deque.modifiers] change paragraph 6 to say:
-6- Throws: Nothing unless an exception is thrown by the copy constructor, move constructor or assignment operator of T.
23.3.6.2 [vector.capacity] remove paragraph 2
-2- Requires: If value_type has a move constructor, that constructor shall not throw any exceptions.
23.3.6.2 [vector.capacity] paragraph 3 change to say:
-3- Effects: A directive that informs a vector of a planned change in size, so that it can manage the storage allocation accordingly. After reserve(), capacity() is greater or equal to the argument of reserve if reallocation happens; and equal to the previous value of capacity() otherwise. Reallocation happens at this point if and only if the current capacity is less than the argument of reserve(). If an exception is thrown, there are no effects unless the exception is thrown by the contained object move constructor.
23.3.6.2 [vector.capacity] paragraph 12 change to say:
-12- Requires:If value_type has a move constructor, that constructor shall not throw any exceptions.If an exception is thrown, there are no effects unless the exception is thrown by the contained object move constructor.
23.3.6.4 [vector.modifiers] change paragraph 1 to say:
-1-Requires: If value_type has a move constructor, that constructor shall not throw any exceptions.Remarks: If an exception is thrown by push_back() or emplace_back() function, that function has no effect unless the exception is thrown by the move constructor of T.
23.3.6.4 [vector.modifiers] change paragraph 2 to say:
-2- Remarks: 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. If an exception is thrown other than by the copy constructor, move constructor or assignment operator of T or by any InputIterator operation there are no effects.
23.3.6.4 [vector.modifiers] change paragraph 6 to say:
-6- Throws: Nothing unless an exception is thrown by the copy constructor, move constructor or assignment operator of T.
Section: 30.4.4 [thread.lock.algorithm] Status: Review Submitter: Chris Fairles Opened: 2009-02-14 Last modified: 2009-03-22
View all issues with Review status.
Discussion:
In 30.4.4 [thread.lock.algorithm], the generic try_lock effects (p2) say that a failed try_lock is when it either returns false or throws an exception. In the event a call to try_lock does fail, by either returning false or throwing an exception, it states that unlock shall be called for all prior arguments. Then the returns clause (p3) goes on to state in a note that after returning, either all locks are locked or none will be. So what happens if multiple locks fail on try_lock?
Example:
#include <mutex>
int main() {
std::mutex m0, m1, m2;
std::unique_lock<std::mutex> l0(m0, std::defer_lock);
std::unique_lock<std::mutex> l1(m1); //throws on try_lock
std::unique_lock<std::mutex> l2(m2); //throws on try_lock
int result = std::try_lock(l0, l1, l2);
assert( !l0.owns_lock() );
assert( l1.owns_lock() ); //??
assert( l2.owns_lock() ); //??
}
The first lock's try_lock succeeded but, being a prior argument to a lock whose try_lock failed, it gets unlocked as per the effects clause of 30.4.4 [thread.lock.algorithm]. However, 2 locks remain locked in this case but the return clause states that either all arguments shall be locked or none will be. This seems to be a contradiction unless the intent is for implementations to make an effort to unlock not only prior arguments, but the one that failed and those that come after as well. Shouldn't the note only apply to the arguments that were successfully locked?
Further discussion and possible resolutions in c++std-lib-23049.
[ Summit: ]
Move to review. Agree with proposed resolution.
Proposed resolution:
Change 30.4.4 [thread.lock.algorithm], p2:
-2- Effects: Calls try_lock() for each argument in order beginning with the first until all arguments have been processed or a call to try_lock() fails, either by returning false or by throwing an exception. If a call to try_lock() fails, unlock() shall be called for all prior arguments and there shall be no further calls to try_lock().
Delete the note from 30.4.4 [thread.lock.algorithm], p3
-3- Returns: -1 if all calls to try_lock() returned true, otherwise a 0-based index value that indicates the argument for which try_lock() returned false.[Note: On return, either all arguments will be locked or none will be locked. -- end note]
Section: 20.7.5 [refwrap] Status: Open Submitter: Howard Hinnant Opened: 2009-02-18 Last modified: 2009-03-14
View all other issues in [refwrap].
View all issues with Open status.
Discussion:
The synopsis in 20.7.5 [refwrap] says:
template <ObjectType T> class reference_wrapper ...
And then paragraph 3 says:
The template instantiation reference_wrapper<T> shall be derived from std::unary_function<T1, R> only if the type T is any of the following:
- a function type or a pointer to function type taking one argument of type T1 and returning R
But function types are not ObjectTypes.
Paragraph 4 contains the same contradiction.
[ Post Summit: ]
Jens: restricted reference to ObjectType
Recommend Review.
[ Post Summit, Peter adds: ]
In https://svn.boost.org/trac/boost/ticket/1846 however Eric Niebler makes the very reasonable point that reference_wrapper<F>, where F is a function type, represents a reference to a function, a legitimate entity. So boost::ref was changed to allow it.
https://svn.boost.org/trac/boost/browser/trunk/libs/bind/test/ref_fn_test.cpp
Therefore, I believe an alternative proposed resolution for issue 987 could simply allow reference_wrapper to be used with function types.
[ Post Summit, Howard adds: ]
I agree with Peter (and Eric). I got this one wrong on my first try. Here is code that demonstrates how easy (and useful) it is to instantiate reference_wrapper with a function type:
#include <functional> template <class F> void test(F f); void f() {} int main() { test(std::ref(f)); }Output (link time error shows type of reference_wrapper instantiated with function type):
Undefined symbols: "void test<std::reference_wrapper<void ()()> >(std::reference_wrapper<void ()()>)",...I've taken the liberty of changing the proposed wording to allow function types and set to Open. I'll also freely admit that I'm not positive ReferentType is the correct concept.
Proposed resolution:
Change the synopsis in 20.7 [function.objects]:
// 20.6.5, reference_wrapper: template <ObjectTypeReferentType T> requires PointeeType<T> class reference_wrapper; template <ObjectTypePointeeType T> reference_wrapper<T> ref(T&); template <ObjectTypePointeeType T> reference_wrapper<const T> cref(const T&); template <ObjectTypePointeeType T> reference_wrapper<T> ref(reference_wrapper<T>); template <ObjectTypePointeeType T> reference_wrapper<const T> cref(reference_wrapper<T>);
Change the synopsis in 20.7.5 [refwrap]:
template <ObjectTypeReferentType T> requires PointeeType<T> class reference_wrapper ...
Change the prototypes in 20.7.5.5 [refwrap.helpers]:
template <ObjectTypePointeeType T> reference_wrapper<T> ref(T&); ... template <ObjectTypePointeeType T> reference_wrapper<const T> cref(const T&); ... template <ObjectTypePointeeType T> reference_wrapper<T> ref(reference_wrapper<T>); ... template <ObjectTypePointeeType T> reference_wrapper<const T> cref(reference_wrapper<T>);
Rationale:
a) The occurrence of T& in the function signature auto-implies std::ReferentType, this is due to 14.11.1.2 [temp.req.impl]/4 bullet 4
b) The occurrence of the constrained template reference_wrapper<T> in the remaining signatures lets kick in 14.11.1.2 [temp.req.impl]/4 bullet 1 and adds *all* requirements of this template. But we need to add at least *one* requirement (and it was an arbitrary, but natural decision to require std::PointeeType here) to *activate* this. If we hadn't done this, we were in unconstrained mode!
Section: 20.2.6 [concept.comparison] Status: Tentatively Ready Submitter: Alisdair Meredith Opened: 2009-02-24 Last modified: 2009-03-09
View other active issues in [concept.comparison].
View all other issues in [concept.comparison].
View all issues with Tentatively Ready status.
Discussion:
20.2.6 [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 20.2.6 [concept.comparison]:
axiom Reflexivity(T a) { (a == a) == true; }
[ Post Summit: ]
Alisdair: I was wrong.
Recommend NAD.
Proposed resolution:
NAD.
Section: 17 [library] Status: New Submitter: Alisdair Meredith Opened: 2009-02-24 Last modified: 2009-02-24
View other active issues in [library].
View all other issues in [library].
View all issues with New 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).
Proposed resolution:
Section: 20.9.5.2 [time.clock.monotonic] Status: New Submitter: Howard Hinnant Opened: 2009-03-09 Last modified: 2009-03-09
View all issues with New status.
Discussion:
There is some confusion over what the value of monotonic_clock::is_monotonic when monotonic_clock is a synonym for system_clock. The intent is that if monotonic_clock exists, then monotonic_clock::is_monotonic is true.
Proposed resolution:
Change 20.9.5.2 [time.clock.monotonic], p1:
-1- Objects of class monotonic_clock represent clocks for which values of time_point never decrease as physical time advances. monotonic_clock may be a synonym for system_clock if and only if system_clock::is_monotonic is true.
Section: 22.3.3.2.2 [conversions.string] Status: Review Submitter: P.J. Plauger Opened: 2009-03-03 Last modified: 2009-03-13
View other active issues in [conversions.string].
View all other issues in [conversions.string].
View all issues with Review status.
Discussion:
Add custom allocator parameter to wstring_convert, since we cannot allocate memory for strings from a custom allocator.
Proposed resolution:
Change 22.3.3.2.2 [conversions.string]:
template<class Codecvt, class Elem = wchar_t,
class Wide_alloc = std::allocator<Elem>,
class Byte_alloc = std::allocator<char> > class wstring_convert {
public:
typedef std::basic_string<char, char_traits<char>, Byte_alloc> byte_string;
typedef std::basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
...
Change 22.3.3.2.2 [conversions.string], p3:
-3- The class template describes an ob ject that controls conversions between wide string ob jects of class std::basic_string<Elem, char_traits<Elem>, Wide_alloc> and byte string objects of class std::basic_string<char, char_traits<char>, Byte_alloc>(also known as std::string).
Section: 17.6.1.1 [contents] Status: Review Submitter: P.J. Plauger Opened: 2009-03-03 Last modified: 2009-03-13
View other active issues in [contents].
View all other issues in [contents].
View all issues with Review status.
Discussion:
This phrasing contradicts later freedom to implement the C standard library portions in the global namespace as well as std. (17.6.2.3p4)
Proposed resolution:
Change 17.6.1.1 [contents], p2:
-2- All library entities except those from the Standard C library, macros, operator new and operator delete are defined within the namespace std or namespaces nested within namespace std.
Section: 18.5 [support.start.term] Status: Review Submitter: P.J. Plauger Opened: 2009-03-03 Last modified: 2009-03-13
View all other issues in [support.start.term].
View all issues with Review status.
Discussion:
The function _Exit does not appear to be defined in this standard. Should it be added to the table of functions included-by-reference to the C standard?
Proposed resolution:
Add to 18.5 [support.start.term] Table 20 (Header <cstdlib> synopsis) Functions:
_Exit
Add before the description of abort(void):
_Exit(int status)The function _Exit(int status) has additional behavior in this International Standard:
- The program is terminated without executing destructors for objects of automatic, thread, or static storage duration and without calling the functions passed to atexit() (3.6.3 [basic.start.term]).
Section: 18.6.2.2 [new.handler] Status: Review Submitter: P.J. Plauger Opened: 2009-03-03 Last modified: 2009-03-13
View all issues with Review status.
Discussion:
quick_exit has been added as a new valid way to terminate a program in a well defined way
Proposed resolution:
Change 18.6.2.2 [new.handler], p2:
-2- Required behavior: ...
- ...
call either abort() or exit();terminate execution of the program without returning to the caller
Section: 17.5.1.3 [structure.requirements] Status: New Submitter: David Abrahams Opened: 2009-03-06 Last modified: 2009-03-14
View all issues with New 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.
Proposed resolution:
Recommend NAD. The text in 17.5.1.3 [structure.requirements] is perfectly clear.
Section: 17 [library] Status: New Submitter: David Abrahams Opened: 2009-03-06 Last modified: 2009-03-10
View other active issues in [library].
View all other issues in [library].
View all issues with New 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.
Proposed resolution:
Section: 17.5.1.4 [structure.specifications] Status: Review Submitter: Thomas Plum Opened: 2009-03-03 Last modified: 2009-03-13
View other active issues in [structure.specifications].
View all other issues in [structure.specifications].
View all issues with Review status.
Discussion:
Many functions are defined as "Effects: Equivalent to a...", which seems to also define the preconditions, effects, etc. But this is not made clear.
After studying the occurrences of "Effects: Equivalent to", I agree with the diagnosis but disagree with the solution. In 21.4.2 [string.cons] we find
14 Effects: If InputIterator is an integral type, equivalent to basic_string(static_cast<size_type>(begin), static_cast<value_type>(end), a)
15 Otherwise constructs a string from the values in the range [begin, end), as indicated in the Sequence Requirements table (see 23.1.3).
This would be devishly difficult to re-write with an explicit "Equivalent to:" clause. Instead, I propose the following, which will result in much less editorial re-work.
Proposed resolution:
Add a new paragraph after 17.5.1.4 [structure.specifications], p3:
-3- Descriptions of function semantics contain the following elements (as appropriate):154
- Requires: the preconditions for calling the function
- Effects: the actions performed by the function
- Postconditions: the observable results established by the function
- Returns: a description of the value(s) returned by the function
- Throws: any exceptions thrown by the function, and the conditions that would cause the exception
- Complexity: the time and/or space complexity of the function
- Remarks: additional semantic constraints on the function
- Error conditions: the error conditions for error codes reported by the function.
- Notes: non-normative comments about the function
Whenever the Effects element specifies that the semantics of some function F are Equivalent to some code-sequence, then the various elements are interpreted as follows. If F's semantics specifies a Requires element, then that requirement is logically imposed prior to the equivalent-to semantics. Then, the semantics of the code-sequence are determined by the Requires, Effects, Postconditions, Returns, Throws, Complexity, Remarks, Error Conditions and Notes specified for the (one or more) function invocations contained in the code-sequence. The value returned from F is specified by F's Returns element, or if F has no Returns element, a non-void return from F is specified by the Returns elements in code-sequence. If F's semantics contains a Throws (or Postconditions, or Complexity) element, then that supersedes any occurrences of that element in the code-sequence.
Section: 20.8.12.2.5 [unique.ptr.single.modifiers] Status: New Submitter: Pavel Minaev Opened: 2009-02-26 Last modified: 2009-03-10
View other active issues in [unique.ptr.single.modifiers].
View all other issues in [unique.ptr.single.modifiers].
View all issues with New status.
Discussion:
Consider the following (simplified) implementation of std::auto_ptr<T>::reset():
void reset(T* newptr = 0) {
if (this->ptr && this->ptr != newptr) {
delete this->ptr;
}
this->ptr = newptr;
}
Now consider the following code which uses the above implementation:
struct foo {
std::auto_ptr<foo> ap;
foo() : ap(this) {}
void reset() { ap.reset(); }
};
int main() {
(new foo)->reset();
}
With the above implementation of auto_ptr, this results in U.B. at the point of auto_ptr::reset(). If this isn't obvious yet, let me explain how this goes step by step:
[ Thanks to Peter Dimov who recognized the connection to unique_ptr and brought this to the attention of the LWG, and helped with the solution. ]
[ Howard adds: ]
To fix this behavior reset must be specified such that deleting the pointer is the last action to be taken within reset.
[ Alisdair adds: ]
The example providing the rationale for LWG 998 is poor, as it relies on broken semantics of having two object believing they are unique owners of a single resource. It should not be surprising that UB results from such code, and I feel no need to go out of our way to support such behaviour.
If an example is presented that does not imply multiple ownership of a unique resource, I would be much more ready to accept the proposed resolution.
Proposed resolution:
Change 20.8.12.2.5 [unique.ptr.single.modifiers], p5 (Effects clause for reset), and p6:
-5- Effects:
If get() == nullptr there are no effects. Otherwise get_deleter()(get()).Assigns p to the stored pointer, and then if the old value of the pointer is not equal to nullptr, calls get_deleter()(the old value of the pointer). [Note: The order of these operations is significant because the call to get_deleter() may destroy *this. -- end note]-6- Postconditions: get() == p. [Note: The postcondition does not hold if the call to get_deleter() destroys *this since this->get() is no longer a valid expression. -- end note]
Section: 20.8.11.1 [object.addressof] Status: New Submitter: Peter Dimov Opened: 2009-03-09 Last modified: 2009-03-14
View other active issues in [object.addressof].
View all other issues in [object.addressof].
View all issues with New status.
Discussion:
The same fix (reference 987) may be applied to addressof, which is also constrained to ObjectType. (That was why boost::ref didn't work with functions - it tried to apply boost::addressof and the reinterpret_cast<char&> implementation of addressof failed.)
Proposed resolution:
Change the synopsis in 20.8 [memory]:
template <ObjectTypePointeeType T> T* addressof(T& r);
Change 20.8.11.1 [object.addressof]:
template <ObjectTypePointeeType T> T* addressof(T& r);
Rationale:
a) The occurrence of T& in the function signature auto-implies std::ReferentType, this is due to 14.11.1.2 [temp.req.impl]/4 bullet 4
Section: 25.3.8 [alg.adjacent.find] Status: Open Submitter: Chris Jefferson Opened: 2009-03-09 Last modified: 2009-03-13
View all other issues in [alg.adjacent.find].
View all issues with Open 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.3.8 [alg.adjacent.find] to:
template<ForwardIterator Iter> requiresEqualityComparableHasEqualTo<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);
Section: 17 [library] Status: New Submitter: Alisdair Meredith Opened: 2009-03-10 Last modified: 2009-04-25
View other active issues in [library].
View all other issues in [library].
View all issues with New 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.
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 include any other C++ headers shown by its synopsis as being included. A C++ header that uses a concept ([concept]) shall include the entire C++ header that defines that concept. The ordering of such inclusions is unspecified.
[Example: If C++ header
<a>contains a concept defined in C++ header<b>, and header<b>contains a concept defined in C++ header<c>, then inclusion of<a>is equivalent to inclusion of<a>,<b>, and<c>. -- end example][footnote] C++ headers must include a C++ header that contains any needed definition (3.2).
Section: 17.6.1.2 [headers] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View all other issues in [headers].
View all issues with Review 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.
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]
Section: 17.6.1.3 [compliance] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View other active issues in [compliance].
View all other issues in [compliance].
View all issues with Review 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)
Proposed resolution:
Add <type_traits> to Table 15.
Section: 17.6.3.8 [res.on.functions] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View all other issues in [res.on.functions].
View all issues with Review status.
Discussion:
Addresses UK 179
According to the 4th bullet there is a problem if "if any replacement function or handler function or destructor operation throws an exception". There should be no problem throwing exceptions so long as they are caught within the function.
Proposed resolution:
Change the 4th bullet of 17.6.3.8 [res.on.functions], p2:
- if any replacement function or handler function or destructor operation
throwspropagates an exception, unless specifically allowed in the applicable Required behavior: paragraph.
Section: 18.3.1.1 [numeric.limits] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View all issues with Review 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.
Proposed resolution:
Change 18.3.1.1 [numeric.limits]:
template<classRegular T> class numeric_limits<const T>; template<classRegular T> class numeric_limits<volatile T>; template<classRegular T> class numeric_limits<const volatile T>;
Section: 18.6.1 [new.delete] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View all other issues in [new.delete].
View all issues with Review status.
Discussion:
Addresses UK 190
It is not entirely clear how the current specification acts in the presence of a garbage collected implementation.
[ Summit: ]
Agreed.
Proposed resolution:
Add paragraphs to 18.6.1.1 [new.delete.single]:
void operator delete(void* ptr) throw();void operator delete(void* ptr, const std::nothrow_t&) throw();[ The second signature deletion above is editorial. ]
Requires: ptr shall be a safely-derived pointer (3.7.4.3 [basic.stc.dynamic.safety]).
-10- ...
void operator delete(void* ptr, const std::nothrow_t&) throw();Requires: ptr shall be a safely-derived pointer (3.7.4.3 [basic.stc.dynamic.safety]).
-15- ...
Add paragraphs to 18.6.1.2 [new.delete.array]:
void operator delete[](void* ptr) throw();void operator delete[](void* ptr, const std::nothrow_t&) throw();[ The second signature deletion above is editorial. ]
Requires: ptr shall be a safely-derived pointer (3.7.4.3 [basic.stc.dynamic.safety]).
-9- ...
void operator delete[](void* ptr, const std::nothrow_t&) throw();Requires: ptr shall be a safely-derived pointer (3.7.4.3 [basic.stc.dynamic.safety]).
-13- ...
Add paragraphs to 18.6.1.3 [new.delete.placement]:
void operator delete(void* ptr, void*) throw();Requires: ptr shall be a safely-derived pointer (3.7.4.3 [basic.stc.dynamic.safety]).
-7- ...
void operator delete[](void* ptr, void*) throw();Requires: ptr shall be a safely-derived pointer (3.7.4.3 [basic.stc.dynamic.safety]).
-9- ...
Section: 18.8.6 [except.nested] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View other active issues in [except.nested].
View all other issues in [except.nested].
View all issues with Open 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.
Section: 18.8.6 [except.nested] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View other active issues in [except.nested].
View all other issues in [except.nested].
View all issues with Open 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.
Proposed resolution:
Section: 24.2.1 [iterator.iterators] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-22
View all issues with Review 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.
Proposed resolution:
Change 24.2.1 [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.2 [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.3 [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.4 [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; }.
Section: 24.2.6 [random.access.iterators] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View other active issues in [random.access.iterators].
View all other issues in [random.access.iterators].
View all issues with Review status.
Discussion:
Addresses UK 263
This requirement on operator-= would be better expressed as a default implementation in the concept, with a matching axiom.
Proposed resolution:
Change 24.2.6 [random.access.iterators]:
concept RandomAccessIterator<typename X> : BidirectionalIterator<X>, LessThanComparable<X> {
...
X& operator-=(X& x, difference_type n) { return x += -n; }
...
}
Section: 24.4 [iterator.operations] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View other active issues in [iterator.operations].
View all other issues in [iterator.operations].
View all issues with Review status.
Discussion:
Addresses UK 271
next/prev return an incremented iterator without changing the value of the original iterator. However, even this may invalidate an InputIterator. A ForwardIterator is required to guarantee the 'multipass' property.
Proposed resolution:
Change [iterator.synopsis]:
template <InputIteratorForwardIterator Iter> Iter next(Iter x, Iter::difference_type n = 1);
Change 24.4 [iterator.operations], p6:
template <InputIteratorForwardIterator Iter> Iter next(Iter x, Iter::difference_type n = 1);
Section: 24.5.1.2.1 [reverse.iter.cons] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View all issues with Review status.
Discussion:
Addresses UK 277
The default constructor default-initializes current, rather than value-initializes. This means that when Iterator corresponds to a trivial type, the current member is left un-initialized, even when the user explictly requests value intialization! At this point, it is not safe to perform any operations on the reverse_iterator other than assign it a new value or destroy it. Note that this does correspond to the basic definition of a singular iterator.
[ Summit: ]
Agree with option i.
Related issue: 408
Proposed resolution:
Change [reverse.iter.con]:
reverse_iterator();-1- Effects:DefaultValue initializes current. Iterator operations applied to the resulting iterator have defined behavior if and only if the corresponding operations are defined on a default constructed iterator of type Iterator.
Change 24.5.3.2.1 [move.iter.op.const]:
move_iterator();-1- Effects: Constructs a move_iterator,defaultvalue initializing current.
Section: 25.5.7 [alg.min.max] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View other active issues in [alg.min.max].
View all other issues in [alg.min.max].
View all issues with Review 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.
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.5.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);
Section: 28.9.2 [re.regex.construct] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View all other issues in [re.regex.construct].
View all issues with Review status.
Discussion:
Addresses UK 317 and JP 74
UK 317:
basic_string has both a constructor and an assignment operator that accepts an initializer list, basic_regex should have the same.
JP 74:
basic_regx & operator= (initializer_list<T>); is not defined.
Proposed resolution:
Change 28.9 [re.regex]:
template <class charT,
class traits = regex_traits<charT> >
class basic_regex {
...
basic_regex& operator=(const charT* ptr);
basic_regex& operator=(initializer_list<charT> il);
template <class ST, class SA>
basic_regex& operator=(const basic_string<charT, ST, SA>& p);
...
};
Add in 28.9.2 [re.regex.construct]:
-20- ...basic_regex& operator=(initializer_list<charT> il);-21- Effects: returns assign(il.begin(), il.end());
Section: 20.2.1 [concept.transform] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View all issues with Review 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.
Proposed resolution:
Change 20.2.1 [concept.transform] p2:
-2- Aprogramuser shall not provide concept maps for any concept in 20.1.1.
Change 20.2.2 [concept.true] p2:
-2- Requires: aprogramuser shall not provide a concept map for the True concept.
Section: 20.2.6 [concept.comparison] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View other active issues in [concept.comparison].
View all other issues in [concept.comparison].
View all issues with Open 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.
Section: 20.2.11 [concept.regular] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View all issues with Open 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:
Section: 20.6 [meta] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View other active issues in [meta].
View all other issues in [meta].
View all issues with Open 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:
Section: 20.6.3 [meta.help] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View other active issues in [meta.help].
View all other issues in [meta.help].
View all issues with Review status.
Discussion:
Addresses UK 205
integral_constant objects should be usable in integral-constant-expressions. The addition to the language of literal types and the enhanced rules for constant expressions make this possible.
Proposed resolution:
Add to the integral_constant struct definition in 20.6.3 [meta.help]:
template <class 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; }
};
Section: 20.6.7 [meta.trans.other] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View other active issues in [meta.trans.other].
View all other issues in [meta.trans.other].
View all issues with Open 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.
Proposed resolution:
Section: 20.8.12.2.3 [unique.ptr.single.asgn] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View all issues with Review status.
Discussion:
Addresses UK 211
The nullptr_t type was introduced to resolve the null pointer literal problem. It should be used for the assignemnt operator, as with the constructor and elsewhere through the library.
Proposed resolution:
Change the synopsis in 20.8.12.2 [unique.ptr.single]:
unique_ptr& operator=(unspecified-pointer-typenullptr_t);
Change 20.8.12.2.3 [unique.ptr.single.asgn]:
unique_ptr& operator=(unspecified-pointer-typenullptr_t);Assigns from the literal 0 or NULL. [Note: The unspecified-pointer-type is often implemented as a pointer to a private data member, avoiding many of the implicit conversion pitfalls. -- end note]
Section: 20.7.16.2 [func.wrap.func] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View other active issues in [func.wrap.func].
View all other issues in [func.wrap.func].
View all issues with Review status.
Discussion:
Addresses DE 22
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.
Proposed resolution:
(no changes to <functional> synopsis required)
Change synopsis in Class template function 20.7.16.2 [func.wrap.func]:
template<Returnable R, CopyConstructible... ArgTypes> class function<R(ArgTypes...)> : public unary_function<T1, R> //iff sizeof...(ArgTypes) == 1 andsee below// ArgTypes contains T1: public binary_function<T1, T2, R> //iff sizeof...(ArgTypes) == 2 andsee below// ArgTypes contains T1 and T2{ ...
Add new p1/p2 before 20.7.16.2.1 [func.wrap.func.con]:
The template instantiation function<R(T1)> shall be 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 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();
Section: 20.7.16.2 [func.wrap.func] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View other active issues in [func.wrap.func].
View all other issues in [func.wrap.func].
View all issues with Review status.
Discussion:
Addresses JP 39
There are no requires corresponding to F of std::function.
Proposed resolution:
Correct as follows in 20.7.16.2 [func.wrap.func] (class definition)
template<class F, Allocator A>
requires ConstructibleWithAllocator<F, A>
&& Callable<F, ArgTypes...>
&& Convertible<Callable<F, ArgTypes...>::result_type, R>
function(allocator_arg_t, const A&, F);
template<class F, Allocator A>
requires ConstructibleWithAllocator<F,A>
&& Callable<F, ArgTypes...>
&& Convertible<Callable<F, ArgTypes...>::result_type, R>
function(allocator_arg_t, const A&, F&&);
Section: 20.8 [memory] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View other active issues in [memory].
View all other issues in [memory].
View all issues with Open 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:
Section: 20.8.6 [default.allocator] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-13
View all issues with Open 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:
Section: 20.8.8 [storage.iterator] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-15
View all issues with Open 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.8 [memory] p2
Update the synopsis for <memory>
// 20.7.8, raw storage iterator: template <classForwardIterator OutputIterator,classObjectType 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.8.8 [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:
Section: 20.8.11 [specialized.algorithms] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-15
View all other issues in [specialized.algorithms].
View all issues with Open 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:
- 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.
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:
- for uninitialized_copy_n: for ( ; n > Size(0); ++result, ++first, --n) {
- for uninitialized_fill_n: for (; n > Size(0); ++first, --n) {
Alisdair adds:
For the record I agree with Daniel's suggestion.
Proposed resolution:
20.8 [memory] p2
Update the synopsis for <memory>
template <classInputIterator InIter,class ForwardIteratorOutputIterator<auto, InIter::reference> OutIter> requires ForwardIterator<OutIter>ForwardIteratorOutIter uninitialized_copy(InputIteratorInIter first,InputIteratorInIter last,ForwardIteratorOutIter result); template <classInputIterator InIter,classIntegralLike Size,class ForwardIteratorOutputIterator<auto, InIter::reference> OutIter> requires ForwardIterator<OutIter>ForwardIteratorOutIter uninitialized_copy_n(InputIteratorInIter first, Size n,ForwardIteratorOutIter result); template <classForwardIterator Iter,classObjectType T> requires Constructible< Iter::value_type, const T& > void uninitialized_fill(ForwardIteratorIter first,ForwardIteratorIter last, const T& x); template <classForwardIterator Iter,classIntegralLike Size,classObjectType T> requires Constructible< Iter::value_type, const T& > void uninitialized_fill_n(ForwardIteratorIter first, Size n, const T& x);
Update as follows:
uninitialized_copy 20.8.11.2 [uninitialized.copy]
template <classInputIterator InIter,class ForwardIteratorOutputIterator<auto, InIter::reference> OutIter> requires ForwardIterator<OutIter>ForwardIteratorOutIter uninitialized_copy(InputIteratorInIter first,InputIteratorInIter last,ForwardIteratorOutIter 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 <classInputIterator InIter,classIntegralLike Size,class ForwardIteratorOutputIterator<auto, InIter::reference> OutIter> requires ForwardIterator<OutIter>ForwardIteratorOutIter uninitialized_copy_n(InputIteratorInIter first, Size n,ForwardIteratorOutIter 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.8.11.3 [uninitialized.fill]
template <classForwardIterator Iter,classObjectType T> requires Constructible< Iter::value_type, const T& > void uninitialized_fill(ForwardIteratorIter first,ForwardIteratorIter 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.8.11.4 [uninitialized.fill.n]
template <classForwardIterator Iter,classIntegralLike Size,classObjectType T> requires Constructible< Iter::value_type, const T& > void uninitialized_fill_n(ForwardIteratorIter 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); }
Section: 20.8.13.6 [util.smartptr.shared.atomic] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View all issues with Open status.
Discussion:
Addresses JP 44
The 1st parameter p and 2nd parameter v is now shared_ptr<T>*.
It should be shared_ptr<T>&, or if these are shared_ptr<T>* then add the "p shall not be a null pointer" at the requires.
[ Summit: ]
Agree. All of the functions need a requirement that p (or v) is a pointer to a valid object.
Proposed resolution:
Section: 20.8.13.2 [util.smartptr.shared] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View other active issues in [util.smartptr.shared].
View all other issues in [util.smartptr.shared].
View all issues with Open 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.
Proposed resolution:
Section: 20.9 [time] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12
View all other issues in [time].
View all issues with Open 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.9 [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:
Section: 30.3.1.5 [thread.thread.member] Status: New Submitter: Alberto Ganesh Barbati Opened: 2009-03-12 Last modified: 2009-03-12
View other active issues in [thread.thread.member].
View all other issues in [thread.thread.member].
View all issues with New status.
Discussion:
While looking at thread::join() I think I spotted a couple of possible defects in the specifications. I could not find a previous issue or NB comment about that, but I might have missed it.
The postconditions clause for thread::join() is:
Postconditions: If join() throws an exception, the value returned by get_id() is unchanged. Otherwise, get_id() == id().
and the throws clause is:
Throws: std::system_error when the postconditions cannot be achieved.
Now... how could the postconditions not be achieved? It's just a matter of resetting the value of get_id() or leave it unchanged! I bet we can always do that. Moreover, it's a chicken-and-egg problem: in order to decide whether to throw or not I depend on the postconditions, but the postconditions are different in the two cases.
I believe the throws clause should be:
Throws: std::system_error when the effects or postconditions cannot be achieved.
as it is in detach(), or, even better, as the postcondition is trivially satisfiable and to remove the circular dependency:
Throws: std::system_error if the effects cannot be achieved.
Problem is that... ehm... join() has no "Effects" clause. Is that intentional?
[ See the thread starting at c++std-lib-23204 for more discussion. ]
Proposed resolution:
Section: 23.2.1 [container.requirements.general] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-12
View other active issues in [container.requirements.general].
View all other issues in [container.requirements.general].
View all issues with Open status.
Discussion:
Addresses UK 222
It is not clear what purpose the Requirement tables serve in the Containers clause. Are they the definition of a library Container? Or simply a conventient shorthand to factor common semantics into a single place, simplifying the description of each subsequent container? This becomes an issue for 'containers' like array, which does not meet the default-construct-to-empty requirement, or forward_list which does not support the size operation. Are these components no longer containers? Does that mean the remaining requirements don't apply? Or are these contradictions that need fixing, despite being a clear design decision?
Recommend:
Clarify all the tables in 23.2 [container.requirements] are there as a convenience for documentation, rather than a strict set of requirements. Containers should be allowed to relax specific requirements if they call attention to them in their documentation. The introductory text for array should be expanded to mention a default constructed array is not empty, and forward_list introduction should mention it does not provide the required size operation as it cannot be implemented efficiently.
[ Summit: ]
Agree in principle.
Proposed resolution:
Section: 23.2.1 [container.requirements.general] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-12
View other active issues in [container.requirements.general].
View all other issues in [container.requirements.general].
View all issues with Open 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.
Proposed resolution:
Section: 23.2.3 [sequence.reqmts] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-12
View other active issues in [sequence.reqmts].
View all other issues in [sequence.reqmts].
View all issues with Open 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.
Section: 23.2.3 [sequence.reqmts] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-12
View other active issues in [sequence.reqmts].
View all other issues in [sequence.reqmts].
View all issues with Review status.
Discussion:
Addresses UK 232
match_results may follow the requirements but is not listed a general purpose library container.
Remove reference to match_results against a[n] operation.
[ Summit: ]
Agree. operator[] is defined elsewhere.
Proposed resolution:
In 23.2.3 [sequence.reqmts] Table 84, remove reference to match_results in the row describing the a[n] operation.
Section: 23.2.3 [sequence.reqmts] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-12
View other active issues in [sequence.reqmts].
View all other issues in [sequence.reqmts].
View all issues with Review status.
Discussion:
Addresses UK 233
Table 84 is missing references to several new container types.
[ Summit: ]
Agree.
Proposed resolution:
In 23.2.3 [sequence.reqmts] Table 84, Add reference to listed containers to the following rows:
Table 84 -- Optional sequence container operations Expression Return type Operational semantics Container a.front() ... ... vector, list, deque, basic_string, array, forward_list a.back() ... ... vector, list, deque, basic_string, array a.emplace_front(args) ... ... list, deque, forward_list a.push_front(t) ... ... list, deque, forward_list a.push_front(rv) ... ... list, deque, forward_list a.pop_front() ... ... list, deque, forward_list a[n] ... ... vector, deque, basic_string, array a.at(n) ... ... vector, deque, basic_string, array
Section: 23.2.3 [sequence.reqmts] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-12
View other active issues in [sequence.reqmts].
View all other issues in [sequence.reqmts].
View all issues with Review status.
Discussion:
Addresses UK 234
The reference to iterator in semantics for back should also allow for const_iterator when called on a const-qualified container. This would be ugly to specify in the 03 standard, but is quite easy with the addition of auto in this new standard.
[ Summit: ]
Agree.
Proposed resolution:
In 23.2.3 [sequence.reqmts] Table 84, replace iterator with auto in semantics for back:
Table 84 -- Optional sequence container operations Expression Return type Operational semantics Container a.back() reference; const_reference for constant a { iteratorauto tmp = a.end();
--tmp;
return *tmp; }vector, list, deque, basic_string
Section: 23.2.4 [associative.reqmts] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-15
View other active issues in [associative.reqmts].
View all other issues in [associative.reqmts].
View all issues with Review status.
Discussion:
Addresses UK 238
Leaving it unspecified whether or not iterator and const_iterator are the same type is dangerous, as user code may or may not violate the One Definition Rule by providing overloads for both types. It is probably too late to specify a single behaviour, but implementors should document what to expect. Observing that problems can be avoided by users restricting themselves to using const_iterator, add a note to that effect.
Suggest Change 'unspecified' to 'implementation defined'.
[ Summit: ]
Agree with issue. Agree with adding the note but not with changing the normative text. We believe the note provides sufficient guidance.
Proposed resolution:
In 23.2.4 [associative.reqmts] p6, add:
-6- iterator of an associative container meets the requirements of the BidirectionalIterator concept. For associative containers where the value type is the same as the key type, both iterator and const_iterator are constant iterators. It is unspecified whether or not iterator and const_iterator are the same type. [Note: iterator and const_iterator have identical semantics in this case, and iterator is convertible to const_iterator. Users can avoid violating the One Definition Rule by always using const_iterator in their function parameter lists -- end note]
Section: 23.2.4 [associative.reqmts] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-15
View other active issues in [associative.reqmts].
View all other issues in [associative.reqmts].
View all issues with Open 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?
Proposed resolution:
In 23.2.4 [associative.reqmts] Table 85, add:
Table 85 -- Associative container requirements (in addition to container) Expression Return type Assertion/note
pre-/post-conditionComplexity 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) Expression Return type Assertion/note
pre-/post-conditionComplexity 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
Section: 23.3 [sequences] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-14
View all other issues in [sequences].
View all issues with Open 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?
Proposed resolution:
Add to <container_concepts> synopsis in 23.2.6 [container.concepts]
concept< typename C > ContiguousStorageContainer see below;
Add a new section to the end of 23.2.6 [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 thatif a isan array<T, N>then it obeys the identity &a[n] == &a[0] + n for all 0 <= n < Nsatisfies 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.3.6 [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 thatif v isa 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.3.6 [vector] p2:
template< typename T, typename A >
requires !SameType< T, bool >
concept_map ContiguousStorageContainer< vector<T, A>> {};
Section: 29.6 [atomics.types.operations] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View all other issues in [atomics.types.operations].
View all issues with Review 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.
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.
Section: 30.4 [thread.mutex] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View all issues with Review status.
Discussion:
Addresses UK 325
We believe constexpr literal values should be a more natural expression of empty tag types than extern objects as it should improve the compilers ability to optimize the empty object away completely.
[ Summit: ]
Move to review. The current specification is a "hack", and the proposed specification is a better "hack".
Proposed resolution:
Change the synopsis in 30.4 [thread.mutex]:
struct defer_lock_t {};
struct try_to_lock_t {};
struct adopt_lock_t {};
extern constexpr defer_lock_t defer_lock {};
extern constexpr try_to_lock_t try_to_lock {};
extern constexpr adopt_lock_t adopt_lock {};
Section: 30.4.3.2.1 [thread.lock.unique.cons] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View all issues with Review status.
Discussion:
Addresses UK 326
The precondition that the mutex is not owned by this thread offers introduces the risk of un-necessary undefined behaviour into the program. The only time it matters whether the current thread owns the mutex is in the lock operation, and that will happen subsequent to construction in this case. The lock operation has the identical pre-condition, so there is nothing gained by asserting that precondition earlier and denying the program the right to get into a valid state before calling lock.
[ Summit: ]
Agree, move to review.
Proposed resolution:
Strike 30.4.3.2.1 [thread.lock.unique.cons] p7:
unique_lock(mutex_type& m, defer_lock_t);-7- Precondition: If mutex_type is not a recursive mutex the calling thread does not own the mutex.
Section: 30.6 [futures] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View all issues with Open 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.
Proposed resolution:
Section: 30.6.4 [futures.unique_future] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-04-25
View other active issues in [futures.unique_future].
View all other issues in [futures.unique_future].
View all issues with Review 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 [futures.shared_future]:
void shared_future<void>::get() const;Effects: If is_ready() would return false, block on the asynchronous result associated with *this.
Proposed resolution:
Add a paragraph to 30.6.4 [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.
Section: 30.6.4 [futures.unique_future] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View other active issues in [futures.unique_future].
View all other issues in [futures.unique_future].
View all issues with Open 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.
Proposed resolution:
Section: 30.6.6 [futures.promise] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View other active issues in [futures.promise].
View all other issues in [futures.promise].
View all issues with Review 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.
Proposed resolution:
Strike 30.6.6 [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.
Section: 30.6.6 [futures.promise] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-04-25
View other active issues in [futures.promise].
View all other issues in [futures.promise].
View all issues with Review 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.6 [futures.promise]:
-12- Throws: future_error if
*this has no associated statethe future has already been retrieved.-13- Error conditions: future_already_retrieved if
*this has no associated statethe future associated with the associated state has already been retrieved.Postcondition: The returned object and *this share the associated state.
Replace p14 30.6.8 [futures.task]:
-14- Throws:
std::bad_function_callfuture_error if the futureassociated with the taskhas 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.
Proposed resolution:
Add after p13 30.6.6 [futures.promise]:
unique_future<R> get_future();-13- ...
Postcondition: *this has no associated state.
Section: 24.5.1.2.12 [reverse.iter.opindex], 24.5.3.2.12 [move.iter.op.index] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-21
View all issues with Open 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.
Proposed resolution:
Section: 24.5.1.2.5 [reverse.iter.opref] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View all issues with Open 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.
Proposed resolution:
Change synopsis in 24.5.1.1 [reverse.iterator]:
template <BidirectionalIterator Iter>
class reverse_iterator {
...
typedef Iter::pointer pointer;
Change 24.5.1.2.5 [reverse.iter.opref]:
pointer operator->() const;Returns:&(operator*());this->tmp = current; --this->tmp; return this->tmp;
Section: 25 [algorithms] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View all other issues in [algorithms].
View all issues with Open 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.
Proposed resolution:
Section: 20.3.2 [forward] Status: New Submitter: Howard Hinnant Opened: 2009-03-13 Last modified: 2009-03-13
View all other issues in [forward].
View all issues with New status.
Discussion:
This is a placeholder issue to track the fact that we (well I) put the standard into an inconsistent state by requesting that we accept N2844 except for the proposed changes to [forward].
There will exist in the post meeting mailing N2835 which in its current state reflects the state of affairs prior to the Summit meeting. I hope to update it in time for the post Summit mailing, but as I write this issue I have not done so yet.
Proposed resolution:
Section: 20.6.7 [meta.trans.other] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View other active issues in [meta.trans.other].
View all other issues in [meta.trans.other].
View all issues with Open status.
Discussion:
Addresses UK 98
It would be useful to be able to determine the underlying type of an arbitrary enumeration type. This would allow safe casting to an integral type (especially needed for scoped enums, which do not promote), and would allow use of numeric_limits. In general it makes generic programming with enumerations easier.
Proposed resolution:
Add a new row to the table in 20.6.7 [meta.trans.other]:
Table 41 -- Other transformations Template Condition Comments template< class T > struct enum_base; T shall be an enumeration type (7.2 [dcl.enum]) The member typedef type shall name the underlying type of the enum T.
Section: 26.5 [rand] Status: New Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View other active issues in [rand].
View all other issues in [rand].
View all issues with New status.
Discussion:
Both the concepts RandomNumberEngine and RandonNumerDistribution has 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.
Proposed resolution:
Section: 26.5 [rand] Status: New Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View other active issues in [rand].
View all other issues in [rand].
View all issues with New 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.
Proposed resolution:
Section: 23.2.3 [sequence.reqmts] Status: New Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13
View other active issues in [sequence.reqmts].
View all other issues in [sequence.reqmts].
View all issues with New status.
Discussion:
Sequence containers 23.2.3 [sequence.reqmts]:
The return value of new calls added to table 83 are not specified.
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.
Section: 20.7.16.2 [func.wrap.func] Status: New Submitter: Daniel Krügler Opened: 2009-03-13 Last modified: 2009-03-14
View other active issues in [func.wrap.func].
View all other issues in [func.wrap.func].
View all issues with New 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.7 [function.objects]/2, header <functional> synopsis and 20.7.16.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.
Proposed resolution:
Change in 20.7 [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
Change in 20.7.16.2 [func.wrap.func]:
namespace std {
template<FunctionTypeReferentType F>
requires PointeeType<F> && !ObjectType<F>
class function; // undefined
Section: 17.5.2.1.4.1 [byte.strings] Status: New Submitter: Alisdair Meredith Opened: 2009-03-13 Last modified: 2009-03-13
View all issues with New status.
Discussion:
Definition of null-terminated sequences allow for embedded nulls. This is surprising, and probably not supportable with the intended use cases.
Proposed resolution:
Section: 20.3.4 [pair.astuple] Status: New Submitter: Alisdair Meredith Opened: 2009-03-13 Last modified: 2009-03-13
View all issues with New status.
Discussion:
The definition of get implies that get must return the second element if given a negative integer.
Proposed resolution:
20.3.4 [pair.astuple] p5:
template<intsize_t I, class T1, class T2> requires True<(I < 2)> const P& get(const pair<T1, T2>&);
Section: 24.7 [insert.iterators] Status: New Submitter: Alisdair Meredith Opened: 2009-03-13 Last modified: 2009-03-13
View other active issues in [insert.iterators].
View all other issues in [insert.iterators].
View all issues with New 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.
Proposed resolution:
Section: D.10.4 [iterator.backward] Status: New Submitter: Alisdair Meredith Opened: 2009-03-15 Last modified: 2009-04-05
View all issues with New 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.
Proposed resolution:
Change D.10 [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 D.10.4 [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:
Section: 17.3.15 [defns.obj.state] Status: Open Submitter: Howard Hinnant Opened: 2009-03-15 Last modified: 2009-03-15
View all issues with Open 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 20.7.18.1 [func.referenceclosure.cons].
Proposed resolution:
Section: 17.6.1.1 [contents] Status: Review Submitter: Howard Hinnant Opened: 2009-03-15 Last modified: 2009-03-15
View other active issues in [contents].
View all other issues in [contents].
View all issues with Review status.
Discussion:
Addresses UK 168
We should make it clear (either by note or normatively) that namespace std may contain inline namespaces, and that entities specified to be defined in std may in fact be defined in one of these inline namespaces. (If we're going to use them for versioning, eg when TR2 comes along, we're going to need that.)
Replace "namespace std or namespaces nested within namespace std" with "namespace std or namespaces nested within namespace std or inline namespaces nested directly or indirectly within namespace std"
[ Summit: ]
adopt UK words (some have reservations whether it is correct)
Proposed resolution:
Change 17.6.1.1 [contents] p2:
All library entities except macros, operator new and operator delete are defined within the namespace std or namespaces nested within namespace std or inline namespaces nested directly or indirectly within namespace std.
Section: 18 [language.support] Status: Review Submitter: Howard Hinnant Opened: 2009-03-15 Last modified: 2009-03-23
View all issues with Review status.
Discussion:
Addresses UK 189 and JP 27
The addition of the [[noreturn]] attribute to the language will be an important aid for static analysis tools.
The following functions should be declared in C++ with the [[noreturn]] attribute: abort exit quick_exit terminate unexpected rethrow_exception throw_with_nested.
[ Summit: ]
Agreed.
Proposed resolution:
Change 18.5 [support.start.term] p3:
-2- ...
void abort [[noreturn]] (void)-3- ...
-6- ...
void exit [[noreturn]] (int status)-7- ...
-11- ...
void quick_exit [[noreturn]] (int status)-12- ...
Change the <exception> synopsis in 18.8 [support.exception]:
void unexpected [[noreturn]] (); ... void terminate [[noreturn]] (); ... void rethrow_exception [[noreturn]] (exception_ptr p); ... template <class T> void throw_with_nested [[noreturn]] (T&& t);// [[noreturn]]
Change 18.8.2.4 [unexpected]:
void unexpected [[noreturn]] ();
Change 18.8.3.3 [terminate]:
void terminate [[noreturn]] ();
Change 18.8.5 [propagation]:
void rethrow_exception [[noreturn]] (exception_ptr p);
In the synopsis of 18.8.6 [except.nested] and the definition area change:
template <class T> void throw_with_nested [[noreturn]] (T&& t);// [[noreturn]]
Section: 26.7 [numeric.ops] Status: New Submitter: Alisdair Meredith Opened: 2009-03-17 Last modified: 2009-03-21
View all issues with New 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.
Proposed resolution:
Change in 26.7 [numeric.ops] and [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,MoveConstructibletypename 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);
Section: 26.5.6 [rand.device] Status: New Submitter: Alisdair Meredith Opened: 2009-03-18 Last modified: 2009-03-21
View all other issues in [rand.device].
View all issues with New status.
Discussion:
class random_device should be movable.
Proposed resolution:
Section: 26.5.7.1 [rand.util.seedseq] Status: New Submitter: Alisdair Meredith Opened: 2009-03-18 Last modified: 2009-03-21
View all other issues in [rand.util.seedseq].
View all issues with New status.
Discussion:
class seed_seq should support efficient move operations.
Proposed resolution:
Section: 20.7.16.2 [func.wrap.func] Status: New Submitter: Howard Hinnant Opened: 2009-03-19 Last modified: 2009-03-31
View other active issues in [func.wrap.func].
View all other issues in [func.wrap.func].
View all issues with New status.
Discussion:
The synopsis in 20.7.16.2 [func.wrap.func] says:
template<Returnable R, CopyConstructible... ArgTypes>
class function<R(ArgTypes...)>
{
...
template<class F>
requires CopyConstructible<F> && Callable<F, ArgTypes...>
&& Convertible<Callable<F, ArgTypes...>::result_type, R>
function(F);
template<class F>
requires CopyConstructible<F> && Callable<F, ArgTypes...>
&& Convertible<Callable<F, ArgTypes...>::result_type, R>
function(F&&);
...
template<class F, Allocator Alloc> function(allocator_arg_t, const Alloc&, F);
template<class F, Allocator Alloc> function(allocator_arg_t, const Alloc&, F&&);
...
template<class F>
requires CopyConstructible<F> && Callable<F, ArgTypes..>
&& Convertible<Callable<F, ArgTypes...>::result_type
function& operator=(F);
template<class F>
requires CopyConstructible<F> && Callable<F, ArgTypes...>
&& Convertible<Callable<F, ArgTypes...>::result_type, R>
function& operator=(F&&);
...
};
Each of the 3 pairs above are ambiguous. We need only one of each pair, and we could do it with either one. If we choose the F&& version we need to bring decay into the definition to get the pass-by-value behavior. In the proposed wording I've gotten lazy and just used the pass-by-value signature.
Proposed resolution:
Change the synopsis of 20.7.16.2 [func.wrap.func], and remove the associated definitions in 20.7.16.2.1 [func.wrap.func.con]:
template<Returnable R, CopyConstructible... ArgTypes>
class function<R(ArgTypes...)>
{
...
template<class F>
requires CopyConstructible<F> && Callable<F, ArgTypes...>
&& Convertible<Callable<F, ArgTypes...>::result_type, R>
function(F);
template<class F>
requires CopyConstructible<F> && Callable<F, ArgTypes...>
&& Convertible<Callable<F, ArgTypes...>::result_type, R>
function(F&&);
...
template<class F, Allocator Alloc> function(allocator_arg_t, const Alloc&, F);
template<class F, Allocator Alloc> function(allocator_arg_t, const Alloc&, F&&);
...
template<class F>
requires CopyConstructible<F> && Callable<F, ArgTypes..>
&& Convertible<Callable<F, ArgTypes...>::result_type
function& operator=(F);
template<class F>
requires CopyConstructible<F> && Callable<F, ArgTypes...>
&& Convertible<Callable<F, ArgTypes...>::result_type, R>
function& operator=(F&&);
...
};
Section: 20.7.12.1.1 [func.bind.isbind] Status: New Submitter: Alisdair Meredith Opened: 2009-03-19 Last modified: 2009-03-22
View all issues with New status.
Discussion:
Class template is_bind_expression 20.7.12.1.1 [func.bind.isbind]:
namespace std {
template<class T> struct is_bind_expression {
static const bool value = see below;
};
}
is_bind_expression should derive from std::integral_constant<bool> like other similar trait types.
[ Daniel adds: ]
We need the same thing for the trait is_placeholder as well.
[ 2009-03-22 Daniel provided wording. ]
Proposed resolution:
In 20.7.12.1.1 [func.bind.isbind] change as indicated:
namespace std {
template<class T> struct is_bind_expression : integral_constant<bool, see below> { };{
static const bool value = see below;
};
}
In 20.7.12.1.1 [func.bind.isbind]/2 change as indicated:
static const bool value;-2-true if T is a type returned from bind, false otherwise.If T is a type returned from bind, is_bind_expression<T> shall be publicly derived from integral_constant<bool, true>, otherwise it shall be publicly derived from integral_constant<bool, false>.
In 20.7.12.1.2 [func.bind.isplace] change as indicated:
namespace std {
template<class T> struct is_placeholder : integral_constant<int, see below> { };{
static const int value = see below;
};
}
In 20.7.12.1.2 [func.bind.isplace]/2 change as indicated:
static const int value;-2-value is J if T is the type of std::placeholders::_J, 0 otherwise.If T is the type of std::placeholders::_J, is_placeholder<T> shall be publicly derived from integral_constant<int, J> otherwise it shall be publicly derived from integral_constant<int, 0>.
Section: 20.7.17 [unord.hash] Status: New Submitter: Alisdair Meredith Opened: 2009-03-19 Last modified: 2009-03-22
View other active issues in [unord.hash].
View all other issues in [unord.hash].
View all issues with New status.
Discussion:
Is std::hash a constrained template or not?
According to Class template hash 20.7.17 [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.7 [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. ]
Proposed resolution:
[To the editor: This resolution is merge-compatible to the resolution of 1078]
In 20.7 [function.objects]/2, header <functional> synopsis, change as indicated:
// 20.6.17, hash function base template: template <ReferentType T> struct hash; // undefined
In 20.7.17 [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
}
In 20.7.17 [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.
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;
Section: 20.8 [memory] Status: New Submitter: Alisdair Meredith Opened: 2009-03-19 Last modified: 2009-03-21
View other active issues in [memory].
View all other issues in [memory].
View all issues with New status.
Discussion:
Declaration of allocator_arg should be constexpr to ensure constant initialization.
Proposed resolution:
Change 20.8 [memory] p2:
// 20.8.1, allocator argument tag
struct allocator_arg_t { };
constexpr allocator_arg_t allocator_arg = allocator_arg_t();
Section: 20.8.3 [allocator.element.concepts] Status: New Submitter: Alisdair Meredith Opened: 2009-03-19 Last modified: 2009-05-01
View all issues with New status.
Discussion:
p7 Allocator-related element concepts 20.8.3 [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 20.8.3 [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 20.8.3 [allocator.element.concepts]/7 this guy contains now
requires FreeStoreAllocatable<T>; void Alloc::construct(T*, Args&&...);
Proposed resolution:
Change 20.8.3 [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)...);
}
}
Section: 20 [utilities], 23 [containers] Status: Open Submitter: Alan Talbot Opened: 2009-03-20 Last modified: 2009-03-21
View all other issues in [utilities].
View all issues with Open status.
Discussion:
Addresses US 65 and US 74.1
US 65:
Scoped allocators and allocator propagation traits add a small amount of utility at the cost of a great deal of machinery. The machinery is user visible, and it extends to library components that don't have any obvious connection to allocators, including basic concepts and simple components like pair and tuple.Suggested resolution:
Sketch of proposed resolution: Eliminate scoped allocators, replace allocator propagation traits with a simple uniform rule (e.g. always propagate on copy and move), remove all mention of allocators from components that don't explicitly allocate memory (e.g. pair), and adjust container interfaces to reflect this simplification.
Components that I propose eliminating include HasAllocatorType, is_scoped_allocator, allocator_propagation_map, scoped_allocator_adaptor, and ConstructibleAsElement.
US 74.1:
Scoped allocators represent a poor trade-off for standardization, since (1) scoped-allocator--aware containers can be implemented outside the C++ standard library but used with its algorithms, (2) scoped allocators only benefit a tiny proportion of the C++ community (since few C++ programmers even use today's allocators), and (3) all C++ users, especially the vast majority of the C++ community that won't ever use scoped allocators are forced to cope with the interface complexity introduced by scoped allocators.
In essence, the larger community will suffer to support a very small subset of the community who can already implement their own data structures outside of the standard library. Therefore, scoped allocators should be removed from the working paper.
Some evidence of the complexity introduced by scoped allocators:
20.3.3 [pairs], 20.5 [tuple]: Large increase in the number of pair and tuple constructors.
23 [containers]: Confusing "AllocatableElement" requirements throughout.
Suggested resolution:
Remove support for scoped allocators from the working paper. This includes at least the following changes:
Remove 20.8.3 [allocator.element.concepts]
Remove 20.8.7 [allocator.adaptor]
Remove 20.8.10 [construct.element]
In Clause 23 [containers]: replace requirements naming the AllocatableElement concept with requirements naming CopyConstructible, MoveConstructible, DefaultConstructible, or Constructible, as appropriate.
[ Post Summit Alan moved from NAD to Open. ]
Proposed resolution:
Section: 20.7.11 [negators] Status: New Submitter: Alisdair Meredith Opened: 2009-03-20 Last modified: 2009-05-01
View all issues with New 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:
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]
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.]
In class unary/binary_function
- I suggest to change "ReturnType" to "Returnable" in both cases.
- I think you want to replace the remaining occurrences of "Predicate" by "P" (in both classes in copy/move from a predicate)
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:
[Don't we want a move call for the second overload as in
unary_negate<P>(std::move(pred))in the Returns clause ?]
-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 ?]
Proposed resolution:
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 20.7.3 [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,classReturnType Result> struct unary_function { typedef Arg argument_type; typedef Result result_type; }; template <class Arg1, class Arg2,classReturnType Result> struct binary_function { typedef Arg1 first_argument_type; typedef Arg2 second_argument_type; typedef Result result_type; }; }
Negators 20.7.11 [negators]:
-1- Negators not1 and not2 take a unary and a binary predicate, respectively, and return their complements (5.3.1).
template <classAdaptableUnaryFunction Predicate> requires Predicate< P, P::argument_type > class unary_negate : public unary_function<typenamePredicate::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()(consttypenamePredicate::argument_type& x) const; };-2 operator() returns !pred(x).template <class Predicate> unary_negate<Predicate> not1(const Predicate& pred); template <class Predicate> unary_negate<Predicate> not1(Predicate&& pred);-3- Returns: unary_negate<Predicate>(pred).template <classAdaptableBinaryFunction Predicate> requires Predicate< P, P::first_argument_type, P::second_argument_type > class binary_negate : public binary_function<typenamePredicate::first_argument_type,typenamePredicate::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()(consttypenamePredicate::first_argument_type& x, consttypenamePredicate::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).
Section: 20.5.2 [tuple.tuple] Status: New Submitter: Pete Becker Opened: 2009-03-20 Last modified: 2009-03-22
View all issues with New status.
Discussion:
Class template tuple 20.5.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. ]
Proposed resolution:
In 20.5.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.5.2.1 [tuple.cnstr]/7+8]
Section: 18.7.2 [type.index] Status: Open Submitter: Doug Gregor Opened: 2009-03-20 Last modified: 2009-03-31
View all issues with Open 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;
- Returns:
x->hash_code()
Add the following new subsection
18.7.1.2
type_infoconcept 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); } }
- Note: provides a well-defined ordering among
type_info constpointers, which makes such pointers usable in associative containers (23.4).
Remove section 18.7.2 [type.index]
RandomAccessIterator's operator- has nonsensical effects clauseSection: 24.2.6 [random.access.iterators] Status: Open Submitter: Doug Gregor Opened: 2009-03-20 Last modified: 2009-03-22
View other active issues in [random.access.iterators].
View all other issues in [random.access.iterators].
View all issues with Open status.
Discussion:
Addresses UK 265
UK-265:
This effects clause is nonesense. It looks more like an axiom stating equivalence, and certainly an effects clause cannot change the state of two arguments passed by const reference
Proposed resolution:
Modify 24.2.6 [random.access.iterators]p7-9 as follows:
difference_type operator-(const X& a, const X& b);
- Precondition: there exists a value
nofdifference_typesuch thata == b + n.Effects:b == a + (b - a)- Returns:
(a < b) ? distance(a,b) : -distance(b,a)n
Section: 20.2.13 [concept.arithmetic] Status: New Submitter: Daniel Krügler Opened: 2009-03-21 Last modified: 2009-03-22
View all issues with New status.
Discussion:
Astonishingly, the current concept ArithmeticLike as specified in 20.2.13 [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.6 [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 a now the no longer supported existing implicit conversion from int to IntegralLike).
Proposed resolution:
In 20.2.13 [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> {
In 24.2.6 [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; }
Section: 21 [strings] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-03-22
View all other issues in [strings].
View all issues with Open 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:
Section: 22 [localization] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-03-22
View other active issues in [localization].
View all other issues in [localization].
View all issues with Open 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:
Section: 22 [localization] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-03-22
View other active issues in [localization].
View all other issues in [localization].
View all issues with Open 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:
Section: 24.2.4 [forward.iterators] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-03-22
View all other issues in [forward.iterators].
View all issues with Open 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.
Proposed resolution:
[ This wording assumes the acceptance of UK 251 / 1009. Both wordings change the same paragraphs. ]
Change 24.2.4 [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;
}
}
Section: 24.2.5 [bidirectional.iterators] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-03-22
View all other issues in [bidirectional.iterators].
View all issues with Open 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.
Proposed resolution:
Change 24.2.5 [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;
}
}
Section: 24.6 [stream.iterators] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-03-22
View all issues with Open 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:
Section: 25.4.5 [alg.replace] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-03-22
View other active issues in [alg.replace].
View all other issues in [alg.replace].
View all issues with Open 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 25.2 [algorithms.syn] and 25.4.5 [alg.replace]:
template<ForwardIterator Iter, class T> requiresOutputIterator<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> requiresOutputIterator<Iter, Iter::reference> &&OutputIterator<Iter, const T&> && CopyConstructible<Pred> void replace_if(Iter first, Iter last, Pred pred, const T& new_value);
Section: 30.6.6 [futures.promise] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-03-22
View other active issues in [futures.promise].
View all other issues in [futures.promise].
View all issues with Open 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. ]
Proposed resolution:
In 30.6.6 [futures.promise], before p.1, immediately after class template promise add:
template <class R> void swap(promise<R>& x, promise<R>& y);
Change 30.6.6 [futures.promise]/10 as indicated (to fix a circular definition):
-10- Effects:
swap(*this, other)Swaps the associated state of *this and otherThrows: Nothing.
After the last paragraph in 30.6.6 [futures.promise] add the following prototype description:
template <class R> void swap(promise<R>& x, promise<R>& y);Effects: x.swap(y)
Throws: Nothing.
Section: 30 [thread] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-03-22
View all issues with Open status.
Discussion:
Addresses JP 76
A description for "Throws: Nothing." are not unified.
At the part without throw, "Throws: Nothing." should be described.
Add "Throws: Nothing." to the following.
[ Summit: ]
Pass on to editor.
[ Post Summit: Editor declares this non-editorial. ]
Proposed resolution:
Section: 30.6.8 [futures.task] Status: New Submitter: Daniel Krügler Opened: 2009-03-22 Last modified: 2009-03-22
View all issues with New status.
Discussion:
Class template packaged_task in 30.6.8 [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.
Proposed resolution:
In 30.6.8 [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...)>&);
In 30.6.8 [futures.task], class template packaged_task change the swap member as indicated:
[ to follow the new lvalue-ref swap style ]
void swap(packaged_task&&other);
In 30.6.8 [futures.task], immediately after operator= prototype description (After p. 8) add:
void swap(packaged_task& other);Effects: Swaps the associated state of *this and other.
Throws: Nothing.
At the end of 30.6.8 [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.
Section: 23.4.2.2 [multimap.modifiers] Status: New Submitter: Beman Dawes Opened: 2009-03-22 Last modified: 2009-03-22
View all issues with New 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 desctiption 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].
Strike 23.4.2.2 [multimap.modifiers] entirely. (but do NOT strike these signatures from the class template definition!)
[ Beman adds: ]
Pete is clearly right that this one is technical rather than editorial.
Proposed resolution:
Section: 20.6.3 [meta.help] Status: New Submitter: Daniel Krügler Opened: 2009-03-22 Last modified: 2009-03-22
View other active issues in [meta.help].
View all other issues in [meta.help].
View all issues with New 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.
Proposed resolution:
In 20.6.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;
In 20.6.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; } };
Section: 25.4.12 [alg.random.shuffle] Status: New Submitter: Alisdair Meredith Opened: 2009-03-22 Last modified: 2009-03-23
View all other issues in [alg.random.shuffle].
View all issues with New status.
Discussion:
There are a couple of issues with the declaration of the random_shuffle algorithm accepting a random number engine.
Proposed resolution:
Change in 25.2 [algorithms.syn] and 25.4.12 [alg.random.shuffle]:
concept UniformRandomNumberGenerator<typename Rand> { }template<RandomAccessIterator Iter, UniformRandomNumberGenerator Rand> requires ShuffleIterator<Iter> void random_shuffle(Iter first, Iter last, Rand&& g);
Section: 27.5.4.3 [iostate.flags] Status: New Submitter: P.J. Plauger Opened: 2009-03-24 Last modified: 2009-05-01
View all other issues in [iostate.flags].
View all issues with New status.
Discussion:
Addresses JP 65 and JP 66
Switch from "unspecified-bool-type" to "explicit operator bool() const".
Replace operator unspecified-bool-type() const;" with explicit operator bool() const;
Proposed resolution:
Change the synopis in 27.5.4 [ios]:
explicit operatorunspecified-bool-typebool() const;
Change 27.5.4.3 [iostate.flags]:
explicit operatorunspecified-bool-typebool() const;-1- Returns: !fail()
If fail() then a value that will evaluate false in a boolean context; otherwise a value that will evaluate true in a boolean context. The value type returned shall not be convertible to int.
[Note: This conversion can be used in contexts where a bool is expected (e.g., an if condition); however, implicit conversions (e.g., to int) that can occur with bool are not allowed, eliminating some sources of user error. One possible implementation choice for this type is pointer-to-member. -- end note]
Section: 17.6.3.10 [res.on.objects] Status: New Submitter: Beman Dawes Opened: 2009-03-27 Last modified: 2009-03-27
View all issues with New status.
Discussion:
N2775, Small library thread-safety revisions, among other changes, removed a note from 17.6.3.10 [res.on.objects] that read:
[Note: This prohibition against concurrent non-const access means that modifying an object of a standard library type shared between threads without using a locking mechanism may result in a data race. --end note.]
That resulted in wording which is technically correct but can only be understood by reading the lengthy and complex 17.6.4.7 [res.on.data.races] Data race avoidance. This has the effect of making 17.6.3.10 [res.on.objects] unclear, and has already resulted in a query to the LWG reflector. See c++std-lib-23194.
Proposed resolution:
Change 17.6.3.10 [res.on.objects] as indicated:
The behavior of a program is undefined if calls to standard library functions from different threads may introduce a data race. The conditions under which this may occur are specified in 17.6.4.7.
[Note: Thus modifying an object of a standard library type shared between threads is a really bad idea unless objects of the type are explicitly specified as being sharable without data races or the user supplies a locking mechanism. --end note]
Section: 17 [library] Status: New Submitter: David Abrahams Opened: 2009-03-21 Last modified: 2009-04-05
View other active issues in [library].
View all other issues in [library].
View all issues with New 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.
Proposed resolution:
Section: 18.2 [support.types] Status: New Submitter: Jens Maurer Opened: 2009-04-03 Last modified: 2009-04-05
View all other issues in [support.types].
View all issues with New status.
Discussion:
Addresses DE 18
Freestanding implementations do not (necessarily) have support for multiple threads (see 1.10 [intro.multithread]). Applications and libraries may want to optimize for the absence of threads. I therefore propose a preprocessor macro to indicate whether multiple threads can occur.
There is ample prior implementation experience for this feature with various spellings of the macro name. For example, gcc implicitly defines _REENTRANT if multi-threading support is selected on the compiler command-line.
While this is submitted as a library issue, it may be more appropriate to add the macro in 16.8 cpp.predefined in the core language.
See also N2693.
Proposed resolution:
Insert a new subsection before 18.2 [support.types], entitled "Feature Macros" (support.macros):
The standard library defines the following macros; no explicit prior inclusion of any header file is necessary.
- __STDCPP_THREADS
- The macro __STDCPP_THREADS shall be defined if and only if a program can have more than one thread of execution (1.10 [intro.multithread]). If the macro is defined, it shall have the same value as the predefined macro __cplusplus (16.8 [cpp.predefined]).
Section: 20.8.13.7 [util.dynamic.safety] Status: New Submitter: Jens Maurer Opened: 2009-04-03 Last modified: 2009-05-01
View all other issues in [util.dynamic.safety].
View all issues with New status.
Discussion:
Addresses DE 18
In 20.8.13.7 [util.dynamic.safety], get_pointer_safety() purports to define behavior for non-safely derived pointers (3.7.4.3 [basic.stc.dynamic.safety]). However, the cited core-language section in paragraph 4 specifies undefined behavior for the use of such pointer values. This seems an unfortunate near-contradiction. I suggest to specify the term relaxed pointer safety in the core language section and refer to it from the library description. This issue deals with the library part, the corresponding core issue (c++std-core-13940) deals with the core modifications.
See also N2693.
Proposed resolution:
In 20.8.13.7 [util.dynamic.safety] p16, replace the description of get_pointer_safety() with:
pointer_safety get_pointer_safety();
Returns: an enumeration value indicating the implementation's treatment of pointers that are not safely derived (3.7.4.3). Returns pointer_safety::relaxed if pointers that are not safely derived will be treated the same as pointers that are safely derived for the duration of the program. Returns pointer_safety::preferred if pointers that are not safely derived will be treated the same as pointers that are safely derived for the duration of the program but allows the implementation to hint that it could be desirable to avoid dereferencing pointers that are not safely derived as described. [Example: pointer_safety::preferred might be returned to detect if a leak detector is running to avoid spurious leak reports. -- end note] Returns pointer_safety::strict if pointers that are not safely derived might be treated differently than pointers that are safely derived.Returns: Returns pointer_safety::strict if the implementation has strict pointer safety (3.7.4.3 [basic.stc.dynamic.safety]). It is implementation-defined whether get_pointer_safety returns pointer_safety::relaxed or pointer_safety::preferred if the implementation has relaxed pointer safety (3.7.4.3 [basic.stc.dynamic.safety]).Footnote
Throws: nothing
Footnote) pointer_safety::preferred might be returned to indicate to the program that a leak detector is running so that the program can avoid spurious leak reports.
Section: 17 [library] Status: New Submitter: David Abrahams Opened: 2009-03-21 Last modified: 2009-04-25
View other active issues in [library].
View all other issues in [library].
View all issues with New 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
[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.
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.
[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-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!
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!
Proposed resolution:
Section: D.9 [depr.auto.ptr] Status: New Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2009-05-01
View all issues with New status.
Discussion:
Message c++std-lib-23182 led to a discussion in which several people expressed interest in being able to convert an auto_ptr to a unique_ptr without the need to call release. Below is wording to accomplish this.
Proposed resolution:
Add to D.9 [depr.auto.ptr]:
The following unique_ptr constructors are in addition to those specified in 20.8.12.2.1 [unique.ptr.single.ctor].
template <class T, class D> class unique_ptr { public: template <class U> requires SameType<D, default_delete<T>> && Convertible<U*, T*> unique_ptr(auto_ptr<U>& u); template <class U> requires SameType<D, default_delete<T>> && Convertible<U*, T*> unique_ptr(auto_ptr<U>&& u); };Effects: Constructs a unique_ptr with u.release().
Postconditions: get() == the value u.get() had before the construciton, modulo any required offset adjustments resulting from the cast from U* to T*. u.get() == nullptr.
Throws: nothing.
Section: 25.4.9 [alg.unique] Status: New Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2009-04-25
View other active issues in [alg.unique].
View all other issues in [alg.unique].
View all issues with New 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.
Proposed resolution:
Change 25.4.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 25.2 [algorithms.syn] is already correct.
Section: 23.3.6.2 [vector.capacity] Status: New Submitter: Daniel Krügler Opened: 2009-04-20 Last modified: 2009-04-25
View all other issues in [vector.capacity].
View all issues with New status.
Discussion:
I have the impression that even the wording of current draft N2857 does insufficiently express the intend 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
the effects clause of std::vector's erase overloads in 23.3.6.4 [vector.modifiers]/4 is silent about capacity changes. This easily causes a misunderstanding, because the counter parting insert functions described in 23.3.6.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.
Proposed resolution:
[ This is a minimum version. I also suggest that the wording explaining the allocation strategy of std::vector in 23.3.6.2 [vector.capacity]/3 and /6 is moved into a separate sub paragraph of 23.3.6.2 [vector.capacity] before any of the prototype's are discussed, but I cannot provide reasonable wording changes now ]
Change 23.3.6.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().
Change 23.3.6.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.
Section: 19.5.5.2 [syserr.syserr.members] Status: New Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2009-04-25
View all issues with New status.
Discussion:
19.5.5.2 [syserr.syserr.members] says:
system_error(error_code ec, const string& what_arg);Effects: Constructs an object of class system_error.
Postconditions: code() == ec and strcmp(runtime_error::what(), what_arg.c_str()) == 0.
However the intent is for:
std::system_error se(std::errc::not_a_directory, "In FooBar");
...
se.what(); // returns something along the lines of:
// "In FooBar: Not a directory"
The way the constructor postconditions are set up now, to achieve both conformance, and the desired intent in the what() string, the system_error constructor must store "In FooBar" in the base class, and then form the desired output each time what() is called. Or alternatively, store "In FooBar" in the base class, and store the desired what() string in the derived system_error, and override what() to return the string in the derived part.
Both of the above implementations seem suboptimal to me. In one I'm computing a new string every time what() is called. And since what() can't propagate exceptions, the client may get a different string on different calls.
The second solution requires storing two strings instead of one.
What I would like to be able to do is form the desired what() string once in the system_error constructor, and store that in the base class. Now I'm:
This is smaller code, smaller data, and faster.
ios_base::failure has the same issue.
[ Comments about this change received favorable comments from the system_error designers. ]
Proposed resolution:
In 19.5.5.2 [syserr.syserr.members], change the following constructor postconditions:
system_error(error_code ec, const string& what_arg);-2- Postconditions: code() == ec andstrcmp(runtime_error::what(), what_arg.c_str()) == 0string(what()).find(what_arg) != std::string::npos.system_error(error_code ec, const char* what_arg);-4- Postconditions: code() == ec andstrcmp(runtime_error::what(), what_arg) == 0string(what()).find(what_arg) != std::string::npos.system_error(error_code ec);-6- Postconditions: code() == ecand strcmp(runtime_error::what(), "".system_error(int ev, const error_category& ecat, const string& what_arg);-8- Postconditions: code() == error_code(ev, ecat) andstrcmp(runtime_error::what(), what_arg.c_str()) == 0string(what()).find(what_arg) != std::string::npos.system_error(int ev, const error_category& ecat, const char* what_arg);-10- Postconditions: code() == error_code(ev, ecat) andstrcmp(runtime_error::what(), what_arg) == 0string(what()).find(what_arg) != std::string::npos.system_error(int ev, const error_category& ecat, const char* what_arg);-12- Postconditions: code() == error_code(ev, ecat)and strcmp(runtime_error::what(), "") == 0.
In 19.5.5.2 [syserr.syserr.members], change the description of what():
const char *what() const throw();-14- Returns: An NTBS incorporating
runtime_error::what() and code().message()the arguments supplied in the constructor.[Note:
One possible implementation would be:The return NTBS might take the form: what_arg + ": " + code().message()if (msg.empty()) { try { std::string tmp = runtime_error::what(); if (code()) { if (!tmp.empty()) tmp += ": "; tmp += code().message(); } swap(msg, tmp); } catch(...) { return runtime_error::what(); } return msg.c_str();— end note]
In 27.5.2.1.1 [ios::failure], change the synopsis:
namespace std {
class ios_base::failure : public system_error {
public:
explicit failure(const string& msg, const error_code& ec = io_errc::stream);
explicit failure(const char* msg, const error_code& ec = io_errc::stream);
virtual const char* what() const throw();
};
}
In 27.5.2.1.1 [ios::failure], change the description of the constructors:
explicit failure(const string& msg, , const error_code& ec = io_errc::stream);-3- Effects: Constructs an object of class failure by constructing the base class with msg and ec.
-4- Postcondition: code() == ec and strcmp(what(), msg.c_str()) == 0explicit failure(const char* msg, const error_code& ec = io_errc::stream);-5- Effects: Constructs an object of class failure by constructing the base class with msg and ec.
-6- Postcondition: code() == ec and strcmp(what(), msg) == 0
In 27.5.2.1.1 [ios::failure], remove what (the base class definition need not be repeated here).
const char* what() const;-7- Returns: The message msg with which the exception was created.
Section: 27.5.4.2 [basic.ios.members] Status: New Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2009-04-25
View other active issues in [basic.ios.members].
View all other issues in [basic.ios.members].
View all issues with New status.
Discussion:
With the rvalue reference changes in N2844 basic_ios::move no longer has the most convenient signature:
void move(basic_ios&& rhs);
This signature should be changed to accept lvalues. It does not need to be overloaded to accept rvalues. This is a special case that only derived clients will see. The generic move still needs to accept rvalues.
Proposed resolution:
Change the prototype in the synopsis of 27.5.4 [ios] and in 27.5.4.2 [basic.ios.members]:
void move(basic_ios&&rhs);
Section: 24.2.8 [iterator.concepts.range] Status: New Submitter: David Abrahams Opened: 2009-04-23 Last modified: 2009-05-01
View all issues with New 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.
Proposed resolution:
Section: 30.6.5 [future.shared_future] Status: New Submitter: Thomas J. Gritzan Opened: 2009-04-03 Last modified: 2009-04-25
View other active issues in [future.shared_future].
View all other issues in [future.shared_future].
View all issues with New 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.
Proposed resolution:
Change 30.6.5 [future.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]
Section: 30.6.5 [future.shared_future] Status: New Submitter: Thomas J. Gritzan Opened: 2009-04-03 Last modified: 2009-04-25
View other active issues in [future.shared_future].
View all other issues in [future.shared_future].
View all issues with New status.
Discussion:
In the shared_future class definition in 30.6.5 [future.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);
Proposed resolution:
Change the synopsis in 30.6.5 [future.shared_future]:
shared_future(unique_future<R>&& rhs);
Change the definition of the constructor in 30.6.5 [future.shared_future]:
shared_future(constunique_future<R>&& rhs);
Section: 30.2.2 [thread.req.exception] Status: New Submitter: Christopher Kohlhoff Opened: 2009-04-25 Last modified: 2009-04-26
View all issues with New status.
Discussion:
The current formulation of 30.2.2 [thread.req.exception]/2 reads:
The error_category of the error_code reported by such an exception's code() member function is as specified in the error condition Clause.
This constraint on the code's associated error_categor means an implementation must perform a mapping from the system-generated error to a generic_category() error code. The problems with this include:
The original error produced by the operating system is lost.
The latter was one of Peter Dimov's main objections (in a private email discussion) to the original error_code-only design, and led to the creation of error_condition in the first place. Specifically, error_code and error_condition are intended to perform the following roles:
Any mapping determining correspondence of the returned error code to the conditions listed in the error condition clause falls under the "latitude" granted to implementors in 19.5.1.5 [syserr.errcat.objects]. (Although obviously their latitude is restricted a little by the need to match the right error condition when returning an error code from a library function.)
It is important that this error_code/error_condition usage is done correctly for the thread library since it is likely to set the pattern for future TR libraries that interact with the operating system.
Proposed resolution:
Change 30.2.2 [thread.req.exception]/2:
-2-
The error_category (19.5.1.1) of the error_code reported by such an exception's code() member function is as specified in the error condition Clause.The error_code reported by such an exception's code() member function shall compare equal to one of the conditions specified in the function's error condition Clause. [Example: When the thread constructor fails:ec.category() == implementation-defined // probably system_category ec == errc::resource_unavailable_try_again // holds true— end example]
Section: 25.5.5.1 [includes] Status: New Submitter: Alisdair Meredith Opened: 2009-04-28 Last modified: 2009-05-01
View other active issues in [includes].
View all other issues in [includes].
View all issues with New 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.
Proposed resolution:
Change 25.2 [algorithms.syn] and 25.5.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);
Section: 25.3.4 [alg.foreach] Status: New Submitter: Alisdair Meredith Opened: 2009-04-29 Last modified: 2009-05-01
View other active issues in [alg.foreach].
View all other issues in [alg.foreach].
View all issues with New status.
Discussion:
Quoting working paper for reference (25.3.4 [alg.foreach]):
template<InputIterator Iter, Callable<auto, Iter::reference> Function> requires CopyConstructible<Function> Function for_each(Iter first, Iter last, Function f);1 Effects: Applies f to the result of dereferencing every iterator in the range [first,last), starting from first and proceeding to last - 1.
2 Returns: f.
3 Complexity: Applies f exactly last - first times.
P2 implies the passed object f should be invoked at each stage, rather than some copy of f. This is important if the return value is to usefully accumulate changes. So the requirements are an object of type Function can be passed-by-value, invoked multiple times, and then return by value. In this case, MoveConstructible is sufficient. This would open support for move-only functors, which might become important in concurrent code as you can assume there are no other references (copies) of a move-only type and so freely use them concurrently without additional locks.
[ See further discussion starting with c++std-lib-23686. ]
Proposed resolution:
Change 25.2 [algorithms.syn] and 25.3.4 [alg.foreach]:
template<InputIterator Iter, Callable<auto, Iter::reference> Function> requiresCopyConstructibleMoveConstructible<Function> Function for_each(Iter first, Iter last, Function f);
Section: 23.4 [associative] Status: New Submitter: Alisdair Meredith Opened: 2009-04-29 Last modified: 2009-05-01
View other active issues in [associative].
View all other issues in [associative].
View all issues with New 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.
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.4 [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<<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<<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<<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<<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<<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<<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<<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<<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 { ... }; }