| Doc. no. | N3054=10-0044 |
| Date: | 2010-03-12 |
| 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, i.e., issues which have a status of New, Open, Ready, or 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 Concepts - The LWG has reached consensus that the issue is NAD for now, but represents a real issue when the library is done with language-supported concepts.
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.
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.
Tentatively - This is a status qualifier. The issue has been reviewed online, or at an unofficial meeting, but not in an official meeting, and some support has been formed for the qualified status. Tentatively qualified issues may be moved to the unqualified status and forwarded to full committee (if Ready) within the same meeting. Unlike Ready issues, Tentatively Ready issues will be reviewed in subcommittee prior to forwarding to full committee. When a status is qualified with Tentatively, the issue is still considered active.
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: 20.3.4 [pairs] Status: Ready Submitter: Martin Sebor Opened: 2001-01-14 Last modified: 2009-10-26
View other active issues in [pairs].
View all other issues in [pairs].
View all issues with Ready status.
Discussion:
The synopsis of the header <utility> in 20.3 [utility] lists the complete set of equality and relational operators for pair but the section describing the template and the operators only describes operator==() and operator<(), and it fails to mention any requirements on the template arguments. The remaining operators are not mentioned at all.
[ 2009-09-27 Alisdair reopens. ]
The issue is a lack of wording specifying the semantics of std::pair relational operators. The rationale is that this is covered by catch-all wording in the relops component, and that as relops directly precedes pair in the document this is an easy connection to make.
Reading the current working paper I make two observations:
- relops no longer immediately precedes pair in the order of specification. However, even if it did, there is a lot of pair specification itself between the (apparently) unrelated relops and the relational operators for pair. (The catch-all still requires operator== and operator< to be specified explicitly)
- No other library component relies on the catch-all clause. The following all explicitly document all six relational operators, usually in a manner that could have deferred to the relops clause.
tuple unique_ptr duration time_point basic_string queue stack move_iterator reverse_iterator regex submatch thread::idThe container components provide their own (equivalent) definition in 23.2.1 [container.requirements.general] Table 90 -- Container requirements and do so do not defer to relops.
Shared_ptr explicitly documents operator!= and does not supply the other 3 missing operators (>,>=,<=) so does not meet the reqirements of the relops clause.
Weak_ptr only supports operator< so would not be covered by relops.
At the very least I would request a note pointing to the relops clause we rely on to provide this definition. If this route is taken, I would recommend reducing many of the above listed clauses to a similar note rather than providing redundant specification.
My preference would be to supply the 4 missing specifications consistent with the rest of the library.
[ 2009-10-11 Daniel opens 1233 which deals with the same issue as it pertains to unique_ptr. ]
[ 2009-10 Santa Cruz: ]
Move to Ready
Proposed resolution:
After p20 20.3.4 [pairs] add:
template <class T1, class T2> bool operator!=(const pair<T1,T2>& x, const pair<T1,T2>& y);Returns: !(x==y)template <class T1, class T2> bool operator> (const pair<T1,T2>& x, const pair<T1,T2>& y);Returns: y < xtemplate <class T1, class T2> bool operator>=(const pair<T1,T2>& x, const pair<T1,T2>& y);Returns: !(x < y)template <class T1, class T2> bool operator<=(const pair<T1,T2>& x, const pair<T1,T2>& y);Returns: !(y < x)
Rationale:
20.3.1 [operators] paragraph 10 already specifies the semantics. That paragraph says that, if declarations of operator!=, operator>, operator<=, and operator>= appear without definitions, they are defined as specified in 20.3.1 [operators]. There should be no user confusion, since that paragraph happens to immediately precede the specification of pair.
Section: 24.2.4 [bidirectional.iterators], 24.2.5 [random.access.iterators] Status: Open Submitter: John Potter Opened: 2001-01-22 Last modified: 2009-10-26
View all other issues in [bidirectional.iterators].
View all issues with Open status.
Discussion:
In section 24.2.4 [bidirectional.iterators], Table 75 gives the return type of *r-- as convertible to T. This is not consistent with Table 74 which gives the return type of *r++ as T&. *r++ = t is valid while *r-- = t is invalid.
In section 24.2.5 [random.access.iterators], Table 76 gives the return type of a[n] as convertible to T. This is not consistent with the semantics of *(a + n) which returns T& by Table 74. *(a + n) = t is valid while a[n] = t is invalid.
Discussion from the Copenhagen meeting: the first part is uncontroversial. The second part, operator[] for Random Access Iterators, requires more thought. There are reasonable arguments on both sides. Return by value from operator[] enables some potentially useful iterators, e.g. a random access "iota iterator" (a.k.a "counting iterator" or "int iterator"). There isn't any obvious way to do this with return-by-reference, since the reference would be to a temporary. On the other hand, reverse_iterator takes an arbitrary Random Access Iterator as template argument, and its operator[] returns by reference. If we decided that the return type in Table 76 was correct, we would have to change reverse_iterator. This change would probably affect user code.
History: the contradiction between reverse_iterator and the Random Access Iterator requirements has been present from an early stage. In both the STL proposal adopted by the committee (N0527==94-0140) and the STL technical report (HPL-95-11 (R.1), by Stepanov and Lee), the Random Access Iterator requirements say that operator[]'s return value is "convertible to T". In N0527 reverse_iterator's operator[] returns by value, but in HPL-95-11 (R.1), and in the STL implementation that HP released to the public, reverse_iterator's operator[] returns by reference. In 1995, the standard was amended to reflect the contents of HPL-95-11 (R.1). The original intent for operator[] is unclear.
In the long term it may be desirable to add more fine-grained iterator requirements, so that access method and traversal strategy can be decoupled. (See "Improved Iterator Categories and Requirements", N1297 = 01-0011, by Jeremy Siek.) Any decisions about issue 299 should keep this possibility in mind.
Further discussion: I propose a compromise between John Potter's resolution, which requires T& as the return type of a[n], and the current wording, which requires convertible to T. The compromise is to keep the convertible to T for the return type of the expression a[n], but to also add a[n] = t as a valid expression. This compromise "saves" the common case uses of random access iterators, while at the same time allowing iterators such as counting iterator and caching file iterators to remain random access iterators (iterators where the lifetime of the object returned by operator*() is tied to the lifetime of the iterator).
Note that the compromise resolution necessitates a change to reverse_iterator. It would need to use a proxy to support a[n] = t.
Note also there is one kind of mutable random access iterator that will no longer meet the new requirements. Currently, iterators that return an r-value from operator[] meet the requirements for a mutable random access iterartor, even though the expression a[n] = t will only modify a temporary that goes away. With this proposed resolution, a[n] = t will be required to have the same operational semantics as *(a + n) = t.
[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]
[ 2009-09-18 Alisdair adds: ]
Why can't we write through the reference returned from operator[] on a random access iterator?
Recommended solution:
In table Table 104 -- Random access iterator requirements, replace
a[n] : convertible toconst T &T& if X is mutable, otherwise convertible to const T&
[ 2009-10 Santa Cruz: ]
Leave Open. Alisdair to spearhead a paper on revivification.
Proposed resolution:
In section 24.1.4 [lib.bidirectdional.iterators], change the return type in table 75 from "convertible to T" to T&.
In section 24.1.5 [lib.random.access.iterators], change the operational semantics for a[n] to " the r-value of a[n] is equivalent to the r-value of *(a + n)". Add a new row in the table for the expression a[n] = t with a return type of convertible to T and operational semantics of *(a + n) = t.
[Lillehammer: Real problem, but should be addressed as part of iterator redesign]
Rationale:
[ San Francisco: ]
Solved by N2758.
Section: 24.2 [iterator.requirements] Status: Open Submitter: Nathan Myers Opened: 2003-06-03 Last modified: 2009-11-03
View other active issues in [iterator.requirements].
View all other issues in [iterator.requirements].
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.
X [iterator.concepts] says that the only operation that can be performed on "singular" iterator values is to assign a non-singular value to them. (It doesn't say they can be destroyed, and that's probably a defect.) Some implementations have taken this to imply that there is no need to initialize the data member of a reverse_iterator<> in the default constructor. As a result, code like
std::vector<std::reverse_iterator<char*> > v(7); v.reserve(1000);
invokes undefined behavior, because it must default-initialize the vector elements, and then copy them to other storage. Of course many other vector operations on these adapters are also left undefined, and which those are is not reliably deducible from the standard.
I don't think that 24.1 was meant to make standard-library iterator types unsafe. Rather, it was meant to restrict what operations may be performed by functions which take general user- and standard iterators as arguments, so that raw pointers would qualify as iterators. However, this is not clear in the text, others have come to the opposite conclusion.
One question is whether the standard iterator adaptors have defined copy semantics. Another is whether they have defined destructor semantics: is
{ std::vector<std::reverse_iterator<char*> > v(7); }
undefined too?
Note this is not a question of whether algorithms are allowed to rely on copy semantics for arbitrary iterators, just whether the types we actually supply support those operations. I believe the resolution must be expressed in terms of the semantics of the adapter's argument type. It should make clear that, e.g., the reverse_iterator<T> constructor is actually required to execute T(), and so copying is defined if the result of T() is copyable.
Issue 235, which defines reverse_iterator's default constructor more precisely, has some relevance to this issue. However, it is not the whole story.
The issue was whether
reverse_iterator() { }
is allowed, vs.
reverse_iterator() : current() { }
The difference is when T is char*, where the first leaves the member uninitialized, and possibly equal to an existing pointer value, or (on some targets) may result in a hardware trap when copied.
8.5 paragraph 5 seems to make clear that the second is required to satisfy DR 235, at least for non-class Iterator argument types.
But that only takes care of reverse_iterator, and doesn't establish a policy for all iterators. (The reverse iterator adapter was just an example.) In particular, does my function
template <typename Iterator>
void f() { std::vector<Iterator> v(7); }
evoke undefined behavior for some conforming iterator definitions? I think it does, now, because vector<> will destroy those singular iterator values, and that's explicitly disallowed.
24.1 shouldn't give blanket permission to copy all singular iterators, because then pointers wouldn't qualify as iterators. However, it should allow copying of that subset of singular iterator values that are default-initialized, and it should explicitly allow destroying any iterator value, singular or not, default-initialized or not.
[ We don't want to require all singular iterators to be copyable, because that is not the case for pointers. However, default construction may be a special case. Issue: is it really default construction we want to talk about, or is it something like value initialization? We need to check with core to see whether default constructed pointers are required to be copyable; if not, it would be wrong to impose so strict a requirement for iterators. ]
[ 2009-05-10 Alisdair provided wording. ]
The comments regarding destroying singular iterators have already been resolved. That just leaves copying (with moving implied).
[ 2009-07 Frankfurt ]
This is related to LWG 1012.
Note that there is a bug in the proposed resolution to LWG 1012. The change to [reverse.iter.con] should be modified so that the word "default" in the second sentence of the Effects clause is replaced by "value."
We believe that the proposed fix to LWG 1012 (now corrected) is sufficient to solve the problem for reverse_iterator. However, Alisdair pointed out that LWG 1012 does not solve the general problem for authors of iterator adaptors.
There are some problems with the proposed resolution. The phrase "safely copyable" is not a term of art. Also, it mentions a DefaultConstructible? concept.
Move to Review after Alisdair updates the wording.
[ 2009-07-31 Alisdair revised wording: ]
[ 2009-08-17 Alisdair and Daniel collaborate on slightly revised wording. This issue depends upon 724 ]
[ 2009-10-14 Daniel adds: ]
There is a clear dependency on 1213, because the term "singular", which is used as part of the resolution, is not properly defined yet.
[ 2009-10 Santa Cruz: ]
Moved to Open. Alisdair will provide improved wording to make this have "value semantics" and otherwise behave like a valid iterator.
Proposed resolution:
Add a new paragrpah to Iterator concepts 24.2 [iterator.requirements] after para 5 (the one describing singular iterators)
Just as a regular pointer to an array guarantees that there is a pointer value pointing past the last element of the array, so for any iterator type there is an iterator value that points past the last element of a corresponding container. These values are called past-the-end values. Values of an iterator i for which the expression *i is defined are called dereferenceable. The library never assumes that past-the-end values are dereferenceable. Iterators can also have singular values that are not associated with any container. [Example: After the declaration of an uninitialized pointer x (as with int* x;), x must always be assumed to have a singular value of a pointer. — end example] Results of most expressions are undefined for singular values; the only exceptions are destroying an iterator that holds a singular value and the assignment of a non-singular value to an iterator that holds a singular value. In this case the singular value is overwritten the same way as any other value. Dereferenceable values are always non-singular.
After value-initialization, any iterator that satisfies the DefaultConstructible requirements ([defaultconstructible]) shall not introduce undefined behaviour when used as the source of a copy or move operation, even if it would otherwise be singular. [Note: This guarantee is not offered for default-initialization (8.5 [dcl.init]), although the distinction only matters for types with trivial default constructors such as pointers. — end note]
Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: Ready Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2010-03-09
View other active issues in [facet.num.get.virtuals].
View all other issues in [facet.num.get.virtuals].
View all issues with Ready 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>.
[ 2009-07 Frankfurt ]
There was general agreement that the standard only needs to specify the behavior when the character type is char or wchar_t.
Beman: we don't need to worry about C++1x because there is a non-zero possibility that we would have a replacement facility for iostreams that would solve these problems.
We need to change the following sentence in [locale.category], paragraph 6 to specify that C is char and wchar_t:
"A template formal parameter with name C represents the set of all possible specializations on a parameter that satisfies the requirements for a character on which any member of the iostream components can be instantiated."
We also need to specify in 27 that the basic character operations, such as eq, lt, and assign use std::char_traits.
Daniel volunteered to provide wording.
[ 2009-09-19 Daniel provided wording. ]
[ 2009-10 Santa Cruz: ]
Leave as Open. Alisdair and/or Tom will provide wording based on discussions. We want to clearly state that streams and locales work just on char and wchar_t (except where otherwise specified).
[ 2010-02-06 Tom updated the proposed wording. ]
[ The original proposed wording is preserved here: ]
Change 22.3.1.1.1 [locale.category]/6:
[..] A template formal parameter with name C represents the set of all possible specializations on a char or wchar_t parameterthat satisfies the requirements for a character on which any of the iostream components can be instantiated. [..]Add the following sentence to the end of 22.4.2 [category.numeric]/2:
[..] These specializations refer to [..], and also for the ctype<> facet to perform character classification. Implementations are encouraged but not required to use the char_traits<charT> functions for all comparisons and assignments of characters of type charT that do not belong to the set of required specializations.Change 22.4.2.1.2 [facet.num.get.virtuals]/3:
Stage 2: If in==end then stage 2 terminates. Otherwise a charT is taken from in and local variables are initialized as if by
char_type ct = *in; using tr = char_traits<char_type>; const char_type* pos = tr::find(atoms, sizeof(src) - 1, ct); char c = src[find(atoms, atoms + sizeof(src) - 1, ct) - atomspos ? pos - atoms : sizeof(src) - 1]; if (tr::eq(ct,ct ==use_facet<numpunct<charT>(loc).decimal_point())) c = '.'; bool discard = tr::eq(ct,ct ==use_facet<numpunct<charT>(loc).thousands_sep()) && use_facet<numpunct<charT> >(loc).grouping().length() != 0;where the values src and atoms are defined as if by: [..]
[Remark of the author: I considered to replace the initialization "char_type ct = *in;" by the sequence "char_type ct; tr::assign(ct, *in);", but decided against it, because it is a copy-initialization context, not an assignment]
Add the following sentence to the end of 22.4.5 [category.time]/1:
[..] Their members use [..] , to determine formatting details. Implementations are encouraged but not required to use the char_traits<charT> functions for all comparisons and assignments of characters of type charT that do not belong to the set of required specializations.Change 22.4.5.1.1 [locale.time.get.members]/8 bullet 4:
The next element of fmt is equal to '%'For the next element c of fmt char_traits<char_type>::eq(c, use_facet<ctype<char_type>>(f.getloc()).widen('%')) == true, [..]Add the following sentence to the end of 22.4.6 [category.monetary]/2:
Their members use [..] to determine formatting details. Implementations are encouraged but not required to use the char_traits<charT> functions for all comparisons and assignments of characters of type charT that do not belong to the set of required specializations.Change 22.4.6.1.2 [locale.money.get.virtuals]/4:
[..] The value units is produced as if by:
for (int i = 0; i < n; ++i) buf2[i] = src[char_traits<charT>::find(atoms,atoms+sizeof(src), buf1[i]) - atoms]; buf2[n] = 0; sscanf(buf2, "%Lf", &units);Change 22.4.6.2.2 [locale.money.put.virtuals]/1:
[..] for character buffers buf1 and buf2. If for the first character c in digits or buf2is equal to ct.widen('-')char_traits<charT>::eq(c, ct.widen('-')) == true, [..]Add a footnote to the first sentence of 27.7.1.2.2 [istream.formatted.arithmetic]/1:
As in the case of the inserters, these extractors depend on the locale's num_get<> (22.4.2.1) object to perform parsing the input stream data.(footnote) [..]
footnote) If the traits of the input stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
Add a footnote to the second sentence of 27.7.2.6.2 [ostream.inserters.arithmetic]/1:
Effects: The classes num_get<> and num_put<> handle locale-dependent numeric formatting and parsing. These inserter functions use the imbued locale value to perform numeric formatting.(footnote) [..]
footnote) If the traits of the output stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
Add a footnote after the first sentence of 27.7.4 [ext.manip]/4:
Returns: An object of unspecified type such that if in is an object of type basic_istream<charT, traits> then the expression in >> get_money(mon, intl) behaves as if it called f(in, mon, intl), where the function f is defined as:(footnote) [..]
footnote) If the traits of the input stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
Add a footnote after the first sentence of 27.7.4 [ext.manip]/5:
Returns: An object of unspecified type such that if out is an object of type basic_ostream<charT, traits> then the expression out << put_money(mon, intl) behaves as a formatted input function that calls f(out, mon, intl), where the function f is defined as:(footnote) [..]
footnote) If the traits of the output stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
13) Add a footnote after the first sentence of 27.7.4 [ext.manip]/8:
Returns: An object of unspecified type such that if in is an object of type basic_istream<charT, traits> then the expression in >>get_time(tmb, fmt) behaves as if it called f(in, tmb, fmt), where the function f is defined as:(footnote) [..]
footnote) If the traits of the input stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
Add a footnote after the first sentence of 27.7.4 [ext.manip]/10:
Returns: An object of unspecified type such that if out is an object of type basic_ostream<charT, traits> then the expression out <<put_time(tmb, fmt) behaves as if it called f(out, tmb, fmt), where the function f is defined as:(footnote) [..]
footnote) If the traits of the output stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
[ 2010 Pittsburgh: ]
Moved to Ready with only two of the bullets. The original wording is preserved here:
Change 22.3.1.1.1 [locale.category]/6:
[..] A template formal parameter with name C represents the setof all possible specializations on aof types containing char, wchar_t, and any other implementation-defined character typeparameterthat satisfies the requirements for a character on which any of the iostream components can be instantiated. [..]Add the following sentence to the end of 22.4.2 [category.numeric]/2:
[..] These specializations refer to [..], and also for the ctype<> facet to perform character classification. [Note: Implementations are encouraged but not required to use the char_traits<charT> functions for all comparisons and assignments of characters of type charT that do not belong to the set of required specializations - end note].Change 22.4.2.1.2 [facet.num.get.virtuals]/3:
Stage 2: If in==end then stage 2 terminates. Otherwise a charT is taken from in and local variables are initialized as if by
char_type ct = *in; using tr = char_traits<char_type>; const char_type* pos = tr::find(atoms, sizeof(src) - 1, ct); char c = src[find(atoms, atoms + sizeof(src) - 1, ct) - atomspos ? pos - atoms : sizeof(src) - 1]; if (tr::eq(ct,ct ==use_facet<numpunct<charT>(loc).decimal_point())) c = '.'; bool discard = tr::eq(ct,ct ==use_facet<numpunct<charT>(loc).thousands_sep()) && use_facet<numpunct<charT> >(loc).grouping().length() != 0;where the values src and atoms are defined as if by: [..]
[Remark of the author: I considered to replace the initialization "char_type ct = *in;" by the sequence "char_type ct; tr::assign(ct, *in);", but decided against it, because it is a copy-initialization context, not an assignment]
Add the following sentence to the end of 22.4.5 [category.time]/1:
[..] Their members use [..] , to determine formatting details. [Note: Implementations are encouraged but not required to use the char_traits<charT> functions for all comparisons and assignments of characters of type charT that do not belong to the set of required specializations - end note].Change 22.4.5.1.1 [locale.time.get.members]/8 bullet 4:
The next element of fmt is equal to '%'For the next element c of fmt char_traits<char_type>::eq(c, use_facet<ctype<char_type>>(f.getloc()).widen('%')) == true, [..]Add the following sentence to the end of 22.4.6 [category.monetary]/2:
Their members use [..] to determine formatting details. [Note: Implementations are encouraged but not required to use the char_traits<charT> functions for all comparisons and assignments of characters of type charT that do not belong to the set of required specializations - end note].Change 22.4.6.1.2 [locale.money.get.virtuals]/4:
[..] The value units is produced as if by:
for (int i = 0; i < n; ++i) buf2[i] = src[char_traits<charT>::find(atoms,atoms+sizeof(src), buf1[i]) - atoms]; buf2[n] = 0; sscanf(buf2, "%Lf", &units);Change 22.4.6.2.2 [locale.money.put.virtuals]/1:
[..] for character buffers buf1 and buf2. If for the first character c in digits or buf2is equal to ct.widen('-')char_traits<charT>::eq(c, ct.widen('-')) == true, [..]Add a new paragraph after the first paragraph of 27.2.2 [iostreams.limits.pos]/1:
In the classes of clause 27, a template formal parameter with name charT represents one of the set of types containing char, wchar_t, and any other implementation-defined character type that satisfies the requirements for a character on which any of the iostream components can be instantiated.Add a footnote to the first sentence of 27.7.1.2.2 [istream.formatted.arithmetic]/1:
As in the case of the inserters, these extractors depend on the locale's num_get<> (22.4.2.1) object to perform parsing the input stream data.(footnote) [..]
footnote) If the traits of the input stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
Add a footnote to the second sentence of 27.7.2.6.2 [ostream.inserters.arithmetic]/1:
Effects: The classes num_get<> and num_put<> handle locale-dependent numeric formatting and parsing. These inserter functions use the imbued locale value to perform numeric formatting.(footnote) [..]
footnote) If the traits of the output stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
Add a footnote after the first sentence of 27.7.4 [ext.manip]/4:
Returns: An object of unspecified type such that if in is an object of type basic_istream<charT, traits> then the expression in >> get_money(mon, intl) behaves as if it called f(in, mon, intl), where the function f is defined as:(footnote) [..]
footnote) If the traits of the input stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
Add a footnote after the first sentence of 27.7.4 [ext.manip]/5:
Returns: An object of unspecified type such that if out is an object of type basic_ostream<charT, traits> then the expression out << put_money(mon, intl) behaves as a formatted input function that calls f(out, mon, intl), where the function f is defined as:(footnote) [..]
footnote) If the traits of the output stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
Add a footnote after the first sentence of 27.7.4 [ext.manip]/8:
Returns: An object of unspecified type such that if in is an object of type basic_istream<charT, traits> then the expression in >>get_time(tmb, fmt) behaves as if it called f(in, tmb, fmt), where the function f is defined as:(footnote) [..]
footnote) If the traits of the input stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
Add a footnote after the first sentence of 27.7.4 [ext.manip]/10:
Returns: An object of unspecified type such that if out is an object of type basic_ostream<charT, traits> then the expression out <<put_time(tmb, fmt) behaves as if it called f(out, tmb, fmt), where the function f is defined as:(footnote) [..]
footnote) If the traits of the output stream has different semantics for lt(), eq(), and assign() than char_traits<char_type>, this may give surprising results.
Proposed resolution:
Change 22.3.1.1.1 [locale.category]/6:
[..] A template formal parameter with name C represents the setof all possible specializations on aof types containing char, wchar_t, and any other implementation-defined character typeparameterthat satisfies the requirements for a character on which any of the iostream components can be instantiated. [..]
Add a new paragraph after the first paragraph of 27.2.2 [iostreams.limits.pos]/1:
In the classes of clause 27, a template formal parameter with name charT represents one of the set of types containing char, wchar_t, and any other implementation-defined character type that satisfies the requirements for a character on which any of the iostream components can be instantiated.
Section: 26.6.2.4 [valarray.sub] Status: Ready Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2010-03-12
View all issues with Ready 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. ]
[ 2009-07 Frankfurt ]
Move to Ready.
[ 2009-11-04 Pete opens: ]
The resolution to LWG issue 430 has not been applied --- there have been changes to the underlying text, and the resolution needs to be reworked.
[ 2010-03-09 Matt updated wording. ]
[ 2010 Pittsburgh: Moved to Ready for Pittsburgh. ]
Proposed resolution:
Replace 26.6.2.4 [valarray.sub], with the following:
The member operator is overloaded to provide several ways to select sequences of elements from among those controlled by *this. Each of these operations returns a subset of the array. The const-qualified versions return this subset as a new valarray. The non-const versions return a class template object which has reference semantics to the original array, working in conjunction with various overloads of operator= (and other assigning operators) to allow selective replacement (slicing) of the controlled sequence. In each case the selected element(s) must exist.
valarray<T> operator[](slice slicearr) const;This function returns an object of class valarray<T> containing those elements of the controlled sequence designated by slicearr. [Example:
valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDE", 5); v0[slice(2, 5, 3)] = v1; // v0 == valarray<char>("abAdeBghCjkDmnEp", 16)end example]
valarray<T> operator[](slice slicearr);This function selects those elements of the controlled sequence designated by slicearr. [Example:
valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDE", 5); v0[slice(2, 5, 3)] = v1; // v0 == valarray<char>("abAdeBghCjkDmnEp", 16)end example]
valarray<T> operator[](const gslice& gslicearr) const;This function returns an object of class valarray<T> containing those elements of the controlled sequence designated by gslicearr. [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)end example]
gslice_array<T> operator[](const gslice& gslicearr);This function selects those elements of the controlled sequence designated by gslicearr. [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)end example]
valarray<T> operator[](const valarray<bool>& boolarr) const;This function returns an object of class valarray<T> containing those elements of the controlled sequence designated by boolarr. [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)end example]
mask_array<T> operator[](const valarray<bool>& boolarr);This function selects those elements of the controlled sequence designated by boolarr. [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)end example]
valarray<T> operator[](const valarray<size_t>& indarr) const;This function returns an object of class valarray<T> containing those elements of the controlled sequence designated by indarr. [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)end example]
indirect_array<T> operator[](const valarray<size_t>& indarr);This function selects those elements of the controlled sequence designated by indarr. [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)end example]
Section: 24.2 [iterator.requirements], 23.2 [container.requirements] Status: Open Submitter: Andy Koenig Opened: 2003-12-16 Last modified: 2009-11-03
View other active issues in [iterator.requirements].
View all other issues in [iterator.requirements].
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. ]
[ 2009-07 Frankfurt ]
Daniel volunteered to work on this.
[ 2009-09-20 Daniel provided wording. ]
[ 2009-10 Santa Cruz: ]
Leave as Open. Alisdair has volunteered to refine the wording.
Proposed resolution:
Insert a new paragraph between 24.2 [iterator.requirements]/7+8:
[..] The result of the application of functions in the library to invalid ranges is undefined.
The result of directly or indirectly evaluating any comparison function or the binary - operator with two iterator values as arguments that were obtained from two different ranges r1 and r2 (including their past-the-end values) which are not subranges of one common range is undefined, unless explicitly described otherwise.
Section: 18.8.1 [exception] Status: Ready Submitter: Martin Sebor Opened: 2004-06-28 Last modified: 2009-10-26
View all issues with Ready 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 derived to a base.
[ Batavia (2009-05): ]
Howard supplied the following replacement wording for paragraph 7 of the proposed resolution:
-7- Postcondition: what() shall return the same NTBS as would be obtained by using static_cast to cast the rhs to the same types as the lhs and then calling what() on that possibly sliced object.Pete asks what "the same NTBS" means.
[ 2009-07-30 Niels adds: ]
Further discussion in the thread starting with c++std-lib-24512.
[ 2009-09-24 Niels provided updated wording: ]
I think the resolution should at least guarantee that the result of what() is independent of whether the compiler does copy-elision. And for any class derived from std::excepion that has a constructor that allows specifying a what_arg, it should make sure that the text of a user-provided what_arg is preserved, when the object is copied. Note that all the implementations I've tested already appear to satisfy the proposed resolution, including MSVC 2008 SP1, Apache stdcxx-4.2.1, GCC 4.1.2, GCC 4.3.2, and CodeGear C++ 6.13.
The proposed resolution was updated with help from Daniel Krügler; the update aims to clarify that the proposed postcondition only applies to homogeneous copying.
[ 2009-10 Santa Cruz: ]
Moved to Ready after inserting "publicly accessible" in two places.
Proposed resolution:
Change 18.8.1 [exception] to:
-1- The class exception defines the base class for the types of objects thrown as exceptions by C++ standard library components, and certain expressions, to report errors detected during program execution.
Each standard library class T that derives from class exception shall have a publicly accessible copy constructor and a publicly accessible copy assignment operator that do not exit with an exception. These member functions shall preserve the following postcondition: If two objects lhs and rhs both have dynamic type T, and lhs is a copy of rhs, then strcmp(lhs.what(), rhs.what()) == 0.
...
exception(const exception& rhs) throw(); exception& operator=(const exception& rhs) throw();-4- Effects: Copies an exception object.
-5- Remarks: The effects of calling what() after assignment are implementation-defined.-5- Postcondition: If *this and rhs both have dynamic type exception then strcmp(what(), rhs.what()) == 0.
Section: 22.4.1.1 [locale.ctype] Status: Ready Submitter: Martin Sebor Opened: 2004-07-01 Last modified: 2009-10-21
View all issues with Ready 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.
[ 2009-07 Frankfurt, Howard provided wording directed by consensus. ]
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Add paragraph 3 to 22.4 [locale.categories]:
-3- Within this clause it is unspecified if one virtual function calls another virtual function.
Rationale:
We are explicitly not addressing bullet item #2, thus giving implementors more latitude. Users will have to override both virtual functions, not just one.
Section: 26.7.3 [partial.sum] Status: Ready Submitter: Marc Schoolderman Opened: 2006-02-06 Last modified: 2009-10-24
View all issues with Ready 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.
[ 2009-05-09 Alisdair adds: ]
Now that we have the facility, the 'best' accumulator type could probably be deduced as:
std::common_type<InIter::value_type, OutIter::reference>::typeThis type would then have additional requirements of constructability and incrementability/assignability.
If this extracting an accumulator type from a pair/set of iterators (with additional requirements on that type) is a problem for multiple functions, it might be worth extracting into a SharedAccumulator concept or similar.
I'll go no further in writing up wording now, until the group gives a clearer indication of preferred direction.
[ 2009-07 Frankfurt ]
The proposed resolution isn't quite right. For example, "the type of *first" should be changed to "iterator::value_type" or similar. Daniel volunteered to correct the wording.
[ 2009-07-29 Daniel corrected wording. ]
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Change 26.7.3 [partial.sum]/1 as indicated:
Effects: Let VT be InputIterator's value type. For a nonempty range, initializes an accumulator acc of type VT with *first and performs *result = acc. For every iterator i in [first + 1, last) in order, acc is then modified by acc = acc + *i or acc = binary_op(acc, *i) and is assigned to *(result + (i - first)).
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)))
orbinary_op(binary_op(..., binary_op(*first, *(first + 1)),...), *(first + (i - result)))
Change 26.7.3 [partial.sum]/3 as indicated:
Complexity: Exactly max((last - first) - 1, 0) applications ofbinary_opthe binary operation.
Change 26.7.3 [partial.sum]/4 as indicated:
Requires: VT shall be constructible from the type of *first, the result of acc + *i or binary_op(acc, *i) shall be implicitly convertible to VT, and the result of the expression acc shall be writable to the result output iterator. In the ranges [first,last] and [result,result + (last - first)] [..]
Change 26.7.4 [adjacent.difference]/1 as indicated:
Effects: Let VT be InputIterator's value type. For a nonempty range, initializes an accumulator acc of type VT with *first and performs *result = acc. For every iterator i in [first + 1, last) in order, initializes a value val of type VT with *i, assigns the result of val - acc or binary_op(val, acc) to *(result + (i - first)) and modifies acc = std::move(val).
Assigns to every element referred to by iterator i in the range [result + 1, result + (last - first)) a value correspondingly equal to*(first + (i - result)) - *(first + (i - result) - 1)
orbinary_op(*(first + (i - result)), *(first + (i - result) - 1)).
result gets the value of *first.
Change 26.7.4 [adjacent.difference]/2 as indicated:
Requires: VT shall be MoveAssignable ([moveassignable]) and shall be constructible from the type of *first. The result of the expression acc and the result of the expression val - acc or binary_op(val, acc) shall be writable to the result output iterator. In the ranges [first,last] [..]
Change 26.7.4 [adjacent.difference]/5 as indicated:
Complexity: Exactly max((last - first) - 1, 0) applications ofbinary_opthe binary operation.
Section: 25.4 [alg.sorting] Status: Ready Submitter: Martin Sebor Opened: 2006-02-05 Last modified: 2010-03-08
View all other issues in [alg.sorting].
View all issues with Ready status.
Discussion:
In 25, p8 we allow BinaryPredicates to return a type that's convertible to bool but need not actually be bool. That allows predicates to return things like proxies and requires that implementations be careful about what kinds of expressions they use the result of the predicate in (e.g., the expression in if (!pred(a, b)) need not be well-formed since the negation operator may be inaccessible or return a type that's not convertible to bool).
Here's the text for reference:
...if an algorithm takes BinaryPredicate binary_pred as its argument and first1 and first2 as its iterator arguments, it should work correctly in the construct if (binary_pred(*first1, first2)){...}.
In 25.3, p2 we require that the Compare function object return true of false, which would seem to preclude such proxies. The relevant text is here:
Compare is used as a function object which returns true if the first argument is less than the second, and false otherwise...
[ Portland: Jack to define "convertible to bool" such that short circuiting isn't destroyed. ]
[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]
[ 2009-10 Santa Cruz: ]
Move to Review once wording received. Stefanus to send proposed wording.
[ 2009-10 Santa Cruz: ]
Move to Review once wording received. Stefanus to send proposed wording.
[ 2009-10-24 Stefanus supplied wording. ]
Move to Review once wording received. Stefanus to send proposed wording. Old proposed wording here:I think we could fix this by rewording 25.3, p2 to read somthing like:
-2- Compare is
used as a function object which returns true if the first argumenta BinaryPredicate. The return value of the function call operator applied to an object of type Compare, when converted to type bool, yields true if the first argument of the call is less than the second, and false otherwise. Compare comp is used throughout for algorithms assuming an ordering relation. It is assumed that comp will not apply any non-constant function through the dereferenced iterator.
[ 2010-01-17: ]
Howard expresses concern that the current direction of the proposed wording outlaws expressions such as:
if (!comp(x, y))Daniel provides wording which addresses that concern.
The previous wording is saved here:
Change 25.4 [alg.sorting] p2:
Compare is used as a function object. The return value of the function call operator applied to an object of type Compare, when converted to type bool, yields true if the first argument of the callwhich returns true if the first argumentis less than the second, and false otherwise. Compare comp is used throughout for algorithms assuming an ordering relation. It is assumed that comp will not apply any non-constant function through the dereferenced iterator.
[ 2010-01-22 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change 25.1 [algorithms.general]/7+8 as indicated. [This change is recommended to bring the return value requirements of BinaryPredicate and Compare in sync.]
7 The Predicate parameter is used whenever an algorithm expects a function object that when applied to the result of dereferencing the corresponding iterator returns a value testable as true. In other words, if an algorithm takes Predicate pred as its argument and first as its iterator argument, it should work correctly in the construct
if (pred(*first)){...}pred(*first) contextually converted to bool (4 [conv]). The function object pred shall not apply any nonconstant function through the dereferenced iterator. This function object may be a pointer to function, or an object of a type with an appropriate function call operator.8 The BinaryPredicate parameter is used whenever an algorithm expects a function object that when applied to the result of dereferencing two corresponding iterators or to dereferencing an iterator and type T when T is part of the signature returns a value testable as true. In other words, if an algorithm takes BinaryPredicate binary_pred as its argument and first1 and first2 as its iterator arguments, it should work correctly in the construct
if (binary_pred(*first1, *first2)){...}binary_pred(*first1, *first2) contextually converted to bool (4 [conv]). BinaryPredicate always takes the first iterator type as its first argument, that is, in those cases when T value is part of the signature, it should work correctly in thecontext of if (binary_pred(*first1, value)){...}construct binary_pred(*first1, value) contextually converted to bool (4 [conv]). binary_pred shall not apply any non-constant function through the dereferenced iterators.
Change 25.4 [alg.sorting]/2 as indicated:
2 Compare isused asa function object type (20.8 [function.objects]). The return value of the function call operation applied to an object of type Compare, when contextually converted to type bool (4 [conv]), yields true if the first argument of the callwhich returns true if the first argumentis less than the second, and false otherwise. Compare comp is used throughout for algorithms assuming an ordering relation. It is assumed that comp will not apply any non-constant function through the dereferenced iterator.
Section: 23.2.5 [unord.req] Status: Ready Submitter: Joaquín M López Muñoz Opened: 2006-06-13 Last modified: 2010-03-11
View other active issues in [unord.req].
View all other issues in [unord.req].
View all issues with Ready status.
Discussion:
See N2023 for full discussion.
[ 2009-12-11 Paolo opens: ]
I'm asking for DR 579 to be re-opened, basing on recent discussions on the library reflector, see Message c++std-lib-26040 and replies.
[ 2010-02-07 Paolo updates wording. ]
As pointed out by Chris in c++std-lib-26040, that an erase(unordered_container, iterator) returning an iterator can easily implemented in user code, if needed; that actually returning an iterator costs nothing for the overload taking two iterators, thus that proposed change is only for consistency; that forward_list::erase_after also returns void (for different reasons, granted, but isn't that any "erase" function in the containers uniformly returns an iterator); that, also in thread started by Chris' message, Alberto pointed out that the proxy idea isn't a good one; that users both of the GNU and Boost implementations are reporting serious performance problems with the current version returning an iterator.
[ 2010-02-07 Original wording saved here: ]
Option 1:
The problem can be eliminated by omitting the requirement that a.erase(q) return an iterator. This is, however, in contrast with the equivalent requirements for other standard containers.
Option 2:
a.erase(q) can be made to compute the next iterator only when explicitly requested: the technique consists in returning a proxy object implicitly convertible to iterator, so that
iterator q1=a.erase(q);works as expected, while
a.erase(q);does not ever invoke the conversion-to-iterator operator, thus avoiding the associated computation. To allow this technique, some sections of TR1 along the line "return value is an iterator..." should be changed to "return value is an unspecified object implicitly convertible to an iterator..." Although this trick is expected to work transparently, it can have some collateral effects when the expression a.erase(q) is used inside generic code.
[ 2010-02-09 Moved to Tentatively Ready after 6 positive votes on c++std-lib. ]
[ 2010 Pittsburgh: ]
There was no concensus for moving this to Ready. However there was concensus for moving this to NAD.
Rationale updated below.
[ 2010 Pittsburgh: ]
Reopened and proposed wording updated by Beman.
[ 2010 Pittsburgh: ]
Moved to Ready for Pittsburgh.
Rationale:
N2023 was discussed in Portland and the consensus was that there appears to be no need for either change proposed in the paper. The consensus opinion was that since the iterator could serve as its own proxy, there appears to be no need for the change. In general, "converts to" is undesirable because it interferes with template matching.
Post Toronto: There does not at this time appear to be consensus with the Portland consensus.
[ Bellevue: ]
The Bellevue review of this issue reached consensus with the Portland consensus, in contravention of the Toronto non-consensus. Common implementations have the iterator readily available, and most common uses depend on the iterator being returned.
****
The rationale for the change in direction here is best summarized by Paolo's 2010-02-07 comment.
Pittsburgh: Issue is wrong because we believe the standard is consistent as written and the complexity is achievable.
Pittsburgh: We want to enable both existing unordred container implementations.
Proposed resolution:
In 23.2.5 [unord.req], Table 98, change the following as indicated:
Table 98 — Unordered associative container requirements (in addition to container) Expression Return type Assertion/note pre-/post-condition Complexity a.erase(q) iterator Erases the element pointed to by q. Return value is the iterator immediately following q prior to the erasure. Average case O(1)O(max(1, 1/a.load_factor()), worst caseO(a.size())O(max(a.size(), a.bucket_count()).a.erase(q1, q2) iterator Erases all elements in the range [q1, q2). Return value is the iterator immediately following the erased elements prior to the erasure. Average case linear in distance(q1, q2)O(max(distance(q1,q2), 1/a.load_factor())), worst caseO(a.size())O(max(a.size(), a.bucket_count()).a.quick_erase(q) void Erases the element pointed to by q. Average case O(1), worst case O(a.size()). a.quick_erase(q1, q2) void Erases all elements in the range [q1, q2). Average case linear in distance(q1, q2), worst case O(a.size()).
Adjust the declarations accordingly in 23.5.1 [unord.map], 23.5.2 [unord.multimap], 23.5.3 [unord.set], and 23.5.4 [unord.multiset].
iterator erase(const_iterator position); void quick_erase(const_iterator position); ... iterator erase(const_iterator first, const_iterator last); void quick_erase(const_iterator first, const_iterator last);
Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: Ready Submitter: John Salmon Opened: 2007-04-20 Last modified: 2009-10-21
View other active issues in [facet.num.put.virtuals].
View all other issues in [facet.num.put.virtuals].
View all issues with Ready 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. ]
[ 2009-07 Frankfurt ]
Leave this open for Robert and Daniel to work on.
Straw poll: Disposition?
- Default is %.6a (i.e. NAD): 2
- Always %a (no precision): 6
- precision(-1) == %a: 3
Daniel and Robert have direction to write up wording for the "always %a" solution.
[ 2009-07-15 Robert provided wording. ]
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Change 22.4.2.2.2 [facet.num.put.virtuals], Stage 1, under p5 (near the end of Stage 1):
For conversion from a floating-point type, str.precision() is specified as precision in the conversion specification if floatfield != (ios_base::fixed | ios_base::scientific), else no precision is specified.
[ Kona (2007): Robert volunteers to propose wording. ]
Section: 23.5 [unord] Status: Ready Submitter: Howard Hinnant Opened: 2007-05-05 Last modified: 2010-03-09
View other active issues in [unord].
View all other issues in [unord].
View all issues with Ready status.
Discussion:
Move semantics are missing from the unordered containers. The proposed resolution below adds move-support consistent with N1858 and the current working draft.
The current proposed resolution simply lists the requirements for each function. These might better be hoisted into the requirements table for unordered associative containers. Futhermore a mild reorganization of the container requirements could well be in order. This defect report is purposefully ignoring these larger issues and just focusing on getting the unordered containers "moved".
[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]
[ 2009-10-17 Removed rvalue-swaps from wording. ]
[ 2009-10 Santa Cruz: ]
Move to Review. Alisdair will review proposed wording.
[ 2009-10-29 Daniel updates wording. ]
[ 2010-01-26 Alisdair updates wording. ]
[ 2010-02-10 Howard updates wording to reference the unordered container requirements table (modified by 704) as much as possible. ]
[ Voted to WP in Bellevue. ]
[ post Bellevue, Pete notes: ]
Please remind people who are reviewing issues to check that the text modifications match the current draft. Issue 676, for example, adds two overloads for unordered_map::insert taking a hint. One takes a const_iterator and returns a const_iterator, and the other takes an iterator and returns an iterator. This was correct at the time the issue was written, but was changed in Toronto so there is only one hint overload, taking a const_iterator and returning an iterator.
This issue is not ready. In addition to the relatively minor signature problem I mentioned earlier, it puts requirements in the wrong places. Instead of duplicating requirements throughout the template specifications, it should put them in the front matter that talks about requirements for unordered containers in general. This presentation problem is editorial, but I'm not willing to do the extensive rewrite that it requires. Please put it back into Open status.
[ 2010-02-11 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
[ 2010-02-24 Pete moved to Open: ]
The descriptions of the semantics of the added insert functions belong in the requirements table. That's where the rest of the insert functions are.
[ 2010 Pittsburgh: ]
Move issue 676 to Ready for Pittsburgh. Nico to send Howard an issue for the broader problem.
Rationale:
[ San Francisco: ]
Solved by N2776.
[ Rationale is obsolete. ]
Proposed resolution:
unordered_map
Change 23.5.1 [unord.map]:
class unordered_map
{
...
unordered_map(const unordered_map&);
unordered_map(unordered_map&&);
unordered_map(const Allocator&);
unordered_map(const unordered_map&, const Allocator&);
unordered_map(unordered_map&&, const Allocator&);
...
unordered_map& operator=(const unordered_map&);
unordered_map& operator=(unordered_map&&);
...
// modifiers
...
std::pair<iterator, bool> insert(const value_type& obj);
template <class P> pair<iterator, bool> insert(P&& obj);
iterator insert(const_iterator hint, const value_type& obj);
template <class P> iterator insert(const_iterator hint, P&& obj);
...
mapped_type& operator[](const key_type& k);
mapped_type& operator[](key_type&& k);
...
};
Add to 23.5.1.2 [unord.map.elem]:
mapped_type& operator[](const key_type& k);...
Requires: key_type shall be CopyConstructible and mapped_type shall be DefaultConstructible.
Complexity: Average case O(1), worst case O(size()).
mapped_type& operator[](key_type&& k);Requires: key_type shall be MoveConstructible and mapped_type shall be DefaultConstructible.
Effects: If the unordered_map does not already contain an element whose key is equivalent to k , inserts the value value_type(std::move(k), mapped_type()).
Returns: A reference to x.second, where x is the (unique) element whose key is equivalent to k.
Complexity: Average case O(1), worst case O(size()).
Add new section [unord.map.modifiers]:
template <class P> pair<iterator, bool> insert(P&& x);Requires: value_type is constructible from std::forward<P>(x).
Effects: Inserts x converted to value_type if and only if there is no element in the container with key equivalent to the key of value_type(x).
Returns: The bool component of the returned pair indicates whether the insertion takes place, and the iterator component points to the element with key equivalent to the key of value_type(x).
Complexity: Average case O(1), worst case O(size()).
Remarks: P shall be implicitly convertible to value_type, else this signature shall not participate in overload resolution.
template <class P> iterator insert(const_iterator hint, P&& x);Requires: value_type is constructible from std::forward<P>(x).
Effects: Inserts x converted to value_type if and only if there is no element in the container with key equivalent to the key of value_type(x). The iterator hint is a hint pointing to where the search should start. Implementations are permitted to ignore the hint.
Returns: An iterator pointing to the element with key equivalent to the key of value_type(x).
Complexity: Average case O(1), worst case O(size()).
Remarks: P shall be implicitly convertible to value_type, else this signature shall not participate in overload resolution.
unordered_multimap
Change 23.5.2 [unord.multimap]:
class unordered_multimap
{
...
unordered_multimap(const unordered_multimap&);
unordered_multimap(unordered_multimap&&);
unordered_multimap(const Allocator&);
unordered_multimap(const unordered_multimap&, const Allocator&);
unordered_multimap(unordered_multimap&&, const Allocator&);
...
unordered_multimap& operator=(const unordered_multimap&);
unordered_multimap& operator=(unordered_multimap&&);
...
// modifiers
...
iterator insert(const value_type& obj);
template <class P> iterator insert(P&& obj);
iterator insert(const_iterator hint, const value_type& obj);
template <class P> iterator insert(const_iterator hint, P&& obj);
...
};
Add new section [unord.multimap.modifiers]:
template <class P> iterator insert(P&& x);Requires: value_type is constructible from std::forward<P>(x).
Effects: Inserts x converted to value_type.
Returns: An iterator pointing to the element with key equivalent to the key of value_type(x).
Complexity: Average case O(1), worst case O(size()).
Remarks: P shall be implicitly convertible to value_type, else this signature shall not participate in overload resolution.
template <class P> iterator insert(const_iterator hint, P&& x);Requires: value_type is constructible from std::forward<P>(x).
Effects: Inserts x converted to value_type if and only if there is no element in the container with key equivalent to the key of value_type(x). The iterator hint is a hint pointing to where the search should start. Implementations are permitted to ignore the hint.
Returns: An iterator pointing to the element with key equivalent to the key of value_type(x).
Complexity: Average case O(1), worst case O(size()).
Remarks: P shall be implicitly convertible to value_type, else this signature shall not participate in overload resolution.
unordered_set
Change 23.5.3 [unord.set]:
class unordered_set
{
...
unordered_set(const unordered_set&);
unordered_set(unordered_set&&);
unordered_set(const Allocator&);
unordered_set(const unordered_set&, const Allocator&);
unordered_set(unordered_set&&, const Allocator&);
...
unordered_set& operator=(const unordered_set&);
unordered_set& operator=(unordered_set&&);
...
// modifiers
...
std::pair<iterator, bool> insert(const value_type& obj);
pair<iterator, bool> insert(value_type&& obj);
iterator insert(const_iterator hint, const value_type& obj);
iterator insert(const_iterator hint, value_type&& obj);
...
};
unordered_multiset
Change 23.5.4 [unord.multiset]:
class unordered_multiset
{
...
unordered_multiset(const unordered_multiset&);
unordered_multiset(unordered_multiset&&);
unordered_multiset(const Allocator&);
unordered_multiset(const unordered_multiset&, const Allocator&);
unordered_multiset(unordered_multiset&&, const Allocator&);
...
unordered_multiset& operator=(const unordered_multiset&);
unordered_multiset& operator=(unordered_multiset&&);
...
// modifiers
...
iterator insert(const value_type& obj);
iterator insert(value_type&& obj);
iterator insert(const_iterator hint, const value_type& obj);
iterator insert(const_iterator hint, value_type&& obj);
...
};
Section: 23.2 [container.requirements] Status: Ready Submitter: Howard Hinnant Opened: 2007-05-20 Last modified: 2010-03-10
View other active issues in [container.requirements].
View all other issues in [container.requirements].
View all issues with Ready status.
Discussion:
The move-related changes inadvertently overwrote the intent of 276. Issue 276 removed the requirement of CopyAssignable from most of the member functions of node-based containers. But the move-related changes unnecessarily introduced the MoveAssignable requirement for those members which used to require CopyAssignable.
We also discussed (c++std-lib-18722) the possibility of dropping MoveAssignable from some of the sequence requirements. Additionally the in-place construction work may further reduce requirements. For purposes of an easy reference, here are the minimum sequence requirements as I currently understand them. Those items in requirements table in the working draft which do not appear below have been purposefully omitted for brevity as they do not have any requirements of this nature. Some items which do not have any requirements of this nature are included below just to confirm that they were not omitted by mistake.
| X u(a) | value_type must be CopyConstructible |
| X u(rv) | array requires value_type to be CopyConstructible |
| a = u | Sequences require value_type to be CopyConstructible and CopyAssignable. Associative containers require value_type to be CopyConstructible. |
| a = rv | array requires value_type to be CopyAssignable. Sequences containers with propagate_on_container_move_assignment == false allocators require value_type to be MoveConstructible and MoveAssignable. Associative containers with propagate_on_container_move_assignment == false allocators require value_type to be MoveConstructible. |
| swap(a,u) | array requires value_type to be Swappable. |
| X(n) | value_type must be DefaultConstructible |
| X(n, t) | value_type must be CopyConstructible |
| X(i, j) | Sequences require value_type to be constructible from *i. Additionally if input_iterators are used, vector and deque require MoveContructible and MoveAssignable. |
| a.insert(p, t) | The value_type must be CopyConstructible. The sequences vector and deque also require the value_type to be CopyAssignable. |
| a.insert(p, rv) | The value_type must be MoveConstructible. The sequences vector and deque also require the value_type to be MoveAssignable. |
| a.insert(p, n, t) | The value_type must be CopyConstructible. The sequences vector and deque also require the value_type to be CopyAssignable. |
| a.insert(p, i, j) | If the iterators return an lvalue the value_type must be CopyConstructible. The sequences vector and deque also require the value_type to be CopyAssignable when the iterators return an lvalue. If the iterators return an rvalue the value_type must be MoveConstructible. The sequences vector and deque also require the value_type to be MoveAssignable when the iterators return an rvalue. |
| a.erase(p) | The sequences vector and deque require the value_type to be MoveAssignable. |
| a.erase(q1, q2) | The sequences vector and deque require the value_type to be MoveAssignable. |
| a.clear() | |
| a.assign(i, j) | If the iterators return an lvalue the value_type must be CopyConstructible and CopyAssignable. If the iterators return an rvalue the value_type must be MoveConstructible and MoveAssignable. |
| a.assign(n, t) | The value_type must be CopyConstructible and CopyAssignable. |
| a.resize(n) | The value_type must be DefaultConstructible. The sequence vector also requires the value_type to be MoveConstructible. |
| a.resize(n, t) | The value_type must be CopyConstructible. |
| a.front() | |
| a.back() | |
| a.push_front(t) | The value_type must be CopyConstructible. |
| a.push_front(rv) | The value_type must be MoveConstructible. |
| a.push_back(t) | The value_type must be CopyConstructible. |
| a.push_back(rv) | The value_type must be MoveConstructible. |
| a.pop_front() | |
| a.pop_back() | |
| a[n] | |
| a.at[n] |
| X(i, j) | If the iterators return an lvalue the value_type must be CopyConstructible. If the iterators return an rvalue the value_type must be MoveConstructible. |
| a_uniq.insert(t) | The value_type must be CopyConstructible. |
| a_uniq.insert(rv) | The key_type and the mapped_type (if it exists) must be MoveConstructible. |
| a_eq.insert(t) | The value_type must be CopyConstructible. |
| a_eq.insert(rv) | The key_type and the mapped_type (if it exists) must be MoveConstructible. |
| a.insert(p, t) | The value_type must be CopyConstructible. |
| a.insert(p, rv) | The key_type and the mapped_type (if it exists) must be MoveConstructible. |
| a.insert(i, j) | If the iterators return an lvalue the value_type must be CopyConstructible. If the iterators return an rvalue the key_type and the mapped_type (if it exists) must be MoveConstructible.. |
| X(i, j, n, hf, eq) | If the iterators return an lvalue the value_type must be CopyConstructible. If the iterators return an rvalue the value_type must be MoveConstructible. |
| a_uniq.insert(t) | The value_type must be CopyConstructible. |
| a_uniq.insert(rv) | The key_type and the mapped_type (if it exists) must be MoveConstructible. |
| a_eq.insert(t) | The value_type must be CopyConstructible. |
| a_eq.insert(rv) | The key_type and the mapped_type (if it exists) must be MoveConstructible. |
| a.insert(p, t) | The value_type must be CopyConstructible. |
| a.insert(p, rv) | The key_type and the mapped_type (if it exists) must be MoveConstructible. |
| a.insert(i, j) | If the iterators return an lvalue the value_type must be CopyConstructible. If the iterators return an rvalue the key_type and the mapped_type (if it exists) must be MoveConstructible.. |
| map[lvalue-key] | The key_type must be CopyConstructible. The mapped_type must be DefaultConstructible and MoveConstructible. |
| map[rvalue-key] | The key_type must be MoveConstructible. The mapped_type must be DefaultConstructible and MoveConstructible. |
[ Kona (2007): Howard and Alan to update requirements table in issue with emplace signatures. ]
[ Bellevue: This should be handled as part of the concepts work. ]
[ 2009-07-20 Reopened by Howard: ]
This is one of the issues that was "solved by concepts" and is now no longer solved.
In a nutshell, concepts adopted the "minimum requirements" philosophy outlined in the discussion of this issue, and enforced it. My strong suggestion is that we translate the concepts specification into documentation for the containers.
What this means for vendors is that they will have to implement container members being careful to only use those characteristics of a type that the concepts specification formally allowed. Note that I am not talking about enable_if'ing everything. I am simply suggesting that (for example) we tell the vendor he can't call T's copy constructor or move constructor within the emplace member function, etc.
What this means for customers is that they will be able to use types within C++03 containers which are sometimes not CopyConstructible, and sometimes not even MoveConstructible, etc.
[ 2009-10 Santa Cruz: ]
Leave open. Howard to provide wording.
[ 2010-02-06 Howard provides wording. ]
[ 2010-02-08 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
[ 2010-02-10 Howard opened. I neglected to reduce the requirements on value_type for the insert function of the ordered and unordered associative containers when the argument is an rvalue. Fixed it. ]
[ 2010-02-11 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
[ 2010-03-08 Nico opens: ]
I took the task to see whether 868 is covered by 704 already. However, by doing that I have the impression that 704 is a big mistake.
Take e.g. the second change of 868:
Change 23.3.2.1 [deque.cons] para 5:
Effects: Constructs a deque with n default constructed elements.where "default constructed" should be replaced by "value-initialized". This is the constructor out of a number of elements:
ContType c(num)704 says:
Remove the entire section 23.3.2.1 [deque.cons].
[ This section is already specified by the requirements tables. ]BUT, there is no requirement table that lists this constructor at all, which means that we would lose the entire specification of this function !!!
In fact, I found with further investigation, if we follow 704 to remove 23.3.2.1 we
- have no semantics for ContType c(num)
- have no complexity and no allocator specification for ContType c(num,val)
- have no semantics for ContType c(num,val,alloc)
- - have no complexity and no allocator specification for ContType c(beg,end)
- - have no semantics for ContType c(beg,end,alloc)
- - have different wording (which might or might not give the same guarantees) for the assign functions
because all these guarantees are given in the removed section but nowhere else (as far as I saw).
Looks to me that 704 need a significant review before we take that change, because chances are high that there are similar flaws in other proposed changes there (provided I am not missing anything).
[ 2010 Pittsburgh: ]
Removed the parts from the proposed wording that removed existing sections, and set to Ready for Pittsburgh.
Rationale:
[ post San Francisco: ]
Solved by N2776.
This rationale is obsolete.
Proposed resolution:
Change 23.2.1 [container.requirements.general]/4:
4 In Tables 91 and 92, X denotes a container class containing objects of type T, a and b denote values of type X, u denotes an identifier, r denotesan lvalue or a const rvaluea non-const value of type X, and rv denotes a non-const rvalue of type X.
Change the following rows in Table 91 — Container requirements 23.2.1 [container.requirements.general]:
Table 91 — Container requirements Expression Return type Assertion/note
pre-/post-conditionComplexity X::value_type T Requires: T is Destructible. compile time
Change 23.2.1 [container.requirements.general]/10:
Unless otherwise specified (see 23.2.4.1, 23.2.5.1, 23.3.2.3, and 23.3.6.4) all container types defined in this Clause meet the following additional requirements:
- ..
- no erase(), clear(), pop_back() or pop_front() function throws an exception.
- ...
Insert a new paragraph prior to 23.2.1 [container.requirements.general]/14:
The descriptions of the requirements of the type T in this section use the terms CopyConstructible, MoveConstructible, constructible from *i, and constructible from args. These terms are equivalent to the following expression using the appropriate arguments:
allocator_traits<allocator_type>::construct(x.get_allocator(), q, args...);where x is a non-const lvalue of some container type X and q has type X::value_type*.
[Example: The container is going to move construct a T, so will call:
allocator_traits<allocator_type>::construct(get_allocator(), q, std::move(t));The default implementation of construct will call:
::new (q) T(std::forward<T>(t)); // where forward is the same as move here, cast to rvalueBut the allocator author may override the above definition of construct and do the construction of T by some other means. — end example]
14 ...
Add to 23.2.1 [container.requirements.general]/14:
14 In Table 93, X denotes an allocator-aware container class with a value_type of T using allocator of type A, u denotes a variable, a and b denote non-const lvalues of type X, t denotes an lvalue or a const rvalue of type X, rv denotes a non-const rvalue of type X, m is a value of type A, and Q is an allocator type.
Change or add the following rows in Table 93 — Allocator-aware container requirements in 23.2.1 [container.requirements.general]:
Table 93 — Allocator-aware container requirements Expression Return type Assertion/note
pre-/post-conditionComplexity X(t, m)
X u(t, m);Requires: T is CopyConstructible.
post: u == t,
get_allocator() == mlinear X(rv, m)
X u(rv, m);Requires: T is MoveConstructible.
post: u shall have the same elements, or copies of the elements, that rv had before this construction,
get_allocator() == mconstant if m == rv.get_allocator(), otherwise linear a = t X& Requires: T is CopyConstructible and CopyAssignable
post: a == t.linear a = rv X& Requires: If allocator_traits< allocator_type > ::propagate_on_container_move_assignment ::value is false, T is MoveConstructible and MoveAssignable.
All existing elements of a are either move assigned to or destroyed.
a shall be equal to the value that rv had before this assignmentlinear a.swap(b); void exchanges the contents of a and b constant
Change the following rows in Table 94 — Sequence container requirements (in addition to container) in 23.2.3 [sequence.reqmts]:
Table 94 — Sequence container requirements (in addition to container) Expression Return type Assertion/note
pre-/post-conditionX(i, j)
X a(i, j)Requires: If the iterator's dereference operation returns an lvalue or a const rvalue, T shall be CopyConstructible.T shall be constructible from *i.
If the iterator does not meet the forward iterator requirements (24.2.3 [forward.iterators]), then vector also requires T to be MoveConstructible.
Each iterator in the range [i,j) shall be dereferenced exactly once.
post: size() == distance between i and j
Constructs a sequence container equal to the range [i, j)a = il; X& Requires: T is CopyConstructible and CopyAssignable.
a = X(il);
Assigns the range [il.begin(), il.end()) into a. All existing elements of a are either assigned or destroyed.
rReturns *this;a.emplace(p, args); iterator Requires: ConstructibleAsElement<A, T, Args>.T is constructible from args. vector and deque also require T to be MoveConstructible and MoveAssignable. Inserts an object of type T constructed with std::forward<Args>(args)... before p.a.insert(p, t); iterator Requires: ConstructibleAsElement<A, T, Args> and T shall be CopyAssignable.T shall be CopyConstructible. vector and deque also require T to be CopyAssignable. Inserts a copy t before p.a.insert(p, rv); iterator Requires: ConstructibleAsElement<A, T, T&&> and T shall be MoveAssignable.T shall be MoveConstructible. vector and deque also require T to be MoveAssignable. Inserts a copy rv before p.a.insert(p, i, j) iterator Requires: If the iterator's dereference operation returns an lvalue or a const rvalue, T shall be CopyConstructible.T shall be constructible from *i.
If the iterator does not meet the forward iterator requirements (24.2.3 [forward.iterators]), then vector also requires T to be MoveConstructible and MoveAssignable.
Each 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 pa.erase(q); iterator Requires: T and T shall be MoveAssignable.vector and deque require T to be MoveAssignable. Erases the element pointed to by q.a.erase(q1, q2); iterator Requires: T and T shall be MoveAssignable.vector and deque require T to be MoveAssignable. Erases the elements in the range [q1, q2).a.clear(); void erase(begin(), end())
Destroys all elements in a. Invalidates all references, pointers, and iterators referring to the elements of a and may invalidate the past-the-end iterator.
post:size() == 0a.empty() == truea.assign(i, j) void Requires: If the iterator's dereference operation returns an lvalue or a const rvalue, T shall be CopyConstructible and CopyAssignable.T shall be constructible and assignable from *i. If the iterator does not meet the forward iterator requirements (24.2.3 [forward.iterators]), then vector also requires T to be MoveConstructible.
Each iterator in the range [i,j) shall be dereferenced exactly once.
pre: i, j are not iterators into a.
Replaces elements in a with a copy of [i, j).
Change the following rows in Table 95 — Optional sequence container operations in 23.2.3 [sequence.reqmts]:
Table 95 — Optional sequence container operations Expression Return type Operational semantics Container a.emplace_front(args) void a.emplace(a.begin(), std::forward<Args>(args)...)
Prepends an object of type T constructed with std::forward<Args>(args)....
Requires:ConstructibleAsElement<A, T, Args>T shall be constructible from args.list, deque, forward_list a.emplace_back(args) void a.emplace(a.end(), std::forward<Args>(args)...)
Appends an object of type T constructed with std::forward<Args>(args)....
Requires:ConstructibleAsElement<A, T, Args>T shall be constructible from args. vector also requires T to be MoveConstructible.list, deque, vector a.push_front(t) void a.insert(a.begin(), t)
Prepends a copy of t.
Requires:ConstructibleAsElement<A, T, T> and T shall be CopyAssignable.T shall be CopyConstructible.list, deque, forward_list a.push_front(rv) void a.insert(a.begin(), t)
Prepends a copy of rv.
Requires:ConstructibleAsElement<A, T, T&&> and T shall be MoveAssignable.T shall be MoveConstructible.list, deque, forward_list a.push_back(t) void a.insert(a.end(), t)
Appends a copy of t.
Requires:ConstructibleAsElement<A, T, T> and T shall be CopyAssignable.T shall be CopyConstructible.vector, list, deque, basic_string a.push_back(rv) void a.insert(a.end(), t)
Appends a copy of rv.
Requires:ConstructibleAsElement<A, T, T&&> and T shall be MoveAssignable.T shall be MoveConstructible.vector, list, deque, basic_string a.pop_front() void a.erase(a.begin())
Destroys the first element.
Requires: a.empty() shall be false.list, deque, forward_list a.pop_back() void { iterator tmp = a.end();
--tmp;
a.erase(tmp); }
Destroys the last element.
Requires: a.empty() shall be false.vector, list, deque, basic_string
Insert a new paragraph prior to 23.2.4 [associative.reqmts]/7, and edit paragraph 7:
The associative containers meet all of the requirements of Allocator-aware containers (23.2.1 [container.requirements.general]), except for the containers map and multimap, the requirements placed on value_type in Table 93 apply instead directly to key_type and mapped_type. [Note: For example key_type and mapped_type are sometimes required to be CopyAssignable even though the value_type (pair<const key_type, mapped_type>) is not CopyAssignable. — end note]
7 In Table 96, X denotes an associative container class, a denotes a value of X, a_uniq denotes a value of X when X supports unique keys, a_eq denotes a value of X when X supports multiple keys, u denotes an identifier,
r denotes an lvalue or a const rvalue of type X, rv denotes a non-const rvalue of type X,i and j satisfy input iterator requirements and refer to elements implicitly convertible to value_type, [i,j) denotes a valid range, p denotes a valid const iterator to a, q denotes a valid dereferenceable const iterator to a, [q1, q2) denotes a valid range of const iterators in a, il designates an object of type initializer_list<value_type>, t denotes a value of X::value_type, k denotes a value of X::key_type and c denotes a value of type X::key_compare. A denotes the storage allocator used by X, if any, or std::allocator<X::value_type> otherwise, and m denotes an allocator of a type convertible to A.
Change or add the following rows in Table 96 — Associative container requirements (in addition to container) in 23.2.4 [associative.reqmts]:
Table 96 — Associative container requirements (in addition to container) Expression Return type Assertion/note
pre-/post-conditionComplexity X::key_type Key Requires: Key is CopyConstructible and CopyAssignableDestructiblecompile time X::mapped_type (map and multimap only) T Requires: T is Destructible compile time X(c)
X a(c);Requires: ConstructibleAsElement<A, key_compare, key_compare>.
key_compare is CopyConstructible.
Constructs an empty container.
Uses a copy of c as a comparison object.constant X()
X a;Requires: ConstructibleAsElement<A, key_compare, key_compare>.
key_compare is DefaultConstructible.
Constructs an empty container.
Uses Compare() as a comparison object.constant X(i, j, c)
X a(i, j, c);Requires: ConstructibleAsElement<A, key_compare, key_compare>.
key_compare is CopyConstructible. value_type shall be constructible from *i.
Constructs an empty container ans inserts elements from the range [i, j) into it; uses c as a comparison object.N log N in general (N is the distance from i to j); linear if [i, j) is sorted with value_comp() X(i, j)
X a(i, j);Requires: ConstructibleAsElement<A, key_compare, key_compare>.
value_type shall be constructible from *i. key_compare is DefaultConstructible.
Same as above, but uses Compare() as a comparison object.same as above a = il X& a = X(il);
return *this;
Requires: T is CopyConstructible and CopyAssignable.
Assigns the range [il.begin(), il.end()) into a. All existing elements of a are either assigned or destroyed.Same as a = X(il).N log N in general (N is il.size() added to the existing size of a); linear if [il.begin(), il.end()) is sorted with value_comp()a_uniq.emplace(args) pair<iterator, bool> Requires: T shall be constructible from args
inserts a T object t constructed with std::forward<Args>(args)... if and only if there is no element in the container with key equivalent to the key of t. The bool component of the returned pair is true if and only if the insertion takes place, and the iterator component of the pair points to the element with key equivalent to the key of t.logarithmic a_eq.emplace(args) iterator Requires: T shall be constructible from args
inserts a T object t constructed with std::forward<Args>(args)... and returns the iterator pointing to the newly inserted element.logarithmic a_uniq.insert(t) pair<iterator, bool> Requires: T shall be MoveConstructible if t is a non-const rvalue expression, else T shall be CopyConstructible.
inserts t if and only if there is no element in the container with key equivalent to the key of t. The bool component of the returned pair is true if and only if the insertion takes place, and the iterator component of the pair points to the element with key equivalent to the key of t.logarithmic a_eq.insert(t) iterator Requires: T shall be MoveConstructible if t is a non-const rvalue expression, else T shall be CopyConstructible.
inserts t and returns the iterator pointing to the newly inserted element. If a range containing elements equivalent to t exists in a_eq, t is inserted at the end of that range.logarithmic a.insert(p, t) iterator Requires: T shall be MoveConstructible if t is a non-const rvalue expression, else T shall be CopyConstructible.
inserts t if and only if there is no element with key equivalent to the key of t in containers with unique keys; always inserts t in containers with equivalent keys; always returns the iterator pointing to the element with key equivalent to the key of t. t is inserted as close as possible to the position just prior to p.logarithmic in general, but amortized constant if t is inserted right before p. a.insert(i, j) void Requires: T shall be constructible from *i.
pre: i, j are not iterators into a. inserts each element from the range [i,j) if and only if there is no element with key equivalent to the key of that element in containers with unique keys; always inserts that element in containers with equivalent keys.N log(size() + N ) (N is the distance from i to j)
Insert a new paragraph prior to 23.2.5 [unord.req]/9:
The unordered associative containers meet all of the requirements of Allocator-aware containers (23.2.1 [container.requirements.general]), except for the containers unordered_map and unordered_multimap, the requirements placed on value_type in Table 93 apply instead directly to key_type and mapped_type. [Note: For example key_type and mapped_type are sometimes required to be CopyAssignable even though the value_type (pair<const key_type, mapped_type>) is not CopyAssignable. — end note]
9 ...
Change or add the following rows in Table 98 — Unordered associative container requirements (in addition to container) in 23.2.5 [unord.req]:
Table 98 — Unordered associative container requirements (in addition to container) Expression Return type Assertion/note
pre-/post-conditionComplexity X::key_type Key Requires: Key shall be CopyAssignable and CopyConstructibleDestructiblecompile time X::mapped_type (unordered_map and unordered_multimap only) T Requires:T is Destructible compile time X(n, hf, eq)
X a(n, hf, eq)X Requires: hasher and key_equal are CopyConstructible. Constructs an empty container with at least n buckets, using hf as the hash function and eq as the key equality predicate. O(N) X(n, hf)
X a(n, hf)X Requires: hasher is CopyConstructible and key_equal is DefaultConstructible. Constructs an empty container with at least n buckets, using hf as the hash function and key_equal() as the key equality predicate. O(N) X(n)
X a(n)X Requires: hasher and key_equal are DefaultConstructible. Constructs an empty container with at least n buckets, using hasher() as the hash function and key_equal() as the key equality predicate. O(N) X()
X aX Requires: hasher and key_equal are DefaultConstructible. Constructs an empty container an unspecified number of buckets, using hasher() as the hash function and key_equal() as the key equality predicate. constant X(i, j, n, hf, eq)
X a(i, j, n, hf, eq)X Requires: value_type is constructible from *i. hasher and key_equal are CopyConstructible.
Constructs an empty container with at least n buckets, using hf as the hash function and eq as the key equality predicate, and inserts elements from [i, j) into it.Average case O(N) (N is distance(i, j)), worst case O(N2) X(i, j, n, hf)
X a(i, j, n, hf)X Requires: value_type is constructible from *i. hasher is CopyConstructible and key_equal is DefaultConstructible.
Constructs an empty container with at least n buckets, using hf as the hash function and key_equal() as the key equality predicate, and inserts elements from [i, j) into it.Average case O(N) (N is distance(i, j)), worst case O(N2) X(i, j, n)
X a(i, j, n)X Requires: value_type is constructible from *i. hasher and key_equal are DefaultConstructible.
Constructs an empty container with at least n buckets, using hasher() as the hash function and key_equal() as the key equality predicate, and inserts elements from [i, j) into it.Average case O(N) (N is distance(i, j)), worst case O(N2) X(i, j)
X a(i, j)X Requires: value_type is constructible from *i. hasher and key_equal are DefaultConstructible.
Constructs an empty container with an unspecified number of buckets, using hasher() as the hash function and key_equal() as the key equality predicate, and inserts elements from [i, j) into it.Average case O(N) (N is distance(i, j)), worst case O(N2) X(b)
X a(b)X Copy constructor. In addition to the contained elementsrequirements of Table 93 (23.2.1 [container.requirements.general]), copies the hash function, predicate, and maximum load factor.Average case linear in b.size(), worst case quadratic. a = b X& Copy assignment operator. In addition to the contained elementsrequirements of Table 93 (23.2.1 [container.requirements.general]), copies the hash function, predicate, and maximum load factor.Average case linear in b.size(), worst case quadratic. a = il X& a = X(il); return *this;
Requires: T is CopyConstructible and CopyAssignable.
Assigns the range [il.begin(), il.end()) into a. All existing elements of a are either assigned or destroyed.Average case linear in il.size(), worst case quadratic. a_uniq.emplace(args) pair<iterator, bool> Requires: T shall be constructible from args
inserts a T object t constructed with std::forward<Args>(args)... if and only if there is no element in the container with key equivalent to the key of t. The bool component of the returned pair is true if and only if the insertion takes place, and the iterator component of the pair points to the element with key equivalent to the key of t.Average case O(1), worst case O(a_uniq.size()). a_eq.emplace(args) iterator Requires: T shall be constructible from args
inserts a T object t constructed with std::forward<Args>(args)... and returns the iterator pointing to the newly inserted element.Average case O(1), worst case O(a_eq.size()). a.emplace_hint(p, args) iterator Requires: T shall be constructible from args
equivalent to a.emplace( std::forward<Args>(args)...). Return value is an iterator pointing to the element with the key equivalent to the newly inserted element. The const_iterator p is a hint pointing to where the search should start. Implementations are permitted to ignore the hint.Average case O(1), worst case O(a.size()). a_uniq.insert(t) pair<iterator, bool> Requires: T shall be MoveConstructible if t is a non-const rvalue expression, else T shall be CopyConstructible.
Inserts t if and only if there is no element in the container with key equivalent to the key of t. The bool component of the returned pair indicates whether the insertion takes place, and the iterator component points to the element with key equivalent to the key of t.Average case O(1), worst case O(a_uniq.size()). a_eq.insert(t) iterator Requires: T shall be MoveConstructible if t is a non-const rvalue expression, else T shall be CopyConstructible.
Inserts t, and returns an iterator pointing to the newly inserted element.Average case O(1), worst case O(a_uniq.size()). a.insert(q, t) iterator Requires: T shall be MoveConstructible if t is a non-const rvalue expression, else T shall be CopyConstructible.
Equivalent to a.insert(t). Return value is an iterator pointing to the element with the key equivalent to that of t. The iterator q is a hint pointing to where the search should start. Implementations are permitted to ignore the hint.Average case O(1), worst case O(a_uniq.size()). a.insert(i, j) void Requires: T shall be constructible from *i.
Pre: i and j are not iterators in a. Equivalent to a.insert(t) for each element in [i,j).Average case O(N), where N is distance(i, j). Worst case O(N * a.size()).
Change 23.3.3 [forwardlist]/2:
2 A forward_list satisfies all of the requirements of a container (table 91), except that the size() member function is not provided. A forward_list also satisfies all of the requirements of an allocator-aware container (table 93). And forward_list provides the assign member functions as specified in Table 94, Sequence container requirements, and several of the optional sequence container requirements (Table 95). Descriptions are provided here only for operations on forward_list that are not described in that table or for operations where there is additional semantic information.
Add a new paragraph after 23.3.3.4 [forwardlist.modifiers]/23:
void clear();23 Effects: Erases all elements in the range [begin(),end()).
Remarks: Does not invalidate past-the-end iterators.
Change 23.3.6.2 [vector.capacity]/13:
void resize(size_type sz, const T& c);13 Requires: T shall be CopyConstructible. If value_type has a move constructor, that constructor shall not throw any exceptions.
In 23.5.3 [unord.set] and 23.5.4 [unord.multiset] substitute "Key" for "Value".
[ The above substitution is normative as it ties into the requirements table. ]
Section: 20.2.1 [utility.arg.requirements] Status: Ready Submitter: Pablo Halpern Opened: 2007-09-12 Last modified: 2010-03-08
View other active issues in [utility.arg.requirements].
View all other issues in [utility.arg.requirements].
View all issues with Ready status.
Discussion:
The DefaultConstructible requirement is referenced in several places in the August 2007 working draft N2369, but is not defined anywhere.
[ Bellevue: ]
Walking into the default/value-initialization mess...
Why two lines? Because we need both expressions to be valid.
AJM not sure what the phrase "default constructed" means. This is unfortunate, as the phrase is already used 24 times in the library!
Example: const int would not accept first line, but will accept the second.
This is an issue that must be solved by concepts, but we might need to solve it independantly first.
It seems that the requirements are the syntax in the proposed first column is valid, but not clear what semantics we need.
A table where there is no post-condition seems odd, but appears to sum up our position best.
At a minimum an object is declared and is destuctible.
Move to open, as no-one happy to produce wording on the fly.
[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]
[ 2009-08-17 Daniel adds "[defaultconstructible]" to table title. 408 depends upon this issue. ]
[ 2009-08-18 Alisdair adds: ]
Looking at the proposed table in this issue, it really needs two rows:
Table 33: DefaultConstructible requirements [defaultconstructible] expression post-condition T t; t is default-initialized. T{} Object of type T is value-initialized. Note I am using the new brace-initialization syntax that is unambiguous in all use cases (no most vexing parse.)
[ 2009-10-03 Daniel adds: ]
The suggested definition T{} describing it as value-initialization is wrong, because it belongs to list-initialization which would - as the current rules are - always prefer a initializer-list constructor over a default-constructor. I don't consider this as an appropriate definition of DefaultConstructible. My primary suggestion is to ask core, whether the special case T{} (which also easily leads to ambiguity situations for more than one initializer-list in a class) would always prefer a default-constructor - if any - before considering an initializer-list constructor or to provide another syntax form to prefer value-initialization over list-initialization. If that fails I would fall back to suggest to use the expression T() instead of T{} with all it's disadvantages for the meaning of the expression
T t();
[ 2009-10 Santa Cruz: ]
Leave Open. Core is looking to make Alisdair's proposed resolution correct.
[ 2010-01-24 At Alisdiar's request, moved his proposal into the proposed wording seciton. The old wording is preserved here: ]
In section 20.2.1 [utility.arg.requirements], before table 33, add the following table:
Table 33: DefaultConstructible requirements [defaultconstructible]
expression
post-condition
T t;
T()T is default constructed.
[ 2010-02-04: Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Rationale:
[ San Francisco: ]
We believe concepts will solve this problem (N2774).
[ Rationale is obsolete. ]
Proposed resolution:
In section 20.2.1 [utility.arg.requirements], before table 33, add the following table:
Table 33: DefaultConstructible requirements [defaultconstructible] expression post-condition T t; Object t is default-initialized. T u{}; Object u is value-initialized. T()
T{}A temporary object of type T is value-initialized.
Section: 28.11.4 [re.alg.replace] Status: Ready Submitter: Stephan T. Lavavej Opened: 2007-09-22 Last modified: 2010-03-08
View all other issues in [re.alg.replace].
View all issues with Ready 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.
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.
[ Batavia (2009-05): ]
Bill comments, "We need to look at the depth of this change."
Pete remarks that we are here dealing with a convenience function that saves a user from calling the iterato-based overload.
Move to Open.
[ 2009-07 Frankfurt: ]
Howard to ask Stephan Lavavej to provide wording.
[ 2009-07-17 Stephan provided wording. ]
[ 2009-07-25 Daniel tweaks both this issue and 726. ]
One relevant part of the proposed resolution below suggests to add a new overload of the format member function in the match_results class template that accepts two character pointers defining the begin and end of a format range. A more general approach could have proposed a pair of iterators instead, but the used pair of char pointers reflects existing practice. If the committee strongly favors an iterator-based signature, this could be simply changed. I think that the minimum requirement should be a BidirectionalIterator, but current implementations take advantage (at least partially) of the RandomAccessIterator sub interface of the char pointers.
Suggested Resolution:
[Moved into the proposed resloution]
[ 2009-07-30 Stephan agrees with Daniel's wording. Howard places Daniel's wording in the Proposed Resolution. ]
[ 2009-10 Santa Cruz: ]
Move to Review. Chair is anxious to move this to Ready in Pittsburgh.
[ 2010-01-27 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change 28.4 [re.syn] as indicated:
// 28.11.4, function template regex_replace:
template <class OutputIterator, class BidirectionalIterator,
class traits, class charT, class ST, class SA>
OutputIterator
regex_replace(OutputIterator out,
BidirectionalIterator first, BidirectionalIterator last,
const basic_regex<charT, traits>& e,
const basic_string<charT, ST, SA>& 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, class ST, class SA,
class FST, class FSA>
basic_string<charT, ST, SA>
regex_replace(const basic_string<charT, ST, SA>& s,
const basic_regex<charT, traits>& e,
const basic_string<charT, FST, FSA>& fmt,
regex_constants::match_flag_type flags =
regex_constants::match_default);
template <class traits, class charT, class ST, class SA>
basic_string<charT, ST, SA>
regex_replace(const basic_string<charT, ST, SA>& 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, class ST, class SA>
basic_string<charT>
regex_replace(const charT* s,
const basic_regex<charT, traits>& e,
const basic_string<charT, ST, SA>& 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);
Change 28.10 [re.results]/3, class template match_results as indicated:
template <class OutputIter>
OutputIter
format(OutputIter out,
const char_type* fmt_first, const char_type* fmt_last,
regex_constants::match_flag_type flags =
regex_constants::format_default) const;
template <class OutputIter, class ST, class SA>
OutputIter
format(OutputIter out,
const string_typebasic_string<char_type, ST, SA>& fmt,
regex_constants::match_flag_type flags =
regex_constants::format_default) const;
template <class ST, class SA>
string_typebasic_string<char_type, ST, SA>
format(const string_typebasic_string<char_type, ST, SA>& fmt,
regex_constants::match_flag_type flags =
regex_constants::format_default) const;
string_type
format(const char_type* fmt,
regex_constants::match_flag_type flags =
regex_constants::format_default) const;
Insert at the very beginning of 28.10.4 [re.results.form] the following:
template <class OutputIter> OutputIter format(OutputIter out, const char_type* fmt_first, const char_type* fmt_last, regex_constants::match_flag_type flags = regex_constants::format_default) const;1 Requires: The type OutputIter shall satisfy the requirements for an Output Iterator (24.2.2 [output.iterators]).
2 Effects: Copies the character sequence [fmt_first,fmt_last) to OutputIter out. Replaces each format specifier or escape sequence in the copied range with either the character(s) it represents or the sequence of characters within *this to which it refers. The bitmasks specified in flags determine which format specifiers and escape sequences are recognized.
3 Returns: out.
Change 28.10.4 [re.results.form], before p. 1 until p. 3 as indicated:
template <class OutputIter, class ST, class SA> OutputIter format(OutputIter out, conststring_typebasic_string<char_type, ST, SA>& fmt, regex_constants::match_flag_type flags = regex_constants::format_default) const;
1 Requires: The type OutputIter shall satisfy the requirements for an Output Iterator (24.2.3).2 Effects:
Copies the character sequence [fmt.begin(),fmt.end()) to OutputIter out. Replaces each format specifier or escape sequence in fmt with either the character(s) it represents or the sequence of characters within *this to which it refers. The bitmasks specified in flags determines what format specifiers and escape sequences are recognizedEquivalent to return format(out, fmt.data(), fmt.data() + fmt.size(), flags).
3 Returns: out.
Change 28.10.4 [re.results.form], before p. 4 until p. 4 as indicated:
template <class ST, class SA>string_typebasic_string<char_type, ST, SA> format(conststring_typebasic_string<char_type, ST, SA>& fmt, regex_constants::match_flag_type flags = regex_constants::format_default) const;Effects:
Returns a copy of the string fmt. Replaces each format specifier or escape sequence in fmt with either the character(s) it represents or the sequence of characters within *this to which it refers. The bitmasks specified in flags determines what format specifiers and escape sequences are recognized.Constructs an empty string result of type basic_string<char_type, ST, SA>, and calls format(back_inserter(result), fmt, flags).Returns: result
At the end of 28.10.4 [re.results.form] insert as indicated:
string_type format(const char_type* fmt, regex_constants::match_flag_type flags = regex_constants::format_default) const;Effects: Constructs an empty string result of type string_type, and calls format(back_inserter(result), fmt, fmt + char_traits<char_type>::length(fmt), flags).
Returns: result
Change 28.11.4 [re.alg.replace] before p. 1 as indicated:
template <class OutputIterator, class BidirectionalIterator, class traits, class charT, class ST, class SA> OutputIterator regex_replace(OutputIterator out, BidirectionalIterator first, BidirectionalIterator last, const basic_regex<charT, traits>& e, const basic_string<charT, ST, SA>& 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);Effects: [..]. If any matches are found then, for each such match, if !(flags & regex_constants::format_no_copy) calls std::copy(m.prefix().first, m.prefix().second, out), and then calls m.format(out, fmt, flags) for the first form of the function and m.format(out, fmt, fmt + char_traits<charT>::length(fmt), flags) for the second form. [..].
Change 28.11.4 [re.alg.replace] before p. 3 as indicated:
template <class traits, class charT, class ST, class SA, class FST, class FSA> basic_string<charT, ST, SA> regex_replace(const basic_string<charT, ST, SA>& s, const basic_regex<charT, traits>& e, const basic_string<charT, FST, FSA>& fmt, regex_constants::match_flag_type flags = regex_constants::match_default); template <class traits, class charT, class ST, class SA> basic_string<charT, ST, SA> regex_replace(const basic_string<charT, ST, SA>& s, const basic_regex<charT, traits>& e, const charT* fmt, regex_constants::match_flag_type flags = regex_constants::match_default);Effects: Constructs an empty string result of type basic_string<charT, ST, SA>, calls regex_replace(back_inserter(result), s.begin(), s.end(), e, fmt, flags), and then returns result.
At the end of 28.11.4 [re.alg.replace] add the following new prototype description:
template <class traits, class charT, class ST, class SA> basic_string<charT> regex_replace(const charT* s, const basic_regex<charT, traits>& e, const basic_string<charT, ST, SA>& 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);Effects: Constructs an empty string result of type basic_string<charT>, calls regex_replace(back_inserter(result), s, s + char_traits<charT>::length(s), e, fmt, flags), and then returns result.
Section: 23 [containers] Status: Ready Submitter: Alisdair Meredith Opened: 2008-01-14 Last modified: 2010-03-12
View other active issues in [containers].
View all other issues in [containers].
View all issues with Ready 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.
[ 2009-07 Frankfurt: ]
Daniel to provide wording. N2590 is no longer applicable.
[ 2009-07-28 Daniel provided wording. ]
- It assumes that the proposed resolution for 883 is applied, which breaks the circularity of definition between member swap and free swap.
- It uses the notation of the pre-concept allocator trait allocator_propagation_map, which might be renamed after the next refactoring phase of generalized allocators.
- It requires that compare objects, key equal functions and hash functions in containers are swapped via unqualified free swap according to 594.
[ 2009-09-30 Daniel adds: ]
The outcome of this issue should be considered with the outcome of 1198 both in style and in content (e.g. bullet 9 suggests to define the semantic of void priority_queue::swap(priority_queue&) in terms of the member swap of the container).
[ 2009-10 Santa Cruz: ]
Looked at, but took no action on as it overlaps too much with N2982. Waiting for a new draft WP.
[ 2009-10 Santa Cruz: ]
Leave as open. Pablo to provide wording.
[ 2009-10-26 Pablo updated wording. Here is the wording he replaced: ]
Add a new Throws clause just after X [allocator.propagation.map]/5:
static void swap(Alloc& a, Alloc& b);Effects: [..]
Throws: Nothing.
[ This exception requirement is added, such that it's combination with the general container requirements of N2723 [container.requirements.general]/9 make it unambiguously clear that the following descriptions of "swaps the allocators" have the following meaning: (a) This swap is done by calling allocator_propagation_map<allocator_type>::swap and (b) This allocator swap does never propagate an exception ]
Change 23.2.4.1 [associative.reqmts.except]/3 as indicated:
For associative containers, no swap function throws an exception unless that exception is thrown by thecopy constructor or copy assignment operatorswap of the container's Pred objects(if any).Change 23.2.5.1 [unord.req.except]/3 as indicated:
For unordered associative containers, no swap function throws an exception unless that exception is thrown by thecopy constructor or copy assignment operatorswap of the container's Hash or Pred objects, respectively(if any).Insert a new paragraph just after 23.3 [sequences]/1:
In addition to being available via inclusion of the <algorithm> header, the swap function templates in 25.3.3 [alg.swap] are also available when the header <queue> is included.[ There is a new issue in process that will suggest a minimum header for swap and move. If this one is provided, this text can be removed and the header dependency should be added to <queue> ]
Add one further clause at the end of 23.3.1.2 [array.special]:
[This part is added, because otherwise array::swap would otherwise contradict the general contract of 23.2.1 [container.requirements.general] p. 10 b. 5]
Throws: Nothing, unless one of the element-wise swap calls throws an exception.
In 23.3.2 [deque], class template deque synopsis change as indicated:
void swap(deque<T,Alloc>&);At the end of 23.3.2.3 [deque.modifiers] add as indicated:
void swap(deque& x);Effects: Exchanges the contents and swaps the allocators of *this with that of x.
Complexity: Constant time.
In 23.3.3 [forwardlist], class template forward_list synposis change as indicated:
void swap(forward_list<T,Allocator>&);At the end of 23.3.3.4 [forwardlist.modifiers] add as indicated:
void swap(forward_list& x);Effects: Exchanges the contents and swaps the allocators of *this with that of x.
Complexity: Constant time.
In 23.3.4 [list], class template list synopsis change as indicated:
void swap(list<T,Allocator>&);At the end of 23.3.4.3 [list.modifiers] add as indicated:
void swap(list& x);Effects: Exchanges the contents and swaps the allocators of *this with that of x.
Complexity: Constant time.
At the end of 23.3.5.2.2 [priqueue.members] add a new prototype description:
void swap(priority_queue& q);Requires: Compare shall satisfy the Swappable requirements ( [swappable]).
[ This requirement is added to ensure that even a user defined swap which is found by ADL for Compare satisfies the Swappable requirements ]
Effects: this->c.swap(q.c); swap(this->comp, q.comp);
Throws: What and if c.swap(q.c) and swap(comp, q.comp) throws.
[ This part is added, because otherwise priority_queue::swap would otherwise contradict the general contract of 23.2.1 [container.requirements.general] p. 10 b. 5 ]
In 23.3.6 [vector], class template vector synopsis change as indicated:
void swap(vector<T,Allocator>&);Change 23.3.6.2 [vector.capacity]/8 as indicated:
void swap(vector<T,Allocator>& x);Effects: Exchanges the contents and capacity() and swaps the allocators of *this with that of x.Insert a new paragraph just before 23.4 [associative]/1:
In addition to being available via inclusion of the <algorithm> header, the swap function templates in 25.3.3 [alg.swap] are also available when any of the headers <map> or <set> are included.
In 23.4.1 [map], class template map synopsis change as indicated:
void swap(map<Key,T,Compare,Allocator>&);At the end of 23.4.1.3 [map.modifiers] add as indicated:
void swap(map& x);Requires: Compare shall satisfy the Swappable requirements ( [swappable]).
[ This requirement is added to ensure that even a user defined swap which is found by ADL for Compare satisfies the Swappable requirements ]
Effects: Exchanges the contents and swaps the allocators of *this with that of x, followed by an unqualified swap of the comparison objects of *this and x.
Complexity: Constant time
In 23.4.2 [multimap], class template multimap synopsis change as indicated:
void swap(multimap<Key,T,Compare,Allocator>&);At the end of 23.4.2.2 [multimap.modifiers] add as indicated:
void swap(multimap& x);Requires: Compare shall satisfy the Swappable requirements ( [swappable]).
Effects: Exchanges the contents and swaps the allocators of *this with that of x, followed by an unqualified swap of the comparison objects of *this and x.
Complexity: Constant time
In 23.4.3 [set], class template set synopsis change as indicated:
void swap(set<Key,Compare,Allocator>&);After section 23.4.3.1 [set.cons] add a new section set modifiers [set.modifiers] and add the following paragraphs:
void swap(set& x);Requires: Compare shall satisfy the Swappable requirements ( [swappable]).
Effects: Exchanges the contents and swaps the allocators of *this with that of x, followed by an unqualified swap of the comparison objects of *this and x.
Complexity: Constant time
In 23.4.4 [multiset], class template multiset synosis, change as indicated:
void swap(multiset<Key,Compare,Allocator>&);After section 23.4.4.1 [multiset.cons] add a new section multiset modifiers [multiset.modifiers] and add the following paragraphs:
void swap(multiset& x);Requires: Compare shall satisfy the Swappable requirements ( [swappable]).
Effects: Exchanges the contents and swaps the allocators of *this with that of x, followed by an unqualified swap of the comparison objects of *this and x.
Complexity: Constant time
Insert a new paragraph just before 23.5 [unord]/1:
In addition to being available via inclusion of the <algorithm> header, the swap function templates in 25.3.3 [alg.swap] are also available when any of the headers <unordered_map> or <unordered_set> are included.After section 23.5.1.2 [unord.map.elem] add a new section unordered_map modifiers [unord.map.modifiers] and add the following paragraphs:
void swap(unordered_map& x);Requires: Hash and Pred shall satisfy the Swappable requirements ( [swappable]).
[ This requirement is added to ensure that even a user defined swap which is found by ADL for Hash and Pred satisfies the Swappable requirements ]
Effects: Exchanges the contents and hash policy and swaps the allocators of *this with that of x, followed by an unqualified swap of the Pred objects and an unqualified swap of the Hash objects of *this and x.
Complexity: Constant time
After section 23.5.2.1 [unord.multimap.cnstr] add a new section unordered_multimap modifiers [unord.multimap.modifiers] and add the following paragraphs:
void swap(unordered_multimap& x);Requires: Hash and Pred shall satisfy the Swappable requirements ( [swappable]).
Effects: Exchanges the contents and hash policy and swaps the allocators of *this with that of x, followed by an unqualified swap of the Pred objects and an unqualified swap of the Hash objects of *this and x
Complexity: Constant time
After section 23.5.3.1 [unord.set.cnstr] add a new section unordered_set modifiers [unord.set.modifiers] and add the following paragraphs:
void swap(unordered_set& x);Requires: Hash and Pred shall satisfy the Swappable requirements ( [swappable]).
Effects: Exchanges the contents and hash policy and swaps the allocators of *this with that of x, followed by an unqualified swap of the Pred objects and an unqualified swap of the Hash objects of *this and x
Complexity: Constant time
After section 23.5.4.1 [unord.multiset.cnstr] add a new section unordered_multiset modifiers [unord.multiset.modifiers] and add the following paragraphs:
void swap(unordered_multiset& x);Requires: Hash and Pred shall satisfy the Swappable requirements ( [swappable]).
Effects: Exchanges the contents and hash policy and swaps the allocators of *this with that of x, followed by an unqualified swap of the Pred objects and an unqualified swap of the Hash objects of *this and x
Complexity: Constant time
[ 2009-10-30 Pablo and Daniel updated wording. ]
[ 2010 Pittsburgh: Ready for Pittsburgh. ]
Proposed resolution:
[ This resolution is based on the September 2009 WP, N2960, except that it assumes that N2982 and issues 883 and 1232 have already been applied. Note in particular that Table 91 in N2960 is refered to as Table 90 because N2982 removed the old Table 90. This resolution also addresses issue 431. ]
In 23.2.1 [container.requirements.general], replace the a.swap(b) row in table 90, "container requirements" (was table 91 before the application of N2982 to the WP):
a.swap(b)voidswap(a,b)Exchange the contents of a and b.(Note A) swap(a,b)voida.swap(b)(Note A)
Modify the notes immediately following Table 90 in 23.2.1 [container.requirements.general] as follows (The wording below is after the application of N2982 to N2960. The editor might also want to combine Notes A and B into one.):
Notes: the algorithms
swap(),equal() and lexicographical_compare() are defined in Clause 25. Those entries marked "(Note A)" or "(Note B)"shouldhave linear complexity for array and constant complexity for all other standard containers.
In 23.2.1 [container.requirements.general], before paragraph 8, add:
The expression
a.swap(b), for containersaandbof a standard container type other thanarray, exchanges the values ofaandbwithout invoking any move, copy, or swap operations on the individual container elements. AnyCompare,Pred, orHashfunction objects belonging toaandbshall beswappableand are exchanged by unqualified calls to non-memberswap. Ifallocator_traits<allocator_type>::propagate_on_container_swap::value == true, then the allocators ofaandbare also exchanged using an unqualified call to non-memberswap. Otherwise, the behavior is undefined unlessa.get_allocator() == b.get_allocator(). Each iterator refering to an element in one container before the swap shall refer to the same element in the other container after the swap. It is unspecified whether an iterator with valuea.end()before the swap will have valueb.end()after the swap. In addition to being available via inclusion of the<utility>header, theswapfunction template in 25.3.3 [alg.swap] is also available within the definition of every standard container'sswapfunction.
[ Note to the editor: Paragraph 2 starts with a sentence fragment, clearly from an editing or source-control error. ]
Modify 23.2.4.1 [associative.reqmts.except] as follows:
23.2.4.1 Exception safety guarantees 23.2.4.1 [associative.reqmts.except]
For associative containers, no
clear()function throws an exception.erase(k)does not throw an exception unless that exception is thrown by the container'sobject (if any).PredCompareFor associative containers, if an exception is thrown by any operation from within an
insert()function inserting a single element, theinsert()function has no effect.For associative containers, no
swapfunction throws an exception unless that exception is thrown by thecopy constructor or copy assignment operatorswap of the container'sobject (if any).PredCompare
Modify 23.2.5.1 [unord.req.except], paragraph 3 as follows:
For unordered associative containers, no
swapfunction throws an exception unless that exception is thrown by thecopy constructor or copy assignment operatorswap of the container'sHashorPredobject (if any).
Modify section 23.3.1.2 [array.special]:
array specialized algorithms 23.3.1.2 [array.special]
template <class T, size_t N> void swap(array<T,N>& x,array<T,N>& y);Effects:
swap_ranges(x.begin(), x.end(), y.begin() );x.swap(y);
Add a new section after 23.3.1.5 [array.fill] (Note to the editor: array::fill make use of a concept requirement that must be removed or changed to text.):
array::swap [array.swap]
void swap(array& y);Effects:
swap_ranges(this->begin(), this->end(), y.begin() );Throws: Nothing unless one of the element-wise swap calls throws an exception.
[Note: Unlike other containers'
swapfunctions,array::swaptakes linear, not constant, time, may exit via an exception, and does not cause iterators to become associated with the other container. — end note]
Insert a new paragraph just after 23.3.5 [container.adaptors]/1:
For container adaptors, no
swapfunction throws an exception unless that exception is thrown by the swap of the adaptor'sContainerorCompareobject (if any).
Section: 25.4.4 [alg.merge] Status: Ready Submitter: Daniel Krügler Opened: 2008-01-25 Last modified: 2010-03-08
View all issues with Ready 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.4.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.
[ Batavia (2009-05): ]
Pete points out the existing wording in [algorithms]/4 that permits the use of + in algorithm specifications.
Alisdair points out that that wording may not apply to input iterators.
Move to Review.
[ 2009-07 Frankfurt: ]
Move to Ready.
[ 2009-08-23 Daniel reopens: ]
The proposed wording must be rephrased, because the part
for every iterator i in [result,last) other than result, the condition *i < *(i - 1) or, respectively, comp(*i, *(i - 1)) will be false"isn't meaningful, because the range [result,last) is that of a pure OutputIterator, which is not readable in general.
[Howard: Proposed wording updated by Daniel, status moved from Ready to Review.]
[ 2009-10 Santa Cruz: ]
Matt has some different words to propose. Those words have been moved into the proposed wording section, and the original proposed wording now appears here:
In 25.4.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)) , such that resulting range will be sorted in non-decreasing order; that is for every pair of iterators i and j of either input ranges, where *i was copied to the output range before *j was copied to the output range, the condition *j < *i or, respectively, comp(*j, *i) 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.
[ 2010-02-10 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change 25.4.4 [alg.merge] 1 and 2:
1
Effects: Merges two sorted ranges [first1,last1) and [first2,last2) into the range [result, result + (last1 - first1) + (last2 - first2)).Effects: Copies all the elements of the two ranges [first1,last1) and [first2,last2) into the range [result, result_last), where result_last is result + (last1 - first1) + (last2 - first2), such that the resulting range satisfies is_sorted(result, result_last) or is_sorted(result, result_last, comp), respectively.
2 Requires: The ranges [first1,last1) and [first2,last2) shall be sorted with respect to operator< or comp. 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.
Change 25.4.4 [alg.merge]/6+7 as indicated [This ensures harmonization between inplace_merge and merge]
6 Effects: Merges two
sortedconsecutive ranges [first,middle) and [middle,last), putting the result of the merge into the range [first,last). The resulting range will be in non-decreasing order; that is, for every iterator i in [first,last) other than first, the condition *i < *(i - 1) or, respectively, comp(*i, *(i - 1)) will be false.7 Requires: The ranges [first,middle) and [middle,last) shall be sorted with respect to operator< or comp. The type of *first shall satisfy the Swappable requirements (37), the MoveConstructible requirements (Table 33), and the the MoveAssignable requirements (Table 35).
Section: 20.4 [tuple] Status: Open Submitter: Lawrence Crowl Opened: 2008-02-18 Last modified: 2010-03-10
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.
[ 2009-05-27 Daniel adds: ]
This is partly solved by 1117.
[ 2009-07 Frankfurt: ]
Wait for dust to settle from fixing exception safety problem with rvalue refs.
[ 2009-07-20 Alisdair adds: ]
Basically, this issue is what should we do with the default constructor for pairs and tuples of trivial types. The motivation of the issue was to force static initialization rather than dynamic initialization, and was rejected in the case of pair as it would change the meaning of existing programs. The advice was "do the best we can" for tuple without changing existing meaning.
Frankfurt seems to simply wait and see the resolution on no-throw move constructors, which (I believe) is only tangentially related to this issue, but as good as any to defer until Santa Cruz.
Looking again now, I think constant (static) initialization for pair can be salvaged by making the default construct constexpr. I have a clarification from Core that this is intended to work, even if the constructor is not trivial/constexpr, so long as no temporaries are implied in the process (even if elided).
[ 2009-10 Santa Cruz: ]
Leave as open. Alisdair to provide wording.
[ 2010 Pittsburgh: ]
We believe this may be NAD Editorial since both pair and tuple now have constexpr default constructors, but we're not sure.
Proposed resolution:
Section: 20.3.4 [pairs] Status: Ready Submitter: Doug Gregor Opened: 2008-03-14 Last modified: 2010-03-08
View other active issues in [pairs].
View all other issues in [pairs].
View all issues with Ready status.
Discussion:
#include <utility>
int main()
{
std::pair<char *, char *> p (0,0);
}
I just got a bug report about that, because it's valid C++03, but not C++0x. The important realization, for me, is that the emplace proposal---which made push_back variadic, causing the push_back(0) issue---didn't cause this break in backward compatibility. The break actually happened when we added this pair constructor as part of adding rvalue references into the language, long before variadic templates or emplace came along:
template<class U, class V> pair(U&& x, V&& y);
Now, concepts will address this issue by constraining that pair constructor to only U's and V's that can properly construct "first" and "second", e.g. (from N2322):
template<class U , class V > requires Constructible<T1, U&&> && Constructible<T2, V&&> pair(U&& x , V&& y );
[ San Francisco: ]
Suggested to resolve using pass-by-value for that case.
Side question: Should pair interoperate with tuples? Can construct a tuple of a pair, but not a pair from a two-element tuple.
Related to 885.
[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]
[ 2009-10 Santa Cruz: ]
Leave as open. Howard to provide wording.
[ 2010-02-06 Howard provided wording. ]
[ 2010-02-09 Moved to Tentatively Ready after 6 positive votes on c++std-lib. ]
Rationale:
[ San Francisco: ]
Solved by N2770.
[ The rationale is obsolete. ]
Proposed resolution:
Add a paragraph to 20.3.4 [pairs]:
template<class U, class V> pair(U&& x, V&& y);6 Effects: The constructor initializes first with std::forward<U>(x) and second with std::forward<V>(y).
Remarks: U shall be implicitly convertible to first_type and V shall be implicitly convertible to second_type, else this constructor shall not participate in overload resolution.
Section: 20.8.11.1.3 [func.bind.bind] Status: Ready Submitter: Howard Hinnant Opened: 2008-03-17 Last modified: 2010-03-08
View all other issues in [func.bind.bind].
View all issues with Ready 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 because 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 Summit 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.8.11.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.
[ Batavia (2009-05): ]
We were going to recommend moving this issue to Tentatively Ready until we noticed potential overlap with issue 816 (q.v.).
Move to Open, and recommend both issues be considered together (and possibly merged).
[ 2009-07 Frankfurt: ]
The proposed resolution uses concepts. Leave Open.
[ 2009-10 Santa Cruz: ]
Leave as Open. Howard to provide deconceptified wording.
[ 2009-11-07 Howard updates wording. ]
[ 2009-11-15 Further updates by Peter, Chris and Daniel. ]
[ Moved to Tentatively Ready after 6 positive votes on c++std-lib. ]
Proposed resolution:
Change 20.8 [function.objects] p2:
template<class Fn, class...TypesBoundArgs> unspecified bind(Fn&&,TypesBoundArgs&&...); template<class R, class Fn, class...TypesBoundArgs> unspecified bind(Fn&&,TypesBoundArgs&&...);
Change 20.8.2 [func.require]:
4 Every call wrapper (20.8.1 [func.def]) shall be
CopyMoveConstructible. A simple call wrapper is a call wrapper that is CopyConstructible and CopyAssignable and whose copy constructor, move constructor and assignment operator do not throw exceptions. A forwarding call wrapper is a call wrapper that can be called with an argument list. [Note: in a typical implementation forwarding call wrappers have an overloaded function call operator of the formtemplate<class...ArgTypesUnBoundsArgs> R operator()(ArgTypesUnBoundsArgs&&... unbound_args) cv-qual;— end note]
Change 20.8.11.1.3 [func.bind.bind]:
Within this clause:
- Let FD be a synonym for the type decay<F>::type.
- Let fd be an lvalue of type FD constructed from std::forward<F>(f).
- Let Ti be a synonym for the ith type in the template parameter pack BoundArgs.
- Let TiD be a synonym for the type decay<Ti>::type.
- Let ti be the ith argument in the function parameter pack bound_args.
- Let tid be an lvalue of type TiD constructed from std::forward<Ti>(ti).
- Let Uj be the jth deduced type of the UnBoundArgs&&... parameter of the operator() of the forwarding call wrapper.
- Let uj be the jth argument associated with Uj.
template<class F, class... BoundArgs> unspecified bind(F&& f, BoundArgs&&... bound_args);-1- Requires: is_constructible<FD, F>::value shall be true. For each Ti in BoundArgs, is_constructible<TiD, Ti>::value shall be true.
F and each Ti in BoundArgs shall be CopyConstructible.INVOKE(fd, w1, w2, ..., wN) (20.8.2 [func.require]) 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.8.2 [func.require]). The effect of g(u1, u2, ..., uM) shall be INVOKE(fd, v1, v2, ..., vN, result_of<FD cv (V1, V2, ..., VN)>::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 FD or of any of the types TiD throws an exception.
-3- Throws: Nothing unless the
copyconstructionorofFfd or of one of the values tidtypes in the BoundArgs... pack expansionthrows an exception.Remarks: The unspecified return type shall satisfy the requirements of MoveConstructible. If all of FD and TiD satisfy the requirements of CopyConstructible then the unspecified return type shall satisfy the requirements of CopyConstructible. [Note: This implies that all of FD and TiD shall be MoveConstructible — end note]
template<class R, class F, class... BoundArgs> unspecified bind(F&& f, BoundArgs&&... bound_args);-4- Requires: is_constructible<FD, F>::value shall be true. For each Ti in BoundArgs, is_constructible<TiD, Ti>::value shall be true.
F and each Ti in BoundArgs shall be CopyConstructible.INVOKE(fd, w1, w2, ..., wN) shall be a valid expression for some values w1, w2, ..., wN, where N == sizeof...(bound_args).-5- 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(fd, 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 FD or of any of the types TiD throws an exception.
-6- Throws: Nothing unless the
copyconstructionorofFfd or of one of the values tidtypes in the BoundArgs... pack expansionthrows an exception.Remarks: The unspecified return type shall satisfy the requirements of MoveConstructible. If all of FD and TiD satisfy the requirements of CopyConstructible then the unspecified return type shall satisfy the requirements of CopyConstructible. [Note: This implies that all of FD and TiD shall be MoveConstructible — end note]
-7- The values of the bound arguments v1, v2, ..., vN and their corresponding types V1, V2, ..., VN depend on the types TiD derived from
of the corresponding argument ti in bound_args of type Ti in BoundArgs inthe call to bind and the cv-qualifiers cv of the call wrapper g as follows:
- if
tiTiD isof typereference_wrapper<T> the argument is tid.get() and its type Vi is T&;- if the value of
std::is_bind_expression<TiD>::value is true the argument is tid(std::forward<Uj>(uj)...u1, u2, ..., uM) and its type Vi is result_of<TiD cv (Uj...U1&, U2&, ..., UM&)>::type;- if the value j of
std::is_placeholder<TiD>::value is not zero the argument is std::forward<Uj>(uj) and its type Vi is Uj&&;- otherwise the value is tid and its type Vi is TiD cv &.
Section: 18.8.6 [except.nested] Status: Ready Submitter: Alisdair Meredith Opened: 2008-03-25 Last modified: 2010-03-11
View other active issues in [except.nested].
View all other issues in [except.nested].
View all issues with Ready 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.
[ 2009-10 Santa Cruz: ]
Leave as Open. Alisdair to provide wording.
[ 2009-11-09 Alisdair provided wording. ]
[ 2010-03-10 Dietmar updated wording. ]
[ 2010 Pittsburgh: ]
Moved to Ready for Pittsburgh.
Proposed resolution:
Change 18.8.6 [except.nested], p8:
template <class E> void rethrow_if_nested(const E& e);-8- Effects:Calls e.rethrow_nested() oOnly if the dynamic type of e is publicly and unambiguously derived from nested_exception this calls dynamic_cast<const nested_exception&>(e).rethrow_nested().
Section: 20.9.10.2 [unique.ptr.single] Status: Open Submitter: Daniel Krügler Opened: 2008-05-14 Last modified: 2010-01-16
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.
[ 2009-07 Frankfurt: ]
Move to Ready.
[ 2009-10-15 Alisdair pulls from Ready: ]
I hate to pull an issue out of Ready status, but I don't think 834 is fully baked yet.
For reference the proposed resolution is to add the following words:
unique_ptr<T, D>::pointer's operations shall be well-formed, shall have well defined behavior, and shall not throw exceptions.This leaves me with a big question : which operations?
Are all pointer operations required to be nothrow, including operations that have nothing to do with interactions with unique_ptr? This was much simpler with concepts where we could point to operations within a certain concept, and so nail down the interactions.
[ 2009-10-15 Daniel adds: ]
I volunteer to prepare a more fine-grained solution, but I would like to ask for feedback that helps me doing so. If this question is asked early in the meeting I might be able to fix it within the week, but I cannot promise that now.
[ 2009-10 Santa Cruz: ]
Leave in open. Daniel to provide wording as already suggested.
[ 2009-12-22 Daniel provided wording and rationale. ]
Rationale:
The here proposed resolution has considerable overlap with the requirements that are used in the allocator requirements.
This might be a convincing argument to isolate the common subset into one requirement. The reason I did not do that is basically because we might find out that they are either over-constraining or under-constraining at this late point of specification. Note also that as a result of the idea of a general requirement set I added the requirement
A default-initialized object may have a singular value
even though this does not play a relevant role for unique_ptr.
One further characteristics of the resolution is that availability of relational operators of unique_ptr<T, D>::pointer is not part of the basic requirements, which is in sync with the allocator requirements on pointer-like (this means that unique_ptr can hold a void_pointer or const_void_pointer).
Proposed resolution:
Change 20.9.10.2 [unique.ptr.single]/1 as indicated: [The intent is to replace the coupling between T* and the deleter's operator() by a coupling between unique_ptr<T, D>::pointer and this operator()]
1 - The default type for the template parameter D is default_delete. A client-supplied template argument D shall be a function pointer or functor for which, given a value d of type D and apointervalue ptr of typeT*unique_ptr<T, D>::pointer, the expression d(ptr) is valid and has the effect of deallocating the pointer as appropriate for that deleter. D may also be an lvalue-reference to a deleter.
Change 20.9.10.2 [unique.ptr.single]/3 as indicated:
3 - If the type remove_reference<D>::type::pointer exists, then unique_ptr<T, D>::pointer shall be a synonym for remove_reference<D>::type::pointer. Otherwise unique_ptr<T, D>::pointer shall be a synonym for T*. The type unique_ptr<T, D>::pointer shall
besatisfy the requirements of EqualityComparable, DefaultConstructible, CopyConstructible(Table 34) and, CopyAssignable(Table 36), Swappable, and Destructible (20.2.1 [utility.arg.requirements]). A default-initialized object may have a singular value. A value-initialized object produces the null value of the type. The null value shall be equivalent only to itself. An object of this type can be copy-initialized with a value of type nullptr_t, compared for equality with a value of type nullptr_t, and assigned a value of type nullptr_t. The effect shall be as if a value-initialized object had been used in place of the null pointer constant. An object p of this type can be contextually converted to bool. The effect shall be as if p != nullptr had been evaluated in place of p. No operation on this type which is part of the above mentioned requirements shall exit via an exception.[Note: Given an allocator type X (20.2.2 [allocator.requirements]), the types X::pointer, X::const_pointer, X::void_pointer, and X::const_void_pointer may be used as unique_ptr<T, D>::pointer — end note]
In addition to being available via inclusion of the <utility> header, the swap function template in 20.3.2 [utility.swap] is also available within the definition of unique_ptr's swap function.
Change 20.9.10.2.1 [unique.ptr.single.ctor]/2+3 as indicated: [The first change ensures that we explicitly say, how the stored pointer is initialized. This is important for a constexpr function, because this may make a difference for user-defined pointer-like types]
constexpr unique_ptr();...
2 - Effects: Constructs a unique_ptr which owns nothing, value-initializing the stored pointer.
3 - Postconditions: get() ==
0nullptr.
Change 20.9.10.2.1 [unique.ptr.single.ctor]/6+7 as indicated: [This is a step-by-fix to ensure consistency to the changes of N2976]
unique_ptr(pointer p);...
6 - Effects: Constructs a unique_ptr which owns p, initializing the stored pointer with p.
7 - Postconditions: get() == p. get_deleter() returns a reference to a
default constructedvalue-initialized deleter D.
Insert a new effects clause in 20.9.10.2.1 [unique.ptr.single.ctor] just before p. 14: [The intent is to fix the current lack of specification in which way the stored pointer is initialized]
unique_ptr(pointer p,implementation-definedsee below d1); unique_ptr(pointer p,implementation-definedsee below d2);...
Effects: Constructs a unique_ptr which owns p, initializing the stored pointer with p and the initializing the deleter as described above.
14 - Postconditions: get() == p. get_deleter() returns a reference to the internally stored deleter. If D is a reference type then get_deleter() returns a reference to the lvalue d.
Change 20.9.10.2.1 [unique.ptr.single.ctor]/18+22 as indicated: [The intent is to clarify that the moved-from source must contain a null pointer, there is no other choice left]
unique_ptr(unique_ptr&& u);[..]
18 - Postconditions: get() == value u.get() had before the construction and u.get() == nullptr. get_deleter() returns a reference to the internally stored deleter which was constructed from u.get_deleter(). If D is a reference type then get_deleter() and u.get_deleter() both reference the same lvalue deleter.
template <class U, class E> unique_ptr(unique_ptr<U, E>&& u);[..]
22 - Postconditions: get() == value u.get() had before the construction, modulo any required offset adjustments resulting from the cast from unique_ptr<U, E>::pointer to pointer and u.get() == nullptr. get_deleter() returns a reference to the internally stored deleter which was constructed from u.get_deleter().
Change 20.9.10.2.1 [unique.ptr.single.ctor]/20 as indicated: [With the possibility of user-defined pointer-like types the implication does only exist, if those are built-in pointers. Note that this change should also be applied with the acceptance of 950]
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.[Note: These requirements imply that T and U are complete types. — end note]
Change 20.9.10.2.2 [unique.ptr.single.dtor]/2 as indicated:
~unique_ptr();...
2 - Effects: If get() ==
0nullptr there are no effects. Otherwise get_deleter()(get()).
Change 20.9.10.2.3 [unique.ptr.single.asgn]/3+8 as indicated: [The intent is to clarify that the moved-from source must contain a null pointer, there is no other choice left]
unique_ptr& operator=(unique_ptr&& u);[..]
3 - Postconditions: This unique_ptr now owns the pointer which u owned, and u no longer owns it, u.get() == nullptr. [Note: If D is a reference type, then the referenced lvalue deleters are move assigned. — end note]
template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u);[..]
8 - Postconditions: This unique_ptr now owns the pointer which u owned, and u no longer owns it, u.get() == nullptr.
Change 20.9.10.2.3 [unique.ptr.single.asgn]/6 as indicated: [With the possibility of user-defined pointer-like types the implication does only exist, if those are built-in pointers. Note that this change should also be applied with the acceptance of 950]
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.
[Note: These requirements imply that T and U are complete types. — end note]
Change 20.9.10.2.3 [unique.ptr.single.asgn] before p. 11 and p. 12 as indicated: [The first change is a simple typo fix]
unique_ptr& operator=(nullptr_t});11 - Effects: reset().
12 - Postcondition: get() ==
0nullptr
Change 20.9.10.2.4 [unique.ptr.single.observers]/1+4+12 as indicated:
typename add_lvalue_reference<T>::type operator*() const;1 - Requires: get() !=
0nullptr. The variable definition add_lvalue_reference<T>::type t = *get() shall be well formed, shall have well-defined behavior, and shall not exit via an exception.[..]
pointer operator->() const;4 - Requires: get() !=
0nullptr.[..]
explicit operator bool() const;12 - Returns: get() !=0nullptr.
Change 20.9.10.2.5 [unique.ptr.single.modifiers]/1 as indicated:
pointer release();1 - Postcondition: get() ==0nullptr.
Change 20.9.10.2.5 [unique.ptr.single.modifiers]/9 as indicated: [The intent is to ensure that potentially user-defined swaps are used. A side-step fix and harmonization with the specification of the the deleter is realized. Please note the additional requirement in bullet 2 of this proposed resolution regarding the availability of the generic swap templates within the member swap function.]
void swap(unique_ptr& u);8 - Requires: The deleter D shall be Swappable and shall not throw an exception under swap.
9 - Effects: The stored pointers of *this and u are exchanged by an unqualified call to non-member swap. The stored deleters are
swap'd (unqualified)exchanged by an unqualified call to non-member swap.
Change 20.9.10.3.2 [unique.ptr.runtime.observers]/1 as indicated:
T& operator[](size_t i) const;Requires: i < the size of the array to which the stored pointer points. The variable definition T& t = get()[i] shall be well formed, shall have well-defined behavior, and shall not exit via an exception.
Change 20.9.10.3.3 [unique.ptr.runtime.modifiers]/1 as indicated:
void reset(pointer p = pointer()); void reset(nullptr_t p);1 - Effects: If get() ==0nullptr there are no effects. Otherwise get_deleter()(get()).
Change 20.9.10.4 [unique.ptr.special] as indicated: [We don't add the relational operators to the basic requirement set, therefore we need special handling here]
template <class T1, class D1, class T2, class D2> bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);Requires: The variable definition bool b = x.get() == y.get(); shall be well formed, shall have well-defined behavior, and shall not exit via an exception.
2 - Returns: x.get() == y.get().
Throws: nothing.
template <class T1, class D1, class T2, class D2> bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);Requires: The variable definition bool b = x.get() != y.get(); shall be well formed, shall have well-defined behavior, and shall not exit via an exception.
3 - Returns: x.get() != y.get().
Throws: nothing.
template <class T1, class D1, class T2, class D2> bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);Requires: The variable definition bool b = x.get() < y.get(); shall be well formed, shall have well-defined behavior, and shall not exit via an exception.
4 - Returns: x.get() < y.get().
Throws: nothing.
template <class T1, class D1, class T2, class D2> bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);Requires: The variable definition bool b = x.get() <= y.get(); shall be well formed, shall have well-defined behavior, and shall not exit via an exception.
5 - Returns: x.get() <= y.get().
Throws: nothing.
template <class T1, class D1, class T2, class D2> bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);Requires: The variable definition bool b = x.get() > y.get(); shall be well formed, shall have well-defined behavior, and shall not exit via an exception.
6 - Returns: x.get() > y.get().
Throws: nothing.
template <class T1, class D1, class T2, class D2> bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);Requires: The variable definition bool b = x.get() >= y.get(); shall be well formed, shall have well-defined behavior, and shall not exit via an exception.
7 - Returns: x.get() >= y.get().
Throws: nothing.
Section: 27.5.4.2 [basic.ios.members] Status: Ready Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2010-03-09
View other active issues in [basic.ios.members].
View all other issues in [basic.ios.members].
View all issues with Ready 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";
}
[ Batavia (2009-05): ]
We agree with the proposed resolution. Move to Review.
[ 2009-05-26 Daniel adds: ]
I think that the most recently suggested change in 27.7.2.4 [ostream::sentry] need some further word-smithing. As written, it would make the behavior undefined, if under conditions when pubsync() should be called, but when in this scenario os.rdbuf() returns 0.
This case is explicitly handled in flush() and needs to be taken care of. My suggested fix is:
If ((os.flags() & ios_base::unitbuf) && !uncaught_exception() && os.rdbuf() != 0) is true, callsos.flush()os.rdbuf()->pubsync().Two secondary questions are:
- Should pubsync() be invoked in any case or shouldn't a base requirement for this trial be that os.good() == true as required in the original flush() case?
- Since uncaught_exception() is explicitly tested, shouldn't a return value of -1 of pubsync() produce setstate(badbit) (which may throw ios_base::failure)?
[ 2009-07 Frankfurt: ]
Daniel volunteered to modify the proposed resolution to address his two questions.
Move back to Open.
[ 2009-07-26 Daniel provided wording. Moved to Review. ]
[ 2009-10-13 Daniel adds: ]
This proposed wording is written to match the outcome of 397.
[ 2009 Santa Cruz: ]
Move to Open. Martin to propose updated wording that will also resolve issue 397 consistently.
[ 2010-02-15 Martin provided wording. ]
[ 2010 Pittsburgh: ]
Moved to Ready for Pittsburgh.
Proposed resolution:
Just before 27.5.4.2 [basic.ios.members]/2 insert a new paragraph:
Requires: If (tiestr != 0) is true, tiestr must not be reachable by traversing the linked list of tied stream objects starting from tiestr->tie().
Change 27.7.2.4 [ostream::sentry]/4 as indicated:
If ((os.flags() & ios_base::unitbuf) && !uncaught_exception() && os.good()) is true, callsos.flush()os.rdbuf()->pubsync(). If that function returns -1 sets badbit in os.rdstate() without propagating an exception.
Add after 27.7.2.4 [ostream::sentry] p17, the following paragraph:
Throws: Nothing.
money_base::space and
money_base::none on money_get
Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: Ready Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2009-10-21
View all other issues in [locale.money.get.virtuals].
View all issues with Ready 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.
[ 2009-07 Frankfurt: ]
There is a noun missing from the proposed resolution. It's not clear that the last sentence would be helpful, even if the word were not missing:
In either case, any required MISSINGWORD followed by all optional whitespace (as recognized by ct.is()) is consumed.Strike this sentence and move to Review.
[ Howard: done. ]
[ 2009-10 Santa Cruz: ]
Move to Ready.
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. If(str.flags() & str.showbase)isfalse, ...
Section: 20.9.10.1.1 [unique.ptr.dltr.dflt] Status: Ready Submitter: Howard Hinnant Opened: 2008-06-18 Last modified: 2009-10-21
View all issues with Ready 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.
[ Batavia (2009-05): ]
Keep in Review status for the reasons cited.
[ 2009-07 Frankfurt: ]
The proposed resolution uses concepts. Howard needs to rewrite the proposed resolution.
Move back to Open.
[ 2009-07-26 Howard provided rewritten proposed wording and moved to Review. ]
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Add after 20.9.10.1.1 [unique.ptr.dltr.dflt], p1:
template <class U> default_delete(const default_delete<U>& other);-1- Effects: ...
Remarks: This constructor shall participate in overload resolution if and only if U* is implicitly convertible to T*.
Section: 26 [numerics] Status: Ready Submitter: Lawrence Crowl Opened: 2008-06-23 Last modified: 2009-10-23
View all other issues in [numerics].
View all issues with Ready 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.
[ 2009-09-23 Hans provided wording. ]
If I understand the history correctly, Nick, as the Posix liaison, should probably get a veto on this, since I think it came from Posix (?) via WG14 and should probably really be addressed there (?). But I think we are basically in agreement that there is no other sane way to do this, and hence we don't have to worry too much about stepping on toes. As far as I can tell, this same issue also exists in the latest Posix standard (?).
[ 2009-10 Santa Cruz: ]
Moved to Ready.
Proposed resolution:
Add at the end of 26.3.1 [cfenv.syn]:
2 The header defines all functions, types, and macros the same as C99 7.6.
A separate floating point environment shall be maintained for each thread. Each function accesses the environment corresponding to its calling thread.
Section: 23.2 [container.requirements] Status: Ready Submitter: Daniel Krügler Opened: 2008-06-24 Last modified: 2010-03-10
View other active issues in [container.requirements].
View all other issues in [container.requirements].
View all issues with Ready 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.
[ 2009-07 Frankfurt ]
Other operational semantics (see, for example, Tables 82 and 83) are written in terms of a container's size() member. Daniel to update proposed resolution C.
[ Howard: Commented out options A and B. ]
[ 2009-07-26 Daniel updated proposed resolution C. ]
[ 2009-10 Santa Cruz: ]
Mark NAD Editorial. Addressed by N2986.
[ 2009-10 Santa Cruz: ]
Reopened. N2986 was rejected in full committee on procedural grounds.
[ 2010-01-30 Howard updated Table numbers. ]
[ 2010 Pittsburgh: ]
Moved to Ready for Pittsburgh.
Proposed resolution:
Option (C):
In 23.2.1 [container.requirements.general] change Table 90 -- Container requirements as indicated:
Change the text in the Assertion/note column in the row for "X u;" as follows:
post: u.size() == 0empty() == trueChange the text in the Assertion/note column in the row for "X();" as follows:
X().size() == 0empty() == trueChange the text in the Operational Semantics column in the row for "a == b" as follows:
== is an equivalence relation.a.size()distance(a.begin(), a.end()) ==b.size()distance(b.begin(), b.end()) && equal(a.begin(), a.end(), b.begin())Add text in the Ass./Note/pre-/post-condition column in the row for "a == b" as follows:
Requires: T is EqualityComparableChange the text in the Operational Semantics column in the row for "a.size()" as follows:
a.end() - a.begin()distance(a.begin(), a.end())Change the text in the Operational Semantics column in the row for "a.max_size()" as follows:
size()distance(begin(), end()) of the largest possible containerChange the text in the Operational Semantics column in the row for "a.empty()" as follows:
a.size() == 0a.begin() == a.end()In 23.2.1 [container.requirements.general] change Table 93 -- Allocator-aware container requirements as indicated:
Change the text in the Assertion/note column in the row for "X() / X u;" as follows:
Requires: A is DefaultConstructible post:u.size() == 0u.empty() == true, get_allocator() == A()Change the text in the Assertion/note column in the row for "X(m) / X u(m);" as follows:
post:u.size() == 0u.empty() == true, get_allocator() == mIn 23.2.3 [sequence.reqmts] change Table 94 -- Sequence container requirements as indicated:
Change the text in the Assertion/note column in the row for "X(n, t) / X a(n, t)" as follows:
post:size()distance(begin(), end()) == n [..]Change the text in the Assertion/note column in the row for "X(i, j) / X a(i, j)" as follows:
[..] post:size() == distance between i and jdistance(begin(), end()) == distance(i, j) [..]Change the text in the Assertion/note column in the row for "a.clear()" as follows:
a.erase(a.begin(), a.end()) post:size() == 0a.empty() == trueIn 23.2.4 [associative.reqmts] change Table 96 -- Associative container requirements as indicated:
[ Not every occurrence of size() was replaced, because all current associative containers have a size. The following changes ensure consistency regarding the semantics of "erase" for all tables and adds some missing objects ]
Change the text in the Complexity column in the row for X(i,j,c)/X a(i,j,c); as follows:
N log N in general (N == distance(i, j)is the distance from i to j); ...Change the text in the Complexity column in the row for "a.insert(i, j)" as follows:
N log(a.size() + N)(N is the distance from i to j)where N == distance(i, j)Change the text in the Complexity column in the row for "a.erase(k)" as follows:
log(a.size()) + a.count(k)Change the text in the Complexity column in the row for "a.erase(q1, q2)" as follows:
log(a.size()) + N where Nis the distance from q1 to q2== distance(q1, q2).Change the text in the Assertion/note column in the row for "a.clear()" as follows:
a.erase(a.begin(),a.end()) post:size() == 0a.empty() == trueChange the text in the Complexity column in the row for "a.clear()" as follows:
linear in a.size()Change the text in the Complexity column in the row for "a.count(k)" as follows:
log(a.size()) + a.count(k)In 23.2.5 [unord.req] change Table 98 -- Unordered associative container requirements as indicated:
[ The same rational as for Table 96 applies here ]
Change the text in the Assertion/note column in the row for "a.clear()" as follows:
[..] Post: a.size() == 0empty() == true
Section: 25.3.6 [alg.fill], 25.3.7 [alg.generate] Status: Ready Submitter: Daniel Krügler Opened: 2008-07-13 Last modified: 2009-10-23
View all issues with Ready 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.2 [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. ]
[ Batavia (2009-05): ]
Alisdair likes the idea, but has concerns about the specific wording about the returns clauses.
Alan notes this is a feature request.
Bill notes we have made similar changes to other algorithms.
Move to Open.
[ 2009-07 Frankfurt ]
We have a consensus for moving forward on this issue, but Daniel needs to deconceptify it.
[ 2009-07-25 Daniel provided non-concepts wording. ]
[ 2009-10 Santa Cruz: ]
Moved to Ready.
Proposed resolution:
Replace the current declaration of fill_n in 25 [algorithms]/2, header <algorithm> synopsis and in 25.3.6 [alg.fill] by
template<class OutputIterator, class Size, class T>voidOutputIterator fill_n(OutputIterator first, Size n, const T& value);
Just after the effects clause add a new returns clause saying:
Returns: For fill_n and positive n, 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.3.7 [alg.generate] by
template<class OutputIterator, class Size, class Generator>voidOutputIterator generate_n(OutputIterator first, Size n, Generator gen);
Just after the effects clause add a new returns clause saying:
For generate_n and positive n, returns first + n. Otherwise returns first for generate_n.
Section: 23 [containers] Status: Review Submitter: Alberto Ganesh Barbati Opened: 2008-07-22 Last modified: 2010-03-08
View other active issues in [containers].
View all other issues in [containers].
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
[ 2009-07 Frankfurt ]
The proposed resolution is incomplete.
Move to Tentatively NAD Future. Howard will contact Ganesh for wording. If wording is forthcoming, Howard will move it back to Review.
[ 2009-07-18 Ganesh updated the proposed wording. ]
Howard: Moved back to Review. Note that 20.2.1 [utility.arg.requirements] refers to a section that is not in the current working paper, but does refer to a section that we expect to reappear after the de-concepts merge. This was a point of confusion we did not recognize when we reviewed this issue in Frankfurt.
Howard: Ganesh also includes a survey of places in the WP surveyed for changes of this nature and purposefully not treated:
Places where changes are not being proposed
In the following paragraphs, we are not proposing changes because it's not clear whether we actually prefer value-initialization over default-initialization (now partially covered by 1012):
20.9.10.2.1 [unique.ptr.single.ctor] para 3 e 7
24.5.1.3.1 [reverse.iter.cons] para 1
24.5.3.3.1 [move.iter.op.const] para 1
In the following paragraphs, the expression "default constructed" need not be changed, because the relevant type does not depend on a template parameter and has a user-provided constructor:
[func.referenceclosure.invoke] para 12, type: reference_closure
30.3.1.2 [thread.thread.constr] para 30, type: thread
30.3.1.5 [thread.thread.member] para 52, type: thread_id
30.3.2 [thread.thread.this], para 1, type: thread_id
[ 2009-08-18 Daniel adds: ]
I have no objections against the currently suggested changes, but I also cross-checked with the list regarding intentionally excluded changes, and from this I miss the discussion of
21.4.1 [string.require]/2:
"[..] 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."N2723, X [rand.req.eng], Table 109, expression "T()":
Pre-/post-condition: "Creates an engine with the same initial state as all other default-constructed engines of type X."as well as in 26.5.5 [rand.predef]/1-9 (N2914), 26.5.7.1 [rand.util.seedseq]/3, 27.7.1.1.1 [istream.cons]/3, 27.7.2.2 [ostream.cons]/9 (N2914), 28.13 [re.grammar]/2, 30.3.1.4 [thread.thread.assign]/1 (N2914),
[ Candidates for the "the expression "default constructed" need not be changed" list ]
I'm fine, if these would be added to the intentionally exclusion list, but mentioning them makes it easier for other potential reviewers to decide on the relevance or not-relevance of them for this issue.
I suggest to remove the reference of [func.referenceclosure.invoke] in the "it's not clear" list, because this component does no longer exist.
I also suggest to add a short comment that all paragraphs in the resolution whether they refer to N2723 or to N2914 numbering, because e.g. "Change 23.3.2.1 [deque.cons] para 5" is an N2723 coordinate, while "Change 23.3.2.2 [deque.capacity] para 1" is an N2914 coordinate. Even better would be to use one default document for the numbering (probably N2914) and mention special cases (e.g. "Change 20.2.1 [utility.arg.requirements] para 2" as referring to N2723 numbering).
[ 2009-08-18 Alisdair adds: ]
I strongly believe the term "default constructed" should not appear in the library clauses unless we very clearly define a meaning for it, and I am not sure what that would be.
In those cases where we do not want to replace "default constructed" with "vale initialized" we should be using "default initialized". If we have a term that could mean either, we reduce portability of programs.
I have not done an exhaustive review to clarify if that is a vendor freedom we have reason to support (e.g. value-init in debug, default-init in release) so I may yet be convinced that LWG has reason to define this new term of art, but generally C++ initialization is confusing enough without supporting further ill-defined terms.
[ 2009-10 Santa Cruz: ]
Move to Ready.
[ 2010 Pittsburgh: ]
Moved to review in order to enable conflict resolution with 704.
Proposed resolution:
Change 20.2.1 [utility.arg.requirements] para 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) if one of those signatures is called using the default argument (8.3.6).
Change 23.3.2.1 [deque.cons] para 5:
Effects: Constructs a deque with ndefault constructedvalue-initialized elements.
Change 23.3.2.2 [deque.capacity] para 1:
Effects: If sz < size(), equivalent to erase(begin() + sz, end());. If size() < sz, appends sz - size()default constructedvalue-initialized elements to the sequence.
Change 23.3.3.1 [forwardlist.cons] para 5:
Effects: Constructs a forward_list object with ndefault constructedvalue-initialized elements.
Change 23.3.3.4 [forwardlist.modifiers] para 21:
Effects: [...] For the first signature the inserted elements aredefault constructedvalue-initialized, and for the second signature they are copies of c.
Change 23.3.4.1 [list.cons] para 5:
Effects: Constructs a list with ndefault constructedvalue-initialized elements.
Change 23.3.4.2 [list.capacity] para 15:
Effects: If sz < size(), equivalent to list<T>::iterator it = begin(); advance(it, sz); erase(it, end());. If size() < sz, appends sz - size()default constructedvalue-initialized elements to the sequence.
Change 23.3.6.1 [vector.cons] para 3:
Effects: Constructs a vector with ndefault constructedvalue-initialized elements.
Change 23.3.6.2 [vector.capacity] para 24:
Effects: If sz < size(), equivalent to erase(begin() + sz, end());. If size() < sz, appends sz - size()default constructedvalue-initialized elements to the sequence.
Section: 23.2.5 [unord.req] Status: Ready Submitter: Daniel Krügler Opened: 2008-08-17 Last modified: 2010-03-08
View other active issues in [unord.req].
View all other issues in [unord.req].
View all issues with Ready status.
Discussion:
Good ol' associative containers allow both function pointers and function objects as feasible comparators, as described in 23.2.4 [associative.reqmts]/2:
Each associative container is parameterized on Key and an ordering relation Compare that induces a strict weak ordering (25.3) on elements of Key. [..]. The object of type Compare is called the comparison object of a container. This comparison object may be a pointer to function or an object of a type with an appropriate function call operator.[..]
The corresponding wording for unordered containers is not so clear, but I read it to disallow function pointers for the hasher and I miss a clear statement for the equality predicate, see 23.2.5 [unord.req]/3+4+5:
Each unordered associative container is parameterized by Key, by a function object Hash that acts as a hash function for values of type Key, and by a binary predicate Pred that induces an equivalence relation on values of type Key.[..]
A hash function is a function object that takes a single argument of type Key and returns a value of type std::size_t.
Two values k1 and k2 of type Key are considered equal if the container's equality function object returns true when passed those values.[..]
and table 97 says in the column "assertion...post-condition" for the expression X::hasher:
Hash shall be a unary function object type such that the expression hf(k) has type std::size_t.
Note that 20.8 [function.objects]/1 defines as "Function objects are objects with an operator() defined.[..]"
Does this restriction exist by design or is it an oversight? If an oversight, I suggest that to apply the following
[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]
[ 2009-10 Santa Cruz: ]
Ask Daniel to provide proposed wording that: makes it explicit that function pointers are function objects at the beginning of 20.8 [function.objects]; fixes the "requirements" for typedefs in 20.8.5 [refwrap] to instead state that the function objects defined in that clause have these typedefs, but not that these typedefs are requirements on function objects; remove the wording that explicitly calls out that associative container comparators may be function pointers.
[ 2009-12-19 Daniel updates wording and rationale. ]
[ 2010-02-11 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Rationale:
The below provided wording also affects some part of the library which is involved with callable types (20.8.1 [func.def]/3). Reason for this is that callable objects do have a lot in common with function objects. A simple formula seems to be:
callable objects = function objects + pointers to member
The latter group is excluded from function objects because of the expression-based usage of function objects in the algorithm clause, which is incompatible with the notation to dereference pointers to member without a concept map available in the language.
This analysis showed some currently existing normative definition differences between the above subset of callable objects and function objects which seem to be unintended: Backed by the Santa Cruz outcome function objects should include both function pointers and "object[s] with an operator() defined". This clearly excludes class types with a conversion function to a function pointer or all similar conversion function situations described in 13.3 [over.match]/2 b. 2. In contrast to this, the wording for callable types seems to be less constrained (20.8.1 [func.def]/3):
A callable type is a [..] class type whose objects can appear immediately to the left of a function call operator.
The rationale given in N1673 and a recent private communication with Peter Dimov revealed that the intention of this wording was to cover the above mentioned class types with conversion functions as well. To me the current wording of callable types can be read either way and I suggest to make the intention more explicit by replacing
[..] class type whose objects can appear immediately to the left of a function call operatorby
[..] class type whose objects can appear as the leftmost subexpression of a function call expression 5.2.2 [expr.call].
and to use the same definition for the class type part of function objects, because there is no reason to exclude class types with a conversion function to e.g. pointer to function from being used in algorithms.
Now this last term "function objects" itself brings us to a third unsatisfactory state: The term is used both for objects (e.g. "Function objects are objects[..]" in 20.8 [function.objects]/1) and for types (e.g. "Each unordered associative container is parameterized [..] by a function object Hash that acts as a hash function [..]" in 23.2.5 [unord.req]/3). This impreciseness should be fixed and I suggest to introduce the term function object type as the counter part to callable type. This word seems to be a quite natural choice, because the library already uses it here and there (e.g. "Hash shall be a unary function object type such that the expression hf(k) has type std::size_t." in Table 98, "X::hasher" or "Requires: T shall be a function object type [..]" in 20.8.15.2.5 [func.wrap.func.targ]/3).
Finally I would like to add that part of the issue 870 discussion related to the requirements for typedefs in 20.8.5 [refwrap] during the Santa Cruz meeting is now handled by the new issue 1290.
Obsolete rationale:
[ San Francisco: ]
This is fixed by N2776.
Proposed resolution:
Change 20.8 [function.objects]/1 as indicated:
1
Function objects are objects with an operator() defined.An object type (3.9 [basic.types]) that can be the type of the postfix-expression in a function call (5.2.2 [expr.call], 13.3.1.1 [over.match.call]) is called a function object type*. A function object is an object of a function object type. In the places where one would expect to pass a pointer to a function to an algorithmic template (Clause 25 [algorithms]), the interface is specified to acceptan object with an operator() defineda function object. This not only makes algorithmic templates work with pointers to functions, but also enables them to work with arbitrary function objects.* Such a type is either a function pointer or a class type which often has a member operator(), but in some cases it can omit that member and provide a conversion to a pointer to function.
Change 20.8.1 [func.def]/3 as indicated: [The intent is to make the commonality of callable types and function object types more explicit and to get rid of wording redundancies]
3 A callable type isa pointer to function,a pointer to memberfunction, a pointer to member data,or aclass type whose objects can appear immediately to the left of a function call operatorfunction object type (20.8 [function.objects]).
Change 20.8.11 [bind]/1 as indicated:
1 The function template bind returns an object that binds afunctioncallable object passed as an argument to additional arguments.
Change 20.8.11.1 [func.bind]/1 as indicated:
1 This subclause describes a uniform mechanism for binding arguments offunctioncallable objects.
Change 20.8.15 [func.wrap]/1 as indicated:
1 This subclause describes a polymorphic wrapper class that encapsulates arbitraryfunctioncallable objects.
Change 20.8.15.2 [func.wrap.func]/2 as indicated [The reason for this change is that 20.8.15.2 [func.wrap.func]/1 clearly says that all callable types may be wrapped by std::function and current implementations indeed do provide support for pointer to members as well. One further suggested improvement is to set the below definition of Callable in italics]:
2 Afunctioncallable object f of type F isCallableCallable for argument typesT1, T2, ..., TN inArgTypes andareturn type R,if, given lvalues t1, t2, ..., tN of types T1, T2, ..., TN, respectively,the expression INVOKE(f, declval<ArgTypes>()..., Rt1, t2, ..., tN), considered as an unevaluated operand (5 [expr]), is well formed (20.7.2)and, if R is not void, convertible to R.
Change 20.8.15.2.1 [func.wrap.func.con]/7 as indicated:
function(const function& f); template <class A> function(allocator_arg_t, const A& a, const function& f);...
7 Throws: shall not throw exceptions if f's target is a function pointer or a
functioncallable object passed via reference_wrapper. Otherwise, may throw bad_alloc or any exception thrown by the copy constructor of the storedfunctioncallable object. [Note: Implementations are encouraged to avoid the use of dynamically allocated memory for smallfunctioncallable objects, e.g., where f's target is an object holding only a pointer or reference to an object and a member function pointer. — end note]
Change 20.8.15.2.1 [func.wrap.func.con]/11 as indicated:
template<class F> function(F f); template <class F, class A> function(allocator_arg_t, const A& a, F f);...
11 [..] [Note: implementations are encouraged to avoid the use of dynamically allocated memory for small
functioncallable objects, for example, where f's target is an object holding only a pointer or reference to an object and a member function pointer. — end note]
Change 20.8.15.2.4 [func.wrap.func.inv]/3 as indicated:
R operator()(ArgTypes... args) const...
3 Throws: bad_function_call if !*this; otherwise, any exception thrown by the wrapped
functioncallable object.
Change 20.8.15.2.5 [func.wrap.func.targ]/3 as indicated:
template<typename T> T* target(); template<typename T> const T* target() const;...
3 Requires: T shall be a
function objecttype that is Callable (20.8.15.2 [func.wrap.func]) for parameter types ArgTypes and return type R.
Change 23.2.4 [associative.reqmts]/2 as indicated: [The suggested removal seems harmless, because 25.4 [alg.sorting]1 already clarifies that Compare is a function object type. Nevertheless it is recommended, because the explicit naming of "pointer to function" is misleading]
2 Each associative container is parameterized on Key and an ordering relation Compare that induces a strict weak ordering (25.4 [alg.sorting]) on elements of Key. In addition, map and multimap associate an arbitrary type T with the Key. The object of type Compare is called the comparison object of a container.This comparison object may be a pointer to function or an object of a type with an appropriate function call operator.
Change 23.2.5 [unord.req]/3 as indicated:
3 Each unordered associative container is parameterized by Key, by a function object type Hash that acts as a hash function for values of type Key, and by a binary predicate Pred that induces an equivalence relation on values of type Key. [..]
Change 25.1 [algorithms.general]/7 as indicated: [The intent is to bring this part in sync with 20.8 [function.objects]]
7 The Predicate parameter is used whenever an algorithm expects a function object (20.8 [function.objects]) that when applied to the result of dereferencing the corresponding iterator returns a value testable as true. In other words, if an algorithm takes Predicate pred as its argument and first as its iterator argument, it should work correctly in the construct if (pred(*first)){...}. The function object pred shall not apply any nonconstant function through the dereferenced iterator.This function object may be a pointer to function, or an object of a type with an appropriate function call operator.
Change 20.9.10.2 [unique.ptr.single]/1 as indicated:
1 The default type for the template parameter D is default_delete. A client-supplied template argument D shall be a functionpointer or functorobject type for which, given a value d of type D and a pointer ptr of type T*, the expression d(ptr) is valid and has the effect of deallocating the pointer as appropriate for that deleter. D may also be an lvalue-reference to a deleter.
Section: 26.7.5 [numeric.iota] Status: Ready Submitter: Daniel Krügler Opened: 2008-08-20 Last modified: 2009-10-22
View all issues with Ready status.
Discussion:
According to the recent WP N2691, 26.7.5 [numeric.iota]/1, the requires clause of std::iota says:
T shall meet the requirements of CopyConstructible and Assignable types, and shall be convertible to ForwardIterator's value type.[..]
Neither CopyConstructible nor Assignable is needed, instead MoveConstructible seems to be the correct choice. I guess the current wording resulted as an artifact from comparing it with similar numerical algorithms like accumulate.
Note: If this function will be conceptualized, the here proposed MoveConstructible requirement can be removed, because this is an implied requirement of function arguments, see N2710/[temp.req.impl]/3, last bullet.
[ post San Francisco: ]
Issue pulled by author prior to review.
[ 2009-07-30 Daniel reopened: ]
with the absence of concepts, this issue (closed) is valid again and I suggest to reopen it. I also revised by proposed resolution based on N2723 wording:
[ 2009-10 Santa Cruz: ]
Change 'convertible' to 'assignable', Move To Ready.
Proposed resolution:
Change the first sentence of 26.7.5 [numeric.iota]/1:
Requires: T shallmeet the requirements of CopyConstructible and Assignable types, and shallbe assignable to ForwardIterator's value type. [..]
Section: 24.5.3.3.12 [move.iter.op.index] Status: Ready Submitter: Doug Gregor Opened: 2008-08-21 Last modified: 2009-10-23
View all issues with Ready status.
Discussion:
move_iterator's operator[] is declared as:
reference operator[](difference_type n) const;
This has the same problem that reverse_iterator's operator[] used to have: if the underlying iterator's operator[] returns a proxy, the implicit conversion to value_type&& could end up referencing a temporary that has already been destroyed. This is essentially the same issue that we dealt with for reverse_iterator in DR 386.
[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]
[ 2009-08-15 Howard adds: ]
I recommend closing this as a duplicate of 1051 which addresses this issue for both move_iterator and reverse_iterator.
[ 2009-10 Santa Cruz: ]
Move to Ready. Note that if 1051 is reopened, it may yield a better resolution, but 1051 is currently marked NAD.
Proposed resolution:
In 24.5.3.1 [move.iterator] and 24.5.3.3.12 [move.iter.op.index], change the declaration of move_iterator's operator[] to:
referenceunspecified operator[](difference_type n) const;
Rationale:
[ San Francisco: ]
NAD Editorial, see N2777.
Section: 20.3.4 [pairs] Status: Ready Submitter: Alisdair Meredith Opened: 2008-09-15 Last modified: 2010-03-12
View other active issues in [pairs].
View all other issues in [pairs].
View all issues with Ready 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.
[ 2009-05-25 Alisdair adds: ]
Issue 885 was something I reported while reviewing the library concepts documents ahead of San Francisco. The missing operator was added as part of the paper adopted at that meeting (N2770) and I can confirm this operator is present in the current working paper. I recommend NAD.
[ 2009-07 Frankfurt ]
We agree with the intent, but we need to wait for the dust to settle on concepts.
[ 2010-03-11 Stefanus provided wording. ]
[ 2010 Pittsburgh: Moved to Ready for Pittsburgh. ]
Proposed resolution:
Add the following declaration 20.3.4.2 [pairs.pair], before the declaration of pair& operator=(pair&& p);:
template<class U, class V> pair& operator=(const pair<U, V>& p);
Add the following description to 20.3.4.2 [pairs.pair] after paragraph 11 (before the description of pair& operator=(pair&& p);):
template<class U, class V> pair& operator=(const pair<U, V>& p);Requires: T1 shall satisfy the requirements of CopyAssignable from U. T2 shall satisfy the requirements of CopyAssignable from V.
Effects: Assigns p.first to first and p.second to second.
Returns: *this.
Section: 30.3.1.2 [thread.thread.constr], 30.4.5.2 [thread.once.callonce] Status: Ready Submitter: Peter Dimov Opened: 2008-09-15 Last modified: 2010-03-08
View other active issues in [thread.thread.constr].
View all other issues in [thread.thread.constr].
View all issues with Ready 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. ]
[ 2009-07 Frankfurt ]
Leave Open. Await decision for thread variadic constructor.
[ 2009-10 Santa Cruz: ]
See proposed wording for 929 for this, for the formulation on how to solve this. 929 modifies the thread constructor to have "pass by value" behavior with pass by reference efficiency through the use of the decay trait. This same formula would be useful for call_once.
[ 2010-02-11 Anthony updates wording. ]
[ 2010-02-12 Moved to Tentatively Ready after 5 postive votes on c++std-lib. ]
Proposed resolution:
Modify 30.4.5.2 [thread.once.callonce] p1-p2 with the following:
template<class Callable, class ...Args> void call_once(once_flag& flag, Callable&& func, Args&&... args);Given a function as follows:
template<typename T> typename decay<T>::type decay_copy(T&& v) { return std::forward<T>(v); }1 Requires:
The template parametersCallable and each Ti in Args shallbe CopyConstructible if an lvalue and otherwisesatisfy the MoveConstructible requirements. INVOKE(decay_copy(std::forward<Callable>(func),w1, w2, ..., wNdecay_copy(std::forward<Args>(args))...) (20.8.2 [func.require]) shall be a valid expressionfor some values w1, w2, ..., wN, where N == sizeof...(Args).2 Effects: Calls to call_once on the same once_flag object are serialized. If there has been a prior effective call to call_once on the same once_flag object, the call to call_once returns without invoking func. If there has been no prior effective call to call_once on the same once_flag object,
the argument func (or a copy thereof) is called as if by invoking func(args)INVOKE(decay_copy(std::forward<Callable>(func)), decay_copy(std::forward<Args>(args))...) is executed. The call to call_once is effective if and only iffunc(args)INVOKE(decay_copy(std::forward<Callable>(func)), decay_copy(std::forward<Args>(args))...) returns without throwing an exception. If an exception is thrown it is propagated to the caller.
Section: 30.4.1.1 [thread.mutex.class] Status: Ready Submitter: Peter Dimov Opened: 2008-09-15 Last modified: 2010-03-08
View all other issues in [thread.mutex.class].
View all issues with Ready 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"
[ 2009-07 Frankfurt ]
Move to Review. Alisdair to provide note.
[ 2009-07-31 Alisdair provided note. ]
[ 2009-10 Santa Cruz: ]
Moved to Ready.
[ 2009-11-18 Peter Opens: ]
I don't believe that the proposed note:
[Note: a program may deadlock if the thread that owns a mutex object calls lock() or try_lock() on that object. If the program can detect the deadlock, a resource_deadlock_would_occur error condition may be observed. — end note]is entirely correct. "or try_lock()" should be removed, because try_lock is non-blocking and doesn't deadlock; it just returns false when it fails to lock the mutex.
[ Howard: I've set to Open and updated the wording per Peter's suggestion. ]
[ 2009-11-18 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
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- ...
Add the following note after p3 30.4.1.1 [thread.mutex.class]
[Note: a program may deadlock if the thread that owns a mutex object calls lock() on that object. If the implementation can detect the deadlock, a resource_deadlock_would_occur error condition may be observed. — end note]
Section: 20.9.11.2 [util.smartptr.shared] Status: Ready Submitter: Hans Boehm Opened: 2008-09-16 Last modified: 2010-03-12
View all other issues in [util.smartptr.shared].
View all issues with Ready 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.
[ 2009-07 Frankfurt ]
Vote: Do we want one thread-safe shared pointer or two? If two, one would allow concurrent construction and destruction of shared pointers, and one would not be thread-safe. If one, then it would be thread-safe.
No concensus on that vote.
Hans to improve wording in consultation with Pete. Leave Open.
[ 2009-10 Santa Cruz: ]
Move to Ready. Ask Editor to clear up wording a little when integrating to make it clear that the portion after the first comma only applies for the presence of data races.
[ 2009-10-24 Hans adds: ]
I think we need to pull 896 back from ready, unfortunately. My wording doesn't say the right thing.
I suspect we really want to say something along the lines of:
For purposes of determining the presence of a data race, member functions access and modify only the shared_ptr and weak_ptr objects themselves and not objects they refer to. Changes in use_count() do not reflect modifications that can introduce data races.But I think this needs further discussion by experts to make sure this is right.
Detlef and I agree continue to disagree on the resolution, but I think we agree that it would be good to try to expedite this so that it can be in CD2, since it's likely to generate NB comments no matter what we do. And lack of clarity of intent is probably the worst option. I think it would be good to look at this between meetings.
[ 2010-01-20 Howard: ]
I've moved Hans' suggested wording above into the proposed resolution section and preserved the previous wording here:
Make it explicitly thread-safe, in this weak sense, as I believe was intended:
Insert in 20.9.11.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.
[ 2010 Pittsburgh: Moved to Ready for Pittsburgh ]
Proposed resolution:
Insert a new paragraph at the end of 20.9.11.2 [util.smartptr.shared]:
For purposes of determining the presence of a data race, member functions access and modify only the shared_ptr and weak_ptr objects themselves and not objects they refer to. Changes in use_count() do not reflect modifications that can introduce data races.
Section: 27.9.1.8 [ifstream.assign] Status: Ready Submitter: Niels Dekker Opened: 2008-09-20 Last modified: 2010-03-10
View all issues with Ready 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).
[ Batavia (2009-05): ]
Howard agrees with the analysis and the direction proposed.
Move to Open pending specific wording to be supplied by Howard.
[ 2009-07 Frankfurt: ]
Howard is going to write wording.
[ 2009-07-26 Howard provided wording. ]
[ 2009-09-13 Niels adds: ]
Note: The proposed change of 27.9.1.3 [filebuf.assign]/1 depends on the resolution of LWG 1204, which allows implementations to assume that *this and rhs refer to different objects.
[ 2009 Santa Cruz: ]
Leave as Open. Too closely related to 911 to move on at this time.
[ 2010 Pittsburgh: ]
Moved to Ready for Pittsburgh.
Proposed resolution:
Change 27.8.1.2 [stringbuf.assign]/1:
basic_stringbuf& operator=(basic_stringbuf&& rhs);-1- Effects:swap(rhs).After the move assignment *this reflects the same observable state it would have if it had been move constructed from rhs (27.8.1.1 [stringbuf.cons]).
Change 27.8.2.2 [istringstream.assign]/1:
basic_istringstream& operator=(basic_istringstream&& rhs);-1- Effects:swap(rhs).Move assigns the base and members of *this with the respective base and members of rhs.
Change 27.8.3.2 [ostringstream.assign]/1:
basic_ostringstream& operator=(basic_ostringstream&& rhs);-1- Effects:swap(rhs).Move assigns the base and members of *this with the respective base and members of rhs.
Change 27.8.5.1 [stringstream.assign]/1:
basic_stringstream& operator=(basic_stringstream&& rhs);-1- Effects:swap(rhs).Move assigns the base and members of *this with the respective base and members of rhs.
Change 27.9.1.3 [filebuf.assign]/1:
basic_filebuf& operator=(basic_filebuf&& rhs);-1- Effects:swap(rhs).Begins by calling this->close(). After the move assignment *this reflects the same observable state it would have if it had been move constructed from rhs (27.9.1.2 [filebuf.cons]).
Change 27.9.1.8 [ifstream.assign]/1:
basic_ifstream& operator=(basic_ifstream&& rhs);-1- Effects:swap(rhs).Move assigns the base and members of *this with the respective base and members of rhs.
Change 27.9.1.12 [ofstream.assign]/1:
basic_ofstream& operator=(basic_ofstream&& rhs);-1- Effects:swap(rhs).Move assigns the base and members of *this with the respective base and members of rhs.
Change 27.9.1.16 [fstream.assign]/1:
basic_fstream& operator=(basic_fstream&& rhs);-1- Effects:swap(rhs).Move assigns the base and members of *this with the respective base and members of rhs.
Section: 27.7.1 [input.streams], 27.7.2 [output.streams] Status: Ready Submitter: Alberto Ganesh Barbati Opened: 2008-09-29 Last modified: 2010-03-10
View all issues with Ready 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.
[ Batavia (2009-05): ]
We note that the rvalue swap functions have already been removed.
Bill is unsure about making the affected functions protected; he believes they may need to be public.
We are also unsure about removing the lvalue swap functions as proposed.
Move to Open.
[ 2009-07 Frankfurt: ]
It's not clear that the use case is compelling.
Howard: This needs to be implemented and tested.
[ 2009-07-26 Howard adds: ]
I started out thinking I would recommend NAD for this one. I've turned around to agree with the proposed resolution (which I've updated to the current draft). I did not fully understand Ganesh's rationale, and attempt to describe my improved understanding below.
The move constructor, move assignment operator, and swap function are different for basic_istream, basic_ostream and basic_iostream than other classes. A timely conversation with Daniel reminded me of this long forgotten fact. These members are sufficiently different that they would be extremely confusing to use in general, but they are very much needed for derived clients.
- The move constructor moves everything but the rdbuf pointer.
- The move assignment operator moves everything but the rdbuf pointer.
- The swap function swaps everything but the rdbuf pointer.
The reason for this behavior is that for the std-derived classes (stringstreams, filestreams), the rdbuf pointer points back into the class itself (self referencing). It can't be swapped or moved. But this fact isn't born out at the stream level. Rather it is born out at the fstream/sstream level. And the lower levels just need to deal with that fact by not messing around with the rdbuf pointer which is stored down at the lower levels.
In a nutshell, it is very confusing for all of those who are not so intimately related with streams that they've implemented them. And it is even fairly confusing for some of those who have (including myself). I do not think it is safe to swap or move istreams or ostreams because this will (by necessary design) separate stream state from streambuffer state. Derived classes (such as fstream and stringstream must be used to keep the stream state and stream buffer consistently packaged as one unit during a move or swap.
I've implemented this proposal and am living with it day to day.
[ 2009 Santa Cruz: ]
Leave Open. Pablo expected to propose alternative wording which would rename move construction, move assignment and swap, and may or may not make them protected. This will impact issue 900.
[ 2010 Pittsburgh: ]
Moved to Ready for Pittsburgh.
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 swap free function signature
// swap: 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);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 swap free function signature
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);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 swap free function signature
// swap: 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 4
template <class charT, class traits> void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);Effects: x.swap(y).
Section: 25.4.7 [alg.min.max] Status: Open Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2009-10-23
View other active issues in [alg.min.max].
View all other issues in [alg.min.max].
View all issues with Open status.
Discussion:
It seems that the proposed changes for N2772 were not clear enough in this point:
25.4.7 [alg.min.max], before p.23 + p.24 + before p. 27 + p. 28 say that the return type of the minmax overloads with an initializer_list is pair<const T&, const T&>, which is inconsistent with the decision for the other min/max overloads which take a initializer_list as argument and return a T, not a const T&. Doing otherwise for minmax would easily lead to unexpected life-time problems by using minmax instead of min and max separately.
[ Batavia (2009-05): ]
We agree with the proposed resolution. Move to Tentatively Ready.
[ 2009-07 Frankfurt ]
Moved from Tentatively Ready to Open only because the wording needs to be tweaked for concepts removal.
[ 2009-08-18 Daniel adds: ]
Recommend NAD since the proposed changes have already been performed as part of editorial work of N2914.
[ 2009-10 Santa Cruz: ]
Can't find initializer_list form of minmax anymore, only variadic version. Seems like we had an editing clash with concepts. Leave Open, at least until editorial issues resolved. Bring this to Editor's attention.
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.4.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.8.14 [func.memfn] Status: Ready Submitter: Bronek Kozicki Opened: 2008-10-06 Last modified: 2009-10-23
View all other issues in [func.memfn].
View all issues with Ready status.
Duplicate of: 1230
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. ]
[ Batavia (2009-05): ]
We need to think about whether we really want to go down the proposed path of combinatorial explosion. Perhaps a Note would suffice.
We would really like to have an implementation before proceeding.
Move to Open, and recommend this be deferred until after the next Committee Draft has been issued.
[ 2009-10-10 Daniel updated wording to post-concepts. ]
1230 has a similar proposed resolution
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Change 20.8 [function.objects]/2, header <functional> synopsis as follows:
// 20.7.14, member function adaptors: template<class R, class T> unspecified mem_fn(R T::*); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...)); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) volatile); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const volatile); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) &); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const &); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) volatile &); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const volatile &); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) &&); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const &&); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) volatile &&); template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const volatile &&);
Change the prototype list of 20.8.14 [func.memfn] as follows [NB: 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. ]:
template<class R, class T> unspecified mem_fn(R T::* pm); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...)); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) &); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const &); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) &&); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const &&); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &&); template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);
Remove 20.8.14 [func.memfn]/5:
Remarks: Implementations may implement mem_fn as a set of overloaded function templates.
Section: 20.6.1 [ratio.ratio] Status: Ready Submitter: Pablo Halpern Opened: 2008-10-07 Last modified: 2009-10-21
View other active issues in [ratio.ratio].
View all other issues in [ratio.ratio].
View all issues with Ready 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.
[ 2009-05-11 Daniel adds: ]
Personally I'm not in favor for the addition of:
typedef ratio type;For a reader of the standard it's usage or purpose is unclear. I haven't seen similar examples of attempts to satisfy non-feature complete compilers.
[ 2009-05-11 Pablo adds: ]
The addition of type to the ratio template allows the previous style (i.e., in the prototype implementations) to remain valid and permits the use of transitional library implementations for C++03 compilers. I do not feel strongly about its inclusion, however, and leave it up to the reviewers to decide.
[ Batavia (2009-05): ]
Bill asks for additional discussion in the issue that spells out more details of the implementation. Howard points us to issue 948 which has at least most of the requested details. Tom is strongly in favor of overflow-checking at compile time. Pete points out that there is no change of functionality implied. We agree with the proposed resolution, but recommend moving the issue to Review to allow time to improve the discussion if needed.
[ 2009-07-21 Alisdair adds: ]
See 1121 for a potentially incompatible proposal.
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
In 20.6 [ratio]/3 change as indicated:
// ratio arithmetic template <class R1, class R2>structusing ratio_add = see below; template <class R1, class R2>structusing ratio_subtract = see below; template <class R1, class R2>structusing ratio_multiply = see below; template <class R1, class R2>structusing ratio_divide = see below;
In 20.6.1 [ratio.ratio], change as indicated:
namespace std {
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 20.6.2 [ratio.arithmetic] change as indicated:
template <class R1, class R2>structusing ratio_add = see below{ typedef see below type; };1 The
nested 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.
template <class R1, class R2>structusing ratio_subtract = see below{ typedef see below type; };2 The
nested typedeftype ratio_subtract<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.
template <class R1, class R2>structusing ratio_multiply = see below{ typedef see below type; };3 The
nested typedeftype ratio_multiply<R1, R2> 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.
template <class R1, class R2>structusing ratio_divide = see below{ typedef see below type; };4 The
nested typedeftype ratio_divide<R1, R2> shall be a synonym for ratio<T1, T2> where T1 has the value R1::num * R2::den and T2 has the value R1::den * R2::num.
In 20.10.3.1 [time.duration.cons]/4 change as indicated:
Requires: treat_as_floating_point<rep>::value shall be true or ratio_divide<Period2, period>::
type::den shall be 1.[..]
In 20.10.3.7 [time.duration.cast]/2 change as indicated:
Returns: Let CF be ratio_divide<Period, typename ToDuration::period>
::type, and [..]
Section: 30.3.1.2 [thread.thread.constr] Status: Ready Submitter: Anthony Williams Opened: 2008-10-23 Last modified: 2010-03-08
View other active issues in [thread.thread.constr].
View all other issues in [thread.thread.constr].
View all issues with Ready 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.4 [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.8.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.
[ Batavia (2009-05): ]
We agree with the proposed resolution, but would like the final sentence to be reworded since "catchable" is not a term of art (and is used nowhere else).
[ 2009-07 Frankfurt: ]
This is linked to N2901.
Howard to open a separate issue to remove (1176).
In Frankfurt there is no consensus for removing the variadic constructor.
[ 2009-10 Santa Cruz: ]
We want to move forward with this issue. If we later take it out via 1176 then that's ok too. Needs small group to improve wording.
[ 2009-10 Santa Cruz: ]
Stefanus provided revised wording. Moved to Review Here is the original wording:
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.8.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.
[ 2010-01-19 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
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:
Given a function as follows:
template<typename T> typename decay<T>::type decay_copy(T&& v) { return std::forward<T>(v); }-4- Requires: F and each Ti in Args shall
be CopyConstructible if an lvalue and otherwisesatisfy the MoveConstructible requirements.INVOKE(f, w1, w2, ..., wN) (20.8.2 [func.require]) shall be a valid expression for some values w1, w2, ... , wN, where N == sizeof...(Args).INVOKE(decay_copy(std::forward<F>(f)), decay_copy(std::forward<Args>(args))...) (20.8.2 [func.require]) shall be a valid expression.-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.... Any return value from f is ignored. If f terminates with an uncaught exception, std::terminate() shall be called.The new thread of execution executes INVOKE(decay_copy(std::forward<F>(f)), decay_copy(std::forward<Args>(args))...) with the calls to decay_copy() being evaluated in the constructing thread. Any return value from this invocation is ignored. [Note: this implies any exceptions not thrown from the invocation of the copy of f will be thrown in the constructing thread, not the new thread. — end note]. If the invocation of INVOKE(decay_copy(std::forward<F>(f)), decay_copy(std::forward<Args>(args))...) terminates with an uncaught exception, std::terminate shall be called.-6- Synchronization: The invocation of the constructor happens before the invocation of the copy of f.
Section: 20.9.10.2.1 [unique.ptr.single.ctor] Status: Ready Submitter: Howard Hinnant Opened: 2008-11-26 Last modified: 2009-10-22
View other active issues in [unique.ptr.single.ctor].
View all other issues in [unique.ptr.single.ctor].
View all issues with Ready status.
Discussion:
Addresses US 79
20.9.10.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.
[ 2009-07 Frankfurt ]
Moved from Tentatively Ready to Open only because the wording needs to be improved for enable_if type constraining, possibly following Robert's formula.
[ 2009-07 Frankfurt: ]
We need to consider whether some requirements in the Requires paragraphs of [unique.ptr] should instead be Remarks.
Leave Open. Howard to provide wording, and possibly demonstrate how this can be implemented using enable_if.
[ 2009-07-27 Howard adds: ]
The two constructors to which this issue applies are not easily constrained with enable_if as they are not templated:
unique_ptr(); explicit unique_ptr(pointer p);To "SFINAE" these constructors away would take heroic effort such as specializing the entire unique_ptr class template on pointer deleter types. There is insufficient motivation for such heroics. Here is the expected and reasonable implementation for these constructors:
unique_ptr() : ptr_(pointer()) { static_assert(!is_pointer<deleter_type>::value, "unique_ptr constructed with null function pointer deleter"); } explicit unique_ptr(pointer p) : ptr_(p) { static_assert(!is_pointer<deleter_type>::value, "unique_ptr constructed with null function pointer deleter"); }I.e. just use static_assert to verify that the constructor is not instantiated with a function pointer for a deleter. The compiler will automatically take care of issuing a diagnostic if the deleter is a reference type (uninitialized reference error).
In keeping with our discussions in Frankfurt, I'm moving this requirement on the implementation from the Requires paragraph to a Remarks paragraph.
[ 2009-08-17 Daniel adds: ]
It is insufficient to require a diagnostic. This doesn't imply an ill-formed program as of 1.3.3 [defns.diagnostic] (a typical alternative would be a compiler warning), but exactly that seems to be the intend. I suggest to use the following remark instead:
Remarks: The program shall be ill-formed if this constructor is instantiated when D is a pointer type or reference type.Via the general standard rules of 1.4 [intro.compliance] the "diagnostic required" is implied.
[ 2009-10 Santa Cruz: ]
Moved to Ready.
Proposed resolution:
Change the description of the default constructor in 20.9.10.2.1 [unique.ptr.single.ctor]:
unique_ptr();-1- Requires: D shall be default constructible, and that construction shall not throw an exception.
D shall not be a reference type or pointer type (diagnostic required)....
Remarks: The program shall be ill-formed if this constructor is instantiated when D is a pointer type or reference type.
Add after 20.9.10.2.1 [unique.ptr.single.ctor]/8:
unique_ptr(pointer p);...
Remarks: The program shall be ill-formed if this constructor is instantiated when D is a pointer type or reference type.
Section: 20.3.3 [forward] Status: Ready Submitter: Alisdair Meredith Opened: 2008-12-11 Last modified: 2009-10-29
View all other issues in [forward].
View all issues with Ready status.
Discussion:
std::identity 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; its 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)!
[ Batavia (2009-05): ]
We dislike options i and iii, and option ii seems like overkill. If we remove it (option iv), implementers can still provide it under a different name.
Move to Open pending wording (from Alisdair) for option iv.
[ 2009-05-23 Alisdair provided wording for option iv. ]
[ 2009-07-20 Alisdair adds: ]
I'm not sure why this issue was not discussed at Frankfurt (or I missed the discussion) but the rationale is now fundamentally flawed. With the removal of concepts, std::identity again becomes an important library type so we cannot simply remove it.
At that point, we need to pick one of the other suggested resolutions, but have no guidance at the moment.
[ 2009-07-20 Howard adds: ]
I believe the rationale for not addressing this issue in Frankfurt was that it did not address a national body comment.
I also believe that removal of identity is still a practical option as my latest reformulation of forward, which is due to comments suggested at Summit, no longer uses identity. :-)
template <class T, class U, class = typename enable_if < !is_lvalue_reference<T>::value || is_lvalue_reference<T>::value && is_lvalue_reference<U>::value >::type, class = typename enable_if < is_same<typename remove_all<T>::type, typename remove_all<U>::type>::value >::type> inline T&& forward(U&& t) { return static_cast<T&&>(t); }[ The above code assumes acceptance of 1120 for the definition of remove_all. This is just to make the syntax a little more palatable. Without this trait the above is still very implementable. ]
Paper with rationale is on the way ... really, I promise this time! ;-)
[ 2009-07-30 Daniel adds: See 823 for an alternative resolution. ]
[ 2009-10 Santa Cruz: ]
Move to Ready. Howard will update proposed wording to reflect current draft.
Proposed resolution:
Strike from 20.3 [utility]:
template <class T> struct identity;
Remove from 20.3.3 [forward]:
template <class T> struct identity { typedef T type; const T& operator()(const T& x) const; };const T& operator()(const T& x) const;-2- Returns: x
Section: 20.9.10.2.1 [unique.ptr.single.ctor] Status: Open Submitter: Howard Hinnant Opened: 2009-01-07 Last modified: 2010-02-28
View other active issues in [unique.ptr.single.ctor].
View all other issues in [unique.ptr.single.ctor].
View all issues with Open 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.
[ Batavia (2009-05): ]
The post-Summit comments have been applied to the proposed resolution. We now agree with the proposed resolution. Move to Tentatively Ready.
[ 2009-07 Frankfurt ]
Moved from Tentatively Ready to Open only because the wording needs to be improved for enable_if type constraining, possibly following Robert's formula.
[ 2009-08-01 Howard updates wording and sets to Review. ]
[ 2009-10 Santa Cruz: ]
Move to Ready.
[ 2010-02-27 Pete Opens: ]
The proposed replacement text doesn't make sense.
If D is a reference type, then E shall be the same type as D, else this constructor shall not participate in overload resolution.This imposes two requirements. 1. If D is a reference type, E has to be D. 2. If D is not a reference type, the constructor shall not participate in overload resolution. If the latter apples, the language in the preceding paragraph that this constructor shall not throw an exception if D is not a reference type is superfluous. I suspect that's not the intention, but I can't parse this text any other way.
U shall not be an array type, else this constructor shall not participate in overload resolution.I don't know what this means.
[ 2010-02-27 Peter adds: ]
I think that the intent is (proposed text):
Remarks: this constructor shall only participate in overload resolution if:
- unique_ptr<U, E>::pointer is implicitly convertible to pointer,
- U is not an array type, and
- if D is a reference type, E is the same type as D.
[ 2010-02-28 Howard adds: ]
I like Peter's proposal. Here is a tweak of it made after looking at my implementation. I believe this fixes a further defect not addressed by the current proposed wording:
Remarks: this constructor shall only participate in overload resolution if:
- unique_ptr<U, E>::pointer is implicitly convertible to pointer, and
- U is not an array type, and
- if D is a reference type, E is the same type as D, else E shall be implicitly convertible to D.
Proposed resolution:
Change 20.9.10.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. [Note: These requirements imply that T and U are complete types. — end note]Remarks: If D is a reference type, then E shall be the same type as D, else this constructor shall not participate in overload resolution. unique_ptr<U, E>::pointer shall be implicitly convertible to pointer, else this constructor shall not participate in overload resolution. U shall not be an array type, else this constructor shall not participate in overload resolution. [Note: These requirements imply that T and U are complete types. — end note]
Change 20.9.10.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. [Note: These requirements imply that T and U are complete types. — end note]Remarks: unique_ptr<U, E>::pointer shall be implicitly convertible to pointer, else this operator shall not participate in overload resolution. U shall not be an array type, else this operator shall not participate in overload resolution. [Note: These requirements imply that T and U are complete types. — end note]
Section: 20.10.2.1 [time.traits.is_fp] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2010-02-11
View all issues with Open status.
Discussion:
Related to 953.
20.10.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?
[ 2009-05-10 Howard adds: ]
IntegralLike.
[ Batavia (2009-05): ]
As with issue 953, we recommend this issue be addressed in the context of providing concepts for the entire thread header.
We look forward to proposed wording.
Move to Open.
[ 2009-08-01 Howard adds: ]
I have surveyed all clauses of 20.10.2.2 [time.traits.duration_values], 20.10.2.3 [time.traits.specializations] and 20.10.3 [time.duration]. I can not find any clause which involves the use of a duration::rep type where the requirements on the rep type are not clearly spelled out. These requirements were carefully crafted to allow any arithmetic type, or any user-defined type emulating an arithmetic type.
Indeed, treat_as_floating_point becomes completely superfluous if duration::rep can never be a class type.
There will be some Rep types which will not meet the requirements of every duration operation. This is no different than the fact that vector<T> can easily be used for types T which are not DefaultConstructible, even though some members of vector<T> require T to be DefaultConstructible. This is why the requirements on Rep are specified for each operation individually.
In 20.10.2.1 [time.traits.is_fp] p1:
template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> { };The duration template uses the treat_as_floating_point trait to help determine if a duration object can be converted to another duration with a different tick period. If treat_as_floating_point<Rep>::value is true, then Rep is a floating-point type and implicit conversions are allowed among durations. Otherwise, the implicit convertibility depends on the tick periods of the durations. If Rep is a class type which emulates a floating-point type, the author of Rep can specialize treat_as_floating_point so that duration will treat this Rep as if it were a floating-point type. Otherwise Rep is assumed to be an integral type or a class emulating an integral type.The phrases "a class type which emulates a floating-point type" and "a class emulating an integral type" are clarifying phrases which refer to the summation of all the requirements on the Rep type specified in detail elsewhere (and should not be repeated here).
This specification has been implemented, now multiple times, and the experience has been favorable. The current specification clearly specifies the requirements at each point of use (though I'd be happy to fix any place I may have missed, but none has been pointed out).
I am amenable to improved wording of this paragraph (and any others), but do not have any suggestions for improved wording at this time. I am strongly opposed to changes which would significantly alter the semantics of the specification under 20.10 [time] without firmly grounded and documented rationale, example implementation, testing, and user experience which relates a positive experience.
I recommend NAD unless someone wants to produce some clarifying wording.
[ 2009-10 Santa Cruz: ]
Stefanus to provide wording to turn this into a note.
[ 2010-02-11 Stefanus provided wording. ]
Proposed resolution:
Change 20.10.2.1 [time.traits.is_fp]/1:
1 The duration template uses the treat_as_floating_point trait to help determine if a duration object can be converted to another duration with a different tick period. If treat_as_floating_point<Rep>::value is true, thenRep is a floating-point type andimplicit conversions are allowed among durations. Otherwise, the implicit convertibility depends on the tick periods of the durations.If Rep is a class type which emulates a floating-point type, the author of Rep can specialize treat_as_floating_point so that duration will treat this Rep as if it were a floating-point type. Otherwise Rep is assumed to be an integral type or a class emulating an integral type.[Note: The intention of this trait is to indicate whether a given class behaves like a floating point type, and thus allows division of one value by another with acceptable loss of precision. If treat_as_floating_point<Rep>::value is false, Rep will be treated as if it behaved like an integral type for the purpose of these conversions. — end note]
Section: 20.10.1 [time.clock.req] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2010-02-11
View other active issues in [time.clock.req].
View all other issues in [time.clock.req].
View all issues with Open status.
Discussion:
Related to 951.
20.10.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?
[ 2009-05-10 Howard adds: ]
This wording was aimed directly at the ArithmeticLike concept.
[ Batavia (2009-05): ]
We recommend this issue be addressed in the context of providing concepts for the entire thread header.
May resolve for now by specifying arithmetic types, and in future change to ArithmeticLike. However, Alisdair believes this is not feasible.
Bill disagrees.
We look forward to proposed wording. Move to Open.
[ 2009-08-01 Howard adds: ]
See commented dated 2009-08-01 in 951.
[ 2009-10 Santa Cruz: ]
Stefanus to provide wording to turn this into a note.
[ 2010-02-11 Stephanus provided wording for 951 which addresses this issue as well. ]
Proposed resolution:
Section: 20.10.1 [time.clock.req] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-21
View other active issues in [time.clock.req].
View all other issues in [time.clock.req].
View all issues with Ready status.
Discussion:
Table 55 -- Clock Requirements (in 20.10.1 [time.clock.req])
[ 2009-05-10 Howard adds: ]
"epoch" is purposefully not defined beyond the common English definition. The C standard also chose not to define epoch, though POSIX did. I believe it is a strength of the C standard that epoch is not defined. When it is known that two time_points refer to the same epoch, then a definition of the epoch is not needed to compare the two time_points, or subtract them.
A time_point and a Clock implicitly refer to an (unspecified) epoch. The time_point represents an offset (duration) from an epoch.
The sentence:
Different clocks may share a time_point definition if it is valid to compare their time_points by comparing their respective durations.
is redundant and could be removed. I believe the sentence which follows the above:
C1 and C2 shall refer to the same epoch.
is sufficient. If two clocks share the same epoch, then by definition, comparing their time_points is valid.
This should probably instead be worded:
An instantiation of ratio.
[ Batavia (2009-05): ]
Re (a): It is not clear to us whether "epoch" is a term of art.
Re (b), (c), and (d): We agree with Howard's comments, and would consider adding to (c) a static constexpr requirement.
Move to Open pending proposed wording.
[ 2009-05-25 Daniel adds: ]
In regards to (d) I suggest to say "a specialization of ratio" instead of "An instantiation of ratio". This seems to be the better matching standard core language term for this kind of entity.
[ 2009-05-25 Ganesh adds: ]
Regarding (a), I found this paper on the ISO website using the term "epoch" consistently with the current wording:
which is part of ISO/IEC 18026 "Information technology -- Spatial Reference Model (SRM)".
[ 2009-08-01 Howard: Moved to Reivew as the wording requested in Batavia has been provided. ]
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Change 20.10.1 [time.clock.req] p1:
-1- A clock is a bundle consisting of a native duration, a native time_point, and a function now() to get the current time_point. The origin of the clock's time_point is referred to as the clock's epoch as defined in section 6.3 of ISO/IEC 18026. A clock shall meet the requirements in Table 45.
Remove the sentence from the time_point row of the table "Clock Requirements":
| C1::time_point | chrono::time_point<C1> or chrono::time_point<C2, C1::duration> |
The native time_point type of the clock.
|
Change the row starting with C1::period of the table "Clock Requirements":
| C1::period | a specialization of ratio | The tick period of the clock in seconds. |
Section: 20.10.1 [time.clock.req] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-11-18
View other active issues in [time.clock.req].
View all other issues in [time.clock.req].
View all issues with Open status.
Discussion:
20.10.1 [time.clock.req] uses the word "native" in several places, but doesn't define it. What is a "native duration"?
[ 2009-05-10 Howard adds: ]
The standard uses "native" in several places without defining it (e.g. 2.14.3 [lex.ccon]). It is meant to mean "that which is defined by the facility", or something along those lines. In this case it refers to the nested time_point and duration types of the clock. Better wording is welcome.
[ Batavia (2009-05): ]
Move to Open pending proposed wording from Pete.
[ 2009-10-23 Pete provides wording: ]
[ 2009-11-18 Daniel adds: ]
I see that 30.4.2 [thread.timedmutex.requirements]/3 says:
Precondition: If the tick period of rel_time is not exactly convertible to the native tick period, the duration shall be rounded up to the nearest native tick period.I would prefer to see that adapted as well. Following the same style as the proposed resolution I come up with
Precondition: If the tick period of rel_time is not exactly convertible to thenativetick period of the execution environment, the duration shall be rounded up to the nearestnativetick period of the execution environment.
Proposed resolution:
Remove every occurrence of "native" in 20.10.1 [time.clock.req].
Add the following sentence at the end of 20.10.1 [time.clock.req]/1:
A clock is a bundle consisting of anativeduration, anativetime_point, and a function now() to get the current time_point. A clock shall meet the requirements in Table 55. The duration and time_point types have the natural size and resolution suggested by the architecture of the execution environment.
Section: 20.10.5.1 [time.clock.system] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-21
View all other issues in [time.clock.system].
View all issues with Ready status.
Discussion:
20.10.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. ]
[ Batavia (2009-05): ]
Move to Review pending input from Howard. and other stakeholders.
[ 2009-05-23 Howard adds: ]
I am in favor of the wording provided by Anthony.
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
In 20.10.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.4.1 [thread.mutex.requirements] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-26
View other active issues in [thread.mutex.requirements].
View all other issues in [thread.mutex.requirements].
View all issues with Ready 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. ]
[ 2009-10 Santa Cruz: ]
Move to Ready. Fix the proposed wording with "functions of type Mutex" -> "functions of Mutex type"
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 Mutex type 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.3.2.2 [thread.lock.unique.locking] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-22
View other active issues in [thread.lock.unique.locking].
View all other issues in [thread.lock.unique.locking].
View all issues with Ready 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. ]
[ 2009-07-21 Beman added wording to address 30.2.2 [thread.req.exception] in response to the Frankfurt notes in 859. ]
[ 2009-09-25 Beman: minor update to wording. ]
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Change Exceptions 30.2.2 [thread.req.exception] as indicated:
Some functions described in this Clause are specified to throw exceptions of type
system_error(19.5.5). Such exceptions shall be thrown if any of the Error conditions are detected or a call to an operating system or other underlying API results in an error that prevents the library function fromsatisfying its postconditions or from returning a meaningful valuemeeting its specifications. Failure to allocate storage shall be reported as described in 17.6.4.11 [res.on.exception.handling].
Change thread assignment 30.3.1.5 [thread.thread.member], join(), paragraph 8 as indicated:
Throws:
std::system_errorwhenthe postconditions cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Change thread assignment 30.3.1.5 [thread.thread.member], detach(), paragraph 13 as indicated:
Throws:
std::system_errorwhenthe effects or postconditions cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Change Mutex requirements 30.4.1 [thread.mutex.requirements], paragraph 11, as indicated:
Throws:
std::system_errorwhenthe effects or postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], paragraph 3, as indicated:
Throws:
std::system_errorwhenthe postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], paragraph 8, as indicated:
Throws:
std::system_errorwhenthe postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], paragraph 13, as indicated:
Throws:
std::system_errorwhenthe postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], paragraph 18, as indicated:
Throws:
std::system_errorwhenthe postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], paragraph 22, as indicated:
Throws:
std::system_errorwhenthe postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Change Function call_once 30.4.5.2 [thread.once.callonce], paragraph 4, as indicated
Throws:
std::system_errorwhenthe effects cannot be achievedan exception is required (30.2.2 [thread.req.exception]), or any exception thrown byfunc.
Change Class condition_variable 30.5.1 [thread.condition.condvar], paragraph 12, as indicated:
Throws:
std::system_errorwhenthe effects or postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Change Class condition_variable 30.5.1 [thread.condition.condvar], paragraph 19, as indicated:
Throws:
std::system_errorwhenthe effects or postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Change Class condition_variable_any 30.5.2 [thread.condition.condvarany], paragraph 10, as indicated:
Throws:
std::system_errorwhenthe effects or postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Change Class condition_variable_any 30.5.2 [thread.condition.condvarany], paragraph 16, as indicated:
Throws:
std::system_errorwhenthe returned value, effects, or postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been applied to the working paper, change Change 30.5.1 [thread.condition.condvar] as indicated:
template <class Rep, class Period> bool wait_for(unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& rel_time);...Throws:
std::system_errorwhenthe effects or postcondition cannot be achievedan exception is required ([thread.req.exception]).
Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been applied to the working paper, change Change 30.5.1 [thread.condition.condvar] as indicated:
template <class Rep, class Period, class Predicate> bool wait_for(unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);...Throws:
std::system_errorwhenthe effects or postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been applied to the working paper, change 30.5.2 [thread.condition.condvarany] as indicated:
template <class Lock, class Rep, class Period> bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);...Throws:
std::system_errorwhenthe returned value, effects or postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been applied to the working paper, change 30.5.2 [thread.condition.condvarany] as indicated:
template <class Lock, class Rep, class Period, class Predicate> bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);...Throws:
std::system_errorwhenthe returned value, effects or postcondition cannot be achievedan exception is required (30.2.2 [thread.req.exception]).
Section: 30.3.1.5 [thread.thread.member] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-26
View other active issues in [thread.thread.member].
View all other issues in [thread.thread.member].
View all issues with Ready 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.
[ 2009-10 Santa Cruz: ]
Mark as Ready with proposed resolution from 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.
Section: 30.5.2 [thread.condition.condvarany] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-26
View other active issues in [thread.condition.condvarany].
View all other issues in [thread.condition.condvarany].
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.
[ 2009-10 Santa Cruz: ]
Leave open. Benjamin to provide wording.
Proposed resolution:
Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2010-02-12
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.
[ 2009-08-01 Howard provides wording. ]
The proposed wording is inspired by the POSIX spec which says:
- [EINVAL]
- The value specified by cond or mutex is invalid.
- [EPERM]
- The mutex was not owned by the current thread at the time of the call.
I do not believe [EINVAL] is possible without memory corruption (which we don't specify). [EPERM] is possible if this thread doesn't own the mutex, which is listed as a precondition. "May" is used instead of "Shall" because not all OS's are POSIX.
[ 2009-10 Santa Cruz: ]
Leave open, Detlef to provide improved wording.
[ 2009-10-23 Detlef Provided wording. ]
Detlef's wording put in Proposed resolution. Original wording here:
Change 30.5.1 [thread.condition.condvar] p12, p19 and 30.5.2 [thread.condition.condvarany] p10, p16:
Throws: May throw std::system_error if a precondition is not met.when the effects or postcondition cannot be achieved.
[ 2009-10 Santa Cruz: ]
Leave open, Detlef to provide improved wording.
[ 2009-11-18 Anthony adds: ]
condition_variable::wait takes a unique_lock<mutex>. We know whether or not a unique_lock owns a lock, through use of its owns_lock() member.
I would like to propose the following resolution:
Modify the first sentence of 30.5.1 [thread.condition.condvar] p9:
void wait(unique_lock<mutex>& lock);9 Precondition:lock is locked by the calling threadlock.owns_lock() is true, and either...
Replace 30.5.1 [thread.condition.condvar] p11-13 with:
void wait(unique_lock<mutex>& lock);...
11 Postcondition:
lock is locked by the calling threadlock.owns_lock() is true.12 Throws: std::system_error
when the effects or postcondition cannot be achievedif the implementation detects that the preconditions are not met or the effects cannot be achieved. Any exception thrown by lock.lock() or lock.unlock().13 Error Conditions: The error conditions are implementation defined.
equivalent error condition from lock.lock() or lock.unlock().
Proposed resolution:
Replace 30.5.1 [thread.condition.condvar] p12, p19 and 30.5.2 [thread.condition.condvarany] p10, p16:
Throws: std::system_error when the effects or postcondition cannot be achieved.
Error conditions:
equivalent error condition from lock.lock() or lock.unlock().Throws: It is implementation-defined whether a std::system_error with implementation-defined error condition is thrown if the precondition is not met.
Section: 30.3.1.2 [thread.thread.constr] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-22
View other active issues in [thread.thread.constr].
View all other issues in [thread.thread.constr].
View all issues with Ready 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. ]
[ 2009-09-25 Beman provided proposed wording. ]
The proposed resolution assumes 962 has been accepted and its proposed resolution applied to the working paper.
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Change Mutex requirements 30.4.1 [thread.mutex.requirements], paragraph 4, as indicated:
Error conditions:
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.
Change Class condition_variable 30.5.1 [thread.condition.condvar], default constructor, as indicated:
condition_variable();Effects: Constructs an object of type
condition_variable.Throws:
std::system_errorwhen an exception is required (30.2.2 [thread.req.exception]).Error conditions:
not_enough_memory— if a memory limitation prevents initialization.resource_unavailable_try_again— if some non-memory resource limitation prevents initialization.device_or_resource_busy— if attempting to initialize a previously-initialized but as of yet undestroyedcondition_variable.
Section: 30.4.1 [thread.mutex.requirements] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-22
View other active issues in [thread.mutex.requirements].
View all other issues in [thread.mutex.requirements].
View all issues with Ready 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. ]
[ 2009-10 Santa Cruz: ]
Moved to Ready with minor word-smithing in the example.
Proposed resolution:
Change Exceptions 30.2.2 [thread.req.exception] as indicated:
Some functions described in this Clause are specified to throw exceptions of type
system_error(19.5.5). Such exceptions shall be thrown if any of the Error conditions are detected or a call to an operating system or other underlying API results in an error that prevents the library function from meeting its specifications. [Note: See 17.6.4.11 [res.on.exception.handling] for exceptions thrown to report storage allocation failures. —end note][Example:
Consider a function in this clause that is specified to throw exceptions of type
system_errorand specifies Error conditions that includeoperation_not_permittedfor a thread that does not have the privilege to perform the operation. Assume that, during the execution of this function, anerrnoofEPERMis reported by a POSIX API call used by the implementation. Since POSIX specifies anerrnoofEPERMwhen "the caller does not have the privilege to perform the operation", the implementation mapsEPERMto anerror_conditionofoperation_not_permitted(19.5 [syserr]) and an exception of typesystem_erroris thrown.—end example]
Editorial note: For the sake of exposition, the existing text above is shown with the changes proposed in issues 962 and 967. The proposed additional example is independent of whether or not the 962 and 967 proposed resolutions are accepted.
Change Mutex requirements 30.4.1 [thread.mutex.requirements], paragraph 4, as indicated:
—
operation_not_permitted— if the thread does not have thenecessary permission to change the state of the mutex objectprivilege to perform the operation.
Change Mutex requirements 30.4.1 [thread.mutex.requirements], paragraph 12, as indicated:
—
operation_not_permitted— if the thread does not have thenecessary permission to change the state of the mutexprivilege to perform the operation.
Section: 20.10.3.1 [time.duration.cons] Status: Ready Submitter: Howard Hinnant Opened: 2009-01-21 Last modified: 2009-10-26
View all issues with Ready 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.
[ Batavia (2009-05): ]
We agree with the proposed resolution.
Move to Tentatively Ready.
[ 2009-07 Frankfurt ]
Moved from Tentatively Ready to Open only because the wording needs to be improved for enable_if type constraining, possibly following Robert's formula.
[ 2009-08-01 Howard adds: ]
Addressed by 1177.
[ 2009-10 Santa Cruz: ]
Not completely addressed by 1177. Move to Ready.
Proposed resolution:
Change 20.10.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.8.16 [unord.hash] Status: Ready Submitter: Alisdair Meredith Opened: 2009-02-02 Last modified: 2010-03-08
View other active issues in [unord.hash].
View all other issues in [unord.hash].
View all issues with Ready status.
Discussion:
Addresses UK 208
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.
[ Batavia (2009-05): ]
Howard points out that the client can always supply a custom hash function.
Alisdair replies that the smart pointer classes are highly likely to be frequently used as hash keys.
Bill would prefer to be conservative.
Alisdair mentions that this issue may also be viewed as a subissue or duplicate of issue 1025.
Move to Open, and recommend the issue be deferred until after the next Committee Draft is issued.
[ 2009-05-31 Peter adds: ]
Howard points out that the client can always supply a custom hash function.Not entirely true. The client cannot supply the function that hashes the address of the control block (the equivalent of the old operator<, now proudly carrying the awkward name of 'owner_before'). Only the implementation can do that, not necessarily via specializing hash<>, of course.
This hash function makes sense in certain situations for shared_ptr (when one needs to switch from set/map using ownership ordering to unordered_set/map) and is the only hash function that makes sense for weak_ptr.
[ 2009-07-28 Alisdair provides wording. ]
[ 2009-10 Santa Cruz: ]
Move to Ready.
[ 2009-11-16 Moved from Ready to Open: ]
Pete writes:
As far as I can see, "...suitable for using this type as key in unordered associative containers..." doesn't define any semantics. It's advice to the reader, and if it's present at all it should be in a note. But we have far too much of this sort of editorial commentary as it is.
And in the resolution of 978 it's clearly wrong: it says that if there is no hash specialization available for D::pointer, the implementation may provide hash<unique_ptr<T,D>> if the result is not suitable for use in unordered containers.
Howard writes:
Is this a request to pull 978 from Ready?Barry writes:
I read this as more than a request. The PE says it's wrong, so it can't be Ready.
[ 2010-01-31 Alisdair: related to 1245 and 1182. ]
[ 2010-02-08 Beman updates wording. ]
[ 2010-02-09 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Add the following declarations to the synopsis of <memory> in 20.9 [memory]
// [util.smartptr.hash] hash support template <class T> struct hash; template <class T, class D> struct hash<unique_ptr<T,D>>; template <class T> struct hash<shared_ptr<T>>;
Add a new subclause under 20.9.11 [util.smartptr] called hash support
hash support [util.smartptr.hash]
template <class T, class D> struct hash<unique_ptr<T,D>>;Specialization meeting the requirements of class template hash (20.8.16 [unord.hash]). For an object p of type UP, where UP is a type unique_ptr<T,D>, hash<UP>()(p) shall evaluate to the same value as hash<typename UP::pointer>()(p.get()). The specialization hash<typename UP::pointer> is required to be well-formed.
template <class T> struct hash<shared_ptr<T>>;Specialization meeting the requirements of class template hash (20.8.16 [unord.hash]). For an object p of type shared_ptr<T>, hash<shared_ptr<T>>()(p) shall evaluate to the same value as hash<T*>()(p.get()).
Section: 20.9.10.2 [unique.ptr.single] Status: Ready Submitter: Howard Hinnant Opened: 2009-02-10 Last modified: 2009-10-21
View other active issues in [unique.ptr.single].
View all other issues in [unique.ptr.single].
View all issues with Ready 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.
[ Batavia (2009-05): ]
Seems correct, but complicated enough that we recommend moving to Review.
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Change 20.9.10.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.9.10.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.9.10.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: 23.2.1 [container.requirements.general] Status: Open Submitter: Rani Sharoni Opened: 2009-02-12 Last modified: 2009-10-20
View other active issues in [container.requirements.general].
View all other issues in [container.requirements.general].
View all issues with Open 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.
[ Batavia (2009-05): ]
Bjarne comments (referring to his draft paper): "I believe that my suggestion simply solves that. Thus, we don't need a throwing move."
Move to Open and recommend it be deferred until after the next Committee Draft is issued.
[ 2009-10 Santa Cruz: ]
Should wait to get direction from Dave/Rani (N2983).
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: 20.8.5 [refwrap] Status: Ready Submitter: Howard Hinnant Opened: 2009-02-18 Last modified: 2010-03-08
View all other issues in [refwrap].
View all issues with Ready status.
Discussion:
The synopsis in 20.8.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.
[ Batavia (2009-05): ]
Howard observed that FunctionType, a concept not (yet?) in the Working Paper, is likely the correct constraint to be applied. However, the proposed resolution provides an adequate approximation.
Move to Review.
[ 2009-05-23 Alisdair adds: ]
By constraining to PointeeType we rule out the ability for T to be a reference, and call in reference-collapsing. I'm not sure if this is correct and intended, but would like to be sure the case was considered.
Is dis-allowing reference types and the implied reference collapsing the intended result?
[ 2009-07 Frankfurt ]
Moved from Review to Open only because the wording needs to be tweaked for concepts removal.
[ 2009-10-14 Daniel provided de-conceptified wording. ]
[ 2009-10 post-Santa Cruz: ]
Move to Tentatively Ready.
Proposed resolution:
Change 20.8.5 [refwrap]/1 as indicated:
reference_wrapper<T> is a CopyConstructible and CopyAssignable wrapper around a reference to an object or function of type T.
Section: 17 [library] Status: Open Submitter: David Abrahams Opened: 2009-03-06 Last modified: 2009-05-23
View other active issues in [library].
View all other issues in [library].
View all issues with Open status.
Discussion:
There are lots of places in the standard where we talk about "the move constructor" but where we mean "the move operation," i.e. T( move( x ) ).
We also don't account for whether that operation modifies x or not, and we need to.
[ Batavia (2009-05): ]
Move to Open, pending proposed wording from Dave for further review.
Proposed resolution:
Section: 20.9.9 [specialized.algorithms] Status: Ready Submitter: Peter Dimov Opened: 2009-03-09 Last modified: 2010-03-08
View all other issues in [specialized.algorithms].
View all issues with Ready 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.)
[ Batavia (2009-05): ]
We agree.
Move to Tentatively Ready.
[ 2009-07 Frankfurt ]
Moved from Tentatively Ready to Open only because the wording needs to be tweaked for concepts removal.
[ 2009-10-10 Daniel updates wording to concept-free. ]
[ 2009-10 post-Santa Cruz: ]
Move to Tentatively Ready.
Proposed resolution:
[ The resolution assumes that addressof is reintroduced as described in n2946 ]
In 20.9.9 [specialized.algorithms] change as described:
template <class T> T* addressof(T& r);Returns: The actual address of the object or function referenced by r, even in the presence of an overloaded operator&.
Section: 24.4.4 [iterator.operations] Status: Ready Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-10-22
View all other issues in [iterator.operations].
View all issues with Ready 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.
[ Batavia (2009-05): ]
We agree with the proposed resolution. Move to Tentatively Ready.
[ 2009-07 Frankfurt ]
Moved from Tentatively Ready to Open only because the wording needs to be tweaked for concepts removal.
[ 2009-10-14 Daniel provided de-conceptified wording. ]
[ 2009-10 Santa Cruz: ]
Moved to Ready.
Proposed resolution:
Change header <iterator> synopsis 24.3 [iterator.synopsis] as indicated:
// 24.4.4, iterator operations: ... template <classInputForwardIterator>InputForwardIterator next(InputForwardIterator x, typename std::iterator_traits<InputForwardIterator>::difference_type n = 1);
Change 24.4.4 [iterator.operations] before p.6 as indicated:
template <classInputForwardIterator>InputForwardIterator next(InputForwardIterator x, typename std::iterator_traits<InputForwardIterator>::difference_type n = 1);
Section: 20.9.11.5 [util.smartptr.shared.atomic] Status: Ready Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-10-23
View all issues with Ready 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.
[ 2009-07 post-Frankfurt: ]
Lawrence explained that these signatures match the regular atomics. The regular atomics must not use references because these signatures are shared with C. The decision to pass shared_ptrs by pointer rather than by reference was deliberate and was motivated by the principle of least surprise.
Lawrence to write wording that requires that the pointers not be null.
[ 2009-09-20 Lawrence provided wording: ]
The parameter types for atomic shared pointer access were deliberately chosen to be pointers to match the corresponding parameters of the atomics chapter. Those in turn were deliberately chosen to match C functions, which do not have reference parameters.
We adopt the second suggestion, to require that such pointers not be null.
[ 2009-10 Santa Cruz: ]
Moved to Ready.
Proposed resolution:
In section "shared_ptr atomic access"
20.9.11.5 [util.smartptr.shared.atomic], add to each function the
following clause.
Requires:
pshall not be null.
Section: 30.3.1.5 [thread.thread.member] Status: Ready Submitter: Alberto Ganesh Barbati Opened: 2009-03-12 Last modified: 2010-03-08
View other active issues in [thread.thread.member].
View all other issues in [thread.thread.member].
View all issues with Ready 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. ]
[ Batavia (2009-05): ]
Pete believes there may be some more general language (in frontmatter) that can address this and related issues such as 962.
Move to Open.
[ 2009-11-18 Anthony provides wording. ]
[ 2010-02-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Edit 30.3.1.5 [thread.thread.member] as indicated:
void join();5 Precondition: joinable() is true.
Effects: Blocks until the thread represented by *this has completed.
6 Synchronization: The completion of the thread represented by *this happens before (1.10 [intro.multithread]) join() returns. [Note: Operations on *this are not synchronized. — end note]
7 Postconditions:
If join() throws an exception, the value returned by get_id() is unchanged. Otherwise,The thread represented by *this has completed. get_id() == id().8 ...
Section: 23.2.1 [container.requirements.general] Status: Ready Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2010-03-11
View other active issues in [container.requirements.general].
View all other issues in [container.requirements.general].
View all issues with Ready 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.
[ 2009-07 post-Frankfurt: ]
We agree in principle, but we have a timetable. This group feels that the issue should be closed as NAD unless a proposed resolution is submitted prior to the March 2010 meeting.
[ 2009-10 Santa Cruz: ]
Looked at this and still intend to close as NAD in March 2010 unless there is proposed wording that we like.
[ 2010-02-02 Nicolai M. Josuttis updates proposed wording and adds: ]
I just came across issue #1034 (response to UK 222), which covers the role of container requirements. The reason I found this issue was that I am wondering why array<> is specified to be a sequence container. For me, currently, this follows from Sequence containers 23.2.3 [sequence.reqmts] saying:
The library provides five basic kinds of sequence containers: array, vector, forward_list, list, and deque. while later on in Table 94 "Sequence container requirements" are defined.IMO, you can hardly argue that this is NAD. We MUST say somewhere that either array is not a sequence container or does not provide all operations of a sequence container (even not all requirements of a container in general).
Here is the number of requirements array<> does not meet (AFAIK):
general container requirements:
- a default constructed array is not empty
- swap has no constant complexity
Note also that swap not only has linear complexity it also invalidates iterators (or to be more precise, assigns other values to the elements), which is different from the effect swap has for other containers. For this reason, I must say that i tend to propose to remove swap() for arrays.
sequence container requirements:
- There is no constructor and assignment for a range
- There is no constructor and assignment for n copies of t
- There are no emplace, insert, erase, clear, assign operations
In fact, out of all sequence container requirements array<> only provides the following operations: from sequence requirements (Table 94):
X(il); a = il;and from optional requirements (Table 95):
[], at(), front(), back()This is almost nothing!
Note in addition, that due to the fact that array is an aggregate and not a container with initializer_lists a construction or assignment with an initializer list is valid for all sequence containers but not valid for array:
vector<int> v({1,2,3}); // OK v = {4,5,6}; // OK array<int,3> a({1,2,3}); // Error array<int,3> a = {1,2,3}; // OK a = {4,5,6}; // ErrorBTW, for this reason, I am wondering, why <array> includes <initializer_list>.
IMO, we can't really say that array is a sequence container. array is special. As the solution to this issue seemed to miss some proposed wording where all could live with, let me try to suggest some.
[ 2010-02-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
[ 2010 Pittsburgh: Ok with move to Ready except for "OPEN:" part. ]
Proposed resolution:
In Sequence containers 23.2.3 [sequence.reqmts] modify paragraph 1 as indicated:
1 A sequence container organizes a finite set of objects, all of the same type, into a strictly linear arrangement. The library provides
fivefour basic kinds of sequence containers:array,vector, forward_list, list, and deque. In addition, array is provided as a sequence container that only provides limited sequence operations because it has a fixed number of elements.ItThe library also provides container adaptors that make it easy to construct abstract data types, such as stacks or queues, out of the basic sequence container kinds (or out of other kinds of sequence containers that the user might define).
Modify paragraph 2 as follows (just editorial):
2 The
five basicsequence containers offer the programmer different complexity trade-offs and should be used accordingly. vector or array is the type of sequence container that should be used by default. list or forward_list should be used when there are frequent insertions and deletions from the middle of the sequence. deque is the data structure of choice when most insertions and deletions take place at the beginning or at the end of the sequence.
In Class template array 23.3.1 [array] modify paragraph 3 as indicated:
3
Unless otherwise specified, all array operations are as described in 23.2.An array satisfies all of the requirements of a container and of a reversible container (given in two tables in 23.2 [container.requirements]) except that a default constructed array is not empty, swap does not have constant complexity, and swap may throw exceptions. An array satisfies some of the requirements of a sequence container (given in 23.2.3 [sequence.reqmts]). Descriptions are provided here only for operations on array that are not describedin that Clausein one of these tables or for operations where there is additional semantic information.
In array specialized algorithms 23.3.1.2 [array.special] add to the specification of swap():
template <class T, size_t N> void swap(array<T,N>& x, array<T,N>& y);1 Effects: ...
Complexity: Linear in N.
Section: 20.8.11.1.1 [func.bind.isbind] Status: Ready Submitter: Alisdair Meredith Opened: 2009-03-19 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
Class template is_bind_expression 20.8.11.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. ]
[ Batavia (2009-05): ]
We recommend this be deferred until after the next Committee Draft is issued.
Move to Open.
[ 2009-05-31 Peter adds: ]
I am opposed to the proposed resolution and to the premise of the issue in general. The traits's default definitions should NOT derive from integral_constant, because this is harmful, as it misleads people into thinking that is_bind_expression<E> always derives from integral_constant, whereas it may not.
is_bind_expression and is_placeholder allow user specializations, and in fact, this is their primary purpose. Such user specializations may not derive from integral_constant, and the places where is_bind_expression and is_placeholder are used intentionally do not require such derivation.
The long-term approach here is to switch to BindExpression<E> and Placeholder<P> explicit concepts, of course, but until that happens, I say leave them alone.
[ 2009-10 post-Santa Cruz: ]
Move to Tentatively Ready. We are comfortable with requiring user specializations to derive from integral_constant.
Proposed resolution:
In 20.8.11.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.8.11.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.8.11.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.8.11.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.8.10 [negators] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-20 Last modified: 2010-01-31
View all issues with Open 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 ?]
[ Batavia (2009-05): ]
There is concern that complicating the solution to preserve the ABI seems unnecessary, since we're not in general preserving the ABI.
We would prefer a separate paper consolidating all Clause 20 issues that are for the purpose of providing constrained versions of the existing facilities.
Move to Open.
[ 2009-10 post-Santa Cruz: ]
Leave open pending the potential move constructor paper. Note that we consider the "constraining" part NAD Concepts.
[ 2010-01-31 Alisdair removes the current proposed wording from the proposed wording section because it is based on concepts. That wording is proposed here: ]
Add new concepts where appropriate::
auto concept AdaptableUnaryFunction< typename X > { typename X::result_type; typename X::argument_type; } auto concept AdaptableBinaryFunction< typename X > { typename X::result_type; typename X::first_argument_type; typename X::second_argument_type; }Revise as follows:
Base 20.8.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.8.10 [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).
Proposed resolution:
RandomAccessIterator's operator- has nonsensical effects clauseSection: 24.2.5 [random.access.iterators] Status: Ready Submitter: Doug Gregor Opened: 2009-03-20 Last modified: 2010-03-09
View all other issues in [random.access.iterators].
View all issues with Ready 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
[ 2009-09-18 Alisdair adds: ]
For random access iterators, the definitions of (b-a) and (a<b) are circular:
From table Table 104 -- Random access iterator requirements:
b - a :==> (a < b) ? distance(a,b) : -distance(b,a) a < b :==> b - a > 0
[ 2009-10 Santa Cruz: ]
Moved to Ready.
[ 2010-02-13 Alisdair opens. ]
Looking again at LWG #1079, the wording in the issue no longer exists, and appears to be entirely an artefact of the concepts wording.
This issue is currently on our Ready list (not even Tentative!) but I think it has to be pulled as there is no way to apply the resolution.
Looking at the current paper, I think this issue is now "NAD, solved by the removal of concepts". Unfortunately it is too late to poll again, so we will have to perform that review in Pittsburgh.
[ 2010-02-13 Daniel updates the wording to address the circularity problem. ]
[ The previous wording is preserved here: ]
Modify 24.2.5 [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
[ 2010 Pittsburgh: ]
Moved to Ready for Pittsburgh.
Proposed resolution:
Modify Table 105 in 24.2.5 [random.access.iterators]:
Table 105 — Random access iterator requirements (in addition to bidirectional iterator) Expression Return type Operational semantics Assertion/note
pre-/post-conditionb - a Distance distance(a,b)return npre: there exists a value n of Distance such that a + n == b. b == a + (b - a).
Section: 30 [thread] Status: Ready Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2010-03-09
View all other issues in [thread].
View all issues with Ready 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. ]
[ 2009-08-01 Howard provided wording: ]
The definition of "Throws: Nothing." that I added is probably going to be controversial, but I beg you to consider it seriously.
In C++ there are three "flow control" options for a function:
The above list can be abbreviated with:
- It can return, either with a value, or with void.
- It can call a function which never returns, such as std::exit or std::terminate.
- It can throw an exception.
- Returns.
- Ends program.
- Throws exception.
In general a function can have the behavior of any of these 3, or any combination of any of these three, depending upon run time data.
- R
- E
- T
- RE
- RT
- ET
- RET
A function with no throw spec, and no documentation, is in general a RET function. It may return, it may end the program, or it may throw. When we specify a function with an empty throw spec:
void f() throw();We are saying that f() is an RE function: It may return or end the program, but it will not throw.
I posit that there are very few places in the library half of the standard where we intend for functions to be able to end the program (call terminate). And none of those places where we do say terminate could be called, do we currently say "Throws: Nothing.".
I believe that if we define "Throws: Nothing." to mean R, we will both clarify many, many places in the standard, and give us a good rationale for choosing between "Throws: Nothing." (R) and throw() (RE) in the future. Indeed, this may give us motivation to change several throw()s to "Throws: Nothing.".
I did not add the following changes as JP 76 requested as I believe we want to allow these functions to throw:
Add a paragraph under 30.4.3.1 [thread.lock.guard] p4:
explicit lock_guard(mutex_type& m);Throws: Nothing.
Add a paragraph under 30.4.3.2.1 [thread.lock.unique.cons] p6:
explicit unique_lock(mutex_type& m);Throws: Nothing.
Add a paragraph under 30.5.2 [thread.condition.condvarany] p19, p21 and p25:
template <class Lock, class Rep, class Period> bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);Throws: Nothing.
template <class Lock, class Duration, class Predicate> bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& rel_time, Predicate pred);Throws: Nothing.
template <class Lock, class Rep, class Period, class Predicate> bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);Throws: Nothing.
[ 2009-10 Santa Cruz: ]
Defer pending further developments with exception restriction annotations.
[ 2010-02-11 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
[ 2010-02-24 Pete moved to Open: ]
A "Throws: Nothing" specification is not the place to say that a function is not allowed to call exit(). While I agree with the thrust of the proposed resolution, "doesn't throw exceptions" is a subset of "always returns normally". If it's important to say that most library functions don't call exit(), say so.
[ 2010 Pittsburgh: ]
Move to Ready except for the added paragraph to 17.5.1.4 [structure.specifications].
Proposed resolution:
Add a paragraph under 30.3.1.6 [thread.thread.static] p1:
unsigned hardware_concurrency();-1- Returns: ...
Throws: Nothing.
Add a paragraph under 30.5.1 [thread.condition.condvar] p7 and p8:
[Informational, not to be incluced in the WP: The POSIX spec allows only:
- [EINVAL]
- The value cond does not refer to an initialized condition variable. — end informational]
void notify_one();-7- Effects: ...
Throws: Nothing.
void notify_all();-8- Effects: ...
Throws: Nothing.
Add a paragraph under 30.5.2 [thread.condition.condvarany] p6 and p7:
void notify_one();-6- Effects: ...
Throws: Nothing.
void notify_all();-7- Effects: ...
Throws: Nothing.
Section: 25.3.12 [alg.random.shuffle] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-22 Last modified: 2009-10-26
View all other issues in [alg.random.shuffle].
View all issues with Open status.
Discussion:
There are a couple of issues with the declaration of the random_shuffle algorithm accepting a random number engine.
[ 2009-05-02 Daniel adds: ]
this issue completes adding necessary requirement to the third new random_shuffle overload. The current suggestion is:
template<RandomAccessIterator Iter, UniformRandomNumberGenerator Rand> requires ShuffleIterator<Iter> void random_shuffle(Iter first, Iter last, Rand&& g);IMO this is still insufficient and I suggest to add the requirement
Convertible<Rand::result_type, Iter::difference_type>to the list (as the two other overloads already have).
Rationale:
Its true that this third overload is somewhat different from the remaining two. Nevertheless we know from UniformRandomNumberGenerator, that it's result_type is an integral type and that it satisfies UnsignedIntegralLike<result_type>.
To realize it's designated task, the algorithm has to invoke the Callable aspect of g and needs to perform some algebra involving it's min()/max() limits to compute another index value that at this point is converted into Iter::difference_type. This is so, because 24.2.5 [random.access.iterators] uses this type as argument of it's algebraic operators. Alternatively consider the equivalent iterator algorithms in 24.4.4 [iterator.operations] with the same result.
This argument leads us to the conclusion that we also need Convertible<Rand::result_type, Iter::difference_type> here.
[ Batavia (2009-05): ]
Alisdair notes that point (ii) has already been addressed.
We agree with the proposed resolution to point (i) with Daniel's added requirement.
Move to Review.
[ 2009-06-05 Daniel updated proposed wording as recommended in Batavia. ]
[ 2009-07-28 Alisdair adds: ]
Revert to Open, with a note there is consensus on direction but the wording needs updating to reflect removal of concepts.
[ 2009-10 post-Santa Cruz: ]
Leave Open, Walter to work on it.
Proposed resolution:
Change in [algorithms.syn] and 25.3.12 [alg.random.shuffle]:
concept UniformRandomNumberGenerator<typename Rand> { }template<RandomAccessIterator Iter, UniformRandomNumberGenerator Rand> requires ShuffleIterator<Iter> && Convertible<Rand::result_type, Iter::difference_type> void random_shuffle(Iter first, Iter last, Rand&& g);
Section: 27.5.4.3 [iostate.flags] Status: Ready Submitter: P.J. Plauger Opened: 2009-03-24 Last modified: 2009-10-20
View all other issues in [iostate.flags].
View all issues with Ready 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;
[ Batavia (2009-05): ]
We agree with the proposed resolution. Move to Review.
[ 2009 Santa Cruz: ]
Moved to Ready.
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: Ready Submitter: Beman Dawes Opened: 2009-03-27 Last modified: 2009-10-21
View all issues with Ready 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.8 [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.
[ Batavia (2009-05): ]
The proposed wording seems to need a bit of tweaking ("really bad idea" isn't quite up to standardese). We would like feedback as to whether the original Note's removal was intentional.
Change the phrase "is a really bad idea" to "risks undefined behavior" and move to Review status.
[ 2009-10 Santa Cruz: ]
Note: Change to read: "Modifying...", Delete 'thus', move to Ready
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: Modifying an object of a standard library type shared between threads risks undefined behavior unless objects of the type are explicitly specified as being sharable without data races or the user supplies a locking mechanism. --end note]
Section: 18.2 [support.types] Status: Ready Submitter: Jens Maurer Opened: 2009-04-03 Last modified: 2010-03-12
View other active issues in [support.types].
View all other issues in [support.types].
View all issues with Ready 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.
[ Batavia (2009-05): ]
We agree with the issue, and believe it is properly a library issue.
We prefer that the macro be conditionally defined as part of the <thread> header.
Move to Review.
[ 2009-10 Santa Cruz: ]
Move to Ready.
[ 2010-02-25 Pete moved to Open: ]
The proposed resolution adds a feature-test macro named __STDCPP_THREADS, described after the following new text:
The standard library defines the following macros; no explicit prior inclusion of any header file is necessary.The correct term here is "header", not "header file". But that's minor. The real problem is that library entities are always defined in headers. If __STDCPP_THREADS is defined without including any header it's part of the language and belongs with the other predefined macros in the Preprocessor clause.
Oddly enough, the comments from Batavia say "We prefer that the macro be conditionally defined as part of the <thread> header." There's no mention of a decision to change this.
[ 2010-02-26 Ganesh updates wording. ]
[ 2010 Pittsburgh: Adopt Ganesh's wording and move to Review. ]
[ 2010-03-08 Pete adds: ]
Most macros we have begin and end with with double underbars, this one only begins with double underbars.
[ 2010 Pittsburgh: Ganesh's wording adopted and moved to Ready for Pittsburgh. ]
Proposed resolution:
Change 17.6.1.3 [compliance]/3:
3 The supplied version of the header <cstdlib> shall declare at least the functions abort(), atexit(), and exit() (18.5). The supplied version of the header <thread> either shall meet the same requirements as for a hosted implementation or including it shall have no effect. The other headers listed in this table shall meet the same requirements as for a hosted implementation.
Add the following line to table 15:
Table 15 — C++ headers for freestanding implementations Subclause Header(s) ... 30.3 [thread.threads] Threads <thread>
Add to the <thread> synopsis in 30.3 [thread.threads]/1 the line:
namespace std {
#define __STDCPP_THREADS __cplusplus
class thread;
...
Section: 20.9.12 [util.dynamic.safety] Status: Ready Submitter: Jens Maurer Opened: 2009-04-03 Last modified: 2009-10-23
View all other issues in [util.dynamic.safety].
View all issues with Ready status.
Discussion:
Addresses DE 18
In 20.9.12 [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.
[ Batavia (2009-05): ]
We recommend if this issue is to be moved, the issue be moved concurrently with the cited Core issue.
We agree with the intent of the proposed resolution. We would like input from garbage collection specialists.
Move to Open.
[ 2009-10 Santa Cruz: ]
The core issue is 853 and is in Ready status.
Proposed resolution:
In 20.9.12 [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: 20.9.10.2.1 [unique.ptr.single.ctor] Status: Ready Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2009-10-21
View other active issues in [unique.ptr.single.ctor].
View all other issues in [unique.ptr.single.ctor].
View all issues with Ready 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.
[ Batavia (2009-05): ]
Pete believes it not a good idea to separate parts of a class's definition. Therefore, if we do this, it should be part of unique-ptr's specification.
Alisdair believes the lvalue overload may be not necessary.
Marc believes it is more than just sugar, as it does ease the transition to unique-ptr.
We agree with the resolution as presented. Move to Tentatively Ready.
[ 2009-07 Frankfurt ]
Moved from Tentatively Ready to Open only because the wording needs to be tweaked for concepts removal.
[ 2009-08-01 Howard deconceptifies wording: ]
I also moved the change from D.9 [depr.auto.ptr] to 20.9.10.2 [unique.ptr.single] per the Editor's request in Batavia (as long as I was making changes anyway). Set back to Review.
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Add to 20.9.10.2 [unique.ptr.single]:
template <class T, class D>
class unique_ptr
{
public:
template <class U>
unique_ptr(auto_ptr<U>& u);
template <class U>
unique_ptr(auto_ptr<U>&& u);
};
Add to 20.9.10.2.1 [unique.ptr.single.ctor]:
template <class U> unique_ptr(auto_ptr<U>& u); template <class U> 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.
Remarks: U* shall be implicitly convertible to T* and D shall be the same type as default_delete<T>, else these constructors shall not participate in overload resolution.
Section: 27.5.4.2 [basic.ios.members] Status: Ready Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2009-10-20
View other active issues in [basic.ios.members].
View all other issues in [basic.ios.members].
View all issues with Ready 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.
[ Batavia (2009-05): ]
Tom prefers, on general principles, to provide both overloads. Alisdair agrees.
Howard points out that there is no backward compatibility issue as this is new to C++0X.
We agree that both overloads should be provided, and Howard will provide the additional wording. Move to Open.
[ 2009-05-23 Howard adds: ]
Added overload, moved to Review.
[ 2009 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Add a signature to the existing prototype in the synopsis of 27.5.4 [ios] and in 27.5.4.2 [basic.ios.members]:
void move(basic_ios& rhs); void move(basic_ios&& rhs);
Section: 30.2.2 [thread.req.exception] Status: Ready Submitter: Christopher Kohlhoff Opened: 2009-04-25 Last modified: 2010-03-08
View all issues with Ready 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.
[ Batavia (2009-05): ]
Move to Open, and recommend the issue be deferred until after the next Committee Draft is issued.
[ 2009-10 post-Santa Cruz: ]
Move to Tentatively Ready.
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.2.4 [alg.foreach] Status: Ready Submitter: Alisdair Meredith Opened: 2009-04-29 Last modified: 2010-03-08
View all other issues in [alg.foreach].
View all issues with Ready status.
Discussion:
Quoting working paper for reference (25.2.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. ]
[ Batavia (2009-05): ]
Pete suggests we may want to look at this in a broader context involving other algorithms. We should also consider the implications of parallelism.
Move to Open, and recommend the issue be deferred until after the next Committee Draft is issued.
[ 2009-10-14 Daniel de-conceptified the proposed resolution. ]
The note in 25.1 [algorithms.general]/9 already says the right thing:
Unless otherwise specified, algorithms that take function objects as arguments are permitted to copy those function objects freely.So we only need to ensure that the wording for for_each is sufficiently clear, which is the intend of the following rewording.
[ 2009-10-15 Daniel proposes: ]
Add a new Requires clause just after the prototype declaration (25.2.4 [alg.foreach]):
Requires: Function shall be MoveConstructible ( [moveconstructible]), CopyConstructible is not required.
Change 25.2.4 [alg.foreach]/2 as indicated:
Returns: std::move(f).
[ 2009-10 post-Santa Cruz: ]
Move to Tentatively Ready, using Daniel's wording without the portion saying "CopyConstructible is not required".
[ 2009-10-27 Daniel adds: ]
I see that during the Santa Cruz meeting the originally proposed addition
, CopyConstructible is not required.was removed. I don't think that this removal was a good idea. The combination of 25.1 [algorithms.general]/9
[Note: Unless otherwise specified, algorithms that take function objects as arguments are permitted to copy those function objects freely.[..]with the fact that CopyConstructible is a refinement MoveConstructible makes it necessary that such an explicit statement is given. Even the existence of the usage of std::move in the Returns clause doesn't help much, because this would still be well-formed for a CopyConstructible without move constructor. Let me add that the originally proposed addition reflects current practice in the standard, e.g. 25.3.9 [alg.unique]/5 usages a similar terminology.
For similar wording need in case for auto_ptr see 973.
[ Howard: Moved from Tentatively Ready to Open. ]
[ 2009-11-20 Howard restores "not CopyConstructible" to the spec. ]
[ 2009-11-22 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Add a new Requires clause just after the prototype declaration (25.2.4 [alg.foreach]):
Requires: Function shall meet the requirements of MoveConstructible ( [moveconstructible]). Function need not meet the requirements of CopyConstructible ( [copyconstructible]).
Change 25.2.4 [alg.foreach]/2 as indicated:
Returns: std::move(f).
Section: 20.5 [template.bitset] Status: Ready Submitter: Alisdair Meredith Opened: 2009-05-09 Last modified: 2010-03-08
View other active issues in [template.bitset].
View all other issues in [template.bitset].
View all issues with Ready status.
Discussion:
In 853 our resolution is changing the signature by adding two defaulting arguments to 3 calls. In principle, this means that ABI breakage is not an issue, while API is preserved.
With that observation, it would be very nice to use the new ability to supply default template parameters to function templates to collapse all 3 signatures into 1. In that spirit, this issue offers an alternative resolution than that of 853.
[ Batavia (2009-05): ]
Move to Open, and look at the issue again after 853 has been accepted. We further recommend this be deferred until after the next Committee Draft.
[ 2009-10 post-Santa Cruz: ]
Move to Tentatively Ready.
Proposed resolution:
In 20.5 [template.bitset]/1 (class bitset) ammend:
template <class charT = char,
class traits = char_traits<charT>,
class Allocator = allocator<charT>>
basic_string<charT, traits, Allocator>
to_string(charT zero = charT('0'), charT one = charT('1')) const;
template <class charT, class traits>
basic_string<charT, traits, allocator<charT> > to_string() const;
template <class charT>
basic_string<charT, char_traits<charT>, allocator<charT> > to_string() const;
basic_string<char, char_traits<char>, allocator<char> > to_string() const;
In 20.5.2 [bitset.members] prior to p35 ammend:
template <class charT = char,
class traits = char_traits<charT>,
class Allocator = allocator<charT>>
basic_string<charT, traits, Allocator>
to_string(charT zero = charT('0'), charT one = charT('1')) const;
Section: 20.7 [meta] Status: Ready Submitter: Daniel Krügler Opened: 2009-05-12 Last modified: 2010-03-08
View all other issues in [meta].
View all issues with Ready status.
Discussion:
The current wording in 20.7.1 [meta.rqmts] is still unclear concerning it's requirements on the type traits classes regarding ambiguities. Specifically it's unclear
[ Batavia (2009-05): ]
Alisdair would prefer to factor some of the repeated text, but modulo a corner case or two, he believes the proposed wording is otherwise substantially correct.
Move to Open.
[ 2009-10 post-Santa Cruz: ]
Move to Tentatively Ready.
Proposed resolution:
[ The usage of the notion of a BaseCharacteristic below might be useful in other places - e.g. to define the base class relation in 20.8.5 [refwrap], 20.8.14 [func.memfn], or 20.8.15.2 [func.wrap.func]. In this case it's definition should probably be moved to Clause 17 ]
Change 20.7.1 [meta.rqmts]/1 as indicated:
[..] It shall be DefaultConstructible, CopyConstructible, and publicly and unambiguously derived, directly or indirectly, from its BaseCharacteristic, which is a specialization of the template integral_constant (20.6.3), with the arguments to the template integral_constant determined by the requirements for the particular property being described. The member names of the BaseCharacteristic shall be unhidden and unambiguously available in the UnaryTypeTrait.
Change 20.7.1 [meta.rqmts]/2 as indicated:
[..] It shall be DefaultConstructible, CopyConstructible, and publicly and unambiguously derived, directly or indirectly, froman instanceits BaseCharacteristic, which is a specialization of the template integral_constant (20.6.3), with the arguments to the template integral_constant determined by the requirements for the particular relationship being described. The member names of the BaseCharacteristic shall be unhidden and unambiguously available in the BinaryTypeTrait.
Change 20.7.4 [meta.unary]/2 as indicated:
Each of these templates shall be a UnaryTypeTrait (20.6.1),publicly derived directly or indirectly from true_type if the corresponding condition is true, otherwise from false_typewhere its BaseCharacteristic shall be true_type if the corresponding condition is true, otherwise false_type.
Change 20.7.5 [meta.rel]/2 as indicated:
Each of these templates shall be a BinaryTypeTrait (20.6.1),publicly derived directly or indirectly from true_type if the corresponding condition is true, otherwise from false_typewhere its BaseCharacteristic shall be true_type if the corresponding condition is true, otherwise false_type.
Section: 20.4.2.5 [tuple.helper] Status: Open Submitter: Alisdair Meredith Opened: 2009-05-23 Last modified: 2009-10-26
View other active issues in [tuple.helper].
View all other issues in [tuple.helper].
View all issues with Open status.
Discussion:
The APIs tuple_size and tuple_element do not support cv-qualified tuples, pairs or arrays.
The most generic solution would be to supply partial specializations once for each cv-type in the tuple header. However, requiring this header for cv-qualified pairs/arrays seems unhelpful. The BSI editorial suggestion (UK-198/US-69, N2533) to merge tuple into <utility> would help with pair, but not array. That might be resolved by making a dependency between the <array> header and <utility>, or simply recognising the dependency be fulfilled in a Remark.
[ 2009-05-24 Daniel adds: ]
All tuple_size templates with a base class need to derive publicly, e.g.
template <IdentityOf T> class tuple_size< const T > : public tuple_size<T> {};The same applies to the tuple_element class hierarchies.
What is actually meant with the comment
this solution relies on 'metafunction forwarding' to inherit the nested typename type?
I ask, because all base classes are currently unconstrained and their instantiation is invalid in the constrained context of the tuple_element partial template specializations.
[ 2009-05-24 Alisdair adds: ]
I think a better solution might be to ask Pete editorially to change all declarations of tupling APIs to use the struct specifier instead of class.
"metafunction forwarding" refers to the MPL metafunction protocol, where a metafunction result is declared as a nested typedef with the name "type", allowing metafunctions to be chained by means of inheritance. It is a neater syntax than repeatedly declaring a typedef, and inheritance syntax is slightly nicer when it comes to additional typename keywords.
The constrained template with an unconstrained base is a good observation though.
[ 2009-10 post-Santa Cruz: ]
Move to Open, Alisdair to provide wording. Once wording is provided, Howard will move to Review.
Proposed resolution:
Add to 20.4.1 [tuple.general] p2 (Header <tuple> synopsis)
// 20.5.2.3, tuple helper classes:
template <IdentityOf T> class tuple_size; // undefined
template <IdentityOf T> class tuple_size< const T > : tuple_size<T> {};
template <IdentityOf T> class tuple_size< volatile T > : tuple_size<T> {};
template <IdentityOf T> class tuple_size< const volatile T > : tuple_size<T> {};
template <VariableType... Types> class tuple_size<tuple<Types...> >;
template <size_t I, IdentityOf T> class tuple_element; // undefined
template <size_t I, IdentityOf T> class tuple_element<I, const T>;
template <size_t I, IdentityOf T> class tuple_element<I, volatile T>;
template <size_t I, IdentityOf T> class tuple_element<I, const volatile T>;
template <size_t I, VariableType... Types>
requires True<(I < sizeof...(Types))> class tuple_element<I, tuple<Types...> >;
Add to 20.4.2.5 [tuple.helper]
[ (note that this solution relies on 'metafunction forwarding' to inherit the nested typename type) ]
template <class... Types>
class tuple_size<tuple<Types...> >
: public integral_constant<size_t, sizeof...(Types)> { };
template <size_t I, class... Types>
requires True<(I < sizeof...(Types))>
class tuple_element<I, tuple<Types...> > {
public:
typedef TI type;
};
template <size_t I, IdentityOf T>
class tuple_element<I, const T> : add_const<tuple_element<I,T>> {};
template <size_t I, IdentityOf T>
class tuple_element<I, volatile T> : add_volatile<tuple_element<I,T>> {};
template <size_t I, IdentityOf T>
class tuple_element<I, const volatile T> : add_cv<tuple_element<I,T>> {};
Section: 20.4.2.5 [tuple.helper] Status: Open Submitter: Alisdair Meredith Opened: 2009-05-23 Last modified: 2009-10-26
View other active issues in [tuple.helper].
View all other issues in [tuple.helper].
View all issues with Open status.
Discussion:
The tuple query APIs tuple_size and tuple_element do not support references-to-tuples. This can be annoying when a template deduced a parameter type to be a reference, which must be explicitly stripped with remove_reference before calling these APIs.
I am not proposing a resolution at this point, as there is a combinatorial explosion with lvalue/rvalue references and cv-qualification (see previous issue) that suggests some higher refactoring is in order. This might be something to kick back over to Core/Evolution.
Note that we have the same problem in numeric_limits.
[ 2009-10 post-Santa Cruz: ]
Move to Open. Alisdair to provide wording.
Proposed resolution:
Section: 27.5.2.1.6 [ios::Init] Status: Ready Submitter: James Kanze Opened: 2009-05-14 Last modified: 2009-10-20
View all other issues in [ios::Init].
View all issues with Ready status.
Discussion:
As currently formulated, the standard doesn't require that there is ever a flush of cout, etc. (This implies, for example, that the classical hello, world program may have no output.) In the current draft (N2798), there is a requirement that the objects be constructed before main, and before the dynamic initialization of any non-local objects defined after the inclusion of <iostream> in the same translation unit. The only requirement that I can find concerning flushing, however, is in 27.5.2.1.6 [ios::Init], where the destructor of the last std::ios_base::Init object flushes. But there is, as far as I can see, no guarantee that such an object ever exists.
Also, the wording in [iostreams.objects] says that:
The objects are constructed and the associations are established at some time prior to or during the first time an object of class ios_base::Init is constructed, and in any case before the body of main begins execution.
In 27.5.2.1.6 [ios::Init], however, as an effect of the constructor, it says that
If init_cnt is zero, the function stores the value one in init_cnt, then constructs and initializes the objects cin, cout, cerr, clog wcin, wcout, wcerr, and wclog"
which seems to forbid earlier construction.
(Note that with these changes, the exposition only "static int init_cnt" in ios_base::Init can be dropped.)
Of course, a determined programmer can still inhibit the flush with things like:
new std::ios_base::Init ; // never deleted
or (in a function):
std::ios_base::Init ensureConstruction ; // ... exit( EXIT_SUCCESS ) ;
Perhaps some words somewhere to the effect that all std::ios_base::Init objects should have static lifetime would be in order.
[ 2009 Santa Cruz: ]
Moved to Ready. Some editorial changes are expected (in addition to the proposed wording) to remove init_cnt from Init.
Proposed resolution:
Change 27.4 [iostream.objects]/2:
-2- The objects are constructed and the associations are established at some time prior to or during the first time an object of class ios_base::Init is constructed, and in any case before the body of main begins execution.292 The objects are not destroyed during program execution.293If a translation unit includes <iostream> or explicitly constructs an ios_base::Init object, these stream objects shall be constructed before dynamic initialization of non-local objects defined later in that translation unit.The results of including <iostream> in a translation unit shall be as if <iostream> defined an instance of ios_base::Init with static lifetime. Similarly, the entire program shall behave as if there were at least one instance of ios_base::Init with static lifetime.
Change 27.5.2.1.6 [ios::Init]/3:
Init();-3- Effects: Constructs an object of class Init.If init_cnt is zero, the function stores the value one in init_cnt, then constructs and initializes the objects cin, cout, cerr, clog (27.4.1), wcin, wcout, wcerr, and wclog (27.4.2). In any case, the function then adds one to the value stored in init_cnt.Constructs and initializes the objects cin, cout, cerr, clog, wcin, wcout, wcerr and wclog if they have not already been constructed and initialized.
Change 27.5.2.1.6 [ios::Init]/4:
~Init();-4- Effects: Destroys an object of class Init.The function subtracts one from the value stored in init_cnt and, if the resulting stored value is one,If there are no other instances of the class still in existance, calls cout.flush(), cerr.flush(), clog.flush(), wcout.flush(), wcerr.flush(), wclog.flush().
Section: 24.6.3.5 [istreambuf.iterator::equal] Status: Ready Submitter: Alisdair Meredith Opened: 2009-05-28 Last modified: 2010-03-08
View all other issues in [istreambuf.iterator::equal].
View all issues with Ready status.
Discussion:
The equal member function of istreambuf_iterator is declared const, but takes its argument by non-const reference.
This is not compatible with the operator== free function overload, which is defined in terms of calling equal yet takes both arguments by reference to const.
[ The proposed wording is consistent with 110 with status TC1. ]
[ 2009-11-02 Howard adds: ]
Set to Tentatively Ready after 5 positive votes on c++std-lib.
Proposed resolution:
Ammend in both:
24.6.3 [istreambuf.iterator]
24.6.3.5 [istreambuf.iterator::equal]
bool equal(const istreambuf_iterator& b) const;
Section: 18.8.5 [propagation] Status: Ready Submitter: Peter Dimov Opened: 2009-05-13 Last modified: 2010-03-08
View other active issues in [propagation].
View all other issues in [propagation].
View all issues with Ready status.
Discussion:
The naming of std::copy_exception misleads almost everyone (experts included!) to think that it is the function that copies an exception_ptr:
exception_ptr p1 = current_exception(); exception_ptr p2 = copy_exception( p1 );
But this is not at all what it does. The above actually creates an exception_ptr p2 that contains a copy of p1, not of the exception to which p1 refers!
This is, of course, all my fault; in my defence, I used copy_exception because I was unable to think of a better name.
But I believe that, based on what we've seen so far, any other name would be better.
Therefore, I propose copy_exception to be renamed to create_exception:
template<class E> exception_ptr create_exception(E e);
with the following explanatory paragraph after it:
Creates an exception_ptr that refers to a copy of e.
[ 2009-05-13 Daniel adds: ]
What about
make_exception_ptrin similarity to make_pair and make_tuple, make_error_code and make_error_condition, or make_shared? Or, if a stronger symmetry to current_exception is preferred:
make_exceptionWe have not a single create_* function in the library, it was always make_* used.
[ 2009-05-13 Peter adds: ]
make_exception_ptr works for me.
[ 2009-06-02 Thomas J. Gritzan adds: ]
To avoid surprises and unwanted recursion, how about making a call to std::make_exception_ptr with an exception_ptr illegal?
It might work like this:
template<class E> exception_ptr make_exception_ptr(E e); template<> exception_ptr make_exception_ptr<exception_ptr>(exception_ptr e) = delete;
[ 2009 Santa Cruz: ]
Move to Review for the time being. The subgroup thinks this is a good idea, but doesn't want to break compatibility unnecessarily if someone is already shipping this. Let's talk to Benjamin and PJP tomorrow to make sure neither objects.
[ 2009-11-16 Jonathan Wakely adds: ]
GCC 4.4 shipped with copy_exception but we could certainly keep that symbol in the library (but not the headers) so it can still be found by any apps foolishly relying on the experimental C++0x mode being ABI stable.
[ 2009-11-16 Peter adopts wording supplied by Daniel. ]
[ 2009-11-16 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change 18.8 [support.exception]/1, header <exception> synopsis as indicated:
exception_ptr current_exception(); void rethrow_exception [[noreturn]] (exception_ptr p); template<class E> exception_ptrcopy_exceptionmake_exception_ptr(E e);
Change 18.8.5 [propagation]:
template<class E> exception_ptrcopy_exceptionmake_exception_ptr(E e);-11- Effects: Creates an exception_ptr that refers to a copy of e, as if
try { throw e; } catch(...) { return current_exception(); }...
Change 30.6.5 [futures.promise]/7 as indicated:
Effects: if the associated state of *this is not ready, stores an exception object of type future_error with an error code of broken_promise as if by this->set_exception(copy_exceptionmake_exception_ptr( future_error(future_errc::broken_promise)). Destroys ...
Section: 20.7.4.3 [meta.unary.prop] Status: Ready Submitter: Niels Dekker Opened: 2009-06-01 Last modified: 2010-03-08
View other active issues in [meta.unary.prop].
View all other issues in [meta.unary.prop].
View all issues with Ready status.
Discussion:
The alignment_of template is no longer necessary, now that the core language will provide alignof. Scott Meyers raised this issue at comp.std.c++, C++0x: alignof vs. alignment_of, May 21, 2009. In a reply, Daniel Krügler pointed out that alignof was added to the working paper after alignment_of. So it appears that alignment_of is only part of the current Working Draft (N2857) because it is in TR1.
Having both alignof and alignment_of would cause unwanted confusion. In general, I think TR1 functionality should not be brought into C++0x if it is entirely redundant with other C++0x language or library features.
[ 2009-11-16 Chris adds: ]
I would like to suggest the following new wording for this issue, based on recent discussions. Basically this doesn't delete alignment_of, it just makes it clear that it is just a wrapper for alignof. This deletes the first part of the proposed resolution, changes the second part by leaving in alignof(T) but changing the precondition and leaves the 3rd part unchanged.
Suggested Resolution:
Change the first row of Table 44 ("Type property queries"), from Type properties 20.7.4.3 [meta.unary.prop]:
Table 44 — Type property queries template <class T> struct alignment_of; alignof(T).
Precondition:T shall be a complete type, a reference type, or an array of unknown bound, but shall not be a function type or (possibly cv-qualified) void.alignof(T) shall be definedChange text in Table 51 ("Other transformations"), from Other transformations 20.7.6.6 [meta.trans.other], as follows:
Table 51 — Other transformations ...aligned_storage; Len shall not be zero. Align shall be equal to alignment_of<T>::valuealignof(T) for some type T or to default-alignment....
[ 2010-01-30 Alisdair proposes that Chris' wording be moved into the proposed wording section and tweaks it on the way. ]
Original proposed wording saved here:
Remove from Header <type_traits> synopsis 20.7.2 [meta.type.synop]:
template <class T> struct alignment_of;Remove the first row of Table 44 ("Type property queries"), from Type properties 20.7.4.3 [meta.unary.prop]:
Table 44 — Type property queries template <class T> struct alignment_of;alignof(T).
Precondition: T shall be a complete type, a reference type, or an array of unknown bound, but shall not be a function type or (possibly cv-qualified) void.Change text in Table 51 ("Other transformations"), from Other transformations 20.7.6.6 [meta.trans.other], as follows:
Table 51 — Other transformations ...aligned_storage; Len shall not be zero. Align shall be equal to alignment_of<T>::valuealignof(T) for some type T or to default-alignment....
[ 2010-01-30 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change the first row of Table 43 ("Type property queries"), from Type properties 20.7.4.3 [meta.unary.prop]:
Table 43 — Type property queries template <class T> struct alignment_of; alignof(T).
Precondition:T shall be a complete type, a reference type, or an array of unknown bound, but shall not be a function type or (possibly cv-qualified) void.alignof(T) is a valid expression (5.3.6 [expr.alignof])
Change text in Table 51 ("Other transformations"), from Other transformations 20.7.6.6 [meta.trans.other], as follows:
Table 51 — Other transformations ...aligned_storage; Len shall not be zero. Align shall be equal to alignment_of<T>::valuealignof(T) for some type T or to default-alignment....
Section: 23.3.3.5 [forwardlist.ops], 23.3.4.4 [list.ops] Status: Ready Submitter: Alisdair Meredith Opened: 2009-05-09 Last modified: 2010-03-08
View other active issues in [forwardlist.ops].
View all other issues in [forwardlist.ops].
View all issues with Ready status.
Discussion:
IIUC, N2844 means that lvalues will no longer bind to rvalue references. Therefore, the current specification of list::splice (list operations 23.3.4.4 [list.ops]) will be a breaking change of behaviour for existing programs. That is because we changed the signature to swallow via an rvalue reference rather than the lvalue reference used in 03.
Retaining this form would be safer, requiring an explicit move when splicing from lvalues. However, this will break existing programs. We have the same problem with forward_list, although without the risk of breaking programs so here it might be viewed as a positive feature.
The problem signatures:
void splice_after(const_iterator position, forward_list<T,Alloc>&& x);
void splice_after(const_iterator position, forward_list<T,Alloc>&& x,
const_iterator i);
void splice_after(const_iterator position, forward_list<T,Alloc>&& x,
const_iterator first, const_iterator last);
void splice(const_iterator position, list<T,Alloc>&& x);
void splice(const_iterator position, list<T,Alloc>&& x,
const_iterator i);
void splice(const_iterator position, list<T,Alloc>&& x,
const_iterator first, const_iterator last);
Option A. Add an additional (non-const) lvalue-reference overload in each case
Option B. Change rvalue reference back to (non-const) lvalue-reference overload in each case
Option C. Add an additional (non-const) lvalue-reference overload in just the std::list cases
I think (B) would be very unfortunate, I really like the forward_list behaviour in (C) but feel (A) is needed for consistency.
My actual preference would be NAD, ship with this as a breaking change as it is a more explicit interface. I don't think that will fly though!
See the thread starting with c++std-lib-23725 for more discussion.
[ 2009-10-27 Christopher Jefferson provides proposed wording for Option C. ]
[ 2009-12-08 Jonathan Wakely adds: ]
As Bill Plauger pointed out, list::merge needs similar treatment.
[ Wording updated. ]
[ 2009-12-13 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
In 23.3.4 [list]
Add lvalue overloads before rvalue ones:
void splice(const_iterator position, list<T,Allocator>& x);
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 i);
void splice(const_iterator position, list<T,Allocator>& x,
const_iterator first, const_iterator last);
void splice(const_iterator position, list<T,Allocator>&& x,
const_iterator first, const_iterator last);
void merge(list<T,Allocator>& x);
template <class Compare> void merge(list<T,Allocator>& x, Compare comp);
void merge(list<T,Allocator>&& x);
template <class Compare> void merge(list<T,Allocator>&& x, Compare comp);
In 23.3.4.4 [list.ops], similarly add lvalue overload before each rvalue one:
(After paragraph 2)
void splice(const_iterator position, list<T,Allocator>& x); void splice(const_iterator position, list<T,Allocator>&& x);
(After paragraph 6)
void splice(const_iterator position, list<T,Allocator>& x, const_iterator i); void splice(const_iterator position, list<T,Allocator>&& x, const_iterator i);
(After paragraph 10)
void splice(const_iterator position, list<T,Allocator>& x,
const_iterator first, const_iterator last);
void splice(const_iterator position, list<T,Allocator>&& x,
const_iterator first, const_iterator last);
In 23.3.4.4 [list.ops], after paragraph 21
void merge(list<T,Allocator>& x); template <class Compare> void merge(list<T,Allocator>& x, Compare comp); void merge(list<T,Allocator>&& x); template <class Compare> void merge(list<T,Allocator>&& x, Compare comp);
Section: 18.4.2 [stdinth], 26.3.2 [fenv], 26.8 [c.math], 26.4.11 [cmplxh] Status: Ready Submitter: Robert Klarer Opened: 2009-05-26 Last modified: 2009-10-20
View all issues with Ready status.
Discussion:
This is probably editorial.
The following items should be removed from the draft, because they're redundant with Annex D, and they arguably make some *.h headers non-deprecated:
18.4.2 [stdinth] (regarding <stdint.h>)
26.3.2 [fenv] (regarding <fenv.h>
Line 3 of 26.8 [c.math] (regarding <tgmath.h>)
26.4.11 [cmplxh] (regarding <complex.h>, though the note in this subclause is not redundant)
[ 2009-06-10 Ganesh adds: ]
While searching for stdint in the CD, I found that <stdint.h> is also mentioned in 3.9.1 [basic.fundamental] /5. It guess it should refer to <cstdint> instead.
[ 2009 Santa Cruz: ]
Real issue. Maybe just editorial, maybe not. Move to Ready.
Proposed resolution:
Remove the section 18.4.2 [stdinth].
Remove the section 26.3.2 [fenv].
Remove 26.8 [c.math], p3:
-3- The header <tgmath.h> effectively includes the headers <complex.h> and <math.h>.
Remove the section 26.4.11 [cmplxh].
Section: 18.8.5 [propagation] Status: Ready Submitter: Daniel Krügler Opened: 2007-06-06 Last modified: 2009-10-20
View other active issues in [propagation].
View all other issues in [propagation].
View all issues with Ready status.
Discussion:
As of N2857 18.8.5 [propagation]/5, the implementation-defined type exception_ptr does provide the following ways to check whether it is a null value:
void f(std::exception_ptr p) {
p == nullptr;
p == 0;
p == exception_ptr();
}
This is rather cumbersome way of checking for the null value and I suggest to require support for evaluation in a boolean context like so:
void g(std::exception_ptr p) {
if (p) {}
!p;
}
[ 2009 Santa Cruz: ]
Move to Ready. Note to editor: considering putting in a cross-reference to 4 [conv], paragraph 3, which defines the phrase "contextually converted to bool".
Proposed resolution:
In section 18.8.5 [propagation] insert a new paragraph between p.5 and p.6:
An object e of type exception_ptr can be contextually converted to bool. The effect shall be as if e != exception_ptr() had been evaluated in place of e. There shall be no implicit conversion to arithmetic type, to enumeration type or to pointer type.
Section: 18.8.6 [except.nested] Status: Ready Submitter: Daniel Krügler Opened: 2007-06-06 Last modified: 2009-10-20
View other active issues in [except.nested].
View all other issues in [except.nested].
View all issues with Ready status.
Discussion:
It was recently mentioned in a newsgroup article http://groups.google.de/group/comp.std.c++/msg/f82022aff68edf3d that the specification of the member function rethrow_nested() of the class nested_exception is incomplete, specifically it remains unclear what happens, if member nested_ptr() returns a null value. In 18.8.6 [except.nested] we find only the following paragraph related to that:
void rethrow_nested() const; // [[noreturn]]-4- Throws: the stored exception captured by this nested_exception object.
This is a problem, because it is possible to create an object of nested_exception with exactly such a state, e.g.
#include <exception>
#include <iostream>
int main() try {
std::nested_exception e; // OK, calls current_exception() and stores it's null value
e.rethrow_nested(); // ?
std::cout << "A" << std::endl;
}
catch(...) {
std::cout << "B" << std::endl;
}
I suggest to follow the proposal of the reporter, namely to invoke terminate() if nested_ptr() return a null value of exception_ptr instead of relying on the fallback position of undefined behavior. This would be consistent to the behavior of a throw; statement when no exception is being handled.
[ 2009 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Change around 18.8.6 [except.nested]/4 as indicated:
-4- Throws: the stored exception captured by this nested_exception object, if nested_ptr() != nullptr
- Remarks: If nested_ptr() == nullptr, terminate() shall be called.
Section: 26.4.9 [cmplx.over] Status: Ready Submitter: Marc Steinbach Opened: 2009-06-11 Last modified: 2010-03-08
View all other issues in [cmplx.over].
View all issues with Ready status.
Discussion:
In clause 1, the Working Draft (N2857) specifies overloads of the functions
arg, conj, imag, norm, proj, real
for non-complex arithmetic types (float, double, long double, and integers). The only requirement (clause 2) specifies effective type promotion of arguments.
I strongly suggest to add the following requirement on the return types:
All the specified overloads must return real (i.e., non-complex) values, specifically, the nested value_type of effectively promoted arguments.
(This has no effect on arg, imag, norm, real: they are real-valued anyway.)
Rationale:
Mathematically, conj() and proj(), like the transcendental functions, are complex-valued in general but map the (extended) real line to itself. In fact, both functions act as identity on the reals. A typical user will expect conj() and proj() to preserve this essential mathematical property in the same way as exp(), sin(), etc. A typical use of conj(), e.g., is the generic scalar product of n-vectors:
template<typename T>
inline T
scalar_product(size_t n, T const* x, T const* y) {
T result = 0;
for (size_t i = 0; i < n; ++i)
result += x[i] * std::conj(y[i]);
return result;
}
This will work equally well for real and complex floating-point types T if conj() returns T. It will not work with real types if conj() returns complex values.
Instead, the implementation of scalar_product becomes either less efficient and less useful (if a complex result is always returned), or unnecessarily complicated (if overloaded versions with proper return types are defined). In the second case, the real-argument overload of conj() cannot be used. In fact, it must be avoided.
Overloaded conj() and proj() are principally needed in generic programming. All such use cases will benefit from the proposed return type requirement, in a similar way as the scalar_product example. The requirement will not harm use cases where a complex return value is expected, because of implicit conversion to complex. Without the proposed return type guarantee, I find overloaded versions of conj() and proj() not only useless but actually troublesome.
[ 2009-11-11 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Insert a new paragraph after 26.4.9 [cmplx.over]/2:
All of the specified overloads shall have a return type which is the nested value_type of the effectively cast arguments.
Section: 21.4.8.1 [string::op+] Status: Ready Submitter: Alisdair Meredith Opened: 2009-06-12 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
Many of the basic_string operator+ overloads return an rvalue-reference. Is that really intended?
I'm considering it might be a mild performance tweak to avoid making un-necessary copies of a cheaply movable type, but it opens risk to dangling references in code like:
auto && s = string{"x"} + string{y};
and I'm not sure about:
auto s = string{"x"} + string{y};
[ 2009-10-11 Howard updated Returns: clause for each of these. ]
[ 2009-11-05 Howard adds: ]
Moved to Tentatively Ready after 5 positive votes on c++std-lib.
Proposed resolution:
Strike the && from the return type in the following function signatures:
21.3 [string.classes] p2 Header Synopsis
template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(basic_string<charT,traits,Allocator>&& lhs, const basic_string<charT,traits,Allocator>& rhs); template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(const basic_string<charT,traits,Allocator>& lhs, basic_string<charT,traits,Allocator>&& rhs); template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(basic_string<charT,traits,Allocator>&& lhs, basic_string<charT,traits,Allocator>&& rhs); template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(const charT* lhs, basic_string<charT,traits,Allocator>&& rhs); template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(charT lhs, basic_string<charT,traits,Allocator>&& rhs); template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(basic_string<charT,traits,Allocator>&& lhs, const charT* rhs); template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(basic_string<charT,traits,Allocator>&& lhs, charT rhs);21.4.8.1 [string::op+]
template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(basic_string<charT,traits,Allocator>&& lhs, const basic_string<charT,traits,Allocator>& rhs);Returns: std::move(lhs.append(rhs))template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(const basic_string<charT,traits,Allocator>& lhs, basic_string<charT,traits,Allocator>&& rhs);Returns: std::move(rhs.insert(0, lhs))template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(basic_string<charT,traits,Allocator>&& lhs, basic_string<charT,traits,Allocator>&& rhs);Returns: std::move(lhs.append(rhs)) [Note: Or equivalently std::move(rhs.insert(0, lhs)) — end note]template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(const charT* lhs, basic_string<charT,traits,Allocator>&& rhs);Returns: std::move(rhs.insert(0, lhs)).template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(charT lhs, basic_string<charT,traits,Allocator>&& rhs);Returns: std::move(rhs.insert(0, 1, lhs)).template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(basic_string<charT,traits,Allocator>&& lhs, const charT* rhs);Returns: std::move(lhs.append(rhs)).template<class charT, class traits, class Allocator> basic_string<charT,traits,Allocator>&&operator+(basic_string<charT,traits,Allocator>&& lhs, charT rhs);Returns: std::move(lhs.append(1, rhs)).
Section: 18.5 [support.start.term] Status: Ready Submitter: LWG Opened: 2009-06-16 Last modified: 2009-10-20
View all other issues in [support.start.term].
View all issues with Ready status.
Discussion:
Addresses UK 187
The term "thread safe" is not defined nor used in this context anywhere else in the standard.
Suggested action:
Clarify the meaning of "thread safe".
[ 2009 Santa Cruz: ]
The "thread safe" language has already been change in the WP. It was changed to "happen before", but the current WP text is still a little incomplete: "happen before" is binary, but the current WP text only mentions one thing.
Move to Ready.
Proposed resolution:
For the following functions in 18.5 [support.start.term].
extern "C" int at_quick_exit(void (*f)(void)); extern "C++" int at_quick_exit(void (*f)(void));
Edit paragraph 10 as follows. The intent is to provide the other half of the happens before relation; to note indeterminate ordering; and to clean up some formatting.
Effects: The
at_quick_exit()functions register the function pointed to byfto be called without arguments whenquick_exitis called. It is unspecified whether a call toat_quick_exit()that does nothappen-beforehappen before (1.10) all calls toquick_exitwill succeed. [Note: theat_quick_exit()functions shall not introduce a data race (17.6.4.7).exitnote—end note] [Note: The order of registration may be indeterminate ifat_quick_exitwas called from more than one thread. —end note] [Note: Theat_quick_exitregistrations are distinct from theatexitregistrations, and applications may need to call both registration functions with the same argument. —end note]
For the following function.
void quick_exit [[noreturn]] (int status)
Edit paragraph 13 as follows. The intent is to note that thread-local variables may be different.
Effects: Functions registered by calls to
at_quick_exitare called in the reverse order of their registration, except that a function shall be called after any previously registered functions that had already been called at the time it was registered. Objects shall not be destroyed as a result of callingquick_exit. If control leaves a registered function called byquick_exitbecause the function does not provide a handler for a thrown exception,terminate()shall be called. [Note: Functions registered by one thread may be called by any thread, and hence should not rely on the identity of thread-storage-duration objects. —end note] After calling registered functions,quick_exitshall call_Exit(status). [Note: The standard file buffers are not flushed. See: ISO C 7.20.4.4. —end note]
Section: 17 [library] Status: Open Submitter: LWG Opened: 2009-06-28 Last modified: 2009-10-20
View other active issues in [library].
View all other issues in [library].
View all issues with Open status.
Discussion:
Addresses US 63
Description
The behavior of the library in the presence of threads is incompletely specified.
For example, if thread 1 assigns to X, then writes data to file f, which is read by thread 2, and then accesses variable X, is thread 2 guaranteed to be able to see the value assigned to X by thread 1? In other words, does the write of the data "happen before" the read?
Another example: does simultaneous access using operator at() to different characters in the same non-const string really introduce a data race?
Suggestion
Notes
17 SG: should go to threads group; misclassified in document
Concurrency SG: Create an issue. Hans will look into it.
[ 2009 Santa Cruz: ]
Move to "Open". Hans and the rest of the concurrency working group will study this. We can't make progress without a thorough review and a paper.
Proposed resolution:
Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: Ready Submitter: Seungbeom Kim Opened: 2009-06-27 Last modified: 2010-03-08
View other active issues in [facet.num.put.virtuals].
View all other issues in [facet.num.put.virtuals].
View all issues with Ready status.
Discussion:
In Table 73 -- Floating-point conversions, 22.4.2.2.2 [facet.num.put.virtuals], in N2914, we have the following entries:
| State | stdio equivalent |
|---|---|
| floatfield == ios_base::fixed | ios_base::scientific && !uppercase | %a |
| floatfield == ios_base::fixed | ios_base::scientific | %A |
These expressions are supposed to mean:
floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase floatfield == (ios_base::fixed | ios_base::scientific)
but technically parsed as:
((floatfield == ios_base::fixed) | ios_base::scientific) && (!uppercase) ((floatfield == ios_base::fixed) | ios_base::scientific)
and should be corrected with additional parentheses, as shown above.
[ 2009-10-28 Howard: ]
Moved to Tentatively Ready after 5 positive votes on c++std-lib.
Proposed resolution:
Change Table 83 — Floating-point conversions in 22.4.2.2.2 [facet.num.put.virtuals]:
| State | stdio equivalent |
|---|---|
| floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase | %a |
| floatfield == (ios_base::fixed | ios_base::scientific) | %A |
Section: 17 [library], 30 [thread], D [depr] Status: Open Submitter: LWG Opened: 2009-06-28 Last modified: 2009-10-20
View other active issues in [library].
View all other issues in [library].
View all issues with Open status.
Discussion:
Addresses DE 2
Description
Marking a constructor with explicit has semantics even for a constructor with zero or several parameters: Such a constructor cannot be used with list-initialization in a copy-initialization context, see 13.3.1.7 [over.match.list]. The standard library apparently has not been reviewed for marking non-single-parameter constructors as explicit.
Suggestion
Consider marking zero-parameter and multi-parameter constructors explicit in classes that have at least one constructor marked explicit and that do not have an initializer-list constructor.
Notes
Robert Klarer to address this one.
[ 2009 Santa Cruz: ]
Move to "Open". Robert Klarer has promised to provide wording.
Proposed resolution:
Section: 17.6.3.2.1 [namespace.std] Status: Ready Submitter: LWG Opened: 2009-06-28 Last modified: 2009-10-21
View all issues with Ready status.
Discussion:
Addresses UK 175
Description
Local types can now be used to instantiate templates, but don't have external linkage.
Suggestion
Remove the reference to external linkage.
Notes
We accept the proposed solution. Martin will draft an issue.
[ 2009-07-28 Alisdair provided wording. ]
[ 2009-10 Santa Cruz: ]
Moved to Ready.
Proposed resolution:
17.6.3.2.1 [namespace.std]
Strike "of external linkage" in p1 and p2:
-1- The behavior of a C++ program is undefined if it adds declarations or definitions to namespace std or to a namespace within namespace std unless otherwise specified. A program may add a concept map for any standard library concept or a template specialization for any standard library template to namespace std only if the declaration depends on a user-defined type
of external linkageand the specialization meets the standard library requirements for the original template and is not explicitly prohibited.179-2- The behavior of a C++ program is undefined if it declares
- an explicit specialization of any member function of a standard library class template, or
- an explicit specialization of any member function template of a standard library class or class template, or
- an explicit or partial specialization of any member class template of a standard library class or class template.
A program may explicitly instantiate a template defined in the standard library only if the declaration depends on the name of a user-defined type
of external linkageand the instantiation meets the standard library requirements for the original template.
Section: 30.2.4 [thread.req.timing] Status: Ready Submitter: LWG Opened: 2009-06-28 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
Addresses UK 322, US 96
Description
Not all systems can provide a monotonic clock. How are they expected to treat a _for function?
Suggestion
Add at least a note explaining the intent for systems that do not support a monotonic clock.
Notes
Create an issue, together with UK 96. Note that the specification as is already allows a non-monotonic clock due to the word “should” rather than “shall”. If this wording is kept, a footnote should be added to make the meaning clear.
[ 2009-06-29 Beman provided a proposed resolution. ]
[ 2009-10-31 Howard adds: ]
Set to Tentatively Ready after 5 positive votes on c++std-lib.
[ 2010-02-24 Pete moved to Open: ]
LWG 1158's proposed resolution replaces the ISO-specified normative term "should" with "are encouraged but not required to", which presumably means the same thing, but has no ISO normative status. The WD used the latter formulation in quite a few non-normative places, but only three normative ones. I've changed all the normative uses to "should".
[ 2010-03-06 Beman updates wording. ]
[ 2010 Pittsburgh: Moved to Ready. ]
Proposed resolution:
Change Timing specifications 30.2.4 [thread.req.timing] as indicated:
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. [Note: Implementations are not required to use a monotonic clock because such a clock may be unavailable. — end note]
Section: 30.4.3.2.2 [thread.lock.unique.locking] Status: Ready Submitter: LWG Opened: 2009-06-28 Last modified: 2010-03-12
View other active issues in [thread.lock.unique.locking].
View all other issues in [thread.lock.unique.locking].
View all issues with Ready status.
Duplicate of: 1219
Discussion:
Addresses UK 327, UK 328
UK 327 Description
Not clear what the specification for error condition resource_deadlock_would_occur means. It is perfectly possible for this thread to own the mutex without setting owns to true on this specific lock object. It is also possible for lock operations to succeed even if the thread does own the mutex, if the mutex is recursive. Likewise, if the mutex is not recursive and the mutex has been locked externally, it is not always possible to know that this error condition should be raised, depending on the host operating system facilities. It is possible that 'i.e.' was supposed to be 'e.g.' and that suggests that recursive locks are not allowed. That makes sense, as the exposition-only member owns is boolean and not a integer to count recursive locks.
UK 327 Suggestion
Add a precondition !owns. Change the 'i.e.' in the error condition to be 'e.g.' to allow for this condition to propogate deadlock detection by the host OS.
UK 327 Notes
Create an issue. Assigned to Lawrence Crowl. Note: not sure what try_lock means for recursive locks when you are the owner. POSIX has language on this, which should ideally be followed. Proposed fix is not quite right, for example, try_lock should have different wording from lock.
UK 328 Description
There is a missing precondition that owns is true, or an if(owns) test is missing from the effect clause
UK 328 Suggestion
Add a precondition that owns == true. Add an error condition to detect a violation, rather than yield undefined behaviour.
UK 328 Notes
Handle in same issue as UK 327. Also uncertain that the proposed resolution is the correct one.
[ 2009-11-11 Alisdair notes that this issue is very closely related to 1219, if not a dup. ]
[ 2010-02-12 Anthony provided wording. ]
[ 2010 Pittsburgh: ]
Wording updated and moved to Ready for Pittsburgh.
Proposed resolution:
Modify 30.4.3.2.2 [thread.lock.unique.locking] p3 to say:
void lock();...
3 Throws: Any exception thrown by pm->lock(). std::system_error if an exception is required (30.2.2 [thread.req.exception]). std::system_error with an error condition of operation_not_permitted if pm is 0. std::system_error with an error condition of resource_deadlock_would_occur if on entry owns is true.
std::system_error when the postcondition cannot be achieved.
Remove 30.4.3.2.2 [thread.lock.unique.locking] p4 (Error condition clause).
Modify 30.4.3.2.2 [thread.lock.unique.locking] p8 to say:
bool try_lock();...
8 Throws: Any exception thrown by pm->try_lock(). std::system_error if an exception is required (30.2.2 [thread.req.exception]). std::system_error with an error condition of operation_not_permitted if pm is 0. std::system_error with an error condition of resource_deadlock_would_occur if on entry owns is true.
std::system_error when the postcondition cannot be achieved.
Remove 30.4.3.2.2 [thread.lock.unique.locking] p9 (Error condition clause).
Modify 30.4.3.2.2 [thread.lock.unique.locking] p13 to say:
template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);...
13 Throws: Any exception thrown by pm->try_lock_until(). std::system_error if an exception is required (30.2.2 [thread.req.exception]). std::system_error with an error condition of operation_not_permitted if pm is 0. std::system_error with an error condition of resource_deadlock_would_occur if on entry owns is true.
std::system_error when the postcondition cannot be achieved.
Remove 30.4.3.2.2 [thread.lock.unique.locking] p14 (Error condition clause).
Modify 30.4.3.2.2 [thread.lock.unique.locking] p18 to say:
template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);...
18 Throws: Any exception thrown by pm->try_lock_for(). std::system_error if an exception is required (30.2.2 [thread.req.exception]). std::system_error with an error condition of operation_not_permitted if pm is 0. std::system_error with an error condition of resource_deadlock_would_occur if on entry owns is true.
std::system_error when the postcondition cannot be achieved.
Remove 30.4.3.2.2 [thread.lock.unique.locking] p19 (Error condition clause).
Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: New Submitter: Cosmin Truta Opened: 2009-07-04 Last modified: 2009-07-07
View other active issues in [facet.num.get.virtuals].
View all other issues in [facet.num.get.virtuals].
View all issues with New status.
Discussion:
As specified in the latest draft,
N2914,
num_get is still not fully compatible with the following C
functions: strtoul, strtoull,
strtof and
strtod.
In C, when conversion of a string to an unsigned integer type falls
outside the
representable range, strtoul and strtoull return
ULONG_MAX and ULLONG_MAX, respectively,
regardless
whether the input field represents a positive or a negative value.
On the other hand, the result of num_get conversion of
negative
values to unsigned integer types is zero. This raises a compatibility
issue.
Moreover, in C, when conversion of a string to a floating-point type falls
outside the representable range, strtof, strtod
and
strtold return ±HUGE_VALF,
±HUGE_VAL and ±HUGE_VALL, respectively.
On the other hand, the result of num_get conversion of such
out-of-range floating-point values results in the most positive/negative
representable value.
Although many C library implementations do implement HUGE_VAL
(etc.) as the highest representable (which is, usually, the infinity),
this
isn't required by the C standard. The C library specification makes no
statement regarding the value of HUGE_VAL and friends, which
potentially raises the same compatibility issue as in the above case of
unsigned integers.
In addition, neither C nor C++ define symbolic constants for the maximum
representable floating-point values (they only do so only for the maximum
representable finite floating-point values), which raises a
usability
issue (it would be hard for the programmer to check the result of
num_get against overflow).
As such, we propose to adjust the specification of num_get to
closely follow the behavior of all of its underlying C functions.
Proposed resolution:
Change 22.4.2.1.2 [facet.num.get.virtuals] as follows:
Stage 3: The sequence of
chars accumulated in stage 2 (the field) is converted to a numeric value by the rules of one of the functions declared in the header<cstdlib>:
- For a signed integer value, the function
strtoll.- For an unsigned integer value, the function
strtoull.- For a
floatvalue, the functionstrtof.- For a
doublevalue, the functionstrtod.- For a
floating-pointlong doublevalue, the functionstrtold.The numeric value to be stored can be one of:
- zero, if the conversion function fails to convert the entire field.
ios_base::failbitis assigned toerr.- the most positive (or negative) representable value, if the field to be converted to a signed integer type represents a value too large positive (or negative) to be represented in
val.ios_base::failbitis assigned toerr.the most negative representable value or zero for an unsigned integer type, if the field represents a value too large negative to be represented inval.ios_base::failbitis assigned toerr.- the most positive representable value, if the field to be converted to an unsigned integer type represents a value that cannot be represented in
val.- the converted value, otherwise.
The resultant numeric value is stored in
val. If the conversion function fails to convert the entire field, or if the field represents a value outside the range of representable values,ios_base::failbitis assigned toerr.
Section: 21.1 [strings.general] Status: Ready Submitter: Beman Dawes Opened: 2009-06-22 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
Addresses UK 218
Prior to the introduction of constant expressions into the library, basic_string elements had to be POD types, and thus had to be both trivially copyable and standard-layout. This ensured that they could be memcpy'ed and would be compatible with other libraries and languages, particularly the C language and its library.
N2349, Constant Expressions in the Standard Library Revision 2, changed the requirement in 21/1 from "POD type" to "literal type". That change had the effect of removing the trivially copyable and standard-layout requirements from basic_string elements.
This means that basic_string elements no longer are guaranteed to be memcpy'able, and are no longer guaranteed to be standard-layout types:
3.9/p2 and 3.9/p3 both make it clear that a "trivially copyable type" is required for memcpy to be guaranteed to work.
Literal types (3.9p12) may have a non-trivial copy assignment operator, and that violates the trivially copyable requirements given in 9/p 6, bullet item 2.
Literal types (3.9p12) have no standard-layout requirement, either.
This situation probably arose because the wording for "Constant Expressions in the Standard Library" was in process at the same time the C++ POD deconstruction wording was in process.
Since trivially copyable types meet the C++0x requirements for literal types, and thus work with constant expressions, it seems an easy fix to revert the basic_string element wording to its original state.
[ 2009-07-28 Alisdair adds: ]
When looking for any resolution for this issue, consider the definition of "character container type" in 17.3.4 [defns.character.container]. This does require the character type to be a POD, and this term is used in a number of places through clause 21 and 28. This suggests the PODness constraint remains, but is much more subtle than before. Meanwhile, I suspect the change from POD type to literal type was intentional with the assumption that trivially copyable types with non-trivial-but-constexpr constructors should serve as well. I don't believe the current wording offers the right guarantees for either of the above designs.
[ 2009-11-04 Howard modifies proposed wording to disallow array types as char-like types. ]
[ 2010-01-23 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change General 21.1 [strings.general] as indicated:
This Clause describes components for manipulating sequences of any
literalnon-array POD (3.9) type. In this Clause such types are called char-like types, and objects of char-like types are called char-like objects or simply characters.
Section: 20.10.3 [time.duration] Status: Open Submitter: Alisdair Meredith Opened: 2009-07-06 Last modified: 2009-10-31
View other active issues in [time.duration].
View all other issues in [time.duration].
View all issues with Open status.
Discussion:
The duration types in 20.10.3 [time.duration] are exactly the sort of type that should be "literal types" in the new standard. Likewise, arithmetic operations on durations should be declared constexpr.
[ 2009-09-21 Daniel adds: ]
An alternative (and possibly preferable solution for potentially heap-allocating big_int representation types) would be to ask the core language to allow references to const literal types as feasible arguments for constexpr functions.
[ 2009-10-30 Alisdair adds: ]
I suggest this issue moves from New to Open.
Half of this issue was dealt with in paper n2994 on constexpr constructors.
The other half (duration arithmetic) is on hold pending Core support for const & in constexpr functions.
Proposed resolution:
Add constexpr to declaration of following functions and constructors:
p1 20.10 [time]
Header <chrono> synopsis
[Draughting note - observe switch to pass-by-value to support constexpr]
// duration arithmetic template <class Rep1, class Period1, class Rep2, class Period2> typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type constexpr operator+(constduration<Rep1, Period1>&lhs,constduration<Rep2, Period2>&rhs); template <class Rep1, class Period1, class Rep2, class Period2> typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type constexpr operator-(constduration<Rep1, Period1>&lhs,constduration<Rep2, Period2>&rhs); template <class Rep1, class Period, class Rep2> duration<typename common_type<Rep1, Rep2>::type, Period> constexpr operator*(constduration<Rep1, Period>&d,constRep2&s); template <class Rep1, class Period, class Rep2> duration<typename common_type<Rep1, Rep2>::type, Period> constexpr operator*(constRep1&s,constduration<Rep2, Period>&d); template <class Rep1, class Period, class Rep2> duration<typename common_type<Rep1, Rep2>::type, Period> constexpr operator/(constduration<Rep1, Period>&d,constRep2&s); template <class Rep1, class Period1, class Rep2, class Period2> typename common_type<Rep1, Rep2>::type constexpr operator/(constduration<Rep1, Period1>&lhs,constduration<Rep2, Period2>&rhs); // duration comparisons template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator==(constduration<Rep1, Period1>&lhs,constduration<Rep2, Period2>&rhs); template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator!=(constduration<Rep1, Period1>&lhs,constduration<Rep2, Period2>&rhs); template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator< (constduration<Rep1, Period1>&lhs,constduration<Rep2, Period2>&rhs); template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator<=(constduration<Rep1, Period1>&lhs,constduration<Rep2, Period2>&rhs); template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator> (constduration<Rep1, Period1>&lhs,constduration<Rep2, Period2>&rhs); template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator>=(constduration<Rep1, Period1>&lhs,constduration<Rep2, Period2>&rhs); // duration_cast template <class ToDuration, class Rep, class Period> constexpr ToDuration duration_cast(constduration<Rep, Period>&d);20.10.3 [time.duration]
template <class Rep, class Period = ratio<1>> class duration { .... public: // 20.9.3.1, construct/copy/destroy: constexpr duration() = default; template <class Rep2> constexpr explicit duration(const Rep2& r); template <class Rep2, class Period2> constexpr duration(const duration<Rep2, Period2>& d); constexpr duration(const duration&) = default; // 20.9.3.2, observer: constexpr rep count() const; // 20.9.3.3, arithmetic: constexpr duration operator+() const; constexpr duration operator-() const; ... };
[ Note - this edit already seems assumed by definition of the duration static members zero/min/max. They cannot meaningfully be constexpr without this change. ]
Section: 17 [library] Status: Open Submitter: David Abrahams Opened: 2009-07-14 Last modified: 2009-10-20
View other active issues in [library].
View all other issues in [library].
View all issues with Open status.
Discussion:
Issue: The CopyConstructible requirements are wishy-washy. It requires that the copy is "equivalent" to the original, but "equivalent" is never defined.
I believe this to be an example of a more general lack of rigor around copy and assignment, although I haven't done the research to dig up all the instances.
It's a problem because if you don't know what CopyConstructible means, you also don't know what it means to copy a pair of CopyConstructible types. It doesn't prevent us from writing code, but it is a hole in our ability to understand the meaning of copy.
Furthermore, I'm pretty sure that vector's copy constructor doesn't require the elements to be EqualityComparable, so that table is actually referring to some ill-defined notion of equivalence when it uses ==.
[ 2009 Santa Cruz: ]
Move to "Open". Dave is right that this is a big issue. Paper D2987 ("Defining Move Special Member Functions", Bjarne Stroustrup and Lawrence Crowl) touches on this but does not solve it. This issue is discussed in Elements of Programming.
Proposed resolution:
Section: 23.2.5 [unord.req] Status: New Submitter: Pablo Halpern Opened: 2009-07-17 Last modified: 2009-07-19
View other active issues in [unord.req].
View all other issues in [unord.req].
View all issues with New status.
Discussion:
When I look at the unordered_* constructors, I think the complexity is poorly described and does not follow the style of the rest of the standard.
The complexity for the default constructor is specified as constant. Actually, it is proportional to n, but there are no invocations of value_type constructors or other value_type operations.
For the iterator-based constructor the complexity should be:
Complexity: exactly n calls to construct value_type from InputIterator::value_type (where n = distance(f,l)). The number of calls to key_equal::operator() is proportional to n in the average case and n*n in the worst case.
Proposed resolution:
Section: 20.10.3 [time.duration] Status: Ready Submitter: Howard Hinnant Opened: 2009-07-18 Last modified: 2010-03-08
View other active issues in [time.duration].
View all other issues in [time.duration].
View all issues with Ready status.
Discussion:
"diagnostic required" has been used (by me) for code words meaning "use enable_if to constrain templated functions. This needs to be improved by referring to the function signature as not participating in the overload set, and moving this wording to a Remarks paragraph.
[ 2009-10 Santa Cruz: ]
Moved to Ready.
[ 2009-11-19 Pete opens: ]
Oh, and speaking of 1177, most of the changes result in rather convoluted prose. Instead of saying
A shall be B, else Cit should be
C if A is not BThat is:
Rep2 shall be implicitly convertible to CR(Rep1, Rep2), else this signature shall not participate in overload resolution.should be
This signature shall not participate in overload resolution if Rep2 is not implicitly convertible to CR(Rep1, Rep2).That is clearer, and eliminates the false requirement that Rep2 "shall be" convertible.
[ 2009-11-19 Howard adds: ]
I've updated the wording to match Pete's suggestion and included bullet 16 from 1195.
[ 2009-11-19 Jens adds: ]
Further wording suggestion using "unless":
This signature shall not participate in overload resolution unless Rep2 is implicitly convertible to CR(Rep1, Rep2).
[ 2009-11-20 Howard adds: ]
I've updated the wording to match Jens' suggestion.
[ 2009-11-22 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
[ This proposed resolution addresses 947 and 974. ]
Change 20.10.3.1 [time.duration.cons] (and reorder the Remarks paragraphs per 17.5.1.4 [structure.specifications]):
template <class Rep2> explicit duration(const Rep2& r);
Requires:Remarks: This constructor shall not participate in overload resolution unless Rep2shall beis implicitly convertible to rep and
- treat_as_floating_point<rep>::value
shall beis true, or- treat_as_floating_point<Rep2>::value
shall beis false.
Diagnostic required[Example:duration<int, milli> d(3); // OK duration<int, milli> d(3.5); // error— end example]
Effects: Constructs an object of type duration.
Postcondition: count() == static_cast<rep>(r).
template <class Rep2, class Period2> duration(const duration<Rep2, Period2>& d);
Requires:Remarks: This constructor shall not participate in overload resolution unless treat_as_floating_point<rep>::valueshall beis true or ratio_divide<Period2, period>::type::denshall beis 1.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] [Example:duration<int, milli> ms(3); duration<int, micro> us = ms; // OK duration<int, milli> ms2 = us; // error— end example]
Effects: Constructs an object of type duration, constructing rep_ from duration_cast<duration>(d).count().
Change the following paragraphs in 20.10.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);RequiresRemarks: This operator shall not participate in overload resolution unless Rep2shall beis implicitly convertible to CR(Rep1, Rep2).Diagnostic required.template <class Rep1, class Period, class Rep2> duration<typename common_type<Rep1, Rep2>::type, Period> operator*(const Rep1& s, const duration<Rep2, Period>& d);RequiresRemarks: This operator shall not participate in overload resolution unless Rep1shall beis implicitly convertible to CR(Rep1, Rep2).Diagnostic required.template <class Rep1, class Period, class Rep2> duration<typename common_type<Rep1, Rep2>::type, Period> operator/(const duration<Rep1, Period>& d, const Rep2& s);RequiresRemarks: This operator shall not participate in overload resolution unless Rep2shall beis implicitly convertible to CR(Rep1, Rep2) and Rep2shall not beis not an instantiation of duration.Diagnostic required.template <class Rep1, class Period, class Rep2> duration<typename common_type<Rep1, Rep2>::type, Period> operator%(const duration<Rep1, Period>& d, const Rep2& s);RequiresRemarks: This operator shall not participate in overload resolution unless Rep2shall beis implicitly convertible to CR(Rep1, Rep2) and Rep2shall not beis not an instantiation of duration.Diagnostic required.
Change the following paragraphs in 20.10.3.7 [time.duration.cast]:
template <class ToDuration, class Rep, class Period> ToDuration duration_cast(const duration<Rep, Period>& d);RequiresRemarks: This function shall not participate in overload resolution unless ToDurationshall beis an instantiation of duration.Diagnostic required.
Change 20.10.4.1 [time.point.cons]/3 as indicated:
Requires: Duration2 shall be implicitly convertible to duration. Diagnostic required.Remarks: This constructor shall not participate in overload resolution unless Duration2 is implicitly convertible to duration.
Change the following paragraphs in 20.10.4.7 [time.point.cast]:
template <class ToDuration, class Clock, class Duration> time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);RequiresRemarks: This function shall not participate in overload resolution unless ToDurationshall beis an instantiation of duration.Diagnostic required.
Section: 28.9.1 [re.submatch.members] Status: Ready Submitter: Daniel Krügler Opened: 2009-07-25 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
The definition of class template sub_match is strongly dependent on the type basic_string<value_type>, both in interface and effects, but does not provide a corresponding typedef string_type, as e.g. class match_results does, which looks like an oversight to me that should be fixed.
[ 2009-11-15 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
In the class template sub_match synopsis 28.9 [re.submatch]/1 change as indicated:
template <class BidirectionalIterator>
class sub_match : public std::pair<BidirectionalIterator, BidirectionalIterator> {
public:
typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;
typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
typedef BidirectionalIterator iterator;
typedef basic_string<value_type> string_type;
bool matched;
difference_type length() const;
operator basic_string<value_type>string_type() const;
basic_string<value_type>string_type str() const;
int compare(const sub_match& s) const;
int compare(const basic_string<value_type>string_type& s) const;
int compare(const value_type* s) const;
};
In 28.9.1 [re.submatch.members]/2 change as indicated:
operatorbasic_string<value_type>string_type() const;Returns: matched ?basic_string<value_type>string_type(first, second) :basic_string<value_type>string_type().
In 28.9.1 [re.submatch.members]/3 change as indicated:
basic_string<value_type>string_type str() const;Returns: matched ?basic_string<value_type>string_type(first, second) :basic_string<value_type>string_type().
In 28.9.1 [re.submatch.members]/5 change as indicated:
int compare(constbasic_string<value_type>string_type& s) const;
Section: 28.9.2 [re.submatch.op] Status: New Submitter: Daniel Krügler Opened: 2009-07-25 Last modified: 2009-07-28
View all other issues in [re.submatch.op].
View all issues with New status.
Discussion:
Several heterogeneous comparison operators of class template sub_match are specified by return clauses that are not valid in general. E.g. 28.9.2 [re.submatch.op]/7:
template <class BiIter, class ST, class SA> bool operator==( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);Returns: lhs == rhs.str().
The returns clause would be ill-formed for all cases where ST != std::char_traits<iterator_traits<BiIter>::value_type> or SA != std::allocator<iterator_traits<BiIter>::value_type>.
The generic character of the comparison was intended, so there are basically two approaches to fix the problem: The first one would define the semantics of the comparison using the traits class ST (The semantic of basic_string::compare is defined in terms of the compare function of the corresponding traits class), the second one would define the semantics of the comparison using the traits class
std::char_traits<iterator_traits<BiIter>::value_type>
which is essentially identical to
std::char_traits<sub_match<BiIter>::value_type>
I suggest to follow the second approach, because this emphasizes the central role of the sub_match object as part of the comparison and would also make sure that a sub_match comparison using some basic_string<char_t, ..> always is equivalent to a corresponding comparison with a string literal because of the existence of further overloads (beginning from 28.9.2 [re.submatch.op]/19). If users really want to take advantage of their own traits::compare, they can simply write a corresponding compare function that does so.
Proposed resolution:
In 28.9.2 [re.submatch.op] change as indicated:
If 1180 is accepted:
template <class BiIter, class ST, class SA> bool operator==( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);7 Returns:lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) == rhs.str().template <class BiIter, class ST, class SA> bool operator!=( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);8 Returns:lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) != rhs.str().template <class BiIter, class ST, class SA> bool operator<( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);9 Returns:lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) < rhs.str().template <class BiIter, class ST, class SA> bool operator>( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);10 Returns:lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) > rhs.str().template <class BiIter, class ST, class SA> bool operator>=( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);11 Returns:lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) >= rhs.str().template <class BiIter, class ST, class SA> bool operator<=( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);12 Returns:lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) <= rhs.str().template <class BiIter, class ST, class SA> bool operator==(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);13 Returns: lhs.str() ==rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).template <class BiIter, class ST, class SA> bool operator!=(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);14 Returns: lhs.str() !=rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).template <class BiIter, class ST, class SA> bool operator<(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);15 Returns: lhs.str() <rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).template <class BiIter, class ST, class SA> bool operator>(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);16 Returns: lhs.str() >rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).template <class BiIter, class ST, class SA> bool operator>=(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);17 Returns: lhs.str() >=rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).template <class BiIter, class ST, class SA> bool operator<=(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);18 Returns: lhs.str() <=rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
If 1180 is not accepted:
template <class BiIter, class ST, class SA> bool operator==( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);7 Returns:lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) == rhs.str().template <class BiIter, class ST, class SA> bool operator!=( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);8 Returns:lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) != rhs.str().template <class BiIter, class ST, class SA> bool operator<( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);9 Returns:lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) < rhs.str().template <class BiIter, class ST, class SA> bool operator>( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);10 Returns:lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) > rhs.str().template <class BiIter, class ST, class SA> bool operator>=( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);11 Returns:lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) >= rhs.str().template <class BiIter, class ST, class SA> bool operator<=( const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& lhs, const sub_match<BiIter>& rhs);12 Returns:lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) <= rhs.str().template <class BiIter, class ST, class SA> bool operator==(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);13 Returns: lhs.str() ==rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).template <class BiIter, class ST, class SA> bool operator!=(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);14 Returns: lhs.str() !=rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).template <class BiIter, class ST, class SA> bool operator<(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);15 Returns: lhs.str() <rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).template <class BiIter, class ST, class SA> bool operator>(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);16 Returns: lhs.str() >rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).template <class BiIter, class ST, class SA> bool operator>=(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);17 Returns: lhs.str() >=rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).template <class BiIter, class ST, class SA> bool operator<=(const sub_match<BiIter>& lhs, const basic_string< typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);18 Returns: lhs.str() <=rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
Section: 20.8.16 [unord.hash] Status: Ready Submitter: Alisdair Meredith Opened: 2009-07-28 Last modified: 2010-03-08
View other active issues in [unord.hash].
View all other issues in [unord.hash].
View all issues with Ready status.
Discussion:
Addresses UK 324
The implied library dependencies created by spelling out all the hash template specializations in the <functional> synopsis are unfortunate. The potential coupling is greatly reduced if the hash specialization is declared in the appropriate header for each library type, as it is much simpler to forward declare the primary template and provide a single specialization than it is to implement a hash function for a string or vector without providing a definition for the whole string/vector template in order to access the necessary bits.
Note that the proposed resolution purely involves moving the declarations of a few specializations, it specifically does not make any changes to 20.8.16 [unord.hash].
[ 2009-09-15 Daniel adds: ]
I suggest to add to the current existing proposed resolution the following items.
Add to the very first strike-list of the currently suggested resolution the following lines:
template <> struct hash<std::error_code>;template <> struct hash<std::thread::id>;
Add the following declarations to 19.5 [syserr], header <system_error> synopsis after // 19.5.4:
// 19.5.x hash support template <class T> struct hash; template <> struct hash<error_code>;
Add a new clause 19.5.X (probably after 19.5.4):
19.5.X Hash support [syserr.hash]
template <> struct hash<error_code>;An explicit specialization of the class template hash (20.8.16 [unord.hash]) shall be provided for the type error_code suitable for using this type as key in unordered associative containers (23.5 [unord]).
Add the following declarations to 30.3.1.1 [thread.thread.id] just after the declaration of the comparison operators:
template <class T> struct hash; template <> struct hash<thread::id>;
Add a new paragraph at the end of 30.3.1.1 [thread.thread.id]:
template <> struct hash<thread::id>;An explicit specialization of the class template hash (20.8.16 [unord.hash]) shall be provided for the type thread::id suitable for using this type as key in unordered associative containers (23.5 [unord]).
[ 2009-11-13 Alisdair adopts Daniel's suggestion and the extended note from 889. ]
[ 2010-01-31 Alisdair: related to 1245 and 978. ]
[ 2010-02-07 Proposed wording updated by Beman, Daniel, Alisdair and Ganesh. ]
[ 2010-02-09 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Strike the following specializations declared in the <functional> synopsis p2 20.8 [function.objects]
template <> struct hash<std::string>;template <> struct hash<std::u16string>;template <> struct hash<std::u32string>;template <> struct hash<std::wstring>;template <> struct hash<std::error_code>;template <> struct hash<std::thread::id>;template <class Allocator> struct hash<std::vector<bool, Allocator> >;template <std::size_t N> struct hash<std::bitset<N> >;
Add the following at the end of 20.8.16 [unord.hash]:
template <> struct hash<bool>; template <> struct hash<char>; template <> struct hash<signed char>; template <> struct hash<unsigned char>; template <> struct hash<char16_t>; template <> struct hash<char32_t>; template <> struct hash<wchar_t>; template <> struct hash<short>; template <> struct hash<unsigned short>; template <> struct hash<int>; template <> struct hash<unsigned int>; template <> struct hash<long>; template <> struct hash<long long>; template <> struct hash<unsigned long>; template <> struct hash<unsigned long long>; template <> struct hash<float>; template <> struct hash<double>; template <> struct hash<long double>; template<class T> struct hash<T*>;Specializations meeting the requirements of class template hash 20.8.16 [unord.hash].
Add the following declarations to 19.5 [syserr], header <system_error> synopsis after // 19.5.4:
// [syserr.hash] hash support template <class T> struct hash; template <> struct hash<error_code>;
Add a new clause 19.5.X (probably after 19.5.4):
19.5.X Hash support [syserr.hash]
template <> struct hash<error_code>;Specialization meeting the requirements of class template hash 20.8.16 [unord.hash].
Add the following declarations to the synopsis of <string> in 21.3 [string.classes]
// [basic.string.hash] hash support template <class T> struct hash; template <> struct hash<string>; template <> struct hash<u16string>; template <> struct hash<u32string>; template <> struct hash<wstring>;
Add a new clause 21.4.X
21.4.X Hash support [basic.string.hash]>
template <> struct hash<string>; template <> struct hash<u16string>; template <> struct hash<u32string>; template <> struct hash<wstring>;Specializations meeting the requirements of class template hash 20.8.16 [unord.hash].
Add the following declarations to the synopsis of <vector> in 23.3 [sequences]
// 21.4.x hash support template <class T> struct hash; template <class Allocator> struct hash<vector<bool, Allocator>>;
Add a new paragraph to the end of 23.3.7 [vector.bool]
template <class Allocator> struct hash<vector<bool, Allocator>>;Specialization meeting the requirements of class template hash 20.8.16 [unord.hash].
Add the following declarations to the synopsis of <bitset> in 20.5 [template.bitset]
// [bitset.hash] hash support template <class T> struct hash; template <size_t N> struct hash<bitset<N> >;
Add a new subclause 20.3.7.X [bitset.hash]
20.3.7.X bitset hash support [bitset.hash]
template <size_t N> struct hash<bitset<N> >;Specialization meeting the requirements of class template hash 20.8.16 [unord.hash].
Add the following declarations to 30.3.1.1 [thread.thread.id] synopsis just after the declaration of the comparison operators:
template <class T> struct hash; template <> struct hash<thread::id>;
Add a new paragraph at the end of 30.3.1.1 [thread.thread.id]:
template <> struct hash<thread::id>;Specialization meeting the requirements of class template hash 20.8.16 [unord.hash].
Change Header <typeindex> synopsis 20.12.1 [type.index.synopsis] as indicated:
namespace std {
class type_index;
// [type.index.hash] hash support
template <class T> struct hash;
template<> struct hash<type_index>; : public unary_function<type_index, size_t> {
size_t operator()(type_index index) const;
}
}
Change Template specialization hash<type_index> 20.12.4 [type.index.templ] as indicated:
20.11.4
Template specialization hash<type_index> [type.index.templ]Hash support [type.index.hash]size_t operator()(type_index index) const;
Returns: index.hash_code()template<> struct hash<type_index>;Specialization meeting the requirements of class template hash [unord.hash]. For an object index of type type_index, hash<type_index>()(index) shall evaluate to the same value as index.hash_code().
Section: 27.5.4.2 [basic.ios.members] Status: Open Submitter: Daniel Krügler Opened: 2009-07-28 Last modified: 2009-10-22
View other active issues in [basic.ios.members].
View all other issues in [basic.ios.members].
View all issues with Open status.
Discussion:
The protected member function set_rdbuf had been added during the process of adding move and swap semantics to IO classes. A relevant property of this function is described by it's effects in 27.5.4.2 [basic.ios.members]/19:
Effects: Associates the basic_streambuf object pointed to by sb with this stream without calling clear().
This means that implementors of or those who derive from existing IO classes could cause an internal state where the stream buffer could be 0, but the IO class has the state good(). This would break several currently existing implementations which rely on the fact that setting a stream buffer via the currently only ways, i.e. either by calling
void init(basic_streambuf<charT,traits>* sb);
or by calling
basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);
to set rdstate() to badbit, if the buffer is 0. This has the effect that many internal functions can simply check rdstate() instead of rdbuf() for being 0.
I therefore suggest that a requirement is added for callers of set_rdbuf to set a non-0 value.
[ 2009-10 Santa Cruz: ]
Moved to Open. Martin volunteers to provide new wording, where set_rdbuf() sets the badbit but does not cause an exception to be thrown like a call to clear() would.
[ 2009-10-20 Martin provides wording: ]
Proposed resolution:
Change 27.5.4.2 [basic.ios.members] around p. 19 as indicated:
void set_rdbuf(basic_streambuf<charT, traits>* sb);
Effects: Associates the basic_streambuf object pointed to by sb with this stream without calling clear(). Postconditions: rdbuf() == sb.Effects: As if:
iostate state = rdstate(); try { rdbuf(sb); } catch(ios_base::failure) { if (0 == (state & ios_base::badbit)) unsetf(badbit); }Throws: Nothing.
Rationale:
We need to be able to call set_rdbuf() on stream objects for which (rdbuf() == 0) holds without causing ios_base::failure to be thrown. We also don't want badbit to be set as a result of setting rdbuf() to 0 if it wasn't set before the call. This changed Effects clause maintains the current behavior (as of N2914) without requiring that sb be non-null.Section: 24.2 [iterator.requirements] Status: New Submitter: Alisdair Meredith Opened: 2009-07-31 Last modified: 2009-07-31
View other active issues in [iterator.requirements].
View all other issues in [iterator.requirements].
View all issues with New status.
Discussion:
(wording relative to N2723 pending new working paper)
According to p3 24.2 [iterator.requirements], Forward iterators, Bidirectional iterators and Random Access iterators all satisfy the requirements for an Output iterator:
XXX iterators satisfy all the requirements of the input and output iterators and can be used whenever either kind is specified ...
Meanwhile, p4 goes on to contradict this:
Besides its category, a forward, bidirectional, or random access iterator can also be mutable or constant...
... Constant iterators do not satisfy the requirements for output iterators
The latter seems to be the overriding concern, as the iterator tag hierarchy does not define forward_iterator_tag as multiply derived from both input_iterator_tag and output_iterator_tag.
The work on concepts for iterators showed us that output iterator really is fundamentally a second dimension to the iterator categories, rather than part of the linear input -> forward -> bidirectional -> random-access sequence. It would be good to clear up these words to reflect that, and separately list output iterator requirements in the requires clauses for the appropriate algorithms and operations.
Proposed resolution:
Section: 20.7.6.6 [meta.trans.other] Status: New Submitter: Jason Merrill Opened: 2009-08-07 Last modified: 2009-08-22
View all other issues in [meta.trans.other].
View all issues with New status.
Discussion:
I notice that std::decay is specified to strip the cv-quals from anything but an array or pointer. This seems incorrect for values of class type, since class rvalues can have cv-qualified type (3.10 [basic.lval]/9).
[ 2009-08-09 Howard adds: ]
See the thread starting with c++std-lib-24568 for further discussion. And here is a convenience link to the original proposal. Also see the closely related issue 705.
Proposed resolution:
Add a note to decay in 20.7.6.6 [meta.trans.other]:
[Note: This behavior is similar to the lvalue-to-rvalue (4.1), array-to-pointer (4.2), and function-to-pointer (4.3) conversions applied when an lvalue expression is used as an rvalue, but also strips cv-qualifiers from class types in order to more closely model by-value argument passing. — end note]
Section: 23.2.5 [unord.req], 23.5 [unord] Status: New Submitter: Matt Austern Opened: 2009-08-10 Last modified: 2009-08-11
View other active issues in [unord.req].
View all other issues in [unord.req].
View all issues with New status.
Discussion:
Unordered associative containers have a notion of a maximum load factor: when the number of elements grows large enough, the containers automatically perform a rehash so that the number of elements per bucket stays below a user-specified bound. This ensures that the hash table's performance characteristics don't change dramatically as the size increases.
For similar reasons, Google has found it useful to specify a minimum load factor: when the number of elements shrinks by a large enough, the containers automatically perform a rehash so that the number of elements per bucket stays above a user-specified bound. This is useful for two reasons. First, it prevents wasting a lot of memory when an unordered associative container grows temporarily. Second, it prevents amortized iteration time from being arbitrarily large; consider the case of a hash table with a billion buckets and only one element. (This was discussed even before TR1 was published; it was TR issue 6.13, which the LWG closed as NAD on the grounds that it was a known design feature. However, the LWG did not consider the approach of a minimum load factor.)
The only interesting question is when shrinking is allowed. In principle the cleanest solution would be shrinking on erase, just as we grow on insert. However, that would be a usability problem; it would break a number of common idioms involving erase. Instead, Google's hash tables only shrink on insert and rehash.
The proposed resolution allows, but does not require, shrinking in rehash, mostly because a postcondition for rehash that involves the minimum load factor would be fairly complicated. (It would probably have to involve a number of special cases and it would probably have to mention yet another parameter, a minimum bucket count.)
The current behavior is equivalent to a minimum load factor of 0. If we specify that 0 is the default, this change will have no impact on backward compatibility.
Proposed resolution:
Add two new rows, and change rehash's postcondition in the unordered associative container requirements table in 23.2.5 [unord.req]:
Table 87 — Unordered associative container requirements (in addition to container) Expression Return type Assertion/note pre-/post-condition Complexity a.min_load_factor() float Returns a non-negative number that the container attempts to keep the load factor greater than or equal to. The container automatically decreases the number of buckets as necessary to keep the load factor above this number. constant a.min_load_factor(z) void Pre: z shall be non-negative. Changes the container's minimum load factor, using z as a hint. [Footnote: the minimum load factor should be significantly smaller than the maximum. If z is too large, the implementation may reduce it to a more sensible value.] constant a.rehash(n) void Post: a.bucket_count() >= n, and a.size() <= a.bucket_count() * a.max_load_factor(). [Footnote: It is intentional that the postcondition does not mention the minimum load factor. This member function is primarily intended for cases where the user knows that the container's size will increase soon, in which case the container's load factor will temporarily fall below a.min_load_factor().] a.bucket_cout > a.size() / a.max_load_factor() and a.bucket_count() >= n.Average case linear in a.size(), worst case quadratic.
Add a footnote to 23.2.5 [unord.req] p12:
The insert members shall not affect the validity of references to container elements, but may invalidate all iterators to the container. The erase members shall invalidate only iterators and references to the erased elements.
[A consequence of these requirements is that while insert may change the number of buckets, erase may not. The number of buckets may be reduced on calls to insert or rehash.]
Change paragraph 13:
The insert members shall not affect the validity of iterators if(N+n) < z * Bzmin * B <= (N+n) <= zmax * B, where N is the number of elements in the container prior to the insert operation, n is the number of elements inserted, B is the container's bucket count, zmin is the container's minimum load factor, and zmax is the container's maximum load factor.
Add to the unordered_map class synopsis in section 23.5.1 [unord.map], the unordered_multimap class synopsis in 23.5.2 [unord.multimap], the unordered_set class synopsis in 23.5.3 [unord.set], and the unordered_multiset class synopsis in 23.5.4 [unord.multiset]:
float min_load_factor() const; void min_load_factor(float z);
In 23.5.1.1 [unord.map.cnstr], 23.5.2.1 [unord.multimap.cnstr], 23.5.3.1 [unord.set.cnstr], and 23.5.4.1 [unord.multiset.cnstr], change:
... max_load_factor() returns 1.0 and min_load_factor() returns 0.
Section: 23.2.5 [unord.req], 23.5 [unord] Status: Ready Submitter: Matt Austern Opened: 2009-08-10 Last modified: 2010-03-08
View other active issues in [unord.req].
View all other issues in [unord.req].
View all issues with Ready status.
Discussion:
Consider a typical use case: I create an unordered_map and then start adding elements to it one at a time. I know that it will eventually need to store a few million elements, so, for performance reasons, I would like to reserve enough capacity that none of the calls to insert will trigger a rehash.
Unfortunately, the existing interface makes this awkward. The user naturally sees the problem in terms of the number of elements, but the interface presents it as buckets. If m is the map and n is the expected number of elements, this operation is written m.rehash(n / m.max_load_factor()) — not very novice friendly.
[ 2009-09-30 Daniel adds: ]
I recommend to replace "resize" by a different name like "reserve", because that would better match the intended use-case. Rational: Any existing resize function has the on-success post-condition that the provided size is equal to size(), which is not satisfied for the proposal. Reserve seems to fit the purpose of the actual renaming suggestion.
[ 2009-10-28 Ganesh summarizes alternative resolutions and expresses a strong preference for the second (and opposition to the first): ]
In the unordered associative container requirements (23.2.5 [unord.req]), remove the row for rehash and replace it with:
Table 87 — Unordered associative container requirements (in addition to container) Expression Return type Assertion/note pre-/post-condition Complexity a. rehashreserve(n)void Post: a.bucket_count > max(a.size(), n) / a.max_load_factor() and a.bucket_count() >= n.Average case linear in a.size(), worst case quadratic. Make the corresponding change in the class synopses in 23.5.1 [unord.map], 23.5.2 [unord.multimap], 23.5.3 [unord.set], and 23.5.4 [unord.multiset].
In 23.2.5 [unord.req]/9, table 98, append a new row after the last one:
Table 87 — Unordered associative container requirements (in addition to container) Expression Return type Assertion/note pre-/post-condition Complexity a.rehash(n) void Post: a.bucket_count > a.size() / a.max_load_factor() and a.bucket_count() >= n. Average case linear in a.size(), worst case quadratic. a.reserve(n) void Same as a.rehash(ceil(n / a.max_load_factor())) Average case linear in a.size(), worst case quadratic. In 23.5.1 [unord.map]/3 in the definition of class template unordered_map, in 23.5.2 [unord.multimap]/3 in the definition of class template unordered_multimap, in 23.5.3 [unord.set]/3 in the definition of class template unordered_set and in 23.5.4 [unord.multiset]/3 in the definition of class template unordered_multiset, add the following line after member function rehash():
void reserve(size_type n);
[ 2009-10-28 Howard: ]
Moved to Tentatively Ready after 5 votes in favor of Ganesh's option 2 above. The original proposed wording now appears here:
Informally: instead of providing rehash(n) provide resize(n), with the semantics "make the container a good size for n elements".
In the unordered associative container requirements (23.2.5 [unord.req]), remove the row for rehash and replace it with:
Table 87 — Unordered associative container requirements (in addition to container) Expression Return type Assertion/note pre-/post-condition Complexity a. rehashresize(n)void Post: a.bucket_count > max(a.size(), n) / a.max_load_factor() and a.bucket_count() >= n.Average case linear in a.size(), worst case quadratic. Make the corresponding change in the class synopses in 23.5.1 [unord.map], 23.5.2 [unord.multimap], 23.5.3 [unord.set], and 23.5.4 [unord.multiset].
Proposed resolution:
In 23.2.5 [unord.req]/9, table 98, append a new row after the last one:
Table 87 — Unordered associative container requirements (in addition to container) Expression Return type Assertion/note pre-/post-condition Complexity a.rehash(n) void Post: a.bucket_count > a.size() / a.max_load_factor() and a.bucket_count() >= n. Average case linear in a.size(), worst case quadratic. a.reserve(n) void Same as a.rehash(ceil(n / a.max_load_factor())) Average case linear in a.size(), worst case quadratic.
In 23.5.1 [unord.map]/3 in the definition of class template unordered_map, in 23.5.2 [unord.multimap]/3 in the definition of class template unordered_multimap, in 23.5.3 [unord.set]/3 in the definition of class template unordered_set and in 23.5.4 [unord.multiset]/3 in the definition of class template unordered_multiset, add the following line after member function rehash():
void reserve(size_type n);
Section: 23.2.5 [unord.req], 23.5 [unord] Status: New Submitter: Matt Austern Opened: 2009-08-10 Last modified: 2009-08-11
View other active issues in [unord.req].
View all other issues in [unord.req].
View all issues with New status.
Discussion:
The unordered associative container requirements table specifies that a.set_max_load_factor(z) has return type void. However, there is a useful piece of information to return: the previous value. Users who don't need it can always ignore it.
Proposed resolution:
In the unordered associative container requirements table, change:
Table 87 — Unordered associative container requirements (in addition to container) Expression Return type Assertion/note pre-/post-condition Complexity a.max_load_factor(z) voidfloatPre: z shall be positive. Changes the container's maximum loadload factor, using z as a hint. Returns: the previous value of a.max_load_factor().constant
Change the return type of set_max_load_factor in the class synopses in 23.5.1 [unord.map], 23.5.2 [unord.multimap], 23.5.3 [unord.set], and 23.5.4 [unord.multiset].
If issue 1188 is also accepted, make the same changes for min_load_factor.
Section: 20.4.2.6 [tuple.elem] Status: Open Submitter: Alisdair Meredith Opened: 2009-08-18 Last modified: 2009-10-31
View all issues with Open status.
Discussion:
The tuple get API should respect rvalues. This would allow for moving a single element out of a tuple-like type.
[ 2009-10-30 Alisdair adds: ]
The issue of rvalue overloads of get for tuple-like types was briefly discussed in Santa Cruz.
The feedback was this would be welcome, but we need full wording for the other types (pair and array) before advancing.
I suggest the issue moves to Open from New as it has been considered, feedback given, and it has not (yet) been rejected as NAD.
Proposed resolution:
Add the following signature to p2 20.4.1 [tuple.general]
template <size_t I, class ... Types> typename tuple_element<I, tuple<Types...> >::type&& get(tuple<Types...> &&);
And again to 20.4.2.6 [tuple.elem].
template <size_t I, class ... Types> typename tuple_element<I, tuple<Types...> >::type&& get(tuple<Types...>&& t);Effects: Equivalent to return std::forward<typename tuple_element<I, tuple<Types...> >::type&&>(get<I>(t));
[Note: If a T in Types is some reference type X&, the return type is X&, not X&&. However, if the element type is non-reference type T, the return type is T&&. — end note]
Add the following signature to p1 20.3 [utility]
template <size_t I, class T1, class T2> typename tuple_element<I, pair<T1,T2> >::type&& get(pair<T1, T2>&&);
And to p5 20.3.4.3 [pair.astuple]
template <size_t I, class T1, class T2> typename tuple_element<I, pair<T1,T2> >::type&& get(pair<T1, T2>&& p);Returns: If I == 0 returns std::forward<T1&&>(p.first); if I == 1 returns std::forward<T2&&>(p.second); otherwise the program is ill-formed.
Throws: Nothing.
Add the following signature to 23.3 [sequences] <array> synopsis
template <size_t I, class T, size_t N> T&& get(array<T,N> &&);
And after p8 23.3.1.7 [array.tuple]
template <size_t I, class T, size_t N> T&& get(array<T,N> && a);Effects: Equivalent to return std::move(get<I>(a));
Section: 21.4.3 [string.iterators] Status: Ready Submitter: Jonathan Wakely Opened: 2009-08-14 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
Unlike the containers in clause 23, basic_string has definitions for begin() and end(), but these have not been updated to include cbegin, cend, crbegin and crend.
[ 2009-10-28 Howard: ]
Moved to Tentatively NAD after 5 positive votes on c++std-lib. Added rationale.
[ 2009-10-28 Alisdair disagrees: ]
I'm going to have to speak up as the dissenting voice.
I agree the issue could be handled editorially, and that would be my preference if Pete feels this is appropriate. Failing that, I really think this issue should be accepted and moved to ready. The other begin/end functions all have a semantic definition for this template, and it is confusing if a small few are missing.
I agree that an alternative would be to strike all the definitions for begin/end/rbegin/rend and defer completely to the requirements tables in clause 23. I think that might be confusing without a forward reference though, as those tables are defined in a *later* clause than the basic_string template itself. If someone wants to pursue this I would support it, but recommend it as a separate issue.
So my preference is strongly to move Ready over NAD, and a stronger preference for NAD Editorial if Pete is happy to make these changes.
[ 2009-10-29 Howard: ]
Moved to Tentatively Ready after 5 positive votes on c++std-lib. Removed rationale to mark it NAD. :-)
Proposed resolution:
Add to 21.4.3 [string.iterators]
iterator begin(); const_iterator begin() const; const_iterator cbegin() const;...
iterator end(); const_iterator end() const; const_iterator cend() const;...
reverse_iterator rbegin(); const_reverse_iterator rbegin() const; const_reverse_iterator crbegin() const;...
reverse_iterator rend(); const_reverse_iterator rend() const; const_reverse_iterator crend() const;
Section: 20.9.10.1 [unique.ptr.dltr] Status: Ready Submitter: Daniel Krügler Opened: 2009-08-18 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
According to the general rules of 17.6.3.8 [res.on.functions]/2 b 5 the effects are undefined, if an incomplete type is used to instantiate a library template. But neither in 20.9.10.1 [unique.ptr.dltr] nor in any other place of the standard such explicit allowance is given. Since this template is intended to be instantiated with incomplete types, this must be fixed.
[ 2009-11-15 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
[ 2009-11-17 Alisdair Opens: ]
LWG 1193 tries to support unique_ptr for incomplete types. I believe the proposed wording goes too far:
The template parameter T of default_delete may be an incomplete type.Do we really want to support cv-void? Suggested ammendment:
The template parameter T of default_delete may be an incomplete type other than cv-void.We might also consider saying something about arrays of incomplete types.
Did we lose support for unique_ptr<function-type> when the concept-enabled work was shelved? If so, we might want a default_delete partial specialization for function types that does nothing. Alternatively, function types should not be supported by default, but there is no reason a user cannot support them via their own deletion policy.
Function-type support might also lead to conditionally supporting a function-call operator in the general case, and that seems way too inventive at this stage to me, even if we could largely steal wording directly from reference_wrapper. shared_ptr would have similar problems too.
[ 2010-01-24 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Add two new paragraphs directly to 20.9.10.1 [unique.ptr.dltr] (before 20.9.10.1.1 [unique.ptr.dltr.dflt]) with the following content:
The class template default_delete serves as the default deleter (destruction policy) for the class template unique_ptr.
The template parameter T of default_delete may be an incomplete type.
Section: 23.3.5 [container.adaptors] Status: Ready Submitter: Howard Hinnant Opened: 2009-08-20 Last modified: 2009-10-20
View other active issues in [container.adaptors].
View all other issues in [container.adaptors].
View all issues with Ready status.
Discussion:
23.3.5.1.1 [queue.defn] has the following queue constructor:
template <class Alloc> explicit queue(const Alloc&);
This will be implemented like so:
template <class Alloc> explicit queue(const Alloc& a) : c(a) {}
The issue is that Alloc can be anything that a container will construct from, for example an int. Is this intended to compile?
queue<int> q(5);
Before the addition of this constructor, queue<int>(5) would not compile. I ask, not because this crashes, but because it is new and appears to be unintended. We do not want to be in a position of accidently introducing this "feature" in C++0X and later attempting to remove it.
I've picked on queue. priority_queue and stack have the same issue. Is it useful to create a priority_queue of 5 identical elements?
[ Daniel, Howard and Pablo collaborated on the proposed wording. ]
[ 2009-10 Santa Cruz: ]
Move to Ready.
Proposed resolution:
[ This resolution includes a semi-editorial clean up, giving definitions to members which in some cases weren't defined since C++98. This resolution also offers editorially different wording for 976, and it also provides wording for 1196. ]
Change container.adaptors, p1:
The container adaptors each take a Container template parameter, and each constructor takes a Container reference argument. This container is copied into the Container member of each adaptor. If the container takes an allocator, then a compatible allocator may be passed in to the adaptor's constructor. Otherwise, normal copy or move construction is used for the container argument.[Note: it is not necessary for an implementation to distinguish between the one-argument constructor that takes a Container and the one- argument constructor that takes an allocator_type. Both forms use their argument to construct an instance of the container. — end note]
Change queue.defn, p1:
template <class T, class Container = deque<T> >
class queue {
public:
typedef typename Container::value_type value_type;
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference;
typedef typename Container::size_type size_type;
typedef Container container_type;
protected:
Container c;
public:
explicit queue(const Container&);
explicit queue(Container&& = Container());
queue(queue&& q); : c(std::move(q.c)) {}
template <class Alloc> explicit queue(const Alloc&);
template <class Alloc> queue(const Container&, const Alloc&);
template <class Alloc> queue(Container&&, const Alloc&);
template <class Alloc> queue(queue&&, const Alloc&);
queue& operator=(queue&& q); { c = std::move(q.c); return *this; }
bool empty() const { return c.empty(); }
...
};
Add a new section after 23.3.5.1.1 [queue.defn], [queue.cons]:
queue constructors [queue.cons]
explicit queue(const Container& cont);Effects: Initializes c with cont.
explicit queue(Container&& cont = Container());Effects: Initializes c with std::move(cont).
queue(queue&& q)Effects: Initializes c with std::move(q.c).
For each of the following constructors, if uses_allocator<container_type, Alloc>::value is false, then the constructor shall not participate in overload resolution.
template <class Alloc> explicit queue(const Alloc& a);Effects: Initializes c with a.
template <class Alloc> queue(const container_type& cont, const Alloc& a);Effects: Initializes c with cont as the first argument and a as the second argument.
template <class Alloc> queue(container_type&& cont, const Alloc& a);Effects: Initializes c with std::move(cont) as the first argument and a as the second argument.
template <class Alloc> queue(queue&& q, const Alloc& a);Effects: Initializes c with std::move(q.c) as the first argument and a as the second argument.
queue& operator=(queue&& q);Effects: Assigns c with std::move(q.c).
Returns: *this.
Add to 23.3.5.2.1 [priqueue.cons]:
priority_queue(priority_queue&& q);Effects: Initializes c with std::move(q.c) and initializes comp with std::move(q.comp).
For each of the following constructors, if uses_allocator<container_type, Alloc>::value is false, then the constructor shall not participate in overload resolution.
template <class Alloc> explicit priority_queue(const Alloc& a);Effects: Initializes c with a and value-initializes comp.
template <class Alloc> priority_queue(const Compare& compare, const Alloc& a);Effects: Initializes c with a and initializes comp with compare.
template <class Alloc> priority_queue(const Compare& compare, const Container& cont, const Alloc& a);Effects: Initializes c with cont as the first argument and a as the second argument, and initializes comp with compare.
template <class Alloc> priority_queue(const Compare& compare, Container&& cont, const Alloc& a);Effects: Initializes c with std::move(cont) as the first argument and a as the second argument, and initializes comp with compare.
template <class Alloc> priority_queue(priority_queue&& q, const Alloc& a);Effects: Initializes c with std::move(q.c) as the first argument and a as the second argument, and initializes comp with std::move(q.comp).
priority_queue& operator=(priority_queue&& q);Effects: Assigns c with std::move(q.c) and assigns comp with std::move(q.comp).
Returns: *this.
Change 23.3.5.3.1 [stack.defn]:
template <class T, class Container = deque<T> >
class stack {
public:
typedef typename Container::value_type value_type;
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference;
typedef typename Container::size_type size_type;
typedef Container container_type;
protected:
Container c;
public:
explicit stack(const Container&);
explicit stack(Container&& = Container());
stack(stack&& s);
template <class Alloc> explicit stack(const Alloc&);
template <class Alloc> stack(const Container&, const Alloc&);
template <class Alloc> stack(Container&&, const Alloc&);
template <class Alloc> stack(stack&&, const Alloc&);
stack& operator=(stack&& s);
bool empty() const { return c.empty(); }
...
};
Add a new section after 23.3.5.3.1 [stack.defn], [stack.cons]:
stack constructors [stack.cons]
stack(stack&& s);Effects: Initializes c with std::move(s.c).
For each of the following constructors, if uses_allocator<container_type, Alloc>::value is false, then the constructor shall not participate in overload resolution.
template <class Alloc> explicit stack(const Alloc& a);Effects: Initializes c with a.
template <class Alloc> stack(const container_type& cont, const Alloc& a);Effects: Initializes c with cont as the first argument and a as the second argument.
template <class Alloc> stack(container_type&& cont, const Alloc& a);Effects: Initializes c with std::move(cont) as the first argument and a as the second argument.
template <class Alloc> stack(stack&& s, const Alloc& a);Effects: Initializes c with std::move(s.c) as the first argument and a as the second argument.
stack& operator=(stack&& s);Effects: Assigns c with std::move(s.c).
Returns: *this.
Section: 17 [library] Status: Ready Submitter: Daniel Krügler Opened: 2009-08-18 Last modified: 2010-03-08
View other active issues in [library].
View all other issues in [library].
View all issues with Ready status.
Discussion:
Several parts of the library use the notion of "Diagnostic required" to indicate that in the corresponding situation an error diagnostic should occur, e.g. 20.9.10.1.1 [unique.ptr.dltr.dflt]/2
void operator()(T *ptr) const;Effects: calls delete on ptr. A diagnostic is required if T is an incomplete type.
The problem with this approach is that such a requirement is insufficient to prevent undefined behavior, if this situation occurs. According to 1.3.3 [defns.diagnostic] a diagnostic message is defined as
a message belonging to an implementation-defined subset of the implementation's output messages.
which doesn't indicate any relation to an ill-formed program. In fact, "compiler warnings" are a typical expression of such diagnostics. This means that above wording can be interpreted by compiler writers that they satisfy the requirements of the standard if they just produce such a "warning", if the compiler happens to compile code like this:
#include <memory>
struct Ukn; // defined somewhere else
Ukn* create_ukn(); // defined somewhere else
int main() {
std::default_delete<Ukn>()(create_ukn());
}
In this and other examples discussed here it was the authors intent to guarantee that the program is ill-formed with a required diagnostic, therefore such wording should be used instead. According to the general rules outlined in 1.4 [intro.compliance] it should be sufficient to require that these situations produce an ill-formed program and the "diagnostic required" part should be implied. The proposed resolution also suggests to remove several redundant wording of "Diagnostics required" to ensure that the absence of such saying does not cause a misleading interpretation.
[ 2009 Santa Cruz: ]
Move to NAD.
It's not clear that there's any important difference between "ill-formed" and "diagnostic required". From 1.4 [intro.compliance], 1.3.5 [defns.ill.formed], and 1.3.15 [defns.well.formed] it appears that an ill-formed program is one that is not correctly constructed according to the syntax rules and diagnosable semantic rules, which means that... "a conforming implementation shall issue at least one diagnostic message." The author's intent seems to be that we should be requiring a fatal error instead of a mere warning, but the standard just doesn't have language to express that distinction. The strongest thing we can ever require is a "diagnostic".
The proposed rewording may be a clearer way of expressing the same thing that the WP already says, but such a rewording is editorial.
[ 2009 Santa Cruz: ]
Considered again. Group disagrees that the change is technical, but likes it editorially. Moved to NAD Editorial.
[ 2009-11-19: Moved from NAD Editorial to Open. Please see the thread starting with Message c++std-lib-25916. ]
[ 2009-11-20 Daniel updated wording. ]
The following resolution differs from the previous one by avoiding the unusual and misleading term "shall be ill-formed", which does also not follow the core language style. This resolution has the advantage of a minimum impact on the current wording, but I would like to mention that a more intrusive solution might be preferrable - at least as a long-term solution: Jens Maurer suggested the following approach to get rid of the usage of the term "ill-formed" from the library by introducing a new category to existing elements to the list of 17.5.1.4 [structure.specifications]/3, e.g. "type requirements" or "static constraints" that define conditions that can be checked during compile-time and any violation would make the program ill-formed. As an example, the currently existing phrase 20.4.2.5 [tuple.helper]/1
Requires: I < sizeof...(Types). The program is ill-formed if I is out of bounds.could then be written as
Static constraints: I < sizeof...(Types).
[ 2009-11-21 Daniel updated wording. ]
[ 2009-11-22 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change 20.6 [ratio]/2 as indicated:
Throughout this subclause, if the template argument types R1 and R2shall beare not specializations of the ratio template, the program is ill-formed.Diagnostic required.
Change 20.6.1 [ratio.ratio]/1 as indicated:
If tThe template argument D shall not
be is zero, and or the absolute values of
the template arguments N and D shall be are
not representable by type intmax_t, the program is
ill-formed. Diagnostic required. [..]
Change 20.6.2 [ratio.arithmetic]/1 as indicated:
Implementations may use other algorithms to compute these values. If overflow occurs, the program is ill-formeda diagnostic shall be issued.
Change 20.6.3 [ratio.comparison]/2 as indicated:
[...] Implementations may use other algorithms to compute this relationship to avoid overflow. If overflow occurs, the program is ill-formeda diagnostic is required.
Change 20.9.10.1.1 [unique.ptr.dltr.dflt]/2 as indicated:
Effects: calls delete on ptr.
A diagnostic is required if T is an incomplete type.Remarks: If T is an incomplete type, the program is ill-formed.
Change 20.9.10.1.2 [unique.ptr.dltr.dflt1]/1 as indicated:
void operator()(T* ptr) const;Effects:
operator()calls delete[] on ptr.A diagnostic is required if T is an incomplete type.Remarks: If T is an incomplete type, the program is ill-formed.
Change 20.9.10.2.1 [unique.ptr.single.ctor] as indicated: [Note: This editorially improves the currently suggested wording of 932 by replacing
"shall be ill-formed" by "is ill-formed"]
[If N3025 is accepted this bullet is applied identically in that paper as well.]
-1- Requires: D shall be default constructible, and that construction shall not throw an exception.
D shall not be a reference type or pointer type (diagnostic required)....
Remarks: If this constructor is instantiated with a pointer type or reference type for the template argument D, the program is ill-formed.
Change 20.9.10.2.1 [unique.ptr.single.ctor]/8 as indicated: [Note: This editorially improves the currently suggested wording of 932 by replacing
"shall be ill-formed" by "is ill-formed"]
[If N3025 is accepted this bullet is applied identically in that paper as well.]
unique_ptr(pointer p);...
Remarks: If this constructor is instantiated with a pointer type or reference type for the template argument D, the program is ill-formed.
Change 20.9.10.2.1 [unique.ptr.single.ctor]/13 as indicated:
[..] If d is an rvalue, it will bind to the second constructor of this pair and the program is ill-formed.That constructor shall emit a diagnostic.[Note: The diagnostic could be implemented using a static_assert which assures that D is not a reference type. — end note] Else d is an lvalue and will bind to the first constructor of this pair. [..]
Change 20.9.10.3 [unique.ptr.runtime]/1 as indicated:
A specialization for array types is provided with a slightly altered interface.
- Conversions among different types of unique_ptr<T[], D> or to or from the non-array forms of unique_ptr
are disallowed (diagnostic required)produce an ill-formed program.- ...
Change 20.10.3 [time.duration]/2-4 as indicated:
2 Requires: Rep shall be an arithmetic type or a class emulating an arithmetic type.
If a program instantiates duration with a duration type for the template argument Rep a diagnostic is required.3 Remarks: If duration is instantiated with a duration type for the template argument Rep, the program is ill-formed.
34RequiresRemarks: If Periodshall beis not a specialization of ratio,diagnostic requiredthe program is ill-formed.
45RequiresRemarks: If Period::numshall beis not positive,diagnostic requiredthe program is ill-formed.
Change 20.10.4 [time.point]/2 as indicated:
If Durationshall beis not an instance of duration, the program is ill-formed.Diagnostic required.
Section: 23.2.5 [unord.req] Status: Ready Submitter: Howard Hinnant Opened: 2009-08-24 Last modified: 2010-03-08
View other active issues in [unord.req].
View all other issues in [unord.req].
View all issues with Ready status.
Discussion:
Table 97 "Unordered associative container requirements" in 23.2.5 [unord.req] says:
Table 97 — Unordered associative container requirements (in addition to container) Expression Return type Assertion/note pre-/post-condition Complexity b.bucket(k) size_type Returns the index of the bucket in which elements with keys equivalent to k would be found, if any such element existed. Post: the return value shall be in the range [0, b.bucket_count()). Constant
What should b.bucket(k) return if b.bucket_count() == 0?
I believe allowing b.bucket_count() == 0 is important. It is a very reasonable post-condition of the default constructor, or of a moved-from container.
I can think of several reasonable results from b.bucket(k) when b.bucket_count() == 0:
[ 2009-08-26 Daniel adds: ]
A forth choice would be to add the pre-condition "b.bucket_count() != 0" and thus imply undefined behavior if this is violated.
[ Howard: I like this option too, added to the list. ]
Further on here my own favorite solution (rationale see below):
Suggested resolution:
[Rationale: I suggest to follow choice (1). The main reason is that all associative container functions which take a key argument, are basically free of pre-conditions and non-disrupting, therefore excluding choices (3) and (4). Option (2) seems a bit unexpected to me. It would be more natural, if several similar functions would exist which would also justify the existence of a symbolic constant like npos for this situation. The value 0 is both simple and consistent, it has exactly the same role as a past-the-end iterator value. A typical use-case is:
size_type pos = m.bucket(key); if (pos != m.bucket_count()) { ... } else { ... }— end Rationale]
- Change Table 97 in 23.2.5 [unord.req] as follows (Row b.bucket(k), Column "Assertion/..."):
Table 97 — Unordered associative container requirements (in addition to container) Expression Return type Assertion/note pre-/post-condition Complexity b.bucket(k) size_type Returns the index of the bucket in which elements with keys equivalent to k would be found, if any such element existed. Post: if b.bucket_count() != 0, the return value shall be in the range [0, b.bucket_count()), otherwise 0. Constant
[ 2010-01-25 Choice 4 put into proposed resolution section. ]
[ 2010-01-31 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change Table 97 in 23.2.5 [unord.req] as follows (Row b.bucket(k), Column "Assertion/..."):
Table 97 — Unordered associative container requirements (in addition to container) Expression Return type Assertion/note pre-/post-condition Complexity b.bucket(k) size_type Pre: b.bucket_count() > 0 Returns the index of the bucket in which elements with keys equivalent to k would be found, if any such element existed. Post: the return value shall be in the range [0, b.bucket_count()). Constant
Section: 23.3.5 [container.adaptors] Status: New Submitter: Pablo Halpern Opened: 2009-08-26 Last modified: 2009-09-30
View other active issues in [container.adaptors].
View all other issues in [container.adaptors].
View all issues with New status.
Discussion:
Under 23.3.5 [container.adaptors] of N2914 the member function of swap of queue and stack call:
swap(c, q.c);
But under 23.3.5 [container.adaptors] of N2723 these members are specified to call:
c.swap(q.c);
Neither draft specifies the semantics of member swap for priority_queue though it is declared.
Although the distinction between member swap and non-member swap is not important when these adaptors are adapting standard containers, it may be important for user-defined containers.
We (Pablo and Howard) feel that it is more likely for a user-defined container to support a namespace scope swap than a member swap, and therefore these adaptors should use the container's namespace scope swap.
[ 2009-09-30 Daniel adds: ]
The outcome of this issue should be considered with the outcome of 774 both in style and in content (e.g. 774 bullet 9 suggests to define the semantic of void priority_queue::swap(priority_queue&) in terms of the member swap of the container).
Proposed resolution:
[ Changes written with respect to N2723. ]
Change 23.3.5.1.1 [queue.defn]:
template <class T, class Container = deque<T> >
class queue {
...
void swap(queue&& q) { using std::swap;
c.swap(c, q.c); }
...
};
Change 23.3.5.2 [priority.queue]:
template <class T, class Container = vector<T>,
class Compare = less<typename Container::value_type> >
class priority_queue {
...
void swap(priority_queue&& q); { using std::swap;
swap(c, q.c);
swap(comp, q.comp); }
...
};
Change 23.3.5.3.1 [stack.defn]:
template <class T, class Container = deque<T> >
class stack {
...
void swap(stack&& s) { using std::swap;
c.swap(c, s.c); }
...
};
Section: 23.3.5 [container.adaptors] Status: Ready Submitter: Pablo Halpern Opened: 2009-08-26 Last modified: 2010-03-08
View other active issues in [container.adaptors].
View all other issues in [container.adaptors].
View all issues with Ready status.
Discussion:
queue has a constructor:
template <class Alloc> queue(queue&&, const Alloc&);
but it is missing a corresponding constructor:
template <class Alloc> queue(const queue&, const Alloc&);
The same is true of priority_queue, and stack. This "extended copy constructor" is needed for consistency and to ensure that the user of a container adaptor can always specify the allocator for his adaptor.
[ 2010-02-01 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
[ This resolution has been harmonized with the proposed resolution to issue 1194 ]
Change 23.3.5.1.1 [queue.defn], p1:
template <class T, class Container = deque<T> >
class queue {
public:
typedef typename Container::value_type value_type;
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference;
typedef typename Container::size_type size_type;
typedef Container container_type;
protected:
Container c;
public:
explicit queue(const Container&);
explicit queue(Container&& = Container());
queue(queue&& q);
template <class Alloc> explicit queue(const Alloc&);
template <class Alloc> queue(const Container&, const Alloc&);
template <class Alloc> queue(Container&&, const Alloc&);
template <class Alloc> queue(const queue&, const Alloc&);
template <class Alloc> queue(queue&&, const Alloc&);
queue& operator=(queue&& q);
bool empty() const { return c.empty(); }
...
};
To the new section [queue.cons], introduced in 1194, add:
template <class Alloc> queue(const queue& q, const Alloc& a);Effects: Initializes c with q.c as the first argument and a as the second argument.
Change 23.3.5.2 [priority.queue] as follows (I've an included an editorial change to move the poorly-placed move-assignment operator):
template <class T, class Container = vector<T>,
class Compare = less<typename Container::value_type> >
class priority_queue {
public:
typedef typename Container::value_type value_type;
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference;
typedef typename Container::size_type size_type;
typedef Container container_type;
protected:
Container c;
Compare comp;
public:
priority_queue(const Compare& x, const Container&);
explicit priority_queue(const Compare& x = Compare(), Container&& = Container());
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last,
const Compare& x, const Container&);
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last,
const Compare& x = Compare(), Container&& = Container());
priority_queue(priority_queue&&);
priority_queue& operator=(priority_queue&&);
template <class Alloc> explicit priority_queue(const Alloc&);
template <class Alloc> priority_queue(const Compare&, const Alloc&);
template <class Alloc> priority_queue(const Compare&,
const Container&, const Alloc&);
template <class Alloc> priority_queue(const Compare&,
Container&&, const Alloc&);
template <class Alloc> priority_queue(const priority_queue&, const Alloc&);
template <class Alloc> priority_queue(priority_queue&&, const Alloc&);
priority_queue& operator=(priority_queue&&);
...
};
Add to 23.3.5.2.1 [priqueue.cons]:
template <class Alloc> priority_queue(const priority_queue& q, const Alloc& a);Effects: Initializes c with q.c as the first argument and a as the second argument, and initializes comp with q.comp.
Change 23.3.5.3.1 [stack.defn]:
template <class T, class Container = deque<T> >
class stack {
public:
typedef typename Container::value_type value_type;
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference;
typedef typename Container::size_type size_type;
typedef Container container_type;
protected:
Container c;
public:
explicit stack(const Container&);
explicit stack(Container&& = Container());
stack(stack&& s);
template <class Alloc> explicit stack(const Alloc&);
template <class Alloc> stack(const Container&, const Alloc&);
template <class Alloc> stack(Container&&, const Alloc&);
template <class Alloc> stack(const stack&, const Alloc&);
template <class Alloc> stack(stack&&, const Alloc&);
stack& operator=(stack&& s);
bool empty() const { return c.empty(); }
...
};
To the new section [stack.cons], introduced in 1194, add:
template <class Alloc> stack(const stack& s, const Alloc& a);Effects: Initializes c with s.c as the first argument and a as the second argument.
Section: 21.2.2 [char.traits.typedefs] Status: New Submitter: Sean Hunt Opened: 2009-09-03 Last modified: 2009-10-28
View all other issues in [char.traits.typedefs].
View all issues with New status.
Discussion:
The footnote for int_type in 21.2.2 [char.traits.typedefs] says that
If eof() can be held in char_type then some iostreams implementations may give surprising results.
This implies that int_type should be a superset of char_type. However, the requirements for char16_t and char32_t define int_type to be equal to int_least16_t and int_least32_t respectively. int_least16_t is likely to be the same size as char_16_t, which may lead to surprising behavior, even if eof() is not a valid UTF-16 code unit. The standard should not prescribe surprising behavior, especially without saying what it is (it's apparently not undefined, just surprising). The same applies for 32-bit types.
I personally recommend that behavior be undefined if eof() is a member of char_type, and another type be chosen for int_type (my personal favorite has always been a struct {bool eof; char_type c;}). Alternatively, the exact results of such a situation should be defined, at least so far that I/O could be conducted on these types as long as the code units remain valid. Note that the argument that no one streams char16_t or char32_t is not really valid as it would be perfectly reasonable to use a basic_stringstream in conjunction with UTF character types.
[ 2009-10-28 Ganesh provides two possible resolutions and expresses a preference for the second: ]
Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with:
The member eof() shall returnan implementation-defined constant that cannot appear as a valid UTF-16 code unitUINT_LEAST16_MAX [Note: this value is guaranteed to be a permanently reserved UCS-2 code position if UINT_LEAST16_MAX == 0xFFFF and it's not a UCS-2 code position otherwise — end note].Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with:
The member eof() shall returnan implementation-defined constant that cannot appear as a Unicode code pointUINT_LEAST32_MAX [Note: this value is guaranteed to be a permanently reserved UCS-4 code position if UINT_LEAST32_MAX == 0xFFFFFFFF and it's not a UCS-4 code position otherwise — end note].In 21.2.3.2 [char.traits.specializations.char16_t], in the definition of char_traits<char16_t> replace the definition of nested typedef int_type with:
namespace std { template<> struct char_traits<char16_t> { typedef char16_t char_type; typedefuint_least16_tuint_fast16_t int_type; ...Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with:
The member eof() shall returnan implementation-defined constant that cannot appear as a valid UTF-16 code unitUINT_FAST16_MAX [Note: this value is guaranteed to be a permanently reserved UCS-2 code position if UINT_FAST16_MAX == 0xFFFF and it's not a UCS-2 code position otherwise — end note].In 21.2.3.3 [char.traits.specializations.char32_t], in the definition of char_traits<char32_t> replace the definition of nested typedef int_type with:
namespace std { template<> struct char_traits<char32_t> { typedef char32_t char_type; typedefuint_least32_tuint_fast32_t int_type; ...Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with:
The member eof() shall returnan implementation-defined constant that cannot appear as a Unicode code pointUINT_FAST32_MAX [Note: this value is guaranteed to be a permanently reserved UCS-4 code position if UINT_FAST32_MAX == 0xFFFFFFFF and it's not a UCS-4 code position otherwise — end note].
Proposed resolution:
Section: 17.6.3.9 [res.on.arguments] Status: Ready Submitter: Howard Hinnant Opened: 2009-09-12 Last modified: 2009-10-20
View all issues with Ready status.
Discussion:
When a library function binds an rvalue reference parameter to an argument, the library must be able to assume that the bound argument is a temporary, and not a moved-from lvalue. The reason for this is that the library function must be able to modify that argument without concern that such modifications will corrupt the logic of the calling code. For example:
template <class T, class A>
void
vector<T, A>::push_back(value_type&& v)
{
// This function should move from v, potentially modifying
// the object v is bound to.
}
If v is truly bound to a temporary, then push_back has the only reference to this temporary in the entire program. Thus any modifications will be invisible to the rest of the program.
If the client supplies std::move(x) to push_back, the onus is on the client to ensure that the value of x is no longer important to the logic of his program after this statement. I.e. the client is making a statement that push_back may treat x as a temporary.
The above statement is the very foundation upon which move semantics is based.
The standard is currently lacking a global statement to this effect. I propose the following addition to 17.6.3.9 [res.on.arguments]:
Each of the following statements applies to all arguments to functions defined in the C++ standard library, unless explicitly stated otherwise.
- If an argument to a function has an invalid value (such as a value outside the domain of the function, or a pointer invalid for its intended use), the behavior is undefined.
- If a function argument is described as being an array, the pointer actually passed to the function shall have a value such that all address computations and accesses to objects (that would be valid if the pointer did point to the first element of such an array) are in fact valid.
- If a function argument binds to an rvalue reference parameter, the C++ standard library may assume that this parameter is a unique reference to this argument. If the parameter is a generic parameter of the form T&&, and an lvalue of type A is bound, then the binding is considered to be to an lvalue reference (14.9.2.1 [temp.deduct.call]) and thus not covered by this clause. [Note: If a program casts an lvalue to an rvalue while passing that lvalue to a library function (e.g. move(x)), then the program is effectively asking the library to treat that lvalue as a temporary. The library is at liberty to optimize away aliasing checks which might be needed if the argument were an lvalue. — end note]
Such a global statement will eliminate the need for piecemeal statements such as 23.2.1 [container.requirements.general]/13:
An object bound to an rvalue reference parameter of a member function of a container shall not be an element of that container; no diagnostic required.
Additionally this clarifies that move assignment operators need not perform the traditional if (this != &rhs) test commonly found (and needed) in copy assignment operators.
[ 2009-09-13 Niels adds: ]
Note: This resolution supports the change of 27.9.1.3 [filebuf.assign]/1, proposed by LWG 900.
[ 2009 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Add a bullet to 17.6.3.9 [res.on.arguments]:
Each of the following statements applies to all arguments to functions defined in the C++ standard library, unless explicitly stated otherwise.
- If an argument to a function has an invalid value (such as a value outside the domain of the function, or a pointer invalid for its intended use), the behavior is undefined.
- If a function argument is described as being an array, the pointer actually passed to the function shall have a value such that all address computations and accesses to objects (that would be valid if the pointer did point to the first element of such an array) are in fact valid.
- If a function argument binds to an rvalue reference parameter, the C++ standard library may assume that this parameter is a unique reference to this argument. If the parameter is a generic parameter of the form T&&, and an lvalue of type A is bound, then the binding is considered to be to an lvalue reference (14.9.2.1 [temp.deduct.call]) and thus not covered by this clause. [Note: If a program casts an lvalue to an rvalue while passing that lvalue to a library function (e.g. move(x)), then the program is effectively asking the library to treat that lvalue as a temporary. The library is at liberty to optimize away aliasing checks which might be needed if the argument were an lvalue. — end note]
Delete 23.2.1 [container.requirements.general]/13:
An object bound to an rvalue reference parameter of a member function of a container shall not be an element of that container; no diagnostic required.
Section: 25 [algorithms] Status: Ready Submitter: Alisdair Meredith Opened: 2009-09-13 Last modified: 2010-03-08
View all other issues in [algorithms].
View all issues with Ready status.
Discussion:
There are a number of algorithms whose result might depend on the handling of an empty range. In some cases the result is not clear, while in others it would help readers to clearly mention the result rather than require some subtle intuition of the supplied wording.
25.2.1 [alg.all_of]
Returns: true if pred(*i) is true for every iterator i in the range [first,last), ...
What does this mean if the range is empty?
I believe that we intend this to be true and suggest a non-normative note to clarify:
Add to p1 25.2.1 [alg.all_of]:
[Note: Returns true if [first,last) is empty. — end note]
25.2.3 [alg.none_of]
Returns: true if pred(*i) is false for every iterator i in the range [first,last), ...
What does this mean if the range empty?
I believe that we intend this to be true and suggest a non-normative note to clarify:
Add to p1 25.2.3 [alg.none_of]:
[Note: Returns true if [first,last) is empty. — end note]
25.2.2 [alg.any_of]
The specification for an empty range is actually fairly clear in this case, but a note wouldn't hurt and would be consistent with proposals for all_of/none_of algorithms.
Add to p1 25.2.2 [alg.any_of]:
[Note: Returns false if [first,last) is empty. — end note]
25.2.6 [alg.find.end]
what does this mean if [first2,last2) is empty?
I believe the wording suggests the algorithm should return last1 in this case, but am not 100% sure. Is this in fact the correct result anyway? Surely an empty range should always match and the naive expected result would be first1?
My proposed wording is a note to clarify the current semantic:
Add to p2 25.2.6 [alg.find.end]:
[Note: Returns last1 if [first2,last2) is empty. — end note]
I would prefer a normative wording treating empty ranges specially, but do not believe we can change semantics at this point in the process, unless existing implementations actually yield this result:
Alternative wording: (NOT a note)
Add to p2 25.2.6 [alg.find.end]:
Returns first1 if [first2,last2) is empty.
25.2.7 [alg.find.first.of]
The phrasing seems precise when [first2, last2) is empty, but a small note to confirm the reader's understanding might still help.
Add to p2 25.2.7 [alg.find.first.of]
[Note: Returns last1 if [first2,last2) is empty. — end note]
25.2.12 [alg.search]
What is the expected result if [first2, last2) is empty?
I believe the wording suggests the algorithm should return last1 in this case, but am not 100% sure. Is this in fact the correct result anyway? Surely an empty range should always match and the naive expected result would be first1?
My proposed wording is a note to clarify the current semantic:
Add to p2 25.2.12 [alg.search]:
[Note: Returns last1 if [first2,last2) is empty. — end note]
Again, I would prefer a normative wording treating empty ranges specially, but do not believe we can change semantics at this point in the process, unless existing implementations actually yield this result:
Alternative wording: (NOT a note)
Add to p2 25.2.12 [alg.search]:
Returns first1 if [first2,last2) is empty.
25.3.13 [alg.partitions]
Is an empty range partitioned or not?
Proposed wording:
Add to p1 25.3.13 [alg.partitions]:
[Note: Returns true if [first,last) is empty. — end note]
25.4.5.1 [includes]
Returns: true if every element in the range [first2,last2) is contained in the range [first1,last1). ...
I really don't know what this means if [first2,last2) is empty. I could loosely guess that this implies empty ranges always match, and my proposed wording is to clarify exactly that:
Add to p1 25.4.5.1 [includes]:
[Note: Returns true if [first2,last2) is empty. — end note]
25.4.6.2 [pop.heap]
The effects clause is invalid if the range [first,last) is empty, unlike all the other heap alogorithms. The should be called out in the requirements.
Proposed wording:
Revise p2 25.4.6.2 [pop.heap]
Requires: The range [first,last) shall be a valid non-empty heap.
[Editorial] Reverse order of 25.4.6.2 [pop.heap] p1 and p2.
25.4.7 [alg.min.max]
minmax_element does not clearly specify behaviour for an empty range in the same way that min_element and max_element do.
Add to p31 25.4.7 [alg.min.max]:
Returns make_pair(first, first) if first == last.
25.4.8 [alg.lex.comparison]
The wording here seems quite clear, especially with the sample algorithm implementation. A note is recommended purely for consistency with the rest of these issue resolutions:
Add to p1 25.4.8 [alg.lex.comparison]:
[Note: An empty sequence is lexicographically less than any other non-empty sequence, but not to another empty sequence. — end note]
[ 2009-11-11 Howard changes Notes to Remarks and changed search to return first1 instead of last1. ]
[ 2009-11-11 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Add to 25.2.1 [alg.all_of]:
Remarks: Returns true if [first,last) is empty.
Add to 25.2.2 [alg.any_of]:
Remarks: Returns false if [first,last) is empty.
Add to 25.2.3 [alg.none_of]:
Remarks: Returns true if [first,last) is empty.
Add to 25.2.6 [alg.find.end]:
Remarks: Returns last1 if [first2,last2) is empty.
Add to 25.2.7 [alg.find.first.of]
Remarks: Returns last1 if [first2,last2) is empty.
Add to 25.2.12 [alg.search]:
Remarks: Returns first1 if [first2,last2) is empty.
Add to 25.3.13 [alg.partitions]:
Remarks: Returns true if [first,last) is empty.
Add to 25.4.5.1 [includes]:
Remarks: Returns true if [first2,last2) is empty.
Revise p2 25.4.6.2 [pop.heap]
Requires: The range [first,last) shall be a valid non-empty heap.
[Editorial]
Reverse order of 25.4.6.2 [pop.heap] p1 and p2.
Add to p35 25.4.7 [alg.min.max]:
template<class ForwardIterator, class Compare> pair<ForwardIterator, ForwardIterator> minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);Returns: make_pair(m, M), where m is the first iterator in [first,last) such that no iterator in the range refers to a smaller element, and where M is the last iterator in [first,last) such that no iterator in the range refers to a larger element. Returns make_pair(first, first) if first == last.
Add to 25.4.8 [alg.lex.comparison]:
Remarks: An empty sequence is lexicographically less than any other non-empty sequence, but not less than another empty sequence.
Section: 25.3.2 [alg.move] Status: New Submitter: Howard Hinnant Opened: 2009-09-13 Last modified: 2009-09-13
View all issues with New status.
Discussion:
25.3.2 [alg.move], p6 says:
template<class BidirectionalIterator1, class BidirectionalIterator2> BidirectionalIterator2 move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result);...
Requires: result shall not be in the range [first,last).
This is essentially an "off-by-one" error.
When result == last, which is allowed by this specification, then the range [first, last) is being move assigned into the range [first, last). The move (forward) algorithm doesn't allow self move assignment, and neither should move_backward. So last should be included in the range which result can not be in.
Conversely, when result == first, which is not allowed by this specification, then the range [first, last) is being move assigned into the range [first - (last-first), first). I.e. into a non-overlapping range. Therefore first should not be included in the range which result can not be in.
The same argument applies to copy_backward though copy assigning elements to themselves (result == last) should be harmless (though is disallowed by copy).
Proposed resolution:
Change 25.3.2 [alg.move], p6:
template<class BidirectionalIterator1, class BidirectionalIterator2> BidirectionalIterator2 move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result);...
Requires: result shall not be in the range
[(first,last]).
Change 25.3.1 [alg.copy], p13:
template<class BidirectionalIterator1, class BidirectionalIterator2> BidirectionalIterator2 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result);...
Requires: result shall not be in the range
[(first,last]).
Section: 23.3.4.4 [list.ops] Status: Open Submitter: Loïc Joly Opened: 2009-09-13 Last modified: 2010-02-10
View other active issues in [list.ops].
View all other issues in [list.ops].
View all issues with Open status.
Discussion:
It looks to me like some operations of std::list (sort, reverse, remove, unique & merge) do not specify the validity of iterators, pointers & references to elements of the list after those operations. Is it implied by some other text in the standard?
I believe sort & reverse do not invalidating anything, remove & unique only invalidates what refers to erased elements, merge does not invalidate anything (with the same precision as splice for elements who changed of container). Are those assumptions correct ?
[ 2009-12-08 Jonathan Wakely adds: ]
23.2.1 [container.requirements.general] paragraph 11 says iterators aren't invalidated unless specified, so I don't think it needs to be repeated on every function that doesn't invalidate iterators. list::unique says it "eliminates" elements, that should probably be "erases" because IMHO that term is used elsewhere and so makes it clearer that iterators to the erased elements are invalidated.
list::merge coud use the same wording as list::splice w.r.t iterators and references to moved elements.
Suggested resolution:
In 23.3.4.4 [list.ops] change paragraph 19
void unique(); template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);Effects:EliminatesErases all but the first element from every consecutive group ...Add to the end of paragraph 23
void merge(list<T,Allocator>&& x); template <class Compare> void merge(list<T,Allocator>&& x, Compare comp);...
Effects: ... that is, for every iterator i, in the range other than the first, the condition comp(*i, *(i - 1) will be false. 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.
[ 2009-12-12 Loïc adds wording. ]
[ 2010-02-10 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
[ 2010-02-10 Alisdair opens: ]
I object to the current resolution of #1207. I believe it is overly strict with regard to list end iterators, being the only mutating operations to require such stability.
More importantly, the same edits need to be applied to forward_list, which uses slightly different words to describe some of these operations so may require subtly different edits (not checked.)
I am prepared to pick up the end() iterator as a separate (new) issue, as part of the FCD ballot review (BSI might tell me 'no' first ;~) but I do want to see forward_list adjusted at the same time.
Proposed resolution:
Change 23.3.4.4 [list.ops], p15:
void remove(const T& value); template <class Predicate> void remove_if(Predicate pred);Effects: Erases all the elements in the list referred by a list iterator i for which the following conditions hold: *i == value, pred(*i) != false. Invalidates only the iterators and references to the erased elements.
Change 23.3.4.4 [list.ops], p19:
void unique(); template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);Effects:EliminatesErases all but the first element from every consecutive group of equal elements referred to by the iterator i in the range [first + 1,last) for which *i == *(i-1) (for the version of unique with no arguments) or pred(*i, *(i - 1)) (for the version of unique with a predicate argument) holds. Invalidates only the iterators and references to the erased elements.
Change 23.3.4.4 [list.ops], p23:
void merge(list<T,Allocator>&& x); template <class Compare> void merge(list<T,Allocator>&& x, Compare comp);Effects: If (&x == this) does nothing; otherwise, merges the two sorted ranges [begin(), end()) and [x.begin(), x.end()). The result is a range in which the elements will be sorted in non-decreasing order according to the ordering defined by comp; that is, for every iterator i, in the range other than the first, the condition comp(*i, *(i - 1) will be false. 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.
Change 23.3.4.4 [list.ops], p26:
void reverse();Effects: Reverses the order of the elements in the list. Does not affect the validity of iterators and references.
Change 23.3.4.4 [list.ops], p30:
void sort(); template <class Compare> void sort(Compare comp);Effects: Sorts the list according to the operator< or a Compare function object. Does not affect the validity of iterators and references.
Section: 26.6.2.1 [valarray.cons] Status: Ready Submitter: Howard Hinnant Opened: 2009-09-23 Last modified: 2010-03-08
View all other issues in [valarray.cons].
View all issues with Ready status.
Discussion:
26.6.2.1 [valarray.cons] says:
valarray(initializer_list<T> il);Effects: Same as valarray(il.begin(), il.end()).
But there is no valarray constructor taking two const T*.
[ 2009-10-29 Howard: ]
Moved to Tentatively Ready after 6 positive votes on c++std-lib.
Proposed resolution:
Change 26.6.2.1 [valarray.cons]:
valarray(initializer_list<T> il);Effects: Same as valarray(il.begin(), il.endsize()).
Section: 28.10.1 [re.results.const] Status: Ready Submitter: Stephan T. Lavavej Opened: 2009-09-15 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
In Working Draft N2914, match_results lacks a move constructor and move assignment operator. Because it owns dynamically allocated memory, it should be moveable.
As far as I can tell, this isn't tracked by an active issue yet; Library Issue 723 doesn't talk about match_results.
[ 2009-09-21 Daniel provided wording. ]
[ 2009-11-18: Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Add the following member declarations to 28.10 [re.results]/3:
// 28.10.1, construct/copy/destroy: explicit match_results(const Allocator& a = Allocator()); match_results(const match_results& m); match_results(match_results&& m); match_results& operator=(const match_results& m); match_results& operator=(match_results&& m); ~match_results();
Add the following new prototype descriptions to 28.10.1 [re.results.const] using the table numbering of N3000 (referring to the table titled "match_results assignment operator effects"):
match_results(const match_results& m);4 Effects: Constructs an object of class match_results, as a copy of m.match_results(match_results&& m);5 Effects: Move-constructs an object of class match_results from m satisfying the same postconditions as Table 131. Additionally the stored Allocator value is move constructed from m.get_allocator(). After the initialization of *this sets m to an unspecified but valid state.
6 Throws: Nothing if the allocator's move constructor throws nothing.
match_results& operator=(const match_results& m);7 Effects: Assigns m to *this. The postconditions of this function are indicated in Table 131.match_results& operator=(match_results&& m);8 Effects: Move-assigns m to *this. The postconditions of this function are indicated in Table 131. After the assignment, m is in a valid but unspecified state.
9 Throws: Nothing.
Section: 24.2 [iterator.requirements] Status: New Submitter: Alisdair Meredith Opened: 2009-09-18 Last modified: 2009-09-19
View other active issues in [iterator.requirements].
View all other issues in [iterator.requirements].
View all issues with New status.
Discussion:
p6 Iterator requirements 24.2 [iterator.requirements]
An iterator j is called reachable from an iterator i if and only if there is a finite sequence of applications of the expression ++i that makes i == j. If j is reachable from i, they refer to the same container.
A good example would be stream iterators, which do not refer to a container. Typically, the end iterator from a range of stream iterators will compare equal for many such ranges. I suggest striking the second sentence.
An alternative wording might be:
If j is reachable from i, and both i and j are dereferencable iterators, then they refer to the same range.
Proposed resolution:
Change 24.2 [iterator.requirements], p6:
An iterator j is called reachable from an iterator i if and only if there is a finite sequence of applications of the expression ++i that makes i == j.If j is reachable from i, they refer to the same container.
Section: 24.5.3.1 [move.iterator] Status: Open Submitter: Alisdair Meredith Opened: 2009-09-18 Last modified: 2009-10-26
View all other issues in [move.iterator].
View all issues with Open status.
Discussion:
I contend that while we can support both bidirectional and random access traversal, the category of a move iterator should never be better than input_iterator_tag.
The contentious point is that you cannot truly have a multipass property when values are moved from a range. This is contentious if you view a moved-from object as still holding a valid value within the range.
The second reason comes from the Forward Iterator requirements table:
Forward iterators 24.2.3 [forward.iterators]
Table 102 -- Forward iterator requirements
For expression *a the return type is: "T& if X is mutable, otherwise const T&"
There is a similar constraint on a->m.
There is no support for rvalue references, nor do I believe their should be. Again, opinions may vary but either this table or the definition of move_iterator need updating.
Note: this requirement probably need updating anyway if we wish to support proxy iterators but I am waiting to see a new working paper before filing that issue.
[ 2009-10 post-Santa Cruz: ]
Move to Open. Howard to put his rationale mentioned above into the issue as a note.
[ 2009-10-26 Howard adds: ]
vector::insert(pos, iter, iter) is significantly more effcient when iter is a random access iterator, as compared to when it is an input iterator.
When iter is an input iterator, the best algorithm is to append the inserted range to the end of the vector using push_back. This may involve several reallocations before the input range is exhausted. After the append, then one can use std::rotate to place the inserted range into the correct position in the vector.
But when iter is a random access iterator, the best algorithm is to first compute the size of the range to be inserted (last - first), do a buffer reallocation if necessary, scoot existing elements in the vector down to make the "hole", and then insert the new elements directly to their correct place.
The insert-with-random-access-iterators algorithm is considerably more efficient than the insert-with-input-iterators algorithmNow consider:
vector<A> v; // ... build up a large vector of A ... vector<A> temp; // ... build up a large temporary vector of A to later be inserted ... typedef move_iterator<vector<A>::iterator> MI; // Now insert the temporary elements: v.insert(v.begin() + N, MI(temp.begin()), MI(temp.end()));A major motivation for using move_iterator in the above example is the expectation that A is cheap to move but expensive to copy. I.e. the customer is looking for high performance. If we allow vector::insert to subtract two MI's to get the distance between them, the customer enjoys substantially better performance, compared to if we say that vector::insert can not subtract two MI's.
I can find no rationale for not giving this performance boost to our customers. Therefore I am strongly against restricting move_iterator to the input_iterator_tag category.
I believe that the requirement that forward iterators have a dereference that returns an lvalue reference to cause unacceptable pessimization. For example vector<bool>::iterator also does not return a bool& on dereference. Yet I am not aware of a single vendor that is willing to ship vector<bool>::iterator as an input iterator. Everyone classifies it as a random access iterator. Not only does this not cause any problems, it prevents significant performance problems.
Proposed resolution:
Class template move_iterator 24.5.3.1 [move.iterator]
namespace std {
template <class Iterator>
class move_iterator {
public:
...
typedef typename iterator_traits<Iterator>::iterator_category input_iterator_tag iterator_category;
Section: 24.2 [iterator.requirements] Status: New Submitter: Alisdair Meredith Opened: 2009-09-18 Last modified: 2009-09-19
View other active issues in [iterator.requirements].
View all other issues in [iterator.requirements].
View all issues with New status.
Discussion:
Forward iterator and bidirectional iterator place different requirements on the result of post-increment/decrement operator. The same form should be used in each case.
Merging row from:
Table 102 -- Forward iterator requirements
Table 103 -- Bidirectional iterator requirements
r++ : convertible to const X&
r-- : convertible to const X&
*r++ : T& if X is mutable, otherwise const T&
*r-- : convertible to T
Proposed resolution:
Section: 24.2 [iterator.requirements] Status: New Submitter: Daniel Krügler Opened: 2009-09-19 Last modified: 2009-09-19
View other active issues in [iterator.requirements].
View all other issues in [iterator.requirements].
View all issues with New status.
Discussion:
The terms valid iterator and singular aren't properly defined. The fuzziness of those terms became even worse after the resolution of 208 (including further updates by 278). In 24.2 [iterator.requirements] as of N2723 the standard says now:
5 - These values are called past-the-end values. Values of an iterator i for which the expression *i is defined are called dereferenceable. The library never assumes that past-the-end values are dereferenceable. Iterators can also have singular values that are not associated with any container. [...] Results of most expressions are undefined for singular values; the only exceptions are destroying an iterator that holds a singular value and the assignment of a non-singular value to an iterator that holds a singular value. [...] Dereferenceable values are always non-singular.
10 - An invalid iterator is an iterator that may be singular.
First, issue 208 intentionally removed the earlier constraint that past-the-end values are always non-singular. The reason for this was to support null pointers as past-the-end iterators of e.g. empty sequences. But there seem to exist different views on what a singular (iterator) value is. E.g. according to the SGI definition a null pointer is not a singular value:
Dereferenceable iterators are always nonsingular, but the converse is not true. For example, a null pointer is nonsingular (there are well defined operations involving null pointers) even thought it is not dereferenceable.
and proceeds:
An iterator is valid if it is dereferenceable or past-the-end.
Even if the standard prefers a different meaning of singular here, the change was incomplete, because by restricting feasible expressions of singular iterators to destruction and assignment isn't sufficient for a past-the-end iterator: Of-course it must still be equality-comparable and in general be a readable value.
Second, the standard doesn't clearly say whether a past-the-end value is a valid iterator or not. E.g. 20.9.9 [specialized.algorithms]/1 says:
In all of the following algorithms, the formal template parameter ForwardIterator is required to satisfy the requirements of a forward iterator (24.1.3) [..], and is required to have the property that no exceptions are thrown from [..], or dereference of valid iterators.
The standard should make better clear what "singular pointer" and "valid iterator" means. The fact that the meaning of a valid value has a core language meaning doesn't imply that for an iterator concept the term "valid iterator" has the same meaning.
Let me add a final example: In X [allocator.concepts.members] of N2914 we find:
pointer X::allocate(size_type n);11 Returns: a pointer to the allocated memory. [Note: if n == 0, the return value is unspecified. —end note][..]
void X::deallocate(pointer p, size_type n);Preconditions: p shall be a non-singular pointer value obtained from a call to allocate() on this allocator or one that compares equal to it.
If singular pointer value would include null pointers this make the preconditions unclear if the pointer value is a result of allocate(0): Since the return value is unspecified, it could be a null pointer. Does that mean that programmers need to check the pointer value for a null value before calling deallocate?
Proposed resolution:
Section: 23.2.4 [associative.reqmts] Status: New Submitter: Daniel Krügler Opened: 2009-09-20 Last modified: 2009-09-20
View other active issues in [associative.reqmts].
View all other issues in [associative.reqmts].
View all issues with New status.
Discussion:
Scott Meyers' mentions on a recent posting on c.s.c++ some arguments that point to an incomplete resolution of 103 and to an inconsistency of requirements on keys in ordered and unordered associative containers:
1) 103 introduced the term immutable without defining it in a unique manner in 23.2.4 [associative.reqmts]/5:
[..] Keys in an associative container are immutable.According to conventional dictionaries immutable is an unconditional way of saying that something cannot be changed. So without any further explicit allowance a user always runs into undefined behavior if (s)he attempts to modify such a key. IMO this was not the intend of the committee to resolve 103 in that way because the comments suggest an interpretation that should give any user the freedom to modify the key in an explicit way provided it would not affect the sort order in that container.
2) Another observation was that surprisingly no similar 'safety guards' exists against unintentional key changes for the unordered associative containers, specifically there is no such requirement as in 23.2.4 [associative.reqmts]/6 that "both iterator and const_iterator are constant iterators". But the need for such protection against unintentional changes as well as the constraints in which manner any explicit changes may be performed are both missing and necessary, because such changes could potentially change the equivalence of keys that is measured by the hasher and key_equal.
I suggest to fix the unconditional wording involved with "immutable keys" by at least adding a hint for the reader that users may perform such changes in an explicit manner and to perform similar wording changes as 103 did for the ordered associative containers also for the unordered containers.
Proposed resolution:
Section: 23.3.4.4 [list.ops] Status: New Submitter: Pablo Halpern Opened: 2009-09-24 Last modified: 2009-09-24
View other active issues in [list.ops].
View all other issues in [list.ops].
View all issues with New status.
Discussion:
In Bellevue (I think), we passed N2525, which, among other things, specifies that the behavior of list::splice is undefined if the allocators of the two lists being spliced do not compare equal. The same rationale should apply to list::merge. The intent of list::merge (AFAIK) is to move nodes from one sorted list into another sorted list without copying the elements. This is possible only if the allocators compare equal.
Proposed resolution:
Relative to the August 2009 WP, N2857, change 23.3.4.4 [list.ops], paragraphs 22-25 as follows:
void merge(list&& x); template <class Compare> void merge(list&& x, Compare comp);Requires: both the list and the argument list shall be sorted according to operator< or comp.
Effects: If (&x == this) does nothing; otherwise, merges the two sorted ranges [begin(), end()) and [x.begin(), x.end()). The result is a range in which the elements will be sorted in non-decreasing order according to the ordering defined by comp; that is, for every iterator i, in the range other than the first, the condition comp(*i, *(i - 1)) will be false.
Remarks: Stable. If (&x != this) the range [x.begin(), x.end()) is empty after the merge. No elements are copied by this operation. The behavior is undefined if this->get_allocator() != x.get_allocator().
Complexity: At most size() + x.size() - 1 applications of comp if (&x != this); otherwise, no applications of comp are performed. If an exception is thrown other than by a comparison there are no effects.
Section: 18.8.6 [except.nested] Status: Ready Submitter: Pete Becker Opened: 2009-09-25 Last modified: 2009-10-20
View other active issues in [except.nested].
View all other issues in [except.nested].
View all issues with Ready status.
Discussion:
LWG 1066 adds [[noreturn]] to a bunch of things. It doesn't add it to rethrow_nested(), which seems like an obvious candidate. I've made the changes indicated in the issue, and haven't changed rethrow_nested().
[ 2009 Santa Cruz: ]
Move to Ready.
Proposed resolution:
Add [[noreturn]] to rethrow_nested() in 18.8.6 [except.nested].
Section: 30.4.1 [thread.mutex.requirements] Status: Ready Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2010-03-08
View other active issues in [thread.mutex.requirements].
View all other issues in [thread.mutex.requirements].
View all issues with Ready status.
Discussion:
If an object *o contains a mutex mu and a correctly-maintained reference count c, is the following code safe?
o->mu.lock();
bool del = (--(o->c) == 0);
o->mu.unlock();
if (del) { delete o; }
If the implementation of mutex::unlock() can touch the mutex's memory after the moment it becomes free, this wouldn't be safe, and "Construction and destruction of an object of a Mutex type need not be thread-safe" 30.4.1 [thread.mutex.requirements] may imply that it's not safe. Still, it's useful to allow mutexes to guard reference counts, and if it's not allowed, users are likely to write bugs.
[ 2009-11-18: Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Add a new paragraph after 30.4.1.1 [thread.mutex.class] p1:
1 The class mutex provides a non-recursive mutex ...
[Note: After a thread A has called unlock(), releasing the mutex, it is possible for another thread B to lock the same mutex, observe that it is no longer in use, unlock and destroy it, before thread A appears to have returned from its unlock call. Implementations are required to handle such scenarios correctly, as long as thread A doesn't access the mutex after the unlock call returns. These cases typically occur when a reference-counted object contains a mutex that is used to protect the reference count. — end note]
Section: 30.5 [thread.condition] Status: Ready Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2010-03-08
View other active issues in [thread.condition].
View all other issues in [thread.condition].
View all issues with Ready status.
Discussion:
"Class condition_variable provides a condition variable that can only wait on an object of type unique_lock" should say "...object of type unique_lock<mutex>"
[ 2009-11-06 Howard adds: ]
Moved to Tentatively Ready after 5 positive votes on c++std-lib.
Proposed resolution:
Change 30.5 [thread.condition], p1:
Condition variables provide synchronization primitives used to block a thread until notified by some other thread that some condition is met or until a system time is reached. Class condition_variable provides a condition variable that can only wait on an object of type unique_lock<mutex>, allowing maximum efficiency on some platforms. Class condition_variable_any provides a general condition variable that can wait on objects of user-supplied lock types.
Section: 30.5.1 [thread.condition.condvar] Status: Ready Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2010-03-08
View other active issues in [thread.condition.condvar].
View all other issues in [thread.condition.condvar].
View all issues with Ready status.
Discussion:
30.5.1 [thread.condition.condvar] says:
~condition_variable();Precondition: There shall be no thread blocked on *this. [Note: That is, all threads shall have been notified; they may subsequently block on the lock specified in the wait. Beware that destroying a condition_variable object while the corresponding predicate is false is likely to lead to undefined behavior. — end note]
The text hasn't introduced the notion of a "corresponding predicate" yet.
[ 2010-02-11 Anthony provided wording. ]
[ 2010-02-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Modify 30.5.1 [thread.condition.condvar]p4 as follows:
~condition_variable();4 Precondition: There shall be no thread blocked on *this. [Note: That is, all threads shall have been notified; they may subsequently block on the lock specified in the wait.Beware that destroying a condition_variable object while the corresponding predicate is false is likely to lead to undefined behavior.The user must take care to ensure that no threads wait on *this once the destructor has been started, especially when the waiting threads are calling the wait functions in a loop or using the overloads of wait, wait_for or wait_until that take a predicate. — end note]
Section: 30.5 [thread.condition] Status: Ready Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2010-03-08
View other active issues in [thread.condition].
View all other issues in [thread.condition].
View all issues with Ready status.
Discussion:
30.5.1 [thread.condition.condvar] says:
void wait(unique_lock<mutex>& lock);...
Effects:
- ...
- If the function exits via an exception, lock.unlock() shall be called prior to exiting the function scope.
Should that be lock.lock()?
[ 2009-11-17 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change 30.5.1 [thread.condition.condvar] p10:
void wait(unique_lock<mutex>& lock);...
Effects:
- ...
- If the function exits via an exception, lock.
unlock() shall be called prior to exiting the function scope.
And make a similar change in p16, and in 30.5.2 [thread.condition.condvarany], p8 and p13.
Section: 20.8.4 [func.ret] Status: New Submitter: Sebastian Gesemann Opened: 2009-10-05 Last modified: 2010-02-14
View other active issues in [func.ret].
View all other issues in [func.ret].
View all issues with New status.
Discussion:
I think the text about std::result_of could be a little more precise. Quoting from N2960...
20.8.4 [func.ret] Function object return types
template<class> class result_of; template<class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)> { public: typedef see below type; };Given an rvalue fn of type Fn and values t1, t2, ..., tN of types T1, T2, ... TN in ArgTypes respectivly, the type member is the result type of the expression fn(t1,t2,...,tN). the values ti are lvalues when the corresponding type Ti is an lvalue-reference type, and rvalues otherwise.
This text doesn't seem to consider lvalue reference types for Fn. Also, it's not clear whether this class template can be used for "SFINAE" like std::enable_if. Example:
template<typename Fn, typename... Args>
typename std::result_of<Fn(Args...)>::type
apply(Fn && fn, Args && ...args)
{
// Fn may be an lvalue reference, too
return std::forward<Fn>(fn)(std::forward<Args>(args)...);
}
Either std::result_of<...> can be instantiated and simply may not have a typedef "type" (-->SFINAE) or instantiating the class template for some type combinations will be a "hard" compile-time error.
[ 2010-02-14 Daniel adds: ]
This issue should be considered resolved by 1255 and 1270. The wish to change result_of into a compiler-support trait was beyond the actual intention of the submitter Sebastian.
Proposed resolution:
[ These changes will require compiler support ]
Change 20.8.4 [func.ret]:
template<class> class result_of; // undefined template<class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)> { public:typedefsee belowtype;};
Given an rvalue fn of type Fn and values t1, t2, ..., tN of types T1, T2, ... TN in ArgTypes respectivly, the type member is the result type of the expression fn(t1,t2,...,tN). the values ti are lvalues when the corresponding type Ti is an lvalue-reference type, and rvalues otherwise.The class template result_of shall meet the requirements of a TransformationTrait: Given the types Fn, T1, T2, ..., TN every template specialization result_of<Fn(T1,T2,...,TN)> shall define the member typedef type equivalent to decltype(RE) if and only if the expression RE
value<Fn>() ( value<T1>(), value<T2>(), ... value<TN>() )would be well-formed. Otherwise, there shall be no member typedef type defined.
[ The value<> helper function is a utility Daniel Krügler proposed in N2958. ]
Section: 20.5 [template.bitset] Status: Ready Submitter: Bo Persson Opened: 2009-10-05 Last modified: 2009-10-26
View other active issues in [template.bitset].
View all other issues in [template.bitset].
View all issues with Ready status.
Discussion:
The resolutions to some library defect reports, like 1178 requires that #includes in each synopsis should be taken literally. This means that the <bitset> header now must include <stdexcept>, even though none of the exceptions are mentioned in the <bitset> header.
Many other classes are required to throw exceptions like invalid_argument and out_of_range, without explicitly including <stdexcept> in their synopsis. It is totally possible for implementations to throw the needed exceptions from utility functions, whose implementations are not visible in the headers.
I propose that <stdexcept> is removed from the <bitset> header.
[ 2009-10 Santa Cruz: ]
Moved to Ready.
Proposed resolution:
Change 20.5 [template.bitset]:
#include <cstddef> // for size_t #include <string>#include <stdexcept> // for invalid_argument,// out_of_range, overflow_error#include <iosfwd> // for istream, ostream namespace std { ...
Section: 20.7.4.3 [meta.unary.prop] Status: Open Submitter: Alisdair Meredith Opened: 2009-10-07 Last modified: 2009-10-26
View other active issues in [meta.unary.prop].
View all other issues in [meta.unary.prop].
View all issues with Open status.
Discussion:
According to p1 20.7.2 [meta.type.synop]:
The behavior of a program that adds specializations for any of the class templates defined in this subclause is undefined unless otherwise specified.
I believe we should 'otherwise specify' for the nothrow traits, are these are exactly the use cases where the end user actually has more information than the compiler.
[ 2009-10 Santa Cruz: ]
Moved to Open. Definitely need to give the users the ability to ensure that the traits give the right answers. Unsure we want to give them the ability to say this in more than one way. Believes the noexcept proposal already gives this.
Proposed resolution:
Add the following comment:
user specialization permitted to derive from std::true_type when the operation is known not to throw.
to the following traits in 20.7.4.3 [meta.unary.prop] Table 43 Type property predicates.
[ This may require a new Comments column ]
has_nothrow_default_constructor has_nothrow_copy_constructor has_nothrow_assign
Section: 20.9.11.3.5 [util.smartptr.weak.obs] Status: Ready Submitter: Daniel Krügler Opened: 2009-10-10 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
The n2637 paper suggested several updates of the ordering semantics of shared_ptr and weak_ptr, among those the explicit comparison operators of weak_ptr were removed/deleted, instead a corresponding functor owner_less was added. The problem is that n2637 did not clearly enough specify, how the previous wording parts describing the comparison semantics of weak_ptr should be removed.
[ 2009-11-06 Howard adds: ]
Moved to Tentatively Ready after 5 positive votes on c++std-lib.
Proposed resolution:
Change 20.9.11.3 [util.smartptr.weak]/2 as described, the intention is to fix the now no longer valid requirement that weak_ptr is LessComparable [Note the deleted comma]:
Specializations of weak_ptr shall be CopyConstructible,and CopyAssignable,and LessThanComparable,allowing their use in standard containers.
In 20.9.11.3.5 [util.smartptr.weak.obs] remove the paragraphs 9-11 including prototype:
template<class T, class U> bool operator<(const weak_ptr<T>& a, const weak_ptr<U>& b);
Returns: an unspecified value such that
operator< is a strict weak ordering as described in 25.4;under the equivalence relation defined by operator<, !(a < b) && !(b < a), two weak_ptr instances are equivalent if and only if they share ownership or are both empty.
Throws: nothing.
[Note: Allows weak_ptr objects to be used as keys in associative containers. — end note]
Section: 23.2.3 [sequence.reqmts] Status: New Submitter: Matt Austern Opened: 2009-10-09 Last modified: 2009-10-13
View all other issues in [sequence.reqmts].
View all issues with New status.
Discussion:
On g++ 4.2.4 (x86_64-linux-gnu), the following file gives a compile error:
#include <vector>
void foo() { std::vector<int*> v(500l, NULL); }
Is this supposed to work?
The issue: if NULL happens to be defined as 0l, this is an invocation of the constructor with two arguments of the same integral type. 23.2.3 [sequence.reqmts]/11 says that this will behave as if the the overloaded constructor
X(size_type, const value_type& = value_type(), const allocator_type& = allocator_type())
were called instead, with the arguments static_cast<size_type>(first), last and alloc, respectively. However, it does not say whether this actually means invoking that constructor with the exact textual form of the arguments as supplied by the user, or whether the standard permits an implementation to invoke that constructor with variables of the same type and value as what the user passed in. In most cases this is a distinction without a difference. In this particular case it does make a difference, since one of those things is a null pointer constant and the other is not.
Note that an implementation based on forwarding functions will use the latter interpretation.
Proposed resolution:
Section: 19.5 [syserr] Status: Ready Submitter: Daniel Krügler Opened: 2009-10-14 Last modified: 2009-10-26
View all other issues in [syserr].
View all issues with Ready status.
Discussion:
I'm just reflecting on the now SFINAE-constrained constructors and assignment operators of error_code and error_condition:
These are the only library components that are pro-actively announcing that they are using std::enable_if as constraining tool, which has IMO several disadvantages:
With the availability of template default arguments and decltype, using enable_if in C++0x standard library, seems unnecessary restricting implementation freedom. E.g. there should be not need for a useless specification of a dummy default function argument, which only confuses the reader. A more reasonable implementation could e.g. be
template <class ErrorCodeEnum class = typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type> error_code(ErrorCodeEnum e);
As currently specified, the function signatures are so unreadable, that errors quite easily happen, see e.g. 1229.
We have a lot of constrained functions in other places, that now have a standard phrase that is easily understandable:
Remarks: This constructor/function shall participate in overload resolution if and only if X.
where X describes the condition. Why should these components deviate?
If enable_if would not be explicitly specified, the standard library is much better prepared for the future. It would also be possible, that libraries with partial support for not-yet-standard-concepts could provide a much better diagnostic as is possible with enable_if. This again would allow for experimental concept implementations in the wild, which as a result would make concept standardization a much more natural thing, similar to the way as templates were standardized in C++.
In summary: I consider it as a library defect that error_code and error_condition explicitly require a dependency to enable_if and do limit implementation freedom and I volunteer to prepare a corresponding resolution.
[ 2009-10-18 Beman adds: ]
I support this proposed resolution, and thank Daniel for writing it up.
[ 2009-10 Santa Cruz: ]
Moved to Ready.
Proposed resolution:
[ Should this resolution be accepted, I recommend to resolve 1229 as NAD ]
In 19.5.2.1 [syserr.errcode.overview]/1, class error_code, change as indicated:
// 19.5.2.2 constructors: error_code(); error_code(int val, const error_category& cat); template <class ErrorCodeEnum> error_code(ErrorCodeEnum e, typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type * = 0); // 19.5.2.3 modifiers: void assign(int val, const error_category& cat); template <class ErrorCodeEnum>typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::typeerror_code& operator=(ErrorCodeEnum e); void clear();
Change 19.5.2.2 [syserr.errcode.constructors] around the prototype before p. 7:
template <class ErrorCodeEnum> error_code(ErrorCodeEnum e, typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type * = 0);Remarks: This constructor shall not participate in overload resolution, unless is_error_code_enum<ErrorCodeEnum>::value == true.
Change 19.5.2.3 [syserr.errcode.modifiers] around the prototype before p. 3:
template <class ErrorCodeEnum>typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::typeerror_code& operator=(ErrorCodeEnum e);Remarks: This operator shall not participate in overload resolution, unless is_error_code_enum<ErrorCodeEnum>::value == true.
In 19.5.3.1 [syserr.errcondition.overview]/1, class error_condition, change as indicated:
// 19.5.3.2 constructors: error_condition(); error_condition(int val, const error_category& cat); template <class ErrorConditionEnum> error_condition(ErrorConditionEnum e, typename enable_if<is_error_condition_enum<ErrorConditionEnum>::type* = 0); // 19.5.3.3 modifiers: void assign(int val, const error_category& cat); template<typenameclass ErrorConditionEnum>typename enable_if<is_error_condition_enum<ErrorConditionEnum>, error_code>::typeerror_condition & operator=( ErrorConditionEnum e ); void clear();
Change 19.5.3.2 [syserr.errcondition.constructors] around the prototype before p. 7:
template <class ErrorConditionEnum> error_condition(ErrorConditionEnum e, typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::type* = 0);Remarks: This constructor shall not participate in overload resolution, unless is_error_condition_enum<ErrorConditionEnum>::value == true.
Change 19.5.3.3 [syserr.errcondition.modifiers] around the prototype before p. 3:
template <class ErrorConditionEnum>typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::typeerror_condition& operator=(ErrorConditionEnum e);Remarks: This operator shall not participate in overload resolution, unless is_error_condition_enum<ErrorConditionEnum>::value == true.
Postcondition: *this == make_error_condition(e).
Returns: *this
Section: 20.8.15.2 [func.wrap.func] Status: New Submitter: Daniel Krügler Opened: 2009-10-18 Last modified: 2009-10-19
View all other issues in [func.wrap.func].
View all issues with New status.
Discussion:
The class template std::function contains the following member declarations:
// deleted overloads close possible hole in the type system template<class R2, class... ArgTypes2> bool operator==(const function<R2(ArgTypes2...)>&) = delete; template<class R2, class... ArgTypes2> bool operator!=(const function<R2(ArgTypes2...)>&) = delete;
The leading comment here is part of the history of std::function, which was introduced with N1402. During that time no explicit conversion functions existed, and the "safe-bool" idiom (based on pointers-to-member) was a popular technique. The only disadvantage of this idiom was that given two objects f1 and f2 of type std::function the expression
f1 == f2;
was well-formed, just because the built-in operator== for pointer to member was considered after a single user-defined conversion. To fix this, an overload set of undefined comparison functions was added, such that overload resolution would prefer those ending up in a linkage error. The new language facility of deleted functions provided a much better diagnostic mechanism to fix this issue.
The central point of this issue is, that with the replacement of the safe-bool idiom by explicit conversion to bool the original "hole in the type system" does no longer exist and therefore the comment is wrong and the superfluous function definitions should be removed as well. An explicit conversion function is considered in direct-initialization situations only, which indirectly contain the so-called "contextual conversion to bool" (4 [conv]/3). These conversions are not considered for == or != as defined by the core language.
Proposed resolution:
In 20.8.15.2 [func.wrap.func]/1, class function change as indicated:
// 20.7.15.2.3, function capacity: explicit operator bool() const;// deleted overloads close possible hole in the type systemtemplate<class R2, class... ArgTypes2>bool operator==(const function<R2(ArgTypes2...)>&) = delete;template<class R2, class... ArgTypes2>bool operator!=(const function<R2(ArgTypes2...)>&) = delete;
Section: 25.3.9 [alg.unique] Status: Ready Submitter: Daniel Krügler Opened: 2009-10-17 Last modified: 2010-03-08
View all other issues in [alg.unique].
View all issues with Ready status.
Discussion:
A lot of fixes were silently applied during concept-time and we should not lose them again. The Requires clause of 25.3.9 [alg.unique]/5 doesn't mention that == and the predicate need to satisfy an EquivalenceRelation, as it is correctly said for unique. This was intentionally fixed during conceptification, were we had:
template<InputIterator InIter, class OutIter>
requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type>
&& EqualityComparable<InIter::value_type>
&& HasAssign<InIter::value_type, InIter::reference>
&& Constructible<InIter::value_type, InIter::reference>
OutIter unique_copy(InIter first, InIter last, OutIter result);
template<InputIterator InIter, class OutIter,
EquivalenceRelation<auto, InIter::value_type> Pred>
requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type>
&& HasAssign<InIter::value_type, InIter::reference>
&& Constructible<InIter::value_type, InIter::reference>
&& CopyConstructible<Pred>
OutIter unique_copy(InIter first, InIter last, OutIter result, Pred pred);
Note that EqualityComparable implied an equivalence relation.
[ N.B. adjacent_find was also specified to require EquivalenceRelation, but that was considered as a defect in concepts, see 1000 ]
[ 2009-10-31 Howard adds: ]
Moved to Tentatively Ready after 5 positive votes on c++std-lib.
Proposed resolution:
Change 25.3.9 [alg.unique]/5 as indicated:
template<class InputIterator, class OutputIterator> OutputIterator unique_copy(InputIterator first, InputIterator last, OutputIterator result); template<class InputIterator, class OutputIterator, class BinaryPredicate> OutputIterator unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred);Requires: The comparison function shall be an equivalence relation. The ranges [first,last) and [result,result+(last-first)) shall not overlap. The expression *result = *first shall be valid. If neither InputIterator nor OutputIterator meets the requirements of forward iterator then the value type of InputIterator shall be CopyConstructible (34) and CopyAssignable (table 36). Otherwise CopyConstructible is not required.
Section: 30.6 [futures] Status: New Submitter: Detlef Vollmann Opened: 2009-10-22 Last modified: 2009-10-23
View other active issues in [futures].
View all other issues in [futures].
View all issues with New status.
Discussion:
With the addition of async(), a future might be associated with a function that is not running in a different thread but is stored to by run synchronously on the get() call. It's not clear what the wait() functions should do in this case.
Suggested resolution:
Throw an exception.
Proposed resolution:
Section: 20.8.16 [unord.hash] Status: Ready Submitter: Paolo Carlini Opened: 2009-10-22 Last modified: 2010-03-08
View other active issues in [unord.hash].
View all other issues in [unord.hash].
View all issues with Ready status.
Discussion:
In 20.8.16 [unord.hash], operator() is specified as taking the argument by value. Moreover, it is said that operator() shall not throw exceptions.
However, for the specializations for class types, like string, wstring, etc, the former requirement seems suboptimal from the performance point of view (a specific PR has been filed about this in the GCC Bugzilla) and, together with the latter requirement, hard if not impossible to fulfill. It looks like pass by const reference should be allowed in such cases.
[ 2009-11-18: Ganesh updates wording. ]
I've removed the list of types for which hash shall be instantiated because it's already explicit in the synopsis of header <functional> in 20.8 [function.objects]/2.
[ 2009-11-18: Original wording here: ]
Add to 20.8.16 [unord.hash]/2:
namespace std { template <class T> struct hash : public std::unary_function<T, std::size_t> { std::size_t operator()(T val) const; }; }The return value of operator() is unspecified, except that equal arguments shall yield the same result. operator() shall not throw exceptions. It is also unspecified whether operator() of std::hash specializations for class types takes its argument by value or const reference.
[ 2009-11-19 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
[ 2009-11-24 Ville Opens: ]
I have received community requests to ask for this issue to be reopened. Some users feel that mandating the inheritance is overly constraining.
[ 2010-01-31 Alisdair: related to 978 and 1182. ]
[ 2010-02-07 Proposed resolution updated by Beman, Daniel and Ganesh. ]
[ 2010-02-09 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Insert a new subclause either before or after the current 20.2.2 [allocator.requirements]:
Hash Requirements [hash.requirements]
This subclause defines the named requirement Hash, used in several clauses of the C++ standard library. A type H meets the Hash requirement if
it is a function object type (20.8 [function.objects]).
it satisfies the requirements of CopyConstructible, and Destructible (20.2.1 [utility.arg.requirements]),
the expressions shown in the following table are valid and have the indicated semantics, and
it satisfies all other requirements of this subclause.
Given Key is an argument type for function objects of type H, in the table below h is a value of type (possibly const) H, u is an lvalue of type Key, and k is a value of a type convertible to (possibly const) Key:
Table ? - Hash requirements
Expression Return type Requirement h(k) size_t Shall not throw exceptions. The value returned shall depend only on the argument k. [Note: Thus all evaluations of the expression h(k) with the same value for k yield the same result. — end note] [Note: For t1 and t2 of different values, the probability that h(t1) and h(t2) compare equal should be very small, approaching (1.0/numeric_limits<size_t>::max()). — end note] Comment (not to go in WP): The wording for the second note is based on a similar note in 22.4.4.1.2 [locale.collate.virtuals]/3 h(u) size_t Shall not modify u.
Change 20.8.16 [unord.hash] as indicated:
1 The unordered associative containers defined in Clause 23.5 [unord] use specializations of the class template hash as the default hash function. For all object types T for which there exists a specialization hash<T>, the instantiation hash<T> shall:
- satisfy the Hash requirements([hash.requirements]), with T as the function call argument type, the DefaultConstructible requirements ([defaultconstructible]), the CopyAssignable requirements ([copyassignable]), and the Swappable requirements ([swappable]),
- provide two nested types result_type and argument_type which shall be synonyms for size_t and T, respectively,
- satisfy the requirement that if k1 == k2 is true, h(k1) == h(k2) is true, where h is an object of type hash<T>, and k1, k2 are objects of type T.
This class template is only required to be instantiable for integer types (3.9.1 [basic.fundamental]), floating-point types (3.9.1 [basic.fundamental]), pointer types (8.3.1 [dcl.ptr]), and std::string, std::u16string, std::u32string, std::wstring, std::error_code, std::thread::id, std::bitset, and std::vector<bool>.namespace std { template <class T> struct hash : public std::unary_function<T, std::size_t> { std::size_t operator()(T val) const; }; }
2 The return value of operator() is unspecified, except that equal arguments shall yield the same result. operator() shall not throw exceptions.
Change Unordered associative containers 23.2.5 [unord.req] as indicated:
Each unordered associative container is parameterized by Key, by a function object type Hash([hash.requirements]) that acts as a hash function for argument values of type Key, and by a binary predicate Pred that induces an equivalence relation on values of type Key. Additionally, unordered_map and unordered_multimap associate an arbitrary mapped type T with the Key.
A hash function is a function object that takes a single argument of type Key and returns a value of type std::size_t.
Two values k1 and k2 of type Key are considered equal if the container's equality function object returns true when passed those values. If k1 and k2 are equal, the hash function shall return the same value for both. [Note: Thus supplying a non-default Pred parameter usually implies the need to supply a non-default Hash parameter. — end note]
Section: D.9.1 [auto.ptr] Status: Ready Submitter: Alisdair Meredith Opened: 2009-10-24 Last modified: 2010-03-08
View all other issues in [auto.ptr].
View all issues with Ready status.
Discussion:
This issue is extracted as the ongoing point-of-interest from earlier issue 463.
auto_ptr is overspecified as the auto_ptr_ref implementation detail is formally specified, and the technique is observable so workarounds for compiler defects can cause a working implementation of the primary auto_ptr template become non-conforming.
auto_ptr_ref is a documentation aid to describe a possible mechanism to implement the class. It should be marked exposition only, as per similar classes, e.g., istreambuf_iterator::proxy
[ 2009-10-25 Daniel adds: ]
I wonder, whether the revised wording shouldn't be as straight as for istream_buf by adding one further sentence:
An implementation is permitted to provide equivalent functionality without providing a class with this name.
[ 2009-11-06 Alisdair adds Daniel's suggestion to the proposed wording. ]
[ 2009-11-06 Howard moves issue to Review. ]
[ 2009-11-14 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Add the term "exposition only" in the following two places:
Ammend D.9.1 [auto.ptr]p2:
The exposition only class
Ttemplate auto_ptr_ref holds a reference to an auto_ptr. It is used by the auto_ptr conversions to allow auto_ptr objects to be passed to and returned from functions. An implementation is permitted to provide equivalent functionality without providing a class with this name.namespace std { template <class Y> struct auto_ptr_ref { }; // exposition only
Section: 23.5 [unord] Status: Open Submitter: Herb Sutter Opened: 2009-10-25 Last modified: 2010-01-24
View other active issues in [unord].
View all other issues in [unord].
View all issues with Open status.
Discussion:
See N2986.
[ 2010-01-22 Alisdair Opens. ]
[ 2010-01-24 Alisdair provides wording. ]
Proposed resolution:
Apply paper N2986.
Section: 27.5.4.1 [basic.ios.cons] Status: New Submitter: Martin Sebor Opened: 2009-10-25 Last modified: 2009-10-26
View all other issues in [basic.ios.cons].
View all issues with New status.
Discussion:
The basic_ios default ctor is required to leave the objects members uninitialized (see below). The paragraph says the object must be initialized by calling basic_ios::init() before it's destroyed by I can't find a requirement that it be initialized before calling any of the class other member functions. Am I not looking in the right place or that an issue?
[ 2009-10-25 Daniel adds: ]
I agree, that your wording makes that clearer, but suggest to write
... calling basic_ios::init()before ...Doing so, I recommend to adapt that of ios_base(); as well, where we have:
Effects: Each ios_base member has an indeterminate value after construction. These members shall be initialized by calling basic_ios::init. If an ios_base object is destroyed before these initializations have taken place, the behavior is undefined.
Proposed resolution:
Change 27.5.2.7 [ios.base.cons] p1:
ios_base();Effects: Each ios_base member has an indeterminate value after construction.TheseThe object's members shall be initialized by calling basic_ios::init before the object's first use or before it is destroyed, whichever comes first; otherwise the behavior is undefined..If an ios_base object is destroyed before these initializations have taken place, the behavior is undefined.
Change 27.5.4.1 [basic.ios.cons] p2:
basic_ios();Effects: Constructs an object of class basic_ios (27.5.2.7) leaving its member objects uninitialized. The object shall be initialized by callingitsbasic_ios::init before its first use or before it is destroyed, whichever comes first; otherwise the behavior is undefined.member function. If it is destroyed before it has been initialized the behavior is undefined.
Section: 20.5 [template.bitset] Status: Ready Submitter: Martin Sebor Opened: 2009-10-29 Last modified: 2010-03-08
View other active issues in [template.bitset].
View all other issues in [template.bitset].
View all issues with Ready status.
Discussion:
Issue 1227 — <bitset> synopsis overspecified makes the observation that std::bitset, and in fact the whole library, may be implemented without needing to #include <stdexcept> in any library header. The proposed resolution removes the #include <stdexcept> directive from the header.
I'd like to add that the <bitset> header (as well as the rest of the library) has also been implemented without #including the <cstddef> header in any library header. In the case of std::bitset, the template is fully usable (i.e., it may be instantiated and all its member functions may be used) without ever mentioning size_t. In addition, just like no library header except for <bitset> #includes <stdexcept> in its synopsis, no header but <bitset> #includes <cstddef> either.
Thus I suggest that the #include <cstddef> directive be similarly removed from the synopsis of <bitset>.
[ 2010-02-08 Moved to Tentatively Ready after 6 positive votes on c++std-lib. ]
Proposed resolution:
Change 20.5 [template.bitset]:
#include <cstddef> // for size_t#include <string> #include <iosfwd> // for istream, ostream namespace std { ...
Section: 22.3.3.2.3 [conversions.buffer] Status: New Submitter: Bo Persson Opened: 2009-10-21 Last modified: 2009-10-31
View all issues with New status.
Discussion:
The synopisis for wbuffer_convert 22.3.3.2.3 [conversions.buffer]/2 contains
typedef typename Tr::state_type state_type;
making state_type a synonym for (possibly) some char_traits<x>::state_type.
However, in paragraph 9 of the same section, we have
typedef typename Codecvt::state_type state_type;The type shall be a synonym for Codecvt::state_type.
From what I can see, it might be hard to implement wbuffer_convert if the types were not both std::mbstate_t, but I cannot find a requirement that they must be the same type.
Proposed resolution:
Section: 23.2.4 [associative.reqmts] Status: New Submitter: Boris Dušek Opened: 2009-10-24 Last modified: 2010-01-25
View other active issues in [associative.reqmts].
View all other issues in [associative.reqmts].
View all issues with New status.
Discussion:
In the latest published draft N2960, section 23.2.4 [associative.reqmts], paragraph 8, it is specifies that that insert does not invalidate any iterators. As per 23.2.1 [container.requirements.general], paragraph 12, this holds true not only for insert, but emplace as well. This gives the insert member a special treatment w.r.t. emplace member in 23.2.4 [associative.reqmts], par. 8, since both modify the container. For the sake of consistency, in 23.2.4 [associative.reqmts], par. 8: either reference to insert should be removed (i.e. count on 23.2.1 [container.requirements.general], par. 12), or reference to emplace be added (i.e. mention all members of assoc. containers that modify it).
[ 2009-11-18 Chris provided wording. ]
This suggested wording covers both the issue discussed, and a number of other identical issues (namely insert being discussed without emplace). I'm happy to go back and split and introduce a new issue if appropriate, but I think the changes are fairly mechanical and obvious.
[ 2010-01-23 Daniel Krügler and J. Daniel García updated wording to make the use of hint consistent with insert. ]
Proposed resolution:
Modify bullet 1 of 23.2.1 [container.requirements.general], p10:
10 Unless otherwise specified (see 23.2.4.1, 23.2.5.1, 23.3.2.3, and 23.3.6.4) all container types defined in this Clause meet the following additional requirements:
Modify 23.2.4 [associative.reqmts], p4:
4 An associative container supports unique keys if it may contain at most one element for each key. Otherwise, it supports equivalent keys. The set and map classes support unique keys; the multiset and multimap classes support equivalent keys. For multiset and multimap, insert, emplace, and erase preserve the relative ordering of equivalent elements.
Modify Table 96 — Associative container requirements in 23.2.4 [associative.reqmts]:
Table 96 — Associative container requirements (in addition to container) Expression Return type Assertion/note
pre-/post-conditionComplexity ... a_eq.emplace(args) iterator inserts a T object t constructed with std::forward<Args>(args)... and returns the iterator pointing to the newly inserted element. If a range containing elements equivalent to t exists in a_eq, t is inserted at the end of that range. logarithmic a.emplace_hint(p, args) iterator equivalent to a.emplace(std::forward<Args>(args)...). Return value is an iterator pointing to the element with the key equivalent to the newly inserted element. The const_iterator p is a hint pointing to where the search should start.The element is inserted as close as possible to the position just prior to p.Implementations are permitted to ignore the hint.logarithmic in general, but amortized constant if the element is inserted right afterbefore p...
Modify 23.2.4 [associative.reqmts], p8:
8 The insert and emplace members shall not affect the validity of iterators and references to the container, and the erase members shall invalidate only iterators and references to the erased elements.
Modify 23.2.4.1 [associative.reqmts.except], p2:
2 For associative containers, if an exception is thrown by any operation from within an insert() or emplace() function inserting a single element, theinsert() functioninsertion has no effect.
Modify 23.2.5 [unord.req], p6, p12 and p13:
6 An unordered associative container supports unique keys if it may contain at most one element for each key. Otherwise, it supports equivalent keys. unordered_set and unordered_map support unique keys. unordered_multiset and unordered_multimap support equivalent keys. In containers that support equivalent keys, elements with equivalent keys are adjacent to each other. For unordered_multiset and unordered_multimap, insert, emplace, and erase preserve the relative ordering of equivalent elements.
12 The insert and emplace members shall not affect the validity of references to container elements, but may invalidate all iterators to the container. The erase members shall invalidate only iterators and references to the erased elements.
13 The insert and emplace members shall not affect the validity of iterators if (N+n) < z * B, where N is the number of elements in the container prior to the insert operation, n is the number of elements inserted, B is the container's bucket count, and z is the container's maximum load factor.
Modify 23.2.5.1 [unord.req.except], p2:
2 For unordered associative containers, if an exception is thrown by any operation other than the container's hash function from within an insert() or emplace() function inserting a single element, theinsert()insertionfunctionhas no effect.
Section: 23.3.7 [vector.bool] Status: Ready Submitter: Christopher Jefferson Opened: 2009-11-01 Last modified: 2010-03-08
View other active issues in [vector.bool].
View all other issues in [vector.bool].
View all issues with Ready status.
Discussion:
The effects of vector<bool>::flip has the line:
It is unspecified whether the function has any effect on allocated but unused bits.
While this is technically true, it is misleading, as any member function in any standard container may change unused but allocated memory. Users can never observe such changes as it would also be undefined behaviour to read such memory.
[ 2009-11-14 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Strike second sentence from the definition of vector<bool>::flip(), 23.3.7 [vector.bool], paragraph 5.
Effects: Replaces each element in the container with its complement.It is unspecified whether the function has any effect on allocated but unused bits.
Section: 20.3 [utility] Status: Ready Submitter: Daniel Krügler Opened: 2009-11-03 Last modified: 2010-03-08
View other active issues in [utility].
View all other issues in [utility].
View all issues with Ready status.
Discussion:
During the Santa Cruz meeting it was decided to split off the provision of the library utility value() proposed in N2979 from the concrete request of the UK 300 comment. The provision of a new library component that allows the production of values in unevaluated expressions is considered as important to realize constrained templates in C++0x where concepts are not available.
The following proposed resolution is an improvement over that suggested in N2958, because the proposed component can now be defined without loss of general usefulness and any use by user-code will make the program ill-formed. A possible prototype implementation that satisfies the core language requirements can be written as:
template<class T>
struct declval_protector {
static const bool stop = false;
static typename std::add_rvalue_reference<T>::type delegate(); // undefined
};
template<class T>
typename std::add_rvalue_reference<T>::type declval() {
static_assert(declval_protector<T>::stop, "declval() must not be used!");
return declval_protector<T>::delegate();
}
Further-on the earlier suggested name value() has been changed to declval() after discussions with committee members.
Finally the suggestion shown below demonstrates that it can simplify existing standard wording by directly using it in the library specification, and that it also improves an overlooked corner case for common_type by adding support for cv void.
[ 2009-11-19 Moved to Tentatively Ready after 6 positive votes on c++std-lib. ]
Proposed resolution:
[ The proposed resolution has been updated to N3000 numbering and wording ]
Change 20.3 [utility], header <utility> synopsis as indicated:
// 20.3.3, forward/move: template <class T> struct identity; template <class T, class U> T&& forward(U&&); template <class T> typename remove_reference<T>::type&& move(T&&); // 20.3.4, declval: template <class T> typename add_rvalue_reference<T>::type declval(); // as unevaluated operand
Immediately after the current section 20.3.3 [forward] insert a new section:
20.3.4 Function template declval [declval]
The library provides the function template declval to simplify the definition of expressions which occur as unevaluated operands (5 [expr]). The template parameter T of declval may be an incomplete type.
template <class T> typename add_rvalue_reference<T>::type declval(); // as unevaluated operand
Remarks: If this function is used according to 3.2 [basic.def.odr], the program is ill-formed.
[Example:
template<class To, class From> decltype(static_cast<To>(declval<From>())) convert(From&&);declares a function template convert, which only participates in overloading if the type From can be explicitly cast to type To. For another example see class template common_type (20.7.6.6 [meta.trans.other]). — end example]
This bullet just makes clear that after applying N2984, the changes in 20.7.4.3 [meta.unary.prop], before table Type property queries should not use declval, because the well-formedness requirement of the specification of is_constructible would become more complicated, because we would need to make sure that the expression CE is checked in an unevaluated context.
Also 20.7.5 [meta.rel]/4 is not modified similar to the previous bullet, because with the stricter requirements of not using declval() the well-formedness condition would be harder to specify. The following changes are only editorial ones (e.g. the removal of the duplicate declaration of create()):
Given the following function prototype:
template <class T> typename add_rvalue_reference<T>::type create();the predicate condition for a template specialization is_convertible<From, To> shall be satisfied if and only if the return expression in the following code would be well-formed, including any implicit conversions to the return type of the function:
template <class T> typename add_rvalue_reference<T>::type create();To test() { return create<From>(); }
Change the entry in column "Comments" for common_type in Table 51 — Other transformations (20.7.6.6 [meta.trans.other]):
[ NB: This wording change extends the type domain of common_type for cv void => cv void transformations and thus makes common_type usable for all binary type combinations that are supported by is_convertible ]
The member typedef type shall be defined as set out below. All types in the parameter pack T shall be complete or (possibly cv-qualified) void. A program may specialize this trait if at least one template parameter in the specialization is a user-defined type. [Note: Such specializations are needed when only explicit conversions are desired among the template arguments. — end note]
Change 20.7.6.6 [meta.trans.other]/3 as indicated:
[ NB: This wording change is more than an editorial simplification of the definition of common_type: It also extends its usefulness for cv void types as outlined above ]
The nested typedef common_type::type shall be defined as follows:
[..]
template <class T, class U> struct common_type<T, U> {private: static T&& __t(); static U&& __u(); public:typedef decltype(true ?__tdeclval<T>() :__udeclval<U>()) type; };
Change 20.8.4 [func.ret]/1 as indicated [This part solves some main aspects of issue 1225]:
namespace std { template <class> class result_of; // undefined template <class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)> { public :// typestypedefsee belowdecltype(declval<Fn>() ( declval<ArgTypes>()... )) type; }; }
1 Given an rvalue fn of type Fn and values t1, t2, ..., tN of types T1, T2, ..., TN in ArgTypes, respectively, the type member is the result type of the expression fn(t1, t2, ...,tN). The values ti are lvalues when the corresponding type Ti is an lvalue-reference type, and rvalues otherwise.
Section: 20.9.11.3 [util.smartptr.weak] Status: Ready Submitter: Daniel Krügler Opened: 2009-11-04 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
Additional to the necessary cleanup of the description of the the weak_ptr component from 20.9.11.3 [util.smartptr.weak] described in 1231 it turns out that the currently deleted comparison functions of weak_ptr are not needed at all: There is no safe-bool conversion from weak_ptr, and it won't silently chose a conversion to shared_ptr.
[ 2009-11-14 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change 20.9.11.3 [util.smartptr.weak]/1 as indicated:
namespace std {
template<class T> class weak_ptr {
public:
...
// comparisons
template<class Y> bool operator<(weak_ptr<Y> const&) const = delete;
template<class Y> bool operator<=(weak_ptr<Y> const&) const = delete;
template<class Y> bool operator>(weak_ptr<Y> const&) const = delete;
template<class Y> bool operator>=(weak_ptr<Y> const&) const = delete;
};
...
concept_mapSection: 27.5 [iostreams.base] Status: Ready Submitter: Beman Dawes Opened: 2009-11-04 Last modified: 2010-03-08
View all other issues in [iostreams.base].
View all issues with Ready status.
Discussion:
The current WP still contains a concept_map.
[ 2009-11-11 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change Iostreams base classes 27.5 [iostreams.base], Header <ios> synopsis, as indicated:
concept_map ErrorCodeEnum<io_errc> { };template <> struct is_error_code_enum<io_errc> : true_type { } error_code make_error_code(io_errc e); error_condition make_error_condition(io_errc e); const error_category& iostream_category();
Section: 20.7.4.3 [meta.unary.prop] Status: New Submitter: Peter Dimov Opened: 2009-11-07 Last modified: 2009-11-08
View other active issues in [meta.unary.prop].
View all other issues in [meta.unary.prop].
View all issues with New status.
Discussion:
The specification of is_constructible<T,Args...> in N3000 uses
static_cast<T>(create<Args>()...)
for the one-argument case, but static_cast also permits unwanted conversions such as void* to T* and Base* to Derived*.
Proposed resolution:
Change 20.7.4.3 [meta.unary.prop], p6:
the predicate condition for a template specialization is_constructible<T, Args> shall be satisfied, if and only if the following
expression CEvariable definition would be well-formed:
if sizeof...(Args) == 0
1, the expression:static_cast<T>(create<Args>()...)T t;otherwise
the expression:T t(create<Args>()...);
Section: 21.5 [string.conversions] Status: Ready Submitter: Christopher Jefferson Opened: 2009-11-10 Last modified: 2010-03-08
View all other issues in [string.conversions].
View all issues with Ready status.
Discussion:
Reported on the gcc mailing list.
The code "int i; to_string(i);" fails to compile, as 'int' is ambiguous between 'long long' and 'long long unsigned'. It seems unreasonable to expect users to cast numbers up to a larger type just to use to_string.
[ 2009-11-14 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
21.3 [string.classes], change to_string and to_wstring to:
string to_string(int val); string to_string(unsigned val); string to_string(long val); string to_string(unsigned long val); string to_string(long long val); string to_string(unsigned long long val); string to_string(float val); string to_string(double val); string to_string(long double val); wstring to_wstring(int val); wstring to_wstring(unsigned val); wstring to_wstring(long val); wstring to_wstring(unsigned long val); wstring to_wstring(long long val); wstring to_wstring(unsigned long long val); wstring to_wstring(float val); wstring to_wstring(double val); wstring to_wstring(long double val);
In 21.5 [string.conversions], paragraph 7, change to:
string to_string(int val); string to_string(unsigned val); string to_string(long val); string to_string(unsigned long val); string to_string(long long val); string to_string(unsigned long long val); string to_string(float val); string to_string(double val); string to_string(long double val);7 Returns: each function returns a string object holding the character representation of the value of its argument that would be generated by calling sprintf(buf, fmt, val) with a format specifier of "%d", "%u", "%ld", "%lu", "%lld", "%llu", "%f", "%f", or "%Lf", respectively, where buf designates an internal character buffer of sufficient size.
In 21.5 [string.conversions], paragraph 14, change to:
wstring to_wstring(int val); wstring to_wstring(unsigned val); wstring to_wstring(long val); wstring to_wstring(unsigned long val); wstring to_wstring(long long val); wstring to_wstring(unsigned long long val); wstring to_wstring(float val); wstring to_wstring(double val); wstring to_wstring(long double val);14 Returns: Each function returns a wstring object holding the character representation of the value of its argument that would be generated by calling swprintf(buf, buffsz, fmt, val) with a format specifier of L"%d", L"%u", L"%ld", L"%lu", L"%lld", L"%llu", L"%f", L"%f", or L"%Lf", respectively, where buf designates an internal character buffer of sufficient size buffsz.
Section: 20.9.11.2.7 [util.smartptr.shared.cmp] Status: Ready Submitter: Jonathan Wakely Opened: 2009-11-10 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
20.9.11.2.7 [util.smartptr.shared.cmp]/5 says:
For templates greater, less, greater_equal, and less_equal, the partial specializations for shared_ptr shall yield a total order, even if the built-in operators <, >, <=, and >= do not. Moreover, less<shared_ptr<T> >::operator()(a, b) shall return std::less<T*>::operator()(a.get(), b.get()).
This is necessary in order to use shared_ptr as the key in associate containers because n2637 changed operator< on shared_ptrs to be defined in terms of operator< on the stored pointers (a mistake IMHO but too late now.) By 5.9 [expr.rel]/2 the result of comparing builtin pointers is unspecified except in special cases which generally do not apply to shared_ptr.
Earlier versions of the WP (n2798, n2857) had the following note on that paragraph:
[Editor's note: It's not clear to me whether the first sentence is a requirement or a note. The second sentence seems to be a requirement, but it doesn't really belong here, under operator<.]
I agree completely - if partial specializations are needed they should be properly specified.
20.9.11.2.7 [util.smartptr.shared.cmp]/6 has a note saying the comparison operator allows shared_ptr objects to be used as keys in associative containers, which is misleading because something else like a std::less partial specialization is needed. If it is not correct that note should be removed.
20.9.11.2.7 [util.smartptr.shared.cmp]/3 refers to 'x' and 'y' but the prototype has parameters 'a' and 'b' - that needs to be fixed even if the rest of the issue is NAD.
I see two ways to fix this, I prefer the first because it removes the need for any partial specializations and also fixes operator> and other comparisons when defined in terms of operator<.
Replace 20.9.11.2.7 [util.smartptr.shared.cmp]/3 with the following and remove p5:
template<class T, class U> bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b);3 Returns:
x.get() < y.get().std::less<V>()(a.get(), b.get()), where V is the composite pointer type (5.9 [expr.rel]).4 Throws: nothing.
5 For templates greater, less, greater_equal, and less_equal, the partial specializations for shared_ptr shall yield a total order, even if the built-in operators <, >, <=, and >= do not. Moreover, less<shared_ptr<T> >::operator()(a, b) shall return std::less<T*>::operator()(a.get(), b.get()).6 [Note: Defining a comparison operator allows shared_ptr objects to be used as keys in associative containers. — end note]
Add to 20.9.11.2 [util.smartptr.shared]/1 (after the shared_ptr comparisons)
template<class T> struct greater<shared_ptr<T>>; template<class T> struct less<shared_ptr<T>>; template<class T> struct greater_equal<shared_ptr<T>>; template<class T> struct less_equal<shared_ptr<T>>;
Remove 20.9.11.2.7 [util.smartptr.shared.cmp]/5 and /6 and replace with:
template<class T, class U> bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b);3 Returns:
xa.get() <yb.get().4 Throws: nothing.
5 For templates greater, less, greater_equal, and less_equal, the partial specializations for shared_ptr shall yield a total order, even if the built-in operators <, >, <=, and >= do not. Moreover, less<shared_ptr<T> >::operator()(a, b) shall return std::less<T*>::operator()(a.get(), b.get()).
6 [Note: Defining a comparison operator allows shared_ptr objects to be used as keys in associative containers. — end note]template<class T> struct greater<shared_ptr<T>> : binary_function<shared_ptr<T>, shared_ptr<T>, bool> { bool operator()(const shared_ptr<T>& a, const shared_ptr<T>& b) const; };operator() returns greater<T*>()(a.get(), b.get()).template<class T> struct less<shared_ptr<T>> : binary_function<shared_ptr<T>, shared_ptr<T>, bool> { bool operator()(const shared_ptr<T>& a, const shared_ptr<T>& b) const; };operator() returns less<T*>()(a.get(), b.get()).template<class T> struct greater_equal<shared_ptr<T>> : binary_function<shared_ptr<T>, shared_ptr<T>, bool> { bool operator()(const shared_ptr<T>& a, const shared_ptr<T>& b) const; };operator() returns greater_equal<T*>()(a.get(), b.get()).template<class T> struct less_equal<shared_ptr<T>> : binary_function<shared_ptr<T>, shared_ptr<T>, bool> { bool operator()(const shared_ptr<T>& a, const shared_ptr<T>& b) const; };operator() returns less_equal<T*>()(a.get(), b.get()).
[ 2009-11-18: Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Replace 20.9.11.2.7 [util.smartptr.shared.cmp]/3 with the following and remove p5:
template<class T, class U> bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b);3 Returns:
x.get() < y.get().less<V>()(a.get(), b.get()), where V is the composite pointer type (5.9 [expr.rel]) of T* and U*.4 Throws: nothing.
5 For templates greater, less, greater_equal, and less_equal, the partial specializations for shared_ptr shall yield a total order, even if the built-in operators <, >, <=, and >= do not. Moreover, less<shared_ptr<T> >::operator()(a, b) shall return std::less<T*>::operator()(a.get(), b.get()).6 [Note: Defining a comparison operator allows shared_ptr objects to be used as keys in associative containers. — end note]
Section: 17.6.1.3 [compliance] Status: Ready Submitter: Alisdair Meredith Opened: 2009-11-12 Last modified: 2010-03-08
View all other issues in [compliance].
View all issues with Ready status.
Discussion:
Addresses UK 172
This issue is a response to NB comment UK-172
The functions quick_exit and at_quick_exit should be added to the required features of <cstdlib> in a freestanding implementation.
This comment was rejected in Summit saying neither at_exit nor at_quick_exit should be required. This suggests the comment was misread, as atexit is already required to be supported. If the LWG really did wish to not require the registration functions be supported, then a separate issue should be opened to change the current standard.
Given both exit and atexit are required, the UK panel feels it is appropriate to require the new quick_exit facility is similarly supported.
[ 2009-12-11 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Ammend p3 Freestanding implementations 17.6.1.3 [compliance]
3 The supplied version of the header <cstdlib> shall declare at least the functions abort(), atexit(), at_quick_exit,andexit(), and quick_exit(18.5 [support.start.term]). The other headers listed in this table shall meet the same requirements as for a hosted implementation.
Section: 30.6.7 [futures.shared_future] Status: New Submitter: Anthony Williams Opened: 2009-11-17 Last modified: 2010-02-19
View all other issues in [futures.shared_future].
View all issues with New status.
Discussion:
If a shared_future is constructed with the result of an async call with a deferred function, and two or more copies of that shared_future are created, with multiple threads calling get(), it is not clear which thread runs the deferred function. 30.6.7 [futures.shared_future]p22 from N3000 says (minus editor's note):
E ffects: if the associated state contains a deferred function, executes the deferred function. Otherwise, blocks until the associated state is ready.
In the absence of wording to the contrary, this implies that every thread that calls wait() will execute the deferred function.
Proposed resolution:
Replace 30.6.7 [futures.shared_future]p22 with the following:
Effects: If the associated state
contains a deferred function, executes the deferred function. Otherwise, blocks until the associated state is ready.was created by a promise or packaged_task object, block until the associated state is ready. If the associated state is associated with a thread created for an async call (30.6.9 [futures.async]), as if associated-thread.join().If the associated state contains a deferred function, calls to wait() on all shared_future objects that share the same associated state are serialized. The first call to wait() that shares a given associated state executes the deferred function and stores the return value or exception in the associated state.
Synchronization: if the associated state was created by a promise object, the completion of set_value() or set_exception() to that promise happens before (1.10 [intro.multithread]) wait() returns. If the associated state was created by a packaged_task object, the completion of the associated task happens before wait() returns. If the associated state is associated with a thread created for an async call (30.6.9 [futures.async]), the completion of the associated thread happens-before wait() returns.
If the associated state contained a deferred function, the invocation of the deferred function happens-before any call to wait() on a future that shares that state returns.
Section: 30.5.2 [thread.condition.condvarany] Status: Ready Submitter: Anthony Williams Opened: 2009-11-17 Last modified: 2010-03-08
View other active issues in [thread.condition.condvarany].
View all other issues in [thread.condition.condvarany].
View all issues with Ready status.
Discussion:
30.5.2 [thread.condition.condvarany]p18 and 30.5.2 [thread.condition.condvarany]p27 specify incorrect preconditions for condition_variable_any::wait_for. The stated preconditions require that lock has a mutex() member function, and that this produces the same result for all concurrent calls to wait_for(). This is inconsistent with wait() and wait_until() which do not impose such a requirement.
[ 2009-12-24 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Remove 30.5.2 [thread.condition.condvarany]p18 and 30.5.2 [thread.condition.condvarany]p27.
template <class Lock, class Rep, class Period> cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
18 Precondition: lock is locked by the calling thread, and either
no other thread is waiting on this condition_variable object orlock.mutex() returns the same value for each of the lock arguments supplied by all concurrently waiting (via wait, wait_for, or wait_until) threads....
template <class Lock, class Rep, class Period, class Predicate> bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
27 Precondition: lock is locked by the calling thread, and either
no other thread is waiting on this condition_variable object orlock.mutex() returns the same value for each of the lock arguments supplied by all concurrently waiting (via wait, wait_for, or wait_until) threads.
Section: 30.4 [thread.mutex] Status: New Submitter: Anthony Williams Opened: 2009-11-17 Last modified: 2010-02-12
View all other issues in [thread.mutex].
View all issues with New status.
Discussion:
The Mutex requirements in 30.4.1 [thread.mutex.requirements] and 30.4.2 [thread.timedmutex.requirements] confuse the requirements on the behaviour of std::mutex et al with the requirements on Lockable types for use with std::unique_lock, std::lock_guard and std::condition_variable_any.
Proposed resolution:
Add a new section to 30.2 [thread.req] after 30.2.4 [thread.req.timing] as follows:
30.2.5 Requirements for Lockable types
The standard library templates unique_lock (30.4.3.2 [thread.lock.unique]), lock_guard (30.4.3.1 [thread.lock.guard]), lock, try_lock (30.4.4 [thread.lock.algorithm]) and condition_variable_any (30.5.2 [thread.condition.condvarany]) all operate on user-supplied Lockable objects. Such an object must support the member functions specified for either the Lockable Requirements or the TimedLockable requirements as appropriate to acquire or release ownership of a lock by a given thread. [Note: the nature of any lock ownership and any synchronization it may entail are not part of these requirements. — end note]
30.2.5.1 Lockable Requirements
In order to qualify as a Lockable type, the following expressions must be supported, with the specified semantics, where m denotes a value of type L that supports the Lockable:
The expression m.lock() shall be well-formed and have the following semantics:
- Effects:
- Block until a lock can be acquired for the current thread.
- Return type:
- void
The expression m.try_lock() shall be well-formed and have the following semantics:
- Effects:
- Attempt to acquire a lock for the current thread without blocking.
- Return type:
- bool
- Returns:
- true if the lock was acquired, false otherwise.
The expression m.unlock() shall be well-formed and have the following semantics:
- Effects:
- Release a lock on m held by the current thread.
- Return type:
- void
- Throws:
- Nothing if the current thread holds a lock on m.
30.2.5.2 TimedLockable Requirements
For a type to qualify as TimedLockable it must meet the Lockable requirements, and additionally the following expressions must be well-formed, with the specified semantics, where m is an instance of a type TL that supports the TimedLockable requirements, rel_time denotes instantiation of duration (20.10.3 [time.duration]) and abs_time denotes an instantiation of time_point (20.10.4 [time.point])
The expression m.try_lock_for(rel_time) shall be well-formed and have the following semantics:
- Effects:
- Attempt to acquire a lock for the current thread within the specified time period.
- Return type:
- bool
- Returns:
- true if the lock was acquired, false otherwise.
The expression m.try_lock_until(abs_time) shall be well-formed and have the following semantics:
- Effects:
- Attempt to acquire a lock for the current thread before the specified point in time.
- Return type:
- bool
- Returns:
- true if the lock was acquired, false otherwise.
Replace 30.4.1 [thread.mutex.requirements] paragraph 2 with the following:
2 This section describes requirements ontemplate argument types used to instantiate templates defined inthe mutex types supplied by the C++ standard library.The template definitions in the C++ standard library referThese types shall conform to the named Mutex requirements whose details are set out below. In this description, m is an object ofa Mutex typeone of the standard library mutex types std::mutex, std::recursive_mutex, std::timed_mutex or std::recursive_timed_mutex..
Add the following paragraph after 30.4.1 [thread.mutex.requirements] paragraph 2:
A Mutex type shall conform to the Lockable requirements (30.2.5.1).
Replace 30.4.2 [thread.timedmutex.requirements] paragraph 1 with the following:
The C++ standard library TimedMutex types std::timed_mutex and std::recursive_timed_mutexA TimedMutex typeshall meet the requirements for a Mutex type. In addition,itthey shall meet the requirements set outin this Clause 30.4.2below, where rel_time denotes an instantiation of duration (20.10.3 [time.duration]) and abs_time denotes an instantiation of time_point (20.10.4 [time.point]).
Add the following paragraph after 30.4.2 [thread.timedmutex.requirements] paragraph 1:
A TimedMutex type shall conform to the TimedLockable requirements (30.2.5.1).
Add the following paragraph following 30.4.3.1 [thread.lock.guard] paragraph 1:
The supplied Mutex type shall meet the Lockable requirements (30.2.5.1).
Add the following paragraph following 30.4.3.2 [thread.lock.unique] paragraph 1:
The supplied Mutex type shall meet the Lockable requirements (30.2.5.1). unique_lock<Mutex> meets the Lockable requirements. If Mutex meets the TimedLockable requirements (30.2.5.2) then unique_lock<Mutex> also meets the TimedLockable requirements.
Replace the use of "mutex" or "mutex object" with "lockable object" throughout clause [thread.mutex.locks] paragraph 1:
1 A lock is an object that holds a reference to amutexlockable object and may unlock themutexlockable object during the lock's destruction (such as when leaving block scope). A thread of execution may use a lock to aid in managingmutexownership of a lockable object in an exception safe manner. A lock is said to own amutexlockable object if it is currently managing the ownership of thatmutexlockable object for a thread of execution. A lock does not manage the lifetime of themutexlockable object it references. [ Note: Locks are intended to ease the burden of unlocking themutexlockable object under both normal and exceptional circumstances. — end note ]
30.4.3 [thread.lock] paragaph 2:
2 Some lock constructors take tag types which describe what should be done with themutexlockable object during the lock's constuction.
30.4.3.1 [thread.lock.guard] paragaph 1:
1 An object of type lock_guard controls the ownership of amutexlockable object within a scope. A lock_guard object maintains ownership of amutexlockable object throughout the lock_guard object's lifetime. The behavior of a program is undefined if themutexlockable object referenced by pm does not exist for the entire lifetime (3.8) of the lock_guard object. Mutex shall meet the Lockable requirements (30.2.5.1).
30.4.3.2 [thread.lock.unique] paragaph 1:
1 An object of type unique_lock controls the ownership of amutexlockable object within a scope.MutexoOwnership of the lockable object may be acquired at construction or after construction, and may be transferred, after acquisition, to another unique_lock object. Objects of type unique_lock are not copyable but are movable. The behavior of a program is undefined if the contained pointer pm is not null and the mutex pointed to by pm does not exist for the entire remaining lifetime (3.8) of the unique_lock object. Mutex shall meet the Lockable requirements (30.2.5.1).
Add the following to the precondition of unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time) in 30.4.3.2.1 [thread.lock.unique.cons] paragraph 18:
template <class Clock, class Duration> unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);18 Precondition: If mutex_type is not a recursive mutex the calling thread does not own the mutex. The supplied mutex_type type shall meet the TimedLockable requirements (30.2.5.2).
Add the following to the precondition of unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time) in 30.4.3.2.1 [thread.lock.unique.cons] paragraph 22
22 Precondition: If mutex_type is not a recursive mutex the calling thread does not own the mutex. The supplied mutex_type type shall meet the TimedLockable requirements (30.2.5.2).
Add the following as a precondition of bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) before 30.4.3.2.2 [thread.lock.unique.locking] paragraph 10
template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);Requires: The supplied mutex_type type shall meet the TimedLockable requirements (30.2.5.2).
Add the following as a precondition of bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) before 30.4.3.2.2 [thread.lock.unique.locking] paragraph 15
template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);Requires: The supplied mutex_type type shall meet the TimedLockable requirements (30.2.5.2).
Replace 30.4.4 [thread.lock.algorithm] p1 with the following:
template <class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);1 Requires: Each template parameter type shall meet theMutexLockable requirements (30.2.5.1)., except that a call to try_lock() may throw an exception.[Note: The unique_lock class template meets these requirements when suitably instantiated. — end note]
Replace 30.4.4 [thread.lock.algorithm] p4 with the following:
template <class L1, class L2, class... L3> void lock(L1&, L2&, L3&...);4 Requires: Each template parameter type shall meet the MutexMutexLockable requirements (30.2.5.1)., except that a call to try_lock() may throw an exception.[Note: The unique_lock class template meets these requirements when suitably instantiated. — end note]
Replace 30.5.2 [thread.condition.condvarany] paragraph 1 with:
1 A Lock type shall meet therequirements for a Mutex typeLockable requirements (30.2.5.1), except that try_lock is not required. [Note: All of the standard mutex types meet this requirement. — end note]
Section: 30.6.4 [futures.state] Status: New Submitter: Anthony Williams Opened: 2009-11-18 Last modified: 2009-11-18
View all issues with New status.
Discussion:
The current description of the associated state in 30.6.4 [futures.state] does not allow for futures created by an async call. The description therefore needs to be extended to cover that.
Proposed resolution:
Add a new sentence to 30.6.4 [futures.state] p2:
2 This associated state consists of some state information and some (possibly not yet evaluated) result, which can be a (possibly void) value or an exception. If the associated state was created by a call to async (30.6.9 [futures.async]) then it may also contain a deferred function or an associated thread.
Add an extra bullet to 30.6.4 [futures.state] p3:
The result of an associated state can be set by calling:
- promise::set_value,
- promise::set_exception,
or- packaged_task::operator()
., or- a call to async (30.6.9 [futures.async]).
Section: 20.8.4 [func.ret] Status: Ready Submitter: Alisdair Meredith Opened: 2009-11-19 Last modified: 2010-03-08
View other active issues in [func.ret].
View all other issues in [func.ret].
View all issues with Ready status.
Discussion:
Addresses UK 198
NB Comment: UK-198 makes this request among others. It refers to a more detailed issue that BSI did not manage to submit by the CD1 ballot deadline though.
result_of is essentially a metafunction to return the type of an expression, and belongs with the other library metafunctions in <type_traits> rather than lurking in <functional>. The current definition in <functional> made sense when result_of was nothing more than a protocol to enable several components in <functional> to provide their own result types, but it has become a more general tool. For instance, result_of is now used in the threading and futures components.
Now that <type_traits> is a required header for free-standing implementations it will be much more noticeable (in such environments) that a particularly useful trait is missing, unless that implementation also chooses to offer <functional> as an extension.
The simplest proposal is to simply move the wording (editorial direction below) although a more consistent form for type_traits would reformat this as a table.
Following the acceptance of 1255, result_of now depends on the declval function template, tentatively provided in <utility> which is not (yet) required of a free-standing implementation.
This dependency is less of an issue when result_of continues to live in <functional>.
Personally, I would prefer to clean up the dependencies so both result_of and declval are available in a free-standing implementation, but that would require slightly more work than suggested here. A minimal tweak would be to require <utility> in a free-standing implementation, although there are a couple of subtle issues with make_pair, which uses reference_wrapper in its protocol and that is much harder to separate cleanly from <functional>.
An alternative would be to enact the other half of N2979 and create a new minimal header for the new C++0x library facilities to be added to the freestanding requirements (plus swap.)
I have a mild preference for the latter, although there are clearly reasons to consider better library support for free-standing in general, and adding the whole of <utility> could be considered a step in that direction. See NB comment JP-23 for other suggestions (array, ratio)
[ 2010-01-27 Beman updated wording. ]
The original wording is preserved here:
Move 20.8.4 [func.ret] to a heading below 20.7 [meta]. Note that in principle we should not change the tag, although this is a new tag for 0x. If it has been stable since TR1 it is clearly immutable though.
This wording should obviously adopt any other changes currently in (Tentatively) Ready status that touch this wording, such as 1255.
[ 2010-02-09 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
From Function objects 20.8 [function.objects], Header <functional> synopsis, remove:
// 20.7.4 result_of: template <class> class result_of; // undefined template <class F, class... Args> class result_of<F(ArgTypes...)>;
Remove Function object return types 20.8.4 [func.ret] in its entirety. This sub-section reads:
namespace std { template <class> class result_of; // undefined template <class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)> { public : // types typedef see below type; }; }Given an rvalue
fnof typeFnand valuest1, t2, ..., tNof types T1, T2, ..., TN inArgTypes, respectively, the type member is the result type of the expressionfn(t1, t2, ...,tN). The valuestiare lvalues when the corresponding typeTiis an lvalue-reference type, and rvalues otherwise.
To Header <type_traits> synopsis 20.7.2 [meta.type.synop], add at the indicated location:
template <class T> struct underlying_type; template <class T> struct result_of; // not defined template <class Fn, class... ArgTypes> struct result_of<Fn(ArgTypes...)>;
To Other transformations 20.7.6.6 [meta.trans.other], Table 51 — Other transformations, add:
Template Condition Comments template <class T>
struct underlying_type;Tshall be an enumeration type (7.2)The member typedef typeshall name the underlying type ofT.template <class Fn, class... ArgTypes> struct result_of<Fn(ArgTypes...)>;Fnshall be a function object type 20.8 [function.objects], reference to function, or reference to function object type. decltype(declval<Fn>()(declval<ArgTypes>()...)) shall be well formed.The member typedef typeshall name the typedecltype(declval<Fn>()(declval<ArgTypes>()...)).
At the end of Other transformations 20.7.6.6 [meta.trans.other] add:
[Example: Given these definitions:
typedef bool(&PF1)(); typedef short(*PF2)(long); struct S { operator PF2() const; double operator()(char, int&); };the following assertions will hold:
static_assert(std::is_same<std::result_of<S(int)>::type, short>::value, "Error!"); static_assert(std::is_same< std::result_of<S&(unsigned char, int&)>::type, double>::value, "Error!"); static_assert(std::is_same< std::result_of<PF1()>::type, bool>::value, "Error!"); — end example]
Section: 20.10.3.5 [time.duration.nonmember] Status: Ready Submitter: Daniel Krügler Opened: 2009-11-21 Last modified: 2010-03-08
View all other issues in [time.duration.nonmember].
View all issues with Ready status.
Discussion:
IMO CR alone is not really defined (it should be CR(Rep1, Rep2)).
[ 2009-12-24 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change 20.10.3.5 [time.duration.nonmember] paragraphs 9 and 12:
template <class Rep1, class Period, class Rep2> duration<typename common_type<Rep1, Rep2>::type, Period> operator/(const duration<Rep1, Period>& d, const Rep2& s);9 Returns: duration<CR(Rep1, Rep2), Period>(d) /= s.template <class Rep1, class Period, class Rep2> duration<typename common_type<Rep1, Rep2>::type, Period> operator%(const duration<Rep1, Period>& d, const Rep2& s);12 Returns: duration<CR(Rep1, Rep2), Period>(d) %= s.
Section: 30.6.5 [futures.promise] Status: New Submitter: Jonathan Wakely Opened: 2009-11-22 Last modified: 2009-11-22
View other active issues in [futures.promise].
View all other issues in [futures.promise].
View all issues with New status.
Discussion:
The definitions of promise::set_value need tidying up, the synopsis says:
// setting the result void set_value(const R& r); void set_value(see below);
Why is the first one there? It implies it is always present for all specialisations of promise, which is not true.
The definition says:
void set_value(const R& r); void promise::set_value(R&& r); void promise<R&>::set_value(R& r); void promise<void>::set_value();
The lack of qualification on the first one again implies it's present for all specialisations, again not true.
Proposed resolution:
Change the synopsis in 30.6.5 [futures.promise]:
// setting the resultvoid set_value(const R& r);void set_value(see below);
And the definition be changed by qualifying the first signature:
void promise::set_value(const R& r); void promise::set_value(R&& r); void promise<R&>::set_value(R& r); void promise<void>::set_value();
Section: 30.6 [futures] Status: New Submitter: Jonathan Wakely Opened: 2009-11-22 Last modified: 2010-02-19
View other active issues in [futures].
View all other issues in [futures].
View all issues with New status.
Discussion:
30.6.6 [futures.unique_future]/1 should be updated to mention async.
30.6.7 [futures.shared_future]/1 should also be updated for async. That paragraph also says
... Its value or exception can be set by use of a shared_future, promise (30.6.5 [futures.promise]), or packaged_task (30.6.10 [futures.task]) object that shares the same associated state.
How can the value be set by a shared_future?
30.6.8 [futures.atomic_future]/1 says
An atomic_future object can only be created by use of a promise (30.6.5 [futures.promise]) or packaged_task (30.6.10 [futures.task]) object.
which is wrong, it's created from a std::future, which could have been default-cosntructed. That paragraph should be closer to the text of 30.6.7 [futures.shared_future]/1, and should also mention async.
Proposed resolution:
Section: 23.3.3 [forwardlist] Status: Ready Submitter: Daniel Krügler Opened: 2009-12-12 Last modified: 2010-03-08
View all other issues in [forwardlist].
View all issues with Ready status.
Discussion:
I found that forward_list has only
forward_list(const forward_list<T,Allocator>& x); forward_list(forward_list<T,Allocator>&& x);
but misses
forward_list(const forward_list& x, const Allocator&); forward_list(forward_list&& x, const Allocator&);
Note to other reviewers: I also checked the container adaptors for similar inconsistencies, but as far as I can see these are already handled by the current active issues 1194 and 1199.
[ 2010-01-14 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
In 23.3.3 [forwardlist]/3, class template forward_list synopsis change as indicated:
forward_list(const forward_list<T,Allocator>& x); forward_list(forward_list<T,Allocator>&& x); forward_list(const forward_list&, const Allocator&); forward_list(forward_list&&, const Allocator&);
Section: 30.3.1.1 [thread.thread.id] Status: Ready Submitter: Anthony Williams Opened: 2009-11-24 Last modified: 2010-03-08
View all other issues in [thread.thread.id].
View all issues with Ready status.
Discussion:
The class definition of std::thread::id in N3000 is:
class thread::id {
public:
id();
};
Typically, I expect that the internal data members will either be pointers or integers, so that in practice the class will be trivially copyable. However, I don't think the current wording guarantees it, and I think it would be useful. In particular, I can see a use for std::atomic<std::thread::id> to allow a thread to claim ownership of a data structure atomicly, and std::atomic<T> requires that T is trivially copyable.
[ 2010-02-12 Moved to Tentatively Ready after 7 positive votes on c++std-lib. ]
Proposed resolution:
Add a new sentence to 30.3.1.1 [thread.thread.id] p1:
1 An object of type thread::id provides a unique identifier for each thread of execution and a single distinct value for all thread objects that do not represent a thread of execution (30.3.1 [thread.thread.class]). Each thread of execution has an associated thread::id object that is not equal to the thread::id object of any other thread of execution and that is not equal to the thread::id object of any std::thread object that does not represent threads of execution. The library may reuse the value of a thread::id of a terminated thread that can no longer be joined. thread::id shall be a trivially copyable class (9 [class]).
Section: 23.3.3.4 [forwardlist.modifiers] Status: New Submitter: Bo Persson Opened: 2009-11-25 Last modified: 2010-02-04
View all other issues in [forwardlist.modifiers].
View all issues with New status.
Discussion:
After applying LDR149, forward_list now has 5 overloads of insert_after, all returning an iterator.
However, two of those - inserting a single object - return "An iterator pointing to a copy of x [the inserted object]" while the other three - inserting zero or more objects - return an iterator equivalent to the position parameter, pointing before any possibly inserted objects.
Is this the intended change?
I don't really know what insert_after(position, empty_range) should really return, but always returning position seems less than useful.
[ 2010-02-04 Howard adds: ]
I agree this inconsistency will be error prone and needs to be fixed. Additionally emplace_after's return value is unspecified.
[ 2010-02-04 Nico provides wording. ]
Proposed resolution:
In forward_list modifiers 23.3.3.4 [forwardlist.modifiers] make the following modifications:
iterator insert_after(const_iterator position, size_type n, const T& x);...
10 Returns:
position.An iterator pointing to the first inserted copy of x or position if n == 0.template <class InputIterator> iterator insert_after(const_iterator position, InputIterator first, InputIterator last);...
13 Returns:
position.An iterator pointing to the first inserted element or position if first == last.iterator insert_after(const_iterator position, initializer_list<T> il);...
15 Returns:
position.An iterator pointing to the first inserted element or position if il is empty.template <class... Args> iterator emplace_after(const_iterator position, Args&&... args);...
17 ...
Returns: An iterator pointing to the new constructed element from args.
Section: 20.8.3 [base] Status: New Submitter: Alberto Ganesh Barbati Opened: 2009-11-30 Last modified: 2009-11-30
View all other issues in [base].
View all issues with New status.
Discussion:
A program should not be allowed to add specialization of class templates unary_function and binary_function, in force of 17.6.3.2.1 [namespace.std]/1. If a program were allowed to specialize these templates, the library could no longer rely on them to provide the intended typedefs or there might be other undesired interactions.
Proposed resolution:
Change paragraph 20.8.3 [base]/1 as follows:
1 The followingclassesclass templates are provided to simplify the typedefs of the argument and result types:. A program shall not declare specializations of these templates.
Section: 24.6.1.1 [istream.iterator.cons], 24.6.2.1 [ostream.iterator.cons.des] Status: Ready Submitter: Jonathan Wakely Opened: 2009-12-04 Last modified: 2010-03-08
View all other issues in [istream.iterator.cons].
View all issues with Ready status.
Discussion:
24.6.1.1 [istream.iterator.cons] describes the effects in terms of:
basic_istream<charT,traits>* in_stream; // exposition only3 Effects: Initializes in_stream with s.
That should be &s and similarly for 24.6.2.1 [ostream.iterator.cons.des].
[ 2009-12-23 Moved to Tentatively Ready after 6 positive votes on c++std-lib. ]
Proposed resolution:
Change 24.6.1.1 [istream.iterator.cons] like so:
istream_iterator(istream_type& s);3 Effects: Initializes in_stream with &s. value ...
And 24.6.2.1 [ostream.iterator.cons.des] like so:
ostream_iterator(ostream_type& s);1 Effects: Initializes out_stream with &s and delim with null.ostream_iterator(ostream_type& s, const charT* delimiter);2 Effects: Initializes out_stream with &s and delim with delimiter.
Section: 20.6.1 [ratio.ratio] Status: New Submitter: Vicente Juan Botet Escribá Opened: 2009-12-07 Last modified: 2009-12-17
View other active issues in [ratio.ratio].
View all other issues in [ratio.ratio].
View all issues with New status.
Discussion:
CopyConstruction and Assignment between ratios having the same normalized form. Current N3000 do not allows to copy-construct or assign ratio instances of ratio classes having the same normalized form.
Two ratio classes ratio<N1,D1> and ratio<N2,D2> have the same normalized form if
ratio<N1, D1>::num == ratio<N2, D2>::num && ratio<N1, D1>::den == ratio<N2, D2>::den
This simple example
ratio<1,3> r1; ratio<3,9> r2; r1 = r2; // (1)
fails to compile in (1). Other example
ratio<1,3> r1; ratio_subtract<ratio<2,3>, ratio<1,3>>::type r2; r1 = r2;
The nested type of ratio_subtract<ratio<2,3>, ratio<1,3>> could be ratio<3,9> so the compilation could fail. It could also be ratio<1,3> and the compilation succeeds.
In 20.6.2 [ratio.arithmetic] 3 and similar clauses
3 The nested typedef type shall be a synonym for ratio<T1, T2> where T1 has the value R1::num * R2::den - R2::num * R1::den and T2 has the value R1::den * R2::den.
the meaning of synonym let think that the result shall be a normalized ratio equivalent to ratio<T1, T2>, but there is not an explicit definition of what synonym means in this context.
Additionally we should add a typedef for accessing the normalized ratio, and change 20.6.2 [ratio.arithmetic] to return only this normalized result.
Proposed resolution:
Make ratio default constructible, copy-constructible and assignable from any ratio which has the same reduced form.
Add to 20.6.1 [ratio.ratio] synopsis
template <intmax_t N, intmax_t D = 1>
class ratio {
public:
static constexpr intmax_t num;
static constexpr intmax_t den;
typedef ratio<num, den> type;
ratio() = default;
template <intmax_t N2, intmax_t D2>
ratio(const ratio<N2, D2>&);
template <intmax_t N2, intmax_t D2>
ratio& operator=(const ratio<N2, D2>&);
};
Add to 20.6.1 [ratio.ratio]:
Two ratio classes ratio<N1,D1> and ratio<N2,D2> have the same reduced form if ratio<N1,D1>::type is the same type as ratio<N2,D2>::type
Add a new section: [ratio.cons]
Construction and assignment [ratio.cons]
template <intmax_t N2, intmax_t D2> ratio(const ratio<N2, D2>& r);Effects: Constructs a ratio object.
Remarks: This constructor shall not participate in overload resolution unless r has the same reduced form as *this.
template <intmax_t N2, intmax_t D2> ratio& operator=(const ratio<N2, D2>& r);Effects: None.
Returns: *this.
Remarks: This operator shall not participate in overload resolution unless r has the same reduced form as *this.
Change 20.6.2 [ratio.arithmetic]
Implementations may use other algorithms to compute these values. If overflow occurs, a diagnostic shall be issued.
template <class R1, class R2> struct ratio_add { typedef see below type; };The nested typedef type shall be a synonym for ratio<T1, T2>::type where T1 has the value R1::num * R2::den + R2::num * R1::den and T2 has the value R1::den * R2::den.template <class R1, class R2> struct ratio_subtract { typedef see below type; };The nested typedef type shall be a synonym for ratio<T1, T2>::type where T1 has the value R1::num * R2::den - R2::num * R1::den and T2 has the value R1::den * R2::den.template <class R1, class R2> struct ratio_multiply { typedef see below type; };The nested typedef type shall be a synonym for ratio<T1, T2>::type where T1 has the value R1::num * R2::num and T2 has the value R1::den * R2::den.template <class R1, class R2> struct ratio_divide { typedef see below type; };The nested typedef type shall be a synonym for ratio<T1, T2>::type where T1 has the value R1::num * R2::den and T2 has the value R1::den * R2::num.
Section: 23.3.7 [vector.bool] Status: Ready Submitter: Bo Persson Opened: 2009-12-09 Last modified: 2010-03-08
View other active issues in [vector.bool].
View all other issues in [vector.bool].
View all issues with Ready status.
Discussion:
The specialization for vector<bool> (23.3.7 [vector.bool]) has a constructor
vector(initializer_list<bool>);
which differs from the base template's constructor (and other containers) in that it has no allocator parameter.
[ 2009-12-16 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change the signature in the synopsis of 23.3.7 [vector.bool] to
vector(initializer_list<bool>, const Allocator& = Allocator());
Section: 20.9.4.2 [allocator.traits.members] Status: Ready Submitter: Howard Hinnant Opened: 2009-12-10 Last modified: 2010-03-08
View other active issues in [allocator.traits.members].
View all other issues in [allocator.traits.members].
View all issues with Ready status.
Discussion:
LWG issue 402 added "::" to the call to new within allocator::construct. I suspect we want to retain that fix.
[ 2009-12-13 Moved to Tentatively Ready after 7 positive votes on c++std-lib. ]
Proposed resolution:
Change 20.2.2 [allocator.requirements], table 40 "Allocator requirements":
Table 40 — Allocator requirements Expression Return type Assertion/note
pre-/post-conditionDefault a.construct(c,args) (not used) Effect: Constructs an object of type C at c ::new ((void*)c) C(forward<Args>(args)...)
Change 20.9.4.2 [allocator.traits.members], p4:
template <class T, class... Args> static void construct(Alloc& a, T* p, Args&&... args);4 Effects: calls a.construct(p, std::forward<Args>(args)...) if that call is well-formed; otherwise, invokes ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...).
Section: 20.9.4.2 [allocator.traits.members] Status: Ready Submitter: Howard Hinnant Opened: 2009-12-10 Last modified: 2010-03-08
View other active issues in [allocator.traits.members].
View all other issues in [allocator.traits.members].
View all issues with Ready status.
Discussion:
allocator_traits::select_on_container_copy_construction refers to an unknown "a":
static Alloc select_on_container_copy_construction(const Alloc& rhs);7 Returns: rhs.select_on_container_copy_construction(a) if that expression is well-formed; otherwise, rhs.
[ 2009-12-13 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change 20.9.4.2 [allocator.traits.members], p7:
static Alloc select_on_container_copy_construction(const Alloc& rhs);7 Returns: rhs.select_on_container_copy_construction(a) if that expression is well-formed; otherwise, rhs.
Section: 20.8.15.2.1 [func.wrap.func.con] Status: Ready Submitter: Jonathan Wakely Opened: 2009-12-13 Last modified: 2010-03-08
View other active issues in [func.wrap.func.con].
View all other issues in [func.wrap.func.con].
View all issues with Ready status.
Discussion:
I think std::function should require CopyConstructible for the target object.
I initially thought that MoveConstructible was enough, but it's not. If F is move-only then function's copy constructor cannot be called, but because function uses type erasure, F is not known and so the copy constructor cannot be disabled via enable_if. One option would be to throw an exception if you try to copy a function with a non-copyable target type, but I think that would be a terrible idea.
So although the constructors require that the target be initialised by std::move(f), that's only an optimisation, and a copy constructor is required.
[ 2009-12-24 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Add to 20.8.15.2.1 [func.wrap.func.con] paragraph 9:
template<class F> function(F f); template <class F, class A> function(allocator_arg_t, const A& a, F f);9 Requires: F shall be CopyConstructible. f shall be callable for argument types ArgTypes and return type R. The copy constructor and destructor of A shall not throw exceptions.
Section: 20.8.15.2.1 [func.wrap.func.con] Status: Ready Submitter: Jonathan Wakely Opened: 2009-12-13 Last modified: 2010-03-08
View other active issues in [func.wrap.func.con].
View all other issues in [func.wrap.func.con].
View all issues with Ready status.
Discussion:
In 20.8.15.2.1 [func.wrap.func.con]
template<class F> function& operator=(F f);20 Effects: function(f).swap(*this);
21 Returns: *this
This assignment operator can be called such that F is an rvalue-reference e.g.
func.operator=<F&&>(f);
There are two issues with this.
The same issues apply to function::assign.
N.B. this issue is not related to 1287 and applies whether that issue is resolved or not. The wording below assumes the resolution of LWG 1258 has been applied.
[ 2009-12-16 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
[ 201002-11 Opened by Alisdair for the purpose of merging 1258 into this issue as there is a minor conflict. ]
[ 2010-02-11 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
In 20.8.15.2.1 [func.wrap.func.con]
template<class F> function& operator=(F&& f);20 Effects: function(std::forward<F>(f)).swap(*this);
21 Returns: *this
In 20.8.15.2.2 [func.wrap.func.mod]
template<class F,Allocator Allocclass A> void assign(F&& f, const Alloc& a);3 Effects: function(
f, aallocator_arg, a, std::forward<F>(f)).swap(*this);
Update member function signature for class template in 20.8.15.2 [func.wrap.func]
template<class F> function& operator=(F&&); template<class F, class A> void assign(F&&, const A&);
Section: 20.3 [utility] Status: New Submitter: Ion Gaztañaga Opened: 2009-12-14 Last modified: 2009-12-16
View other active issues in [utility].
View all other issues in [utility].
View all issues with New status.
Discussion:
In section 20.2.2 [allocator.requirements], Table 40 — Allocator requirements, the following expression is required for allocator pointers:
Table 40 — Allocator requirements Expression Return type Assertion/note
pre-/post-conditionDefault static_cast<X::pointer>(w) X::pointer static_cast<X::pointer>(w) == p
To achieve this expression, a smart pointer writer must introduce an explicit conversion operator from smart_ptr<void> to smart_ptr<T> so that static_cast<pointer>(void_ptr) is a valid expression. Unfortunately this explicit conversion weakens the safety of a smart pointer since the following expression (invalid for raw pointers) would become valid:
smart_ptr<void> smart_v = ...; smart_ptr<T> smart_t(smart_v);
On the other hand, shared_ptr also defines its own casting functions in 20.9.11.2.10 [util.smartptr.shared.cast], and although it's unlikely that a programmer will use shared_ptr as allocator::pointer, having two different ways to do the same cast operation does not seem reasonable. A possible solution would be to replace static_cast<X::pointer>(w) expression with a user customizable (via ADL) static_pointer_cast<value_type>(w), and establish the xxx_pointer_cast functions introduced by shared_ptr as the recommended generic casting utilities of the standard.
Unfortunately, we've experienced problems in Boost when trying to establish xxx_pointer_cast as customization points for generic libraries (http://objectmix.com/c/40424-adl-lookup-explicit-template-parameters.html) because these casting functions are called with explicit template parameters and the standard says in 14.9.1 [temp.arg.explicit] p.8 "Explicit template argument specification":
8 ...But when a function template with explicit template arguments is used, the call does not have the correct syntactic form unless there is a function template with that name visible at the point of the call. If no such name is visible, the call is not syntactically well-formed and argument-dependent lookup does not apply.
So we can do this:
template<class BasePtr>
void generic_ptr_swap(BasePtr p)
{
//ADL customization point
swap(p, p);
//...
}
but not the following:
template<class BasePtr>
void generic_ptr_algo(BasePtr p)
{
typedef std::pointer_traits<BasePtr>::template
rebind<Derived> DerivedPtr;
DerivedPtr dp = static_pointer_cast<Derived>(p);
}
The solution to make static_pointer_cast a customization point is to add a generic declaration (no definition) of static_pointer_cast in a namespace (like std) and apply "using std::static_pointer_cast" declaration to activate ADL:
namespace std{
template<typename U, typename T>
unspecified
static_pointer_cast(T&&) = delete;
}
template<class BasePtr>
void generic_ptr_algo(BasePtr p)
{
typedef std::pointer_traits<BasePtr>::template
rebind<Derived> DerivedPtr;
//ADL applies because static_pointer_cast is made
// visible according to [temp.arg.explicit]/8
using std::static_pointer_cast;
DerivedPtr dp = static_pointer_cast<Derived>(p);
//...
}
A complete solution will need also the definition of static_pointer_cast for raw pointers, and this definition has been present in Boost (http://www.boost.org/boost/ pointer_cast.hpp) for years.
Proposed resolution:
Add to section 20.3 [utility] Utility components, Header <utility> synopsis:
// 20.3.X, generic pointer cast functions
template<typename U, typename T>
unspecified
static_pointer_cast(T&&) = delete;
template<typename U, typename T>
unspecified
dynamic_pointer_cast(T&&) = delete;
template<typename U, typename T>
unspecified
const_pointer_cast(T&&) = delete;
//Overloads for raw pointers
template<typename U, typename T>
auto static_pointer_cast(T* t) -> decltype(static_cast<U*>(t)) {
return static_cast<U*>(t);
}
template<typename U, typename T>
auto dynamic_pointer_cast(T* t) -> decltype(dynamic_cast<U*>(t)) {
return dynamic_cast<U*>(t);
}
template<typename U, typename T>
auto const_pointer_cast(T* t) -> decltype(const_cast<U*>(t)) {
return const_cast<U*>(t);
}
Add to section 20.3 [utility] Utility components, a new subclause 20.3.X Pointer cast utilities [pointer.cast]:
20.3.X Pointer cast utilities [pointer.cast]
1 The library defines generic pointer casting function templates so that template code can explicitly make these names visible and activate argument-dependent lookup for pointer cast calls.
//Generic declarations template<typename U, typename T> unspecified static_pointer_cast(T&&) = delete; template<typename U, typename T> unspecified dynamic_pointer_cast(T&&) = delete; template<typename U, typename T> unspecified const_pointer_cast(T&&) = delete;2 The library also defines overloads of these functions for raw pointers.
//Overloads for raw pointers template<typename U, typename T> auto static_pointer_cast(T* t) -> decltype(static_cast<U*>(t));Returns: static_cast<U*>(t)template<typename U, typename T> auto dynamic_pointer_cast(T* t) -> decltype(dynamic_cast<U*>(t));Returns: dynamic_cast<U*>(t)template<typename U, typename T> auto const_pointer_cast(T* t) -> decltype(const_cast<U*>(t));Returns: const_cast<U*>(t)[Example:
#include <utility> //static_pointer_cast #include <memory> //pointer_traits class Base{}; class Derived : public Base{}; template<class BasePtr> void generic_pointer_code(BasePtr b) { typedef std::pointer_traits<BasePtr>::template rebind<Derived> DerivedPtr; using std::static_pointer_cast; //ADL applies now that static_pointer_cast is visible DerivedPtr d = static_pointer_cast<Derived>(b); }— end example]
Replace in section 20.2.2 [allocator.requirements] Table 40 — Allocator requirements, the following table entries for allocator pointers:
Table 40 — Allocator requirements Expression Return type Assertion/note
pre-/post-conditionDefault static_pointer_cast< X::pointerT>(w)X::pointer static_pointer_cast< X::pointerT>(w) == pstatic_pointer_cast< X::const_pointerconst T>(w)X::const_pointer static_pointer_cast< X::const_pointerconst T>(z) == q
Section: 20.8 [function.objects] Status: New Submitter: Daniel Krügler Opened: 2009-12-14 Last modified: 2009-12-19
View all other issues in [function.objects].
View all issues with New status.
Discussion:
This issue is a follow-up of the discussion on issue 870 during the 2009 Santa Cruz meeting.
The class templates unary_function and binary_function are actually very simple typedef providers,
namespace std {
template <class Arg, class Result>
struct unary_function {
typedef Arg argument_type;
typedef Result result_type;
};
template <class Arg1, class Arg2, class Result>
struct binary_function {
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef Result result_type;
};
}
which may be used as base classes (similarly to the iterator template), but were originally not intended as a customization point. The SGI documentation introduced the concept Adaptable Unary Function as function objects "with nested typedefs that define its argument type and result type" and a similar definition for Adaptable Binary Function related to binary_function. But as of TR1 a protocol was introduced that relies on inheritance relations based on these types. 20.8.5 [refwrap]/3 b. 3 requires that a specialization of reference_wrapper<T> shall derive from unary_function, if type T is "a class type that is derived from std::unary_function<T1, R>" and a similar inheritance-based rule for binary_function exists as well.
As another disadvantage it has been pointed out in the TR1 issue list, N1837 (see section 10.39), that the requirements of mem_fn 20.8.14 [func.memfn]/2+3 to derive from std::unary_function/std::binary_function under circumstances, where the provision of corresponding typedefs would be sufficient, unnecessarily prevent implementations that take advantage of empty-base-class- optimizations.
Both requirements should be relaxed in the sense that the reference_wrapper should provide typedef's argument_type, first_argument_type, and second_argument_type based on similar rules as the weak result type rule (20.8.2 [func.require]/3) does specify the presence of result_type member types.
For a related issue see also 1279.
Proposed resolution:
[ The here proposed resolution is an attempt to realize the common denominator of the reflector threads c++std-lib-26011, c++std-lib-26095, and c++std-lib-26124. ]
Change 20.8.3 [base]/1 as indicated: [The intend is to provide an alternative fix for issue 1279 and some editorial harmonization with existing wording in the library, like 24.4.2 [iterator.basic]/1]
1 The following class templates are provided to simplify the definition of typedefs of the argument and result types for function objects. The behavior of a program that adds specializations for any of these templates is undefined.
:namespace std { template <class Arg, class Result> struct unary_function { typedef Arg argument_type; typedef Result result_type; }; } namespace std { template <class Arg1, class Arg2, class Result> struct binary_function { typedef Arg1 first_argument_type; typedef Arg2 second_argument_type; typedef Result result_type; }; }
Change 20.8.5 [refwrap], class template reference_wrapper synopsis as indicated: [The intent is to remove the requirement that reference_wrapper derives from unary_function or binary_function if the situation requires the definition of the typedefs argument_type, first_argument_type, or second_argument_type. This change is suggested, because the new way of definition uses the same strategy as the weak result type specification applied to argument types, which provides the following advantages: It creates less potential conflicts between [u|bi]nary_function bases and typedefs in a function object and it ensures that user-defined function objects which provide typedefs but no such bases are handled as first class citizens.]
namespace std {
template <class T> class reference_wrapper
: public unary_function<T1, R> // see below
: public binary_function<T1, T2, R> // see below
{
public :
// types
typedef T type;
typedef see below result_type; // not always defined
typedef see below argument_type; // not always defined
typedef see below first_argument_type; // not always defined
typedef see below second_argument_type; // not always defined
// construct/copy/destroy
...
};
Change 20.8.5 [refwrap]/3 as indicated: [The intent is to remove the requirement that reference_wrapper derives from unary_function if the situation requires the definition of the typedef argument_type and result_type. Note that this clause does concentrate on argument_type alone, because the result_type is already ruled by p. 2 via the weak result type specification. The new way of specifying argument_type is equivalent to the weak result type specification]
3 The template instantiation reference_wrapper<T> shall
be derived from std::unary_function<T1, R>define a nested type named argument_type as a synonym for T1 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- a pointer to member function R T0::f cv (where cv represents the member function's cv-qualifiers); the type T1 is cv T0*
- a class type
that is derived from std::unary_function<T1, R>with a member type argument_type; the type T1 is T::argument_type
Change 20.8.5 [refwrap]/4 as indicated: [The intent is to remove the requirement that reference_wrapper derives from binary_function if the situation requires the definition of the typedef first_argument_type, second_argument_type, and result_type. Note that this clause does concentrate on first_argument_type and second_argument_type alone, because the result_type is already ruled by p. 2 via the weak result type specification. The new way of specifying first_argument_type and second_argument_type is equivalent to the weak result type specification]
The template instantiation reference_wrapper<T> shall
be derived from std::binary_function<T1, T2, R>define two nested types named first_argument_type and second_argument_type as a synonym for T1 and T2, respectively, only if the type T is any of the following:
- a function type or a pointer to function type taking two arguments of types T1 and T2
and returning R- a pointer to member function R T0::f(T2) cv (where cv represents the member function's cv-qualifiers); the type T1 is cv T0*
- a class type
that is derived from std::binary_function<T1, T2, R>with member types first_argument_type and second_argument_type; the type T1 is T::first_argument_type and the type T2 is T::second_argument_type
Change 20.8.14 [func.memfn]/2+3 as indicated: [The intent is to remove the requirement that mem_fn's return type has to derive from [u|bi]nary_function. The reason for suggesting the change here is to better support empty-base-class optimization choices as has been pointed out in N1837]
2 The simple call wrapper shall
be derived from std::unary_function<cv T*, Ret>define two nested types named argument_type and result_type as a synonym for cv T* and Ret, respectively, when pm is a pointer to member function with cv-qualifier cv and taking no arguments, where Ret is pm's return type.3 The simple call wrapper shall
be derived from std::binary_function<cv T*, T1, Ret>define three nested types named first_argument_type, second_argument_type, and result_type as a synonym for cv T*, T1, and Ret, respectively, when pm is a pointer to member function with cv-qualifier cv and taking one argument of type T1, where Ret is pm's return type.
Section: 30.6.5 [futures.promise] Status: New Submitter: Jonathan Wakely Opened: 2009-12-18 Last modified: 2009-12-19
View other active issues in [futures.promise].
View all other issues in [futures.promise].
View all issues with New status.
Discussion:
In 30.6.5 [futures.promise]
Does promise<R>::set_value return normally if the copy/move constructor of R throws?
The exception could be caught and set using promise<R>::set_exception, or it could be allowed to leave the set_value call, but it's not clear which is intended. I suggest the exception should not be caught.
N.B. This doesn't apply to promise<R&>::set_value or promise<void>::set_value because they don't construct a new object.
Proposed resolution:
Change 30.6.5 [futures.promise]/18:
18 Throws: future_error if its associated state is already ready or, for the first version an exception thrown by the copy constructor of R, or for the second version an exception thrown by the move constructor of R.
Section: 20.8.15.2.1 [func.wrap.func.con] Status: New Submitter: Daniel Krügler Opened: 2009-12-19 Last modified: 2009-12-21
View other active issues in [func.wrap.func.con].
View all other issues in [func.wrap.func.con].
View all issues with New status.
Discussion:
Some parts of the specification of std::function is unnecessarily restricted to a subset of all callable types (as defined in 20.8.1 [func.def]/3), even though the intent clearly is to be usable for all of them as described in 20.8.15.2 [func.wrap.func]/1. This argument becomes strengthened by the fact that current C++0x-compatible compilers work fine with them:
#include <functional>
#include <iostream>
struct A
{
int foo(int i) const {return i+1;}
};
struct B
{
int mem;
};
int main()
{
std::function<int(const A&, int)> f(&A::foo);
A a;
std::cout << f(a, 1) << '\n';
std::cout << f.target_type().name() << '\n';
typedef int (A::* target_t)(int) const;
target_t* p = f.target<target_t>();
std::cout << (p != 0) << '\n';
std::function<int(B&)> f2(&B::mem);
B b = { 42 };
std::cout << f2(b) << '\n';
std::cout << f2.target_type().name() << '\n';
typedef int (B::* target2_t);
target2_t* p2 = f2.target<target2_t>();
std::cout << (p2 != 0) << '\n';
}
The problematics passages are 20.8.15.2.1 [func.wrap.func.con]/10:
template<class F> function(F f); template <class F, class A> function(allocator_arg_t, const A& a, F f);...
10 Postconditions: !*this if any of the following hold:
- f is a NULL function pointer.
- f is a NULL member function pointer.
- F is an instance of the function class template, and !f
because it does not consider pointer to data member and all constraints based on function objects which like 20.8.15.2 [func.wrap.func]/2 or 20.8.15.2.5 [func.wrap.func.targ]/3. The latter two will be resolved by the proposed resolution of 870 and are therefore not handled here.
Proposed resolution:
Change 20.8.15.2.1 [func.wrap.func.con]/10+11 as indicated:
template<class F> function(F f); template <class F, class A> function(allocator_arg_t, const A& a, F f);...
10 Postconditions: !*this if any of the following hold:
- f is a NULL function pointer.
- f is a NULL pointer to member
function pointer.- F is an instance of the function class template, and !f
11 Otherwise, *this targets a copy of f
or, initialized with std::move(f)if f is not a pointer to member function, and targets a copy of mem_fn(f) if f is a pointer to member function. [Note: implementations are encouraged to avoid the use of dynamically allocated memory for small function objects, for example, where f's target is an object holding only a pointer or reference to an object and a member function pointer. — end note]
Section: 20.9.10.3 [unique.ptr.runtime] Status: Ready Submitter: Daniel Krügler Opened: 2009-12-20 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
Addresses UK 211
As a response to UK 211 LWG issue 1021 has replaced the unspecified-pointer-type by nullptr_t to allow assignment of type-safe null-pointer literals in the non-array form of unique_ptr::operator=, but did not the same for the specialization for arrays of runtime length. But without this parallel change of the signature we have a status quo, where unique_ptr<T[], D> declares a member function which is completely unspecified.
[ 2009-12-21 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
In 20.9.10.3 [unique.ptr.runtime], class template unique_ptr<T[], D> synopsis, change as indicated:
// assignment unique_ptr& operator=(unique_ptr&& u); unique_ptr& operator=(unspecified-pointer-typenullptr_t);
Section: 20.8.2 [func.require] Status: New Submitter: Jens Maurer Opened: 2009-12-21 Last modified: 2009-12-21
View other active issues in [func.require].
View all other issues in [func.require].
View all issues with New status.
Discussion:
The current wording in the standard makes it hard to discriminate the difference between a "call wrapper" as defined in 20.8.1 [func.def]/5+6:
5 A call wrapper type is a type that holds a callable object and supports a call operation that forwards to that object.
6 A call wrapper is an object of a call wrapper type.
and a "forwarding call wrapper" as defined in 20.8.2 [func.require]/4:
4 [..] A forwarding call wrapper is a call wrapper that can be called with an argument list. [Note: in a typical implementation forwarding call wrappers have an overloaded function call operator of the form
template<class... ArgTypes> R operator()(ArgTypes&&... args) cv-qual;— end note]
Reason for this lack of clear difference seems to be that the wording adaption to variadics and rvalues that were applied after it's original proposal in N1673:
[..] A forwarding call wrapper is a call wrapper that can be called with an argument list t1, t2, ..., tN where each ti is an lvalue. The effect of calling a forwarding call wrapper with one or more arguments that are rvalues is implementation defined. [Note: in a typical implementation forwarding call wrappers have overloaded function call operators of the form
template<class T1, class T2, ..., class TN> R operator()(T1& t1, T2& t2, ..., TN& tN) cv-qual;— end note]
combined with the fact that the word "forward" has two different meanings in this context. This issue attempts to clarify the difference better.
Proposed resolution:
Change 20.8.2 [func.require]/4 as indicated:
4 [..] A forwarding call wrapper is a call wrapper that can be called with an arbitrary argument list and uses perfect forwarding to deliver the arguments to the wrapped callable object. [Note: in a typical implementation forwarding call wrappers have an overloaded function call operator of the form
template<class... ArgTypes> R operator()(ArgTypes&&... args) cv-qual;— end note]
Section: 20.8.2 [func.require] Status: New Submitter: Daniel Krügler Opened: 2009-12-22 Last modified: 2009-12-23
View other active issues in [func.require].
View all other issues in [func.require].
View all issues with New status.
Discussion:
20.8.2 [func.require]/3 b 1 says
3 If a call wrapper (20.8.1 [func.def]) has a weak result type the type of its member type result_type is based on the type T of the wrapper's target object (20.8.1 [func.def]):
- if T is a function, reference to function, or pointer to function type, result_type shall be a synonym for the return type of T;
- [..]
The first two enumerated types (function and reference to function) can never be valid types for T, because
20.8.1 [func.def]/7
7 A target object is the callable object held by a call wrapper.
and 20.8.1 [func.def]/3
3 A callable type is a pointer to function, a pointer to member function, a pointer to member data, or a class type whose objects can appear immediately to the left of a function call operator.
exclude functions and references to function as "target objects".
Proposed resolution:
Change 20.8.2 [func.require]/3 b 1 as indicated:
3 If a call wrapper (20.8.1 [func.def]) has a weak result type the type of its member type result_type is based on the type T of the wrapper's target object (20.8.1 [func.def]):
- if T is a
function, reference to function, orpointer to function type, result_type shall be a synonym for the return type of T;- [..]
Section: 20.9.10.4 [unique.ptr.special] Status: New Submitter: Daniel Krügler Opened: 2009-12-23 Last modified: 2009-12-23
View all issues with New status.
Discussion:
The comparison functions of unique_ptr currently directly delegate to the underlying comparison functions of unique_ptr<T, D>::pointer. This is disadvantageous, because this would not guarantee to induce a total ordering for native pointers and it is hard to define a total order for mixed types anyway.
The currently suggested resolution for shared_ptr comparison as of 1262 uses a normalization strategy: They perform the comparison on the composite pointer type (5.9 [expr.rel]). This is not exactly possible for unique_ptr in the presence of user-defined pointer-like types but the existing definition of std::duration comparison as of 20.10.3.6 [time.duration.comparisons] via common_type of both argument types demonstrates a solution of this problem. The approach can be seen as the general way to define a composite pointer type and this is the approach which is used for here suggested wording change.
For consistency reasons I would have preferred the same normalization strategy for == and !=, but Howard convinced me not to do so (now).
Proposed resolution:
[ Based on N3000 wording. It should be considered to replace the suggested changes of LWG issue 834, bullet 17 ]
Change 20.9.10.4 [unique.ptr.special] as indicated:
In the function descriptions that follow, CT represents common_type<unique_ptr<T1, D1>::pointer, unique_ptr<T2, D2>::pointer>::type, where T1, D1, T2 and D2 are template argument types of these function templates. Additional to the requirements described below, the following requirements shall be satisfied for the relational operator function templates of unique_ptr: CT shall satisfy the LessThanComparable requirements. If !is_convertible<unique_ptr<T1, D1>::pointer, CT>::value || !is_convertible<unique_ptr<T2, D2>::pointer, CT>::value, the program shall be ill-formed.
template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y);1 Effects: Calls x.swap(y).template <class T1, class D1, class T2, class D2> bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);Requires: The variable definition bool b = x.get() == y.get(); shall be well formed, shall have well-defined behavior, and shall not exit via an exception.
2 Returns: x.get() == y.get().
Throws: nothing.
template <class T1, class D1, class T2, class D2> bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);Requires: The variable definition bool b = x.get() != y.get(); shall be well formed, shall have well-defined behavior, and shall not exit via an exception.
3 Returns: x.get() != y.get().
template <class T1, class D1, class T2, class D2> bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);The expression less<CT>()(x.get(), y.get()) shall not exit via an exception.
4 Returns:
x.get() < y.get()less<CT>()(x.get(), y.get()).Throws: nothing.
template <class T1, class D1, class T2, class D2> bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);5
ReturnsEffects:x.get() <= y.get()Equivalent to: return !(y < x).template <class T1, class D1, class T2, class D2> bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);6
ReturnsEffects:x.get() > y.get()Equivalent to: return (y < x).template <class T1, class D1, class T2, class D2> bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);7
ReturnsEffects:x.get() >= y.get()Equivalent to: return !(x < y).
Section: 22.2 [locale.syn] Status: Ready Submitter: Alisdair Meredith Opened: 2009-12-25 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
The <locale> synopsis in 22.2 [locale.syn] calls out an explicit specialization for ctype_byname<char>, however no such specialization is defined in the standard. The only reference I can find to ctype_byname<char> is 22.3.1.1.2 [locale.facet]:Table 77 — Required specializations (for facets) which also refers to ctype_byname<wchar_t> which has no special consideration.
Is the intent an explicit instantiation which would use a slightly different syntax? Should the explicit specialization simply be struck?
[ 2010-01-31 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
22.2 [locale.syn]
Strike the explicit specialization for ctype_byname<char> from the <locale> synopsis
... template <class charT> class ctype_byname;template <> class ctype_byname<char>; // specialization...
Section: 27.7.4 [ext.manip] Status: Ready Submitter: Alisdair Meredith Opened: 2009-12-25 Last modified: 2010-03-08
View all other issues in [ext.manip].
View all issues with Ready status.
Discussion:
Extended Manipulators 27.7.4 [ext.manip] p8 defines the semantics of get_time in terms of a function f.
template <class charT, class traits>
void f(basic_ios<charT, traits>& str, struct tm* tmb, const charT* fmt) {
typedef istreambuf_iterator<charT, traits> Iter;
typedef time_get<charT, Iter> TimeGet;
ios_base::iostate err = ios_base::goodbit;
const TimeGet& tg = use_facet<TimeGet>(str.getloc());
tm.get(Iter(str.rdbuf()), Iter(), str, err, tmb, fmt, fmt + traits::length(fmt));
if (err != ios_base::goodbit)
str.setstate(err):
}
Note the call to tm.get. This is clearly an error, as tm is a type and not an object. I believe this should be tg.get, rather than tm, but this is not my area of expertise.
[ 2010-01-14 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change 27.7.4 [ext.manip] p8:
template <class charT, class traits>
void f(basic_ios<charT, traits>& str, struct tm* tmb, const charT* fmt) {
typedef istreambuf_iterator<charT, traits> Iter;
typedef time_get<charT, Iter> TimeGet;
ios_base::iostate err = ios_base::goodbit;
const TimeGet& tg = use_facet<TimeGet>(str.getloc());
tgm.get(Iter(str.rdbuf()), Iter(), str, err, tmb, fmt, fmt + traits::length(fmt));
if (err != ios_base::goodbit)
str.setstate(err):
}
Section: 23.2.4 [associative.reqmts], 23.2.5 [unord.req] Status: New Submitter: Nicolai Josuttis Opened: 2010-01-03 Last modified: 2010-01-04
View other active issues in [associative.reqmts].
View all other issues in [associative.reqmts].
View all issues with New status.
Discussion:
According to the new naming scheme introduced with N2680
vector<T> v; v.emplace(v.begin(),x,y,z)
now has a different semantics than
set<T> s; s.emplace(s.begin(),x,y,z);
While the version for vectors takes the first argument as position and the remaining for construction, the version for sets takes all arguments for construction.
IMO, this is a serious design mistake for a couple of reasons:
First, in principle, all STL member functions should have the same behavior with the same member function to avoid confusion and allow to write proper generic code.
In fact, when I write the following simple function template:
template <typename T>
void doEmplace (T& cont)
{
cont.emplace(cont.begin(),"nico","josuttis",42);
}
the semantics depends on the type of the container.
In addition, I also guess using the name emplace_hint() instead of emplace() for associative containers is a design mistake. According to my knowledge, it was a design goal of the original STL to provide ONE insert function, which works for ALL containers. This was insert(pos,val).
The trick to declare pos as a hint, allowed that we could implement a generic insert for all containers. Now, with the new emplace naming scheme, this trick is gone for the new kind of insertion.
I consider this to be a serious design penalty because once this is specified we can't fix that without breaking backward compatibility.
However, we have two choices for a fix:
Proposed resolution:
In 23.2.5 [unord.req], change:
Table 96 — Associative container requirements (in addition to container) expression Return type Assertion/note pre-/post-condition Post-condition ... a_uniq.emplace_value(args) pair<iterator, bool> inserts a T object t constructed with std::forward<Args>(args)...
if and only if there is no element in the container with key equivalent to the key of t.
The bool component of the returned pair is true if and only if the insertion takes place, and the iterator component of the pair points to the element with key equivalent to the key of t.logarithmic a_eq.emplace_value(args) iterator inserts a T object t constructed with std::forward<Args>(args)... and returns the iterator pointing to the newly inserted element. logarithmic a.emplace _hint(p,args)iterator equivalent to a.emplace_value(std::forward<Args>(args)...). Return value is an iterator pointing to the element with the key equivalent to the newly inserted element. The const_iterator p is a hint pointing to where the search should start. Implementations are permitted to ignore the hint. logarithmic in general, but amortized constant if the element is inserted right after p ...
In 23.2.5 [unord.req], change:
Table 98 — Unordered associative container requirements (in addition to container) expression Return type Assertion/note pre-/post-condition Post-condition ... a_uniq.emplace_value(args) pair<iterator, bool> inserts a T object t constructed with std::forward<Args>(args)... if and only if there is no element in the container with key equivalent to the key of t. The bool component of the returned pair is true if and only if the insertion takes place, and the iterator component of the pair points to the element with key equivalent to the key of t. Average case O(1), worst case O(a_uniq.size()). a_eq.emplace_value(args) iterator inserts a T object t constructed with std::forward<Args>(args)... and returns the iterator pointing to the newly inserted element. Average case O(1), worst case O(a_eq.size()). a.emplace _hint(p,args)iterator equivalent to a.emplace_value(std::forward<Args>(args)...). Return value is an iterator pointing to the element with the key equivalent to the newly inserted element. The const_iterator p is a hint pointing to where the search should start. Implementations are permitted to ignore the hint. Average case O(1), worst case O(a.size()). ...
In 23.4.1 [map], 23.4.3 [set], 23.5.1 [unord.map], 23.5.3 [unord.set], change:
// modifiers:
template <class... Args> pair<iterator, bool> emplace_value(Args&&... args);
template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args);
In 23.4.2 [multimap], 23.4.4 [multiset], 23.5.2 [unord.multimap], 23.5.4 [unord.multiset], change:
// modifiers:
template <class... Args> iterator emplace_value(Args&&... args);
template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args);
Section: 20.9.10.2 [unique.ptr.single], 20.9.11.2 [util.smartptr.shared] Status: Ready Submitter: Stephan T. Lavavej Opened: 2010-01-23 Last modified: 2010-03-08
View other active issues in [unique.ptr.single].
View all other issues in [unique.ptr.single].
View all issues with Ready status.
Discussion:
N3000 20.9.11.2 [util.smartptr.shared]/1 still says:
template <class Y, class D> explicit shared_ptr(const unique_ptr<Y, D>& r) = delete; template <class Y, class D> shared_ptr& operator=(const unique_ptr<Y, D>& r) = delete;
I believe that this is unnecessary now that "rvalue references v2" prevents rvalue references from binding to lvalues, and I didn't see a Library Issue tracking this.
[ 2010-02-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Strike from 20.9.10.2 [unique.ptr.single]:
template <class T, class D = default_delete<T>> class unique_ptr {
...
unique_ptr(const unique_ptr&) = delete;
template <class U, class E> unique_ptr(const unique_ptr<U, E>&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
template <class U, class E> unique_ptr& operator=(const unique_ptr<U, E>&) = delete;
};
Strike from 20.9.11.2 [util.smartptr.shared]:
template<class T> class shared_ptr {
...
template <class Y, class D> explicit shared_ptr(const unique_ptr<Y, D>& r) = delete;
...
template <class Y, class D> shared_ptr& operator=(const unique_ptr<Y, D>& r) = delete;
...
};
Section: 30.6.8 [futures.atomic_future] Status: New Submitter: Alisdair Meredith Opened: 2010-01-23 Last modified: 2010-01-23
View all other issues in [futures.atomic_future].
View all issues with New status.
Discussion:
The revised futures package in the current working paper simplified the is_ready/has_exception/has_value set of APIs, replacing them with a single 'valid' method. This method is used in many places to signal pre- and post- conditions, but that edit is not complete.
Atomic future retains the extended earlier API, and provides defined, synchronized behaviour for all calls. However, some preconditions and throws clauses are missing, which can easily be built around the new valid() api. Note that for consistency, I suggest is_ready/has_exception/has_value throw an exception if valid() is not true, rather than return false. I think this is implied by the existing pre-condition on is_ready.
[ 2010-01-23 See discussion starting with Message c++std-lib-26666. ]
Proposed resolution:
Insert the following extra paragraphs:
In 30.6.8 [futures.atomic_future]
bool is_ready() const;17
PreconditionRequires: valid() == true.18 Returns: true only if the associated state is ready.
Throws: future_error with an error condition of no_state if the precondition is not met.
bool has_exception() const;Requires: valid() == true.
19 Returns: true only if the associated state is ready and contains an exception.
Throws: future_error with an error condition of no_state if the precondition is not met.
bool has_value() const;Requires: valid() == true.
20 Returns: true only if the associated state is ready and contains a value.
Throws: future_error with an error condition of no_state if the precondition is not met.
void wait() const;Requires: valid() == true.
22 Effects: blocks until ...
Throws: future_error with an error condition of no_state if the precondition is not met.
template <class Rep, class Period> bool wait_for(const chrono::duration<Rep, Period>& rel_time) const;Requires: valid() == true.
23 Effects: blocks until ...
24 Returns: true only if ...
Throws: future_error with an error condition of no_state if the precondition is not met.
template <class Clock, class Duration> bool wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;Requires: valid() == true.
25 Effects: blocks until ...
26 Returns: true only if ...
Throws: future_error with an error condition of no_state if the precondition is not met.
Section: 23.3.1 [array] Status: Ready Submitter: Nicolai Josuttis Opened: 2010-01-24 Last modified: 2010-03-08
View all other issues in [array].
View all issues with Ready status.
Discussion:
Class <array> is the only sequence container class that has no types pointer and const_pointer defined. You might argue that this makes no sense because there is no allocator support, but on the other hand, types reference and const_reference are defined for array.
[ 2010-02-11 Moved to Tentatively Ready after 6 positive votes on c++std-lib. ]
Proposed resolution:
Add to Class template array 23.3.1 [array]:
namespace std {
template <class T, size_t N >
struct array {
...
typedef T value_type;
typedef T * pointer;
typedef const T * const_pointer;
...
};
}
Section: 18.8.5 [propagation] Status: New Submitter: Daniel Krügler Opened: 2010-01-26 Last modified: 2010-01-27
View other active issues in [propagation].
View all other issues in [propagation].
View all issues with New status.
Discussion:
The current requirements for a conforming implementation of std::exception_ptr (18.8.5 [propagation]/1-6) does not clarify whether the expression
e1 != e2 e1 != nullptr
with e1 and e2 being two values of type std::exception_ptr are supported or not. Reason for this oddity is that the concept EqualityComparable does not provide operator !=.
For the same reason programmers working against the types X::pointer, X::const_pointer, X::void_pointer, and X::const_void_pointer of any allocator concept X (20.2.2 [allocator.requirements]/4 + Table 40) in a generic context can not rely on the availability of the != operation, which is rather unnatural and error-prone.
Proposed resolution:
Section: 25.4.7 [alg.min.max] Status: New Submitter: Niels Dekker Opened: 2010-02-02 Last modified: 2010-02-15
View other active issues in [alg.min.max].
View all other issues in [alg.min.max].
View all issues with New status.
Discussion:
In San Francisco, June 2008, N2722 was adopted, replacing the variadic templates min, max, and minmax by overloads that have an initializer_list<T> parameter. The paper showed benchmark results wherein initializer_list versions of min appeared to outperform the corresponding variadic template. Unfortunately, in October 2009 a very serious error was detected in the benchmark. (c++std-lib-25210). In fact, an initializer_list<T> version of min often appears to perform worse than the corresponding variadic template, especially when T has an expensive copy constructor (c++std-lib-25253, http://www.xs4all.nl/~nd/dekkerware/issues/n2772_fix).
IMO, the biggest problem of the initializer_list overloads is that they pass and return T objects by value. Which has the following consequences:
In the future, this problem might be solvable by using an initializer_list of const references, instead:
const T& min(initializer_list<const T&>); const T& max(initializer_list<const T&>); pair<const T&, const T&> minmax(initializer_list<const T&>);
It is unlikely that C++0x will support initializer_list<const T&>, but technically it seems possible to add such a language feature after C++0x (c++std-core-15428).
Variadic templates of min, max, and minmax, as proposed by N2551 (Sylvain Pion), do have some other advantages over initializer_list overloads:
Unfortunately, the variadic templates of min, max, and minmax may still need further improvement, before having them in the Standard Library. Especially the optional Compare parameter appears to be a concern. So for this moment I recommend to keep both versions out of C++0x, and postpone further discussion until after C++0x.
Proposed resolution:
Remove both variadic templates and initializer_list overloads of min, max, and minmax from the synopsis in 25.1 [algorithms.general] and from 25.4.7 [alg.min.max].
[ Note: This proposed resolution will resolve LWG 915 as NAD. ]
Section: 20.2.1 [utility.arg.requirements] Status: Ready Submitter: Daniel Krügler Opened: 2010-02-03 Last modified: 2010-03-08
View other active issues in [utility.arg.requirements].
View all other issues in [utility.arg.requirements].
View all issues with Ready status.
Discussion:
Table 33 — MoveConstructible requirements [moveconstructible] and Table 34 — CopyConstructible requirements [copyconstructible] support solely the following expression:
T t(rv)
where rv is defined to be as "non-const rvalue of type T" and t as a "modifiable lvalue of type T" in 20.2.1 [utility.arg.requirements]/1.
This causes two different defects:
We cannot move/copy-initialize a const lvalue of type T as in:
int get_i(); const int i1(get_i());
both in Table 33 and in Table 34.
The single support for
T t(rv)
in case of CopyConstructible means that we cannot provide an lvalue as a source of a copy as in
const int& get_lri(); int i2(get_lri());
I believe this second defect is due to the fact that this single expression supported both initialization situations according to the old (implicit) lvalue reference -> rvalue reference conversion rules.
Finally [copyconstructible] refers to some name u which is not part of the expression, and both [copyconstructible] and [moveconstructible] should support construction expressions from temporaries - this would be a stylistic consequence in the light of the new DefaultConstructible requirements and compared with existing requirements (see e.g. Container requirements or the output/forward iterator requirements)..
[ 2010-02-09 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
[ 2010-02-10 Reopened. The proposed wording of 1283 has been merged here. ]
[ 2010-02-10 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
Change 20.2.1 [utility.arg.requirements]/1 as indicated: [This change suggestion is motivated to make type descriptions clearer: First, a, b, and c may also be non-const T. Second, u is described in a manner consistent with the container requirements tables.]
1 The template definitions in the C++ standard library refer to various named requirements whose details are set out in tables 31-38. In these tables, T is an object or reference type to be supplied by a C++ program instantiating a template; a, b, and c are values of type (possibly const) T; s and t are modifiable lvalues of type T; u denotes an identifier;is a value of type (possibly const) T; andrv is annon-constrvalue of type T; and v is an lvalue of type (possibly const) T or an rvalue of type const T.
In 20.2.1 [utility.arg.requirements] Table 33 ([moveconstructible]) change as indicated [Note: The symbol u is defined to be either a const or a non-const value and is the right one we need here]:
Table 33 — MoveConstructible requirements [moveconstructible] Expression Post-condition T tu(rv);tu is equivalent to the value of rv before the constructionT(rv) T(rv) is equivalent to the value of rv before the construction [Note: There is no requirement on the value of rv after the construction.rv remains a valid object. Its state is unspecified. — end note]
In 20.2.1 [utility.arg.requirements] Table 34 ([copyconstructible]) change as indicated [Note: The symbol u is defined to be either a const or a non-const value and is the right one we need here. The expressions using a are recommended to ensure that lvalues are supported as sources of the copy expression]:
Table 34 — CopyConstructible requirements [copyconstructible]
(in addition to MoveConstructible)Expression Post-condition T tu(rv);the value of uv is unchanged and is equivalent totuT(v) the value of v is unchanged and is equivalent to T(v) [Note: A type that satisfies the CopyConstructible requirements also satisfies the MoveConstructible requirements. — end note]
In Table 35 — MoveAssignable requirements [moveassignable] change as indicated:
Table 35 — MoveAssignable requirements [moveassignable] Expression Return type Return value Post-condition t = rv T& t t is equivalent to the value of rv before the assigment. [Note: There is no requirement on the value of rv after the assignment.rv remains a valid object. Its state is unspecified. — end note]
In 20.2.1 [utility.arg.requirements] change Table 36 as indicated:
Table 36 — CopyAssignable requirements [copyassignable]
(in addition to MoveAssignable)Expression Return type Return value Post-condition t = uvT& t t is equivalent to uv, the value ofuv is unchanged[Note: A type that satisfies the CopyAssignable requirements also satisfies the MoveAssignable requirements. — end note]
Section: 23.3.3.5 [forwardlist.ops] Status: New Submitter: Howard Hinnant Opened: 2010-02-05 Last modified: 2010-02-05
View other active issues in [forwardlist.ops].
View all other issues in [forwardlist.ops].
View all issues with New status.
Discussion:
We've moved 1133 to Tentatively Ready and I'm fine with that.
1133 adds lvalue-references to the splice signatures for list. So now list can splice from lvalue and rvalue lists (which was the intent of the original move papers btw). During the discussion of this issue it was mentioned that if we want to give the same treatment to forward_list, that should be a separate issue.
This is that separate issue.
Consider the following case where you want to splice elements from one place in a forward_list to another. Currently this must be coded like so:
fl.splice_after(to_here, std::move(fl), from1, from2);
This looks pretty shocking to me. I would expect to be able to code instead:
fl.splice_after(to_here, fl, from1, from2);
but we currently don't allow it.
When I say move(fl), I consider that as saying that I don't care about the value of fl any more (until I assign it a new value). But in the above example, this simply isn't true. I do care about the value of fl after the move, and I'm not assigning it a new value. I'm merely permuting its current value.
I propose adding forward_list& overloads to the 3 splice_after members. For consistency's sake (principal of least surprise) I'm also proposing to overload merge this way as well.
Proposed resolution:
Add to the synopsis of 23.3.3 [forwardlist]:
template <class T, class Allocator = allocator<T> >
class forward_list {
public:
...
void splice_after(const_iterator p, forward_list& x);
void splice_after(const_iterator p, forward_list&& x);
void splice_after(const_iterator p, forward_list& x, const_iterator i);
void splice_after(const_iterator p, forward_list&& x, const_iterator i);
void splice_after(const_iterator p, forward_list& x,
const_iterator first, const_iterator last);
void splice_after(const_iterator p, forward_list&& x,
const_iterator first, const_iterator last);
...
void merge(forward_list& x);
void merge(forward_list&& x);
template <class Compare> void merge(forward_list& x, Compare comp);
template <class Compare> void merge(forward_list&& x, Compare comp);
...
};
Add to the signatures of 23.3.3.5 [forwardlist.ops]:
void splice_after(const_iterator p, forward_list& x); void splice_after(const_iterator p, forward_list&& x);1 ...
void splice_after(const_iterator p, forward_list& x, const_iterator i); void splice_after(const_iterator p, forward_list&& x, const_iterator i);5 ...
void splice_after(const_iterator p, forward_list& x, const_iterator first, const_iterator last); void splice_after(const_iterator p, forward_list&& x, const_iterator first, const_iterator last);9 ...
void merge(forward_list& x); void merge(forward_list&& x); template <class Compare> void merge(forward_list& x, Compare comp); template <class Compare> void merge(forward_list&& x, Compare comp);18 ...
Section: 24.2.3 [forward.iterators] Status: New Submitter: Alisdair Meredith Opened: 2010-02-07 Last modified: 2010-02-07
View all other issues in [forward.iterators].
View all issues with New status.
Discussion:
The following example demonstrates code that would meet the guarantees of a Forward Iterator, but only permits a single traversal of the underlying sequence:
template< typename ForwardIterator>
struct bad_iterator {
shared_ptr<ForwardIterator> impl;
bad_iterator( ForwardIterator iter ) {
: impl{new ForwardIterator{iter} }
{
}
auto operator*() const -> decltype(*ForwardIterator{}) {
return **impl;
}
auto operator->() const -> ForwardIterator {
return *impl;
}
auto operator==(bad_iterator const & rhs) {
return impl == rhs.impl;
}
auto operator++() {
++(*imp);
}
// other operations as necessary...
};
Here, we use shared_ptr to wrap a forward iterator, so all iterators constructed from the same original iterator share the same 'value', and incrementing any one copy increments all others.
There is a missing guarantee, expressed by the following code sequence
FwdIter x = seq.begin(); // obtain forward iterator from a sequence FwdIter y = x; // copy the iterator assert(x == y); // iterators must be the same ++x; // increment *just one* iterator assert(x != y); // iterators *must now be different* ++y; // increment the other iterator assert(x == y); // now the iterators must be the same again
That inequality in the middle is an essential guarantee. Note that this list is simplified, as each assertion should also note that they refer to exactly the same element (&*x == &*y) but I am not complicating the issue with tests to support proxy iterators, or value types overloading unary operator+.
I have not yet found a perverse example that can meet this additional constraint, and not meet the multi-pass expectations of a Forward Iterator without also violating other Forward Iterator requirements.
Note that I do not yet have standard-ready wording to resolve the problem, as saying this neatly and succinctly in 'standardese' is more difficult.
Proposed resolution:
Section: 23.3.6.3 [vector.data] Status: Ready Submitter: Alisdair Meredith Opened: 2010-02-07 Last modified: 2010-03-08
View all issues with Ready status.
Discussion:
The original intent of vector::data was to match array::data in providing a simple API with direct access to the contiguous buffer of elements that could be passed to a "classic" C API. At some point, the return type became the 'pointer' typedef, which is not derived from the allocator via allocator traits - it is no longer specified to precisely T *. The return type of this function should be corrected to no longer use the typedef.
[ 2010-02-10 Moved to Tentatively Ready after 5 positive votes on c++std-lib. ]
Proposed resolution:
23.3.6 [vector]
Update the class definition in p2:
// 23.3.6.3 data accesspointerT * data();const_pointerconst T * data() const;
23.3.6.3 [vector.data]
Adjust signatures:
pointerT * data();const_pointerconst T * data() const;
Section: 18.2 [support.types] Status: New Submitter: Sean Hunt Opened: 2010-02-07 Last modified: 2010-02-10
View other active issues in [support.types].
View all other issues in [support.types].
View all issues with New status.
Discussion:
Currently, the 18.2 [support.types]/3 allows NULL to be any null pointer constant. The footnote marks that 0 or 0L might be appropriate. However, this definition also allows the implementation to define NULL to be nullptr. This may lead to overload and conversion issues more serious than with the C++98 version:
void f(void*);
void f(int);
void g()
{
// calls f(int) if NULL is integral
// calls f(void*) if NULL is nullptr
f(NULL);
}
Possible resolutions:
Making NULL nullptr would improve code correctness, and breaking backwards compatibility shouldn't be a huge concern as NULL shouldn't be used except as a null pointer constant anyways.
[ 2010-02-10 Chris provided wording. ]
Proposed resolution:
18.2 [support.types]
3 The macro NULL is defined to be nullptr.
is an implementation-defined C++ null pointer constant in this International Standard (4.10).196
196) Possible definitions include 0 and 0L, but not (void*)0.
20.9.14 [c.malloc]
7 The contents are the same as the Standard C library header <string.h>, with the change to memchr() specified in 21.6 and the macro NULL defined to be nullptr.
20.11 [date.time]
2 The contents are the same as the Standard C library header <time.h>.232 except the macro NULL, which is defined to be nullptr. The functions asctime, ctime, gmtime, and localtime are not required to avoid data races (17.6.4.8).
22.6 [c.locales]
2 The contents are the same as the Standard C library header <locale.h> except the macro NULL, which is defined to be nullptr.
C.2.2.4 [diff.null]
1 The macro NULL, defined in any of <clocale>, <cstddef>, <cstdio>, <cstdlib>, <cstring>, <ctime>, or <cwchar>, is nullptran implementation-defined C++ null pointer constant in this International Standard (18.2).
Section: 20.9.6 [allocator.adaptor] Status: New Submitter: Pablo Halpern Opened: 2009-02-11 Last modified: 2010-02-11
View all issues with New status.
Discussion:
The WP (N3000) contains these declarations:
template <class OuterA1, class OuterA2, class... InnerAllocs>
bool operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b);
template <class OuterA1, class OuterA2, class... InnerAllocs>
bool operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b);
But does not define what the behavior of these operators are.
Proposed resolution:
Add a new section after 20.9.6.3 [allocator.adaptor.members]:
Scoped allocator operators [scoped.adaptor.operators]
template <class OuterA1, class OuterA2, class... InnerAllocs> bool operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a, const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b);Returns:a.outer_allocator() == b.outer_allocator()ifsizeof...(InnerAllocs)is zero; otherwise,a.outer_allocator() == b.outer_allocator() && a.inner_allocator() == b.inner_allocator().template <class OuterA1, class OuterA2, class... InnerAllocs> bool operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a, const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b);Returns:!(a == b).
Section: 20.8.16 [unord.hash] Status: New Submitter: Nicolai M. Josuttis Opened: 2010-02-10 Last modified: 2010-02-11
View other active issues in [unord.hash].
View all other issues in [unord.hash].
View all issues with New status.
Discussion:
Currently, the library lacks a convenient way to provide a hash function that can be used with the provided unordered containers to allow the usage of non trivial element types.
While we can easily declare an
std::unordered_set<int>
or
std::unordered_set<std::string>
we have no easy way to declare an unordered_set for a user defined type. IMO, this is a big obstacle to use unordered containers in practice. Note that in Java, the wide usage of HashMap is based on the fact that there is always a default hash function provided.
Of course, a default hash function implies the risk to provide poor hash functions. But often even poor hash functions are good enough.
While I really would like to see a default hash function, I don't propose it here because this would probably introduce a discussion that's too big for this state of C++0x.
However, I strongly suggest at least to provide a convenience variadic template function make_hash<>() to allow an easy definition of a (possibly poor) hash function.
As a consequence for a user-defined type such as
class Customer {
friend class CustomerHash;
private:
string firstname;
string lastname;
long no;
...
};
would allow to specify:
class CustomerHash : public std::unary_function<Customer, std::size_t>
{
public:
std::size_t operator() (const Customer& c) const {
return make_hash(c.firstname,c.lastname,c.no);
}
};
instead of:
class CustomerHash : public std::unary_function<Customer, std::size_t>
{
public:
std::size_t operator() (const Customer& c) const {
return std::hash<std::string>()(c.firstname) +
std::hash<std::string>()(c.lastname) +
std::hash<long>()(c.no);
}
};
Note that, in principle, we can either specify that
make_hash returns the sum of a call of std::hash<T>()(x) for each argument x of type T
or we can specify that
make_hash provides a hash value for each argument, for which a std::hash() function is provided
with the possible note that the hash value may be poor or only a good hash value if the ranges of all passed arguments is equally distributed.
For my convenience, I propose wording that describes the concrete implementation.
Proposed resolution:
In Function objects 20.8 [function.objects] in paragraph 2 at the end of the Header <functional> synopsis insert:
// convenience functions template <class T> size_t make_hash (const T&); template <class T, class... Types> size_t make_hash (const T&, const Types&...);
In Class template hash 20.8.16 [unord.hash] add:
20.7.16.1 Hash creation functions [hash.creation]
template <class T> size_t make_hash (const T& val);Returns: hash<T>()(val);template <class T, class... Types> size_t make_hash (const T& val, const Types&... args);Returns: hash<T>()(val) + std::make_hash(args...)
Section: 20.9.4.1 [allocator.traits.types] Status: New Submitter: Pete Becker Opened: 2010-02-11 Last modified: 2010-02-25
View all issues with New status.
Discussion:
N2982 says that containers should have a nested typedef that defines their reference_type as value_type&; the previous standard deferred to the allocator to define its reference_type, and containers simply passed the allocator's typedef on. This change is a mistake. Allocators should define both a pointer type and a reference type. That's essential for their original purpose, which was to make different memory models transparent. If an allocator defines a pointer type that isn't compatible with a normal pointer it also has to define a corresponding reference type. For example (and please forgive a Windows-ism), if an allocator's pointer is T __far*, then it's reference has to be T __far&. Otherwise everything crashes (under the hood, references are pointers and have to have the same memory access mechanics). Extensions such as this for more general memory models were explicitly encouraged by C++03, and the allocator's pointer and reference typedefs were the hooks for such extensions. Removing the allocator's reference and const_reference typedefs makes those extensions unimplementable and breaks existing implementations that rely on those hooks.
[ 2010-02-25 Alisdair adds: ]
vector<bool>::reference is a nested class, and not a typedef. It should be removed from the list of containers when this change is made.
In general, I am unfcomfortable placing this reference requirement on each container, as I would prefer to require:
is_same<Container::reference, Container::iterator::reference>This distinction is important, if we intend to support proxy iterators. The iterator paper in the pre-Pittsburgh mailing (N3046) does not make this proposal, but organises clause 24 in such a way this will be much easier to specify.
The changes to clause 20 remain important for all the reasons Pete highlights.
Proposed resolution:
Add the following two rows to Table 40, Allocator requirements:
Table 40 — Allocator requirements Expression Return type Assertion/note
pre-/post-conditionDefault X::reference T& X::const_reference const T&
2. Change the following two rows in Table 40:
Table 40 — Allocator requirements Expression Return type Assertion/note
pre-/post-conditionDefault *p T&X::reference*q const T&X::const_reference
Add the following typedef declarations to allocator_traits 20.9.4 [allocator.traits]:
template <class Alloc> struct allocator_traits {
...
typedef see below reference;
typedef see below const_reference;
...
Add the following descriptions to 20.9.4.1 [allocator.traits.types]:
typedef see below reference;Type: Alloc::reference if such a type exists; otherwise, value_type&.typedef see below const reference;Type: Alloc::const_reference if such a type exists; otherwise, const value_type&.
Add the following typdef declarations to scoped_allocator_adaptor 20.9.6 [allocator.adaptor]:
template <class OuterAlloc, class... InnerAllocs>
class scoped_allocator_adaptor : public OuterAlloc {
...
typedef typename OuterTraits::reference reference;
typedef typename OuterTraits::const_reference const_reference;
...
Change the nested typedefs reference and const_reference to:
typedef typename allocator_traits<Allocator>::reference reference; typedef typename allocator_traits<Allocator>::const_reference const_reference;
for each of the following class templates:
deque 23.3.2 [deque]
forward_list 23.3.3 [forwardlist]
list 23.3.4 [list]
queue 23.3.5.1.1 [queue.defn]
priority_queue 23.3.5.2 [priority.queue]
stack 23.3.5.3.1 [stack.defn]
vector 23.3.6 [vector]
vector<bool> 23.3.7 [vector.bool]
map 23.4.1 [map]
multimap 23.4.2 [multimap]
set 23.4.3 [set]
multiset 23.4.4 [multiset]
unordered_map 23.5.1 [unord.map]
unordered_multimap 23.5.2 [unord.multimap]
unordered_set 23.5.3 [unord.set]
unordered_multiset 23.5.4 [unord.multiset]
basic_string 21.4 [basic.string]
match_results 28.10 [re.results]
Section: 23.2.1 [container.requirements.general] Status: New Submitter: Alisdair Meredith Opened: 2010-02-16 Last modified: 2010-02-16
View other active issues in [container.requirements.general].
View all other issues in [container.requirements.general].
View all issues with New status.
Discussion:
The requirements on container iterators are spelled out in 23.2.1 [container.requirements.general], table 91.
Table 91 — Container requirements Expression Return type Operational semantics Assertion/note
pre-/post-conditionComplexity ... X::iterator iterator type whose value type is T any iterator category except output iterator. Convertible to X::const_iterator. compile time X::const_iterator constant iterator type whose value type is T any iterator category except output iterator compile time ...
As input iterators do not have the multi-pass guarantee, they are not suitable for iterating over a container. For example, taking two calls to begin(), incrementing either iterator might invalidate the other. While data structures might be imagined where this behaviour produces interesting and useful results, it is very unlikely to meet the full set of requirements for a standard container.
Proposed resolution:
Change Table 91 in 23.2.1 [container.requirements.general] as indicated:
Table 91 — Container requirements Expression Return type Operational semantics Assertion/note
pre-/post-conditionComplexity ... X::iterator iterator type whose value type is T any iterator category except output iterator.A Forward, Bidirectional or Random Access Iterator. Convertible to X::const_iterator.compile time X::const_iterator constant iterator type whose value type is T any iterator category except output iteratorA Forward, Bidirectional or Random Access Iterator.compile time ...
Section: 24.3 [iterator.synopsis] Status: New Submitter: Alisdair Meredith Opened: 2010-02-16 Last modified: 2010-02-16
View all issues with New status.
Discussion:
The iter_swap function template appears in the <algorithm> header, yet its main use is in building further algorithms, not calling existing ones. The main clients are implementers of data structures and their iterators, so it seems most appropriate to place the template in the <iterator> header instead.
Note that this is not an issue for implementers of the standard library, as they rarely use the standard headers directly, designing a more fine-grained set of headers for their own internal use. This option is not available to customers of the standard library.
Note that we cannot remove iter_swap from <algorithm> without breaking code, but there is no reason we cannot offer the same declaration via two standard headers. Alternatively, require <algorithm> to #include <iterator>, but introducing the dependency on the iterator adaptors seems un-necessary.
Proposed resolution:
Add the declaration of iter_swap to the <iterator> header synopsis (24.3 [iterator.synopsis]), with a note that it is documented in clause 25 [algorithms].
... template <class T, size_t N> T* end(T (&array)[N]); // documented in 25 [algorithms] template<class ForwardIterator1, class ForwardIterator2> void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
Section: 20.9.6.3 [allocator.adaptor.members] Status: New Submitter: Howard Hinnant Opened: 2010-02-16 Last modified: 2010-02-21
View all issues with New status.
Discussion:
20.9.6.3 [allocator.adaptor.members] p8-9 says:
template <class T, class... Args> void construct(T* p, Args&&... args);8 Effects: let OUTERMOST(x) be x if x does not have an outer_allocator() function and OUTERMOST(x.outer_allocator()) otherwise.
- If uses_allocator<T, inner_allocator_type>::value is false and is_constructible<T, Args...>::value is true, calls OUTERMOST(*this).construct(p, std::forward<Args>(args)...).
- Otherwise, if uses_allocator<T, inner_allocator_type>::value is true and is_constructible<T, allocator_arg_t, inner_allocator_type, Args...>::value is true, calls OUTERMOST(*this).construct(p, allocator_arg, inner_allocator(),std::forward<Args>(args)...).
- Otherwise, if uses_allocator<T, inner_allocator_type>::value is true and is_constructible<T, Args..., inner_allocator_type>::value is true, calls OUTERMOST(*this).construct(p, std::forward<Args>(args)..., inner_allocator()).
- Otherwise, the program is ill-formed. [Note: an error will result if uses_allocator evaluates to true but the specific constructor does not take an allocator. This definition prevents a silent failure to pass an inner allocator to a contained element. — end note]
template <class T> void destroy(T* p);9 Effects: calls outer_allocator().destroy(p).
In all other calls where applicable scoped_allocator_adaptor does not call members of an allocator directly, but rather does so indirectly via allocator_traits. For example:
size_type max_size() const;7 Returns: allocator_traits<OuterAlloc>::max_size(outer_allocator()).
Indeed, without the indirection through allocator_traits the definitions for construct and destroy are likely to fail at compile time since the outer_allocator() may not have the members construct and destroy.
[ The proposed wording is a product of Pablo, Daniel and Howard. ]
Proposed resolution:
In 20.9.6.3 [allocator.adaptor.members] move and change p8 as indicated, and change p9 as indicated:
Let OUTERMOST(x) be x if x does not have an outer_allocator() member function and OUTERMOST(x.outer_allocator()) otherwise. Let OUTERMOST_ALLOC_TRAITS(x) be allocator_traits<decltype(OUTERMOST(x))>. [Note: OUTERMOST(x) and OUTERMOST_ALLOC_TRAITS(x) are recursive operations. It is incumbent upon the definition of outer_allocator() to ensure that the recursion terminates. It will terminate for all instantiations of scoped_allocator_adaptor. — end note]
template <class T, class... Args> void construct(T* p, Args&&... args);8 Effects:
let OUTERMOST(x) be x if x does not have an outer_allocator() function and OUTERMOST(x.outer_allocator()) otherwise.
- If uses_allocator<T, inner_allocator_type>::value is false and is_constructible<T, Args...>::value is true, calls
OUTERMOST(*this).OUTERMOST_ALLOC_TRAITS(outer_allocator())::construct( OUTERMOST(outer_allocator()), p, std::forward<Args>(args)... ).- Otherwise, if uses_allocator<T, inner_allocator_type>::value is true and is_constructible<T, allocator_arg_t, inner_allocator_type, Args...>::value is true, calls
OUTERMOST(*this).OUTERMOST_ALLOC_TRAITS(outer_allocator())::construct( OUTERMOST(outer_allocator()), p, allocator_arg, inner_allocator(), std::forward<Args>(args)... ).- Otherwise, if uses_allocator<T, inner_allocator_type>::value is true and is_constructible<T, Args..., inner_allocator_type>::value is true, calls
OUTERMOST(*this).OUTERMOST_ALLOC_TRAITS(outer_allocator())::construct( OUTERMOST(outer_allocator()), p, std::forward<Args>(args)..., inner_allocator() ).- Otherwise, the program is ill-formed. [Note: an error will result if uses_allocator evaluates to true but the specific constructor does not take an allocator. This definition prevents a silent failure to pass an inner allocator to a contained element. — end note]
template <class T> void destroy(T* p);9 Effects: callsouter_allocator().OUTERMOST_ALLOC_TRAITS(outer_allocator())::destroy( OUTERMOST(outer_allocator()), p).
Section: 20.2.1 [utility.arg.requirements] Status: New Submitter: Daniel Krügler Opened: 2010-02-16 Last modified: 2010-02-17
View other active issues in [utility.arg.requirements].
View all other issues in [utility.arg.requirements].
View all issues with New status.
Discussion:
With the acceptance of library defect 822 only direct-initialization is supported, and not copy-initialization in the requirement sets MoveConstructible and CopyConstructible. This is usually a good thing, if only the library implementation needs to obey these restrictions, but the Empire strikes back quickly:
Affects user-code: std::exception_ptr is defined purely via requirements, among them CopyConstructible. A strict reading of the standard would make implementations conforming where std::exception_ptr has an explicit copy-c'tor and user-code must code defensively. This is a very unwanted effect for such an important component like std::exception_ptr.
Wrong re-use: Recently proposed requirement sets (NullablePointer as of N3025, Hash) or cleanup of existing requirement sets (e.g. iterator requirements as of N3046) tend to reuse existing requirement sets, so reusing CopyConstructible is attempting, even in cases, where the intend is to support copy-initialization as well.
Inconsistency: The current iterator requirements set Table 102 (output iterator requirements) and Table 103 (forward iterator requirements) demonstrate quite clearly a strong divergence of copy-semantics: The specified semantics of
X u(a); X u = a;
are underspecified compared to the most recent clarifications of the CopyConstructible requirements, c.f. issue 1309 which is very unsatisfactory. This will become worse for each further issue that involves the CopyConstructible specification (for possible directions see 1173).
The suggested resolution is to define two further requirements implicit-MoveConstructible and implicit-CopyConstructible (or any other reasonable name like MoveConvertible and CopyConvertible) each with a very succinct but precise meaning solving all three problems mentioned above.
Proposed resolution:
Add the following new table ?? after Table 33 — MoveConstructible requirements [moveconstructible]:
[Assumes that 1309 has been applied]
Table ?? — implicit-MoveConstructible requirements [implicit.moveconstructible] (in addition to MoveConstructible) Expression Operational Semantics T u = rv; Equivalent to: T u(rv);
Add the following new table ?? after Table34 — CopyConstructible requirements [copyconstructible]:
[Assumes that 1309 has been applied]
Table ?? — implicit-CopyConstructible requirements [implicit.copyconstructible] (in addition to CopyConstructible) Expression Operational Semantics T u = v; Equivalent to: T u(v);
If N3025 is applied, change [nullablepointer.requirements]/3 as follows:
A type P meets the NullablePointer requirements, if — it satisfies the requirements of EqualityComparable, DefaultConstructible, implicit-CopyConstructible, CopyAssignable, Swappable, and Destructible (20.2.1 [utility.arg.requirements]),
If N3025 is not applied:
Change 18.8.5 [propagation]/2 as follows:
2 exception_ptr shall be DefaultConstructible, implicit-CopyConstructible, CopyAssignable, and EqualityComparable. [..]
Change 20.2.2 [allocator.requirements]/4 as follows:
4 The X::pointer, X::const_pointer, X::void_pointer, and X::const_void_pointer types shall satisfy the requirements of EqualityComparable, DefaultConstructible, implicit-CopyConstructible, CopyAssignable, Swappable, and Destructible (20.2.1). [..]
Change 20.7.1 [meta.rqmts]/1+2 as indicated:
1 A UnaryTypeTrait describes a property of a type. It shall be a class template that takes one template type argument and, optionally, additional arguments that help define the property being described. It shall be DefaultConstructible, implicit-CopyConstructible, [..]
2 A BinaryTypeTrait describes a relationship between two types. It shall be a class template that takes two template type arguments and, optionally, additional arguments that help define the relationship being described. It shall be DefaultConstructible, implicit-CopyConstructible, and [..]
Change 20.8.2 [func.require]/4 as indicated:
4 Every call wrapper (20.7.1) shall be implicit-CopyConstructible. [..]
Change 20.8.5 [refwrap]/1 as indicated:
1 reference_wrapper<T> is a implicit-CopyConstructible and Assignable wrapper around a reference to an object of type T.
Change 20.8.11.1.4 [func.bind.place] as indicated:
1 All placeholder types shall be DefaultConstructible and implicit-CopyConstructible, and [..]
Change 20.9.10 [unique.ptr]/2 as indicated:
2 [..] A unique_ptr is not CopyConstructible, nor CopyAssignable, however it is implicit-MoveConstructible and MoveAssignable. [..]
Change 20.9.11.2 [util.smartptr.shared]/2 as indicated:
2 Specializations of shared_ptr shall be implicit-CopyConstructible, CopyAssignable, and LessThanComparable, [..]
Change 20.9.11.3 [util.smartptr.weak]/2 as indicated:
2 Specializations of weak_ptr shall be implicit-CopyConstructible, CopyAssignable, and LessThanComparable, [..]
Change 24.2.2 [output.iterators]/1 as indicated:
1 A class or a built-in type X satisfies the requirements of an output iterator if X is a implicit-CopyConstructible (34) and Assignable type (23.2) and [..]
Change D.9.1 [auto.ptr]/3 as indicated:
3 [..] Instances of auto_ptr meet the requirements of implicit-MoveConstructible and MoveAssignable, but do not meet the requirements of CopyConstructible and CopyAssignable. — end note]
Section: 21.4.6.6 [string::replace] Status: New Submitter: Daniel Krügler Opened: 2010-02-19 Last modified: 2010-02-20
View all other issues in [string::replace].
View all issues with New status.
Discussion:
In contrast to all library usages of purely positional iterator values several overloads of std::basic_string::replace still use iterator instead of const_iterator arguments. The paper N3021 quite nicely visualizes the purely positional responsibilities of the function arguments.
This should be fixed to make the library consistent, the proposed changes are quite mechanic.
Proposed resolution:
In 21.4 [basic.string], class template basic_string synopsis change as indicated:
// 21.4.6 modifiers:
...
basic_string& replace(const_iterator i1, const_iterator i2,
const basic_string& str);
basic_string& replace(const_iterator i1, const_iterator i2,
const charT* s, size_type n);
basic_string& replace(const_iterator i1, const_iterator i2,
const charT* s);
basic_string& replace(const_iterator i1, const_iterator i2,
size_type n, charT c);
template<class InputIterator>
basic_string& replace(const_iterator i1, const_iterator i2,
InputIterator j1, InputIterator j2);
basic_string& replace(const_iterator, const_iterator,
initializer_list<charT>);
In 21.4.6.6 [string::replace] before p.10, change the following signatures as indicated:
basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
In 21.4.6.6 [string::replace] before p.14, change the following signatures as indicated:
basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
In 21.4.6.6 [string::replace] before p.16, change the following signatures as indicated:
basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
In 21.4.6.6 [string::replace] before p.18, change the following signatures as indicated:
basic_string& replace(const_iterator i1, const_iterator i2, size_type n,
charT c);
In 21.4.6.6 [string::replace] before p.20, change the following signatures as indicated:
template<class InputIterator>
basic_string& replace(const_iterator i1, const_iterator i2,
InputIterator j1, InputIterator j2);
In 21.4.6.6 [string::replace] before p.22, change the following signatures as indicated:
basic_string& replace(const_iterator i1, const_iterator i2,
initializer_list<charT> il);
Section: 23.2.2 [container.requirements.dataraces] Status: New Submitter: Alisdair Meredith Opened: 2010-02-24 Last modified: 2010-02-24
View other active issues in [container.requirements.dataraces].
View all other issues in [container.requirements.dataraces].
View all issues with New status.
Discussion:
According to 23.2.2 [container.requirements.dataraces] p1, a number of member functions are treated as const for the purpose of avoiding data races:
1 For purposes of avoiding data races (17.6.4.8), implementations shall consider the following functions to be const: begin, end, rbegin, rend, front, back, data, find, lower_bound, upper_bound, equal_range, and, except in associative containers, operator[].
I believe this wording is an ambiguous attempt to cover both associative and unordered associative containers with the minimal wording. Unfortunately, our 'ordered' associative containers are simply called the 'associative containers', so the term cannot extend to cover the unordered containers as well. I suspect it is far too late to ammend the the associative containers to be referred to as the 'ordered' associative containers (we might consider this a cleanup for 1x) so suggest we make the data race wording explicit.
Proposed resolution:
Ammend the last part of the sentance in 23.2.2 [container.requirements.dataraces] p1:
1 For purposes of avoiding data races (17.6.4.8), implementations shall consider the following functions to be const: begin, end, rbegin, rend, front, back, data, find, lower_bound, upper_bound, equal_range, and, except in associative and unordered associative containers, operator[].
Section: 20.5.1 [bitset.cons] Status: New Submitter: Christopher Jefferson Opened: 2010-03-07 Last modified: 2010-03-10
View all other issues in [bitset.cons].
View all issues with New status.
Discussion:
As mentioned on the boost mailing list:
The following code, valid in C++03, is broken in C++0x due to ambiguity between the "unsigned long long" and "char*" constructors.
#include <bitset> std::bitset<10> b(0);
Proposed resolution:
In WD N3035, 20.5 [template.bitset]/1, replace the fourth bitset constructor:
explicit bitset(const char *str);template <class charT> explicit bitset( const charT *str, typename basic_string<charT>::size_type pos = 0, typename basic_string<charT>::size_type n = basic_string<charT>::npos, charT zero = charT('0'), charT one = charT('1'));
And in 20.5.1 [bitset.cons]/8:
explicit bitset(const char *str);Effects: Constructs an object of class bitset<N> as if by bitset(string(str)).template <class charT> explicit bitset(const char *str, typename basic_string<charT>::size_type pos = 0, typename basic_string<charT>::size_type n = basic_string<charT>::npos, charT zero = charT('0'), charT one = charT('1'));Effects: Constructs an object of class bitset<N> as if by bitset(basic_string<charT>(str), pos, n, zero, one).
Section: 20.4.2.1 [tuple.cnstr] Status: New Submitter: Daniel Krügler Opened: 2010-03-07 Last modified: 2010-03-10
View all other issues in [tuple.cnstr].
View all issues with New status.
Discussion:
There are several constructors and creation functions of std::tuple that impose requirements on it's arguments, that are unnecessary restrictive and don't match the intention for the supported argument types. This is related to the fact that tuple is supposed to accept both object types and lvalue-references and the usual MoveConstructible and CopyConstructible requirements are bad descriptions for non-const references. Some examples:
20.4.2.1 [tuple.cnstr] before p.4 and p.8, resp.:
explicit tuple(const Types&...);4 Requires: Each type in Types shall be copy constructible.tuple(const tuple& u) = default;8 Requires: Each type in Types shall satisfy the requirements of CopyConstructible (Table 34).
A tuple that contains lvalue-references to non-const can never satisfy the CopyConstructible requirements. CopyConstructible requirements refine the MoveConstructible requirements and this would require that these lvalue-references could bind rvalues. But the core language does not allow that. Even, if we would interpret that requirement as referring to the underlying non-reference type, this requirement would be wrong as well, because there is no reason to disallow a type such as
struct NoMoveNoCopy {
NoMoveNoCopy(NoMoveNoCopy&&) = delete;
NoMoveNoCopy(const NoMoveNoCopy&) = delete;
...
}:
for the instantiation of std::tuple<NoMoveNoCopy&> and that of it's copy constructor.
A more reasonable requirement for this example would be to require that "is_constructible<Ti, const Ti&>::value shall evaluate to true for all Ti in Types". In this case the special reference-folding and const-merging rules of references would make this well-formed in all cases. We could also add the further constraint "if Ti is an object type, it shall satisfy the CopyConstructible requirements", but this additional requirement seems not really to help here. Ignoring it would only mean that if a user would provide a curious object type C that satisfies the std::is_constructible<C, const C&> test, but not the "C is CopyConstructible" test would produce a tuple<C> that does not satisfy the CopyConstructible requirements as well.
20.4.2.1 [tuple.cnstr] before p.6 and p.10, resp.:
template <class... UTypes> explicit tuple(UTypes&&... u);6 Requires: Each type in Types shall satisfy the requirements of MoveConstructible (Table 33) from the corresponding type in UTypes. sizeof...(Types) == sizeof...(UTypes).tuple(tuple&& u);10 Requires: Each type in Types shall shall satisfy the requirements of MoveConstructible (Table 33).
We have a similar problem as in (a): Non-const lvalue-references are intended template arguments for std::tuple, but cannot satisfy the MoveConstructible requirements. In this case the correct requirements would be
is_constructible<Ti, Ui>::value shall evaluate to true for all Ti in Types and for all Ui in UTypes
and
is_constructible<Ti, Ti>::value shall evaluate to true for all Ti in Types
respectively.
Proposed resolution:
Change 20.4.2.1 [tuple.cnstr]/4 as indicated:
explicit tuple(const Types&...);4 Requires: is_constructible<Ti, const Ti&>::value == true for e
Each type Ti in Typesshall be copy constructible.5 Effects: Copy initializes each element with the value of the corresponding parameter.
Change 20.4.2.1 [tuple.cnstr]/6 as indicated:
template <class... UTypes> explicit tuple(UTypes&&... u);6 Requires: is_constructible<Ti, Ui>::value == true for e
Each type Ti in Typesshall satisfy the requirements of MoveConstructible (Table 33) fromand for the corresponding type Ui in UTypes. sizeof...(Types) == sizeof...(UTypes).7 Effects: Initializes the elements in the tuple with the corresponding value in std::forward<UTypes>(u).
Change 20.4.2.1 [tuple.cnstr]/8+9 as indicated:
tuple(const tuple& u) = default;8 Requires: is_constructible<Ti, const Ti&>::value == true for e
Each type Ti in Typesshall satisfy the requirements of CopyConstructible(Table 34).9 Effects: Initializes
Copy constructseach element of *this with the correspondingelement ofvalue in u.
Change 20.4.2.1 [tuple.cnstr]/10+11 as indicated:
tuple(tuple&& u);10 Requires: is_constructible<Ti, Ti>::value == true for e
Each type Ti in Typesshall shall satisfy the requirements of MoveConstructible (Table 33).11 Effects: Initializes
Move-constructseach element of *this with the correspondingelement ofvalue in std::forward<Types>(u).
Change 20.4.2.1 [tuple.cnstr]/15+16 as indicated:
template <class... UTypes> tuple(tuple<UTypes...>&& u);15 Requires: is_constructible<Ti, Ui>::value == true for e
Each type Ti in Typesshall shall satisfy the requirements of MoveConstructible (Table 33)from the corresponding type Ui in UTypes. sizeof...(Types) == sizeof...(UTypes).16 Effects: Initializes
Move-constructseach element of *this with the correspondingelement ofvalue in std::forward<UTypes>(u).
Change 20.4.2.1 [tuple.cnstr]/19 as indicated:
template <class U1, class U2> tuple(pair<U1, U2>&& u);19 Requires: is_constructible<T1, U1>::value == true for t
The first type T1 in Typesshall shall satisfy the requirements of MoveConstructible(Table 33) from U1and is_constructible<T2, U2>::value == true for the second type T2 in Typesshall be move-constructible from U2. sizeof...(Types) == 2.20 Effects: Initializes
Constructsthe first element with std::forward<U1>move(u.first) and the second element with std::forward<U2>move(u.second).
Change 20.4.2.4 [tuple.creation]/6-13 as indicated:
template <class... TTypes, class... UTypes> tuple<TTypes..., UTypes...> tuple_cat(const tuple<TTypes...>& t, const tuple<UTypes...>& u);6 Requires: is_constructible<Ti, const Ti&>::value == true for each type Ti
All the typesin TTypesshall be CopyConstructible (Table 34). is_constructible<Ui, const Ui&>::value == true for each type UiAll the typesin UTypesshall be CopyConstructible (Table 34).7 Returns: A tuple object constructed by initializing
copy constructingits first sizeof...(TTypes) elements from the corresponding elements of t and initializingcopy constructingits last sizeof...(UTypes) elements from the corresponding elements of u.template <class... TTypes, class... UTypes> tuple<TTypes..., UTypes...> tuple_cat(tuple<TTypes...>&& t, const tuple<UTypes...>& u);8 Requires: is_constructible<Ti, Ti>::value == true for each type Ti
All the typesin TTypesshall be MoveConstructible (Table 33). is_constructible<Ui, const Ui&>::value == true for each type UiAll the typesin UTypesshall be CopyConstructible (Table 34).9 Returns: A tuple object constructed by initializing
move constructingits first sizeof...(TTypes) elements from the correspondingelements ofvalue in std::forward<TTypes>(t) and initializingcopy constructingits last sizeof...(UTypes) elements from the corresponding elements of u.template <class... TTypes, class... UTypes> tuple<TTypes..., UTypes...> tuple_cat(const tuple<TTypes...>& t, tuple<UTypes...>&& u);10 Requires: is_constructible<Ti, const Ti&>::value == true for each type Ti
All the typesin TTypesshall be CopyConstructible (Table 34). is_constructible<Ui, Ui>::value == true for each type UiAll the typesin UTypesshall be MoveConstructible (Table 33).11 Returns: A tuple object constructed by initializing
copy constructingits first sizeof...(TTypes) elements from the corresponding elements of t and initializingmove constructingits last sizeof...(UTypes) elements from the correspondingelements ofvalue in std::forward<UTypes>(u).template <class... TTypes, class... UTypes> tuple<TTypes..., UTypes...> tuple_cat(tuple<TTypes...>&& t, tuple<UTypes...>&& u);12 Requires: is_constructible<Ti, Ti>::value == true for each type Ti
All the typesin TTypesshall be MoveConstructible (Table 33). is_constructible<Ui, Ui>::value == true for each type UiAll the typesin UTypesshall be MoveConstructible (Table 33).13 Returns: A tuple object constructed by initializing
move constructingits first sizeof...(TTypes) elements from the correspondingelements ofvalue in std::forward<TTpes>(t) and initializingmove constructingits last sizeof...(UTypes) elements from the correspondingelements ofvalue in std::forward<UTypes>(u).
Section: 26.8 [c.math] Status: New Submitter: Michael Wong Opened: 2010-03-07 Last modified: 2010-03-08
View all other issues in [c.math].
View all issues with New status.
Discussion:
In 26.8 [c.math]p12 The templates defined in <cmath> replace the C99 macros with the same names. The templates have the following declarations:
namespace std {
template <class T> bool signbit(T x);
template <class T> int fpclassify(T x);
template <class T> bool isfinite(T x);
template <class T> bool isinf(T x);
template <class T> bool isnan(T x);
template <class T> bool isnormal(T x);
template <class T> bool isgreater(T x, T y);
template <class T> bool isgreaterequal(T x, T y);
template <class T> bool isless(T x, T y);
template <class T> bool islessequal(T x, T y);
template <class T> bool islessgreater(T x, T y);
template <class T> bool isunordered(T x, T y);
}
and p13:
13 The templates behave the same as the C99 macros with corresponding names defined in C99 7.12.3, Classification macros, and C99 7.12.14, Comparison macros in the C standard.
The C Std versions look like this:
7.12.14.1/p1:
Synopsis
1 #include <math.h>
int isgreaterequal(real-floating x, real-floating y);
which is not necessarily the same types as is required by C++ since the two parameters may be different. Would it not be better if it were truly aligned with C?
Proposed resolution:
Section: 27.7.1.1.3 [istream::sentry] Status: New Submitter: Paolo Carlini Opened: 2010-02-17 Last modified: 2010-03-09
View all other issues in [istream::sentry].
View all issues with New status.
Discussion:
basing on the recent discussion on the library reflector, see c++std-lib-27728 and follow ups, I hereby formally ask for LWG 419 to be re-opened, the rationale being that according to the current specifications, per n3000, it seems actually impossible to seek away from end of file, contrary to the rationale which led 342 to its closure as NAD. My request is also supported by Martin Sebor, and I'd like also to add, as tentative proposed resolution for the re-opened issue, the wording suggested by Sebor, thus, change the beginning of 27.7.1.1.3 [istream::sentry]/2, to:
2 Effects: If (!noskipws && !is.good()) isfalsetrue, calls is.setstate(failbit). Otherwise prepares for formatted or unformatted input. ...
Proposed resolution:
Change 27.7.1.1.3 [istream::sentry]/2:
2 Effects: If (!noskipws && !is.good()) isfalsetrue, calls is.setstate(failbit). Otherwise prepares for formatted or unformatted input. ...
vector<bool>Section: 23.2.2 [container.requirements.dataraces] Status: New Submitter: Jeffrey Yaskin Opened: 2010-03-09 Last modified: 2010-03-09
View other active issues in [container.requirements.dataraces].
View all other issues in [container.requirements.dataraces].
View all issues with New status.
Discussion:
The common implementation of vector<bool> is as an unsynchronized bitfield. The addition of 23.2.2 [container.requirements.dataraces]/2 would require either a change in representation or a change in access synchronization, both of which are undesireable with respect to compatibility and performance.
Proposed resolution:
Container data races 23.2.2 [container.requirements.dataraces]
Paragraph 1 is unchanged as follows:
1 For purposes of avoiding data races (17.6.4.8), implementations shall consider the following functions to beconst:begin,end,rbegin,rend,front,back,data,find,lower_bound,upper_bound,equal_range, and, except in associative containers,operator[].
Edit paragraph 2 as follows:
2 Notwithstanding (17.6.4.8), implementations are required to avoid data
races when the contents of the contained object in different elements in
the same sequence, excepting vector<bool>,
are modified concurrently.
Edit paragraph 3 as follows:
3 [Note: For avector<int> xwith a size greater than one,x[1] = 5and*x.begin() = 10can be executed concurrently without a data race, butx[0] = 5and*x.begin() = 10executed concurrently may result in a data race. As an exception to the general rule, for avector<bool> y,y[i] = truemay race withy[j] = true. —end note]
Section: 23.2 [container.requirements] Status: New Submitter: Nicolai Josuttis Opened: 2010-03-10 Last modified: 2010-03-10
View other active issues in [container.requirements].
View all other issues in [container.requirements].
View all issues with New status.
Discussion:
Abstract:
In general, it seems that in a couple of places container behavior is not described in requirement tables although it is a general behavior.
History:
Issue 676 added move semantics to unordered containers. For the added insert functions the Editor requested to put their semantic description into a requirements table rather than describing them for each container individually. The text however was taken from the associative containers, where we also have the semantics for each container described. Also, 1034 is to some extend requesting a clarification of the requirement tables and it turned out that in other places we have the same problem (e.g. we have no general requirement for type pointer and const_pointer although each container has them with issue 1306).
From my personal list of functions in requirement tables and containers, the following types/functions are missing in requirement tables:
all copy constructors, copy constructors with allocator, assignment operators, and insert operators with move semantics for associative and unordered containers
ContType c1(c2&&) ContType c1(c2&&,alloc) c1 = c2&& c.insert(val&&) c.insert(pos,val&&)
As a special case, we lack the following requirements for all sequence containers BUT array (so special wording or a new container category is required):
constructor with only a size argument
ContType c(num)
copy constructor with allocator and move semantics
ContType c1(c2&&,alloc)
all constructors that insert multiple elements with additional allocator
ContType c(num, val,alloc) ContType c(beg, end,alloc) ContType c(initlist,alloc)
all resize functiuons:
c.resize(num) c.resize(num,val)
Note that we also might have to add additional requirements on other places for sequence containers because having an allocator requires additional statements for the treatment of the allocators. E.g. swap for containers with allocators is not specified in any requirement table.
And finally, if we have the requirements in the requirements tables, we can remove the corresponding descriptions for the individual container. However, note that sequence container requirements have NO complexity column, so that we still need container specific descriptions for the functions listed there.
Proposed resolution:
Section: 17 [library] Status: New Submitter: Martin Sebor Opened: 2010-03-10 Last modified: 2010-03-11
View other active issues in [library].
View all other issues in [library].
View all issues with New status.
Discussion:
Review the library portion of the spec and incorporate the newly added core feature Move Special Member Functions (N3044).
Proposed resolution: