C++ 11/17/20 新特性：智能指针、lambda 表达式与概念（Concepts）应用

1. 智能指针：告别裸指针的智慧选择

C++11引入的智能指针通过RAII机制实现了内存自动管理，开发者终于可以放心告别手动delete时代

1.1 unique_ptr：专属所有权的轻量守卫

// C++17技术栈示例
#include <memory>

void process_resource() {
    // 创建并独占管理文件资源
    auto file = std::make_unique<FILE>(fopen("data.txt", "r"));
    
    // 所有权转移演示（移动语义）
    auto transfer_ownership = [](std::unique_ptr<FILE> f) {
        // 此处获得文件所有权
        if(f) fclose(f.get());
    };
    transfer_ownership(std::move(file));
    
    // file在此处已是空指针，避免悬垂指针
}

1.2 shared_ptr与weak_ptr：复杂场景的黄金组合

// C++20技术栈示例
class DeviceController;
class SensorModule {
    std::shared_ptr<DeviceController> controller;
};

class DeviceController {
    std::weak_ptr<SensorModule> sensor;  // 打破循环引用的关键
};

void setup_system() {
    auto controller = std::make_shared<DeviceController>();
    auto sensor = std::make_shared<SensorModule>();
    
    sensor->controller = controller;
    controller->sensor = sensor;  // 使用weak_ptr避免循环引用
}

2. Lambda表达式：函数式编程的瑞士军刀

从C++11到C++20的演进中，lambda表达式不断增强，成为了现代C++的标准配置

2.1 基础语法与捕获机制

// C++14技术栈通用示例
void filter_data() {
    int threshold = 42;
    std::vector<int> data{35, 47, 12, 68};
    
    // 值捕获与引用捕获混合使用
    auto smart_filter = [=, &data](auto x) mutable {
        threshold += 5;  // mutable允许修改值捕获变量
        return x > threshold && data.size() > 0;
    };
    
    std::erase_if(data, smart_filter);  // C++20新算法
}

2.2 类型推导与模板增强

// C++20技术栈模板应用
auto create_processor(auto factor) {
    // 泛型lambda参数推导
    return [factor]<typename T>(T param) -> decltype(auto) {
        if constexpr(std::is_floating_point_v<T>) {
            return param * factor;
        } else {
            return param + factor;
        }
    };
}

void run_calculation() {
    auto proc = create_processor(3.14);
    std::cout << proc(5) << "\n";    // 输出8.14
    std::cout << proc(2.718) << "\n";// 输出8.53852
}

3. Concepts：模板编程的革命性突破

C++20引入的Concepts机制，让模板编程摆脱了"SFINAE魔法"，走向了类型安全的新纪元

3.1 基础概念定义与应用

// C++20技术栈标准示例
template<typename T>
concept NumericType = requires(T a, T b) {
    { a + b } -> std::same_as<T>;
    { a * b } -> std::convertible_to<T>;
    std::is_arithmetic_v<T>;
};

template<NumericType T>
T power_sum(T base, int exponent) {
    T result = 1;
    for(int i=0; i<exponent; ++i) {
        result = result * base + base;
    }
    return result;
}

3.2 嵌套约束与概念组合

// C++20高级用法示例
template<typename T>
concept OutputDevice = requires(T device, std::string msg) {
    device.display(msg);
    { device.is_ready() } -> std::convertible_to<bool>;
};

template<typename T>
concept Loggable = requires(T item) {
    { item.to_string() } -> std::convertible_to<std::string>;
};

void system_log(Loggable auto item, OutputDevice auto& output) {
    if(output.is_ready()) {
        output.display(item.to_string());
    }
}

4. 智能指针与Lambda的默契配合

实际工程中这三项技术往往珠联璧合，共同构建高效安全的现代C++系统

// C++17异步场景应用
void start_async_task() {
    auto task = std::make_shared<BackgroundTask>();
    
    // Lambda捕获智能指针管理生命周期
    auto callback = [weak_task = std::weak_ptr(task)] {
        if(auto shared_task = weak_task.lock()) {
            shared_task->complete();
        }
    };
    
    // 使用标准线程模拟异步调用
    std::thread worker([callback] {
        // 执行耗时操作
        callback(); 
    });
    worker.detach();
}

5. 应用场景与选型指南

5.1 典型案例分析

• 智能指针：游戏引擎对象生命周期管理
• Lambda：GUI事件处理、并行算法回调
• Concepts：数学库泛型约束、序列化框架

5.2 技术优势对照表

5.3 专家使用建议

• 智能指针陷阱：避免原始指针参数传递
• Lambda优化点：捕获列表的最小化原则
• Concepts设计：逐步细化接口约束

6. 技术演进展望

随着C++23标准的推进，这三项特性正在持续进化：

• 智能指针：可能支持自定义删除器类型推导
• Lambda：有望支持显式模板参数声明
• Concepts：标准化更多基础概念库类型