闭关之 C++ 函数式编程笔记（三）：range、代数数据类型及模式匹配

最新推荐文章于 2024-09-09 21:23:38 发布

七Du°C糊涂

最新推荐文章于 2024-09-09 21:23:38 发布

阅读量1.5k

点赞数 2

分类专栏：笔记文章标签： c++

本文链接：https://blog.csdn.net/jiamada/article/details/127069661

版权

笔记专栏收录该内容

28 篇文章 12 订阅

订阅专栏

第七章 range

7.1 range 简介

包含两个迭代器
- 一个指向集合的第一个元素
- 一个指向集合最后一个元素的后面
同一结构中保存两个迭代器与两个分离的迭代器相比有什么优点
- 可以返回一个完整的 range 作为函数结果
- 并把它传递给另一个函数，而无需使用局部变量保存中间结果

示例

std::vector<std::string> names = transform(
                                    filter(people, is_female),
                                    name
                                );

filter 函数将返回一个 range，包含 people 集合中符合 is_female 谓词元素。
transform 函数将接收这个 range, 并从这个过滤好的 range 中返回含姓名的 range
可以有更多的嵌套

| 管道操作符
- 可以把原始集合通过管道操作符和算法连接起来，而不是嵌套的函数谓词
- 示例
  std::vector<std::string> names = people | filter(is_female) | transform(name);

7.2 创建数据的只读试图

7.2.1 range 的 filter 函数

range 是表示集合元素的一种抽象
- 它需要一个起点，一个终点，并允许获取它的每个元素
filter 将返回一个 range 结构
- 它的起始迭代器是一个智能的迭代器代理，指向源集合中满足指定谓词的第一个元素
- 结束迭代器是源集合中终止迭代器的代理。
- 代理迭代器与源集合中的迭代器唯一的不同是，代理迭代器指向符合过滤谓词的元素

每次迭代器代理向后移动时，就需要找到源集合中满足谓词的下一个元素

重载了 ++ 操作符

示例

auto& operator++() 
{
    //移动迭代器
    ++m_current_position;
    //从下一个元素开始搜索
    m_current_position = std::find_if(m_current_position, 
                            m_current_position,
                            m_end,
                            m_predicate
                        );
    return *this;
}

通过过滤器的代理迭代器，就无须创建临时集合保存源集合中符合谓词的元素副本
这样做其实创建了源数据的一个新视图 (view)

7.2.2 range 的 transform 函数

与 filter 类似， transform 函数也不需要返回一个新的集合
与 filter 不同的是，transform 的 ++ 操作符没有重载，而是重载了 * 解引用操作符

示例

auto operator*()  const
{  
    //获取源集合中的元素，对他施加转换函数
    //并把它作为代理迭代器指向的返回值
    return m_function( *m_current_position);
}

7.2.3 range 惰性求值

从上面的解释可以看出，调用 filter 和 transform 都是创建一个视图，没有正真的进行计算。等到调用它们重载的操作符时，才真正的进行计算。这就是上一章惰性求值的方式。

7.3 修改 range 中的值

虽然转换可以通过视图实现，但有些需要改变源集合中的元素，这种操作称为行为(action)
行为最常见的例子是排序，排序要改变源集合元素位置或创建一个新的集合保存
行为与视图的区别
- 视图转换对原来的数据创建一个惰性视图
- 而行为直接处理存在的集合，并立即执行所需操作

示例

std::vector<std::string>  words = 
                        read_text() | action::sort 
                                    | action:unique;

因为向 sort 传递临时文件，因此无需创建副本

行为操作临时数据不是必须的，可以使用 |= 操作符进行左结合运算

示例

std::vector<std::string>  words = read_text();
words |= action::sort | action:unique;

7.4 定界 range （delimited range）和无限 range

在 range 中，指向末端的迭代器用于指向集合的末尾
- 但实际上没必要是一个迭代器，可以是任何其东西
  - 只要检测是否能达到集合末尾就可以
- 这种特殊的值称为哨兵(sentinel)
利用哨兵就可以创建定界 range 和无限 range

7.4.1 用定界 range 优化用于输入的 range

定界 range 不能实现知晓其大小

但可以通过一个谓词检测是否已经达到末尾
- 以 null 结尾的字符串是定界 range 的很好的例子

示例

std::accumulate(
        std::istream_iterator<double>(std::cin),
        std::istream_iterator<double>(),
        0
    );

这里算法使用 std::istream_iterator<double>() 检测是否达到集合末尾，类似哨兵的迭代器
std::accumulate 将一直读取输入中的值，直到遍历迭代器和末端迭代器相同

下面是类似的哨兵伪代码

template <typename T>
bool operator==(const std::istream_iterator<T>& left,
    const std::istream_iterator<T>& right) 
{
    if (left.is_sentinel() && right.is_sentinel()) 
    {
        return true;
    }
    else if (left.is_sentinel()) 
    {
    ...
    }
    else if (right.is_sentinel()) 
    {
    ...
    } 
    else 
    {
    ...
    }
}

不论左右迭代器是否是哨兵，都应该覆盖所有可能的情况，在算法的每一步都进行这些检查

7.4.2 用哨兵创建无限 range

无限 range 没有末端。有一个开始，但没有结束
- 例如：无限整数 range view::ints(1)

view::ints(1) 应用示例

//Range 示例为 std::vector
template <typename Range>
void write_top_10(const Range& xs)
{
    auto items =
        //将电影 range 和从1开始的整数无限 range 压缩在一起
        //得到一个键值对的 range，电影名字和下标
        view::zip(xs, view::ints(1))
            //取出一个键值对，构造一个包含电影分级和电影名字的字符串
            | view::transform([] (const auto& pair) {
                    return std::to_string(pair.second) +
                        " " + pair.first;
            })
            //只对前10部电影感兴趣
            | view::take(10);

    for (const auto& item: items) {
        std::cout << item << std::endl;
    }
}

view::zip 接收两个 range，并对两个元素进行匹配，得到一个元素对
无限 range 的一个优点是可以使代码更通用
- 算法基于无限 range，它就可以处理任意大小的 range，包括未知大小的 range

7.5 用 range 统计词频

Code_7_5_1

第八章函数式数据结构

8.1 不可变链表（Immutable linked lists）

链表对于大多数任务来说效率较低，因为它的定位机制与现代缓存硬件不符

8.1.1 在表头添加和删除元素

原始链表不可变
- 在表头添加元素：只需新建一个节点，让新节点的指针指向原始链表表头
- 在表头删除元素：只需新建一个头指针，指向原始链表中第二个元素

8.1.2 在链表末尾添加和删除元素

原始链表不可变
- 在链表末尾添加元素
  - 复制原始链表中的数据，并在复制的链表末尾添加新元素
- 在链表末尾删除元素
  - 复制原始链表中的数据，并删除复制的链表末尾元素

8.1.3 在链表中间添加和删除元素

原始链表不可变
- 在链表中间添加元素
  - 复制位置之前所有元素，插入新元素，并把新元素与原始链表中剩余的元素链接起来
- 在链表中间删除元素
  - 同理

8.1.4 内存管理

使用 std::unique_ptr 不理想，使用 std::shared_ptr

8.2 不可变类向量结构（略）

std::vector 实现不可变结构的问题是
- 每次需要修改时都要复制所有的元素，创建一个修改后的副本
常用的代替品是位图向量树(bitmapped vector trie, 也称前缀树)
Copy-on-write
- 称为惰性拷贝，是一种优化技术
- 它把复制延迟到实际修改时进行

个人理解

这部分更像是一篇论文
个人理解与不可变链表一样，利用原始集合以最小的代价创建新的副本

第九章代数数据类型及模式匹配

9.1 代数数据类型

从已有的类型构造一个新类型有两种主要的操作
- 和与乘积
C++ 创建乘积类型
- std::pair (对) 和 std::tuple (元组)
- std::pair 是两种类型的乘积
- std::tuple可以包含任意多的类型
- 乘积：笛卡尔积
- std::tie
  - 创建一个对传递给它的值的引用元组
  - 在创建元组时，并不复制原始数据，原始字符串参与比较
- std::pair 和 std::tuple的用途是创建乘积类型，可以自动获取字典比较运算符
- 示例
  - 包含姓和名的类，需要实现姓和名的小于比较
```
bool operator<(const person_t& left, const person_t& right)
{
    return std::tie(left.m_surname, left.m_name) < 
        std::tie(right.m_surname, right.m_name);
}
```
  - 创建乘积元组并比较
和类型 (sum type)
A 类型和 B 类型的和类型可以包含 A 的实例或 B 的实例，而不能同时包含两个实例
- 如枚举 (enum)
- 枚举是一种特殊的和类型
- 和类型是枚举的泛化类型，在构建和类型时，不是提供单个元素的集合，而是可以使用任意数目元素的集合

9.1.1 通过继承实现和类型

Code_9_1_1
- dynameic_cast 效率不高
- 优势
  - 不会有无效状态
  - 没开始统计时，count 不会大于 0
  - count 也不会在统计结束后被意外修改
  - 可以实时掌握程序的状态
- 个人理解，不适合在主循环中使用，开销有点大，内存碎片怎么办？
继承方式创建和类型有一些缺陷
- 为了保证开发性，需要使用虚函数和动态指派
- 为了避免较慢的强制类型转换必须使用类型标志
- 必须在堆上动态分配状态对象
- 必须保证 state 指针有效

9.1.2 通过 union 和 std::variant 实现和类型

可以使用 std::variant 代替继承实现和类型
Code_9_1_2
- std::variant 不是基于动态多态，所以它不会保存指向推中对象的指针
  - 它在自己的内存空间保存对象本身，和 union 一样
  - 不同的是，它可以自动控制保存对象的创建和消耗
  - 并且任意时刻都可以知道所包含对象的类型
  - 可以使用 std::get 和 std::get_if 访问其中的值
    - 两者都可以通过类型或类型索引访问 variant 中的元素
      - std::get<running_t>(m_state);
      - std::get_if<1>(&m_state);
    - 不同的是，std::get 要么返回一个值，要么在获取不到时抛出异常
    - std::get_if 返回指向被包含值的指针，或出错时返回null
使用 std::variant 优点
- 不需要呆板的代码，因为类型标志由 std::variant 掌握
- 也不需要创建继承关系，还可以对以存在的类型进行聚类
- 不需要动态内存分配
  - 把存放类型的最大长度作为自己的大小
    - 加上一些额外标记
缺点
- 扩展比较困难
  - 如果需要向和类型中添加新类型，需要修改 variant 的类型
- 在需要扩展的少数情况下，必须返回到使用继承实现的和类型
基于继承的开放的和类型的另一种实现是使用 std::any 类，它是任意类型值的安全容器。
- 虽然有时比较有用，但效率比 std::variant 低，不应该作为 std::variant的简单类型替换

9.1.3 特定状态的实现

std::variant 中的索引成员函数
- 返回 variant 实例中当前类型的索引
- m_state.index() == 0
对于使用和类型处理状态的程序设计方法推荐
- 针对某一状态的处理代码，定义在状态对象中，而处理状态转换的代码定义在主程序中
  - 参考 Code_9_1_2
- 另一种方法是把所有逻辑都放在状态类中
  - 这种方法可以避免使用 get_if 和索引获取状态，因为状态类的成员函数只用在这一状态时才会被调用
    - 缺陷是状态类型必须负责程序的状态转换，也就是说，状态之间必须互相了解，因此会打破程序的封装性
- 个人理解
  - 还是使用 Filament 中的 variant 效率较高

9.1.4 特殊的和类型: Optional

工厂方法使用 std::unique_ptr
返回一个指向已存在对象的指针，但用户不拥有这个对象使用 std::shared_ptr
函数可能执行失败，借用 null 表示函数执行错误使用 std::optional

可以定义一个模板实现自己的 get_if

template<typename T, typename Variant>
std::optional<T> get_if(const Variant& variant)
{
    T* ptr = std::get_if<T>(variant);
    if (ptr)
    {
        return *ptr;
    }
    else
    {
        return std::nullopt;
    }

}

9.1.5 和类型用于错误处理

Code_9_1_5
- Placement new
  - 与通常的 new 不同，new 进行内存分配并初始化
  - 而 placement new 允许使用已分配的内存，并在其中构建对象
  - 只用于实现不需要在运行时分配内存的和类型
- 把错误嵌入类型中，对异步编程很有用。可以在不同的异步进程之间传递错误

9.2 使用代数数据类型进行域建模

设计数据类型时的思想
- 使非法数据无法表示
- 设计自定义类型或函数时也应该如此
  - 不要考虑需要哪些数据来涵盖程序可以包含的所有可能状态，并将它们放入类中
  - 而应考虑如何定义数据来仅涵盖程序可以包含的状态

9.2.1 原始方法及其缺点（设计网球程序）

原始方法
- 创建两个整型变量记录每个玩家的分数
- 该方法涵盖了所有可能的状态
- 问题
  - 会导致对玩家的分数设置成无效的值
  - 通常可以在 setter 进行验证，但不如不验证
    - 如果数据类型本身可以保证代码的正确性
改进方法
- 使用 enum 枚举代替数值型分数，它只允许分数设置有效的值
- 这样大幅减少了程序的可能状态
- 问题
  - 由于两个人可以平分，而且不能表示占先，需要额外添加平局和占先的枚举，从而引入了新的状态
更好的办法是使用自上而下的设计

9.2.2 更复制的方法：自上而下的设计

将普通得分状态拆分

class  tennis_t
{
  enum class points
  {
    love,
    fifteen,
    thirty
  };
  enum class player
  {
    player_1,
    player_2

  };
  struct normal_scoring
  {
    points player_1_points;
    points player_2_points;
  };
  struct forty_scoring
  {
    player leading_player;
    points other_player_scores;

  };

};

平局和占先状态

class tennis_t
{
  struct deuce {};
  struct advantage
  {
    player player_with_advantage;
  };
};

定义所有状态的和类型

class tennis_t
{
  std::variant<normal_scoring, forty_scoring, deuce, advantage> state_;
};

这个例子主要目的是说明如何设计代数类型以符合业务建模的需要
- 先把原来的状态分解成几个独立的子状态，再分别描述这些子状态

9.3 使用模式匹配更好地处理代数数据类型

实现可选值、变体和其他代数数据类型的程序时的主要问题
- 每当需要一个值，都需要检查它是否存在，并从它的包装类型中提取它
许多函数时编程语言提供了特殊的语法来简化这种操作
- 语法类似 switch

标准库提供了一个 std::visit 函数

它接收一个 std::variant 实例和一个对 std::variant 中的值操作的函数

std::vistit([] (const auto& value) {
      std::cout << value << std::endl;
    }, state_);

需要对变体 variant 中的值执行不同的代码可以创建一个重载函数对象
- 对不同类型执行不同的操作
- 使用了模板参数推断

template <typename... Fs>
struct overloaded : Fs... { using Fs::operator()...; };

template <typename... Fs> overloaded(Fs...) -> overloaded<Fs...>;

应用

return std::visit(overloaded {
            [] (init_t) {
                return (unsigned)0;
            },
            [] (const running_t& state) {
                return state.count();
            },
            [] (const finished_t& state) {
                return state.count();
            }
        }, m_state);

9.4 Mach7 的强大匹配功能

比 visitor 模式更高效
缺点：语法比较笨拙

示例

void point_for(player which_player)
{
  Match(m_state)
  {
    Case(C<normal_scoring>()) //增加分数或切换状态
    Case(C<forty_scoring>())  //玩家获胜或切换到平局
    Case(C<deuce>())          //却换占先状态
    Case(C<advantage>())      //玩家获胜，或切换回平局状态
  }
  EndMatch
}