pomocí prohlášení
using Prohlášení název zavádí do deklarativní regionu, ve kterém using se zobrazí prohlášení.
using [typename][::] nested-name-specifier unqualified-id
using :: unqualified-id
Poznámky
Název se stane synonymum pro entitu deklarované jinde.Umožňuje jednotlivých jméno z určitého oboru názvů bez explicitní kvalifikace.To je rozdíl oproti using směrnice, která umožňuje všechny názvy v oboru názvů bez kvalifikace.Viz použití směrnice Další informace.
Příklad
A pomocí prohlášení lze použít v definici třídy.
// 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');
}
Při deklaraci člena using prohlášení musí odkazovat na člen základní třídy.
// 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');
}
Členové deklarována s using prohlášení lze odkazovat pomocí explicitních kvalifikace.:: Prefix odkazuje na globální obor názvů.
// 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();
}
Při použití prohlášení, synonymum vytvořené prohlášení odkazuje pouze na definice, které jsou platné v okamžiku pomocí prohlášení.Definice vkládají do oboru názvů použití prohlášení nejsou platná synonyma.
Název definovaný pomocí prohlášení je alias původní název.Typ, navázání nebo jiné atributy původní prohlášení neovlivní.
// 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);
}
S ohledem na funkce v oborech názvů, pokud sada místní prohlášení a prohlášení jsou uvedeny jediný název v deklarativní oblast, musí všechny odkazují na stejný subjekt nebo musí všechny odkazují na funkce.
// 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
}
V příkladu výše using B::i příkaz způsobí, že druhý int i uvádějí v g() funkce.using B::f Příkaz není v rozporu s f(char) fungovat, protože názvy funkcí zavedených B::f mají různé typy parametrů.
Prohlášení místní funkce nemůže mít stejný název a typ jako funkce zavedena pomocí prohlášení.Příklad:
// 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)
}
Vzhledem k dědičnosti při použití prohlášení zavádí název ze základní třídy do oboru odvozené třídy, funkce členů v odvozené třídy přepsat virtuální členské funkce stejné typy název a argument v základní třídě.
// 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);
}
Všechny výskyty názvu pomocí uvedených prohlášení musí být přístupné.Zejména pokud používá odvozené třídy using prohlášení přístup člen základní třídy, název člena musí být přístupné.Pokud je název přetížené členské funkce, která pak musí být dostupné všechny funkce s názvem.
Viz Řízení přístupu členských, Další informace o usnadnění členů.
// 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
};