如何根据函数参数创建std::unique_lock或std::shared_lock并解决作用域问题？

你遇到的核心问题很明确：std::unique_lock<std::shared_mutex>和std::shared_lock<std::shared_mutex>是完全独立的类型，没法用同一个变量来存储它们，所以直接赋值的写法肯定编译不过。下面给你几种实用的解决方案，从简单到灵活都有：

方案1：用分支封装锁与任务逻辑（最简洁） #

这是最直接的写法，不需要额外的类型包装，直接在对应的锁作用域里执行任务即可：

#include <shared_mutex>

// 先把任务逻辑抽成独立函数，避免代码重复
void doActualTask() {
    // 这里写你的任务代码
}

void function(bool check, std::shared_mutex& mutex) {
    if (check) {
        // 独占锁：写操作时用
        std::unique_lock<std::shared_mutex> lock(mutex);
        doActualTask();
    } else {
        // 共享锁：读操作时用
        std::shared_lock<std::shared_mutex> lock(mutex);
        doActualTask();
    }
}

重要提醒：你原来代码里的lock.lock()是多余的！这两种锁的构造函数默认会自动上锁（除非你传入std::defer_lock参数），手动调用会导致重复上锁，触发未定义行为，一定要去掉。

方案2：用std::variant存储动态锁类型（C++17及以上） #

如果你的代码结构不允许拆分分支（比如锁创建和任务执行不在同一个代码块），可以用C++17引入的std::variant来存储两种不同的锁对象：

#include <variant>
#include <shared_mutex>

void doActualTask() {
    // 任务逻辑
}

void function(bool check, std::shared_mutex& mutex) {
    // 定义一个可以容纳两种锁类型的variant
    std::variant<std::unique_lock<std::shared_mutex>, std::shared_lock<std::shared_mutex>> lock;

    if (check) {
        lock = std::unique_lock<std::shared_mutex>(mutex);
    } else {
        lock = std::shared_lock<std::shared_mutex>(mutex);
    }

    // 锁已经持有，执行任务
    doActualTask();
}

variant会自动管理内部锁对象的生命周期：当你给它赋值新的锁时，旧的锁会被销毁（自动解锁），新的锁会被创建并上锁。只要variant对象存在，锁就会保持持有状态，直到函数结束时variant被销毁。

方案3：用模板函数复用锁逻辑（适合复杂场景） #

如果需要在多个地方复用“根据条件选锁执行任务”的逻辑，可以把锁类型作为模板参数封装成通用函数：

#include <shared_mutex>

void doActualTask() {
    // 任务逻辑
}

template<typename LockType>
void runWithLock(std::shared_mutex& mutex) {
    LockType lock(mutex);
    doActualTask();
}

void function(bool check, std::shared_mutex& mutex) {
    if (check) {
        runWithLock<std::unique_lock<std::shared_mutex>>(mutex);
    } else {
        runWithLock<std::shared_lock<std::shared_mutex>>(mutex);
    }
}

这种方式的好处是把锁的逻辑和任务逻辑完全分离，后续如果需要调整锁的类型（比如换成其他互斥量的锁），只需要修改模板参数即可。

内容的提问来源于stack exchange，提问作者Ahmet Tanakol