第一章: 引言
1.1 C++ Ranges库简介
C++ Ranges库是C++20标准的一部分，它为C++标准库引入了一种新的范式，旨在提供更现代、更安全、更高效的方式来处理序列和算法。Ranges库通过引入范围（ranges）、视图（views）、适配器（adaptors）等概念，使得对序列的操作更加灵活和表达力更强。
在传统的C++中，操作序列通常涉及迭代器（iterators）和算法（algorithms），这种方式虽然强大，但往往代码冗长且容易出错。Ranges库的出现，正是为了解决这些问题，它将迭代器和算法的操作抽象成更高层次的范围操作，使得代码更加简洁、清晰，同时也更加安全。
1.2 为什么要使用Ranges库
使用Ranges库有多个原因，其中最主要的是它提供了更高的抽象级别，使得对序列的操作更加直观和容易理解。此外，Ranges库还有以下优点：
- 更安全：通过减少对裸迭代器的直接操作，降低了出错的概率。
- 更高效：许多Ranges操作是惰性求值的，这意味着只有在需要时才进行计算，从而提高了性能。
- 更灵活：Ranges库提供了丰富的视图和适配器，使得对序列的处理更加灵活，可以轻松地进行过滤、转换等操作。
- 更现代：Ranges库是C++标准库向现代化演进的一部分，它体现了现代C++的设计理念和编程范式。
正如心理学家卡尔·罗杰斯（Carl Rogers）在《成为一位存在的人》中所说：“令人兴奋的不是过去，而是未来。” C++ Ranges库的引入，正是C++语言不断创新和发展的体现，它开辟了一条更现代、更高效的编程之路，值得每一位C++开发者去探索和应用。
第二章: 基础概念
2.1 范围（Ranges）
在C++ Ranges库中，范围（Range）是核心概念之一。它代表了一系列值的集合，这些值可以是连续的也可以是离散的，可以是有限的也可以是无限的。范围提供了一种统一的方式来表示和操作这些值的集合。
范围的本质是一对迭代器（Iterator），表示序列的开始和结束。在C++中，迭代器用于访问容器中的元素，而范围则将这对迭代器封装起来，提供了一种更抽象、更高级的操作接口。
范围的定义非常灵活，它可以是一个数组、一个标准容器（如std::vector、std::list等）、一个字符串，甚至是一个由范围适配器（Range Adaptor）生成的视图（View）。这种灵活性使得范围可以应用于各种不同的场景和需求。
在C++ Ranges库中，范围被分为两大类：
- 输入范围（Input Range）：最基本的范围类型，只支持单向迭代，即只能从开始向结束遍历元素。
- 前向范围（Forward Range）：除了支持单向迭代外，还支持多次遍历和元素访问。
此外，还有双向范围（Bidirectional Range）、随机访问范围（Random Access Range）等更高级的范围类型，它们提供了更丰富的操作和访问能力。
范围的引入，使得C++编程更加符合人类的直观认知。如哲学家亚里士多德（Aristotle）所说：“整体大于部分之和。” 范围作为一个整体，提供了比单个迭代器更丰富、更高效的操作方式，使得对序列的处理更加直观和高效。
2.2 迭代器（Iterators）
迭代器是C++中一个非常重要的概念，它是一种抽象的指针，用于访问和遍历容器中的元素。在C++ Ranges库中，迭代器仍然扮演着重要的角色，因为范围的本质是由一对迭代器表示的序列。
迭代器主要分为以下几类：
- 输入迭代器（Input Iterator）：支持读取元素，但不支持写入。它只能单向移动，并且每个元素只能遍历一次。
- 输出迭代器（Output Iterator）：支持写入元素，但不支持读取。它同样只能单向移动，并且每个元素只能遍历一次。
- 前向迭代器（Forward Iterator）：支持读写操作，并且可以多次遍历元素。
- 双向迭代器（Bidirectional Iterator）：在前向迭代器的基础上，增加了向后移动的能力。
- 随机访问迭代器（Random Access Iterator）：提供了最丰富的功能，支持随机访问任何元素，支持迭代器之间的距离计算，以及迭代器的加减操作。
迭代器的设计遵循了“最小权限原则”，即每种迭代器只提供其所需的最小操作集。这有助于降低错误的发生概率，并提高代码的安全性。
在使用迭代器时，需要注意迭代器失效的问题。当容器发生改变（如添加、删除元素）时，迭代器可能会失效，继续使用失效的迭代器将导致未定义行为。因此，合理地管理迭代器的生命周期和使用方式是非常重要的。
正如哲学家康德（Immanuel Kant）在《纯粹理性批判》中所说：“我们的知识起始于经验，但并不因此而发源于经验。” 迭代器作为访问容器元素的工具，是我们在编程中经验的起点，但我们对迭代器的理解和运用，需要超越单纯的经验，达到对其本质和规则的深刻把握。
2.3 定制点对象（Customization Point Objects, CPOs）
定制点对象（Customization Point Objects, 简称CPOs）是C++ Ranges库中的一个重要概念，它提供了一种机制，允许用户定制标准库中的行为，以适应特定的需求或类型。CPOs是一种特殊的函数对象，它们能够根据传入参数的类型自动选择最合适的实现。
在C++ Ranges库中，很多操作都是通过CPOs来实现的，例如std::ranges::begin、std::ranges::end、std::ranges::size等。这些CPOs允许我们以统一的方式处理不同类型的范围，无论它们是标准容器、数组还是由适配器生成的视图。
CPOs的一个关键特性是它们支持自定义类型。如果你有一个自定义的容器类型，你可以为它提供特化的begin和end函数，这样当使用std::ranges::begin和std::ranges::end时，就会自动调用你提供的特化版本，从而实现定制化的行为。
使用CPOs的好处是它提供了一种扩展标准库功能的方式，同时保持了接口的一致性和代码的可读性。它遵循了“开放/封闭原则”，即软件实体应该对扩展开放，对修改封闭。这意味着你可以在不修改现有代码的基础上，通过添加新的特化来扩展功能。
正如心理学家卡尔·荣格（Carl Jung）所说：“创造性来自于潜意识的无限可能性。” CPOs正是这种创造性的体现，它们为C++程序员提供了一种灵活的工具，使得我们可以根据自己的需求定制和扩展标准库的行为，从而充分发挥我们的创造潜能。
2.4 迭代器与Ranges的关系
在C++ Ranges库中，迭代器（Iterators）和Ranges之间存在着密切的关系。Ranges是一种高级抽象，它代表了一个序列或集合，而迭代器则是访问和遍历这个序列中元素的工具。
- Ranges基于迭代器：Ranges的本质是由一对迭代器定义的，这对迭代器分别指向序列的开始和结束。因此，迭代器是构建Ranges的基础，没有迭代器就没有Ranges。
- 迭代器支持多种类型：在C++中，迭代器有多种类型，如输入迭代器、输出迭代器、前向迭代器、双向迭代器和随机访问迭代器。这些不同类型的迭代器支持不同级别的操作。Ranges库能够处理这些不同类型的迭代器，从而支持多种不同类型的Ranges。
- Ranges提供了对迭代器的抽象：虽然Ranges是基于迭代器构建的，但在使用Ranges时，我们通常不需要直接处理迭代器。Ranges库提供了一系列操作和算法，允许我们直接对Ranges进行操作，而不是对单个迭代器进行操作。这使得代码更加简洁和易于理解。
- 迭代器的灵活性增强了Ranges的能力：由于迭代器的多样性，Ranges能够表示各种类型的序列，包括但不限于标准容器、数组、字符串和自定义类型。这种灵活性使得Ranges成为处理序列数据的强大工具。
正如哲学家亚里士多德（Aristotle）所说：“整体大于部分之和。” 在C++ Ranges库中，迭代器是构建Ranges的基本部分，而Ranges则是对迭代器进行了更高级的抽象。通过结合使用迭代器和Ranges，我们可以更有效地处理序列数据，编写更简洁、更可读的代码。
以下是一个C++示例，展示了如何使用迭代器和Ranges遍历一个std::vector中的数据，并对比了两种方法的区别：
#include <iostream> #include <vector> #include <ranges> int main() { std::vector<int> numbers = {1, 2, 3, 4, 5}; // 使用迭代器遍历 std::cout << "使用迭代器遍历:" << std::endl; for (auto it = numbers.begin(); it != numbers.end(); ++it) { std::cout << *it << " "; } std::cout << std::endl; // 使用Ranges遍历 std::cout << "使用Ranges遍历:" << std::endl; for (int num : numbers | std::views::all) { // std::views::all创建一个覆盖整个范围的视图 std::cout << num << " "; } std::cout << std::endl; return 0; }
输出：
使用迭代器遍历: 1 2 3 4 5 使用Ranges遍历: 1 2 3 4 5
在这个示例中，我们首先使用传统的迭代器方法遍历std::vector，然后使用C++ Ranges的方式遍历相同的数据。两种方法都能达到相同的效果，但是Ranges的方法更加简洁和直观。
Ranges的优势体现在：
- 代码简洁：使用Ranges遍历时，不需要显式地声明迭代器和结束条件，代码更加简洁。
- 易于理解：Ranges的方式更接近自然语言，更容易理解和维护。
- 灵活性：在这个简单的示例中，我们只是直接遍历了整个范围，但是Ranges还支持通过各种适配器进行过滤、转换等操作，提供了更大的灵活性。
底层实现上，std::views::all创建的视图确实与直接使用迭代器遍历整个范围非常相似。std::views::all是一个范围适配器，它接受一个范围作为输入，并返回一个新的范围，这个新范围提供与原始范围相同的迭代器和哨兵（sentinel，用于表示范围结束的特殊值）。
因此，当你使用std::views::all遍历一个std::vector时，底层的迭代机制实际上与直接使用迭代器遍历相同。但是，值得注意的是，std::views::all只是Ranges库中众多适配器之一，其他适配器如std::views::filter、std::views::transform等提供了更复杂的迭代行为，这些是直接使用迭代器无法轻易实现的。
总的来说，虽然在某些简单情况下，使用Ranges和直接使用迭代器的底层实现可能相似，但Ranges库提供了更高层次的抽象，使得在更复杂的场景下能够更简洁、更灵活地处理序列数据。
第三章: 范围视图
3.1 创建视图
在C++ Ranges库中，视图（views）是对范围（ranges）的轻量级引用，它们提供了一种惰性求值的方式来转换和过滤数据。创建视图的方法多种多样，下面我们将介绍一些常见的创建视图的方法。
3.1.1 使用视图适配器
视图适配器（view adaptors）是一类用于生成视图的函数对象。例如，std::views::filter 和 std::views::transform 是两个常用的视图适配器，分别用于过滤和转换数据：
#include <ranges> #include <vector> #include <iostream> int main() { std::vector<int> numbers = {1, 2, 3, 4, 5}; auto even_numbers = numbers | std::views::filter([](int n) { return n % 2 == 0; }); auto squared_numbers = even_numbers | std::views::transform([](int n) { return n * n; }); for (int n : squared_numbers) { std::cout << n << ' '; } // Output: 4 16 }
在这个例子中，我们首先使用 std::views::filter 创建了一个只包含偶数的视图 even_numbers，然后使用 std::views::transform 创建了一个包含偶数平方的视图 squared_numbers。
3.1.2 使用范围工厂函数
范围库还提供了一些工厂函数来直接创建视图。例如，std::views::iota 可以创建一个表示整数序列的视图：
#include <ranges> #include <iostream> int main() { auto numbers = std::views::iota(1, 6); // [1, 2, 3, 4, 5] for (int n : numbers) { std::cout << n << ' '; } // Output: 1 2 3 4 5 }
3.1.3 使用视图的成员函数
一些视图类型提供了成员函数来进一步转换或过滤数据。例如，std::ranges::subrange 类型提供了 take 和 drop 成员函数来获取子范围：
#include <ranges> #include <vector> #include <iostream> int main() { std::vector<int> numbers = {1, 2, 3, 4, 5}; auto subrange = std::ranges::subrange(numbers.begin(), numbers.end()); auto first_three = subrange.take(3); for (int n : first_three) { std::cout << n << ' '; } // Output: 1 2 3 }
在这个例子中，我们使用 std::ranges::subrange 创建了一个表示整个 numbers 向量的视图，然后使用 take 成员函数获取了前三个元素的子范围。
通过这些方法，我们可以灵活地创建和组合视图，以实现对数据的高效和灵活的处理。
3.2 常用视图类型
C++ Ranges库提供了多种视图类型，用于不同的数据处理需求。下面是一些常用视图类型的介绍和示例：
3.2.1 过滤视图（Filter View）
过滤视图（std::views::filter）用于从原始范围中过滤出满足特定条件的元素：
#include <ranges> #include <vector> #include <iostream> int main() { std::vector<int> numbers = {1, 2, 3, 4, 5}; auto even_numbers = numbers | std::views::filter([](int n) { return n % 2 == 0; }); for (int n : even_numbers) { std::cout << n << ' '; } // Output: 2 4 }
3.2.2 转换视图（Transform View）
转换视图（std::views::transform）用于对原始范围中的每个元素应用一个转换函数：
#include <ranges> #include <vector> #include <iostream> int main() { std::vector<int> numbers = {1, 2, 3, 4, 5}; auto squared_numbers = numbers | std::views::transform([](int n) { return n * n; }); for (int n : squared_numbers) { std::cout << n << ' '; } // Output: 1 4 9 16 25 }
3.2.3 切片视图（Slice View）
切片视图（std::views::slice）用于从原始范围中提取一个连续的子范围：
#include <ranges> #include <vector> #include <iostream> int main() { std::vector<int> numbers = {1, 2, 3, 4, 5}; auto middle_numbers = numbers | std::views::slice(1, 4); for (int n : middle_numbers) { std::cout << n << ' '; } // Output: 2 3 4 }
3.2.4 其他视图类型
除了上述视图类型外，C++ Ranges库还提供了其他多种视图类型，例如：
std::views::reverse：反转视图，用于反转原始范围的顺序。std::views::take：取前N个元素的视图。std::views::drop：丢弃前N个元素的视图。std::views::join：连接视图，用于将多个范围连接成一个范围。std::views::split：分割视图，用于根据分隔符将原始范围分割成多个子范围。
这些视图类型提供了灵活的工具，使得对序列的处理更加方便和高效。
3.3 视图的惰性求值
在C++ Ranges库中，视图的一个关键特性是惰性求值（lazy evaluation）。这意味着视图中的元素只有在被访问时才会被计算，而不是在视图创建时就立即计算。这种特性使得视图非常高效，尤其是在处理大型数据集或复杂的数据流时。
3.3.1 惰性求值的优势
惰性求值带来了几个重要的优势：
- 性能提升：只计算需要的元素，避免了不必要的计算，从而提高了性能。
- 内存节省：不需要存储整个计算结果，只在需要时才计算，因此可以节省内存。
- 无限序列：可以表示潜在无限的序列，例如生成器或无限序列视图。
3.3.2 惰性求值的示例
下面的示例展示了惰性求值的工作方式：
#include <ranges> #include <iostream> int main() { auto numbers = std::views::iota(1) | std::views::transform([](int n) { std::cout << "Computing " << n << std::endl; return n * n; }); for (int i : numbers | std::views::take(5)) { std::cout << "Value: " << i << std::endl; } }
输出结果：
Computing 1 Value: 1 Computing 2 Value: 4 Computing 3 Value: 9 Computing 4 Value: 16 Computing 5 Value: 25
在这个例子中，numbers 视图是一个无限序列，它通过 std::views::iota 生成整数序列，并通过 std::views::transform 对每个元素进行平方计算。但是，实际的计算只发生在元素被访问时，即在循环中迭代时。这就是惰性求值的体现。
3.3.3 注意事项
虽然惰性求值带来了很多好处，但在使用时也需要注意一些事项：
- 副作用：避免在视图的函数中使用有副作用的操作，因为它们可能会被多次调用或根本不被调用。
- 性能影响：虽然惰性求值可以提高性能，但在某些情况下，频繁地访问视图元素也可能导致性能下降。需要根据具体情况权衡使用。
总的来说，视图的惰性求值是C++ Ranges库中一个强大且灵活的特性，它为高效地处理数据提供了强有力的支持。
第四章: 范围算法
4.1 算法概述
C++ Ranges库中的范围算法是对传统STL算法的扩展和改进。它们直接作用于范围（ranges），而不是迭代器对（iterator pairs），从而使得代码更加简洁和易于理解。这些算法涵盖了排序、搜索、变换、统计等多种操作，旨在提供更高效、更安全的序列处理能力。
4.1.1 特点
- 统一的接口：所有范围算法都采用统一的接口，接受范围作为参数，这使得它们的使用更加一致和直观。
- 惰性求值：许多范围算法支持惰性求值，即只有在需要时才进行计算，这有助于提高性能。
- 安全性：通过减少裸迭代器的使用，范围算法降低了出错的风险。
4.1.2 常用算法
- 排序算法：如
ranges::sort，对范围内的元素进行排序。 - 搜索算法：如
ranges::find，在范围内查找指定的元素。 - 变换算法：如
ranges::transform，对范围内的每个元素应用给定的函数。 - 统计算法：如
ranges::count，计算范围内满足特定条件的元素数量。
4.1.3 使用示例
下面是一个使用ranges::sort对一个std::vector进行排序的示例：
#include <vector> #include <iostream> #include <ranges> int main() { std::vector<int> v = {5, 3, 1, 4, 2}; std::ranges::sort(v); for (int i : v) { std::cout << i << " "; } return 0; }
输出结果将是：1 2 3 4 5
正如哲学家亚里士多德在《尼各马科伦理学》中所说：“我们是我们反复做的事情。因此，卓越不是一个行为，而是一个习惯。” 在编程中，掌握并反复使用范围算法，能够提升我们代码的质量和效率，使卓越成为一种编程习惯。
4.2 排序和搜索
4.2.1 排序算法
排序是编程中常见的操作之一，C++ Ranges库提供了多种排序算法，使得对序列的排序更加方便和高效。
ranges::sort：对给定范围内的元素进行排序，默认使用operator<进行比较。ranges::stable_sort：对范围内的元素进行稳定排序，保持相等元素的相对顺序。ranges::partial_sort：对范围内的一部分元素进行排序，使得前N个元素是整个范围中最小的N个元素。
4.2.2 搜索算法
搜索是另一种常见的操作，用于在序列中查找特定的元素或满足特定条件的元素。C++ Ranges库提供了多种搜索算法：
ranges::find：在给定范围内查找指定的值，返回指向第一个匹配元素的迭代器，如果未找到则返回范围的末尾。ranges::find_if：在给定范围内查找满足特定条件的元素，条件通过一个谓词函数指定。ranges::binary_search：对已排序的范围进行二分搜索，检查指定的值是否存在。
4.2.3 使用示例
下面是一个使用ranges::find_if查找第一个偶数的示例：
#include <vector> #include <iostream> #include <ranges> int main() { std::vector<int> v = {1, 3, 4, 6, 5}; auto it = std::ranges::find_if(v, [](int i) { return i % 2 == 0; }); if (it != v.end()) { std::cout << "First even number: " << *it << std::endl; } else { std::cout << "No even numbers found." << std::endl; } return 0; }
输出结果将是：First even number: 4
通过使用C++ Ranges库中的排序和搜索算法，我们可以更加简洁和高效地处理序列。正如心理学家威廉·詹姆斯在《心理学原理》中所说：“最简单和最自然的事情往往是最神圣的。” 在编程中，简洁和直观的代码往往是最有效和最易维护的。
4.3 数值算法
C++ Ranges库不仅提供了排序和搜索算法，还包含了一系列用于数值计算的算法，使得对序列中的数值进行处理变得更加方便和高效。
4.3.1 常用数值算法
ranges::accumulate：计算给定范围内所有元素的累加和，可以指定一个初始值和一个二元操作函数。ranges::reduce：与accumulate类似，但是更适合并行计算。ranges::inner_product：计算两个范围的内积，即对应元素乘积的累加和。ranges::partial_sum：计算给定范围内每个元素的前缀和，并将结果存储在另一个范围中。
4.3.2 使用示例
下面是一个使用ranges::accumulate计算整数序列累加和的示例：
#include <vector> #include <iostream> #include <numeric> #include <ranges> int main() { std::vector<int> v = {1, 2, 3, 4, 5}; int sum = std::ranges::accumulate(v, 0); std::cout << "Sum of elements: " << sum << std::endl; return 0; }
输出结果将是：Sum of elements: 15
4.3.3 数值算法的应用
C++ Ranges库中的数值算法广泛应用于数据分析、统计计算、信号处理等领域。它们提供了一种简洁高效的方式来进行数值计算，使得处理复杂的数值数据变得更加容易。
正如哲学家休谟（David Hume）在《人性论》中所说：“习惯是一切实践科学的指导原则。” 在编程中，熟练运用C++ Ranges库中的数值算法，可以使我们更加高效地处理数值数据，形成良好的编程习惯。
4.4 范围算法与标准算法的对比
C++ Ranges库中的范围算法是对传统STL算法的扩展和改进。虽然它们在功能上与标准算法相似，但在使用方式和设计理念上存在一些显著的区别。
4.4.1 接口的统一性
- 标准算法：通常接受迭代器对作为参数，表示操作的序列范围。
- 范围算法：直接接受范围作为参数，使得代码更加简洁和直观。
4.4.2 惰性求值和管道操作
- 标准算法：立即对序列进行操作和计算。
- 范围算法：支持惰性求值，可以通过管道操作符（
|）将多个操作组合在一起，从而实现更灵活的数据处理流程。
4.4.3 安全性和易用性
- 标准算法：需要手动管理迭代器，容易出错。
- 范围算法：通过减少对裸迭代器的直接操作，提高了代码的安全性和易用性。
4.4.4 使用示例对比
下面是一个使用标准算法和范围算法进行元素过滤的对比示例：
// 使用标准算法 std::vector<int> v = {1, 2, 3, 4, 5}; std::vector<int> result; std::copy_if(v.begin(), v.end(), std::back_inserter(result), [](int i) { return i % 2 == 0; }); // 使用范围算法 auto result = v | std::views::filter([](int i) { return i % 2 == 0; });
在这个示例中，使用范围算法的代码更加简洁和直观。
正如心理学家亚伯拉罕·马斯洛（Abraham Maslow）在《人类动机论》中所说：“如果你只有一把锤子，你会把每个问题都当作钉子。” 在编程中，了解并灵活运用多种工具和方法，可以帮助我们更有效地解决问题。C++ Ranges库提供了一套强大的工具，使得序列操作更加灵活和高效。
第五章: 范围适配器
5.1 适配器的作用
在C++ Ranges库中，适配器（Adaptors）是一类特殊的对象，它们的主要作用是对范围（Ranges）进行转换和处理，以生成新的视图（Views）。这些适配器可以看作是对范围进行操作的工具，它们能够实现对序列的过滤、转换、排序等操作。
适配器的一个核心特性是它们通常是惰性求值的，这意味着它们不会立即对整个序列进行操作，而是在需要时才进行计算。这种特性使得适配器非常高效，特别是在处理大型序列或进行链式操作时。
在C++ Ranges库中，适配器可以分为两类：
- 视图适配器（View Adaptors）：这些适配器用于创建新的视图。例如，
std::views::filter可以用于创建一个只包含满足特定条件的元素的视图，而std::views::transform可以用于创建一个对原始序列中的每个元素应用某个函数的视图。 - 动作适配器（Action Adaptors）：这些适配器用于对范围进行操作，但不返回新的视图。例如，
std::ranges::sort可以用于对序列进行排序。
适配器的使用大大简化了对序列的操作，使得代码更加简洁和易于理解。例如，使用适配器，我们可以轻松地将一个序列转换为另一个序列，或者从一个序列中过滤出满足特定条件的元素。
正如哲学家亚里士多德（Aristotle）所说：“整体不仅仅是部分的总和，而是部分之间某种秩序的总和。” 在C++ Ranges库中，适配器就像是构建整体的秩序，它们使得对序列的操作更加有序和高效，从而使整个编程过程更加流畅和优雅。
5.2 常用适配器
在C++ Ranges库中，有许多常用的适配器可以帮助开发者更高效地处理序列。以下是一些常用适配器的简要介绍：
- filter：该适配器用于创建一个新的视图，其中只包含满足给定谓词的元素。例如，
std::views::filter([](int x) { return x % 2 == 0; })可以用于创建一个只包含偶数的视图。 - transform：该适配器用于创建一个新的视图，其中的每个元素都是通过应用给定的函数转换得到的。例如，
std::views::transform([](int x) { return x * 2; })可以用于创建一个每个元素都是原始元素的两倍的视图。 - take：该适配器用于创建一个新的视图，其中只包含原始序列的前n个元素。例如，
std::views::take(3)可以用于创建一个只包含前三个元素的视图。 - drop：该适配器用于创建一个新的视图，其中排除了原始序列的前n个元素。例如，
std::views::drop(3)可以用于创建一个排除了前三个元素的视图。 - reverse：该适配器用于创建一个新的视图，其中的元素顺序与原始序列相反。例如，
std::views::reverse可以用于创建一个元素顺序颠倒的视图。 - unique：该适配器用于创建一个新的视图，其中的元素是原始序列中唯一的元素。例如，
std::views::unique可以用于创建一个只包含唯一元素的视图。
这些适配器可以单独使用，也可以组合使用，以实现更复杂的序列操作。例如，我们可以结合使用filter和transform适配器来创建一个新的视图，其中包含原始序列中的偶数元素的平方：
auto even_squares = std::views::filter([](int x) { return x % 2 == 0; }) | std::views::transform([](int x) { return x * x; });
正如数学家卡尔·弗里德里希·高斯（Carl Friedrich Gauss）所说：“数学是科学的皇后，数论是数学的皇后。” 在C++ Ranges库中，适配器就像是数学中的操作符，它们使得对序列的操作变得更加灵活和强大，从而使整个编程过程更加高效和优雅。
5.3 适配器的组合
C++ Ranges库的一个强大特性是适配器的组合能力。通过组合不同的适配器，我们可以构建复杂的序列操作，而这些操作在执行时仍然保持高效和惰性求值的特性。
适配器可以通过管道操作符|进行组合。这种方式的语法类似于Unix中的管道，它允许我们将多个操作串联起来，形成一个操作流水线。例如：
auto processed = my_range | std::views::filter(predicate) | std::views::transform(transformation);
在这个例子中，my_range首先被filter适配器处理，只保留满足predicate的元素；然后，结果被transform适配器处理，对每个元素应用transformation函数。整个操作是惰性的，只有在迭代processed时，才会逐步执行这些操作。
适配器的组合不仅限于两个，我们可以根据需要将任意多个适配器组合在一起。这使得我们可以以非常灵活和表达力强的方式来处理序列。
正如哲学家亚里士多德（Aristotle）所说：“整体是部分之和。” 在C++ Ranges库中，通过适配器的组合，我们可以将简单的操作构建成复杂的整体，从而实现对序列的高效和灵活处理。这种组合的能力是C++ Ranges库的核心优势之一，它极大地提高了C++语言处理序列的能力和表达力。
第六章: 高级特性
6.1 Assignable Wrapper和Non-propagating Cache
在C++ Ranges库中，有一些高级特性是为了解决特定问题而设计的。这些特性可能不会在日常编程中频繁使用，但了解它们的存在和作用可以帮助我们更深入地理解Ranges库的工作原理，并在需要时加以应用。
6.1.1 Assignable Wrapper
Assignable Wrapper是一种包装器，它的主要目的是为了使一些不具有赋值能力的对象变得可赋值。在C++ Ranges库中，某些范围适配器可能需要对其包含的元素或函数对象进行赋值操作。然而，并非所有的对象都是可赋值的，这时就需要Assignable Wrapper来提供帮助。
Assignable Wrapper通过内部持有一个可赋值的副本来实现这一点。当需要对原始对象进行赋值时，实际上是对这个内部副本进行赋值。这样，即使原始对象不具有赋值能力，也可以通过Assignable Wrapper间接实现赋值操作。
6.1.2 Non-propagating Cache
Non-propagating Cache是一种用于缓存计算结果的机制，它在C++ Ranges库中的某些范围适配器中得到应用。这种缓存机制的特点是“非传播性”，即它不会在复制或移动操作中传递缓存的内容。
Non-propagating Cache的行为类似于std::optional<T>，它可以用来存储一个可选的值。当缓存中有值时，可以避免重复计算；当缓存为空时，表示需要重新计算。这种机制可以提高效率，尤其是在处理复杂或耗时的计算时。
然而，与std::optional<T>不同的是，Non-propagating Cache在对象被复制或移动后，缓存的内容不会被保留。这意味着每个对象实例都有自己独立的缓存，它们之间不会相互影响。
在实际应用中，Assignable Wrapper和Non-propagating Cache是C++ Ranges库高级特性的两个例子。它们的设计反映了C++语言的一个哲学思想：在追求效率的同时，也要保持代码的安全性和清晰性。正如哲学家弗里德里希·尼采（Friedrich Nietzsche）所说：“有组织的复杂性是生命的一种表现。” 在C++编程中，我们通过合理使用这些高级特性，可以使我们的代码既高效又可靠，从而更好地应对复杂的编程挑战。
6.2 辅助函数和概念
C++ Ranges库中的一些高级特性依赖于特定的辅助函数和概念，这些工具用于支持库的内部实现，同时也为库的扩展提供了灵活性。虽然这些辅助函数和概念主要用于库的内部，但了解它们可以帮助我们更深入地理解Ranges库的工作原理，并为我们自定义范围和适配器提供灵感。
6.2.1 辅助函数
C++ Ranges库中的一些辅助函数是展示性质的（exposition-only），这意味着它们不是库的正式接口的一部分，而是用于说明库的工作原理。以下是一些常见的辅助函数：
possibly-const-range：这是一个用于处理深度常量范围（deep-const range）的函数，如果范围是深度常量的，则返回一个常量限定的范围，否则返回原始范围。as-const-pointer：这个函数用于获取指向常量类型对象的指针，保证了对对象的只读访问。
6.2.2 辅助概念
辅助概念（exposition-only concepts）用于描述某些类型的属性，但它们不是标准库接口的一部分。以下是一些常见的辅助概念：
simple-view：这个概念用于检测一个范围是否是一个简单视图（simple view），即它是一个视图（view）且其常量和非常量形式具有相同的迭代器和哨兵类型。has-arrow：这个概念用于检测一个输入迭代器（input iterator）是否具有箭头操作符（operator->），这对于指针类型的迭代器自然成立，对于其他类型的迭代器，则需要该迭代器提供相应的成员函数。
正如哲学家亚里士多德（Aristotle）所说：“整体不仅仅是部分的总和，而且还有部分之间的排列。” 在C++ Ranges库中，这些辅助函数和概念虽然是库的“部分”，但它们在库的整体设计中起着重要的作用，使得库的功能更加完整和协调。通过理解这些辅助工具，我们可以更好地掌握C++ Ranges库的精髓，并在实践中灵活运用这些知识。
6.3 自定义范围和适配器
C++ Ranges库提供了一套丰富的工具和抽象，使得开发者可以根据自己的需求自定义范围（ranges）和适配器（adaptors）。这种灵活性使得Ranges库不仅适用于标准库中的容器和算法，还可以扩展到用户定义的类型和操作。
6.3.1 自定义范围
自定义范围可以通过实现特定的接口来创建，这通常涉及定义迭代器（iterator）和哨兵（sentinel）类型，以及相应的begin()和end()成员函数。以下是一个简单的自定义范围示例：
class MyRange { public: // 迭代器类型定义 class Iterator { public: // 迭代器需要的类型和操作定义... }; // 返回范围的起始迭代器 Iterator begin() const { /* 实现... */ } // 返回范围的结束哨兵 Iterator end() const { /* 实现... */ } };
6.3.2 自定义适配器
自定义适配器允许开发者定义新的范围操作，这可以通过继承现有的适配器或创建全新的适配器来实现。以下是一个简单的自定义适配器示例：
class MyAdapter : public std::ranges::view_interface<MyAdapter> { public: // 适配器的构造函数和其他成员函数... // 必须提供的迭代器和哨兵类型 using iterator = /* 定义迭代器类型 */; using sentinel = /* 定义哨兵类型 */; // 必须提供的begin()和end()函数 iterator begin() const { /* 实现... */ } sentinel end() const { /* 实现... */ } };
自定义范围和适配器的设计和实现需要遵循C++ Ranges库的规范和约定，以确保它们能够无缝地与库中的其他组件协作。这种自定义能力极大地增强了C++ Ranges库的灵活性和通用性，使得它可以适应各种不同的编程场景和需求。
正如心理学家阿尔弗雷德·阿德勒（Alfred Adler）所说：“人类的主要任务在于发现自己将要成为什么样的人。” 在C++编程的世界中，通过自定义范围和适配器，开发者可以发挥创造力，设计出符合自己需求的高效、灵活的解决方案，从而实现更高层次的编程表达和性能优化。
第七章: 实际应用案例
7.1 数据处理
在数据处理领域，C++ Ranges库提供了强大而灵活的工具，使得对数据的操作变得更加简洁和高效。以下是一些利用Ranges库进行数据处理的实例。
7.1.1 过滤数据
假设我们有一个包含整数的容器，我们想要过滤出所有的偶数。使用Ranges库，我们可以轻松实现这一操作：
#include <vector> #include <ranges> #include <iostream> int main() { std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; auto even_numbers = numbers | std::views::filter([](int n) { return n % 2 == 0; }); for (int n : even_numbers) { std::cout << n << " "; } // 输出: 2 4 6 8 10 }
在这个例子中，我们使用了std::views::filter适配器来创建一个新的视图，该视图只包含满足给定条件（即为偶数）的元素。
7.1.2 数据转换
接下来，假设我们想要对容器中的每个元素应用一个函数，例如将每个数乘以2。这可以通过std::views::transform适配器轻松完成：
#include <vector> #include <ranges> #include <iostream> int main() { std::vector<int> numbers = {1, 2, 3, 4, 5}; auto doubled_numbers = numbers | std::views::transform([](int n) { return n * 2; }); for (int n : doubled_numbers) { std::cout << n << " "; } // 输出: 2 4 6 8 10 }
这个例子展示了如何使用std::views::transform适配器来创建一个新的视图，该视图包含原始元素经过给定函数变换后的结果。
7.1.3 数据聚合
最后，假设我们想要计算容器中所有元素的总和。虽然这不是Ranges库的直接功能，但我们可以结合使用std::reduce算法和Ranges来实现：
#include <vector> #include <numeric> #include <ranges> int main() { std::vector<int> numbers = {1, 2, 3, 4, 5}; int sum = std::reduce(std::begin(numbers), std::end(numbers)); std::cout << "Sum: " << sum << std::endl; // 输出: Sum: 15 }
在这个例子中，我们使用了std::reduce算法来计算范围内所有元素的总和。虽然这不是一个纯粹的Ranges操作，但它展示了如何将Ranges与标准库中的其他算法结合使用。
通过这些例子，我们可以看到C++ Ranges库在数据处理方面的强大能力。它不仅使代码更加简洁易读，还提高了开发效率和程序性能。正如哲学家弗里德里希·尼采（Friedrich Nietzsche）所说：“在混乱中寻找简单，在纷扰中寻找和谐。” Ranges库正是在复杂的数据操作中提供了简单而优雅的解决方案。
7.2 算法优化
C++ Ranges库不仅能够简化数据处理的代码，还可以帮助优化算法的性能。下面是一些使用Ranges库进行算法优化的示例。
7.2.1 惰性求值优化
在使用标准算法时，每个算法调用通常都会遍历整个序列。然而，使用Ranges库，许多操作是惰性求值的，这意味着只有在需要时才会进行计算。这可以减少不必要的遍历，从而提高性能。
例如，假设我们想要找到一个序列中第一个满足某个条件的元素：
#include <vector> #include <ranges> #include <iostream> int main() { std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; auto result = numbers | std::views::filter([](int n) { return n % 3 == 0; }) | std::views::take(1); for (int n : result) { std::cout << n << std::endl; break; // 只需要第一个满足条件的元素 } // 输出: 3 }
在这个例子中，即使filter适配器处理了整个序列，take适配器确保只有第一个满足条件的元素被计算和访问，从而优化了性能。
7.2.2 管道式组合优化
Ranges库允许通过管道操作符（|）将多个操作组合在一起，形成一个操作管道。这种方式不仅使代码更加清晰，还可以避免创建不必要的中间序列，从而优化性能。
例如，假设我们想要对一个序列进行过滤、转换，然后计算结果的总和：
#include <vector> #include <ranges> #include <numeric> #include <iostream> int main() { std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; auto pipeline = numbers | std::views::filter([](int n) { return n % 2 == 0; }) | std::views::transform([](int n) { return n * 3; }); int sum = std::accumulate(std::begin(pipeline), std::end(pipeline), 0); std::cout << "Sum: " << sum << std::endl; // 输出: Sum: 90 }
在这个例子中，通过管道式组合，我们避免了创建额外的中间序列，直接在最终结果上进行累加，从而提高了算法的效率。
7.2.3 自定义视图优化
有时，标准库提供的视图和适配器可能无法完全满足需求。此时，我们可以创建自定义视图来优化特定的算法场景。
例如，假设我们需要一个视图，它可以将序列中的每个元素转换为其平方：
#include <ranges> #include <vector> #include <iostream> template <std::ranges::input_range R> auto square_view(R&& range) { return std::views::transform(std::forward<R>(range), [](auto&& elem) { return elem * elem; }); } int main() { std::vector<int> numbers = {1, 2, 3, 4, 5}; for (int n : square_view(numbers)) { std::cout << n << " "; } // 输出: 1 4 9 16 25 }
在这个例子中，我们定义了一个square_view函数，它接受一个范围并返回一个视图，该视图在迭代时会将每个元素转换为其平方。这种自定义视图可以针对特定需求进行优化，提高算法的效率和灵活性。
通过这些示例，我们可以看到C++ Ranges库在算法优化方面的强大能力。它不仅简化了代码，还提供了多种方式来提高性能，使得C++编程更加高效和现代化。正如数学家兼哲学家阿尔弗雷德·诺斯·怀特海（Alfred North Whitehead）所说：“简单性和直接性是真正的复杂性的标志。” C++ Ranges库正是通过简化和优化，揭示了算法处理的真正复杂性。
7.3 自定义视图和适配器的开发
C++ Ranges库提供了强大的工具集，但有时我们可能需要根据特定需求开发自定义视图和适配器。下面是一些开发自定义视图和适配器的示例。
7.3.1 开发自定义视图
假设我们需要一个视图，它可以将序列中的字符串转换为大写形式。我们可以创建一个自定义视图来实现这个功能：
#include <ranges> #include <string> #include <vector> #include <iostream> #include <algorithm> #include <cctype> template <std::ranges::input_range R> auto to_upper_view(R&& range) { return std::views::transform(std::forward<R>(range), [](std::string s) { std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::toupper(c); }); return s; }); } int main() { std::vector<std::string> words = {"hello", "world", "ranges"}; for (const auto& word : to_upper_view(words)) { std::cout << word << " "; } // 输出: HELLO WORLD RANGES }
在这个例子中，我们定义了一个to_upper_view函数，它接受一个字符串序列的范围并返回一个视图，该视图在迭代时会将每个字符串转换为大写形式。
7.3.2 开发自定义适配器
假设我们需要一个适配器，它可以对序列应用一个复杂的转换逻辑。我们可以创建一个自定义适配器来实现这个功能：
#include <ranges> #include <vector> #include <iostream> template <typename Func> class custom_adaptor { public: explicit custom_adaptor(Func func) : func_(std::move(func)) {} template <std::ranges::input_range R> friend auto operator|(R&& range, const custom_adaptor& adaptor) { return std::views::transform(std::forward<R>(range), adaptor.func_); } private: Func func_; }; auto make_custom_adaptor(auto func) { return custom_adaptor(std::move(func)); } int main() { std::vector<int> numbers = {1, 2, 3, 4, 5}; auto adaptor = make_custom_adaptor([](int n) { return n * n - 1; }); for (int n : numbers | adaptor) { std::cout << n << " "; } // 输出: 0 3 8 15 24 }
在这个例子中，我们定义了一个custom_adaptor类，它接受一个函数并通过管道操作符|将其应用于一个序列。我们还定义了一个make_custom_adaptor函数来方便创建适配器实例。
通过开发自定义视图和适配器，我们可以扩展C++ Ranges库的功能，使其更好地满足特定需求。这种灵活性是Ranges库的一个重要优势，它鼓励开发者根据自己的需求进行创新和定制。正如哲学家亨利·戴维·梭罗（Henry David Thoreau）所说：“创新是真正的天才的标志。”通过开发自定义视图和适配器，C++开发者可以展现他们的创新能力，同时提高代码的效率和表达力。
第八章: 总结和展望
8.1 Ranges库的优势和局限
C++ Ranges库是C++20标准的一部分，它为C++标准库引入了一种新的范式，提供了更现代、更安全、更高效的方式来处理序列和算法。它通过引入范围（ranges）、视图（views）、适配器（adaptors）等概念，使得对序列的操作更加灵活和表达力更强。
优势：
- 更高的抽象级别：Ranges库提供了一种更高层次的抽象，使得对序列的操作更加直观和容易理解。
- 更安全的代码：通过减少对裸迭代器的直接操作，降低了出错的概率。
- 更高的性能：许多Ranges操作是惰性求值的，这意味着只有在需要时才进行计算，从而提高了性能。
- 更灵活的操作：Ranges库提供了丰富的视图和适配器，使得对序列的处理更加灵活，可以轻松地进行过滤、转换等操作。
局限：
- 学习曲线：对于初学者来说，Ranges库的概念和语法可能有些复杂，需要一定的学习和适应时间。
- 编译时间：由于Ranges库的复杂性，使用它的代码可能会有较长的编译时间。
- 兼容性：Ranges库是C++20的新特性，可能不被所有编译器完全支持。
8.2 未来发展趋势
C++ Ranges库的引入标志着C++标准库向现代化和高效化的重要一步。随着C++社区的不断发展和技术的进步，我们可以预见Ranges库将会继续完善和扩展，以满足更多的使用场景和需求。
未来的发展趋势可能包括：
- 更多的视图和适配器：为了满足更多样化的需求，可能会引入更多的视图和适配器。
- 性能优化：随着对Ranges库的深入了解和使用，将会有更多的性能优化技术出现。
- 更广泛的支持：随着C++20标准的普及，Ranges库将得到更广泛的支持和应用。
正如心理学家亚伯拉罕·马斯洛（Abraham Maslow）所说：“在我们追求的过程中，我们是在创造的。”C++ Ranges库的未来发展将是C++社区共同努力和创新的结果，它将继续推动C++语言的发展和进步。
结语
在我们的编程学习之旅中，理解是我们迈向更高层次的重要一步。然而，掌握新技能、新理念，始终需要时间和坚持。从心理学的角度看，学习往往伴随着不断的试错和调整，这就像是我们的大脑在逐渐优化其解决问题的“算法”。
这就是为什么当我们遇到错误，我们应该将其视为学习和进步的机会，而不仅仅是困扰。通过理解和解决这些问题，我们不仅可以修复当前的代码，更可以提升我们的编程能力，防止在未来的项目中犯相同的错误。
我鼓励大家积极参与进来，不断提升自己的编程技术。无论你是初学者还是有经验的开发者，我希望我的博客能对你的学习之路有所帮助。如果你觉得这篇文章有用，不妨点击收藏，或者留下你的评论分享你的见解和经验，也欢迎你对我博客的内容提出建议和问题。每一次的点赞、评论、分享和关注都是对我的最大支持，也是对我持续分享和创作的动力。
