C++基础语法简单介绍(四) -- 其他特性

// 声明一个命名空间
namespace MyNamespace {
    int value = 42;  // 命名空间中的变量

    void print() {   // 命名空间中的函数
        std::cout << "Value: " << value << std::endl;
    }

    class MyClass {  // 命名空间中的类
    public:
        void greet() {
            std::cout << "Hello from MyClass!" << std::endl;
        }
    };
}

int main() {
    // 使用作用域解析运算符 `::` 访问命名空间中的成员
    std::cout << MyNamespace::value << std::endl;  // 输出命名空间中的变量，42
    MyNamespace::print();  // 调用命名空间中的函数，输出 Value: 42

    // 创建命名空间中的类对象并调用成员函数
    MyNamespace::MyClass obj;
    obj.greet();  // 输出 Hello from MyClass!

    return 0;
}

int main() {
    // 使用 `using` 声明将命名空间中的某个成员引入当前作用域
    using MyNamespace::value;  // 引入变量
    using MyNamespace::print;  // 引入函数

    std::cout << value << std::endl;  // 输出引入的变量，42
    print();  // 调用引入的函数，输出 Value: 42

    return 0;
}

int main() {
    // 使用 `using namespace` 指令将整个命名空间引入当前作用域
    using namespace MyNamespace;

    std::cout << value << std::endl;  // 输出命名空间中的变量，42
    print();  // 调用命名空间中的函数，输出 Value: 42

    // 创建命名空间中的类对象并调用成员函数
    MyClass obj;
    obj.greet();  // 输出 Hello from MyClass!

    return 0;
}

// 嵌套命名空间的示例
namespace Outer {
    int value = 10;  // 外层命名空间中的变量

    namespace Inner {
        int value = 20;  // 内层命名空间中的变量
    }
}

int main() {
    // 访问嵌套命名空间中的成员
    std::cout << Outer::value << std::endl;         // 输出外层命名空间变量，10
    std::cout << Outer::Inner::value << std::endl;  // 输出内层命名空间变量，20

    return 0;
}

int main() {
    int originalValue = 1, secondValue = 2;

    // 示例1: 最简单的 lambda - 不捕获外部变量，无参数
    // - 仅返回固定值
    // - 适用于不需要外部状态的简单函数
    auto simpleLambda = []() { return 42; };
    std::cout << "simpleLambda() = " << simpleLambda() << std::endl;  // 输出：42
    
    // 示例2: 纯函数式 lambda - 不捕获外部变量，接收参数
    // - 类似普通函数，结果只依赖输入参数
    // - 适用于通用的计算功能
    auto addNumbers = [](int x, int y) { return x + y; };
    std::cout << "addNumbers(3, 4) = " << addNumbers(3, 4) << std::endl;  // 输出：7
    
    // 示例3: 值捕获 lambda - 复制外部变量的值
    // - 捕获时创建外部变量的副本
    // - 外部变量的后续修改不会影响 lambda 内的值
    auto valueCaptured = [originalValue](int x) { return originalValue + x; };
    originalValue = 10;  // 不影响 lambda 中的值
    std::cout << "valueCaptured(5) = " << valueCaptured(5) << std::endl;  // 输出：6 (1 + 5)
    
    // 示例4: 引用捕获 lambda - 使用外部变量的引用
    // - 直接使用外部变量的内存地址
    // - 外部变量的修改会影响 lambda 的结果
    auto referenceCaptured = [&originalValue](int x) { return originalValue + x; };
    originalValue = 10;  // 会影响 lambda 中的值
    std::cout << "referenceCaptured(5) = " << referenceCaptured(5) << std::endl;  // 输出：15 (10 + 5)
    
    // 示例5: 全值捕获 lambda - 复制所有外部变量
    // - 使用 [=] 自动捕获所有使用的外部变量
    // - 创建所有变量的副本
    auto captureAllByValue = [=](int x) { return originalValue + secondValue + x; };
    originalValue = 20;  // 不影响 lambda
    secondValue = 30;    // 不影响 lambda
    std::cout << "captureAllByValue(5) = " << captureAllByValue(5) << std::endl;  // 输出：17 (10 + 2 + 5)
    
    // 示例6: 全引用捕获 lambda - 引用所有外部变量
    // - 使用 [&] 自动以引用方式捕获所有使用的外部变量
    // - 所有外部变量的修改都会影响 lambda
    auto captureAllByRef = [&](int x) { return originalValue + secondValue + x; };
    std::cout << "captureAllByRef(5) = " << captureAllByRef(5) << std::endl;  // 输出：55 (20 + 30 + 5)
    
    // 示例7: 混合捕获 lambda - 同时使用值捕获和引用捕获
    // - 可以精确控制每个变量的捕获方式
    // - 适用于需要不同捕获方式的场景
    auto mixedCapture = [originalValue, &secondValue](int x) { return originalValue + secondValue + x; };
    originalValue = 100;  // 不影响 lambda 中的值
    secondValue = 200;    // 会影响 lambda 中的值
    std::cout << "mixedCapture(5) = " << mixedCapture(5) << std::endl;  // 输出：225 (20 + 200 + 5)
}