C++ 命名空间

C++ 中的命名空间

想象一个大型项目，有多位程序员贡献代码，或者你使用了多个第三方库。很可能代码的不同部分会定义同名的函数或类（例如，两个库可能都定义了一个名为 open() 的函数）。这会导致名称冲突（name collision 或 name clash），使得编译器无法确定你想要调用哪个 open() 函数。

命名空间（namespace）是 C++ 中专门设计用于解决此问题的一个特性。命名空间提供了一个声明区域（declarative region）或作用域（scope），将其中定义的名称（变量、函数、类等的名称）隔离开来。这可以防止在一个命名空间中定义的名称与在其他命名空间或全局作用域中定义的同名名称发生冲突。

可以将其类比为人的姓氏：两个名为“John”的人可以通过不同的姓氏区分开来（例如，John Smith 与 John Doe）。命名空间就像代码实体的姓氏。

定义命名空间

你可以使用 namespace 关键字创建一个命名空间，后跟一个名称，然后是一对花括号，其中包含属于该命名空间的声明和定义。

namespace MyLibrary {
    // Declarations and definitions within this namespace
    void print(const char* message); // Declaration
    int calculate(int x, int y);

    class Widget {
        // ...
    };

    const double PI = 3.14159;
}

访问命名空间成员

要从命名空间外部访问在该命名空间内定义的成员，必须使用作用域解析运算符 (::) 来限定该成员的名称。

NamespaceName::memberName

示例：

#include <iostream>

namespace First {
    void sayHello() {
        std::cout << "Hello from First namespace!" << std::endl;
    }
}

namespace Second {
    void sayHello() {
        std::cout << "Greetings from Second namespace!" << std::endl;
    }
}

int main() {
    // Call the function from the First namespace
    First::sayHello();

    // Call the function from the Second namespace
    Second::sayHello();

    // This would be ambiguous without qualification:
    // sayHello(); // Compile Error: Ambiguous call

    return 0;
}

编译并运行上述代码，将产生以下输出：

Hello from First namespace!
Greetings from Second namespace!

using 指令

重复输入命名空间名称可能会很繁琐。using namespace 指令告诉编译器，你打算在当前作用域中使用来自特定命名空间的名称。这使得你可以无需显式限定即可引用该命名空间的成员。

#include <iostream>

namespace First {
    void sayHello() { /* ... */ }
}
namespace Second {
    void sayHello() { /* ... */ }
}

// 将 First 命名空间的所有名称引入当前（全局）作用域
using namespace First;

int main() {
    // 由于 'using' 指令，现在调用 First::sayHello()
    sayHello();

    // 要调用 Second 的函数，仍然需要限定
    Second::sayHello();

    return 0;
}

注意： 应避免在头文件（.h、.hpp）的全局作用域中使用 using namespace 指令，尤其是 using namespace std;。这样做会将该命名空间的所有名称导入到包含此头文件的任何文件的作用域中，从而可能为使用你的头文件的用户带来意外的名称冲突。在源文件（.cpp）中或在函数等有限作用域内使用通常是可以接受的。

using 声明

一种更受控地将特定名称引入作用域的方式是 using 声明。它只使特定的成员无需限定即可访问。

using NamespaceName::memberName;

示例：

#include <iostream>

namespace MyOutput {
    void print(const std::string& s) { std::cout << "MyOutput: " << s << std::endl; }
    void debug(const std::string& s) { std::cerr << "DEBUG: " << s << std::endl; }
}

// 只将 MyOutput 中的 'print' 引入当前作用域
using MyOutput::print;

int main() {
    print("Hello using declaration!"); // 调用 MyOutput::print

    // 'debug' 需要限定
    MyOutput::debug("This needs qualification.");

    return 0;
}

当你只需要命名空间中少数几个特定名称时，这种方式通常比 using namespace 更受欢迎，因为它减少了意外名称冲突的可能性。

std 命名空间

整个 C++ 标准库（Standard Library）都定义在 std 命名空间中。这就是为什么标准库组件，如 cout、endl、string、vector 等，需要用 std:: 来限定（例如 std::cout），或者通过 using 声明或指令引入作用域。

#include <iostream> // Defines std::cout, std::endl
#include <string>   // Defines std::string

// 常见做法：
// 1. 显式限定（在头文件中最安全）：
int main_explicit() {
    std::string message = "Explicit qualification";
    std::cout << message << std::endl;
    return 0;
}

// 2. using 声明（适用于特定项）：
#include <vector> // Defines std::vector
using std::cout; // 只将 cout 引入作用域
using std::endl; // 只将 endl 引入作用域
using std::vector; // 只将 vector 引入作用域

int main_declaration() {
    vector<int> numbers = {1, 2, 3};
    cout << "Vector size: " << numbers.size() << endl;
    return 0;
}

// 3. using 指令（在 .cpp 文件或函数中可接受）：
#include <map> // Defines std::map

void process_data() {
    using namespace std; // 将 using 指令的作用域限制在此函数内
    map<string, int> scores;
    scores["Alice"] = 100;
    cout << "Alice's score: " << scores["Alice"] << endl;
}

嵌套命名空间

命名空间可以嵌套在其他命名空间中，以创建层次结构。

namespace Outer {
    int outerVar = 10;
    namespace Inner {
        void innerFunc() {
            std::cout << "Inside Inner::innerFunc. outerVar = " << outerVar << std::endl;
        }
        int innerVar = 20;
    }
}

int main() {
    Outer::Inner::innerFunc();
    std::cout << "Inner var: " << Outer::Inner::innerVar << std::endl;

    // using 声明用于嵌套成员
    using Outer::Inner::innerVar;
    std::cout << "Inner var via using: " << innerVar << std::endl;

    // using 指令用于嵌套命名空间
    using namespace Outer::Inner;
    innerFunc(); // 现在可以直接访问

    return 0;
}

自 C++17 起，嵌套命名空间可以更简洁地定义：

// C++17 风格的嵌套命名空间定义
namespace Outer::Inner::EvenDeeper {
    int deepVar = 30;
}

未命名（匿名）命名空间

你可以定义一个没有名称的命名空间：

namespace {
    // Internal linkage declarations/definitions
    int internalCounter = 0; // Behaves like a static global
    void utilityFunction() { /* ... */ } // Behaves like a static function
}

int main() {
    internalCounter++; // Accessible directly within this file
    utilityFunction(); // Accessible directly within this file
    // ...
}

在未命名命名空间中定义的实体具有内部链接性（internal linkage），这意味着它们只能在当前源文件（.cpp 文件）内访问。这是现代 C++ 中实现变量和函数的文件局部作用域（file-local scope）的首选方式，取代了旧版本中为此目的在全局作用域使用 static 关键字。