casting an vector::iterato r to a derived type to the base class

[propokergrad]

Hello, say I have two classes:

class Base{...};
class Derived : public Base{...}

I would like to do something similar to this:

std::vector<Bas e*>::iterator b;
std::vector<Der ived*>::iterato r d;

d = vector_of_deriv ed.begin();
b = *((std::vector< Base*>::iterato r*)(&d));

Am I correct that this a really stupid thing to do? Is there a better
way of going about this? Thanks for any help!

-Mike

[red floyd]

pr**********@gm ail.com wrote:

Hello, say I have two classes:

class Base{...};
class Derived : public Base{...}

I would like to do something similar to this:

std::vector<Bas e*>::iterator b;
std::vector<Der ived*>::iterato r d;

d = vector_of_deriv ed.begin();
b = *((std::vector< Base*>::iterato r*)(&d));

Am I correct that this a really stupid thing to do? Is there a better
way of going about this? Thanks for any help!

don't even bother with the d variable.

Base* b_ptr = *b;
Derived* d_ptr = dynamic_cast<De rived*>(b_ptr);

But is there a reason you need to know if it's a Base or Derived in this
situation? If so, then you probably should have two containers,
otherwise, just rely on polymorphic behavior in Base.

[Ian Collins]

pr**********@gm ail.com wrote:

Hello, say I have two classes:

class Base{...};
class Derived : public Base{...}

I would like to do something similar to this:

std::vector<Bas e*>::iterator b;
std::vector<Der ived*>::iterato r d;

d = vector_of_deriv ed.begin();
b = *((std::vector< Base*>::iterato r*)(&d));

Am I correct that this a really stupid thing to do? Is there a better
way of going about this? Thanks for any help!

Yes, it is really stupid thing to do! Iterators are unrelated types, so
casting between different iterators is not a good idea.

Why not just use a vector of Base*?

--
Ian Collins.

[propokergrad]

Here's my issue. I have a vector<Derived* >, and an interface that
takes a vector<Base*>:: iterator. Is there something as a proxy
iterator class that will do the conversion automatically?

On Mar 28, 6:37 pm, Ian Collins <[e-mail] mwrote:

propokerg...@gm ail.com wrote:

Hello, say I have two classes:

class Base{...};
class Derived : public Base{...}

I would like to do something similar to this:

std::vector<Bas e*>::iterator b;
std::vector<Der ived*>::iterato r d;

d = vector_of_deriv ed.begin();
b = *((std::vector< Base*>::iterato r*)(&d));

Am I correct that this a really stupid thing to do? Is there a better
way of going about this? Thanks for any help!

Yes, it is really stupid thing to do! Iterators are unrelated types, so
casting between different iterators is not a good idea.

Why not just use a vector of Base*?

--
Ian Collins.

[Ian Collins]

pr**********@gm ail.com wrote:

Please don't top-post.

>
On Mar 28, 6:37 pm, Ian Collins <[e-mail] mwrote:

>>propokerg...@ gmail.com wrote:

>>>Hello, say I have two classes:

>>>class Base{...};
class Derived : public Base{...}

>>>I would like to do something similar to this:

>>>std::vector< Base*>::iterato r b;
std::vector< Derived*>::iter ator d;

>>>d = vector_of_deriv ed.begin();
b = *((std::vector< Base*>::iterato r*)(&d));

>>>Am I correct that this a really stupid thing to do? Is there a better
way of going about this? Thanks for any help!

Yes, it is really stupid thing to do! Iterators are unrelated types, so
casting between different iterators is not a good idea.

Why not just use a vector of Base*?

Here's my issue. I have a vector<Derived* >, and an interface that
takes a vector<Base*>:: iterator. Is there something as a proxy
iterator class that will do the conversion automatically?

Not easily, no. The iterators are different types.

Can't you change the vector<Derived* to a vector<Base*>?

--
Ian Collins.