Breaking template circular dependencies by using template template parameters

Question

If my understanding is correct, the following is a classical circular dependency between template classes:

template <class MyB>
struct A {
    MyB *b_;
};

template <class MyA>
struct B {
    MyA *a_;
};

If we want to instantiate A with B and B with A, then we can't begin with either one, since we would have to write: A<B<A<B<...>>> (infinite).

I think that template template parameters provide a solution. The following code compiles (with gcc version 4.8.2):

template <class MyB>
struct A {
    MyB *b_;
};

template <template <class> class MyA>
struct B {
    MyA<B> *a_;
};

int main() {
    using MyB = B<A>;
    using MyA = A<MyB>;
    MyA a;
    MyB b;
    a.b_ = &b; b.a_ = &a;
    return 0;
}

Am I missing the essence of the problem?

UPDATE: I just ran into this post which proposes essentially the same solution.

score 2 · Answer 1 · answered Dec 07 '15 at 08:23

I would try to design my code in order to avoid those circular dependencies. Anyway if prompted with a compelling reason not to, there are several ways of solve this issue:

As you noted, using a template template parameter solves the problem by breaking the cycle

template <class MyB>
struct A {
    MyB *b_;
};

template <template <class> class MyA>
struct B {
    MyA<B> *a_;
};

int main() {
    using MyB = B<A>;
    using MyA = A<MyB>;
    MyA a;
    MyB b;
    a.b_ = &b; b.a_ = &a;
    return 0;
}

Another solution could be to encapsulate the types you need into an external struct/class

template<class Common> struct A
{
  typedef typename Common::BT B;
  B* b;
};

template<class Common> struct B
{
  typedef typename Common::AT A;
  A* a;
};

struct Common {
  using AT = A<Common>;
  using BT = B<Common>;
};


int main() {
  A<Common> a;
  B<Common> b;
  return 0;
}

Depending on what the rest of your code does, in a simple case like this you might get away with variadic templates

template <class MyA>
struct B;

template <typename ...MyB>
struct A {
  B<A<>> *b_;
};

template <>
struct A<> {};

template <class MyA>
struct B {
  A<B<MyA>> *a_;
};

int main() {

  using BoA = B<A<>>;
  using AoBoA = A<B<A<>>>;

  BoA obj1;
  AoBoA obj2;

  obj1.a_ = &obj2;
  obj2.b_ = &obj1;

  return 0;
}

Finally it's worth to be noted that exposing a common base class and using a CRTP-like approach could probably be the cleaner way to achieve this (you might even gain points for clarity and readability).

Breaking template circular dependencies by using template template parameters

1 Answers1