🚀 go-pugleaf

Stefan Neis (neis@cs.uni-sb.de) wrote:
:                Hi there,

: I'm having an ugly problem with templates and inheritance. I mirrored
: my problem by a less complicated --though useless --  example which
: avoids using templates.
:    A    B
: 	|
:        Bderived
: and let there be a constructor which makes a Bderived from A.
:
: I hoped, the compiler would automatically convert A to Bderived (user
: defined conv.) and then convert this to B (standard conversion, isn't
: it?) if I give an "A" as argument to a function expecting a "B".

Strictly speaking, it expects a const B&, and yes, you can call such
a function with a temporary Bderived as argument.  The trouble is,
*any* class derived from B has this property.  What kind of object
should the compiler construct?  I know, in your example, the situation
is unambiguous, but that won't be true in general.  Your explicit cast
works because it tells the compiler you want, specifically, a
Bderived object. 

: I hoped, the compiler would automatically convert A to Bderived (user
: defined conv.) and then convert this to B (standard conversion, isn't
: it?) if I give an "A" as argument to a function expecting a "B". But
: this is obviously not the case -- neither with g++ nor with CC -- (see
: the following example), so I assume that a user defined conversion
: always has to be the last conversion that is applied to an
: argument. Is this assumption correct (Couldn't find anything on this
: in Stroustrup's "The C++ Programming Language")? 

Not quite.  It's true when the conversion is via ctor, because of the
potential ambiguity I mention above.  But, for example, if you have
defined an A::operator int(), then it's legal to use an A where
where float is expected.  The conversion to float happens after the
conversion to int. 

If so, are there
: plans to change this? I would find this kind of conversions extremely
: useful for using templates, e.g. (to get to my original example) if
: you want a "vector<int>" and a "vector<complex>", where complex is
: intended to be some class realizing complex numbers, you would like to
: have a automatic conversion from "vector<int>" to "vector<complex>"
: and maybe "vector<complex>" should have additional functions. So I
: wrote a "base_vector<T>" (corresponding to B) where all common
: functions are included, vector inherits from this, and is specialised
: for complex...

Your idea (or something like it) has considerable merit, if you
derive the template from a base class that is *not* a template.  In
other words, if there is functionality that any vector<T> will share
regardless of T, put it in the base class and you'll get only one
copy of the code generated, instead of a bazillion.  In any case,
you'll need to define the operators all at the vector<T> level, so
that the argument and return types are right -- but probably many
can be one-liners that invoke workhorse functions in the base class.

Good luck!

[code example deleted]

--
Russell Blackadar,   russell@mdli.com