list<int> constructor

Code:

int data[] = {1, 2, 3, 4, 5, 6, 7, 8};
list<int> numbers(data, data+3); // 1 2 3
list<int> values(data+4, data+8); // 5 6 7 8
numbers.splice(++numbers.begin(), values); // 1 5 6 7 8 2 3

list<T> accepts an iterator but here we provide a pointeR ??? it works... wHy ???

Since a pointer behaves like an iterator (adding one to it works by giving you the next piece of memory, using * works by giving you an int), then it is an iterator. (I'm getting tired of reading that line in Josuttis, so I thought I'd inflict it on you.)

so u mean we can assign pointers to an iterator both of the same tyPE ?

and it will work ?

That particular constructor is itself a function template whose template argument is an input iterator. Consequently, it works with any pair of input iterators of the same type, from pointers to std::istream_iterator.

I have no idea what you're asking. A std::list constructor takes a very general sort of iterator (it doesn't have to be a list::iterator), and int* can be converted to that general iterator. You can't assign an int* to a list::iterator.

That constructor is templated, which means that as long as the argument types meet the requirements anything goes.

So, that constructor might be implemented as following:

Code:

    template <class Iter>
    list(Iter first, Iter last)
    {
        while (first != last) {
            theList.push_back(*first);
            ++first;
        }
    }

As you can see, what is required of the Iter type is that it supports operator!=, operator* (which must return a type that can go into the list), and operator++. These operators work for both pointers and iterators.

>> so u mean we can assign pointers to an iterator both of the same tyPE ?

No, you can't assign a pointer to a list<T>::iterator. They are different types. The constructor for list doesn't take a regular type, it takes a templated type. A templated type is different than a regular type, because it is just a concept. It means, any regular type that fits certain requirements can be used here.

So any regular type that can be incremented with ++ and can be dereferenced with * should work there. That doesn't mean anything that works there is the same type, just that they all fit the "iterator" concept, or in this case the input iterator concept.

Further, because of all that, you can create lists out of things that have little to do with arrays or sequences, as long as they have a suitable interface. For example the following, which generates a sequence as demanded (the minimal example might lack a few operators):

Code:

 
#include <iostream>
#include <list>

class make_sequence
{
    int value;
public:
    make_sequence(int n): value(n) {}
    make_sequence& operator++()
    {
        ++value;
        return *this;
    }
    int operator*() const { return value; }
    bool operator!= (make_sequence other) const
    {
        return value != other.value;
    }
};

int main()
{
    std::list<int> n(make_sequence(1), make_sequence(10)); //1, 2, 3, 4, 5, 6, 7, 8, 9
    for (std::list<int>::iterator it = n.begin(); it != n.end(); ++it) {
        std::cout << *it << ' ';
    }
}

Originally Posted by Daved

That doesn't mean anything that works there is the same type, just that they all fit the "iterator" concept, or in this case the forward_iterator concept.

As I mentioned earlier, the requirement is not so strict: only input iterators are required since a copy is a single pass algorithm.