vector constructor

Suppose I have one vector as follows:

Code:

---

  vector<int> v1;
    for(int i = 0; i < 10; ++i) {
      v1.push_back(i+1);
    vector<int>::iterator next;
    }

---

and I want to make a new vector containing, say, the first 5 elements of v1. Why is it OK to do

Code:

---

  vector<int> v2(&v1[0], &v1[5]);
 
  for(next = v2.begin() ; next != v2.end(); ++next ) {
    cout << *next << " ";
  }
  cout << "\n";

---

and OK to do

Code:

---

  next = v1.begin();
  vector<int> v2(next, next+5);

---

but not OK to do

Code:

---

  vector<int> v2(v1.begin(), &v1[5]);

---

Well the short answer is that v1.begin() and &v1[5] aren't the same type (the first being std::vector<int>::iterator, the second being int*). I personally would be very surprised if there was any way that v1.begin()+5 == &v1[5] could even be true. (That doesn't mean it probably doesn't happen, of course.)

The compiler won't even let me make that kind of comparison. I tried

Code:

---

  cout << (v1.begin() == &v1[0]) << endl;

---

and was rewarded with

Code:

---

testv.cc: In function `int main()':
testv.cc:47: error: no match for 'operator==' in 'std::vector<_Tp,
  _Alloc>::begin() [with _Tp = int, _Alloc = std::allocator<int>]() ==
  +(&v1)->std::vector<_Tp, _Alloc>::operator[] [with _Tp = int, _Alloc =
  std::allocator<int>](0)'

---

I guess the real point of my question is, since that constructor wants iterators, why does it let me get away with

Code:

---

  vector<int> v2(&v1[0], &v1[5]);  // the compiler allows this

---

Because the compiler wants iterators. It does not require std::vector<int>::iterators, just iterators -- and specifically, two iterators of the same type (which these are -- int* is an iterator).

Quote:

---

Originally Posted by R.Stiltskin

I guess the real point of my question is, since that constructor wants iterators, why does it let me get away with

Code:

---

  vector<int> v2(&v1[0], &v1[5]);  // the compiler allows this

---

---

Because a pointer IS an iterator, in the sense this constructor wants. &v1[0] is of type int *, which is a perfectly meaningful iterator type

Because the signature of the constructor is as follows:

Code:

---

template <class Iter>
vector(Iter from, Iter to)

---

where Iter can be a suitable pointer, vector::iterator, list::iterator, my_random_sequence_generator::iterator etc.

As you can see both arguments must be of the same type.

I have looked through the standard for a related question, but I can't find it. So I'll add it here, as it is interesting for the OP as well...
The OP uses v1.begin() + 5. How is this defined for iterators? As I understand it, it is not defined to be a constant time operation; it may be implemented as O(n). &v1[5], however, is defined to be constant time.
I think any implementation will probably make the + operator for an iterator on a vector constant time, but can you actually assume it does?

Operator + should be constant time. There are several kinds of iterators, and if they can't implement operator+ in constant time then it is not available at all.

There is also a std::advance(iterator, how_much) function which is constant time (iterator += how_much) for random access iterators and linear for others (++iterator how_much times). In your own applications you can get the type of the iterator using std::iterator_traits<some_iterator>::iterator_cate gory which is specialized for pointers, so pointers are recognized as random_access iterators too.

Quote:

---

Originally Posted by anon

Because the signature of the constructor is as follows:

Code:

---

template <class Iter>
vector(Iter from, Iter to)

---

where Iter can be a suitable pointer, vector::iterator, list::iterator, my_random_sequence_generator::iterator etc.

As you can see both arguments must be of the same type.

---

Well, you can see that, but it wasn't immediately apparent to me (although, thinking about it now, it does make sense that that should be the case). I have to say I'm still not accustomed to consulting official iso standards on a regular basis. I was looking at this (from cppreference.com):

Code:

---

#include <vector>
    vector();
    vector( const vector& c );
    vector( size_type num, const TYPE& val = TYPE() );
    vector( input_iterator start, input_iterator end );
    ~vector();

---

which doesn't seem to say that the two iterators must be of the same type. Now I see, in the iso standard (which you seem to be paraphrasing),

Code:

---

23.2.4.1 vector constructors, copy, and assignment

    vector(const Allocator& = Allocator());
    explicit vector(size_type n, const T& value = T(),
                          const Allocator& = Allocator());
    template <class InputIterator>
      vector(InputIterator first, InputIterator last,
                const Allocator& = Allocator());
    vector(const vector<T,Allocator>& x);

---

but that seems to be a pretty "clunky" source for frequent reference.
Do you know of a convenient online reference that provides more details than cppreference.com?

>> Do you know of a convenient online reference that provides more details than cppreference.com?

It's not an online reference, but The C++ Standard Library: A Tutorial and Reference by Josuttis.

You can also go to the sites of actual library implementations. The two I usually check are from dinkumware and SGI:

http://www.dinkumware.com/manuals/default.aspx
http://www.sgi.com/tech/stl/table_of_contents.html

The MSDN provides a ton of detail and examples.
Unfortunately they aren't always accurate and sometimes mix in MS specific crap.

Quote:

---

Originally Posted by cpjust

The MSDN provides a ton of detail and examples.
Unfortunately they aren't always accurate and sometimes mix in MS specific crap.

---

That's a heckuva recommendation! :p