C/C++编程：using 声明

左手的ㄟ右手 2022-11-14 13:19 210阅读 0赞

作用：

*  将名称引入声明性区域

# 示例 #

## 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;    // B::f(char) is now visible as D::f(char)
       using B::g;    // B::g(char) is now visible as D::g(char)
       void f(int) {
        
          printf_s("In D::f()\n");
          f('c');     // Invokes B::f(char) instead of recursing
       }
    
       void g(int) {
        
          printf_s("In D::g()\n");
          g('c');     // Invokes B::g(char) instead of recursing
       }
    };
    
    int main() {
        
       D myD;
       myD.f(1);
       myD.g('a');
    }

![在这里插入图片描述][20210329155712173.png]

## 声明`using`成员的声明 ##

用于声明成员时，`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');
    }

![在这里插入图片描述][20210329155936882.png]

## `using`具有显式限定的声明 ##

使用`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 is also visible as X::f
       using A::g;   // A's g is now visible as X::g
    }
    
    void h() {
        
       printf_s("In h\n");
       X::f();   // calls ::f
       X::g();   // calls A::g
    }
    
    int main() {
        
       h();
    }

![在这里插入图片描述][20210329160619528.png]

## `using`声明同义词和别名 ##

*  当使用声明时，由声明创建的同义词只引用在使用声明点有效的定义。 在 using 声明后面添加到命名空间的定义是无效同义词。
 *  声明定义的名称 using 是其原始名称的别名。 它不会影响原始声明的类型、链接或其他特性。

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);
    }

## 局部声明和 using 声明 ##

对于命名空间中的函数，如果声明区域中提供了一组本地声明和使用单个名称的声明，则它们必须引用同一实体，或者它们必须都引用函数。

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 具有不同的参数类型。

## 局部函数声明和using声明 ##

局部函数不能与使用声明引入的函数具有相同的名称和类型。比如：

namespace B {
        
        void f(int);
        void f(double);
    }
    
    namespace C {
        
        void f(int);
        void f(double);
        void f(char);
    }
    
    void C::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声明将基类的名称引入派生类作用域时，派生类中的成员函数会重写基类中具有相同名称和参数类型的虚拟成员函数。

// 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);
    }

![在这里插入图片描述][20210329162532549.png]

## using声明可访问性 ##

使用声明中提到的名称的所有实例必须都是可访问的。特别是，如果派生类使用using声明访问基类成员，则该成员名称必须是可访问的。如果名称是重载成员函数的名称，则它们都必须是可访问的。

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
    };

[20210329155712173.png]: /images/20221022/775168fc4dd4454bb9a23c5fa9e4dc65.png
[20210329155936882.png]: https://img-blog.csdnimg.cn/20210329155936882.png
[20210329160619528.png]: https://img-blog.csdnimg.cn/20210329160619528.png
[20210329162532549.png]: https://img-blog.csdnimg.cn/20210329162532549.png