à l'aide de la déclaration
La déclaration d' using présente un nom dans la zone déclarative dans laquelle la déclaration d' using s'affiche.
using [typename][::] nested-name-specifier unqualified-id
using :: unqualified-id
Notes
Le nom devient un synonyme d'une entité déclarée ailleurs.elle permet un nom individuel d'un espace de noms spécifique à utiliser sans qualification explicite.Ceci contraste avec la directive d' using , qui permet de tous les noms d'un espace de noms à utiliser sans qualification.Consultez directive using pour plus d'informations.
Exemple
Un à l'aide de la déclaration peut être utilisé dans une définition 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');
}
Une fois utilisé pour déclarer un membre, un à l'aide de la déclaration doit faire référence à un membre d'une classe de 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');
}
Les membres déclarés avec un à l'aide de la déclaration peuvent être référencés à l'aide de la qualification explicite.Le préfixe d' :: fait référence à l'espace de noms 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();
}
Lorsqu'un à l'aide de la déclaration est fait, le synonyme créé par la déclaration désigne uniquement les définitions valides au point de la déclaration de utilisation.les définitions ajoutées à un espace de noms après la déclaration de utilisation sont des synonymes non valides.
Un nom défini par un à l'aide de la déclaration est un alias pour son nom d'origine.elles n'affectent pas le type, la liaison ou d'autres attributs de la déclaration d'origine.
// 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);
}
En ce qui concerne les fonctions des espaces de noms, si un ensemble de déclarations locales et les déclarations d'utilisation pour un nom unique sont donnés dans la région déclarative, ils doivent faire référence à la même entité, ou ils doivent faire référence à des fonctions.
// 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
}
dans l'exemple ci-dessus, l'instruction d' using B::i provoque une seconde int i à déclarer dans la fonction d' g() .L'instruction d' using B::f n'est pas en conflit avec la fonction d' f(char) parce que les noms de fonctions introduites par B::f ont différents types de paramètre.
Une déclaration de fonction locale ne peut pas avoir le même nom et type qu'une fonction présentée à l'aide de la déclaration.Par exemple :
// 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)
}
Par rapport à l'héritage, lorsqu'un à l'aide de la déclaration présente un nom d'une classe de base dans une portée de classe dérivée, les fonctions membres dans les fonctions membres virtuelles de priorité de classe dérivée avec le même nom et des types d'argument dans la classe de 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);
}
Toutes les instances d'un nom mentionné dans un à l'aide de la déclaration doivent être accessibles.En particulier, si une classe dérivée utilise un à l'aide de la déclaration pour accéder à un membre d'une classe de base, le nom de membre doit être accessible.Si le nom est celui d'une fonction membre surchargée, toutes les fonctions nommées doivent être accessibles.
Consultez Contrôle d'accès de membre, pour plus d'informations sur l'accessibilité des membres.
// 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
};