Multiple template parameters reference loop - c++

Question

I got two classes, a B class has a member A1, and the A1 class has a reference member B, this is easy to write like this:
class B;
class A1 {
public:
A1(const B& b) : b_(b) {}
private:
const B& b_; // a reference to B
};
class B {
public:
B(A1 a1) : a1_(a1) {}
private:
A1 a1_; // a Type A1 member
};
And then I need change class B to a template class, so the code should be like this:
template<typename T1>
class B;
class A1 {
public:
A1(const B<A1> &b) : b_(b) {};
private:
const B<A1> &b_; // a reference to B<A1>
};
template<typename T1>
class B {
public:
B(T1 t1) : t1_(t1){}
private:
T1 t1_; //a T1 type member
};
And suddenly we need a second member in B, so I changed the B to this:
template<typename T1, typename T2>
class B {
public:
B(T1 t1, T2 t2) : t1_(t1), t2_(t2){}
private:
T1 t1_;
T2 t2_;
};
This got a problem:
now if I'm a coder of A, the code below is illegal:
template<typename T1, typename T2>
class B;
class A1 {
public:
A1(const B<A1> &b) : b_(b) {}; //wrong, need a second template argument
private:
const B<A1> &b_; // wrong, either
};
That means the coder must fill the second template argument which he may not know (or at least, may not care about). So I change the code to this:
template <typename T1, typename T2>
class B;
template <typename TB>
class A1 {
public:
explicit A1(const TB& b) : b_(b) {}
private:
const TB& b_;
};
template <typename TB>
class A2 {
public:
explicit A2(const TB& b) : b_(b) {}
private:
const TB& b_;
};
template <typename T1, typename T2>
class B {
public:
B(T1 a1, T2 a2) : a1_(a1), a2_(a2) {}
private:
T1 a1_;
T2 a2_;
};
This looks nice except I don't know how to make a B instance(like this:B<A1<B<A1<...>,A2>, A2>, it's recursively.)
The ideal design I'm looking forward to is that programmers for A1 and A2 simply do not need to know each other, and the programmer for B is simply add A1 and A2 more or less like this B<A1, A2>(or add some other stuff), and even if he add a T3 parameter like B<A1, A2, A3>, the code ofA1andA2` will not need to be changed.
So
1: If I insist in this syntax, does this mean I have to give up using template for B, instead use pointers?
2: If I insist in using template, does this mean the class T1 and class T2 must know each other?
3: Is there a third way by using template while T1 and T2 is independent? That is, no matter how many parameters I add to class B, the A1 class does not need to change? Template template/CRTP/SFINAE, all of this seems not useful. As the B class is only a reference in class A, the B class is more like a interface rather than a certain class, this remind me of the C++ proposal "concept", can "concept" help in this case?
4: Is this a xy problem? That means I should not design my code pattern in this way?

Answer 1

Here's how one might do that.
// B doesn't know about A
template <class T1, class T2>
class B {};
// A doesn't know about B
template <template<class> class TB>
class A {
using MyB = TB<A<TB>>;
};
template <class K>
using Bint = B<K, int>;
int main() {
A<Bint> abint;
}
Edit: If B has more than one template parameters, this can also be done, though a bit more complicated. One needs to tie all the template parameters in one class using some helpers. Here's an example. (I have renamed the classes for clarity).
// The top class parameterised by 3 bottom classes
template <class A1, class A2, class A3>
struct Top {};
// Three bottom classes parameterised by the top
template <template<class> class T> struct Bottom1 {};
template <template<class> class T> struct Bottom2 {};
template <template<class> class T> struct Bottom3 {};
// Until this point, none of the classes know about any other.
// Now tie them together with these helper definitions.
template <typename K>
using BundledTop = Top<typename K::A1, typename K::A2, typename K::A3>;
struct Bundle
{
using A1 = Bottom1<BundledTop>;
using A2 = Bottom2<BundledTop>;
using A3 = Bottom3<BundledTop>;
};
using MyTop = BundledTop<Bundle>;

Answer 2

I would say that your answer 4 is this right one: this seems as being a flawed design. I cannot prove that but I would like to give you an example.
I have implemented something similar to your code when I have been implementing bounding volume hierarchies. You could think of B as a branch class and A as a leave class of the tree (that is not completely correct, but should give an idea). Every branch has to contain its leaves, therefore B stores instances of A. But it is also nice to go back from a leave to its branch, therefore A should store a reference to B. You could decide to make your bounding volume hierarchy store arbitrary content (triangle, quads, polygons), therefore the item type should be a template parameter. Also you might decide to make the maximum leave number of each branch a template parameter of B.
But why should the branch class be able to store leaves that are made for arbitrary branches (because the B type is a template parameter of A)? If B stores instances of A, then I cannot think of any reason for making the B type a template parameter of A.
So probably you are too general here and should look for another design.
I am looking forward to your comments.