using-Deklaration
Die using Deklaration erstellt einen Namen in den deklarativen Bereich vor, in dem die using Deklaration wird.
using [typename][::] nested-name-specifier unqualified-id
using :: unqualified-id
Hinweise
Der Name ist ein Synonym für eine Entität, die an anderer Stelle deklariert ist.Sie können einen einzelnen Namen von einem angegebenen Explizite Qualifizierungohne Namespace verwendet werden soll.Dies steht im Gegensatz zu den using-Direktive, die alle Namen in einem ohne Qualifikation Namespace verwendet werden können.Weitere Informationen finden Sie unter Using-Direktiven .
Beispiel
A mit der Deklaration kann in einer Klassendefinition verwendet werden.
// using_declaration1.cpp
#include <stdio.h>
class B {
public:
void f(char) {
printf_s("In B::f()\n");
}
void g(char) {
printf_s("In B::g()\n");
}
};
class D : B {
public:
using B::f;
using B::g;
void f(int) {
printf_s("In D::f()\n");
f('c');
}
void g(int) {
printf_s("In D::g()\n");
g('c');
}
};
int main() {
D myD;
myD.f(1);
myD.g('a');
}
Wenn es für einen Member verwendet wird, A mit der Deklaration muss deklariert einen Member einer Basisklasse zugreifen.
// using_declaration2.cpp
#include <stdio.h>
class B {
public:
void f(char) {
printf_s("In B::f()\n");
}
void g(char) {
printf_s("In B::g()\n");
}
};
class C {
public:
int g();
};
class D2 : public B {
public:
using B::f; // ok: B is a base of D2
// using C::g; // error: C isn't a base of D2
};
int main() {
D2 MyD2;
MyD2.f('a');
}
Die Member, die eine mit der Deklaration deklariert werden, können mithilfe der expliziten Qualifikation verwiesen wird.Das :: Präfix verweist auf den globalen Namespace an.
// using_declaration3.cpp
#include <stdio.h>
void f() {
printf_s("In f\n");
}
namespace A {
void g() {
printf_s("In A::g\n");
}
}
namespace X {
using ::f; // global f
using A::g; // A's g
}
void h() {
printf_s("In h\n");
X::f(); // calls ::f
X::g(); // calls A::g
}
int main() {
h();
}
Wenn eine mit der Deklaration erfolgt, das das Synonym verweist, von der Deklaration erstellt wird, nur Definitionen, die zum Zeitpunkt der Deklaration der Anwendung gültig sind.Die Definitionen, die auf einen Namespace nach der Deklaration der Anwendung hinzugefügt werden, sind ungültige Synonyme.
Ein Name, der durch das mithilfe der Deklaration definiert ist, ist ein Alias für den ursprünglichen Namen.Es hat keine Auswirkungen auf den Typ, Bindung oder andere Attribute der ursprünglichen Deklaration.
// post_declaration_namespace_additions.cpp
// compile with: /c
namespace A {
void f(int) {}
}
using A::f; // f is a synonym for A::f(int) only
namespace A {
void f(char) {}
}
void f() {
f('a'); // refers to A::f(int), even though A::f(char) exists
}
void b() {
using A::f; // refers to A::f(int) AND A::f(char)
f('a'); // calls A::f(char);
}
In Bezug auf Funktionen in den Namespaces, wenn ein Satz lokale Deklarationen und mit Deklarationen für einen einzelnen Namen in einem deklarativen Gültigkeitsbereich angegeben sind, müssen alle die gleiche Entität verweisen, oder sie müssen alle Funktionen verweisen.
// functions_in_namespaces1.cpp
// C2874 expected
namespace B {
int i;
void f(int);
void f(double);
}
void g() {
int i;
using B::i; // error: i declared twice
void f(char);
using B::f; // ok: each f is a function
}
Im Beispiel oben wird die using B::i-Anweisung eine Sekunde int i , in der g()-Funktion deklariert werden.Die using B::f-Anweisung verursacht nicht mit der f(char)-Funktion, da die Funktionsnamen, die von B::f eingegeben werden, andere Parametertypen verfügen.
Eine lokale Funktionsdeklaration kann denselben Namen und denselben Typ wie eine Funktion haben, die mithilfe von Deklaration eingegeben wird.Beispiele:
// functions_in_namespaces2.cpp
// C2668 expected
namespace B {
void f(int);
void f(double);
}
namespace C {
void f(int);
void f(double);
void f(char);
}
void h() {
using B::f; // introduces B::f(int) and B::f(double)
using C::f; // C::f(int), C::f(double), and C::f(char)
f('h'); // calls C::f(char)
f(1); // C2668 ambiguous: B::f(int) or C::f(int)?
void f(int); // C2883 conflicts with B::f(int) and C::f(int)
}
In Bezug auf einen wenn Vererbung mit der Deklaration einen Namen aus einer Basisklasse in einen Bereich der abgeleiteten Klasse überschreiben die virtuelle Memberfunktionen Memberfunktionen in der abgeleiteten Klasse mit demselben Namen in der Basisklasse Argumenttypen und vorstellt.
// using_declaration_inheritance1.cpp
#include <stdio.h>
struct B {
virtual void f(int) {
printf_s("In B::f(int)\n");
}
virtual void f(char) {
printf_s("In B::f(char)\n");
}
void g(int) {
printf_s("In B::g\n");
}
void h(int);
};
struct D : B {
using B::f;
void f(int) { // ok: D::f(int) overrides B::f(int)
printf_s("In D::f(int)\n");
}
using B::g;
void g(char) { // ok: there is no B::g(char)
printf_s("In D::g(char)\n");
}
using B::h;
void h(int) {} // Note: D::h(int) hides non-virtual B::h(int)
};
void f(D* pd) {
pd->f(1); // calls D::f(int)
pd->f('a'); // calls B::f(char)
pd->g(1); // calls B::g(int)
pd->g('a'); // calls D::g(char)
}
int main() {
D * myd = new D();
f(myd);
}
Alle Instanzen eines Namens, der mit der in einer Deklaration erwähnt wird, müssen verfügbar sein.Insbesondere wenn eine abgeleitete Klasse unter Verwendung der Deklaration verwendet, um einen Member einer Basisklasse zugreifen, muss der Membername möglich sein.Wenn der Name der eine überladene Memberfunktion ist, müssen alle Funktionen, die benannte barrierefrei sein.
Weitere Informationen finden Sie unter Member-ACCESS-Steuerelement. Weitere Informationen über Barrierefreiheit von Membern.
// using_declaration_inheritance2.cpp
// C2876 expected
class A {
private:
void f(char);
public:
void f(int);
protected:
void g();
};
class B : public A {
using A::f; // C2876: A::f(char) is inaccessible
public:
using A::g; // B::g is a public synonym for A::g
};