Usando declaração
O using declaração apresenta um nome para a região declarativa em que o using declaração aparece.
using [typename][::] nested-name-specifier unqualified-id
using :: unqualified-id
Comentários
O nome se torna um sinônimo para uma entidade declarado em outro lugar.Ele permite que um individuais nome de um namespace específico a ser usada sem explícita qualificação.Isso é em contraste com o using diretiva, que permite que todos os os nomes em um namespace a ser usada sem qualificação.Consulte usando a diretiva para obter mais informações.
Exemplo
A usando a declaração pode ser usado em uma definição de classe.
// 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');
}
Quando usado para declarar um membro, usando uma declaração deve se referir a um membro de uma classe base.
// 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');
}
Os membros declarados com o uso de uma declaração pode ser referenciada qualificação explícita.O :: prefixo refere-se ao namespace global.
// 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();
}
Ao usar uma declaração feita, o sinônimo criado pela declaração refere-se somente às definições que são válidas no ponto de uso declaração.Definições adicionadas a um namespace após usar a declaração não são sinônimos válidos.
Um nome definido por meio de uma declaração é um alias para seu nome original.Ele não afeta o tipo, ligação ou outros atributos da declaração original.
// 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);
}
Com relação a funções nos namespaces, se um conjunto de declarações de locais e o uso de declarações para um único nome são dadas em uma região declarativa, eles devem fazer referência a mesma entidade ou eles devem fazer referência às funções.
// 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
}
No exemplo acima, o using B::i instrução faz com que uma segunda int i deve ser declarado na g() função.O using B::f instrução não entra em conflito com o f(char) funcionar porque os nomes de função introduzidos por B::f têm tipos de parâmetros diferentes.
Uma declaração de função local não pode ter o mesmo nome e tipo, como uma função introduzida pelo uso de declaração.Por exemplo:
// 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)
}
Com relação a herança, ao usar uma declaração apresenta um nome de uma classe base para um escopo de classe derivada, funções de membro nas funções de membro virtual da substituição de classe derivada com os mesmos tipos de nome e o argumento na classe base.
// 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);
}
Todas as instâncias de um nome mencionado em um usando a declaração deve ser acessível.Em particular, se uma classe derivada usa um usando a declaração para acessar um membro de uma classe base, o nome do membro deve estar acessível.Se o nome de uma função de membro sobrecarregadas, é então chamadas de todas as funções devem estar acessíveis.
Consulte O controle de acesso de membro, para obter mais informações sobre acessibilidade de membros.
// 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
};