using – deklarace

Deklarace using zavádí název do deklarativní oblasti, ve které se zobrazí deklarace using.

Syntaxe

using [typename] nested-name-specifier unqualified-id ;
using declarator-list ;

Parametry

specifikátor vnořených názvů A posloupnost názvů, tříd nebo názvů výčtů a operátorů překladu oborů (::), ukončená operátorem překladu oboru. K zavedení názvu z globálního oboru názvů lze použít jeden operátor překladu oboru názvů. Klíčové slovo typename je volitelné a lze ho použít k překladu závislých názvů při zavedení do šablony třídy ze základní třídy.

unqualified-id An unqualified id-expression, which may be an identifier, an přetížení operator name, a user-defined literal operator or conversion function name, a class destructor name, or a template name and argument list.

deklarator-list A čárkami oddělený seznamtypename [] vnořený specifikátor-název-specifikátorunqualified-id , následovaný volitelně třemi tečkami.

Poznámky

Deklarace using zavádí nekvalifikovaný název jako synonymum pro entitu deklarovanou jinde. Umožňuje použít jeden název z konkrétního oboru názvů bez explicitní kvalifikace v oblasti deklarace, ve které se zobrazí. To je na rozdíl od direktivy using, která umožňuje použití všech názvů v oboru názvů bez kvalifikace. Klíčové using slovo se také používá pro aliasy typů.

Příklad: using Deklarace v poli třídy

Deklarace using 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;    // B::f(char) is now visible as D::f(char)
   using B::g;    // B::g(char) is now visible as D::g(char)
   void f(int) {
      printf_s("In D::f()\n");
      f('c');     // Invokes B::f(char) instead of recursing
   }

   void g(int) {
      printf_s("In D::g()\n");
      g('c');     // Invokes B::g(char) instead of recursing
   }
};

int main() {
   D myD;
   myD.f(1);
   myD.g('a');
}

In D::f()
In B::f()
In B::g()

Příklad: using Deklarace deklarací člena

Pokud se používá k deklaraci členu, musí deklarace using 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');
}

In B::f()

Příklad: using deklarace s explicitní kvalifikací

Na členy deklarované pomocí deklarace using lze odkazovat pomocí explicitní kvalifikace. Předpona :: 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 is also visible as X::f
   using A::g;   // A's g is now visible as X::g
}

void h() {
   printf_s("In h\n");
   X::f();   // calls ::f
   X::g();   // calls A::g
}

int main() {
   h();
}

In h
In f
In A::g

Příklad: using synonyma a aliasy deklarace

Při použití deklarace se synonymum vytvořené deklarací odkazuje pouze na definice platné v okamžiku deklarace using. Definice přidané do oboru názvů po deklaraci using nejsou platná synonyma.

Název definovaný using deklarací je alias pro původní název. Nemá vliv na typ, propojení nebo jiné atributy původní deklarace.

// 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);
}

Příklad: Místní deklarace a using deklarace

S ohledem na funkce v oborech názvů, pokud je v deklarativní oblasti uvedena sada místních deklarací a použití deklarací pro jeden název, musí všechny odkazovat na stejnou entitu, nebo musí všechny odkazovat 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
}

Ve výše uvedeném příkladu using B::i příkaz způsobí deklaraci sekundy int ig() ve funkci. Příkaz using B::f není v konfliktu s f(char) funkcí, protože názvy funkcí zavedené B::f různými typy parametrů.

Příklad: Deklarace a using deklarace místní funkce

Deklarace místní funkce nemůže mít stejný název a typ jako funkce zavedená pomocí deklarace. 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)
}

Příklad: using deklarace a dědičnost

Pokud jde o dědičnost, při použití deklarace zavádí název ze základní třídy do odvozeného oboru třídy, členské funkce v odvozené třídě přepisují virtuální členské funkce se stejným názvem a typy 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);
}

In D::f(int)
In B::f(char)
In B::g
In D::g(char)

Příklad: using Přístupnost deklarace

Všechny instance názvu uvedené v deklaraci using musí být přístupné. Konkrétně pokud odvozená třída používá pro přístup k členu základní třídy deklaraci using, musí být název člena přístupný. Pokud je název přetížené členské funkce, musí být všechny pojmenované funkce přístupné.

Další informace o přístupnosti členů najdete v tématu Řízení přístupu č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
};

Viz také

Obory názvů
Klíčová slova