za pomocą deklaracji
using Deklarację wprowadza nazwę do deklaracyjne regionu, w którym using pojawia się deklarację.
using [typename][::] nested-name-specifier unqualified-id
using :: unqualified-id
Uwagi
Nazwa staje się synonim dla jednostki zadeklarowane w innym miejscu.Pozwala na poszczególnych nazwa z określonego obszaru nazw ma być używany bez jawne kwalifikacji.Jest to w przeciwieństwie do using dyrektywy, która pozwala na wszystkich nazw w obszarze nazw ma być używany bez kwalifikacji.Zobacz przy użyciu dyrektywy Aby uzyskać więcej informacji.
Przykład
A za pomocą deklaracji, mogą być używane w definicji klasy.
// 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');
}
Gdy deklarujących składnika, za pomocą deklaracji musi odwoływać się do członka klasy podstawowej.
// 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');
}
Członków zadeklarowanych z za pomocą deklaracji można się odwoływać za pomocą jawnego kwalifikacji.:: Prefiks odnosi się do globalnego obszaru nazw.
// 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();
}
Podczas korzystania z zgłoszenia, synonim, utworzone przez deklarację odnosi się wyłącznie do definicji, które są ważne w punkcie uderzenia za pomocą deklaracji.Definicje dodane do obszaru nazw po użyciu deklaracja nie są prawidłowe synonimy.
Nazwa zdefiniowana za pomocą deklaracji jest aliasem dla jego oryginalną nazwą.Nie dotyczy typu, powiązanie lub inne atrybuty zgłoszenia pierwotnego.
// 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);
}
W odniesieniu do funkcji w obszarach nazw, jeśli zestaw lokalnych deklaracji i za pomocą deklaracji dla jednej nazwy są podane w regionie deklaracyjne, należy wszystkie odnoszą się do tego samego podmiotu lub muszą wszystkie odnoszą się do funkcji.
// 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
}
W przykładzie powyżej using B::i instrukcja powoduje, że drugi int i mają zostać zadeklarowane w g() funkcji.using B::f Instrukcja nie powoduje konfliktu z f(char) działać, ponieważ nazwy funkcji wprowadzonych przez B::f parametr różnych typów.
Deklarację funkcji lokalnej nie może mieć tę samą nazwę i typ jako funkcja wprowadzone za pomocą deklaracji.Na przykład:
// 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)
}
W odniesieniu do dziedziczenia podczas korzystania z deklaracji wprowadza nazwę od klasy podstawowej do zakresu klasy pochodnej, funkcji elementów członkowskich w funkcji członka wirtualnego override klasy pochodnej z tego samego typu nazwa i argument w klasie podstawowej.
// 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);
}
Wszystkie wystąpienia nazwy wymienione w użyciu zgłoszenia muszą być dostępne.W szczególności, jeśli klasie pochodnej przy użyciu deklaracji uzyskać dostępu do członka klasy podstawowej, nazwa członka muszą być dostępne.Jeśli nazwa jest funkcji zastąpionej Członkowskich, a następnie wszystkich funkcji o nazwie muszą być dostępne.
Zobacz Kontroli dostępu Członkowskie, aby uzyskać więcej informacji o ułatwieniach dostępu członków.
// 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
};