risoluzioni di portata più brevi per le classi nidificate privati ​​

Question

ho questo (semplificato) Situazione:

class Tree { 
    class Iterator { 
     class Stack { 
      // ... 
     } 
    public: 
     // ... 
    } 
public: 
    //... 
} 

Non voglio ingombrare le definizioni delle classi e decido di scrivere solo dichiarazioni di metodo all'interno delle classi stesse. Più tardi (mooolto basso) quando voglio definire, ad esempio, copiare operatore di assegnamento in questo modo:

Tree::Iterator::Stack& Tree::Iterator::Stack::operator = (const Stack& p_stack) { 
// ... 
} 

ho a che fare con queste risoluzioni portata brutte. Mi chiedo se c'è un modo per accorciarli, perché using e typedef, come li conosco, non mi offrono nulla.

EDIT: Dal momento che questo non è CodeReview, e @Yulian chiesto chiarimenti, ecco la versione corta:

sto facendo un'implementazione iterativa Red-Black Tree. Menzionato class Iterator è per il movimento di post-ordine (quindi è specifico per il post-ordine) e class Stack è la sua classe di utilità. In questo programma breve, solo class Tree utilizza Iterator e solo Iterator utilizza Stack.

Dopo il promemoria di @ Yulian, ho ricordato che sarebbe stato più orientato agli oggetti se le classi menzionate fossero definite separatamente (forse anche come modelli), ma questo è un programma piccolo e autonomo e sto cercando di mantenere in quel modo

EDIT: autonomo significa anche che si tratta di un caso isolato di programma, file singolo, quindi nessun file .h o codice esterno riutilizzo di sorta. Perché? Perché ACADEMIA (e restrizioni arbitrarie associate).

Answer 1

È possibile eliminare completamente le risoluzioni degli ambiti con un using o typedef. Ma non con il modo tradizionale perché le tue classi annidate sono dichiarate private. Dovresti quindi utilizzare using nella sezione public di ogni classe annidata per "esporli". Purtroppo, questo rompe il "privatezza" di loro:

class Tree { 
    class Iterator { 
     class Stack { 
      Stack& operator = (const Stack& p_stack); 
     }; 
    public: 
     using Stack_Out = Stack; 

     // ... 
    }; 
public: 
    using Iterator_Out = Iterator::Stack_Out; 
    //... 

}; 

using Stack = Tree::Iterator_Out; 

Stack& Stack::operator = (const Stack& p_stack) { 
// ... 
} 

LIVE DEMO

Si potrebbe tuttavia, rimuovere i livelli di ambito (ad eccezione di quello esterno, vale a dire, Tree::) con fuori esponendo le classi nidificate privati nel seguente modo:

class Tree { 
    class Iterator { 
     friend class Tree; 
     ^^^^^^^^^^^^^^^^^^ 
     class Stack { 
      Stack operator = (const Stack& p_stack); 
     }; 
    public: 

     // ... 
    }; 

    using Stack = Iterator::Stack; 
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

public: 

}; 

Tree::Stack Tree::Stack::operator = (const Stack& p_stack) { 
^^^^^^^^^^^ ^^^^^^^^^^^ 
} 

LIVE DEMO

Answer 2

Prima di tutto è bene spiegare cosa vorresti ottenere e come pensi che questo metodo sia adatto al tuo compito. IMHO, un approccio migliore è quello di creare classi individuali che non siano nidificate e usarle all'interno della classe Tre. Questo approccio è chiamato "HA UN". È più semplice da mantenere e da capire dagli altri. Se fornisci maggiori dettagli, possiamo proporre un design di classe migliore.

Answer 3

Puoi lasciare che il preprocessore ti aiuti:

#define foobar Tree::Iterator::Stack  
foobar& foobar::operator = (const Stack& p_stack) { 
    // ... 
}