前言#

友元 (Friends)#

可以在一个命名空间的类定义内部声明一个友元函数或友元类。如果友元函数在首次声明时位于此友元声明中，并且没有在命名空间作用域内预先声明，那么该友元函数会被“注入”到包含该类的最近的封闭命名空间中。

// FriendInjection.cpp
#include <iostream>

namespace Me {
    class Us {
    public:
        Us() : data(10) {}
    private:
        int data;
        // 'you'函数在首次声明时作为Us的友元
        // 它将被注入到命名空间Me中
        friend void you(const Us& us_obj);
    };

    // 'you'函数现在是Me命名空间的成员，尽管它是在Us类内部作为友元声明的
    void you(const Us& us_obj) {
        std::cout << "Friend function Me::you() can access Us::data: " << us_obj.data << std::endl;
    }
} // namespace Me

// void you(); // 如果在这里声明，则Me::you会隐藏全局的you

int main() {
    Me::Us myUs;
    Me::you(myUs); // 调用注入到Me命名空间的you函数
    // you(myUs); // 如果没有全局的you或using声明/指令，这可能无法编译
    return 0;
}

作用域解析 (::)#

命名空间中的任何名称都可以通过作用域解析运算符::来显式指定，这与访问类静态成员或嵌套类型的方式类似。

// ScopeResolution.cpp
#include <iostream>

namespace X {
    class Y {
    public:
        static int i; // 静态成员声明
        void f();     // 成员函数声明
    };

    // 静态成员i的定义（属于X::Y）
    int Y::i = 0; // 初始化静态成员

    void Y::f() { // 成员函数f的定义
        std::cout << "X::Y::f() called. Y::i = " << i << std::endl;
    }

    class Z {
        int u, v, w; // 成员变量
    public:
        Z(int val);  // 构造函数
        void func(); // 普通成员函数
        int g();     // 另一个成员函数
    };

    // 构造函数Z的定义（属于X::Z）
    Z::Z(int val) : u(val), v(val), w(val) {
        std::cout << "X::Z::Z(" << val << ") constructor called." << std::endl;
    }

    // 成员函数g的定义（属于X::Z）
    int Z::g() {
        std::cout << "X::Z::g() called. u = " << u << std::endl;
        return u;
    }

    // 成员函数func的定义（属于X::Z）
    void Z::func() {
        std::cout << "X::Z::func() called." << std::endl;
        Y::i = 99; // 通过作用域解析访问X::Y的静态成员
        Y temp_y;
        temp_y.f(); // 调用X::Y::f()

        Z local_z_obj(1); // 创建另一个X::Z对象
        local_z_obj.g();
    }
} // namespace X

int main() {
    X::Y::i = 23; // 修改X::Y的静态成员
    X::Y y_instance;
    y_instance.f(); // 输出: X::Y::f() called. Y::i = 23

    X::Z z_instance(5); // 调用X::Z::Z(5)
    z_instance.func();
    z_instance.g();

    return 0;
}

注意，定义X::Y::i时，我们是在命名空间X的上下文中引用类Y的静态成员i。

与Java的package或C#的namespace相比，C++的namespace主要用于逻辑组织和避免名称冲突，其与文件系统的对应关系不像Java那样严格。访问控制主要由成员的访问修饰符（public, private, protected）决定，而非namespace本身。

using指令 (Using Directive)#

using指令允许我们将一个命名空间中的所有名称引入到当前作用域，从而可以直接使用这些名称而无需完全限定。语法为 using namespace NamespaceName;。

// NamespaceInt.h
#ifndef NAMESPACEINT_H
#define NAMESPACEINT_H
#include <iostream>
namespace Int {
    enum Sign { positive, negative };
    class Integer {
        int i;
        Sign s;
    public:
        Integer(int ii = 0) : i(ii), s(i >= 0 ? positive : negative) {}
        Sign getSign() const { return s; }
        void setSign(Sign newSign) { s = newSign; }
        void print() const {
             std::cout << (s == positive ? "+" : "-") << i << std::endl;
        }
    };
} // namespace Int
#endif // NAMESPACEINT_H
// NamespaceMath.h (假设内容)
#ifndef NAMESPACEMATH_H
#define NAMESPACEMATH_H
#include "NamespaceInt.h" // Math可能用到Int::Integer
namespace Math {
    // 假设Math也有一个名为Integer的类或变量
    class Integer { // 与Int::Integer同名
    public:
        void setSign(Int::Sign s) { /* ... */ }
        void print() const { /* ... */ }
    };
    // 假设Math有一个名为a的Integer对象
    // Integer a; // 如果直接定义，需要处理初始化
} // namespace Math
#endif // NAMESPACEMATH_H
// NamespaceOverriding1.cpp
#include "NamespaceInt.h" // 定义了 Int::Integer, Int::positive, Int::negative
#include "NamespaceMath.h"// 定义了 Math::Integer (可能与Int::Integer同名)
#include <iostream>

int main() {
    using namespace Int; // 引入Int命名空间的所有名称

    Integer a(10); // 编译器优先查找当前作用域的Integer，这里是Int::Integer
    a.setSign(negative); // 使用Int::negative
    a.print(); // 调用Int::Integer::print()

    // 如果Math命名空间也有一个名为 'a' 的变量或名为 'Integer' 的类型，
    // 且未使用using namespace Math; 则不会冲突。
    // 若使用了 using namespace Math; 且Math::Integer也存在，
    // 则对 Integer 的不限定使用可能导致歧义，或根据规则被隐藏。

    // 要明确使用Math命名空间中的同名实体，需要作用域解析：
    Math::Integer math_a_obj; // 明确使用Math::Integer
    // math_a_obj.setSign(Int::positive); // 假设Math::Integer有此方法
    // math_a_obj.print();
    std::cout << "Demonstration complete." << std::endl;
    return 0;
}

如果引入的多个命名空间中包含同名成员，或者引入的命名空间成员与当前作用域的局部声明同名，则可能产生歧义 (ambiguity) 或名称隐藏 (name hiding)。歧义通常在使用该名称时才会被编译器检测到。

// NamespaceCalculation.h (假设内容)
#ifndef NAMESPACECALCULATION_H
#define NAMESPACECALCULATION_H
#include "NamespaceInt.h"
namespace Calculation {
    using namespace Int; // Calculation内部也使用了Int命名空间
    // 假设Calculation定义了自己的divide函数
    Integer divide(Integer n1, Integer n2) { /* ... 实现 ... */ return Integer(0); }
} // namespace Calculation
#endif // NAMESPACECALCULATION_H
// OverridingAmbiguity.cpp
#include "NamespaceMath.h"      // 假设Math也有一个divide函数
#include "NamespaceCalculation.h" // Calculation有一个divide函数
#include <iostream>

// 假设NamespaceMath.h中也有:
// namespace Math {
//     Int::Integer divide(Int::Integer, Int::Integer) { /* Math的实现 */ return Int::Integer(0); }
// }

void s() {
    using namespace Math;        // 引入Math中的所有名称
    using namespace Calculation; // 引入Calculation中的所有名称

    Int::Integer i1(10), i2(2);
    // divide(i1, i2); // 编译错误：歧义！
                     // 编译器不知道是调用 Math::divide还是Calculation::divide
                     // (因为Calculation内部using了Int, 所以Calculation::divide参数也是Int::Integer)

    // 必须明确指定：
    Math::divide(i1, i2);
    Calculation::divide(i1, i2);
    std::cout << "Ambiguity example processed." << std::endl;
}

int main() {
    s();
    return 0;
}

即使从不产生歧义，使用using指令引入包含潜在命名冲突的多个命名空间也是可能的，但需谨慎。

using声明 (Using Declaration)#

using声明允许将命名空间中的特定名称引入到当前作用域。语法为 using NamespaceName::identifier;。与using指令不同，using声明更像是在当前作用域内进行了一次声明。这使得该名称在当前作用域内可以直接使用。如果与using指令同时存在，using声明通常具有更高的优先级，可以覆盖由using指令引入的同名实体。

// UsingDeclaration.h
#ifndef USINGDECLARATION_H
#define USINGDECLARATION_H
#include <iostream>

namespace U {
    inline void f() { std::cout << "U::f()" << std::endl; }
    inline void g() { std::cout << "U::g()" << std::endl; }
}
namespace V {
    inline void f() { std::cout << "V::f()" << std::endl; }
    inline void g() { std::cout << "V::g()" << std::endl; }
}

// 为UsingDeclaration2.cpp准备的命名空间Q
namespace Q {
    using U::f; // Q将U::f引入为其成员Q::f
    using V::g; // Q将V::g引入为其成员Q::g
    // Q本身没有定义新的f()或g()，而是“借用”了U和V的
}
#endif // USINGDECLARATION_H
// UsingDeclaration1.cpp
#include "UsingDeclaration.h"

void h_func() { // Renamed from h to avoid conflict if h is defined elsewhere
    using namespace U; // using指令：引入U::f和U::g
    using V::f;        // using声明：明确引入V::f

    f(); // 调用 V::f()，因为using声明 V::f 覆盖了来自 using namespace U 的 U::f
    U::f(); // 必须完全限定才能调用 U::f()
    g(); // 调用 U::g() (来自 using namespace U)
    V::g(); // 必须完全限定才能调用 V::g()
}
int main() {
    h_func();
    return 0;
}
// UsingDeclaration2.cpp
#include "UsingDeclaration.h" // Q中包含了 using U::f; 和 using V::g;

void m_func() { // Renamed from m
    using namespace Q; // 引入Q中的所有名称 (即Q::f 和 Q::g)

    f(); // 调用 Q::f，而Q::f是U::f的using声明，所以实际调用 U::f()
    g(); // 调用 Q::g，而Q::g是V::g的using声明，所以实际调用 V::g()
}

int main() {
    m_func();
    return 0;
}

一个using声明将特定命名从一个命名空间引入到当前作用域。这意味着你可以在不使用完全限定名称的情况下引用该命名。如果多个命名空间中存在同名函数，using声明可以明确指定使用哪一个。当与using指令结合使用时，using声明通常能覆盖由using指令引入的同名实体，从而解决潜在的歧义或为特定名称指定优先级。它不会引起重复定义，因为它只是让一个已存在的名称在当前作用域可见。