[C++知识库]第三章：C++对C的扩展-2

击上方“南山府嵌入式”，选择“置顶/星标公众号”

干货福利，第一时间送达！

=====================

3.2 名字控制

创建名字是程序设计过程中一项最基本的活动，当一个项目很大时，它会不可避免地包含大量名字。c++允许我们对名字的产生和名字的可见性进行控制。我们之前在学习 c 语言可以通过 static 关键字来使得名字只得在本编译单元内可见，在 c++中我们将通过一种通过命名空间来控制对名字的访问。

3.2.1 C++命名空间(namespace)*

在 c++中，名称（name）可以是符号常量、变量、函数、结构、枚举、类和对象等等。工程越大，名称互相冲突性的可能性越大。另外使用多个厂商的类库时，也可能导致名称冲突。为了避免，在大规模程序的设计中，以及在程序员使用各种各样的 C++库时，这些标识符的命名发生冲突，标准 C++引入关键字 namespace（命名空间/名字空间/名称空间），可以更好地控制标识符的作用域。

3.2.2 命名空间使用语法

创建一个命名空间:

namespace A{
int a = 1000; 
}
namespace B{ 
int a = 2000; 
}
void test(){ 
cout << "A::a : " << A::a << endl; 
cout << "B::a : " << B::a << endl; 
}

1-命名冲突解决

namespace A {
int a = 100;//a属于空间A
}
namespace B {
int a = 200;//a属于空间b
}
void test2()
{
//A::a  a是属于A中
cout << "A中a = " << A::a << endl;//::命名空间直接找到空间A中的a（在以后的命名中最好加上命名空间，是为了区分防止命名重复，）
cout << "B中a = " << B::a << endl;
}

命名空间只能全局定义，不能够局部函数内定义，如下所示：

void test2()
{
    namespace A {
        int a = 100;//a属于空间A
    }
    namespace B {
        int a = 200;//a属于空间b
    }
    //A::a  a是属于A中
    cout << "A中a = " << A::a << endl;//::命名空间直接找到空间A中的a
    cout << "B中a = " << B::a << endl;
}
int main()
{
    test2();
}

2-命名空间的嵌套

namespace A {
    int a = 500;//a属于空间A
    namespace B {
        int a = 10200;//a属于空间b
    }
}
void test3()
{
    cout << "A中a = " << A::a << endl;//::命名空间直接找到空间A中的a
    cout << "B中a = " << A::B:: a << endl;//访问A空间中B中间里的a的值（空间嵌套基层::就加几次，如本例嵌套2层就加两个）
}

int main()
{
    test3();
}

命名空间的开放性：（可以随时加入新的命名空间）

比如，如果某个函数我在写的时候才想起来，我就可以加入已有的命名空间中（不在举例）

3-命名空间还可以存放函数、变量

namespace B {
int a=989898;//变量
void funb()
{
cout << "funb遍历a= " << a << endl;//因为命名空间层级一样，所以不用写A::a这种，除非层级不一样，比如funb在A中的B空间中，这时候就需要::来进行访问，可自行验证
}
}
void test4()
{
cout << "A中a = " << B::a << endl;//::命名空间直接找到空间A中的a
B::funb();
}
int main()
{
test4();

4-命名空间的函数可以在命名空间外部定义
namespace B {
    int a = 989898;//变量
    void funb();
}


void funb()
{
    cout << "funb遍历a= " << B::a << endl;//因为命名空间层级一样，所以不用写A::a这种，除非层级不一样，比如funb在A中的B空间中，这时候就需要::来进行访问，可自行验证
}

void test4()
{
    
   funb();
}

int main()
{
    test4();
}

namespace B {
    int a = 989898;//变量
    void funb();
}


void funb()
{
    cout << "funb遍历a= " << B::a << endl;//因为命名空间层级一样，所以不用写A::a这种，除非层级不一样，比如funb在A中的B空间中，这时候就需要::来进行访问，可自行验证
}

void test4()
{
    
   funb();
   B::funb();//这种方式是不被允许的；因为你不知道这个是属于那个命名空间，void funb()只是个普通的函数，
}

namespace B {
    int a = 989898;//变量
    void funb();
}
 
 
 void funb()
{
    cout << "funb遍历a= " << B::a << endl;//因为命名空间层级一样，所以不用写A::a这种，除非层级不一样，
                                          //比如funb在A中的B空间中，这时候就需要::来进行访问，可自行验证
}
 
 void B::funb()
 {
     cout << "funb遍历a= " << B::a << endl;//因为命名空间层级一样，所以不用写A::a这种，
                                          //除非层级不一样，比如funb在A中的B空间中，这时候就需要::来进行访问，可自行验证
 }
void test4()
{
    
  // funb();
   B::funb();//这种方式是不被允许的；
}
 
int main()
{
    test4();
}

无名命名空间，意味着命名空间中的标识符只能在本文件内访问，相当于给这个标识符加上了 static，使得其可以作为内部连接(在此不建议使用无名命名空间)

namespace{ 
int a = 10; 
void func(){ cout << "hello namespace" << endl; } 
}
void test(){cout << "a : " << a << endl; 
func(); 
}

命名空间别名 （就是给一个命名空间重新取个名字和typedef一样，但是不是用这个 ）

namespace A_name{ 
int a = 10; 
void func(){ cout << "hello namespace" << endl; } 
}
void test(){ 
namespace B_name= A_name; 
cout << "A_name::a : " << B_name::a << endl; 
veryLongName::func(); 
shortName::func(); 
}

using使用命名空间

您可以使用 using namespace 指令，这样在使用命名空间时就可以不用在前面加上命名空间的名称。这个指令会告诉编译器，后续的代码将使用指定的命名空间中的名称。

namespace B_Name
{
int a = 200;
void func()
{
cout << "Hi,namespace" << endl;
}
}
void test6()
{
cout << "a= " << B_Name::a << endl;
B_Name::func();
}
int main()
{
test6();
}

namespace B_Name
{
    int a = 200;
    void func()
{
        cout << "Hi,namespace" << endl;
    }
}

void test6()
{
    cout << "a= " << B_Name::a << endl;
    B_Name::func();
}
void test7()
{
    //使用命名空间B_Name ,意思就是先从B_Name空间内找（using意思就是使用，所以根据字面意思就能理解）
    using namespace B_Name;
    cout << "a= " << a << endl;
    func();
}
int main()
{
    test6();
    
    test7();
}

1-对命名空间有简化作用，但是有时候会造成冲突。（）

namespace B_Name
{
int a = 200;
void func()
{
cout << "Hi,namespace" << endl;
}
}
void test7()
{
int a = 3000;
//使用命名空间B_Name ,意思就是先从B_Name空间内找（using意思就是使用，所以根据字面意思就能理解）
using namespace B_Name;
cout << "a= " << a << endl;
func();
}

可以看到这样会优先选择变量近的，也就是就近原则。所以在进行变量命名时，尽量不要变量名一样（在使用using的时候）或者使用 using B_NAme::a;形式

void test8()
{
/*int a = 3000;*/
//使用命名空间B_Name ,意思就是先从B_Name空间内找（using意思就是使用，所以根据字面意思就能理解）
using B_Name::a;
cout << "a= " << a << endl;
B_Name::func();
}

但是我认为这样比较麻烦买还是直接使用比较好，因为这样使用你如果定义一个局部变量a,命名空间中也有变量a，这样就会报错提示using导致多次声明，会出现下图中的错误：

void test8()
{
int a = 3000;
//使用命名空间B_Name ,意思就是先从B_Name空间内找（using意思就是使用，所以根据字面意思就能理解）
using B_Name::a;
cout << "a= " << a << endl;
B_Name::func();

1-函数重载

namespace B_Name
{
//函数重载 函数名+参数 代表是函数的入口地址
void func()
{
cout << "Hi, 对对对namespace" << endl;
}
void func(int a)
{
cout << "Hi,nam对啊对espace" << endl;
}
void func(int a, int b)
{
cout << "Hi,nam不懂得espace" << endl;
}
}
void  test9()
{
B_Name::func();
}
int main()
{


test9();
}
namespace B_Name
{
//函数重载 函数名+参数 代表是函数的入口地址
void func()
{
cout << "Hi, 对对对namespace" << endl;
}
void func(int a)
{
cout << "Hi,nam对啊对espace" << endl;
}
void func(int a, int b)
{
cout << "Hi,nam不懂得espace" << endl;
}
}

如果命名空间包含一组用相同名字重载的函数，using 声明就声明了这个重载函数的所有集合如下：

void  test9()
{ //using指明 使用A中的FUNC会对所有的func起作用
using B_Name::func;
func();
func(1,1);
func(1);
}
int main()
{


test9();
}

更多请关注**：**

https://blog.csdn.net/qq_38575895?spm=1000.2115.3001.5343