编辑“︁C++ 连续迭代器cpp20”︁

{{DISPLAYTITLE:C++连续迭代器(C++20)}}

'''连续迭代器（Contiguous Iterator）'''是C++20标准引入的迭代器类别，用于表示内存中连续存储的元素序列。这类迭代器满足随机访问迭代器的所有要求，并额外保证底层元素在内存中是物理连续的。

== 概念定义 ==
连续迭代器是[[C++标准模板库|STL]]迭代器体系中的最高级类别之一，定义于<iterator>头文件。它满足以下数学关系：

<math>
\forall \text{迭代器 } it, \text{整数 } n : \&(*(it + n)) == \&(*it) + n
</math>

即：对连续迭代器进行算术运算时，其地址变化与指针算术完全一致。

=== 迭代器类别关系 ===
<mermaid>
graph TD
    A[迭代器] --> B[输入迭代器]
    A --> C[输出迭代器]
    B --> D[前向迭代器]
    D --> E[双向迭代器]
    E --> F[随机访问迭代器]
    F --> G[连续迭代器]
</mermaid>

== 核心特性 ==
连续迭代器具有以下关键特征：
1. '''内存连续性'''：指向的元素在内存中物理连续
2. '''指针互操作性'''：可以安全转换为指针且保持有效性
3. '''常量表达式支持'''：可在编译期进行相关操作
4. '''类型特征检测'''：可通过<type_traits>的<code>std::contiguous_iterator</code>检测

== 代码示例 ==
=== 基本使用 ===
<syntaxhighlight lang="cpp">
#include <iostream>
#include <vector>
#include <array>
#include <span>

void check_contiguous(auto&& container) {
    using Iter = decltype(container.begin());
    if constexpr (std::contiguous_iterator<Iter>) {
        std::cout << "是连续迭代器\n";
        
        // 演示指针互操作性
        auto it = container.begin();
        int* ptr = &*it; // 安全转换为指针
        std::cout << "首元素: " << *ptr << "\n";
    } else {
        std::cout << "不是连续迭代器\n";
    }
}

int main() {
    std::vector<int> vec{1, 2, 3};
    std::array<float, 4> arr{1.1f, 2.2f, 3.3f};
    std::list<double> lst{1.0, 2.0}; // 非连续
    
    check_contiguous(vec);  // 输出: 是连续迭代器
    check_contiguous(arr);  // 输出: 是连续迭代器
    check_contiguous(lst);  // 输出: 不是连续迭代器
}
</syntaxhighlight>

=== 与C函数交互 ===
连续迭代器特别适合与C风格API交互：

<syntaxhighlight lang="cpp">
#include <cstring>
#include <vector>

void process_c_data(const char* data, size_t len) {
    // C风格处理...
}

int main() {
    std::vector<char> buffer{'H', 'e', 'l', 'l', 'o'};
    
    // 直接传递连续迭代器范围
    process_c_data(&*buffer.begin(), buffer.size());
    
    // C++20更安全的做法
    process_c_data(std::to_address(buffer.begin()), buffer.size());
}
</syntaxhighlight>

== 实际应用场景 ==
连续迭代器在以下场景中特别重要：

1. '''底层内存操作'''：如memcpy、SIMD指令等需要连续内存块的操作
2. '''跨语言交互'''：与C/Python等语言交换数据缓冲区
3. '''高性能计算'''：确保内存访问模式最优
4. '''序列化/反序列化'''：直接操作二进制数据流

=== 性能优化示例 ===
<syntaxhighlight lang="cpp">
#include <vector>
#include <algorithm>
#include <numeric>

void process_block(int* start, size_t count) {
    // 使用SIMD指令优化处理
    std::transform(start, start + count, start, 
        [](int x) { return x * x; });
}

int main() {
    std::vector<int> data(1024);
    std::iota(data.begin(), data.end(), 0);
    
    // 利用连续迭代器保证进行批量处理
    process_block(data.data(), data.size());
}
</syntaxhighlight>

== 类型特征检测 ==
C++20提供了检测连续迭代器的方法：

<syntaxhighlight lang="cpp">
#include <iterator>
#include <list>
#include <vector>

template<typename Iter>
constexpr bool is_contiguous() {
    return std::contiguous_iterator<Iter>;
}

static_assert(is_contiguous<std::vector<int>::iterator>());
static_assert(!is_contiguous<std::list<int>::iterator>());
</syntaxhighlight>

== 限制与注意事项 ==
1. 标准容器中只有<code>vector</code>、<code>array</code>、<code>string</code>和<code>span</code>保证提供连续迭代器
2. <code>deque</code>虽然支持随机访问但不是连续迭代器
3. 自定义容器需要显式特化<code>std::contiguous_iterator</code>才能被识别
4. 迭代器失效规则与对应容器一致

== 进阶主题 ==
=== 自定义连续迭代器 ===
实现自定义连续迭代器需要满足：
1. 继承自<code>std::contiguous_iterator_tag</code>
2. 提供正确的指针交互语义

<syntaxhighlight lang="cpp">
#include <iterator>

template<typename T>
class MyContiguousIterator {
    T* ptr;
public:
    using iterator_concept = std::contiguous_iterator_tag;
    // ... 其他必要成员定义
};
</syntaxhighlight>

=== 编译期检测 ===
C++20允许在编译期检测连续性：

<syntaxhighlight lang="cpp">
constexpr bool test_contiguity() {
    std::vector<int> v{1, 2, 3};
    auto it = v.begin();
    return std::contiguous_iterator<decltype(it)>;
}

static_assert(test_contiguity());
</syntaxhighlight>

== 总结 ==
连续迭代器是C++20对内存连续序列的正式抽象，它：
* 统一了指针和迭代器的操作模型
* 为高性能计算提供了类型安全的保证
* 增强了与低级代码的互操作性
* 通过概念(concept)提供了更好的接口约束

正确理解和使用连续迭代器可以显著提高代码的效率和安全性，特别是在需要与底层内存交互的场景中。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++stl 迭代器]]