A question about iterators.

[JustSomeGuy]

I have a method that takes a pointer to an object as a parameter.

method(image * i)
{
....
}
somefunction(series *Ser)
{
series::iterator im_it;
for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
x = method(&*im_it);
...
}
}

Notice the call to the method has the address of the contents of the
iterator?
What have I done wrong here... Why couldn't I just call the method as:
x = method(im_it);

[Art Stamness]

I assume somewhere you have this :

typedef std::list<image> series ;
/// Or some other sequence container vector, deque ...

The type series::iterator is a type of object ( sometimes a pointer ),
which is used to iterate through a container. To get to the item that
the iterator points to you must first dereference it through operator*.
This gets you back to the object "image", since your function takes a
pointer to that object, you must then put "&" in front, to get the
pointer to it. Hence the need for "&*im_it".

In some implementations of std::vector a iterator is indeed a pointer,
but you should not rely on that, as switching to a different
implementation will cause your code to not compile. ( See Meyers
Effective STL for lots of discussion regarding this ).

I hope this helped.

-Art

[Victor Bazarov]

JustSomeGuy wrote:

I have a method that takes a pointer to an object as a parameter.

method(image * i)
{
....
}
somefunction(series *Ser)
{
series::iterator im_it;
for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
x = method(&*im_it);
...
}
}

Notice the call to the method has the address of the contents of the
iterator?
Not the address of the contents. The address of the results of the
operator* applied to the iterator.
What have I done wrong here...
Nothing, judging from the minuscule amount of code you provided.
Why couldn't I just call the method as:
x = method(im_it);

You could if 'im_it' were convertible to 'image*'.

V

[Ben Pope]

JustSomeGuy wrote:

I have a method that takes a pointer to an object as a parameter.

method(image * i)
{
....
}
somefunction(series *Ser)
{
series::iterator im_it;
for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
x = method(&*im_it);
...
}
}

Notice the call to the method has the address of the contents of the
iterator?
What have I done wrong here... Why couldn't I just call the method as:
x = method(im_it);

An interator may not be implemented as a pointer.

You should also post complete code.

Ben
--
I'm not just a number. To many, I'm known as a String...

[Andre Kostur]

"JustSomeGuy" <bo*******@yahoo.com> wrote in news:1124995116.298859.232630
@o13g2000cwo.googlegroups.com:

I have a method that takes a pointer to an object as a parameter.

method(image * i)
{
....
}
somefunction(series *Ser)
{
series::iterator im_it;
for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
x = method(&*im_it);
...
}
}

Notice the call to the method has the address of the contents of the
iterator?
What have I done wrong here... Why couldn't I just call the method as:
x = method(im_it);

Because series::iterator isn't necessarily a pointer. It may be a full
blown class. However, *im_it is required to be a reference to the
contained type. So, by doing a &*im_it you are getting a pointer to the
contained type.

[Clark S. Cox III]

On 2005-08-25 14:43:55 -0400, Andre Kostur <nn******@kostur.net> said:

"JustSomeGuy" <bo*******@yahoo.com> wrote in news:1124995116.298859.232630
@o13g2000cwo.googlegroups.com:

I have a method that takes a pointer to an object as a parameter.

method(image * i)
{
....
}
somefunction(series *Ser)
{
series::iterator im_it;
for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
x = method(&*im_it);
...
}
}

Notice the call to the method has the address of the contents of the
iterator?
What have I done wrong here... Why couldn't I just call the method as:
x = method(im_it);
Because series::iterator isn't necessarily a pointer. It may be a full
blown class. However, *im_it is required to be a reference to the
contained type.

<pedantic>
That, of course, depends on series::iterator's category. If it is
simply an Input Iterator, then there is no guarantee that *im_it is a
reference at all (operator*() may return by value, or it may return
some intermediate helper class, etc.).
</pedantic>
So, by doing a &*im_it you are getting a pointer to the contained type.

--
Clark S. Cox, III
cl*******@gmail.com

[Andre Kostur]

Clark S. Cox III <cl*******@gmail.com> wrote in
news:2005082517010916807%clarkcox3@gmailcom:

On 2005-08-25 14:43:55 -0400, Andre Kostur <nn******@kostur.net> said:

"JustSomeGuy" <bo*******@yahoo.com> wrote in
news:1124995116.298859.232630 @o13g2000cwo.googlegroups.com:

I have a method that takes a pointer to an object as a parameter.

method(image * i)
{
....
}
somefunction(series *Ser)
{
series::iterator im_it;
for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
x = method(&*im_it);
...
}
}

Notice the call to the method has the address of the contents of the
iterator?
What have I done wrong here... Why couldn't I just call the method
as: x = method(im_it);

Because series::iterator isn't necessarily a pointer. It may be a
full blown class. However, *im_it is required to be a reference to
the contained type.

<pedantic>
That, of course, depends on series::iterator's category. If it is
simply an Input Iterator, then there is no guarantee that *im_it is a
reference at all (operator*() may return by value, or it may return
some intermediate helper class, etc.).
</pedantic>

OK... granted. However somewhere else we were talking about a list<>
specifically... so I'm assuming a container, and not something like
istream_iterator :)

[Old Wolf]

JustSomeGuy wrote:

somefunction(series *Ser)
{
series::iterator im_it;
for (im_it=Ser->begin(); im_it != Ser->end(); ++im_it)
{
x = method(&*im_it);
...
}
}

If you aren't going to check 'Ser' for NULL, then consider
passing by reference:

somefunction(series &ser)
{
for (series::iterator im_it = ser.begin();
im_it != ser.end(); ++im_it)
x = method(&*im_it);
}