«

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 ?

call_me_anything 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.

"call_me_anything" <> wrote in message
news: ps.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<X> vx;
vector<Y> vy;

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.assign(vec_of_derived.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>*.

Andrew Koenig wrote:
> "call_me_anything" <> wrote in message
> news: ps.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<X> vx;
> vector<Y> vy;
>
> 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...maybe something like so:

template < typename other_val_type >
enable_if
<
mpl::and_
<
is_pointer<value_type>
, is_pointer<other_val_type>
, is_base_of<value_type, other_val_type>
>
, vector &
>
operator = ( vector<other_val_type> const & right)
{
....??
}

On Jan 23, 8:31 pm, "call_me_anything" <s...@yahoo.com> 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_cast vec_of_base. Though, having been never tried out by
me, it seems reasonable.

call_me_anything 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.assign(vec_of_derived.begin(), vec_of_derived.end());

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

Joe Gottman

> 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=*reinterpret_cast<vector<Base*>*>(&vec _of_derived)

This does work, at least under MSVS.

"Pavel Shved" <> wrote in message
news: oups.com...

> I became curious enough to check it for myself.

> vec_of_base=*reinterpret_cast<vector<Base*>*>(&vec _of_derived)

> This does work, at least under MSVS.

If it works, it does so only by coincidence.

On Jan 24, 8:54 am, "Andrew Koenig" <a...@acm.org> wrote:
> > vec_of_base=*reinterpret_cast<vector<Base*>*>(&vec _of_derived)

> 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.

On Jan 23, 1:33 pm, "Noah Roberts" <roberts.n...@gmail.com> wrote:

> > whenever it is possible to convert Y to X.You could use a combination of enable_if, is_pointer, and
> is_base_of...maybe something like so:
>
> template < typename other_val_type >
> enable_if
> <
> mpl::and_
> <
> is_pointer<value_type>
> , is_pointer<other_val_type>
> , is_base_of<value_type, other_val_type>
> >
> , vector &
> > // HERE
> operator = ( vector<other_val_type> const & 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.