vector <Base *> = vector <Derived *> ??

[call_me_anything]

why is the following not allowed :

vector <Base *vec_of_base;
vector <Derived *vec_of_derived ;
vec_of_base = vec_of_derived;

Note : The following is allowed :

Base *base_ptr;
Derived *derived_ptr;
base_ptr = derived_ptr;

How do things change when we use a vector ?

[Mark P]

call_me_anythin g wrote:

why is the following not allowed :

vector <Base *vec_of_base;
vector <Derived *vec_of_derived ;
vec_of_base = vec_of_derived;

Because vector<Derived* is not derived from vector<Base*>. In fact,
considering the possibility of template specialization, vector<Derived* >
may be wildly different than vector<Base*>.

>
Note : The following is allowed :

Base *base_ptr;
Derived *derived_ptr;
base_ptr = derived_ptr;

How do things change when we use a vector ?

It's not unique to a vector. A relation between the template parameters
does not imply any relationship between the template classes.

[Andrew Koenig]

"call_me_anythi ng" <sg***@yahoo.co mwrote in message
news:11******** *************@q 2g2000cwa.googl egroups.com...

why is the following not allowed :

vector <Base *vec_of_base;
vector <Derived *vec_of_derived ;
vec_of_base = vec_of_derived;

It's hard to understand how one would implement such a feature without also
allowing

vector<Xvx;
vector<Yvy;

vx = vy;

whenever it is possible to convert Y to X. Such assignments could be
allowed in principle, but they can also be hazardous and inefficient. If
you want to achieve that effect, you can do so fairly easily:

vec_of_base.ass ign(vec_of_deri ved.begin(), vec_of_derived. end());

Please note that this question is completely different from the commonly
asked question about why it is not possible to convert a vector<Derived> * to
a vector<Base>*.

[Noah Roberts]

Andrew Koenig wrote:

"call_me_anythi ng" <sg***@yahoo.co mwrote in message
news:11******** *************@q 2g2000cwa.googl egroups.com...

why is the following not allowed :

vector <Base *vec_of_base;
vector <Derived *vec_of_derived ;
vec_of_base = vec_of_derived;

It's hard to understand how one would implement such a feature without also
allowing

vector<Xvx;
vector<Yvy;

vx = vy;

whenever it is possible to convert Y to X.

You could use a combination of enable_if, is_pointer, and
is_base_of...ma ybe something like so:

template < typename other_val_type >
enable_if
<
mpl::and_
<
is_pointer<valu e_type>
, is_pointer<othe r_val_type>
, is_base_of<valu e_type, other_val_type>

>

, vector &

>

operator = ( vector<other_va l_typeconst & right)
{
....??
}

[Pavel Shved]

On Jan 23, 8:31 pm, "call_me_anythi ng" <[e-mail] wrote:

why is the following not allowed :

vector <Base *vec_of_base;
vector <Derived *vec_of_derived ;
vec_of_base = vec_of_derived;
...
How do things change when we use a vector ?

Well, and if we call these types not Base and Derived, having the
assignment base=derived being correct, will these vectors be equal,
without derivation relationships? We will have to do element-by-element
assignment anyway.

Although in this case there should work a trick, based on the equality
of Base* and Derived* entities -- they are pointers with same size. I'm
not quite sure whether it's correct, but i was once told to try
reinterpret_cas t vec_of_base. Though, having been never tried out by
me, it seems reasonable.

[Joe Gottman]

call_me_anythin g wrote:

why is the following not allowed :

vector <Base *vec_of_base;
vector <Derived *vec_of_derived ;
vec_of_base = vec_of_derived;

Note that the following is legal:

vector<Base *vec_of_base;
vector<Derived *vec_of_derived ;
vec_of_base.ass ign(vec_of_deri ved.begin(), vec_of_derived. end());

Admittedly it's much wordier than your version, but it compiles and does
what you want.

Joe Gottman

[Pavel Shved]

why is the following not allowed :

>
vector <Base *vec_of_base;
vector <Derived *vec_of_derived ;
vec_of_base = vec_of_derived;

I became curious enough to check it for myself.

vec_of_base=*re interpret_cast< vector<Base*>*> (&vec_of_derive d)

This does work, at least under MSVS.

[Andrew Koenig]

"Pavel Shved" <Pa*********@gm ail.comwrote in message
news:11******** **************@ m58g2000cwm.goo glegroups.com.. .

I became curious enough to check it for myself.

vec_of_base=*re interpret_cast< vector<Base*>*> (&vec_of_derive d)

This does work, at least under MSVS.

If it works, it does so only by coincidence.

[Pavel Shved]

On Jan 24, 8:54 am, "Andrew Koenig" <[e-mail] ote:

vec_of_base=*re interpret_cast< vector<Base*>*> (&vec_of_derive d)

If it works, it does so only by coincidence.

Yes, coincidence is the exact reason why it does work. ;-) vector
<Base*and vector <Derived*are be byte-to-byte equal.

[Noah Roberts]

On Jan 23, 1:33 pm, "Noah Roberts" <roberts.n...@g mail.comwrote:

whenever it is possible to convert Y to X.You could use a combination of enable_if, is_pointer, and

is_base_of...ma ybe something like so:

template < typename other_val_type >
enable_if
<
mpl::and_
<
is_pointer<valu e_type>
, is_pointer<othe r_val_type>
, is_base_of<valu e_type, other_val_type>

>

, vector &

// HERE

operator = ( vector<other_va l_typeconst & right)
{
...??

}

I don't normally respond to people that email me instead of posting to
the group but I decided in this case I would. Someone asked me two
questions:

1) Are these standard components or did I just make them up?

It is a combination of standard stuff and things that are found in
certain boost libraries. Some of it, including the is_pointer and
is_base_of traits, will be in the next standard. These are basic
metaprogramming techniques but if you've never seen metaprogramming it
might be rather difficult to understand.

2) Where does the last go?

Apparently google groups removed it. It should be on the line after
vector& and before "operator", I put it back.

Now, newsgroup etiquette says you post your replies to the group, not
the user. This is not only because it might be considered rude but so
that others can see the answer...now you know.