C++命名空间的使用实践

ゝ一世哀愁。 2022-08-20 11:09 122阅读 0赞

大型程序往往是由团队开发的，即使是个人编写的程序，随着代码量的增多，变量、函数、类的名字冲突的现象时有发生。

有的情况下，编译器会指明错误所在，但有时候会发生一些察觉不到的覆盖，让程序员对出现的错误摸不着头脑。

很多厂商也提供了快捷的第3方类库，用户不用关心库中的类是如何实现的，知道如何调用接口使用即可，但多个厂商定义的变量、函数和类的名字可能会发生冲突，同样是初始化操作，甲公司类库提供了initial函数，乙公司可能也提供了initial函数，如果在程序中同时使用了两个公司的类库，initial函数对应哪个版本呢？

为了解决这些问题，新的C++标准提供了**命名空间机制**。

--------------------

## 命名空间定义 ##

命名空间通过定义一种新的声明区域来创建命名的名称空间，一个名称空间中的实体不会和另外一个名称空间中的同名实体冲突：

C++中定义命名空间的基本格式为：

namespace 命名空间名 
    { 
        变量类型 变量； 
        函数返回类型 函数原型；
    }

--------------------

使用命名空间简单示例：

#include <iostream>
    using namespace std;
    
    /*创建命名空间A*/
    namespace A
    {
        int num = 1;//A中变量num
        class Eclass//A中类定义Eclass
        {
        public:
             void hello();
        };
    }
    /*创建命名空间A*/
    namespace B
    {
        int num = 2;//B中变量num
        class Eclass//B中类定义Eclass
        {
        public:
             void hello()
             {
                 cout << " this is B" << endl;
                 cout << num << endl;
             }
        };
    }
    
    namespace A //命名空间是开放的
    {
        void Eclass::hello()//A中类Eclass的方法hello()的实现
        {
            cout << " this is A" << endl;
            cout << num << endl;
        }
    }
    
    
    int main(int argc, char** argv)
    {
        A::Eclass a;
        B::Eclass b;
        a.hello(); 
        b.hello();
    
        return 0;
    }
    
    /*
    执行结果:
     this is A
    1
     this is B
    2
    */

--------------------

## 实体可见域 ##

名称空间中实体的作用域是全局的，并不意味着其可见域也是全局的。  
如果不使用作用域限定符和using机制，抛开名称空间嵌套和内部屏蔽的情况，实体的可见域是从实体创建到该名称空间结束，在命名空间外，该实体是不可见的。  
程序实例：

/*实体可见域*/
    #include <iostream>
    using namespace std;
    
    namespace A
    {
        void showA()
        {
            cout << "This is A" << endl;
        }
    }
    /*B使用A*/
    namespace B
    {
        void showB()
        {
            showA(); //错  应为A::showA();
            cout << "This is B" <<endl;
        }
    }
    
    /*主函数使用命名空间B*/
    int main()
    {
       showB(); //错 应为B::showB();
    
       return 0;
    }

--------------------

## using声明机制 ##

如果不希望在每次使用名称空间中实体时都使用作用域限定符，可使用using声明机制扩展其可见域。  
using声明的基本格式为：

using 名称空间::实体名;

如“`using A::showA;`”  
至于using声明语句将该实体的可见域扩展到什么程度，这取决于using语句的书写位置，换言之，这取决于using语句的可见域。  
全局using声明实例：

/*全局using声明*/
    #include <iostream>
    using namespace std;
    
    namespace A
    {
        void showA()
        {
            cout << "This is A" << endl;
        }
    }
    
    using A::showA;//全局using声明语句，showA等价于全局变量
    
    void myMethod()//全局函数
    {
        cout << "outside" << endl;
    }
    
    /*创建命名空间B*/
    namespace B
    {
        void showB()
        {
            myMethod();
            showA();
            cout << "This is B" << endl;
        }
    }
    
    /*主函数使用命名空间B*/
    int main(int argc, char** argv)
    {
        B::showB(); //错 应为B::showB();
        showA();
        return 0;
    }
    
    /*
    执行结果：
    yu@ubuntu:~/CPP/224$ vi namespace2.cpp
    yu@ubuntu:~/CPP/224$ g++ namespace2.cpp
    yu@ubuntu:~/CPP/224$ ./a.out
    outside
    This is A
    This is B
    This is A
    */

--------------------

局部using声明实例：

/*局部using声明*/
    #include <iostream>
    using namespace std;
    
    namespace A
    {
        int num = 0;
    }
    
    void myMethod()//全局函数
    {
        using A::num; //局部声明
        cout << num << endl;
    }
    
    int main(int argc, char** argv)
    {
        myMethod();
        return 0;
    }
    
    /*
    执行结果：
    yu@ubuntu:~/CPP/224$ vi namespace3.cpp
    yu@ubuntu:~/CPP/224$ g++ namespace3.cpp
    yu@ubuntu:~/CPP/224$ ./a.out
    0
    */

--------------------

## 变量的屏蔽 ##

在一个空间内，变量可见域也有“屏蔽”规则，如内部变量对外部变量的屏蔽等，程序实例：

/*变量的屏蔽*/
    #include <iostream>
    using namespace std;
    
    int num = 1111; //外部变量num的定义性声明
    
    namespace B
    {
        int num = 111; //B中num
    }
    
    namespace A
    {
        int num = 11;//A中num
        void showA()
        {
            int num = 3;//showA中num
            cout << "showA函数中的num：" << num << endl;
            cout << "A中的num: " << A::num << endl;
            cout << "A中的num: " << B::num << endl;
            cout << "外部的num: " << ::num << endl; //::匿名
        }
    }
    
    int main(int argc, char** argv)
    {
        A::showA();
    
        return 0;
    }
    
    /*
    执行结果：
    yu@ubuntu:~/CPP/224$ vi namespace4.cpp
    yu@ubuntu:~/CPP/224$ g++ namespace4.cpp
    yu@ubuntu:~/CPP/224$ ./a.out
    showA函数中的num：3
    A中的num: 11
    B中的num: 111
    外部的num: 1111
    */

--------------------

使用**定义和实现分开的策略**解决相互调用的问题，程序实例：

#include <iostream>
    using namespace std;
    
    int num = 1111;
    
    namespace B
    {
        int num = 2;
    }
    
    namespace A
    {
        int num = 1;
    
        void showA()
        {
            int num = 3;
            cout << "showA函数中的num: " << num << endl;
            cout << "A中的num: " << A::num << endl;
            cout << "B中的num: " << B::num << endl;
            cout << "外部的num: " << ::num << endl;
        }
    }
    
    namespace B//创建名称空间B
    {
        void showB()
        {
            A::showA;
        }
    }
    
    int main(int argc, char **argv)
    {
        A::showA();
        B::showB();
    
        return 0;
    }
    
    /*
    yu@ubuntu:~/CPP/224$ vi namespace5.cpp
    yu@ubuntu:~/CPP/224$ g++ namespace5.cpp
    yu@ubuntu:~/CPP/224$ ./a.out
    showA函数中的num: 3
    A中的num: 1
    B中的num: 2
    外部的num: 1111
    */

--------------------

## 命名空间的嵌套 ##

名称空间可以定义在另一个名称空间内，以单层嵌套为例，要访问内部命名空间中的实体，必须采用“`外部命名空间::内部命名空间::实体名`”的形式，如果是多层嵌套，还要多次使用作用域限定符。  
程序实例：

/*命名空间的嵌套*/
    #include <iostream>
    
    using namespace std;
    
    int num = 0;
    
    namespace A //创建命名空间A
    {
        int num = 1;
        namespace B//创建命名空间B，嵌套于A中
        {
            int num = 11;
            void method()
            {
                int num = 3;
                cout << "函数method中的num: " << num << endl;
                cout << "嵌套域B中的num: " << B::num << endl;
                cout << "嵌套域A中的num: " << A::num << endl;
                cout << "全局变量num: " << ::num << endl;
            }
        }
    }
    
    int main(int argc, char **argv)
    {
        A::B::method(); //双重限定符
    
        return 0;
    }
    
    /*
    执行结果：
    yu@ubuntu:~/CPP/224$ vi namespace6.cpp
    yu@ubuntu:~/CPP/224$ g++ namespace6.cpp
    yu@ubuntu:~/CPP/224$ ./a.out
    函数method中的num: 3
    嵌套域B中的num: 11
    嵌套域A中的num: 1
    全局变量num: 0
    */

--------------------

## 匿名命名空间 ##

可以通过省略名称空间的名称来创建匿名的名称空间。  
此时，直接不加任何作用域限定来访问就是访问匿名的名字空间中的实体，相当于全局的。  
程序示例：

/*匿名命名空间*/
    #include <iostream>
    using namespace std;
    
    float float1 = 88.8f; //全局变量  ::
    
    namespace//匿名命名空间
    {
        float fUnnameSpaceFloat = 99.9f;
    }
    
    namespace mynamespace    //命名空间mynamespace
    {
        const int integer1 = 100;
        const double double1 = 100.5;
        float float1 = 99.9f;
        void printValue();
        namespace Inner//内嵌命名空间
        {
            double innerdouble = 55.5;
        }
    }
    
    int main(int argc, char **argv)
    {
        cout << "全局变量" << ::float1 << endl;
        cout << "匿名命名空间变量" << fUnnameSpaceFloat << endl;
        cout << "mynamespace::integer1 = " << mynamespace::integer1 << endl;
        cout << "mynamespace::double1 = " << mynamespace::double1 << endl;
        cout << "mynamespace::float1 = " << mynamespace::float1 << endl;
        cout << "mynamespace::Inner::innerdouble = " << mynamespace::Inner::innerdouble << endl;
    
        cout << endl;
        mynamespace::printValue();
    
        return 0;
    }
    
    void mynamespace::printValue()//mynamespace中输出函数的实现
    {
        cout << ::float1 << endl;
        cout << fUnnameSpaceFloat << endl;
        cout << "integer1 = " << integer1 << endl;
        cout << "double1 = " << double1 << endl;
        cout << "float1 = " << float1 << endl;
        cout << "Inner::innerdouble = " << Inner::innerdouble << endl;
    }
    
    /*
    执行结果：
    yu@ubuntu:~/CPP/224$ vi namespace7.cpp
    yu@ubuntu:~/CPP/224$ g++ namespace7.cpp
    yu@ubuntu:~/CPP/224$ ./a.out
    全局变量88.8
    匿名命名空间变量99.9
    mynamespace::integer1 = 100
    mynamespace::double1 = 100.5
    mynamespace::float1 = 99.9
    mynamespace::Inner::innerdouble = 55.5
    
    88.8
    99.9
    integer1 = 100
    double1 = 100.5
    float1 = 99.9
    Inner::innerdouble = 55.5
    */