如何将std::mutex作为可选参数传入C++类构造函数？

编写测试用例时需要将std::mutex作为可选参数传入类构造函数（部分场景不需要互斥锁），尝试了两种std::optional写法均编译失败，也考虑过用默认参数但不确定正确声明方式，现寻求正确实现方案。

第一种错误写法分析 #

代码：

#include <iostream>
#include <optional>
#include <mutex>

class A {
    public:
        A(std::optional<std::mutex&> opLock);
};

A::A(std::optional<std::mutex&> opLock){
    
}

int main() {
    std::mutex lock;
    A a(lock);
}

编译错误核心原因：

• C++标准明确禁止std::optional存储引用类型，库内的static_assert(!is_reference_v<_Tp>)直接触发断言失败
• std::optional底层用union存储值，而C++不允许union包含引用类型，导致语法错误
• 额外问题：main中直接传lock无法隐式转换为std::optional<std::mutex&>，且构造函数定义时的访问权限出现误设

第二种错误写法分析 #

代码：

#include <iostream>
#include <optional>
#include <mutex>

class A {
    public:
        A(std::optional<std::mutex> opLock);
};

A::A(std::optional<std::mutex> opLock){
    
}

int main() {
    std::mutex lock;
    A a(lock);
}

编译错误核心原因：

• std::mutex是不可拷贝类型，std::optional<std::mutex>仅支持移动构造，但main中传入的是左值lock，无法隐式转换为std::optional<std::mutex>
• 不存在从std::mutex&到std::optional<std::mutex>的隐式转换规则，因此找不到匹配的构造函数

正确实现方案 #

方案1：使用std::optional<std::mutex*>（推荐） #

利用指针可拷贝、可空的特性，结合std::optional实现可选参数，默认值设为std::nullopt：

#include <iostream>
#include <optional>
#include <mutex>

class A {
public:
    explicit A(std::optional<std::mutex*> opLock = std::nullopt) 
        : m_mutex(opLock) {}

private:
    std::optional<std::mutex*> m_mutex;
};

int main() {
    std::mutex lock;
    A a1(&lock); // 传入互斥锁
    A a2;        // 不传入互斥锁
}

优点：实现简单，避免拷贝/移动std::mutex，符合指针使用习惯

方案2：使用指针默认参数替代std::optional #

直接用指针作为参数，默认值设为nullptr，无需引入std::optional：

#include <iostream>
#include <mutex>

class A {
public:
    explicit A(std::mutex* lock = nullptr) 
        : m_mutex(lock) {}

private:
    std::mutex* m_mutex;
};

int main() {
    std::mutex lock;
    A a1(&lock); // 传入互斥锁
    A a2;        // 不传入互斥锁
}

优点：代码更简洁，减少头文件依赖

方案3：使用std::optional<std::reference_wrapper<std::mutex>> #

如果需要保留引用语义，可借助std::reference_wrapper包装引用，使其能被std::optional存储：

#include <iostream>
#include <optional>
#include <mutex>
#include <functional> // 引入std::reference_wrapper

class A {
public:
    explicit A(std::optional<std::reference_wrapper<std::mutex>> opLock = std::nullopt) 
        : m_mutex(opLock) {}

private:
    std::optional<std::reference_wrapper<std::mutex>> m_mutex;
};

int main() {
    std::mutex lock;
    A a1(std::ref(lock)); // 必须用std::ref包装引用
    A a2;                 // 不传入互斥锁
}

注意：必须用std::ref或std::cref构造std::reference_wrapper，不能直接传原始引用

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