mediante la dichiarazione
using la dichiarazione viene introdotto un nome nell'area dichiarativa in cui using la dichiarazione viene visualizzata.
using [typename][::] nested-name-specifier unqualified-id
using :: unqualified-id
Note
Il nome diventa un sinonimo di un'entità dichiarata in un'altra posizione.Consente utente nome da uno spazio dei nomi specifico da utilizzare senza qualificazione esplicita.Ciò si differenzia da a using direttiva, che consente tutti i nomi in uno spazio dei nomi da utilizzare senza qualificazione.vedere direttiva using per ulteriori informazioni.
Esempio
All'utilizzo della dichiarazione può essere utilizzato in una definizione di 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 viene utilizzata per dichiarare un membro, un oggetto mediante la dichiarazione deve fare riferimento a un membro di una 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');
}
I membri dichiarati con un oggetto mediante la dichiarazione è possibile fare riferimento utilizzando la qualifica esplicita.:: il prefisso fa riferimento allo spazio dei nomi globale.
// 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();
}
Quando un oggetto mediante la dichiarazione viene effettuata, un sinonimo creato dalla dichiarazione si riferisce solo a definizioni valide al momento della dichiarazione utilizzando.Le definizioni aggiunte a uno spazio dei nomi dopo la dichiarazione utilizzando sono sinonimi non validi.
Un nome definito da un oggetto utilizzando la dichiarazione è un alias per il nome originale.Non influisce sul tipo, il collegamento o altri attributi della dichiarazione originale.
// 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);
}
Rispetto alle funzioni negli spazi dei nomi, se un set di variabili locali e le dichiarazioni utilizzando per un singolo nome sono indicati in un'area dichiarativa, devono fare riferimento alla stessa entità, o devono fare riferimento a funzioni.
// 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
}
Nell'esempio precedente, using B::i l'istruzione genera un secondo int i per essere dichiarato in g() funzione.using B::f l'istruzione non sia in conflitto con f(char) funzione poiché i nomi di funzione introdotti da B::f includere tipi di parametro diversi.
Una dichiarazione di funzione locale non può avere lo stesso nome e lo stesso tipo come funzione presentata tramite la dichiarazione.Di seguito è riportato un esempio:
// 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)
}
Rispetto all'ereditarietà, quando un oggetto mediante la dichiarazione introduce un nome da una classe base in un ambito della classe derivata, nelle funzioni membro nelle funzioni membro virtuali di override della classe derivata con lo stesso nome e nei tipi di argomento nella 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);
}
Tutte le istanze di un nome definito in un oggetto mediante la dichiarazione devono essere accessibili.In particolare, se una classe derivata utilizza un oggetto mediante la dichiarazione per accedere a un membro di una classe base, il nome del membro deve essere accessibile.Se il nome è quello di una funzione membro in overload, tutte le funzioni denominate devono essere accessibili.
vedere Controllo di accesso al membro, per ulteriori informazioni sull'accessibilità dei membri.
// 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
};