Re: Input iterators?

From:

desktop <fff@sss.com>

Newsgroups:

comp.lang.c++

Date:

Tue, 24 Apr 2007 22:32:36 +0200

Message-ID:

<f0lpfn$9kt$1@news.net.uni-c.dk>

Erik Wikstr?m wrote:

On 2007-04-24 20:01, desktop wrote:

Erik Wikstr?m wrote:

On 2007-04-24 19:01, desktop wrote:

In accelerated C++ on page 146 there is this example:

template <class In, class Out>
Out copy(In begin, In end, Out dest)
{
    While (begin != end)
        *dest++ = *begin++;
    return dest;
}

They say that the function takes 3 iterators, but is that not just
another name for a pointer?

If we are dealing with a string begin would be a pointer to the
first char, end would be a pointer to the last char and dest would
contain the copy.

Or does iterator mean something more complicated?

An iterator is a concept in C++, anything that fulfills the
requirements can be used as iterators. In most (all?) cases a simple
pointer does fulfill the requirements of an iterator and can thus be
use where an iterator is required.

But an iterator can be so much more, consider for example std::map,
which is usually implemented as a RB-tree, std::map has a number of
methods that returns iterators, you can as an example iterate through
all elements in the map, this you can not do with a pointer since it
would require that all elements were contiguously laid out in memory.
The same goes for std::list which is a double-linked list.

To take the example with a string (a C++ one, and not a C char array)
there is no guarantee that the second char in the string is on the
memory-location after the first, but using iterators we let them
worry about that and just increment it to get an iterator to the next
character.

Ok so reducing iterators to pointers only works if the only structure
that are used is an integer array (under the assumption that elements
in integer arrays are placed after each other in memory).

Any array will do, since arrays are guaranteed to be a contiguous piece
of memory.

In other cases this assumption does not necessary hold and therefore
its necessary to use an iterator which I assume it designed to work on
a lot of different structures which makes it good in generic programming.

Yes, each class, such as vector, map and list, has it's own iterator-
type. Consider the following code:

std::vector<int> vec;
typedef std::vector<int>::iterator iter;

for (iter i = vec.begin(); i != vec.end(); ++i)
std::cout << *i << std::endl;

Then you can just replace std::vector<int> with, for example,
std::list<std::string> and it will work.

Ok I thought that a pointer or an iterator was just a number, but it
seems that the compiler treats them as different types:

int myints[] = {1,2,3,4,5,1,2,3,4,5};
std::vector<int> myvector (myints,myints+10);

int match1[] = {1,2,3};

int ff = match1; // gives an error indicating that match1 is an int*
int gg = myvector.begin(); // gives an error indicating that
myvector.begin() is an iterator.

BTW: Why is this legal:
std::vector<int> myvector (myints,myints+10);

on this page:
http://www.cppreference.com/cppvector/vector_constructors.html

it should match:

vector( input_iterator start, input_iterator end );

but as just described 'myints' like 'match1' are int* and not iterators.