Re: Help with Template-Template and Mixin Polymorphism

On Aug 9, 1:37 pm, TimeHorse <darkl...@timehorse.com> wrote:


This is a slightly better example of what I'm trying to do. Here you
can see, there is a (pure) virtual function in A called foo that I
want B to override. The problem is that the types used by foo must
come from the X template parameter to A. The code as you see it below
will not compile because two different A bases are created and one of
them is not derived by B and thus has no implementation for foo.
AFAICT, the B-hierarchy define's A's X as G<Z>::G1, where as the non-B-
hierarchy sets A's X to P<Y>::H::G1 which is G<X>::G1 from the B
hierarchy which is G<G<Z>::G1>::G1. Since G<Z>::G1 is not the same
type as G<G<Z>::G1>::G1, the definitions of A differ, which is not
desired. An alternate solution would be to define a specialization of
G that says: "when the definition of X1 in G is of the form X1 =
G<X2>::G1 (X2 being of the same template type as X1), make
G<G<X2>::G1>::G1 type equivalent to G<X2>::G1". I.e. do not let the
definition of G1 be recursive.

template <class E, class Y>
struct Z
{
    typedef E key_type;
    typedef Y value_type;
};

template <template <class, class> class X1>
struct G
{
    template <class E2, class Y2>
    struct G1
    {
        typedef X1<E2, Y2> type;
        typedef typename type::key_type key_type;
        typedef typename type::value_type value_type;
    };
};

template <template <class, class> class X, class Y>
struct A
{
    typedef typename G<X> H;
    typedef typename H::G1<A *, Y> F;
    typedef typename F::key_type key_type;
    typedef typename F::value_type value_type;
    A(void) { }
    virtual ~A(void) { }
    virtual key_type foo(value_type) = 0;
};

template <class Y>
struct B : public virtual A<G<Z>::G1, Y>
{
    B(void) { }
    virtual ~B(void) { }
    virtual key_type foo(value_type) { }
};

template <class Y, template <class> class P = B>
struct C : public virtual A<P<Y>::H::G1, Y>, private P<Y>
{
    typedef C<Y, P> my_type;
    C(void) { }
    virtual ~C(void) { }
    C(const my_type &) { }
    const my_type &operator=(const my_type &) { return *this; }
};

int main(/* int argc, char ** argv */void)
{
    C<int> c;
    return 0;
}

Does this make sense?

Jeffrey.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]