派生std::unique_lock时遇强制复制构造函数问题（含虚析构）

这个问题的核心在于**std::unique_lock是不可复制的**，而你的派生类A在添加虚析构函数后，某些场景下会触发编译器尝试生成复制构造函数，进而引发冲突。

为什么会报错？ #

先看你的代码示例：

#include <iostream>
#include <mutex>
#include <string>
template<class T>
class A : public std::unique_lock<T> {
public:
    template<typename... Args>
    A(const std::string name, Args&&... args) : name_(name), std::unique_lock<T>(args...) { }
    virtual ~A() {} // 若存在该虚析构函数时出现强制复制构造函数问题
private:
    std::string name_;
};

std::unique_lock的设计目标是独占锁的所有权，因此它的复制构造函数和复制赋值运算符被显式标记为删除（= delete）。当你的类A添加了虚析构函数后，如果代码中出现复制A对象的操作（比如按值传递A、将A存入需要复制语义的容器等），编译器会尝试为A合成一个复制构造函数。这个合成的函数会自动调用基类std::unique_lock的复制构造函数，但基类的该函数已经被删除，因此编译会直接报错。

哪怕你没有主动写复制代码，某些隐式场景也可能触发这个问题——比如当A作为多态基类被使用时，编译器的优化或检查逻辑也可能尝试生成复制构造函数。

解决方法 #

方法1：显式禁止复制操作 #

直接在A类中显式删除复制构造和复制赋值运算符，和基类保持一致，从根源上避免编译器合成相关函数：

template<class T>
class A : public std::unique_lock<T> {
public:
    template<typename... Args>
    A(const std::string name, Args&&... args) : name_(name), std::unique_lock<T>(args...) { }
    virtual ~A() {}

    // 显式禁止复制，与基类行为对齐
    A(const A&) = delete;
    A& operator=(const A&) = delete;

    // 可选：允许移动操作（unique_lock支持移动，A也可以继承这个特性）
    A(A&&) = default;
    A& operator=(A&&) = default;
private:
    std::string name_;
};

这样编译器就不会再尝试生成复制构造函数，也就不会触发和基类的冲突。

方法2：改用组合而非继承（更推荐） #

std::unique_lock并不是设计用来被继承的标准库类（它本身没有虚析构函数，你自行添加的虚析构虽然能解决多态删除问题，但继承非设计为基类的标准库类通常不是最佳实践）。改用组合方式，让A包含一个std::unique_lock成员，更符合面向对象"has-a"的设计逻辑：

#include <iostream>
#include <mutex>
#include <string>
#include <utility> // 用于std::forward

template<class T>
class A {
public:
    template<typename... Args>
    A(const std::string name, Args&&... args) 
        : name_(name), lock_(std::forward<Args>(args)...) { }
    
    virtual ~A() = default;

    // 按需转发unique_lock的常用成员函数
    void lock() { lock_.lock(); }
    void unlock() { lock_.unlock(); }
    bool try_lock() { return lock_.try_lock(); }
    bool owns_lock() const { return lock_.owns_lock(); }

    // 显式禁止复制
    A(const A&) = delete;
    A& operator=(const A&) = delete;

    // 允许移动
    A(A&&) = default;
    A& operator=(A&&) = default;

private:
    std::string name_;
    std::unique_lock<T> lock_;
};

这种方式更安全，避免了继承带来的潜在问题，同时也能完全实现你需要的功能——给锁附加一个名字，同时拥有unique_lock的所有特性。

总结 #

问题的本质是不可复制的基类与编译器合成复制构造函数的冲突，虚析构只是触发这个问题的场景之一。通过显式禁止复制，或者改用组合设计，都能解决这个问题，其中组合方式是更符合C++设计原则的选择。

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