Usare `using` in C ++ o evitarlo?

Sconti semantici leggermente diversi a causa dell'ADL, come dovrei generalmente usare using e perché? Dipende dalla situazione (es. Intestazione che sarà #included vs. file sorgente che non lo farà)?

Inoltre, dovrei preferire ::std::ostd:: ?

1. Livello di spazio dei nomi using namespace:

   using namespace std;
   
   pair<string::const_iterator, string::const_iterator>
   f(const string &s) {
       return make_pair(s.begin(), s.end());
   }

2. Essere pienamente espliciti:

   std::pair<std::string::const_iterator, std::string::const_iterator>
   f(const std::string &s) {
       return std::make_pair(s.begin(), s.end());
   }

3. Dichiarazioni di utilizzo a livello di spazio dei nomi:

   using std::pair;
   using std::string;
   
   pair<string::const_iterator, string::const_iterator>
   f(const string &s) {
       return make_pair(s.begin(), s.end());
   }

4. Dichiarazioni di utilizzo locali delle funzioni:

   std::pair<std::string::const_iterator, std::string::const_iterator>
   f(const std::string &s) {
       using std::make_pair;
       return make_pair(s.begin(), s.end());
   }

5. Funzione locale using namespace:

   std::pair<std::string::const_iterator, std::string::const_iterator>
   f(const std::string &s) {
       using namespace std;
       return make_pair(s.begin(), s.end());
   }

6. Qualcos'altro?

_{Ciò presuppone pre-C ++ 14 e quindi nessuna deduzione del tipo di ritorno utilizzando auto.}

Evitare di utilizzare usingnelle intestazioni, perché ciò interrompe lo scopo degli spazi dei nomi.

Va bene usarlo nei file sorgente, ma lo eviterei comunque in alcuni casi (ad esempio using std).

Tuttavia, se hai spazi dei nomi nidificati, va bene:

namespace A {
namespace B {
namespace C {
class s;
} // C
} // B
namespace D{
using B::C::s;
} // D
} // A

Quando si inserisce un'istruzione using in un file di origine, PER FAVORE, basta inserire le cose necessarie. Per esempio:

using std::string;
using std::ostringstream;

Il problema qui è che se lo fai

using namespace std;

si inserisce OGNI SINGOLA COSA da std nello spazio dei nomi globale. Il che porta a messaggi di errore molto interessanti quando si utilizza accidentalmente un nome nel codice che corrisponde a uno di cui non si era completamente a conoscenza in std. Se inserisci semplicemente le cose che vuoi, non avrai quel problema (o, più precisamente, il prossimo programmatore che lavorerà sul tuo codice non avrà quel problema).

Come indica VJovic, non utilizzare usingin un file di intestazione. usingin un file di intestazione influisce sull'unità di compilazione corrente (il file .cpp) in modi che il file di origine potrebbe non aspettarsi.

using namespacedeve anche essere evitato in un file sorgente. Questo porta ogni simbolo nello stesso ambito del file sorgente. È più chiaro ai tuoi lettori cosa stai facendo se usi simboli specifici dallo spazio dei nomi.

Scrivere usingin Headers è il modo migliore per creare tutti i tipi di bug cattivi e impossibili da eseguire il debug . Do Non fare questo.

Scrivere using namespace XYZnel file sorgente è un po 'meglio, ma può comunque causare innumerevoli mal di testa. Il modo sicuro è specificare esplicitamente ciò che si sta utilizzando ad es using Foo::Bar.

Supponiamo che tu abbia Bar.cpp con il seguente:

//Bar.cpp
using namespace Foo;
namespace
{
    double increment(double v) { return (v + 1); }
}

void Bar::someFunction()
{
    //...
    int currentIndex = 0;
    int nextIndex = increment(currentIndex);
    //...
}

La funzione ha funzionato bene, fino a quando un giorno - apparentemente senza alcuna modifica del codice nelle classi pertinenti - il suo comportamento è cambiato: improvvisamente currentIndexsembra sempre essere spento da uno . Scorrendo le modifiche recenti non si rilevano modifiche anche in remoto relative al codice.

Alla fine scopri la causa:
includi (indirettamente) da Foo.hqualche parte. Nei file per lo spazio dei nomi Foo è stata aggiunta una nuova funzione:

//Foo.h
namespace Foo
{
    //...
    int& increment(int& v) { v += 1; return v; };
    //...
}

Che è una corrispondenza inequivocabilmente migliore increment(int)della tua funzione increment(double), quindi ora Foo::increment()viene chiamata la funzione Bar::someFunction(). Ops.

(E se dovessi scrivere usingin Headers che using namespace Foopotrebbe benissimo essere ovunque nel tuo albero include ...)

Quindi ... Non scrivere alcuno usingnelle intestazioni e diffidare di scrivere using namespacenei file sorgente.