如何将唯一指针的 std::vector 转换为原始指针的 std::span？

Question

我在某个模块的界面中有如下功能：

void DoSomething(Span<MyObject *const> objects);

，其中Span 是我对C++20 的std::span 模板的简化实现。

这个函数只是迭代一个指向对象的连续指针序列并调用它们的一些函数，而不试图修改指针（因此签名中的const）。

在来电者方面，我有一个std::vector<std::unique_ptr<MyObject>>。我想将该向量传递给DoSomething 函数而不分配额外的内存（对于任何像临时的std::vector<MyObject*>）。我只想在恒定时间内将unique_ptrs 的左值向量转换为不可变原始指针的Span。

这一定是可能的，因为带有无状态删除器的std::unique_ptr<T> 与原始T* 指针具有相同的大小和对齐方式，并且它存储在内部的只是原始指针本身。因此，按字节计算，std::vector<std::unique_ptr<MyObject>> 必须与 std::vector<MyObject*> 具有相同的表示形式——因此必须可以将其传递给需要 Span<MyObject *const> 的函数。

我的问题是：

1. 在std::span 的当前提案中是否可以进行这样的转换，而不会导致未定义的行为并依赖于肮脏的黑客攻击？

2. 如果不是，是否可以在以下标准（例如 C++23）中预期？

3. 使用我在我的Span 版本中实现的转换，使用memcpy 的肮脏技巧有什么危险？它在实践中似乎工作正常，但我想其中可能存在一些未定义的行为。如果有，在哪些情况下，这种未定义的行为会在 MSVC、GCC 或 Clang/LLVM 上让我措手不及，具体情况如何？如果可能的话，我将不胜感激。

我的代码是这样的：

namespace detail
{
  constexpr std::size_t dynamic_extent = static_cast<std::size_t>(-1);

  template<typename SourceSmartPointer, typename SpanElement, typename = void>
  struct is_smart_pointer_type_compatible_impl
    : std::false_type
  {
  };

  template<typename SourceSmartPointer, typename SpanElement>
  struct is_smart_pointer_type_compatible_impl<SourceSmartPointer, SpanElement,
                                               decltype((void)(std::declval<SourceSmartPointer&>().get()))>
    : std::conjunction<
        std::is_pointer<SpanElement>,
        std::is_const<SpanElement>,
        std::is_convertible<std::add_pointer_t<decltype(std::declval<SourceSmartPointer&>().get())>,
                            SpanElement*>,
        std::is_same<std::remove_cv_t<std::remove_pointer_t<decltype(std::declval<SourceSmartPointer&>().get())>>,
                     std::remove_cv_t<std::remove_pointer_t<SpanElement>>>,
        std::bool_constant<(sizeof(SourceSmartPointer) == sizeof(SpanElement)) &&
                           (alignof(SourceSmartPointer) == alignof(SpanElement))>>
  {
  };

  // Helper type trait which detects whether a contiguous range of smart pointers of the source type
  // can be used to initialize a span of respective immutable raw pointers using a memcpy-based hack.
  template<typename SourceSmartPointer, typename SpanElement>
  struct is_smart_pointer_type_compatible
    : is_smart_pointer_type_compatible_impl<SourceSmartPointer, SpanElement>
  {
  };

  template<typename T, typename R>
  inline T* cast_smart_pointer_range_data_to_raw_pointer(R& source_range)
  {
    T* result = nullptr;

    auto* source_range_data = std::data(source_range);
    std::memcpy(&result, &source_range_data, sizeof(T*));

    return result;
  }
}

template<typename T, std::size_t Extent = detail::dynamic_extent>
class Span final
{
public:
  // ...

  // Non-standard extension.
  // Allows, e.g., to convert `std::vector<std::unique_ptr<Object>>` to `Span<Object *const>`
  // by using the fact that such smart pointers are bytewise equal to the resulting raw pointers;
  // `const` is required on the destination type to ensure that the source smart pointers
  // will be read-only for the users of the resulting Span.
  template<typename R,
           std::enable_if_t<std::conjunction<
             std::bool_constant<(Extent == detail::dynamic_extent)>,
             detail::is_smart_pointer_type_compatible<std::remove_reference_t<decltype(*std::data(std::declval<R&&>()))>, T>,
             detail::is_not_span<R>,
             detail::is_not_std_array<R>,
             std::negation<std::is_array<std::remove_cv_t<std::remove_reference_t<R>>>> >::value, int> = 0>
  constexpr Span(R&& source_range)
    : _data(detail::cast_smart_pointer_range_data_to_raw_pointer<T>(source_range))
    , _size(std::size(source_range))
  {
  }

  // ...

private:
  T* _data = nullptr;
  std::size_t _size = 0;
};

Answer 1

当前的 std::span 提案是否可以进行这样的转换，而不会导致未定义的行为并依赖于肮脏的黑客攻击？

没有。即使这个陈述是真的（我知道标准中没有要求强制它是真的）：

带有无状态删除器的std::unique_ptr<T> 与原始T* 指针具有相同的大小和对齐方式，并且它存储在内部的只是原始指针本身。

没关系。 unique_ptr<T> 不仅仅是带有一些成员函数的T*。这是一个unique_ptr<T>，由于违反了严格别名规则，试图假装一个是另一个是UB。

如果不是，是否可以在以下标准（例如 C++23）中预期？

没有。即使P0593 的一种形式以一种允许将存储在unique_ptr<T> 数组中的字节转换为T* 数组的方式进入标准，这也将是一个转换，不是演员表。也就是说，unique_ptr<T>s 的生命周期将结束，T*s 数组的生命周期将开始使用先前结束的对象中的数据。所以你不能再使用vector<unique_ptr<T>>了。

任何这样的转变，如果允许的话，肯定是单向的。 P0593 在字节存储中隐式创建对象的能力仅限于本质上只是数据字节的类型，unique_ptr 不符合该限制。