How to gurantee iterator behavior?

[desktop]

I have read about input, output forward etc iterators. But if I make the
following:

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

I can still type "--forward_iterator" eventhough "--it" is illegal on
forward iterators.

Are there some way to specify an iterator so the compiler will give
errors if used incorrectly, like when using the keyword "const" on a
variable?

I also read that find_end uses forward_iterators, but as I understand
they provide sequential read-write access. I don't see why the write
access is needed, would an input_iterator (read-only) not be more
appropriate since find only returns unchanged info?

[Gianni Mariani]

desktop wrote:

I have read about input, output forward etc iterators. But if I make the
following:

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

I can still type "--forward_iterator" eventhough "--it" is illegal on
forward iterators.

std::vector<T>::iterator does support --.

>
Are there some way to specify an iterator so the compiler will give
errors if used incorrectly, like when using the keyword "const" on a
variable?

I suppose you can create a class that is an iterator and override
operator--. There is some work on a thing called "C++ Concepts" that
may be what you're looking for. I personally don't set the cost/benefit
ratio working out but I may be wrong on this one.

>
I also read that find_end uses forward_iterators, but as I understand
they provide sequential read-write access. I don't see why the write
access is needed, would an input_iterator (read-only) not be more
appropriate since find only returns unchanged info?

You can send a const_iterator to find_end.

[Zeppe]

desktop wrote:

I have read about input, output forward etc iterators. But if I make the
following:

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

I can still type "--forward_iterator" eventhough "--it" is illegal on
forward iterators.

that's because, if you see the documentation for the class vector, you
will discover that the vector iterator is a random iterator, that is, it
implements the operators ++, --, ==, &, <, +=, -=, +, -, [] (if I
haven't forgot any). forward_iterator is just the name of your variable :)

Are there some way to specify an iterator so the compiler will give
errors if used incorrectly, like when using the keyword "const" on a
variable?

it's not needed. For example, if they tell you that the function

template<typename iterator>
foo(iterator i);

requires a bidirectional iterator, it's because inside of foo both the
operators ++ and -- will be used. If you provide it with a forward
iterator, the compiler will complain, not finding any operator-- for
that class.

I also read that find_end uses forward_iterators, but as I understand
they provide sequential read-write access. I don't see why the write
access is needed, would an input_iterator (read-only) not be more
appropriate since find only returns unchanged info?

this would be a const_iterator. The same, but read only.

Regards,

Zeppe

[desktop]

Zeppe wrote:

desktop wrote:

>I have read about input, output forward etc iterators. But if I make the
following:

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

I can still type "--forward_iterator" eventhough "--it" is illegal on
forward iterators.

that's because, if you see the documentation for the class vector, you
will discover that the vector iterator is a random iterator, that is, it
implements the operators ++, --, ==, &, <, +=, -=, +, -, [] (if I
haven't forgot any). forward_iterator is just the name of your variable :)

>Are there some way to specify an iterator so the compiler will give
errors if used incorrectly, like when using the keyword "const" on a
variable?

it's not needed. For example, if they tell you that the function

template<typename iterator>
foo(iterator i);

requires a bidirectional iterator, it's because inside of foo both the
operators ++ and -- will be used. If you provide it with a forward
iterator, the compiler will complain, not finding any operator-- for
that class.

I am a bit confused. How will the compiler complain if a forward
iterator is just a variable name? The only way I can get it to report an
error is if I make my own class "class ForwarIterator" where I somehow
make it illegal to use "--".

[Zeppe]

desktop wrote:

I am a bit confused. How will the compiler complain if a forward
iterator is just a variable name?

it won't complain.

The only way I can get it to report an
error is if I make my own class "class ForwarIterator" where I somehow
make it illegal to use "--".

Well, is not necessary to make the use of operator-- forbidden. It's
enough not to define it. Example, you write a very strange container
that for some really good reason ant to provide only the forward access
to the elements. You decide to implement the iterators for your
container, because it's a good and flexible way to access it (maybe is
not possible to access it like a normal vector, with []).

The you will write:

class MyContainerIterator
{
public:
bool operator==(const MyContainerIterator&) const;
const MyContainerIterator & operator==(const MyContainerIterator&);
MyType& operator*();
};

where MyType is the type of the elements of you container. The
implementation of the iterator will be more or less difficult depending
on your container.

and then, in your container:

class MyContainer
{
public:
typedef MyContainerIterator iterator;

iterator begin();
iterator end();
}

ok, now your container has got a forward iterator. When you want to use
it, you will define

MyContainer::iterator foo = mycont.begin();

you will be able to use it in all the stl functions that accept a
forward iterator, but if you put in some function that accept beckward
iterators, for example, the compiler will try to use the operator-- on
your Iterator class, and will complain because it haven't got it.

Regards,

Zeppe

[desktop]

Zeppe wrote:

desktop wrote:

>I am a bit confused. How will the compiler complain if a forward
iterator is just a variable name?

it won't complain.

>The only way I can get it to report an
error is if I make my own class "class ForwarIterator" where I somehow
make it illegal to use "--".

Well, is not necessary to make the use of operator-- forbidden. It's
enough not to define it. Example, you write a very strange container
that for some really good reason ant to provide only the forward access
to the elements. You decide to implement the iterators for your
container, because it's a good and flexible way to access it (maybe is
not possible to access it like a normal vector, with []).

The you will write:

class MyContainerIterator
{
public:
bool operator==(const MyContainerIterator&) const;
const MyContainerIterator & operator==(const MyContainerIterator&);
MyType& operator*();
};

where MyType is the type of the elements of you container. The
implementation of the iterator will be more or less difficult depending
on your container.

and then, in your container:

class MyContainer
{
public:
typedef MyContainerIterator iterator;

iterator begin();
iterator end();
}

ok, now your container has got a forward iterator. When you want to use
it, you will define

MyContainer::iterator foo = mycont.begin();

you will be able to use it in all the stl functions that accept a
forward iterator, but if you put in some function that accept beckward
iterators, for example, the compiler will try to use the operator-- on
your Iterator class, and will complain because it haven't got it.

Regards,

Zeppe

Ok but is there not a class in the STL that defines this kind of
behavior for an iterator already?

Seems confusing that the iterators mentioned at:

http://www.cppreference.com/iterators.html

has different names but you can use the same operators on them. And the
only way to make them different are by making your own classes as your
example above.

[Zeppe]

desktop wrote:

Ok but is there not a class in the STL that defines this kind of
behavior for an iterator already?

no. At the end, since the real behaviour of the operators depends on
your specific container, the only thing that could be defined would be
some virtual function to be overloaded. Useless, since as I shown you if
you don't define the operators, the compiler will complain anyway, less
flexible, because for example you coudn't construct your vector from
int* as you did, and much less performing (and the iterators have to be
fast).

Seems confusing that the iterators mentioned at:

http://www.cppreference.com/iterators.html

has different names but you can use the same operators on them.

those names are not related to any class. It's just a categorization.

And the
only way to make them different are by making your own classes as your
example above.

well, the type of an iterator is defined only by the methods that it
supports. If your class is a forward iterator, has to support ++,==,*,
if it supportas also -- is not a forward iterator anymore, is a
bidirectional one. This is the template conceptual philosophy, sometimes
referred as "duck typing":

"When I see a bird that walks like a duck and swims like a duck and
quacks like a duck, I call that bird a duck."

In the iterators case, it would be:

"When I see an object that increments like a forward iterator and
decrements like a forward iterator and dereferences like a forward
iterator, I call that object a forward iterator."

Regards,

Zeppe

[jiaxiong.xu]

On 4ÔÂ25ÈÕ, ÏÂÎç4ʱ43·Ö, desktop <[e-mail]:

I have read about input, output forward etc iterators. But if I make the
following:

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

std::vector<int>::const_iterator

>
I can still type "--forward_iterator" eventhough "--it" is illegal on
forward iterators.

Are there some way to specify an iterator so the compiler will give
errors if used incorrectly, like when using the keyword "const" on a
variable?

I also read that find_end uses forward_iterators, but as I understand
they provide sequential read-write access. I don't see why the write
access is needed, would an input_iterator (read-only) not be more
appropriate since find only returns unchanged info?

[desktop]

Gianni Mariani wrote:

desktop wrote:

>I have read about input, output forward etc iterators. But if I make
the following:

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

I can still type "--forward_iterator" eventhough "--it" is illegal on
forward iterators.

std::vector<T>::iterator does support --.

On this page they pretty much conclude that bidirectional and
random_access iterators are the same thing:

// Random access iterators are bidirectional iterators that
// can access any point in the container.

http://anaturb.net/C/iter_example.ht...ccess_iterator

and that you declare them both with:
vector<int>::iterator pos;
// vector::iterator and deque::iterator
// are random access iterator types

So I don't understand that you write that

"std::vector<T>::iterator does support --."

[=?ISO-8859-1?Q?Erik_Wikstr=F6m?=]

On 2007-04-28 21:15, desktop wrote:

Gianni Mariani wrote:

>desktop wrote:

>>I have read about input, output forward etc iterators. But if I make
the following:

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

I can still type "--forward_iterator" eventhough "--it" is illegal on
forward iterators.

std::vector<T>::iterator does support --.

On this page they pretty much conclude that bidirectional and
random_access iterators are the same thing:

// Random access iterators are bidirectional iterators that
// can access any point in the container.

http://anaturb.net/C/iter_example.ht...ccess_iterator

You can make a random access iterator "jump around", while a
bidirectional iterator can only move one step at a time.

Consider an collectionand an iterator it to the beginning of this
collection, then if you can use *(it + 3) to access the 4th element of
this collection the iterator is a random access iterator. If you have to
do it++; it++; it++; to get to the forth element it is at most a
bidirectional iterator.

--
Erik Wikström

[James Kanze]

On Apr 28, 9:15 pm, desktop <[e-mail]:

Gianni Mariani wrote:

desktop wrote:

I have read about input, output forward etc iterators. But if I make
the following:

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

I can still type "--forward_iterator" eventhough "--it" is illegal on
forward iterators.

std::vector<T>::iterator does support --.

On this page they pretty much conclude that bidirectional and
random_access iterators are the same thing:

// Random access iterators are bidirectional iterators that
// can access any point in the container.

http://anaturb.net/C/iter_example.ht...ccess_iterator

You're quoting out of context. The very next sentence says that
"In a constant amount of time, one can move to any position in a
containerusing a random access iterator." Which is *not* true
for bidirectional iterators. (The wording in the page you quote
is somewhat loose, perhaps to try and make the text more easily
assimilable. The exact rule is that a random access iterator
meets all the constraints of a bidirectional iterator, and in
addition...)

and that you declare them both with:

vector<int>::iterator pos;

Both what? There is only one type in the declaration above, and
it meets to constraints of a random access iterator (which
includes the constraints of a bidirectional iterator, which
includes the constraints of a forward iterator, which includes
the constraints of an input iterator).

// vector::iterator and deque::iterator
// are random access iterator types

So I don't understand that you write that

"std::vector<T>::iterator does support --."

I don't understand what you don't understand. Random access
iterators must meet all of the constraints of bidirectional
iterators. One of those constraints is support for --.

--
James Kanze (Gabi Software) email: ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]