Preferisci spazi dei nomi espliciti o "utilizzo" in C ++?

Question

Quando usi gli spazi dei nomi C ++, preferisci nominarli esplicitamente, in questo modo:

std::cout << "Hello, world!\n";

O preferisci utilizzando lo spazio dei nomi :

using namespace std;
cout << "Hello, world!\n";

E se preferite quest'ultimo, dichiarate i vostri usi nell'ambito dei file o delle funzioni?

Personalmente preferisco nominarli esplicitamente - è più digitante ma quando si usa una combinazione di spazi dei nomi (ad es. std e boost ) lo trovo più leggibile.

Answer 1

Uso sempre usando namespace per std & amp; Incremento. Tutto il resto tendo a usare uno spazio dei nomi esplicito a meno che non sia usato così tanto da ingombrare il codice.

Nelle intestazioni, non uso mai usando lo spazio dei nomi per evitare di inquinare lo spazio dei nomi globale della fonte #including.

Answer 2

La digitazione extra non è il problema qui. Il problema con nomi esplicitamente qualificati è il disordine visivo. Ammettiamolo, la sintassi C ++ è disordinata. Non c'è bisogno di peggiorare le cose allungando inutilmente i nomi e cospargendo generosamente il codice con :: s.

Sono con Jeff Atwood: Il miglior codice non è affatto codice . Questo è così vero.

Le importazioni di spazi dei nomi sono un ottimo modo per ridurre il disordine senza inconvenienti: purché l'ambito degli spazi dei nomi aperti sia ridotto a una singola unità di compilazione ¹ , i conflitti di nomi, se compaiono, possono essere risolti facilmente.

Perché i nomi espliciti dovrebbero (in generale) essere più leggibili è sempre stato un mistero per me. I lettori dovrebbero generalmente conoscere il codice abbastanza bene da poter dedurre la semantica. In caso contrario, il codice deve comunque essere risolto.

---

¹⁾ Corollario: nessun utilizza nelle intestazioni!

Answer 3

Uso sempre quelli espliciti. Scrivere std non mi fa male e vedo chiaramente da dove viene. È utile quando hai qualche progetto legacy di cui occuparti con le sue "stringhe", "vettori" ecc per mantenere. Più informazioni contiene il codice, meglio è.

Answer 4

La mia regola generale è sempre usare esplicitamente lo spazio dei nomi nelle intestazioni e di solito usare usando nel codice. La ragione per la prima è di rendere esplicitamente chiaro in ogni parte della definizione ciò che viene usato, e la ragione per la seconda è che rende facile usare sostituzioni da un altro spazio dei nomi se ciò diventa necessario. cioè se vogliamo iniziare a usare foo :: string invece di std :: string dobbiamo solo aggiornare l'intestazione e l'istruzione using anziché sostituire ogni istanza di std :: string con foo :: string nel codice.

Naturalmente, questo è meno utile per le classi che risiedono nello spazio std :: namespace, poiché anche se si sostituisce una classe è comunque probabile che ne si utilizzino altre in std e si potrebbero riscontrare problemi di ambiguità, ma era solo un esempio.

Answer 5

utilizzando e utilizzando lo spazio dei nomi sono molto molto utili per rendere il codice più leggibile - rimuovere il disordine.

Ma in ogni caso in cui è più difficile scoprire da dove viene un simbolo, rifiuto di importare l'intero spazio dei nomi.

Provo a limitare l'ambito degli spazi dei nomi importati:

void bar() {

   // do stuff without vector

   { using std::vector;
      // do stuff with vector
   }

   // do stuff without vector
}

Per " generalmente noto " librerie, come std , oserei usare usando namespace std . C'è motivo di credere che chiunque legga questo codice conosca questi simboli.

Come sidenote, la parola chiave using viene utilizzata anche per indicare che una classe derivata esporta anche i membri sovraccaricati della sua superclasse.

class A {
  void f( A  );
  void f( bool );
};

class B : public A {
  using A::f; // without this, we get a compilation error in foo()
  void f(bool);
};

void foo() {
  B b;
  b.f( A() ); // here's a compilation error when no `using` is used in B
}

Answer 6

Uso gli spazi dei nomi espliciti solo quando c'è qualche ambiguità. È più leggibile, ma la digitazione extra è troppo noiosa e devi presumere che altri sviluppatori abbiano un livello di familiarità di base con le librerie standard.

Le uniche altre volte in cui scrivo uno spazio dei nomi sono quando lo sto usando solo una o due volte, come l'aggiunta di una veloce istruzione di debug o se sto usando una libreria non standard.

In genere dichiaro lo spazio dei nomi nell'ambito del file, ma se stai mescolando gli spazi dei nomi potrebbe avere senso avvicinare la dichiarazione al punto in cui viene utilizzata, nell'ambito della funzione.

Answer 7

usando nell'ambito della funzione, o se la funzione è molto piccola (spesso lo è), basta uno spazio dei nomi esplicito

Answer 8

Tendo a importare esplicitamente i nomi di cui ho bisogno nella parte superiore del file .cpp, quindi ...

usando std :: cout; usando std :: endl;

ecc ...

In questo modo ho il controllo sui nomi che utilizzo ed è facile vedere da dove provengono e il codice non è disordinato al punto di utilizzo.

Nei rari casi in cui sto usando due nomi di diversi spazi dei nomi, li qualifico pienamente al punto di utilizzo.

Uso sempre nomi completi nelle intestazioni e quasi mai uso 'using namespace x' ovunque ...