C++
Deklaration verwenden
Suche…
Einführung
Mit einer using
Deklaration wird ein einzelner Name in den aktuellen Bereich eingefügt, der zuvor an anderer Stelle deklariert wurde.
Syntax
- using typename ( opt ) nested-name- spezifier unqualifizierte-id ;
- using :: unqualified-id ;
Bemerkungen
Eine using-Deklaration unterscheidet sich von einer using-Direktive , die den Compiler anweist, bei der Suche nach einem Namen in einem bestimmten Namespace zu suchen. Eine using-Direktive beginnt mit der using namespace
.
Eine using-Deklaration unterscheidet sich auch von einer Alias-Deklaration, die einem vorhandenen Typ auf dieselbe Weise wie typedef
einen neuen Namen gibt. Eine Alias-Deklaration enthält ein Gleichheitszeichen.
Namen einzeln aus einem Namespace importieren
Einmal using
wird verwendet , um den Namen einzuführen cout
aus dem Namensraum std
in den Rahmen der main
die std::cout
- Objekt kann als bezeichnet wird cout
allein.
#include <iostream>
int main() {
using std::cout;
cout << "Hello, world!\n";
}
Neu deklarieren von Mitgliedern aus einer Basisklasse, um das Ausblenden von Namen zu vermeiden
Wenn eine using-Deklaration im Klassenbereich vorkommt, darf nur ein Member einer Basisklasse neu deklariert werden. Beispielsweise ist die using std::cout
im Klassenbereich nicht zulässig.
Oft wird der Name erneut deklariert, der sonst verborgen wäre. Im folgenden Code bezieht sich Derived1::foo(const char*)
d1.foo
nur auf Derived1::foo(const char*)
und ein Kompilierungsfehler wird auftreten. Die Funktion Base::foo(int)
ist ausgeblendet und wird überhaupt nicht berücksichtigt. d2.foo(42)
ist jedoch in Ordnung, da die using-Deklaration Base::foo(int)
in die Gruppe der Entities mit Name foo
in Derived2
. Die Namenssuche findet dann sowohl foo
s als auch die Überlastauflösung und wählt Base::foo
.
struct Base {
void foo(int);
};
struct Derived1 : Base {
void foo(const char*);
};
struct Derived2 : Base {
using Base::foo;
void foo(const char*);
};
int main() {
Derived1 d1;
d1.foo(42); // error
Derived2 d2;
d2.foo(42); // OK
}
Erbauer erben
Als Sonderfall kann eine using-Deklaration im Klassenbereich auf die Konstruktoren einer direkten Basisklasse verweisen. Diese Konstruktoren werden dann von der abgeleiteten Klasse geerbt und können zum Initialisieren der abgeleiteten Klasse verwendet werden.
struct Base {
Base(int x, const char* s);
};
struct Derived1 : Base {
Derived1(int x, const char* s) : Base(x, s) {}
};
struct Derived2 : Base {
using Base::Base;
};
int main() {
Derived1 d1(42, "Hello, world");
Derived2 d2(42, "Hello, world");
}
Im obigen Code verfügen sowohl Derived1
als auch Derived2
über Konstruktoren, die die Argumente direkt an den entsprechenden Konstruktor von Base
weiterleiten. Derived1
führt die Weiterleitung explizit aus, während Derived2
mit der C ++ 11-Funktion zum Erben von Konstruktoren implizit erfolgt.