【C++高级主题】命令空间(四)：命名空间成员的使用

namespace Math {
    int add(int a, int b) { return a + b; }
    class Vector2D { /* 实现 */ };
}

using 命名空间::成员名;

using Math::add;  // 引入Math命名空间的add函数
int result = add(3, 5);  // 直接使用add，无需Math::前缀

#include <iostream>

namespace Math {
    int add(int a, int b) { return a + b; }
}

using Math::add;  // 全局作用域的using声明

int main() {
    std::cout << add(2, 3) << std::endl;  // 输出5（直接使用add）
    return 0;
}

namespace Math {
    int multiply(int a, int b) { return a * b; }
}

void calculate() {
    using Math::multiply;  // 局部作用域的using声明（仅在calculate函数内有效）
    int product = multiply(4, 5);  // 正确：可直接使用multiply
}

int main() {
    // multiply(4,5);  错误：multiply不在当前作用域（using声明仅在calculate函数内有效）
    calculate();
    return 0;
}

namespace Shapes {
    class Rectangle {
    public:
        void draw() { std::cout << "Drawing a rectangle\n"; }
    };
}

class FilledRectangle : public Shapes::Rectangle {
public:
    using Shapes::Rectangle::draw;  // 引入基类的draw函数到当前类作用域
    void fill() { draw(); /* 使用基类的draw */ }
};

int main() {
    FilledRectangle rect;
    rect.draw();  // 直接调用基类的draw（通过using声明引入）
    return 0;
}

namespace Math { int add(int a, int b) { return a + b; } }
int add(double a, double b) { return static_cast<int>(a + b); }  // 全局作用域的add函数

// using Math::add;  错误：全局作用域已有同名函数add（参数类型不同仍算冲突）

namespace Math {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
}

using Math::add;  // 引入两个重载版本的add函数

int main() {
    add(1, 2);      // 调用int版本
    add(1.5, 2.5);  // 调用double版本
    return 0;
}

namespace 别名 = 原命名空间;

namespace Company {
    namespace Product {
        namespace Module {
            namespace Algorithm {
                int compute(int x) { return x * 2; }
            }
        }
    }
}

namespace Algo = Company::Product::Module::Algorithm;  // 创建别名Algo

int main() {
    int result = Algo::compute(10);  // 等价于Company::Product::Module::Algorithm::compute(10)
    return 0;
}

namespace MathLib_v2_3 { /* 新功能实现 */ }
namespace Math = MathLib_v2_3;  // 别名Math指向当前版本

// 未来升级到v3_0时，只需修改别名指向即可，调用代码无需改动

template <typename T>
namespace Container {
    class Vector { /* 实现 */ };
}

namespace IntVector = Container<int>::Vector;  // 为模板实例创建别名

using namespace 命名空间;

namespace Math {
    int add(int a, int b) { return a + b; }
    int subtract(int a, int b) { return a - b; }
}

using namespace Math;  // 引入Math的所有成员到全局作用域

int main() {
    std::cout << add(5, 3) << std::endl;     // 输出2（直接使用add）
    std::cout << subtract(5, 3) << std::endl;  // 输出2（直接使用subtract）
    return 0;
}

namespace Tools {
    void log() { std::cout << "Logging...\n"; }
}

void test() {
    using namespace Tools;  // 局部作用域的using指示
    log();  // 正确：Tools::log被引入当前作用域
}

int main() {
    // log();  错误：using指示仅在test函数内有效
    Tools::log();  // 正确：显式使用命名空间限定符
    return 0;
}

namespace Math { int add(int a, int b) { return a + b; } }
int add(double a, double b) { return static_cast<int>(a + b); }  // 全局add函数

using namespace Math;  // 引入Math::add到全局作用域

int main() {
    add(1, 2);      // 错误：二义性（Math::add(int, int) 与全局add(double, double)）
    add(1.5, 2.5);  // 错误：同样二义性
    return 0;
}

namespace A { int func() { return 1; } }
namespace B { int func() { return 2; } }

using namespace A;
using namespace B;

int main() {
    func();  // 错误：无法确定调用A::func还是B::func
    return 0;
}

#include <iostream>
using namespace std;  // 常见于示例代码

int main() {
    cout << "Hello, World!" << endl;  // 无需std::前缀
    return 0;
}

void processData() {
    using namespace DataUtils;  // 仅在processData函数内有效
    // 大量使用DataUtils的成员，简化代码
}

namespace VeryLongNamespaceName { /* 大量成员 */ }
namespace VL = VeryLongNamespaceName;  // 别名

using namespace VL;  // 引入VL的所有成员（即原命名空间的成员）

// 推荐方式：使用using声明引入常用成员
#include <vector>
#include <string>

using std::vector;  // 引入vector
using std::string;  // 引入string

void process() {
    vector<string> names;  // 无需std::前缀
    // ...
}

// 不推荐：全局using namespace std（可能引发冲突）
// using namespace std;

// math_utils.h（头文件）
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

namespace MathUtils {
    int add(int a, int b);  // 接口声明
    int subtract(int a, int b);  // 接口声明
}

#endif

// math_utils.cpp（源文件）
#include "math_utils.h"

namespace MathUtils {
    namespace Internal {  // 内部实现命名空间
        int validate(int x) { /* 校验逻辑 */ }
    }

    int add(int a, int b) {
        int a_valid = Internal::validate(a);
        int b_valid = Internal::validate(b);
        return a_valid + b_valid;
    }

    using Internal::validate;  // 仅在源文件内部使用validate（无需暴露给头文件）
}

// 团队A的命名空间
namespace TeamA::FeatureX::V1 { /* 实现 */ }

// 团队B的代码中需要调用TeamA的功能
namespace TA_FeatureX = TeamA::FeatureX::V1;  // 别名简化

using TA_FeatureX::initialize;  // 引入常用接口
using TA_FeatureX::shutdown;

void teamB_task() {
    initialize();  // 直接使用TeamA的接口
    // ...
    shutdown();
}