Evitare le dipendenze circolari dei file di intestazione

Question

Avete qualche buon consiglio su come evitare le dipendenze circolari dei file di intestazione, per favore?

Naturalmente, sin dall'inizio, cerco di progettare il progetto nel modo più trasparente possibile. Tuttavia, man mano che vengono aggiunte sempre più funzionalità e classi e il progetto diventa meno trasparente, le dipendenze circolari iniziano a verificarsi.

Esistono regole generali, verificate e funzionanti? Grazie.

Answer 1

Se si dispone di dipendenza circolare, allora stai facendo qualcosa di sbagliato.

Come per esempio:

foo.h 
----- 
class foo { 
public: 
    bar b; 
}; 

bar.h 
----- 
class bar { 
public: 
    foo f; 
}; 

è illegale probabilmente si desidera:

foo.h 
----- 
class bar; // forward declaration 
class foo { 
    ... 
    bar *b; 
    ... 
}; 

bar.h 
----- 
class foo; // forward declaration 
class bar { 
    ... 
    foo *f; 
    ... 
}; 

e questo è ok.

Regole generali:

1. assicurarsi che ogni intestazione può essere incluso da solo.
2. Se è possibile utilizzare le dichiarazioni di inoltro usarle!

Answer 2

a seconda delle capacità del preprocessore:

#pragma once 

o

#ifndef MY_HEADER_H 
#define MY_HEADER_H 
your header file 
#endif 

Se lo trovate molto noioso per la progettazione di file di intestazione forse makeheaders da Hwaci (progettisti di SQLite e DVCS fossili) potrebbe essere di interesse per te.

Answer 3

Un approccio generale consiste nel tratteggiare gli elementi comuni in un terzo file di intestazione che viene quindi referenziato dai due file di intestazione originali.

Vedi anche Circular Dependency Best Practice

Answer 4

Quello che stai puntando a è un layered approach. È possibile definire i livelli in cui i moduli possono dipendere da moduli di livello inferiore, ma l'inverso deve essere eseguito con observers. Ora puoi ancora definire quanto dovrebbero essere grani i tuoi strati e se accetti la dipendenza circolare all'interno dei livelli, ma in questo caso userei lo this.

Answer 5

• Utilizzare dichiarazioni di inoltro ove possibile.
• Sposta qualsiasi intestazione inclusa da un file di intestazione e nel file cpp corrispondente se sono necessari solo dal file cpp. Il modo più semplice per far rispettare ciò è rendere #include "myclass.h" il primo incluso in myclass.cpp.
• L'introduzione di interfacce nel punto di interazione tra classi separate può aiutare a ridurre le dipendenze.

Answer 6

In generale, i file di intestazione devono dichiarare in modo diretto anziché includere altre intestazioni laddove possibile.

Assicurarsi inoltre di attenersi a una classe per intestazione.

Quindi quasi certamente non andrà male.

Il peggior accoppiamento di solito deriva dal codice modello gonfiato. Poiché devi includere la definizione all'interno dell'intestazione, spesso è necessario includere intestazioni di tutti i tipi, quindi la classe che utilizza il modello include l'intestazione del modello, incluso un carico di altre cose.

Per questo motivo, in genere direi: fai attenzione ai modelli! Idealmente, un modello non dovrebbe includere nulla nel suo codice di implementazione.

Answer 7

Alcune buone pratiche che seguo per evitare dipendenze circolari sono,

1. Stick ai principi OOAD. Non includere un file di intestazione, a meno che la classe inclusa non sia in relazione di composizione con la classe corrente. Utilizzare invece la dichiarazione diretta.
2. Progettare classi astratte per fungere da interfacce per due classi. Crea l'interazione delle classi attraverso quell'interfaccia.

Answer 8

Benche Artyom fornito risposta migliore questo tutorial è anche grande e fornisce alcuni extenstions http://www.cplusplus.com/forum/articles/10627/