Question

考虑以下设计：

template <class SecondType>
struct First
{
    SecondType* _ptr;
};

template <class FirstType>
struct Second
{
    FirstType* _ptr;
};

其中First类型具有指向Second类型的指针，反之亦然。问题是我无法宣布这一点，因为它们是相互依存的，我应该声明First<Second<First<Second...>>>。

如何解决这个问题？

Answer 1

也许可以解决看起来像CRTP但更疯狂的事情：

#include <iostream>

template <class SecondType>
struct FirstBase
{
    SecondType* _ptr;
};

template <class FirstType>
struct SecondBase
{
    FirstType* _ptr;
};

struct FirstDerived
: public FirstBase<SecondBase<FirstDerived>>
{
};

struct SecondDerived
: public SecondBase<FirstBase<SecondDerived>>
{
};

int main()
{
    FirstBase<SecondDerived> x;
    SecondBase<FirstDerived> y;
    return 0;
}

如果某人有更优雅的方式来做这件事，我会很高兴看到它。

Answer 2

不确定您要实现的目标，但以下编译正常。

template <class T> struct First  { T* _ptr; };
template <class T> struct Second { T* _ptr; };

int main(){
   First<Second<First<Second<void>>>> a; // or
   First<Second<First<Second<nullptr_t>>>> b;
   return 0;
}

注意我完全替换了FirstType，SecondType，这无关紧要。 T将被你传递的任何内容所取代，这将在编译之前模板专用时发生。

Answer 3

这是另一个可能更优雅的解决方案，根本不需要空白。我不知道继承是否可以接受，但我认为它运作良好。

#include<vector>
#include<algorithm>
#include<iostream>
using namespace std;
struct Base {
    //make all functions virtual
};
template <class SecondType>
struct First: public Base
{
    SecondType* _ptr;
    First(SecondType * st) {
        _ptr = st;
    }
    First() {
    }
};

template <class FirstType>
struct Second: public Base
{
    FirstType* _ptr;
    Second(FirstType * ft) {
        _ptr = ft;
    }
    Second() {
    }
};

int main() {
    First<Base> f;
    Second<Base>  s;
    f._ptr = &s;
    s._ptr = &f;
    cout << s._ptr << endl;
}

相互依赖的类模板设计？

3 个答案: