【C++】命名空间（namespace-超详细解析，小白必看系列）

1 命名空间简介

命名空间（Namespace）是编程语言中用于组织和隔离标识符（如变量、函数、类等）的一种机制。它的主要作用是 避免命名冲突，即当不同代码片段中使用相同名称的标识符时，通过命名空间来区分它们，从而避免冲突。 namespace关键字的出现就是针对这种问题的。

1.1 举例（c语言命名冲突）

1 变量命名冲突

#include<stdio.h>
#include<stdlib.h>
// 命名冲突
// rand 是库中的一个函数
// 自己又定义了一个与其名字相同的一个变量
int rand = 0;
int main()
{
	printf("%d", rand);
	return 0;
}
// 编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”

2 函数命名冲突

// 库A中的函数定义
void print() {
    printf("Library A print function\n");
}

// 库B中的函数定义
void print() {
    printf("Library B print function\n");
}

int main() {
    print(); // 编译器无法确定调用哪个print函数
    return 0;
}

2 命名空间定义

由上文可以看出当我们遇到这些问题的时候，可以通过更改名字的方法解决问题，更简单的我们可以使用namespace解决问题

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

在命名空间（Namespace）的定义中，可以包含多种类型的标识符和声明。

2.1命名空间内常见的内容：

2.1.1 变量

命名空间中可以定义变量，用于存储数据。例如：

namespace MyNamespace {
    int myVariable = 10;
}

2.1.2 函数

命名空间中可以定义函数，用于执行特定的操作。例如：

namespace MyNamespace {
    void myFunction() {
        // 函数实现
    }
}

2.1.3 类和结构体

命名空间中可以定义类和结构体，用于创建自定义的数据类型。例如：

namespace MyNamespace {
    class MyClass {
    public:
        void display() {
            std::cout << "Hello from MyClass" << std::endl;
        }
    };
}

2.1.4 枚举

命名空间中可以定义枚举类型，用于表示一组相关的常量。例如：

namespace MyNamespace {
    enum Color {
        RED,
        GREEN,
        BLUE
    };
}

2.1.5 类型别名

命名空间中可以定义类型别名，用于为现有类型创建新的名称。例如：

namespace MyNamespace {
    using MyInt = int;
}

2.1.6 常量

命名空间中可以定义常量，用于表示固定不变的值。例如：

namespace MyNamespace {
    const double PI = 3.14159;
}

2.1.7 嵌套命名空间

命名空间中可以定义嵌套的命名空间，用于进一步组织代码。例如：

namespace MyNamespace {
    namespace NestedNamespace {
        void nestedFunction() {
            // 函数实现
        }
    }
}

2.2 补充

同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。在同一个工程中，可以在多个文件中定义相同名称的命名空间，编译器会将它们合并成一个命名空间。这种特性允许开发者在不同的文件中扩展同一个命名空间，从而更好地组织和管理代码。

示例

假设我们有两个文件，file1.cpp 和 file2.cpp，它们都定义了相同名称的命名空间：

file1.cpp

#include <iostream>

namespace MyNamespace {
    void function1() {
        std::cout << "Function 1 from file1.cpp" << std::endl;
    }
}

file2.cpp

#include <iostream>

namespace MyNamespace {
    void function2() {
        std::cout << "Function 2 from file2.cpp" << std::endl;
    }
}

main.cpp

#include <iostream>

// 声明函数
namespace MyNamespace {
    void function1();
    void function2();
}

int main() {
    MyNamespace::function1();
    MyNamespace::function2();
    return 0;
}

在这个示例中，file1.cpp 和 file2.cpp 都定义了 MyNamespace 命名空间，并在其中添加了不同的函数。编译器会将这两个文件中的 MyNamespace 合并成一个命名空间，因此在 main.cpp 中可以访问 MyNamespace 中的所有函数。

编译和运行

运行程序时，输出将是：

Function 1 from file1.cpp
Function 2 from file2.cpp

通过这种方式，可以在不同的文件中扩展同一个命名空间，从而更好地组织代码，避免命名冲突。

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

3 命名空间使用

命名空间中成员该如何使用呢？比如

#include <stdio.h>

namespace learn 
{
    int a = 0;
    int b = 1;

}

int main() 
{

    printf("%d\n", a); 
    // 编译报错：error C2065: “a”: 未声明的标识符
    return 0;
}

在代码中，编译器会报错，因为在 main 函数中直接访问了命名空间 learn 中的变量 a，但没有指定命名空间。要解决这个问题，可以通过以下几种方法来正确访问命名空间中的成员。

方法1：使用作用域解析运算符 ::

你可以使用作用域解析运算符 :: 来访问命名空间中的变量和函数：

#include <stdio.h>

namespace learn {
    int a = 0;
    int b = 1;
}

int main() {
    printf("%d\n", learn::a); // 使用作用域解析运算符访问命名空间中的变量
    return 0;
}

方法2：使用 using 关键字

你可以使用 using 关键字将命名空间中的成员引入当前作用域：

#include <stdio.h>

namespace learn {
    int a = 0;
    int b = 1;
}

int main() {
    using learn::a; // 将命名空间中的变量引入当前作用域
    printf("%d\n", a);
    return 0;
}

方法3：使用 using namespace 指令

你可以使用 using namespace 指令将整个命名空间引入当前作用域：

#include <stdio.h>

namespace learn {
    int a = 0;
    int b = 1;
}

int main() {
    using namespace learn; // 将整个命名空间引入当前作用域
    printf("%d\n", a);
    return 0;
}

通过这些方法，可以正确访问命名空间中的成员，避免编译错误。