相互依存的類模板設計？

考慮以下設計：相互依存的類模板設計？

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

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

其中First類型有一個指針指向一個Second類型，反之亦然。問題是我不能申報，因爲它們是相互依存的，我應該聲明First<Second<First<Second...>>>。

如何解決這個問題？

來源

2013-06-03 Vincent

這個模擬到底是什麼？ – chris

爲什麼上面的課堂設計？你想要解決什麼現實生活中的問題？ – Andrzej

也許一個變通的東西，看起來像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; 
}

如果有人有更優雅的方式來做到這一點，我會很樂意看到它。

來源

2013-06-03 04:59:29 Vincent

我會假設你不希望我們更改模板太多，因爲要做到這一點，沒有模板會很容易 – aaronman

不知道你想達到什麼，但以下編譯罰款。

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一起cos無所謂。 T會被你傳遞的任何東西所取代，當模板在編譯之前被專門化時會發生這種情況。

來源

2013-06-03 05:00:07 salek

這是另一種可能更優雅的解決方案，它根本不需要void。我不知道你的繼承是否可以接受，但我認爲它運作良好。

#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; 
}

來源

2013-06-03 15:05:41 aaronman

相互依存的類模板設計？

回答

相關問題