如何让std::span适配数组容器等连续内存结构？

针对你需要让func(std::span<double>)直接接收std::vector<std::array<double,3>>，同时兼容普通std::vector<T>、std::array<T>的需求，提供以下几种实用方案：

方案1：模板转换函数（灵活通用） #

写一个通用的转换函数，自动将不同类型的连续容器（包括嵌套的）转换成std::span<double>，调用时只需包裹一层函数：

#include <span>
#include <vector>
#include <array>
#include <type_traits>

// 处理vector<array<double, N>>的情况
template <size_t N>
std::span<double> as_flat_span(std::vector<std::array<double, N>>& vec) {
    return vec.empty() ? std::span<double>{} : std::span<double>{&vec[0][0], vec.size() * N};
}

// 处理const版本的vector<array<double, N>>
template <size_t N>
std::span<const double> as_flat_span(const std::vector<std::array<double, N>>& vec) {
    return vec.empty() ? std::span<const double>{} : std::span<const double>{&vec[0][0], vec.size() * N};
}

// 兼容普通vector<double>
std::span<double> as_flat_span(std::vector<double>& vec) {
    return vec;
}

std::span<const double> as_flat_span(const std::vector<double>& vec) {
    return vec;
}

// 兼容普通std::array<double, N>
template <size_t N>
std::span<double> as_flat_span(std::array<double, N>& arr) {
    return arr;
}

template <size_t N>
std::span<const double> as_flat_span(const std::array<double, N>& arr) {
    return arr;
}

调用示例：

void func(std::span<double> vec) {
    // 原有逻辑
}

int main() {
    std::vector<std::array<double,3>> vec_arr{{1,2,3}, {4,5,6}};
    std::vector<double> vec{1,2,3};
    std::array<double,4> arr{1,2,3,4};

    func(as_flat_span(vec_arr));
    func(as_flat_span(vec));
    func(as_flat_span(arr));
}

方案2：重载func函数（调用最简洁） #

直接为不同类型的容器重载func，用户调用时无需额外转换，直接传入容器即可：

#include <span>
#include <vector>
#include <array>

// 核心实现：处理std::span<double>
void func(std::span<double> vec) {
    // 原有业务逻辑
}

// 重载：处理vector<array<double, N>>
template <size_t N>
void func(std::vector<std::array<double, N>>& vec) {
    func(vec.empty() ? std::span<double>{} : std::span<double>{&vec[0][0], vec.size() * N});
}

// 重载：处理const版本的vector<array<double, N>>
template <size_t N>
void func(const std::vector<std::array<double, N>>& vec) {
    func(std::span<const double>(vec.empty() ? nullptr : &vec[0][0], vec.size() * N));
}

// 重载：处理普通vector<double>
void func(std::vector<double>& vec) {
    func(std::span<double>(vec));
}

void func(const std::vector<double>& vec) {
    func(std::span<const double>(vec));
}

// 重载：处理普通std::array<double, N>
template <size_t N>
void func(std::array<double, N>& arr) {
    func(std::span<double>(arr));
}

template <size_t N>
void func(const std::array<double, N>& arr) {
    func(std::span<const double>(arr));
}

调用示例：

int main() {
    std::vector<std::array<double,3>> vec_arr{{1,2,3}, {4,5,6}};
    std::vector<double> vec{1,2,3};
    std::array<double,4> arr{1,2,3,4};

    func(vec_arr); // 直接调用，无需转换
    func(vec);
    func(arr);
}

方案3：C++20 constexpr if 通用适配器（扩展性强） #

利用C++20的constexpr if特性，写一个高度通用的适配器，支持更多嵌套连续类型（比如C风格数组的vector）：

#include <span>
#include <vector>
#include <array>
#include <type_traits>

template <typename Range>
auto get_flat_span(Range& r) -> std::span<std::remove_const_t<typename Range::value_type::value_type>>
requires requires(Range& r) {
    r.begin();
    r.empty();
    *r.begin();
    std::size(*r.begin());
} {
    if (r.empty()) return {};
    using InnerElem = typename Range::value_type::value_type;
    return {&(*r.begin())[0], r.size() * std::size(*r.begin())};
}

// 处理普通单元素容器
template <typename Range>
auto get_flat_span(Range& r) -> std::span<typename Range::value_type>
requires requires(Range& r) {
    r.begin();
    r.empty();
    std::is_same_v<typename Range::value_type, double>;
} {
    return r;
}

这个方案通过概念（requires）自动判断容器类型，既支持嵌套的连续容器，也支持普通的单元素容器，扩展性更强。

注意事项 #

• 所有方案都处理了容器为空的边界情况，避免访问空容器的首元素导致未定义行为。
• 如果需要支持const容器，要对应实现const版本的转换函数或重载。
• 嵌套容器必须保证内存连续：std::vector<std::array<double,N>>的内存是连续的，每个std::array内部也是连续的，因此整个容器的元素在内存中是连续的，这是转换的前提。

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