概念

可以将迭代器看成是一种指针，但是不完全是指针，因为有些时候迭代器是一个类类型，然后重载了指针的功能，所以迭代器可以像指针一样使用。

C++为什么要设计迭代器这种东西？

迭代器算是C++一个非常重要的抽象概念，它的意义在于：

• 为访问容器中的元素提供了统一的方式。比如vector/deque/list三种容器存储元素的方式完全不同，存储元素的类型也可能不同，但是都可以用迭代器来遍历和操作容器中的元素，而不需要关心容器的具体实现细节。

• 使算法能够独立于容器进行设计和实现。例如，std::sort算法可以对任何支持随机访问迭代器的容器进行排序，而不需要为每种容器单独实现排序算法。这样可以提高代码的可复用性和灵活性。

也就是说C++通过迭代器把不同的容器的元素的访问逻辑抽象了出来。

迭代器的类型

• 输入迭代器(InputIterator)

• 输出迭代器(OutputIterator)

• 前向迭代器(ForwardIterator)

• 双向迭代器(BidirectionIterator)

• 随机访问迭代器(RandomAccessIterator)

这个表格展示了不同类型迭代器支持的操作：

• 输出迭代器(Output): 只支持写入和递增操作

• 输入迭代器(Input): 支持读取、访问、递增和比较操作

• 前向迭代器(Forward): 在输入迭代器基础上增加写入功能

• 双向迭代器(Bidirection): 在前向迭代器基础上增加递减操作和更多比较操作

• 随机访问迭代器(Random): 支持所有操作，包括随机访问([])和算术运算

输入迭代器（Input Iterator）

• 特点：用于读取容器中的元素，只能向前移动，支持自增操作（++）来指向下一个元素，可进行解引用（*）操作来访问当前元素的值，还能进行相等（==）和不等（!=）比较以判断两个迭代器是否指向同一位置。

• 应用场景：常用于只读算法，如 std::find、std::count 等，这些算法只需要从容器中读取元素，不需要修改元素的值。

 

输出迭代器（Output Iterator）

• 特点：用于向容器中写入元素，只能向前移动，支持自增操作（++），可通过解引用（*）操作来修改元素的值，但不能读取元素的值。输出迭代器不支持比较操作。

• 应用场景：常用于输出算法，如 std::copy 算法可以将一个范围的元素复制到另一个由输出迭代器指定的位置。

 

前向迭代器（Forward Iterator）

• 特点：结合了输入迭代器和输出迭代器的功能，既能读取又能写入元素，并且可以多次读取同一个元素。它可以向前移动，支持自增操作（++），也支持解引用（*）操作，还能进行相等（==）和不等（!=）比较。

• 应用场景：适用于需要对容器元素进行读写操作，且只需要单向遍历容器的场景，例如对单链表的遍历和操作。

 

双向迭代器（Bidirectional Iterator）

• 特点：在向前迭代器的基础上，增加了向后移动的功能，支持自减操作（--），可以方便地在容器中前后移动，进行元素的访问和修改。

• 应用场景：常用于需要双向遍历容器的算法，如 std::reverse 算法用于反转容器中元素的顺序，就需要双向迭代器来从两端向中间进行元素交换。

 

随机访问迭代器（Random Access Iterator）

• 特点：具有最强的功能，除了支持双向迭代器的所有操作外，还支持随机访问元素，就像数组下标访问一样，可以通过偏移量直接访问容器中的任意元素。支持加法（+）、减法（-）操作来计算迭代器之间的距离，也支持比较操作（<、>、<=、>=）来判断两个迭代器的相对位置。

• 应用场景：适用于需要快速随机访问元素的算法，如 std::sort 算法对容器中的元素进行排序，通常要求迭代器具有随机访问能力，以便高效地进行元素的比较和交换。

流迭代器

流迭代器是特殊的迭代器，其作用有：

（1）可以将输入/输出流作为容器看待(因为输入输出流都有缓冲区的概念，也可以视为存一些数据)，流迭代器可以用来访问输入输出流这种"容器"中的数据。

（2）STL 中有许多算法都是基于迭代器设计的，输入流迭代器和输出流迭代器使得这些算法能够直接应用于输入输出流。因此任何接受迭代器参数的算法都可以和流一起工作。

输出流迭代器

基本概念

输出流迭代器 (Output Stream Iterator)是一种特殊迭代器，专门用于将数据写入输出流。它是一个输出迭代器，只支持写入操作，不支持读取。

• 只写性: 只能写入数据，不能读取

• 单向性: 只支持递增操作（++）

• 一次性: 每个位置只能写入一次

• 流绑定: 与特定的输出流绑定

xxxxxxxxxx
4
1
*iter = value;  // 写入操作
2
++iter;         // 递增操作
3
iter++;         // 后置递增
4
*iter++ = value; // 写入并递增

声明和使用

xxxxxxxxxx
8
1
#include <iostream>
2
#include <iterator>
3
#include <vector>
4
#include <algorithm>
5

6
// 创建输出流迭代器
7
std::ostream_iterator<int> out_iter(std::cout, " ");
8
std::ostream_iterator<std::string> str_iter(std::cout, "\n");

xxxxxxxxxx
8
1
// 构造函数形式
2
ostream_iterator(ostream_type& stream);                    // 无分隔符
3
ostream_iterator(ostream_type& stream, const char* delim); // 有分隔符
4

5
// 示例
6
std::ostream_iterator<int> iter1(std::cout);        // 无分隔符
7
std::ostream_iterator<int> iter2(std::cout, ", ");   // 逗号分隔
8
std::ostream_iterator<int> iter3(std::cout, "\n");   // 换行分隔

应用

基本使用

xxxxxxxxxx
17
1
#include <iostream>
2
#include <iterator>
3
#include <vector>
4
#include <algorithm>
5

6
int main() {
7
    std::vector<int> vec = {1, 2, 3, 4, 5};
8
    
9
    // 创建输出流迭代器
10
    std::ostream_iterator<int> out_iter(std::cout, " ");
11
    
12
    // 使用copy算法输出
13
    std::copy(vec.begin(), vec.end(), out_iter);
14
    // 输出: 1 2 3 4 5 
15
    
16
    return 0;
17
}

不同分隔符的使用

xxxxxxxxxx
30
1
#include <iostream>
2
#include <iterator>
3
#include <vector>
4
#include <string>
5

6
int main() {
7
    std::vector<std::string> words = {"Hello", "World", "C++"};
8
    
9
    // 不同的分隔符
10
    std::cout << "无分隔符: ";
11
    std::copy(words.begin(), words.end(), 
12
              std::ostream_iterator<std::string>(std::cout));
13
    std::cout << "\n";
14
    
15
    std::cout << "空格分隔: ";
16
    std::copy(words.begin(), words.end(), 
17
              std::ostream_iterator<std::string>(std::cout, " "));
18
    std::cout << "\n";
19
    
20
    std::cout << "换行分隔:\n";
21
    std::copy(words.begin(), words.end(), 
22
              std::ostream_iterator<std::string>(std::cout, "\n"));
23
    
24
    std::cout << "自定义分隔: ";
25
    std::copy(words.begin(), words.end(), 
26
              std::ostream_iterator<std::string>(std::cout, " | "));
27
    std::cout << "\n";
28
    
29
    return 0;
30
}

与STL算法配合使用

xxxxxxxxxx
40
1
#include <iostream>
2
#include <iterator>
3
#include <vector>
4
#include <algorithm>
5
#include <numeric>
6

7
int main() {
8
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
9
    
10
    std::ostream_iterator<int> out(std::cout, " ");
11
    
12
    // 1. 复制所有元素
13
    std::cout << "所有元素: ";
14
    std::copy(numbers.begin(), numbers.end(), out);
15
    std::cout << "\n";
16
    
17
    // 2. 复制满足条件的元素
18
    std::cout << "偶数: ";
19
    std::copy_if(numbers.begin(), numbers.end(), out, 
20
                 [](int n) { return n % 2 == 0; });
21
    std::cout << "\n";
22
    
23
    // 3. 变换后输出
24
    std::cout << "平方: ";
25
    std::transform(numbers.begin(), numbers.end(), out,
26
                   [](int n) { return n * n; });
27
    std::cout << "\n";
28
    
29
    // 4. 生成序列
30
    std::cout << "斐波那契前10项: ";
31
    std::vector<int> fib(10);
32
    fib[0] = 0; fib[1] = 1;
33
    for (int i = 2; i < 10; ++i) {
34
        fib[i] = fib[i-1] + fib[i-2];
35
    }
36
    std::copy(fib.begin(), fib.end(), out);
37
    std::cout << "\n";
38
    
39
    return 0;
40
}

输出到文件

xxxxxxxxxx
34
1
#include <iostream>
2
#include <fstream>
3
#include <iterator>
4
#include <vector>
5
#include <algorithm>
6

7
int main() {
8
    std::vector<int> data = {10, 20, 30, 40, 50};
9
    
10
    // 输出到文件
11
    std::ofstream file("output.txt");
12
    if (file.is_open()) {
13
        std::ostream_iterator<int> file_iter(file, "\n");
14
        std::copy(data.begin(), data.end(), file_iter);
15
        file.close();
16
        std::cout << "数据已写入文件\n";
17
    }
18
    
19
    // 同时输出到控制台和文件
20
    std::ofstream log("log.txt");
21
    if (log.is_open()) {
22
        std::ostream_iterator<int> console_iter(std::cout, " ");
23
        std::ostream_iterator<int> file_iter(log, "\n");
24
        
25
        std::cout << "控制台输出: ";
26
        std::copy(data.begin(), data.end(), console_iter);
27
        std::cout << "\n";
28
        
29
        std::copy(data.begin(), data.end(), file_iter);
30
        log.close();
31
    }
32
    
33
    return 0;
34
}

自定义类型的输出

xxxxxxxxxx
28
1
#include <iostream>
2
#include <iterator>
3
#include <vector>
4
#include <algorithm>
5

6
struct Point {
7
    int x, y;
8
    
9
    Point(int x, int y) : x(x), y(y) {}
10
    
11
    // 重载输出运算符
12
    friend std::ostream& operator<<(std::ostream& os, const Point& p) {
13
        return os << "(" << p.x << ", " << p.y << ")";
14
    }
15
};
16

17
int main() {
18
    std::vector<Point> points = {
19
        {1, 2}, {3, 4}, {5, 6}, {7, 8}
20
    };
21
    
22
    std::cout << "点坐标: ";
23
    std::copy(points.begin(), points.end(), 
24
              std::ostream_iterator<Point>(std::cout, " "));
25
    std::cout << "\n";
26
    
27
    return 0;
28
}

实用工具函数

xxxxxxxxxx
47
1
#include <iostream>
2
#include <iterator>
3
#include <vector>
4
#include <algorithm>
5
#include <sstream>
6

7
// 通用打印函数
8
template<typename Container>
9
void print_container(const Container& container, 
10
                    const std::string& delimiter = " ") {
11
    std::copy(container.begin(), container.end(),
12
              std::ostream_iterator<typename Container::value_type>
13
              (std::cout, delimiter.c_str()));
14
    std::cout << "\n";
15
}
16

17
// 转换为字符串
18
template<typename Container>
19
std::string container_to_string(const Container& container,
20
                               const std::string& delimiter = ", ") {
21
    std::ostringstream oss;
22
    std::copy(container.begin(), container.end(),
23
              std::ostream_iterator<typename Container::value_type>
24
              (oss, delimiter.c_str()));
25
    return oss.str();
26
}
27

28
int main() {
29
    std::vector<int> numbers = {1, 2, 3, 4, 5};
30
    std::vector<std::string> words = {"Hello", "World", "C++"};
31
    
32
    // 使用通用打印函数
33
    std::cout << "数字: ";
34
    print_container(numbers);
35
    
36
    std::cout << "单词: ";
37
    print_container(words, " | ");
38
    
39
    // 转换为字符串
40
    std::string num_str = container_to_string(numbers);
41
    std::string word_str = container_to_string(words, " - ");
42
    
43
    std::cout << "数字字符串: " << num_str << "\n";
44
    std::cout << "单词字符串: " << word_str << "\n";
45
    
46
    return 0;
47
}

格式化输出

xxxxxxxxxx
19
1
#include <iostream>
2
#include <iterator>
3
#include <vector>
4
#include <iomanip>
5
#include <algorithm>
6

7
int main() {
8
    std::vector<double> values = {3.14159, 2.71828, 1.41421, 1.73205};
9
    
10
    // 设置输出格式
11
    std::cout << std::fixed << std::setprecision(2);
12
    
13
    std::cout << "格式化输出: ";
14
    std::copy(values.begin(), values.end(),
15
              std::ostream_iterator<double>(std::cout, " "));
16
    std::cout << "\n";
17
    
18
    return 0;
19
}

条件输出

xxxxxxxxxx
39
1
#include <iostream>
2
#include <iterator>
3
#include <vector>
4
#include <algorithm>
5

6
template<typename T, typename Predicate>
7
class conditional_ostream_iterator {
8
private:
9
    std::ostream_iterator<T> iter;
10
    Predicate pred;
11
    
12
public:
13
    conditional_ostream_iterator(std::ostream& os, const char* delim, Predicate p)
14
        : iter(os, delim), pred(p) {}
15
    
16
    conditional_ostream_iterator& operator=(const T& value) {
17
        if (pred(value)) {
18
            iter = value;
19
        }
20
        return *this;
21
    }
22
    
23
    conditional_ostream_iterator& operator*() { return *this; }
24
    conditional_ostream_iterator& operator++() { return *this; }
25
    conditional_ostream_iterator& operator++(int) { return *this; }
26
};
27

28
int main() {
29
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
30
    
31
    std::cout << "偶数: ";
32
    conditional_ostream_iterator<int, std::function<bool(int)>> 
33
        even_iter(std::cout, " ", [](int n) { return n % 2 == 0; });
34
    
35
    std::copy(numbers.begin(), numbers.end(), even_iter);
36
    std::cout << "\n";
37
    
38
    return 0;
39
}

输入流迭代器

基本概念

输入流迭代器 (Input Stream Iterator)是一种特殊迭代器，专门用于从输入流中读取数据。它是一个输入迭代器，只支持读取操作，不支持写入。

• 只读性: 只能读取数据，不能写入

• 单向性: 只支持递增操作（++）

• 单遍历: 每个元素只能读取一次

• 流绑定: 与特定的输入流绑定

• 惰性求值: 只在需要时才从流中读取数据

xxxxxxxxxx
6
1
value = *iter;   // 读取操作
2
++iter;          // 递增操作
3
iter++;          // 后置递增
4
value = *iter++; // 读取并递增
5
iter1 == iter2;  // 相等比较
6
iter1 != iter2;  // 不等比较

声明和使用

1. 基本声明

xxxxxxxxxx
12
1
#include <iostream>
2
#include <iterator>
3
#include <vector>
4
#include <algorithm>
5

6
// 创建输入流迭代器
7
std::istream_iterator<int> int_iter(std::cin);
8
std::istream_iterator<std::string> str_iter(std::cin);
9
std::istream_iterator<double> double_iter(std::cin);
10

11
// 创建结束迭代器
12
std::istream_iterator<int> end_iter;

2. 构造函数

xxxxxxxxxx
7
1
// 构造函数形式
2
istream_iterator();                    // 默认构造（结束迭代器）
3
istream_iterator(istream_type& stream); // 绑定到输入流
4

5
// 示例
6
std::istream_iterator<int> iter(std::cin);  // 从标准输入读取
7
std::istream_iterator<int> end;             // 结束迭代器

应用

基本使用

xxxxxxxxxx
24
1
#include <iostream>
2
#include <iterator>
3
#include <vector>
4
#include <algorithm>
5

6
int main() {
7
    std::cout << "请输入一些整数（按Ctrl+Z结束）: ";
8
    
9
    // 创建输入流迭代器
10
    std::istream_iterator<int> input_iter(std::cin);
11
    std::istream_iterator<int> end_iter;
12
    
13
    // 读取所有输入到vector中
14
    std::vector<int> numbers(input_iter, end_iter);
15
    
16
    // 输出读取的数据
17
    std::cout << "读取到的数字: ";
18
    for (int num : numbers) {
19
        std::cout << num << " ";
20
    }
21
    std::cout << "\n";
22
    
23
    return 0;
24
}

从文件读取

xxxxxxxxxx
31
1
#include <iostream>
2
#include <fstream>
3
#include <iterator>
4
#include <vector>
5
#include <algorithm>
6

7
int main() {
8
    // 创建测试文件
9
    std::ofstream outfile("numbers.txt");
10
    outfile << "1 2 3 4 5 6 7 8 9 10";
11
    outfile.close();
12
    
13
    // 从文件读取
14
    std::ifstream infile("numbers.txt");
15
    if (infile.is_open()) {
16
        std::istream_iterator<int> file_iter(infile);
17
        std::istream_iterator<int> end_iter;
18
        
19
        std::vector<int> numbers(file_iter, end_iter);
20
        
21
        std::cout << "从文件读取的数字: ";
22
        for (int num : numbers) {
23
            std::cout << num << " ";
24
        }
25
        std::cout << "\n";
26
        
27
        infile.close();
28
    }
29
    
30
    return 0;
31
}

与STL算法配合使用

xxxxxxxxxx
47
1
#include <iostream>
2
#include <sstream>
3
#include <iterator>
4
#include <vector>
5
#include <algorithm>
6
#include <numeric>
7

8
int main() {
9
    // 模拟输入数据
10
    std::string input_data = "10 20 30 40 50 60 70 80 90 100";
11
    std::istringstream iss(input_data);
12
    
13
    std::istream_iterator<int> input_iter(iss);
14
    std::istream_iterator<int> end_iter;
15
    
16
    // 1. 直接复制到容器
17
    std::vector<int> numbers;
18
    std::copy(input_iter, end_iter, std::back_inserter(numbers));
19
    
20
    std::cout << "读取的数字: ";
21
    for (int num : numbers) {
22
        std::cout << num << " ";
23
    }
24
    std::cout << "\n";
25
    
26
    // 重置字符串流
27
    iss.clear();
28
    iss.str(input_data);
29
    std::istream_iterator<int> input_iter2(iss);
30
    
31
    // 2. 计算总和
32
    int sum = std::accumulate(input_iter2, end_iter, 0);
33
    std::cout << "总和: " << sum << "\n";
34
    
35
    // 重置字符串流
36
    iss.clear();
37
    iss.str(input_data);
38
    std::istream_iterator<int> input_iter3(iss);
39
    
40
    // 3. 查找特定值
41
    auto found = std::find(input_iter3, end_iter, 50);
42
    if (found != end_iter) {
43
        std::cout << "找到值: " << *found << "\n";
44
    }
45
    
46
    return 0;
47
}

读取不同类型的数据

xxxxxxxxxx
40
1
#include <iostream>
2
#include <sstream>
3
#include <iterator>
4
#include <vector>
5
#include <string>
6
#include <algorithm>
7

8
int main() {
9
    // 读取字符串
10
    std::string text_data = "Hello World C++ Programming";
11
    std::istringstream text_stream(text_data);
12
    
13
    std::istream_iterator<std::string> word_iter(text_stream);
14
    std::istream_iterator<std::string> word_end;
15
    
16
    std::vector<std::string> words(word_iter, word_end);
17
    
18
    std::cout << "读取的单词: ";
19
    for (const auto& word : words) {
20
        std::cout << word << " ";
21
    }
22
    std::cout << "\n";
23
    
24
    // 读取浮点数
25
    std::string float_data = "3.14 2.718 1.414 1.732";
26
    std::istringstream float_stream(float_data);
27
    
28
    std::istream_iterator<double> float_iter(float_stream);
29
    std::istream_iterator<double> float_end;
30
    
31
    std::vector<double> floats(float_iter, float_end);
32
    
33
    std::cout << "读取的浮点数: ";
34
    for (double f : floats) {
35
        std::cout << f << " ";
36
    }
37
    std::cout << "\n";
38
    
39
    return 0;
40
}

自定义类型的读取

xxxxxxxxxx
41
1
#include <iostream>
2
#include <sstream>
3
#include <iterator>
4
#include <vector>
5
#include <algorithm>
6

7
struct Point {
8
    int x, y;
9
    
10
    Point() : x(0), y(0) {}
11
    Point(int x, int y) : x(x), y(y) {}
12
    
13
    // 重载输入运算符
14
    friend std::istream& operator>>(std::istream& is, Point& p) {
15
        char comma;
16
        return is >> p.x >> comma >> p.y;  // 期望格式: "x,y"
17
    }
18
    
19
    // 重载输出运算符
20
    friend std::ostream& operator<<(std::ostream& os, const Point& p) {
21
        return os << "(" << p.x << ", " << p.y << ")";
22
    }
23
};
24

25
int main() {
26
    std::string point_data = "1,2 3,4 5,6 7,8";
27
    std::istringstream point_stream(point_data);
28
    
29
    std::istream_iterator<Point> point_iter(point_stream);
30
    std::istream_iterator<Point> point_end;
31
    
32
    std::vector<Point> points(point_iter, point_end);
33
    
34
    std::cout << "读取的点: ";
35
    for (const auto& point : points) {
36
        std::cout << point << " ";
37
    }
38
    std::cout << "\n";
39
    
40
    return 0;
41
}

实用工具函数

xxxxxxxxxx
81
1
#include <iostream>
2
#include <sstream>
3
#include <iterator>
4
#include <vector>
5
#include <algorithm>
6
#include <type_traits>
7

8
// 从字符串读取数据到容器
9
template<typename T>
10
std::vector<T> read_from_string(const std::string& data) {
11
    std::istringstream iss(data);
12
    std::istream_iterator<T> iter(iss);
13
    std::istream_iterator<T> end;
14
    return std::vector<T>(iter, end);
15
}
16

17
// 从流读取指定数量的元素
18
template<typename T>
19
std::vector<T> read_n_elements(std::istream& is, size_t n) {
20
    std::vector<T> result;
21
    result.reserve(n);
22
    
23
    std::istream_iterator<T> iter(is);
24
    std::istream_iterator<T> end;
25
    
26
    for (size_t i = 0; i < n && iter != end; ++i, ++iter) {
27
        result.push_back(*iter);
28
    }
29
    
30
    return result;
31
}
32

33
// 读取直到遇到特定值
34
template<typename T>
35
std::vector<T> read_until(std::istream& is, const T& sentinel) {
36
    std::vector<T> result;
37
    std::istream_iterator<T> iter(is);
38
    std::istream_iterator<T> end;
39
    
40
    while (iter != end && *iter != sentinel) {
41
        result.push_back(*iter);
42
        ++iter;
43
    }
44
    
45
    return result;
46
}
47

48
int main() {
49
    // 测试从字符串读取
50
    std::string data = "1 2 3 4 5 6 7 8 9 10";
51
    auto numbers = read_from_string<int>(data);
52
    
53
    std::cout << "从字符串读取: ";
54
    for (int num : numbers) {
55
        std::cout << num << " ";
56
    }
57
    std::cout << "\n";
58
    
59
    // 测试读取指定数量
60
    std::istringstream iss(data);
61
    auto first_five = read_n_elements<int>(iss, 5);
62
    
63
    std::cout << "前5个数字: ";
64
    for (int num : first_five) {
65
        std::cout << num << " ";
66
    }
67
    std::cout << "\n";
68
    
69
    // 测试读取直到特定值
70
    std::string data2 = "1 2 3 4 0 5 6 7 8";
71
    std::istringstream iss2(data2);
72
    auto until_zero = read_until<int>(iss2, 0);
73
    
74
    std::cout << "读取到0之前: ";
75
    for (int num : until_zero) {
76
        std::cout << num << " ";
77
    }
78
    std::cout << "\n";
79
    
80
    return 0;
81
}

错误处理

xxxxxxxxxx
51
1
#include <iostream>
2
#include <sstream>
3
#include <iterator>
4
#include <vector>
5
#include <stdexcept>
6

7
template<typename T>
8
std::vector<T> safe_read_from_string(const std::string& data) {
9
    std::istringstream iss(data);
10
    std::vector<T> result;
11
    
12
    std::istream_iterator<T> iter(iss);
13
    std::istream_iterator<T> end;
14
    
15
    try {
16
        while (iter != end) {
17
            result.push_back(*iter);
18
            ++iter;
19
            
20
            // 检查流状态
21
            if (iss.fail() && !iss.eof()) {
22
                throw std::runtime_error("读取数据时发生错误");
23
            }
24
        }
25
    } catch (const std::exception& e) {
26
        std::cerr << "错误: " << e.what() << "\n";
27
        result.clear();
28
    }
29
    
30
    return result;
31
}
32

33
int main() {
34
    // 正常数据
35
    std::string good_data = "1 2 3 4 5";
36
    auto good_result = safe_read_from_string<int>(good_data);
37
    
38
    std::cout << "正常读取: ";
39
    for (int num : good_result) {
40
        std::cout << num << " ";
41
    }
42
    std::cout << "\n";
43
    
44
    // 包含错误的数据
45
    std::string bad_data = "1 2 abc 4 5";
46
    auto bad_result = safe_read_from_string<int>(bad_data);
47
    
48
    std::cout << "错误数据读取结果大小: " << bad_result.size() << "\n";
49
    
50
    return 0;
51
}

自定义输入流迭代器

xxxxxxxxxx
61
1
#include <iostream>
2
#include <iterator>
3
#include <sstream>
4
#include <vector>
5

6
template<typename T, typename Predicate>
7
class filtered_istream_iterator {
8
private:
9
    std::istream_iterator<T> iter;
10
    std::istream_iterator<T> end;
11
    Predicate pred;
12
    
13
    void advance_to_valid() {
14
        while (iter != end && !pred(*iter)) {
15
            ++iter;
16
        }
17
    }
18
    
19
public:
20
    filtered_istream_iterator(std::istream& is, Predicate p) 
21
        : iter(is), pred(p) {
22
        advance_to_valid();
23
    }
24
    
25
    filtered_istream_iterator() : pred(Predicate{}) {}
26
    
27
    const T& operator*() const { return *iter; }
28
    
29
    filtered_istream_iterator& operator++() {
30
        ++iter;
31
        advance_to_valid();
32
        return *this;
33
    }
34
    
35
    bool operator==(const filtered_istream_iterator& other) const {
36
        return iter == other.iter;
37
    }
38
    
39
    bool operator!=(const filtered_istream_iterator& other) const {
40
        return !(*this == other);
41
    }
42
};
43

44
int main() {
45
    std::string data = "1 2 3 4 5 6 7 8 9 10";
46
    std::istringstream iss(data);
47
    
48
    // 只读取偶数
49
    filtered_istream_iterator<int, std::function<bool(int)>> 
50
        even_iter(iss, [](int n) { return n % 2 == 0; });
51
    filtered_istream_iterator<int, std::function<bool(int)>> end_iter;
52
    
53
    std::cout << "偶数: ";
54
    while (even_iter != end_iter) {
55
        std::cout << *even_iter << " ";
56
        ++even_iter;
57
    }
58
    std::cout << "\n";
59
    
60
    return 0;
61
}

流的组合使用

xxxxxxxxxx
64
1
#include <iostream>
2
#include <sstream>
3
#include <iterator>
4
#include <vector>
5
#include <algorithm>
6
#include <numeric>
7

8
class DataProcessor {
9
private:
10
    std::vector<int> data;
11
    
12
public:
13
    void read_from_stream(std::istream& is) {
14
        std::istream_iterator<int> iter(is);
15
        std::istream_iterator<int> end;
16
        data.assign(iter, end);
17
    }
18
    
19
    void process_data() {
20
        // 排序
21
        std::sort(data.begin(), data.end());
22
        
23
        // 去重
24
        auto last = std::unique(data.begin(), data.end());
25
        data.erase(last, data.end());
26
    }
27
    
28
    void output_statistics() const {
29
        if (data.empty()) {
30
            std::cout << "没有数据\n";
31
            return;
32
        }
33
        
34
        int sum = std::accumulate(data.begin(), data.end(), 0);
35
        double average = static_cast<double>(sum) / data.size();
36
        
37
        std::cout << "数据统计:\n";
38
        std::cout << "  数量: " << data.size() << "\n";
39
        std::cout << "  总和: " << sum << "\n";
40
        std::cout << "  平均值: " << average << "\n";
41
        std::cout << "  最小值: " << *std::min_element(data.begin(), data.end()) << "\n";
42
        std::cout << "  最大值: " << *std::max_element(data.begin(), data.end()) << "\n";
43
    }
44
    
45
    const std::vector<int>& get_data() const { return data; }
46
};
47

48
int main() {
49
    std::string input_data = "5 2 8 2 1 9 5 3 7 1 6 4";
50
    std::istringstream iss(input_data);
51
    
52
    DataProcessor processor;
53
    processor.read_from_stream(iss);
54
    processor.process_data();
55
    processor.output_statistics();
56
    
57
    std::cout << "处理后的数据: ";
58
    for (int num : processor.get_data()) {
59
        std::cout << num << " ";
60
    }
61
    std::cout << "\n";
62
    
63
    return 0;
64
}