C++模板包装类条件禁用特殊成员函数失效问题排查

初始实现 #

我在编写一个支持条件性禁用四类特殊成员函数（拷贝构造、移动构造、拷贝赋值、移动赋值）的包装类，初始实现代码如下：

#include <cstdint>
#include <type_traits>

enum class special_member : uint8_t {
    copy_ctor, move_ctor,
    copy_asgn, move_asgn
};

template<typename MemberType, special_member...>
struct _disabled_wrapper {
public:
    constexpr _disabled_wrapper(MemberType type) : _type(type) {}

public:
    constexpr MemberType& unwrapped() { return _type; }
    constexpr const MemberType& unwrapped() const { return _type; }

private:
    MemberType _type;
};

template<typename MemberType, special_member ... Disables>
struct _disabled_wrapper<MemberType, special_member::copy_ctor, Disables...> 
{
private:
    using _parent_t = _disabled_wrapper<MemberType, Disables...>;

public:
    constexpr _disabled_wrapper(const _parent_t& parent) : _parent(parent) {}

    constexpr _disabled_wrapper(const _disabled_wrapper&) = delete;
    constexpr _disabled_wrapper(_disabled_wrapper&&) = default;
    constexpr _disabled_wrapper& operator=(const _disabled_wrapper&) = default;
    constexpr _disabled_wrapper& operator=(_disabled_wrapper&&) = default;

public:
    constexpr MemberType& unwrapped() { return _parent.unwrapped(); }
    constexpr const MemberType& unwrapped() const { return _parent.unwrapped(); }

private:
    _parent_t _parent;
};

template<typename MemberType, special_member ... Disables>
struct _disabled_wrapper<MemberType, special_member::move_ctor, Disables...>
{
public:
    using _parent_t = _disabled_wrapper<MemberType, Disables...>;

public:
    constexpr _disabled_wrapper(const _parent_t& parent) : _parent(parent) {}

    constexpr _disabled_wrapper(const _disabled_wrapper&) = default;
    constexpr _disabled_wrapper(_disabled_wrapper&&) = delete;
    constexpr _disabled_wrapper& operator=(const _disabled_wrapper&) = default;
    constexpr _disabled_wrapper& operator=(_disabled_wrapper&&) = default;

public:
    constexpr MemberType& unwrapped() { return _parent.unwrapped(); }
    constexpr const MemberType& unwrapped() const { return _parent.unwrapped(); }

private:
    _parent_t _parent;
};

template<typename MemberType, special_member ... Disables>
struct _disabled_wrapper<MemberType, special_member::copy_asgn, Disables...>
{
private: 
    using _parent_t = _disabled_wrapper<MemberType, Disables...>;

public:
    constexpr _disabled_wrapper(const _parent_t& parent) : _parent(parent) {}

    constexpr _disabled_wrapper(const _disabled_wrapper&) = default;
    constexpr _disabled_wrapper(_disabled_wrapper&&) = default;
    constexpr _disabled_wrapper& operator=(const _disabled_wrapper&) = delete;
    constexpr _disabled_wrapper& operator=(_disabled_wrapper&&) = default;

public:
    constexpr MemberType& unwrapped() { return _parent.unwrapped(); }
    constexpr const MemberType& unwrapped() const { return _parent.unwrapped(); }

private:
    _parent_t _parent;
};

template<typename MemberType, special_member ... Disables>
struct _disabled_wrapper<MemberType, special_member::move_asgn, Disables...>
{
private:
    using _parent_t = _disabled_wrapper<MemberType, Disables...>;

public:
    constexpr _disabled_wrapper(const _parent_t& parent) : _parent(parent) {}

    constexpr _disabled_wrapper(const _disabled_wrapper&) = default;
    constexpr _disabled_wrapper(_disabled_wrapper&&) = default;
    constexpr _disabled_wrapper& operator=(const _disabled_wrapper&) = default;
    constexpr _disabled_wrapper& operator=(_disabled_wrapper&&) = delete;

public:
    constexpr MemberType& unwrapped() { return _parent.unwrapped(); }
    constexpr const MemberType& unwrapped() const { return _parent.unwrapped(); }

private:
    _parent_t _parent;
};

异常现象 #

上述代码在单特殊成员禁用场景下运行正常，但在三类模板参数组合下出现不符合预期的行为：

• <move_ctor, move_asgn>
• <copy_ctor, move_asgn>
• <copy_ctor, move_ctor, move_asgn>

测试代码如下：

int main() {
    using type = _disabled_wrapper<int, special_member::move_ctor, special_member::move_asgn>;

    // 正常通过，证明内部成员类型的移动赋值已按预期删除
    static_assert(std::is_move_assignable_v<type::_parent_t> == false); 
    // 断言失败，外层类型仍可移动赋值
    static_assert(std::is_move_assignable_v<type> == false); 

    return 0;
}

根据C++标准规则：

类T的隐式声明或显式defaulted的移动赋值运算符，在T存在无法移动赋值（移动赋值为deleted、不可访问或有歧义）的非静态数据成员时，应当被定义为deleted；被删除的隐式声明移动赋值运算符会被重载决议忽略。

按照规则外层类的移动赋值理应被删除，和实际运行结果矛盾。

异常现象完全符合C++标准规则，不存在编译器或标准实现偏差，核心问题是对隐式删除特殊成员的重载规则理解不到位：

1. 外层类的移动赋值运算符确实被隐式删除了：在move_ctor偏特化中声明的operator=(_disabled_wrapper&&) = default，由于成员_parent的移动赋值已被删除，该运算符会被编译器隐式定义为deleted。
2. 隐式删除的移动赋值运算符不参与重载决议：这正是标准规则中明确说明的行为，当重载决议查找赋值运算符候选时，会直接跳过这个被隐式删除的移动赋值，转而匹配其他可行函数。
3. 拷贝赋值运算符成为可行候选：外层类的拷贝赋值运算符被显式声明为default，签名为operator=(const _disabled_wrapper&)，右值可以合法绑定到const左值引用，因此右值赋值表达式会成功匹配到拷贝赋值，导致std::is_move_assignable_v<type>返回true，断言失败。
4. 递归层叠偏特化的设计本身存在缺陷：这种实现依赖嵌套成员触发外层特殊成员的隐式删除，所有多成员禁用的组合都会触发隐式删除特殊成员被重载决议跳过的问题，无法实现预期的禁用效果。

放弃递归偏特化的实现思路，直接在主模板中根据禁用参数列表显式声明并删除对应的特殊成员即可，不需要编写任何偏特化，也不会出现组合爆炸问题。
C++20及以上版本可以直接用requires约束实现，逻辑清晰代码简洁：

#include <cstdint>
#include <type_traits>
#include <utility>

enum class special_member : uint8_t {
    copy_ctor, move_ctor,
    copy_asgn, move_asgn
};

// 辅助变量：判断指定特殊成员是否在禁用列表中
template<special_member F, special_member... Fs>
constexpr bool contains_special = ((F == Fs) || ...);

template<typename MemberType, special_member... Disables>
struct disabled_wrapper {
private:
    MemberType _value;
public:
    constexpr disabled_wrapper(MemberType v) : _value(std::move(v)) {}

    // 拷贝构造
    disabled_wrapper(const disabled_wrapper&) requires (!contains_special<special_member::copy_ctor, Disables...>) = default;
    disabled_wrapper(const disabled_wrapper&) requires (contains_special<special_member::copy_ctor, Disables...>) = delete;

    // 移动构造
    disabled_wrapper(disabled_wrapper&&) requires (!contains_special<special_member::move_ctor, Disables...>) = default;
    disabled_wrapper(disabled_wrapper&&) requires (contains_special<special_member::move_ctor, Disables...>) = delete;

    // 拷贝赋值
    disabled_wrapper& operator=(const disabled_wrapper&) requires (!contains_special<special_member::copy_asgn, Disables...>) = default;
    disabled_wrapper& operator=(const disabled_wrapper&) requires (contains_special<special_member::copy_asgn, Disables...>) = delete;

    // 移动赋值
    disabled_wrapper& operator=(disabled_wrapper&&) requires (!contains_special<special_member::move_asgn, Disables...>) = default;
    disabled_wrapper& operator=(disabled_wrapper&&) requires (contains_special<special_member::move_asgn, Disables...>) = delete;

    constexpr MemberType& unwrapped() { return _value; }
    constexpr const MemberType& unwrapped() const { return _value; }
};

// 测试用例
int main() {
    // 测试禁用move_ctor + move_asgn的场景
    using type1 = disabled_wrapper<int, special_member::move_ctor, special_member::move_asgn>;
    static_assert(!std::is_move_constructible_v<type1>);
    static_assert(!std::is_move_assignable_v<type1>);
    static_assert(std::is_copy_constructible_v<type1>);
    static_assert(std::is_copy_assignable_v<type1>);

    // 测试禁用copy_ctor + move_asgn的场景
    using type2 = disabled_wrapper<int, special_member::copy_ctor, special_member::move_asgn>;
    static_assert(!std::is_copy_constructible_v<type2>);
    static_assert(!std::is_move_assignable_v<type2>);
    static_assert(std::is_move_constructible_v<type2>);
    static_assert(std::is_copy_assignable_v<type2>);

    // 测试禁用copy_ctor + move_ctor + move_asgn的场景
    using type3 = disabled_wrapper<int, special_member::copy_ctor, special_member::move_ctor, special_member::move_asgn>;
    static_assert(!std::is_copy_constructible_v<type3>);
    static_assert(!std::is_move_constructible_v<type3>);
    static_assert(!std::is_move_assignable_v<type3>);
    static_assert(std::is_copy_assignable_v<type3>);

    // 测试全默认场景
    using type4 = disabled_wrapper<int>;
    static_assert(std::is_copy_constructible_v<type4>);
    static_assert(std::is_move_constructible_v<type4>);
    static_assert(std::is_copy_assignable_v<type4>);
    static_assert(std::is_move_assignable_v<type4>);

    return 0;
}

如果需要兼容C++17版本，可以将requires约束替换为std::enable_if_t的SFINAE约束，核心逻辑不变。

注：原实现中以下划线开头的标识符（如_disabled_wrapper、_parent_t）在全局命名空间下属于C++标准保留给实现的标识符，存在未定义行为风险，修复时已调整命名。

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