C 语言

关注公众号 jb51net

关闭
首页 > 软件编程 > C 语言 > C++ std::optional

C++中std::optional的使用指南分享

作者：YunfengWang

C++ 17 引入了std::optional，表示一个可能有值的对象，这篇文章主要来和大家聊聊std::optional的使用，文中的示例代码讲解详细，感兴趣的小伙伴可以了解一下

1. std::optional 是什么

C++ 17 引入了std::optional，表示一个可能有值的对象（没有值时就是默认的std::nullopt)，例如下面的例子中，创建了一个 std::optional 对象 even_value，如果is_even 为真的话就有整数值128，否则就是默认值std::nullopt:

#include <iostream>
#include <optiona>
bool is_even = true;
// 在 没有赋实际值的情况下 std::optional 对象的默认值为 std::nullopt
std::optional<int> even_value = is_even ? std::optional<int>(128) : std::nullopt;
// 可以用 std::optional 对象是否等于 std::nullopt 来判断 std::optional 对象是否有值
if (even_value != std::nullopt) {
    // 采用.value 获取 std::optional 对象的值
    std::cout << "has value, which is " << even_value.value() << std::endl;
} else {
    std::cout << "no value" << std::endl;
}

其实std::optional的作用和Python里面的None比较像，例如上面的例子用Python来写就是这样：

is_even = True
even_value = 128 if is_even else None
if even_value is not None:
    print("has value, which is", even_value)
else:
    print("no value")

2. 为什么要引入 std::optional

我觉得提出std::optional就是因为C++底层缺少None 这个表示，所以将std::nullopt和某种特定类型的变量合并在一起构造成一个std::optional对象，用以解决因为缺少之前None因而存在的一些不怎么直接的用法。

这里举个例子来说明前面提到的"不直接"的用法。这是一个寻找数组中的第一个非0元素的函数：

    int findFirstNonZero(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        if (arr[i] != 0) {
            return arr[i];
        }
    }
    return -1; // 如果数组中没有非0元素，则返回-1
}

可以看到，没找到元素时返回-1，所以当拿到-1时，没法判断是第一个非0元素为-1还是没找到非0元素。 改进方案是返回一个pair，第一个位置表示是否包含非0元素，第二个位置表示非0元素的值：

#include <utility>
std::pair<bool, int> findFirstNonZero(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        if (arr[i] != 0) {
            return std::make_pair(true, arr[i]);
        }
    }
    return std::make_pair(false, -1); // 如果数组中没有非0元素，则返回false和-1
}

但这样其实比较繁琐且不直观，两个变量的解析和使用成本还是有些高，如果能用一个变量来完成的话就更简洁了。

采用std::optional可以简化上面的代码：

#include <optional>
std::optional<int> findFirstNonZero(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        if (arr[i] != 0) {
            return arr[i];
        }
    }
    return std::nullopt; // 如果数组中没有非0元素，则返回std::nullopt
}

使用这个函数时也只需要判断一下返回值是否为std::nullopt 就可以。

总之可以将std::optional对象当作支持判断是否为NULL的对象的封装，在不确定对象是否存在的情况下，建议使用。

3. std::optional 的构造

空的 std::optional 对象可以用std::nullopt 或者{} 来构造，然后用emplace 函数来插入数值：

    // 1.0 采用 std::nullopt 初始化再调用 emplace 插入值
    std::optional<int> val0 = std::nullopt;
    val0.emplace(128);
    std::cout << val0.value() << std::endl;
    // 1.1 采用 {} 初始化再调用 emplace 插入值
    std::optional<int> val1 = {};
    val1.emplace(128);
    std::cout << val1.value() << std::endl;

每次调用emplace 时，会清除掉之前的值，因此可以多次调用，且能保证每次都是最新的数值。

也可以用 std::make_optional 函数来构造：

    // 1.7 采用 std::make_optional<T>(val) 初始化
    std::optional<int> val7 = std::make_optional<int>(128);
    std::cout << val7.value() << std::endl;
    // 1.8 采用 std::make_optional(val) 初始化，自动推导变量类型
    std::optional<int> val8 = std::make_optional(128);
    std::cout << val8.value() << std::endl;

除此之外还有很多种初始化 std::optional 对象的方法，都写在这个示例代码里面了，记得看注释：

    // 1.2 采用 std::optional<T>(val) 初始化
    std::optional<int> val2 = std::optional<int>(128);
    std::cout << val2.value() << std::endl;
    // 1.3 采用 std::optional(val) 初始化，自动推导变量类型
    std::optional<int> val3 = std::optional(128);
    std::cout << val3.value() << std::endl;
    // 1.4 采用 std::optional<T>{val} 初始化
    std::optional<int> val4 = std::optional<int>{128};
    std::cout << val4.value() << std::endl;
    // 1.5 采用 std::optional{val} 初始化
    std::optional<int> val5 = std::optional{128};
    std::cout << val5.value() << std::endl;
    // 1.6 采用 {val} 初始化
    std::optional<int> val6 = {128};
    std::cout << val6.value() << std::endl;

4. std::optional 判断是否有值

判断 std::optional 对象是否有值可以用 has_value函数，或者判断是否不等于std::nullopt，或者直接用if语句对对象进行判断：

    std::optional<int> result1 = find_the_first_postive_value(pos_values);
    if (result1.has_value()) {
        std::cout << result1.value() << std::endl;
    }
    if (result1 != std::nullopt) {
        std::cout << result1.value() << std::endl;
    }
    if (result1) {
        std::cout << result1.value() << std::endl;
    }

5. std::optional 获取值

获取值的话可以用.value() 函数，或者* 运算符：

    if (result1) {
        std::cout << result1.value() << std::endl;
    }
    if (result1) {
        std::cout << *result1 << std::endl;
    }

如果想在std::optional对象为std::nullopt的情况下设置默认值的话，可以用value_or 函数：

    std::optional<int> val9 = std::nullopt;
    std::cout << val9.value_or(-1) << std::endl; // 输出 -1
    val9.emplace(128);
    std::cout << val9.value_or(-1) << std::endl; // 输出 128

很明显，value_or函数中的默认值需要和optional对象的类型一致，否则会编译报错。

6. 没有值时的异常处理

如果在没有值的情况下调用.value 函数，会在运行时报错std::bad_optional_access:

std::optional<int> val10 = std::nullopt;
    std::cout << val10.value() << std::endl;

输出：

libc++abi: terminating due to uncaught exception of type std::bad_optional_access: bad_optional_access

所以建议使用.value_or来处理，如果要强行使用.value的话，需要使用 try-catch 语句：

    std::optional<int> val11 = std::nullopt;
    try {
        std::cout << val11.value() << std::endl;
    } catch (const std::bad_optional_access& e) {
        std::cout << "==> error: " << e.what() << std::endl;
    }

7. 示例代码

上面的所有示例代码汇总：

#include <iostream>
#include <optional>
#include <vector>
std::optional<int> find_the_first_postive_value(const std::vector<int>& values) {
    for (auto& val : values) {
        if (val > 0) {
            return std::optional<int>(val);
        }
    }
    return std::nullopt;
}
std::optional<int> find_the_first_postive_value_v2(const std::vector<int>& values) {
    auto it = std::find_if(values.begin(), values.end(), [](int val) { return val > 0; });
    return it != values.end() ? std::make_optional(*it) : std::nullopt;
}
void show_backend(std::optional<std::string> backend) {
    if (backend) {
        std::cout << "==> use set backend: " << backend.value() << std::endl;
    } else {
        std::cout << "==> use default backend: CPU" << std::endl;
    }
}
int main() {
    // std::optional 简单例子
    bool is_even = true;
    std::optional<int> even_value = is_even ? std::optional<int>(128) : std::nullopt;
    if (even_value != std::nullopt) {
        std::cout << "has value, which is " << even_value.value() << std::endl;
    } else {
        std::cout << "no value" << std::endl;
    }
    // 1. std::optional 对象的构造
    // 1.0 采用 std::nullopt 初始化再调用 emplace 插入值
    std::optional<int> val0 = std::nullopt;
    val0.emplace(128);
    val0.emplace(129);
    std::cout << val0.value() << std::endl;
    // 1.1 采用 {} 初始化再调用 emplace 插入值
    std::optional<int> val1 = {};
    val1.emplace(128);
    std::cout << val1.value() << std::endl;
    // 1.2 采用 std::optional<T>(val) 初始化
    std::optional<int> val2 = std::optional<int>(128);
    std::cout << val2.value() << std::endl;
    // 1.3 采用 std::optional(val) 初始化，自动推导变量类型
    std::optional<int> val3 = std::optional(128);
    std::cout << val3.value() << std::endl;
    // 1.4 采用 std::optional<T>{val} 初始化
    std::optional<int> val4 = std::optional<int>{128};
    std::cout << val4.value() << std::endl;
    // 1.5 采用 std::optional{val} 初始化
    std::optional<int> val5 = std::optional{128};
    std::cout << val5.value() << std::endl;
    // 1.6 采用 {val} 初始化
    std::optional<int> val6 = {128};
    std::cout << val6.value() << std::endl;
    // 1.7 采用 std::make_optional<T>(val) 初始化
    std::optional<int> val7 = std::make_optional<int>(128);
    std::cout << val7.value() << std::endl;
    // 1.8 采用 std::make_optional(val) 初始化，自动推导变量类型
    std::optional<int> val8 = std::make_optional(128);
    std::cout << val8.value() << std::endl;
    std::optional<int> val9 = std::nullopt;
    std::cout << val9.value_or(-1) << std::endl;
    val9.emplace(128);
    std::cout << val9.value_or(-1) << std::endl;
    //    std::optional<int> val10 = std::nullopt;
    //    std::cout << val10.value() << std::endl;
    std::optional<int> val11 = std::nullopt;
    try {
        std::cout << val11.value() << std::endl;
    } catch (const std::bad_optional_access& e) {
        std::cout << "==> error: " << e.what() << std::endl;
    }
    // 函数调用例子
    std::vector<int> neg_values = {-1, -3, -5};
    std::vector<int> pos_values = {1, 3, 5};
    auto result1 = find_the_first_postive_value_v2(pos_values);
    if (result1.has_value()) {
        std::cout << result1.value() << std::endl;
    }
    if (result1 != std::nullopt) {
        std::cout << result1.value() << std::endl;
    }
    if (result1) {
        std::cout << result1.value() << std::endl;
    }
    if (result1) {
        std::cout << *result1 << std::endl;
    }
    // try-catch 示例
    try {
        std::cout << result1.value() << std::endl;
    } catch (const std::bad_optional_access& e) {
        std::cout << "==> error: " << e.what() << std::endl;
    }
    show_backend(std::nullopt);
    show_backend(std::make_optional("CUDA"));
    auto my_backend = std::optional<std::string>{"MPS"};
    show_backend(my_backend);
    my_backend.emplace("DSP");
    show_backend(my_backend);
    std::optional<std::vector<int>> res = std::optional<std::vector<int>>({1, 2, 3});
    std::cout << res.value()[0] << std::endl;
}

可以通过g++ -std=c++17 main.cpp && ./a.out 来编译运行。

到此这篇关于C++中std::optional的使用指南分享的文章就介绍到这了,更多相关C++ std::optional内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文