Re: vector ctor passed with two arguments of same type
On Apr 29, 9:47 am, Kai-Uwe Bux <jkherci...@gmx.net> wrote:
subramanian10...@yahoo.com, India wrote:
I am copying the following text as it is from Stroustrup's TC++PL 3rd
edition, page 450.
It says:
"Note that a constructor given two arguments of the same
type can be a match for more than one constructor. For
example,
vector<int> v(10, 50); // (size, value) or (iterator1, iterator2)?
The problem is that the declaration
template <class In> vector<In first, In last, const A& = A());
doesn't actually say that 'In' must be an input iterator.
The declaration specifies only that the constructor's two
first arguments must be of the same type. The unfortunate
consequence is that v's declaration causes compile-time or
link-time errors."
My Doubt:
---------------
I ran the following program with v(10, 50). It didn't give
any compilation or linker error. Instead it printed ten 50s.
I am using g+ + 3.4.3
Is it wrong with the compiler or my understanding that 'In'
should be an input iterator is wrong. ? Kindly clarify.
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> v(10, 50);
for (vector<int>::const_iterator cit = v.begin(); cit !=
v.end(); ++cit)
cout << *cit << endl;
return EXIT_SUCCESS;
}
This is covered by the standard [23.1.1/9]:
For every sequence defined in this clause and in clause 21:
? the constructor
template <class InputIterator>
X(InputIterator f, InputIterator l, const Allocator& a = Allocator=
())
shall have the same effect as:
X(static_cast<typename X::size_type>(f),
static_cast<typename X::value_type>(l),
a)
if InputIterator is an integral type.
Two additional remarks:
-- This is a "correction" of the C++ committee to the original
STL. I think it was added toward the end of the
standardization process, and Stroustrup's text may be
talking about an earlier version, where you did have to cast
the first argument to a size_t for the correct constructor
to be called.
-- The "correction" also allows things like:
std::vector< std::vector< int > > v( 10, 50 ) ;
because the "effect" is described using an explicit
conversion (static_cast) rather than an implicit one. The
consensus of the committe is that this was more than was
intended, and the next version of the standard has been
reworded so that the "effect" depends on an implicit
conversion (and the preceding line is illegal). (On the
other hand, the new wording will allow something like:
std::vector< double > v( 3.5, 5.0 ) ;
which is currently still illegal.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34