Share
Entriamo subito dando un'occhiata ad un esempio.
Esempio: GlobalNamespaceSample \ GlobalNamespaceSample.cpp
#includere#includere #include "... /pchar.h" int g_x = 10; int AddTwoNumbers (int a, int b) return a + b; int _pmain (int / * argc * /, _pchar * / * argv * / []) int y = 20; std :: wcout << L"The result of AddTwoNumbers(g_x, y) where g_x = " << g_x << L" and y = " << y << L" is " << AddTwoNumbers(g_x, y) << L"." << std::endl; if (true == 1) std::wcout << L"true == 1!" << std::endl; return 0;
Nell'esempio precedente, definiamo due funzioni, AddTwoNumbers e wmain. Queste due funzioni sono entrambe nello spazio dei nomi globale. Lo spazio dei nomi globale è il livello base in cui esiste tutto il resto del programma. C ++, grazie alla sua eredità C, consente di definire qualsiasi cosa all'interno dello spazio dei nomi globale (in modo da poter definire spazi dei nomi, classi, strutture, variabili, funzioni, enumerazioni e modelli).
C # ha anche il concetto di uno spazio dei nomi globale, ma non ti permette di definire nulla al suo interno oltre che i namespace e i tipi. Nell'esempio precedente, abbiamo la dichiarazione int g_x = 10; che definisce un numero intero g_x all'interno del namespace globale e assegna ad esso un valore di 10. Questo è ciò che viene comunemente definito come una variabile globale. In C # le variabili globali sono illegali.
In breve, ogni linguaggio di programmazione con cui ho mai lavorato ha avuto la sua parte di cattive funzionalità, cose che il linguaggio consente, ma cose che di solito portano a problemi. Questi problemi includono problemi difficili da correggere, errori sottili che passano inosservati per lungo tempo, problemi di manutenibilità, problemi di leggibilità e tutte le altre cose frustranti che aggiungono molte ore ai tempi di sviluppo senza alcun beneficio. C ++ non è diverso. Quando incontreremo qualcosa che si adatta a questa descrizione, farò del mio meglio per chiamarlo. Questo è uno di quei momenti.
Le variabili globali sono cattive. Evitali quando possibile. C'è una convenzione comune quando li si usa in C ++, che è per il prefisso del nome della variabile con g_, come nell'esempio precedente. Mentre questo aiuta ad avvisare te e altri programmatori sul fatto che questa è una variabile globale, non cambia il fatto che è una variabile globale, avendo tutti i problemi che ho descritto. Questo non è un libro su cattive pratiche di programmazione, quindi non ho intenzione di spendere tempo a spiegare perché le variabili globali sono cattive. Tutto ciò che devi sapere è che questa funzione esiste in C ++, ma dovresti evitare di usarla ogni volta che è possibile.
Accentsconagua
:: In C++, :: è l'operatore di risoluzione dell'ambito. Viene utilizzato per separare gli spazi dei nomi nidificati, separare i tipi dal loro spazio dei nomi e separare le funzioni e le variabili dei membri dal loro tipo.
Si noti che viene utilizzato solo nell'ultima situazione quando si esegue quanto segue:
In altri casi, si utilizza il. operatore o l'operatore ->, a seconda che si stia accedendo al membro direttamente o tramite un puntatore.
Questo può sembrare complicato poiché C # usa solo il. operatore per tutti gli scopi che ::,., e -> sono usati per in C++.
Nota: Discuteremo del. e -> operatori più tardi. Per ora, devi solo sapere che sono usati per accedere alle variabili membro di istanza e alle funzioni dei membri non statici (che usi a seconda che tu stia lavorando o meno con un puntatore).
Per la maggior parte, starai bene. L'unico posto in cui è probabile che si verifichi un errore è se si tenta di accedere a un membro della classe base utilizzando il comando. operatore piuttosto che l'operatore :: o se si tenta di specificare un membro enum utilizzando qualcosa di diverso da ::. Se compili il tuo programma e ricevi un errore di sintassi che si lamenta di "missing"; prima '.' ", è una buona scommessa che hai usato a. dove dovresti aver usato un :: invece.
Uno spazio dei nomi è definito più o meno come in C #. Ecco un esempio:
Esempio: NamespacesSample \ NamespacesSample.cpp
#includere#includere #includere #include "... /pchar.h" usando namespace std; namespace Places namespace Cities struct City City (const wchar_t * nome) Name = wstring (name); Nome stringa; ; int _pmain (int / * argc * /, _pchar * / * argv * / []) auto nyc = Places :: Cities :: City (L "New York City"); wcout << L"City name is " << nyc.Name.c_str() << L"." << endl; return 0;
Nota: Non includere mai una direttiva using in un file di intestazione. In tal caso, non si importano solo i tipi e gli spazi dei nomi in tale spazio dei nomi nel file di intestazione, ma si importano anche in qualsiasi file di origine o di intestazione che include il file di intestazione. Questo causa problemi di inquinamento dello spazio dei nomi davvero brutti. Di seguito discuteremo dei file di intestazione, quindi tutto ciò che non è chiaro su questo dovrebbe avere senso. Ricorda solo che avere una direttiva namespace in un file di intestazione è una cattiva idea; usarli solo nei file del codice sorgente.
Come nella maggior parte delle lingue, gli spazi dei nomi sono importanti in C ++ per mantenere tutto organizzato e per evitare conflitti di nomi. Nella prossima puntata di questa serie, ci concentreremo su funzioni e classi.
Questa lezione rappresenta un capitolo di C ++, un eBook gratuito del team di Syncfusion.
