1. 导入命名空间

使用C++在写不同的功能模块时，为了防止命名冲突，建议对模块取命名空间，这样在使用时就需要指定是哪个命名空间。
使用 using 导入命名空间，即使一个命名空间中的所有名字都在该作用域中可见，常见的如下：
// 导入整个命名空间到当前作用域 using namespace std; // 只导入某个变量到当前作用域 using std::cout;
在.h头文件中，一般不应该使用using声明。
因为头文件的内容会拷贝到所有引用它的文件中去，如果头文件里有某个using声明，那么每个使用了该头文件的文件就都会有这个声明，从而可能产生名字冲突。

2. 指定别名

C++ 11 通过 using 指定别名，作用等同于 typedef，但相比 typedef，逻辑更直观，可读性更好。
typedef int T; // 用 T 代替 int using T = int; // 用 T 代替 int

3. 在派生类中引用基类成员

但是：
private变量不能通过using获得
using的使用更像是配合private继承来使用，通过基类的public来暴露接口。
代码如下：

如上图代码所示，尽管派生类 Derived 对 基类 Base 是私有继承，但通过 using 声明，派生类的对象就可以访问基类的 proteced 成员变量和 public 成员函数了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <iostream>
//#include <array>
#include <typeinfo>


using namespace std;

class Base
{
public:
    Base()
    {}
    ~Base(){}

    void dis1()
    {
        cout<<"dis1"<<endl;
    }
    void dis2()
    {
        cout<<"dis2"<<endl;
    }
};

class BaseA:private Base
{
public:
    using Base::dis1;//需要在BaseA的public下释放才能对外使用，
    void dis2show()
    {
        this->dis2();
    }
};

int main(int argc, char *argv[])
{

    BaseA ba;
    ba.dis1();
    ba.dis2show();

    return 0;
}

注意：using只是引用，不参与形参的指定。

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <iostream>
using namespace std;

// first name space
namespace first_space {
    void func() {
        cout << "Inside first_space" << endl;
    }

    // second name space
    namespace second_space {
        void func() {
            cout << "Inside second_space" << endl;
        }
    }
}

using namespace first_space::second_space;

int main () {
    // This calls function from second name space.
    func();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
//
// Created by DELL on 2023/2/21.
//
#include <iostream>
#include <vector>
#include <string>
#include <cstring>

using namespace std;

namespace A {
    void f() {
        cout << 1;
    }
}

namespace B {
    void f() {
        cout << 2;
    }
    void test(){
        cout << 3 << endl;
    }
}
-------------
int main() {
    A::f();
    B::f();
    using namespace A;
    f();
    using namespace B;
    test();
}
// 1213
-------------
int main() {
    A::f();
    B::f();
    using namespace A;
    f();
    using namespace B;
    f(); // error
}
-------------
int main() {
    A::f();
    B::f();
    using namespace A;
    f();
    using B::f;; // no error
    f(); 
    using namespace A;
    f(); //why 2?
    // 12122
}
------------
int main() {
    using B::f;; // no error
    f(); //
    using namespace A;
    f();
    using namespace B;
    f();
    // 222
}

如果是B::f，那就是特殊引用，所以就不会再次被覆盖了，如果是全部的，就会被特殊引用被覆盖
一般引用可以被特殊引用覆盖，但是不能被另外的一般引用覆盖；特殊引用不可以被另外的特殊引用覆盖（会报错），不会被另外的一般引用覆盖（无报错），相当于重新引用了一般引用。但是还可以使用B::f