Re: Cyclic dependence created by CRTP with typedefs in derived class,
on Sat Oct 13 2007, AlfC <alfredo.correa-AT-gmail.com> wrote:
Hi,
Does anybody know how to elegantly solve this cyclic dependency in
the CRTP?
//begin code
template<class derived> class base;
class child;
You don't need that declaration; it isn't helping. In fact, it's
illegal as child is declared to be a plain class below.
template<class derived>
class base{
public:
base(typename derived::domain const& x){} //<-- compilation error
};
class child : public base<child>{
public:
typedef int domain;
};
main(){return 0;}
//end code
the error I get is the following
//error messages
test.cpp: In instantiation of 'base<child>':
test.cpp:10: instantiated from here
test.cpp:7: error: invalid use of undefined type 'class child'
test.cpp:2: error: forward declaration of 'class child'
//end of error messages
You have to decouple the domain type from the complete type of the
child if you want to be able to use that type in any base class
declaration. I can think of two basic approaches:
template<class derived, class domain>
class base{
public:
base(domain const& x){}
};
class child : public base<child, int>{
};
and
// trait/metafunction that gets the domain of T
template <class T>
struct domain;
template<class derived>
class base{
public:
base(typename domain<T>::type const& x){}
};
// specialize domain for child
class child;
template <>
struct domain<child>
{
typedef int type;
};
// now instantiate base<child>; the domain is fully defined.
class child : public base<child>{
};
of course I could just replace "typename child::domain" by "int" in
the offending line, but I am actually thinking in something more
general case where class child is a template and "domain" is the
template T of child, i.e.
template<class T>
class child : public base<child>{
public:
typedef T domain;
};
note also that "typename derived::domain" can be used *inside* member
functions without any problems, i.e. outside the member definition or
signature.
Isn't it "curious" that the "Curiously Recurring Template Pattern" is
supposed to solve cyclic dependencies between types and at the same
time this example creates a cyclic dependecy of a higher level?
Maybe, but it becomes really clear why it works that way once you
understand how/when templates are instantiated. Deriving child from
base<child> requires the compiler to see the full declaration of
base<child> (just as though base<child> were an ordinary class).
Thus, the compiler instantiates the *declarations* in base<child>'s
class body. Members of templates are needed --- and thus instantiated
--- only when actually used, so instantiation of the bodies of
base<child>'s member functions can be put off until the full
declaration of child is known.
--
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]