Defect Report: Inconsistency in sequence constructors.
Since comp.std.c++ still seems to be down, I'm sending this here.
{ Be aware that clc++m does not have any status in the official defect
reporting procedure, and that with respect to the official guidelines
this clc++m article does not constitute a Defect Report. The official
guideline at <url: http://www.comeaucomputing.com/csc/faq.html#B15>
lists an alternative to posting a Defect Reports to csc++. -mod }
I've noticed a curious inconsistency in N1858, "Rvalue Reference
Recommendations for Chapter 23". Among the things the paper proposes
is to split the sequence constructor
explicit sequence(size_type n, const T& value = T(), const Allocator&
= Allocator())
into two constructors
explicit sequence(size_type n)
sequence(size_type n, const T& value, const Allocator& = Allocator())
This is done so that a type need not be CopyConstructible in order to
use the length constructor.
The inconsistency is that every constructor has an optional allocator
argument at the end of the list (move and copy constructor have
overloads instead of defaults, probably because the default behaviour
is to use the source's allocator), except for the new one. I see no
reason why it should not be possible to explicitly specify an
allocator in this case.
I believe the new constructor should have this signature:
explicit sequence(size_type n, const Allocator& = Allocator())
On a related editorial note, the same paper proposed removing the
explicit template arguments from the type when used within the class
body, in order to increase legibility. This has been largely followed,
with three exceptions: the copy constructor, the move assignment
operator and the copy assignment operator. These three (for all three
classic sequences) still specify the arguments. For forward_list,
these three and the move constructor specify the arguments.
Due to this, I'd like to propose the following changes to the working
paper (N2588):
In 23.2.2, in the definition of class deque, change
-----------------------------
// 23.2.2.1 construct/copy/destroy:
explicit deque(const Allocator& = Allocator());
explicit deque(size_type n);
deque(size_type n, const T& value,const Allocator& = Allocator());
template <class InputIterator>
deque(InputIterator first, InputIterator last,const Allocator& =
Allocator());
deque(const deque<T,Allocator>& x);
deque(deque&&);
deque(const deque&, const Allocator&);
deque(deque&&, const Allocator&);
~deque();
deque<T,Allocator>& operator=(const deque<T,Allocator>& x);
deque<T,Allocator>& operator=(const deque<T,Allocator>&& x);
-----------------------------
to
+++++++++++++++++++++++++++++
// 23.2.2.1 construct/copy/destroy:
explicit deque(const Allocator& = Allocator());
explicit deque(size_type n, const Allocator& = Allocator());
deque(size_type n, const T& value,const Allocator& = Allocator());
template <class InputIterator>
deque(InputIterator first, InputIterator last,const Allocator& =
Allocator());
deque(const deque& x);
deque(deque&&);
deque(const deque&, const Allocator&);
deque(deque&&, const Allocator&);
~deque();
deque& operator=(const deque& x);
deque& operator=(const deque&& x);
+++++++++++++++++++++++++++++
In 23.2.2.1, prior to paragraph 3, change the declaration of the
constructor to
+++++++++++++++++++++++++++++
explicit deque(size_type n, const Allocator& = Allocator());
+++++++++++++++++++++++++++++
Change paragraph 3 from
-----------------------------
Effects: Constructs a deque with n default constructed elements.
-----------------------------
to
+++++++++++++++++++++++++++++
Effects: Constructs a deque with n default constructed elements, using
the specified allocator.
+++++++++++++++++++++++++++++
In 23.2.3, in the definition of class forward_list, change
-----------------------------
// 23.2.3.1 construct/copy/destroy:
explicit forward_list(const Allocator& = Allocator());
explicit forward_list(size_type n);
forward_list(size_type n, const T& value,
const Allocator& = Allocator());
template <class InputIterator>
forward_list(InputIterator first, InputIterator last,
const Allocator& = Allocator());
forward_list(const forward_list<T,Allocator>& x);
forward_list(forward_list<T,Allocator>&& x);
~forward_list();
forward_list<T,Allocator>& operator=(const forward_list<T,Allocator>&
x);
forward_list<T,Allocator>& operator=(forward_list<T,Allocator>&& x);
-----------------------------
to
+++++++++++++++++++++++++++++
// 23.2.3.1 construct/copy/destroy:
explicit forward_list(const Allocator& = Allocator());
explicit forward_list(size_type n, const Allocator& = Allocator());
forward_list(size_type n, const T& value,
const Allocator& = Allocator());
template <class InputIterator>
forward_list(InputIterator first, InputIterator last,
const Allocator& = Allocator());
forward_list(const forward_list& x);
forward_list(forward_list&& x);
~forward_list();
forward_list& operator=(const forward_list& x);
forward_list& operator=(forward_list&& x);
+++++++++++++++++++++++++++++
In 23.2.3.1, before paragraph 3, change the declaration of the
constructor to
+++++++++++++++++++++++++++++
explicit forward_list(size_type n, const Allocator& = Allocator());
+++++++++++++++++++++++++++++
Change paragraph 3 from
-----------------------------
Effects: Constructs a forward_list with n default constructed
elements.
-----------------------------
to
+++++++++++++++++++++++++++++
Effects: Constructs a forward_list with n default constructed
elements, using the specified allocator.
+++++++++++++++++++++++++++++
In 23.2.4, in the definition of class list, change
-----------------------------
// 23.2.4.1 construct/copy/destroy:
explicit list(const Allocator& = Allocator());
explicit list(size_type n);
list(size_type n, const T& value, const Allocator& = Allocator());
template <class InputIterator>
list(InputIterator first, InputIterator last, const Allocator& =
Allocator());
list(const list<T,Allocator>& x);
list(list&& x);
list(const list&, const Allocator&);
list(list&&, const Allocator&);
~list();
list<T,Allocator>& operator=(const list<T,Allocator>& x);
list<T,Allocator>& operator=(list<T,Allocator>&& x);
-----------------------------
to
+++++++++++++++++++++++++++++
// 23.2.4.1 construct/copy/destroy:
explicit list(const Allocator& = Allocator());
explicit list(size_type n, const Allocator& = Allocator());
list(size_type n, const T& value, const Allocator& = Allocator());
template <class InputIterator>
list(InputIterator first, InputIterator last, const Allocator& =
Allocator());
list(const list& x);
list(list&& x);
list(const list&, const Allocator&);
list(list&&, const Allocator&);
~list();
list& operator=(const list& x);
list& operator=(list&& x);
+++++++++++++++++++++++++++++
In 23.2.4.1, before paragraph 3, change the declaration of the
constructor to
+++++++++++++++++++++++++++++
explicit list(size_type n, const Allocator& = Allocator());
+++++++++++++++++++++++++++++
Change paragraph 3 from
-----------------------------
Effects: Constructs a list with n default constructed elements.
-----------------------------
to
+++++++++++++++++++++++++++++
Effects: Constructs a list with n default constructed elements, using
the specified allocator.
+++++++++++++++++++++++++++++
In 23.2.6, in the definition of class vector, change
-----------------------------
// 23.2.6.1 construct/copy/destroy:
explicit vector(const Allocator& = Allocator());
explicit vector(size_type n);
vector(size_type n, const T& value, const Allocator& = Allocator());
template <class InputIterator>
vector(InputIterator first, InputIterator last,
const Allocator& = Allocator());
vector(const vector<T,Allocator>& x);
vector(vector&&);
vector(const vector&, const Allocator&);
vector(vector&&, const Allocator&);
~vector();
vector<T,Allocator>& operator=(const vector<T,Allocator>& x);
vector<T,Allocator>& operator=(vector<T,Allocator>&& x);
-----------------------------
to
+++++++++++++++++++++++++++++
// 23.2.6.1 construct/copy/destroy:
explicit vector(const Allocator& = Allocator());
explicit vector(size_type n, const Allocator& = Allocator());
vector(size_type n, const T& value, const Allocator& = Allocator());
template <class InputIterator>
vector(InputIterator first, InputIterator last,
const Allocator& = Allocator());
vector(const vector& x);
vector(vector&&);
vector(const vector&, const Allocator&);
vector(vector&&, const Allocator&);
~vector();
vector& operator=(const vector& x);
vector& operator=(vector&& x);
+++++++++++++++++++++++++++++
In 23.2.6.1, before paragraph 3, change the declaration of the
constructor to
+++++++++++++++++++++++++++++
explicit vector(size_type n, const Allocator& = Allocator());
+++++++++++++++++++++++++++++
Change paragraph 3 from
-----------------------------
Effects: Constructs a vector with n default constructed elements.
-----------------------------
to
+++++++++++++++++++++++++++++
Effects: Constructs a vector with n default constructed elements,
using the specified allocator.
+++++++++++++++++++++++++++++
Sebastian Redl
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]