如何让函数适配C++ ContiguousContainer概念及实现方案

首先明确：C++标准中的ContiguousContainer是仅用于文档说明的 exposition-only 概念，并没有在标准头文件中提供可直接使用的标识符，所以你找不到对应的头文件是正常的。下面是两种可行的实现思路：

方案一：利用标准连续迭代器概念约束（C++20及以上） #

连续容器的核心特征是其迭代器满足std::contiguous_iterator概念，C++20开始标准库提供了这个可直接使用的概念，你可以通过约束容器的迭代器来间接限制参数为连续容器：

#include <iterator>

template <typename Cont>
requires std::contiguous_iterator<typename Cont::iterator>
void process_contiguous(Cont& cont) {
    // 连续容器必然支持data()、size()等操作
    auto* raw_data = cont.data();
    std::size_t elem_count = cont.size();
    
    // 你的业务逻辑代码
}

这种方式不需要手动检查size()、begin()等成员，因为contiguous_iterator已经隐含了容器的迭代器是随机访问且连续存储的特性，同时标准及第三方合规连续容器都会提供data()成员，完全满足需求。

如果你使用C++20的范围库，也可以直接用std::ranges::ContiguousRange概念，它更直接地描述了连续范围类型：

#include <ranges>

template <std::ranges::ContiguousRange Cont>
void process_contiguous(Cont& cont) {
    // 处理逻辑
}

方案二：自行实现ContiguousContainer概念（兼容旧标准或自定义约束） #

如果需要兼容C++20之前的版本，或者想要完全匹配标准中ContiguousContainer的所有要求，可以自行实现一个约束逻辑：

C++20版本自定义concept #

#include <concepts>
#include <iterator>

template <typename Cont>
concept ContiguousContainer =
    std::ranges::Range<Cont> &&
    std::contiguous_iterator<typename Cont::iterator> &&
    requires(Cont& c) {
        { c.data() } -> std::same_as<typename std::iterator_traits<typename Cont::iterator>::pointer>;
        { c.size() } -> std::convertible_to<std::size_t>;
    };

// 使用自定义概念
template <ContiguousContainer Cont>
void process_contiguous(Cont& cont) {
    // 处理逻辑
}

C++17及更早版本（SFINAE实现） #

对于没有concept的旧标准，用SFINAE结合类型特性来做编译期检查：

#include <type_traits>
#include <iterator>

template <typename Cont, typename = void>
struct is_contiguous_container : std::false_type {};

template <typename Cont>
struct is_contiguous_container<Cont, std::void_t<
    decltype(std::declval<Cont>().begin()),
    decltype(std::declval<Cont>().end()),
    decltype(std::declval<Cont>().size()),
    decltype(std::declval<Cont>().data()),
    typename std::iterator_traits<typename Cont::iterator>::pointer
>> : std::bool_constant<
    std::is_same_v<decltype(std::declval<Cont>().data()), typename std::iterator_traits<typename Cont::iterator>::pointer> &&
    std::is_random_access_iterator_v<typename Cont::iterator> &&
    // 利用编译器扩展检查连续迭代器（GCC/Clang支持）
    __is_contiguous_iterator(typename Cont::iterator{})
> {};

template <typename Cont>
constexpr bool is_contiguous_container_v = is_contiguous_container<Cont>::value;

// SFINAE约束的函数
template <typename Cont, typename = std::enable_if_t<is_contiguous_container_v<Cont>>>
void process_contiguous(Cont& cont) {
    // 处理逻辑
}

总结 #

• 如果你使用C++20及以上，优先选择方案一，直接使用标准提供的std::contiguous_iterator或std::ranges::ContiguousRange，这是最简洁且符合标准的方式。
• 若需兼容旧版本或自定义更严格的约束，再考虑方案二的自定义实现。

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