Verwenden Sie `using` in C ++ oder vermeiden Sie es?

Wie soll ich generell vorgehen usingund warum? Ist es situationsabhängig (zB Header, der #included sein wird, vs. Quelldatei, der nicht sein wird)?

Auch sollte ich lieber ::std::oder std::?

1. Namespace-Ebene using namespace:

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

2. Vollständig explizit sein:

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

3. Namespace-Ebene mit Deklarationen:

   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. Funktionslokale using-Deklarationen:

   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. Funktionslokal 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. Etwas anderes?

_{Dies setzt Pre-C ++ 14 voraus und somit keine Return-Type-Deduktion mit auto.}

Vermeiden Sie die Verwendung usingin Headern, da dies den Zweck von Namespaces verletzt.

Es ist in Ordnung, es in Quelldateien zu verwenden, aber ich würde es in einigen Fällen (zum Beispiel using std) immer noch vermeiden .

Wenn Sie jedoch verschachtelte Namespaces haben, ist dies in Ordnung:

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

Wenn Sie eine using-Anweisung in eine Quelldatei einfügen, müssen Sie nur die erforderlichen Informationen eingeben. Zum Beispiel:

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

Das Problem hierbei ist, dass, wenn Sie dies tun

using namespace std;

Sie ziehen JEDES EINZELNE von STD in den globalen Namespace. Dies führt zu sehr interessanten Fehlermeldungen, wenn Sie versehentlich einen Namen in Ihrem Code verwenden, der mit einem übereinstimmt, den Sie in std. Wenn Sie nur das gewünschte Material einlesen, haben Sie dieses Problem nicht (oder genauer gesagt, der nächste Programmierer, der an Ihrem Code arbeitet, wird dieses Problem nicht haben).

Verwenden Sie VJovic zufolge nicht usingin einer Header-Datei. usingin einer Headerdatei wirkt sich auf die aktuelle Kompilierungseinheit (die CPP-Datei) in einer Weise aus, die die Quelldatei möglicherweise nicht erwartet.

using namespaceist auch in einer Quelldatei zu vermeiden. Dies bringt jedes Symbol in den gleichen Bereich wie die Quelldatei. Den Lesern wird klarer, was Sie tun, wenn Sie bestimmte Symbole aus dem Namespace verwenden.

Schreiben usingin Headern ist der beste Weg, um alle Arten von bösen und unmöglich zu debuggenden Fehlern zu erstellen . Mach das nicht .

Das Schreiben using namespace XYZin der Quelldatei ist etwas besser, kann aber dennoch unzählige Kopfschmerzen verursachen. Auf sichere Weise können Sie explizit angeben, was Sie verwenden, z using Foo::Bar.

Angenommen, Sie haben Bar.cpp mit folgendem Inhalt:

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

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

Die Funktion funktionierte einwandfrei, bis sich eines Tages - scheinbar ohne Codeänderungen in relevanten Klassen - ihr Verhalten änderte: Plötzlich currentIndexscheint es immer um eins zu gehen . Wenn Sie die letzten Änderungen durchgehen, werden Sie feststellen, dass sich auch aus der Ferne keine Änderungen am Code ergeben.

Schließlich entdecken Sie die Ursache:
Sie schließen (indirekt) Foo.hirgendwo ein. In den Dateien für den Foo-Namespace wurde eine neue Funktion hinzugefügt:

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

Welches ist eine eindeutig bessere Übereinstimmung increment(int)als Ihre Funktion increment(double)- so wird Foo::increment()Funktion jetzt Bar::someFunction()stattdessen von aufgerufen . Hoppla.

(Und wenn Sie usingin Überschriften schreiben würden , using namespace Foodie sich sehr gut irgendwo in Ihrem Include-Baum befinden könnten ...)

So ... Do nicht schreibt jede usingin Header und auch das Schreiben vorsichtig sein , using namespacein Quelldateien.