Bildirimi kullanarak
using Bildirimi tanıtan bir ad, bildirimsel bölge içine using bildirimi görüntülenir.
using [typename][::] nested-name-specifier unqualified-id
using :: unqualified-id
Notlar
Başka bir yerde bildirilen bir varlık eşanlamlısı adı olur.Veren bir tek tek olmadan kullanılacak belirli bir ad alanından adı açık bir nitelik.Aksine budur using veren yönergesi tüm nitelik kullanılacak bir ad alanındaki adları.Bkz: yönergesini kullanarak daha fazla bilgi için.
Örnek
A bildirimini kullanarak sınıf tanımında kullanılabilir.
// 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');
}
Using üyesi bildirmek için kullanıldığında bildiriminin, bir temel sınıf üyesi için başvurmalıdır.
// 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');
}
Üyelere bildirilen kullanma ile bildirimi açık niteliği kullanılarak başvurulabilir.:: Öneki genel ad alanına başvurur.
// 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();
}
Bir kullanırken, bildirimin yapıldığı, kullanma noktasında geçerli olan tanımları bildirimi tarafından oluşturulan eşanlamlı başvurduğu bildirimi.Tanımları kullandıktan sonra bir ad alanınıza eklenen bildirim geçerli eşanlamlı değildir.
Bir kullanılarak tanımlanmış bir ad özgün adı için diğer ad bildirimidir.Türü, bağlantı veya diğer öznitelikleri özgün bildirimin etkilemez.
// 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);
}
Ad alanları, yerel bildirimleri kümesi, işlevleri açısından ve bildirimleri Bildirime dayanan bir bölgede tek bir adı verilen tüm aynı varlığa başvurmalıdır veya tüm işlevler için başvurmalıdır.
// 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
}
Yukarıdaki örnekte using B::i deyimi neden olan ikinci bir int i içinde bildirilmesi için g() işlevi.using B::f Deyimi değil çakışma ile f(char) işlev adları tarafından tanıtılan işlev B::f farklı parametre türlerine sahip.
Yerel işlev bildirimi bildirimi kullanarak tanıtılan bir işlevle aynı adda ve türde olamaz.Örne?in:
// 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)
}
Devralma açısından bir kullanırken bildirimi bir ad Temel sınıftan türetilmiş sınıf override sanal üye işlevlerinde üye işlevleri ile aynı adı ve bağımsız değişken türlerini temel sınıfta bir türetilmiş sınıf kapsamı içine tanıtır.
// 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);
}
Using sözü adının tüm örneklerinin bildirim erişilebilir olmalıdır.Türetilmiş bir sınıf kullanarak bir kullanıyorsa, özellikle üye adı bir temel sınıf üyesi erişmek için bildirim erişilebilir olmalıdır.Adlı tüm işlevleri erişilebilir adı, bir aşırı yüklü üye işlevi ise.
Bkz: Üye erişim denetimi, üyelerinin erişilebilirlik hakkında daha fazla bilgi için.
// 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
};