std::is_copy_assignable与boost::optional的异常行为及解决方案

问题现象 #

当自定义类型Bar的拷贝构造函数被删除后：

• std::optional<Bar>的std::is_copy_assignable_v能正确返回false，符合预期；
• 但boost::optional<Bar>的std::is_copy_assignable_v却返回true，导致依赖constexpr-if分支的代码编译失败——特性检测认为拷贝赋值可行，但实际调用时会触发删除的拷贝构造函数错误。

代码复现 #

定义不可拷贝构造的类型Bar #

struct Bar {
    Bar() = default;
    Bar(Bar const&) = delete;
};

std::optional的特性检测（符合预期） #

using T = std::optional<Bar>;
static_assert(!std::is_copy_assignable_v<T>); // 断言通过

boost::optional的特性检测（不符合预期） #

using T = boost::optional<Bar>;
static_assert(std::is_copy_assignable_v<T>); // 断言通过，但实际调用会报错

触发编译错误的通用代码 #

template <typename T>
void foo() {
    if constexpr (std::is_copy_assignable_v<T>){
        T lhs;
        T rhs;
        lhs = rhs;
    } else {
        std::cout << "Nope!\n";
    }
}

int main()
{
    foo<std::optional<Bar>>();  // 正常运行，输出"Nope!"
    foo<boost::optional<Bar>>(); // 编译错误
}

GCC 13.2编译错误信息 #

In file included from /opt/compiler-explorer/libs/boost_1_84_0/boost/optional.hpp:15,
                 from <source>:4:
/opt/compiler-explorer/libs/boost_1_84_0/boost/optional/optional.hpp: In instantiation of 'void boost::optional_detail::optional_base<T>::construct(argument_type) [with T = Bar; argument_type = const Bar&]':
/opt/compiler-explorer/libs/boost_1_84_0/boost/optional/optional.hpp:277:20:   required from 'void boost::optional_detail::optional_base<T>::assign(const boost::optional_detail::optional_base<T>&) [with T = Bar]'
/opt/compiler-explorer/libs/boost_1_84_0/boost/optional/optional.hpp:249:19:   required from 'boost::optional_detail::optional_base<T>& boost::optional_detail::optional_base<T>::operator=(const boost::optional_detail::optional_base<T>&) [with T = Bar]'
/opt/compiler-explorer/libs/boost_1_84_0/boost/optional/optional.hpp:1099:15:   required from 'void foo() [with T = boost::optional<Bar>]'
<source>:34:34:   required from here
/opt/compiler-explorer/libs/boost_1_84_0/boost/optional/optional.hpp:410:8: error: use of deleted function 'Bar::Bar(const Bar&)'
  410 |        ::new (m_storage.address()) unqualified_value_type(val) ;
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<source>:19:5: note: declared here
   19 |     Bar(Bar const&) = delete;
      |     ^~~
Compiler returned: 1

问题根源 #

std::optional的拷贝赋值运算符是通过**SFINAE（替换失败不是错误）**条件化声明的：当内部类型T不可拷贝构造或不可拷贝赋值时，拷贝赋值运算符会被禁用，因此std::is_copy_assignable_v能正确识别其不可拷贝赋值的特性。

而boost::optional的拷贝赋值运算符是无条件声明的，它没有在声明阶段依赖T的可拷贝性做约束。类型特性检测时，只会检查运算符是否存在（此时确实存在），但实际调用时，运算符内部需要构造T的拷贝，这才触发了Bar被删除的拷贝构造函数，导致编译错误。

解决方案与替代方案 #

临时修复：特化自定义类型特性 #

针对boost::optional特化自定义的拷贝赋值检测特性，直接检查内部T的可拷贝构造和可拷贝赋值能力：

template <typename T>
struct is_copy_assignable : std::is_copy_assignable<T> {};

template <typename T>
struct is_copy_assignable<boost::optional<T>> 
{
    constexpr static bool value = std::is_copy_assignable_v<T> && std::is_copy_constructible_v<T>;
};

template <typename T>
constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value;

之后替换代码中的std::is_copy_assignable_v为自定义的is_copy_assignable_v即可。

通用库的可靠替代方案 #

1. 使用检测表达式（Detection Idiom）

自定义特性直接检测拷贝赋值表达式是否合法，比标准特性更准确：

#include <type_traits>

// 定义检测拷贝赋值的表达式
template <typename T>
using copy_assign_expr = decltype(std::declval<T&>() = std::declval<const T&>());

// 利用std::is_detected检测表达式是否可行（C++17及以上）
template <typename T>
constexpr bool is_copy_assignable_v = std::is_detected_v<copy_assign_expr, T>;

2. 使用C++20 Requires表达式

如果项目支持C++20，可以直接在constexpr-if中用requires表达式检测操作合法性，无需依赖类型特性：

template <typename T>
void foo() {
    if constexpr (requires(T lhs, const T rhs) { lhs = rhs; }) {
        T lhs;
        T rhs;
        lhs = rhs;
    } else {
        std::cout << "Nope!\n";
    }
}

这种方式直接模拟了实际调用场景，结果最准确。

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