Was ist die Logik hinter dem Schlüsselwort "using" in C++?

In C++11, die using Schlüsselwort, wenn Sie für die type alias ist identisch mit typedef.

7.1.3.2

Einen typedef-Namen können auch eingeführt werden, indem Sie einen alias-Deklaration. Die
id nach dem using-Schlüsselwort wird ein typedef-name und die
optionales Attribut-specifier-seq folgenden die Bezeichner gehört
zu dieser typedef-name. Es hat dieselbe Semantik, wie wenn es
eingeführt durch die typedef-Bezeichner. Insbesondere, es nicht definieren
ein neuer Typ und es wird nicht angezeigt, in der Typ-id.

Bjarne Stroustrup bietet ein Beispiel aus der Praxis:

typedef void (*PFD)(double);    //C style
using PF = void (*)(double);    //using plus C-style type
using P = [](double)->void; //using plus suffix return type, syntax error
using P = auto(double)->void //Fixed thanks to DyP

Pre-C++11, die using keyword bringen können member-Funktionen in scope. In C++11, können Sie jetzt tun Sie dies für Konstruktoren (andere Bjarne Stroustrup B.):

class Derived : public Base { 
public: 
    using Base::f;    //lift Base's f into Derived's scope -- works in C++98
    void f(char);     //provide a new f 
    void f(int);      //prefer this f to Base::f(int) 

    using Base::Base; //lift Base constructors Derived's scope -- C++11 only
    Derived(char);    //provide a new constructor 
    Derived(int);     //prefer this constructor to Base::Base(int) 
    //...
}; 

Ben Voight bietet einen ziemlich guten Grund, hinter die Logik der nicht die Einführung einer neuen keyword oder eine neue syntax. Der standard will, um zu vermeiden, brechen alte code so viel wie möglich. Dies ist der Grund, warum im Vorschlag der Dokumente sehen Sie Abschnitte wie Impact on the Standard, Design decisions, und wie Sie sich auswirken könnten, älteren code. Es gibt Situationen, wenn ein Vorschlag scheint wie eine wirklich gute Idee, aber möglicherweise nicht die Traktion, denn es wäre zu schwierig zu implementieren, zu verwirrend oder widersprechen würde alte code.

Hier ist ein altes Papier aus dem Jahr 2003 n1449. Die Begründung scheint zu sein, in Bezug auf Vorlagen. Warnung: es kann sein, Schreibfehler durch kopieren aus der PDF.

Betrachten wir zuerst eine Spielzeug-Beispiel:

template <typename T>
class MyAlloc {/*...*/};

template <typename T, class A>
class MyVector {/*...*/};

template <typename T>

struct Vec {
typedef MyVector<T, MyAlloc<T> > type;
};
Vec<int>::type p; //sample usage

Das grundlegende problem mit diesem idiom, und die wichtigste motivierende Tatsache
für diesen Vorschlag ist, dass das idiom, bewirkt, dass die template-Parameter
erscheinen in nicht-ableitbar Kontext. Das heißt, es wird nicht möglich sein
Aufruf der Funktion foo unten, ohne explizite Angabe von template
Argumente.

template <typename T> void foo (Vec<T>::type&);

Also, die syntax ist etwas hässlich. Wir würden lieber vermeiden verschachtelte ::type
Wir würden lieber etwas wie die folgenden:

template <typename T>
using Vec = MyVector<T, MyAlloc<T> >; //defined in section 2 below
Vec<int> p; //sample usage

Beachten Sie, dass wir gezielt vermeiden, den Begriff "typedef " Vorlage" und intr
oduce die neue syntax mit den paar "mit" und "=", um zu vermeiden,
Verwirrung: wir sind nicht die Definition von jedem Typen hier, sind wir die Einführung einer
synonym (z.B. alias) für eine Abstraktion, die von einer Typ-id (z.B. Typ
Ausdruck) Einbeziehung der template-Parameter. Wenn die template-Parameter
verwendet in Kontexten ableitbar in den Typ-Ausdruck, dann, wenn
die template-alias verwendet wird, um die form eines template-id, die Werte der
entsprechenden template-Parameter können abgeleitet werden – mehr dazu wird
Folgen. In jedem Fall ist es jetzt möglich, generische Funktionen zu schreiben
die arbeiten auf Vec<T> im Kontext ableitbar, und die syntax ist
ebenfalls verbessert. Zum Beispiel könnten wir umschreiben foo:

template <typename T> void foo (Vec<T>&);

Wir unterstreichen hier, dass einer der primären Gründe für den Vorschlag
Vorlage Aliase war, so dass argument der Abzug und der Aufruf foo(p)
erfolgreich sein wird.

Den follow-up-Papier n1489 erklärt, warum using anstatt typedef:

Es wurde vorgeschlagen, zu (re)mit dem Schlüsselwort typedef — wie in der
Papier [4] — Einführung-Vorlage-Aliase:

template<class T> 
    typedef std::vector<T, MyAllocator<T> > Vec;

Notation hat den Vorteil, mit einem Stichwort schon bekannt
die Einführung eines Typ-alias. Aber es zeigt auch mehrere
Nachteile, unter denen die Verwirrung der mit einem Schlüsselwort bekannt
die Einführung eines alias für einen Typ-Namen in einem Kontext, in dem der alias hat
nicht bezeichnen, eine Art, aber eine Vorlage; Vec ist nicht ein alias für eine
Art, und sollte nicht getroffen werden, für einen typedef-Namen ein. Der name Vec ist ein
name für die Familie std::vector< [bullet] , MyAllocator< [bullet] > >
– wo die Kugel ist ein Platzhalter für einen Typ-Namen. Somit sind wir in der
nicht schlagen die "typedef" - syntax. Auf der anderen Seite den Satz

template<class T>
    using Vec = std::vector<T, MyAllocator<T> >;

können gelesen/interpretiert werden als: von nun an werde ich mit Vec<T> als
synonym für std::vector<T, MyAllocator<T> >. Mit das Lesen, die
neue syntax für aliasing scheint einigermaßen logisch.

Ich denke, der entscheidende Unterschied ist hier aliases statt Typs. Ein weiteres Zitat aus demselben Dokument:

Einen alias-Erklärung ist eine Erklärung und keine definition. Ein alias-
Deklaration führt einen Namen in eine deklarative region als alias
für die Art gekennzeichnet durch die Rechte-hand-Seite der Erklärung. Die
Kern dieses Vorschlags beschäftigt sich mit Typ-Namen, aliases, aber die
Schreibweise kann natürlich verallgemeinert werden, um Alternative Schreibweisen
der namespace-aliasing oder die Benennung Satz mit überladenen Funktionen (siehe ✁
2.3 für die weitere Diskussion). [Mein Hinweis: diesen Abschnitt wird erläutert, was die syntax Aussehen kann, und Gründe, warum es nicht Teil des Vorschlags.] Es kann erwähnt werden, dass die Grammatik die Produktion alias-Erklärung akzeptabel ist überall ein typedef
Erklärung oder ein namespace-alias-definition ist akzeptabel.

Zusammenfassung, für die Rolle des using:

• template aliases (oder die Vorlage, typedefs, die erstere ist bevorzugt namewise)
• namespace-Aliase (d.h., namespace PO = boost::program_options und using PO = ... äquivalent)
• das Dokument sagt A typedef declaration can be viewed as a special case of non-template alias-declaration. Es ist eine ästhetische Veränderung und wird als identisch, in diesem Fall.
• bringen etwas in den Bereich (zum Beispiel namespace std in das Globale scope), member-Funktionen, Konstruktoren Erben

Es nicht verwendet werden für:

int i;
using r = i; //compile-error

Stattdessen tun:

using r = decltype(i);

Benennen eine Reihe von überladungen.

//bring cos into scope
using std::cos;

//invalid syntax
using std::cos(double);

//not allowed, instead use Bjarne Stroustrup function pointer alias example
using test = std::cos(double);

InformationsquelleAutor