C++: utilizzo di namespace e #include

Question

In C++ Qual è la differenza tra la direttiva #include e using namespace? Inoltre memorizzi i tuoi spazi dei nomi come file separati e qual è l'estensione di file per tali file?

Answer 1

Per rispondere alla domanda, tornerò un po 'indietro e prendo alcune nozioni di base di C e C++.

Durante la compilazione di C/C++, la compilazione dei file di origine in un eseguibile reale è in realtà due fasi, la compilazione e il collegamento. La fase di compilazione prende un file .cpp alla volta e lo compila. Il contenuto di altri file .cpp non è visibile al compilatore. Questo genera un "file oggetto" (non so perché si chiama così). Tutti i file oggetto sono quindi collegati dal linker per produrre l'eseguibile finale.

Questo introduce due concetti importanti in C++, dichiarazioni e definizioni. Una dichiarazione specifica che qualcosa (una variabile o una funzione) esiste da qualche parte. Quello che segue è la dichiarazione della funzione Foo()

void Foo(); 

Questo significa che abbiamo detto al compilatore che da qualche parte ci sarà una funzione Foo() che non prende argomenti e restituire alcun valore.

Una definizione specifica quale funzione esegue effettivamente. Qui la funzione è definita

void Foo() { cout << "Foo!!"; } 

Consente di definire un'altra funzione, Bar()

void Bar() { 
    Foo(); 
    cout << "bar"; 
} 

Questa funzione chiamate di funzione Foo(). Questa funzione non può essere compilata se la funzione foo non è già stata dichiarata o definita precedentemente nello stesso file. Quindi la dichiarazione non produce di per sé alcun codice compilato.Devono essere lì.

Se la funzione Foo() non è definita in questo file, ma un diverso file .cpp, allora è il lavoro del linker effettuare la connessione tra queste due funzioni. Se la funzione Foo(), non è definita ovunque, si otterrà un errore del linker, non un errore del compilatore.

Questo arriva al concetto di file di intestazione. I file di intestazione sono il luogo in cui vengono archiviate le dichiarazioni. Quando si usa # include per includere il contenuto del file di intestazione, allora ciò che accade in realtà è che il preprocessore (un passo che viene eseguito prima del compilatore vero e proprio) carica il file incluso e "incolla" il contenuto nel file sorgente originale. Quindi il compilatore vedrà il file come se l'intero file di intestazione fosse effettivamente incollato nel file C++.

Così, quando si programma in C++, è di norma inserire il vostro definizioni in file cpp, e potrete inserire il vostro dichiarazioni nei file .h

namespace d'altra parte è semplicemente un modo per raggruppare logicamente il codice .

Quindi no, gli spazi dei nomi non sono archiviati in file separati e non hanno un'estensione di file specifica. Se avessi un progetto con più spazi dei nomi, potrei creare una directory separata per ogni spazio dei nomi (e poi ancora, forse no, dipenderebbe dalla situazione).

Answer 2

In C++, #include viene utilizzato per aggiungere file al progetto, mentre namespace viene utilizzato per mantenere i vostri oggetti in moduli logici (spazio dei nomi non si applica a C)

Ad esempio, si potrebbe avere una classe vettore in un file "vector.h" così lo includi nel tuo progetto.

vettore è una parte di una grande biblioteca (la libreria standard) STD, in modo da poter accedere con

std::vector 

Tuttavia, poiché i programmatori sono pigri e non vogliono scrivere std :: tutto il posto (la libreria standard ha molte molte parti molto utili), è possibile scrivere

using namespace std 

nella parte superiore del file. Questo dirà al compilatore che ogni volta che vede un tipo (come il vettore), controlla anche nello spazio dei nomi std perché la definizione potrebbe essere lì. In questo modo, le seguenti affermazioni diventano equivalenti.

std::vector 
vector 

In vector.h, si dovrebbe vedere qualcosa di simile

namespace std 
{ 
    class vector { /* Implementation */ } 
} 

Così #include è aggiungere i file, mentre using namespace è quello di mantenere il vostro pulitore di codice e confezionato nelle biblioteche "significativi". È possibile omettere using namespace durante la programmazione, ma è assolutamente necessario il #include