使用宣告
using宣告引入的宣告式的區域，在其中一個名稱using宣告就會出現。
using [typename][::] nested-name-specifier unqualified-id
using :: unqualified-id
備註
名稱會變成同義資料表的其他位置所宣告的實體。 它可讓個別 ，不需要使用特定的命名空間名稱 外顯的限定性條件。 這是相對於using指示詞，它可讓所有中無限制地使用命名空間的名稱。 請參閱 using 指示詞如需詳細資訊。
範例
A using 宣告可用於類別定義。
// 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 宣告必須參考基底類別的成員。
// 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');
}
使用 using 宣告的成員可以使用外顯的限定性條件所宣告的參考。 ::前置詞指的是全域命名空間。
// 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();
}
使用時進行宣告，宣告所建立的同義資料表只會參考處使用有效的定義宣告。 定義使用後面加上命名空間宣告不是有效的同義字。
藉由使用已定義的名稱宣告是原來的名稱的別名。 它不會影響型別、 連結或其他屬性的原始宣告。
// 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);
}
相對於命名空間，如果區域宣告一組中的函式和使用單一名稱都指定在宣告式的區域、 將它們必須參照相同的實體，或將它們必須參照到函式的宣告。
// 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
}
在上述範例中， using B::i陳述式會導致第二個int i宣告在g()函式。 using B::f陳述式沒有衝突的f(char)函數，因為函式名稱引入B::f有不同的參數型別。
本機的函式宣告不能有相同的名稱和型別，藉由宣告引入的函式。 例如：
// 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)
}
相對於繼承中，當 using 宣告引入名稱從基底類別衍生的類別範圍中，在衍生的類別覆寫虛擬成員函式相同的名稱和引數型別，基底類別中的成員函式。
// 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 宣告，以存取基底類別，而成員名稱的成員必須是可存取。 如果名稱是多載的成員函式則名為所有的函式必須可供存取。
請參閱成員存取控制，如需協助工具的成員。
// 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
};