当前位置：首页 > article >正文

(C++23) expected 基础使用

article 2024/9/22 21:24:10

文章目录

⭐前言
⭐expected
- 🎛️基础使用
- 🎛️单子操作 (Monadic operations)
- - 🎚️and_then & or_else
  - 🎚️transform & transform_error
⭐END
- 🌟跋
- 🌟交流方式

⭐前言

在 C++17 中，提出了 optional 的可选项类型。但是该类型仅能表示二元状态，true | false 但在实际业务常见成功与否可以只用一个flag表示，但失败的原因却多种多样，需要以一种更丰富的形式表示。

因此在 C++23 中正式规范了std::expected，操作方式与原先的std::optional相似，又扩展了一些统一的处理方案。

同时这些方法在 C++23 中也为 std::optional 提供。

⭐expected

下面以一个获取星期几的字符串的demo为例子来表示。

🎛️基础使用

操作以使用 std::optional 一致，但这里多了一项 error 的选项。

#include <ctime>
#include <expected>
#include <iostream>
#include <string>
#include <typeinfo>

enum struct ParseError : int {
    Below,  // (<0)
    Above   // (>6)
};

std::expected<std::string, ParseError> get_weekDay(int d) {
    if (d < 0) {
        return std::unexpected(ParseError::Below);
    } else if (d > 6) {
        return std::unexpected(ParseError::Above);
    }

    // C++20 指定初始化
    std::tm t{.tm_wday = d};
    char    buffer[16];
    std::strftime(buffer, sizeof(buffer), "%A", &t);

    return std::string(buffer);
}

void test(int d) {
    auto ex = get_weekDay(d);
    if (ex.has_value()) {
        std::cout << ex.value() << std::endl;
    } else {
        if (ex.error() == ParseError::Below) {
            std::cout << "ParseError::Below" << std::endl;
        } else if (ex.error() == ParseError::Above) {
            std::cout << "ParseError::Above" << std::endl;
        } else {
            std::cout << ex.value_or("ParseError") << std::endl;
        }
    }
}

int main() {
    test(-1);
    test(0);
    test(114514);
}

🎛️单子操作 (Monadic operations)

下面仅对上面 demo 的 void test(int) 函数进行修改

一般来说 Monadic operations 会被翻译成一元操作，或者单目操作。不知道为什么std::expected - cppreference.com 这里翻译成单子操作。

🎚️and_then & or_else

and_then() 如果 *this：

表示预期值，那么调用 f 并返回它的结果。
否则返回一个包含非预期值的 std::expected 对象，以 *this 的非预期值初始化该值。

or_else 如果 *this：

包含非预期值，那么以 *this 的非预期值作为实参调用 f 并返回它的结果。
否则返回一个表示预期值的 std::expected 对象。

因此两者的使用非常灵活，使用得当可以非常遍历的进行链式编程。

这个写法让我回想起以前写 javascript 的时候。

void test(int d) {
    auto ex = get_weekDay(d);

    ex
        /**
         * 若存在预期值则返回给定的函数在其上的结果，否则返回 expected 本身
         */
        .and_then([](const auto& e) -> std::expected<std::string, ParseError> {
            std::cout << "[and_then] Type:" << typeid(e).name() << std::endl;
            std::cout << e << std::endl;
            return {e};
        })
        /**
         * 若 expected 含有预期值则返回其自身，否则返回给定的函数在非预期值上的结果
         */
        .or_else([](const auto& e) -> std::expected<std::string, ParseError> {
            std::cout << "[or_else] Type:" << typeid(e).name() << std::endl;

            if (e == ParseError::Below) {
                std::cout << "ParseError::Below" << std::endl;
            } else if (e == ParseError::Above) {
                std::cout << "ParseError::Above" << std::endl;
            } else {
                std::cout << "ParseError" << std::endl;
            }
            return std::unexpected{e};
        });
}

mingw-gcc 运行效果

[or_else] Type:10ParseError
ParseError::Below
[and_then] Type:NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Sunday
[or_else] Type:10ParseError
ParseError::Above

🎚️transform & transform_error

transform() 如果 *this：

表示预期值，那么调用 f 并返回一个包含预期值的 std::expected 对象，以 f 的结果初始化该值（或在结果类型是 void 时值初始化）。
否则返回一个包含非预期值的 std::expected 对象，以 *this 的非预期值初始化该值。

transform_error() 如果 *this：

包含非预期值，那么以 *this 的非预期值作为实参调用 f 并返回一个包含预期值的 std::expected 对象，以 f 的结果初始化该值。
否则返回一个表示预期值的 std::expected 对象。

这两个基本可以被and_then & or_else取代。

主要区别在于，在成功调用时能保证返回一个std::expected，且依赖于 f 的返回值。

这是少有的在 C++ 中可以天然的允许链式编程的函数。

void test(int d) {
    auto ex = get_weekDay(d);

    ex
        /**
         * 若存在预期值则返回含有变换后的预期值的 expected，否则返回 expected 本身
         */
        .transform([](const auto& e) -> std::expected<std::string, ParseError> {
            std::cout << "[transform] Type:" << typeid(e).name() << std::endl;
            std::cout << e << std::endl;
            return {e};
        })
        /**
         * 若含有预期值则返回 expected 本身，否则返回含有变换后非预期值的 expected
         */
        .transform_error([](const auto& e) -> std::expected<std::string, ParseError> {
            std::cout << "[transform_error] Type:" << typeid(e).name() << std::endl;

            if (e == ParseError::Below) {
                std::cout << "ParseError::Below" << std::endl;
            } else if (e == ParseError::Above) {
                std::cout << "ParseError::Above" << std::endl;
            } else {
                std::cout << "ParseError" << std::endl;
            }
            return std::unexpected{e};
        });
}

mingw-gcc 运行效果

[transform_error] Type:10ParseError
ParseError::Below
[transform] Type:NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Sunday
[transform_error] Type:10ParseError
ParseError::Above