użycie — deklaracja
Deklaracja using wprowadza nazwę do regionu deklaracyjnego, w którym pojawia się deklaracja using.
using [typename][::] nested-name-specifier unqualified-id
using :: unqualified-id
Uwagi
Nazwa staje się synonimem dla jednostki zadeklarowanej w innym miejscu.Pozwala indywidualnej nazwie z określonego obszaru nazw na bycie używaną bez jawnej kwalifikacji.Jest to przeciwieństwem do dyrektywy using, która pozwala wszystkim nazwom w obszarze nazw na bycie używanym bez kwalifikacji.Zobacz Dyrektywa using w celu uzyskania więcej informacji.To słowo kluczowe jest używane także do aliasów typu.
Przykład
Deklaracja using może być używana 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');
}
Podczas użycia przy deklaracji członka, deklaracja using musi odnosić 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');
}
Do elementów członkowskich zadeklarowanych za pomocą deklaracji using można się odwoływać za pomocą jawnych 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();
}
Gdy zostanie utworzona deklaracja using, synonim utworzony przez deklaracje odnosi się tylko do definicji, które są prawidłowe w punkcie deklaracji using.Definicje dodane do obszaru nazw po deklaracji using nie są prawidłowymi synonimami.
Nazwa zdefiniowana za pomocą deklaracji using jest aliasem dla jego oryginalnej nazwy.Nie ma wpływu na typ, powiązanie lub inne atrybuty pierwotnej deklaracji.
// 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 przestrzeni nazw, jeśli zbiór deklaracji lokalnych i deklaracje using w odniesieniu do pojedynczej nazwy podane są w regionie deklaracyjnym, wszystkie muszą odnosić się do tej samej encji lub 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 instrukcja using B::i powoduje, że drugi int i deklaruje się w funkcji g().Wyrażenie using B::f nie powoduje konfliktów z funkcją f(char), ponieważ nazwy funkcji wprowadzonych przez B::f mają różne typy parametrów.
Lokalna deklaracja funkcji nie może mieć tej samej nazwy i typu co funkcja wprowadzona przez deklaracje using.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, gdy deklaracja using wprowadza nazwę od klasy podstawowej do zakresu klasy pochodnej, funkcje składowe w klasie pochodnej zastępują wirtualne funkcje składowe o tej samej nazwie i typie argumentów co 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 wymienionej w deklaracji using muszą być dostępne.W szczególności, jeśli klasa pochodna używa deklaracji using w celu uzyskania dostępu do elementu członkowskiego klasy podstawowej, nazwa elementu musi być dostępna.Jeśli nazwa to nazwa przeciążonej funkcji składowej, wtedy wszystkie nazwy funkcje muszą być dostępne.
Zobacz Kontrola dostępu do elementu członkowskiego, aby uzyskać więcej informacji o dostępności elementów członkowskich.
// 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
};