Riferimento circolare in C++ senza puntatori

Question

C'è un modo per definire riferimenti circolari senza utilizzare i puntatori?

ho bisogno di avere somthing come questo:

struct A; 
struct B { 
    A a; 
}; 

struct A { 
    B b; 
}; 

Grazie!

Answer 1

È possibile utilizzare i riferimenti al posto

struct A; 
struct B { 
    A& a; 
}; 

struct A { 
    B b; 
}; 

Ma no non è possibile creare un riferimento circolare senza un certo livello di indirezione. Ciò che sta facendo il tuo campione non è nemmeno la creazione di un riferimento circolare, ma sta tentando di creare una definizione ricorsiva. Il risultato sarebbe una struttura di dimensioni infinite e quindi non legale.

Answer 2

No, non c'è. Tale struttura avrebbe dimensioni infinite.

È possibile utilizzare i puntatori intelligenti (shared_ptr e weak_ptr) per evitare la manipolazione diretta del puntatore, ma questo è tutto.

Answer 3

Come potrebbe funzionare? Se ricordo bene, il valore dell'indirizzo di un riferimento non può essere modificato una volta impostato, quindi non è possibile definire un riferimento circolare.

Potrebbe funzionare nel modo seguente (identica all'Esempio di Jared inclusa costruttori definito):

struct A; 

struct B { 
    A& m_a; 
    B(A& a) : m_a(a) {} 
}; 

struct A { 
    B m_b; 
    //construct B m_b member using a reference to self 
    A() : m_b(*this) {} 
    //construct B m_b member using a reference to other 
    A(A& other) : m_b(other) {} 
}; 

Answer 4

In C++, T o significa "un oggetto di tipo T, non un riferimento a qualche T (come, per esempio, con i tipi di riferimento in C# e Java). con il codice dalla tua domanda, tipo A avrebbe un oggetto sub di tipo B (chiamato b), e che B a sua volta, avrebbe un oggetto sub di tipo A (nome a). Ora, quello a avrebbe a sua volta un altro A all'interno (di nuovo chiamato a), che poi ha un altro B, che ...

No, questo non funzionerà.

Che probabilmente si desidera è che un Asiano state ottenute ad un B, che a loro volta siano state ottenute che A. Questo può essere fatto usando i puntatori:

struct A; 
struct B { 
    A* a; 
    B(A*); 
}; 

struct A { 
    B* b; 
    A(B* b_) : b(b_) { if(b) b.a = this; } 
}; 

B::B(A* a_) : : a(a_) { if(a) a.b = this; } 

Non penso che si possa fare usando i riferimenti.

Answer 5

soluzione ChrisW può essere generalizzato un po 'come questo:

template <class defaultState> struct Context; 

struct State1 { 
    Context<State1>& mContext; 
    State1(Context<State1> & ref) : mContext(ref) {} 
}; 

template <class TDefaultState> 
struct Context { 
    TDefaultState mState; 
    Context() : mState(*this) {} 
}; 

Questo ora permette di fare

Context<State1> demo; 

Inoltre, Stato può avere un po' di codice di supporto template così

template <class State> 
struct TState { 
    typedef Context<State> TContext; 
    typedef TState<State> TBase; 
    Context<State> & mContext; 
    TState(Context<State> &ref) : mContext(ref) {} 
}; 

struct State2 : TState<State2> { 
    State2(TContext & ref) : TBase(ref) {} 
}; 
struct State3 : TState<State3> { 
    State3(TContext & ref) : TBase(ref) {} 
}; 

Che ora ti permette di fare qualsiasi di

Context<State2> demo2; 
Context<State3> demo3;