Re: Help with Template-Template and Mixin Polymorphism
On 8/9/07 1:12 PM, in article
1186685686.839429.99560@x40g2000prg.googlegroups.com, "TimeHorse"
<darklord@timehorse.com> wrote:
On Aug 9, 1:37 pm, TimeHorse <darkl...@timehorse.com> wrote:
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?
My rule of thumb about programming with C++ templates has always been, "if
the template code compiles - then the code is correct." :-). So the
challenge is getting template code to compile successfully. And the good
news here, is that your program does compile (more or less, as is), once a
few "typename" and 'template" keywords (and a few more typedefs) are
sprinkled in - as needed:
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 G1 self;
typedef X1<E2, Y2> type;
typedef typename X1<E2, Y2>::key_type key_type;
typedef typename X1<E2, Y2>::value_type
value_type;
};
};
template <template <class, class> class X, class Y>
struct A
{
typedef G<X> H;
typedef typename G<X>::template G1<A*,Y>::self F;
typedef typename G<X>::template G1<A*,Y>::key_type
key_type;
typedef typename F::value_type value_type;
A() {}
virtual ~A() {}
// redeclared foo() non-pure in order to compile
virtual key_type foo( value_type) {};// = 0;
};
template <class Y>
struct B : public virtual A< G<Z>::template G1, Y>
{
typedef typename A<G<Z>::G1, Y>::key_type key_type;
typedef typename A<G<Z>::G1, Y>::key_type value_type;
B() {}
virtual ~B() {}
virtual key_type foo( value_type) {}
};
template <class Y, template <class> class P = B>
struct C : public virtual A<P<Y>::H::template G1, Y>,
private P<Y>
{
C() {}
C( const C&) {}
virtual ~C() {}
const C& operator=(const C& ) { return *this; }
};
int main()
{
C<int> c;
}
Greg
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]