标准库出发，了解optional的用法

已于 2023-08-25 16:29:57 修改
阅读量155 收藏 1
点赞数
分类专栏： C++新增类型 C++学习笔记 文章标签： 学习 笔记 c++
于 2023-08-25 16:29:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42223817/article/details/132483930
版权
本文详细介绍了C++标准库中optional类的用法，包括其两种状态、构造方式（如单参数构造、使用其他optional对象构造等）、操作符重载（如=、*、->、bool、has_value、value、value_or等）以及相关辅助类和make_optional函数的使用。
摘要由CSDN通过智能技术生成

前言

本编文章，从标准库出发，解析optional类的用法。
如果想要了解optional类的底层是如何实现的，看完本编文章后，可以自己查看optional类继承的两个辅助类。

1 概述

optional对象可以有两种状态。即，表示一个已存在的值或表示不存在。

我们可以令函数返回值的类型为 optional。在调用函数后，我们可以根据返回的optional对象的状态来了解函数的行为。

optional类是开辟一块动态内存去存储值的。

2 解析

1 nullopt_t类型

nullopt_t类的定义和nulloopt对象的定义如下：

  struct nullopt_t
  {
    // Do not user-declare default constructor at all for
    // optional_value = {} syntax to work.
    // nullopt_t() = delete;

    // Used for constructing nullopt.
    enum class _Construct { _Token };

    // Must be constexpr for nullopt_t to be literal.
    explicit constexpr nullopt_t(_Construct) noexcept { }
  };

  /// Tag to disengage optional objects.
  inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };

nullopt是 nullopt_t类型的一个常量对象，作为一个标记，表示 optional对象不存在（没有存储任何值）。

2 前置的静态断言和类型声明（不强求）

先看看能不能看懂， 具体的解释另起代码段，附在了上面

  template<typename _Tp>
    class optional
    {
      static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
      static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
      static_assert(!is_reference_v<_Tp>);

    private:
      using _Base = _Optional_base<_Tp>;

      // SFINAE helpers
      template<typename _Up>
	using __not_self = __not_<is_same<optional, __remove_cvref_t<_Up>>>;
      template<typename _Up>
	using __not_tag = __not_<is_same<in_place_t, __remove_cvref_t<_Up>>>;
      template<typename... _Cond>
	using _Requires = enable_if_t<__and_v<_Cond...>, bool>;

解释

  template<typename _Tp> 
    class optional 
    {
    	//_Tp类型不可以是 nullopt_t类型、in_place_t类型、引用类型
      static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>); 
      static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>); 
      static_assert(!is_reference_v<_Tp>); 

    private: 
      using _Base = _Optional_base<_Tp>; 

      // SFINAE helpers 
     
      template<typename _Up>	//_Up类型参数不是对象类型本身
	using __not_self = __not_<is_same<optional, __remove_cvref_t<_Up>>>; 
      template<typename _Up>	//_Up类型参数不是in_place_t类型
	using __not_tag = __not_<is_same<in_place_t, __remove_cvref_t<_Up>>>; 
      template<typename... _Cond>	//用来约束只有当_Cond...条件都成立时，bool类型才有效
	using _Requires = enable_if_t<__and_v<_Cond...>, bool>;

3 constructor

1 构造无效的optional对象

      constexpr optional() noexcept { }

      constexpr optional(nullopt_t) noexcept { }

比如：

optional<int> opt = {};
optional<int> opt_(nullopt);

2 使用单参数构造函数构造optional对象

满足下面条件的就是单参数构造函数（可省略）

	//满足 _Up不是optional对象，不是in_plade_t对象，_Tp类型可由_Up类型构造，_up类型可转化为_Tp类型
      template<typename _Up = _Tp,
	       _Requires<__not_self<_Up>, __not_tag<_Up>,
			 is_constructible<_Tp, _Up>,
			 is_convertible<_Up, _Tp>> = true>
	constexpr
	optional(_Up&& __t)
	noexcept(is_nothrow_constructible_v<_Tp, _Up>)
	: _Base(std::in_place, std::forward<_Up>(__t)) { }

      template<typename _Up = _Tp,
	       _Requires<__not_self<_Up>, __not_tag<_Up>,
			 is_constructible<_Tp, _Up>,
			 __not_<is_convertible<_Up, _Tp>>> = false>
	explicit constexpr
	optional(_Up&& __t)
	noexcept(is_nothrow_constructible_v<_Tp, _Up>)
	: _Base(std::in_place, std::forward<_Up>(__t)) { }

比如

struct A {
    int a, b;
    A(int a) :a {a}, b{0} {}
};
auto opt3 = std::optional<A>(1)

3 使用optional对象构造

使用存储类型可转换的optional对象构造

     template<typename _Up,
	       _Requires<__not_<is_same<_Tp, _Up>>,
			 is_constructible<_Tp, _Up>,
			 is_convertible<_Up, _Tp>,
			 __not_<__converts_from_optional<_Tp, _Up>>> = true>
	constexpr
	optional(optional<_Up>&& __t)
	noexcept(is_nothrow_constructible_v<_Tp, _Up>)
	{
	  if (__t)
	    emplace(std::move(*__t));
	}

比如：const char*类型可转换为string_view类型

    auto opt5 = std::optional<std::string_view>(std::optional("Hello"));

4 显示指示调用构造函数构造对象

in_place_t就一个标志，表示这些参数用于构造对象

      template<typename... _Args,
	       _Requires<is_constructible<_Tp, _Args...>> = false>
	explicit constexpr
	optional(in_place_t, _Args&&... __args)
	noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
	: _Base(std::in_place, std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
	       _Requires<is_constructible<_Tp,
					  initializer_list<_Up>&,
					  _Args...>> = false>
	explicit constexpr
	optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
	noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
					    _Args...>)
	: _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }

比如：

struct A {
    int a, b;
    A(int a, int b) :a{a}, b{b}{}
    A(int a) :a {a}, b{0} {}
};
auto opt4 = std::optional<A>(std::in_place, 1, 2);

4 operator= ，emplace

operator=对应于constructor的1、2、3

1 nullopt

      operator=(nullopt_t) noexcept
      {
	this->_M_reset();
	return *this;
      }

2 使用单参数的构造函数

等号右边的值必须能够调用类型单参数构造函数的

     template<typename _Up = _Tp>
	enable_if_t<__and_v<__not_self<_Up>,
			    __not_<__and_<is_scalar<_Tp>,
					  is_same<_Tp, decay_t<_Up>>>>,
			    is_constructible<_Tp, _Up>,
			    is_assignable<_Tp&, _Up>>,
		    optional&>
	operator=(_Up&& __u)
	noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
			 is_nothrow_assignable<_Tp&, _Up>>)

3 调用内部类型可转换的optional对象

     template<typename _Up>
	enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
			    is_constructible<_Tp, const _Up&>,
			    is_assignable<_Tp&, const _Up&>,
			    __not_<__converts_from_optional<_Tp, _Up>>,
			    __not_<__assigns_from_optional<_Tp, _Up>>>,
		    optional&>
	operator=(const optional<_Up>& __u)
	noexcept(__and_v<is_nothrow_constructible<_Tp, const _Up&>,
			 is_nothrow_assignable<_Tp&, const _Up&>>)

4 emplace

对应于constructor中的4
调用与这些参数相匹配的构造函数，构造一个对象，并返回这个对象。

     template<typename... _Args>
	_GLIBCXX20_CONSTEXPR
	enable_if_t<is_constructible_v<_Tp, _Args...>, _Tp&>
	emplace(_Args&&... __args)
	noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
	{
	  this->_M_reset();
	  this->_M_construct(std::forward<_Args>(__args)...);
	  return this->_M_get();
	}

      template<typename _Up, typename... _Args>
	_GLIBCXX20_CONSTEXPR
	enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
		    _Tp&>
	emplace(initializer_list<_Up> __il, _Args&&... __args)
	noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
					    _Args...>)
	{
	  this->_M_reset();
	  this->_M_construct(__il, std::forward<_Args>(__args)...);
	  return this->_M_get();
	}

5 operator*，operator->

1 operator*

定义了适用于不同对象*运算符函数，获取对象的引用

      constexpr const _Tp&
      operator*() const& noexcept
      { return this->_M_get(); }

      constexpr _Tp&
      operator*()& noexcept
      { return this->_M_get(); }

      constexpr _Tp&&
      operator*()&& noexcept
      { return std::move(this->_M_get()); }

      constexpr const _Tp&&
      operator*() const&& noexcept
      { return std::move(this->_M_get()); }

2 operator->

返回对象的地址，可以用来访问结构体成员

      constexpr const _Tp*
      operator->() const noexcept
      { return std::__addressof(this->_M_get()); }

      constexpr _Tp*
      operator->() noexcept
      { return std::__addressof(this->_M_get()); }

6 operator bool， has_value

判断optional对象是否有效

      constexpr explicit operator bool() const noexcept
      { return this->_M_is_engaged(); }

      constexpr bool has_value() const noexcept
      { return this->_M_is_engaged(); }

7 value, value_or

1 value

定义了适用于不同对象的value函数。用来获取optional对象存储的值。
if分支处理：

  1. 如果optional不为空，返回存储的值的引用
  2. 如果optional为空，抛出一个错误bad_optional_access()
      constexpr const _Tp&
      value() const&
      {
	if (this->_M_is_engaged())
	  return this->_M_get();
	__throw_bad_optional_access();
      }

      constexpr _Tp&
      value()&
      {
	if (this->_M_is_engaged())
	  return this->_M_get();
	__throw_bad_optional_access();
      }

      constexpr _Tp&&
      value()&&
      {
	if (this->_M_is_engaged())
	  return std::move(this->_M_get());
	__throw_bad_optional_access();
      }

      constexpr const _Tp&&
      value() const&&
      {
	if (this->_M_is_engaged())
	  return std::move(this->_M_get());
	__throw_bad_optional_access();
      }

2 value_or

if分支处理：

  1. 如果optional不为空，返回存储的值的引用
  2. 如果optional为空，返回另一个值
      template<typename _Up>
	constexpr _Tp
	value_or(_Up&& __u) const&
	{
	  static_assert(is_copy_constructible_v<_Tp>);
	  static_assert(is_convertible_v<_Up&&, _Tp>);

	  if (this->_M_is_engaged())
	    return this->_M_get();
	  else
	    return static_cast<_Tp>(std::forward<_Up>(__u));
	}

      template<typename _Up>
	constexpr _Tp
	value_or(_Up&& __u) &&
	{
	  static_assert(is_move_constructible_v<_Tp>);
	  static_assert(is_convertible_v<_Up&&, _Tp>);

	  if (this->_M_is_engaged())
	    return std::move(this->_M_get());
	  else
	    return static_cast<_Tp>(std::forward<_Up>(__u));
	}

8 reset

销毁optional对象存储的值，也就是释放到管理的内存。

void reset() noexcept { this->_M_reset(); }

9 make_optional

1 使用内置类型

例如：int、float

  template<typename _Tp>
    constexpr
    enable_if_t<is_constructible_v<decay_t<_Tp>, _Tp>,
		optional<decay_t<_Tp>>>
    make_optional(_Tp&& __t)
    noexcept(is_nothrow_constructible_v<optional<decay_t<_Tp>>, _Tp>)
    { return optional<decay_t<_Tp>>{ std::forward<_Tp>(__t) }; }

2 使用构造函数构造

调用与这些参数相匹配的构造函数

	// 一系列参数
  template<typename _Tp, typename... _Args>
    constexpr
    enable_if_t<is_constructible_v<_Tp, _Args...>,
		optional<_Tp>>
    make_optional(_Args&&... __args)
    noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
    { return optional<_Tp>{ in_place, std::forward<_Args>(__args)... }; }

	//初始化列表 + 一系列参数
  template<typename _Tp, typename _Up, typename... _Args>
    constexpr
    enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
		optional<_Tp>>
    make_optional(initializer_list<_Up> __il, _Args&&... __args)
    noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
    { return optional<_Tp>{ in_place, __il, std::forward<_Args>(__args)... }; }

10 比较运算符

optional类定义了一整套比较运算符以及三路运算符的重载方法

与optional对象相匹配的可以为如下：

  1. nullopt对象
  2. 可比较的optional对象
  3. 可比较的optional存储的数据类型对象
std::optional<int> opt(1);

if (opt == 1) {}
else if (opt < 1.1) {}
else if (opt < std::make_optional(1.1)) {}
else if (opt != nullopt) {}
...
qq_42223817
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python标准库3.7
02-09
在学习和使用Python 3.7标准库时，阅读官方文档是非常重要的，它能帮助开发者深入理解各个模块的用法和功能，提升编程技能。提供的"Python标准库3.7.pdf"文件应该是官方文档的高清版，非常适合查阅和学习。通过仔细...
Optional 使用方法详解
最新发布
10-18
本篇文章将深入解析`Optional`的使用方法，帮助你更好地理解和运用这一特性。 首先，`Optional`并不是一个容器对象，它仅仅用于封装可能为null的对象。`Optional`的API设计旨在避免空指针异常，提供了一套优雅的...
C++项目代码学习笔记2
梓潼的优化空间
07-06 1546
yaml-cpp是用c++实现的用来解析和生成yaml文件的，首先说一下YAML是啥？（原文来自维基百科链接：https://zh.wikipedia.org/wiki/YAML)YAML（/ˈjæməl/，尾音类似camel骆驼）是一个可读性高，用来表达资料序列化的格式。YAML参考了其他多种语言，包括：C语言、Python、Perl，并从XML、电子邮件的数据格式（RFC 2822）中获得灵感。Clark Evans在2001年首次发表了这种语言，另外Ingy döt Net与Oren Ben-Kiki
C++11/14
u010378559的博客
05-04 1000
C++11和C++14特性总结
深入探索C++17新特性：std::optional
Jack__Lau__的博客
05-21 543
std::optional是C++17引入的一个强大工具，它提供了一种更安全、更直观的方式来处理可能不存在的值。通过使用std::optional，我们可以避免空指针异常，并且代码更加清晰易懂。它的灵活性和简洁性使得它在许多场景下都能发挥巨大的作用。因此，在你的C++项目中，不妨考虑使用std::optional来提升代码的可读性和健壮性。
C++推导本2
个人进步之路
01-29 503
C++推导本2
Java：高级类特性
KaiSarH
09-04 538
Java高级类特性
JAVA Optional类用法分享
08-28
JAVA Optional类用法分享 JAVA中的Optional类是一个容器类，它可能包含一个非空值或不包含任何值。Optional类提供了一种安全的方式来处理可能为null的对象，避免了空指针异常。 Optional类结构 Optional类中包含...
使用Java8中Optional机制的正确姿势
08-28
尽管 `Optional` 可以帮助你避免在返回值上使用 `null`，但它不适合作为类的成员变量或方法参数。这是因为 `Optional` 的主要目的是在方法返回值中表示可能不存在的值，而不是用于数据存储。如果你的类需要序列化，...
Java8 Optional原理及用法解析
09-07
`Optional` 类的设计灵感来源于 Google 的 Guava 库，但在 Java 8 中被正式引入，成为标准库的一部分。 ### 1. `Optional` 原理 `Optional` 不是一个容器对象，它代表一个值存在或不存在。使用 `Optional` 可以使...
C++ exception with description “bad optional access“ thrown in the test body.
weixin_45022086的博客
12-17 4101
昨天写完代码跑case的时候，返现一个很奇怪的问题 case的log里面报了这样一个错误： C++ exception with description “bad optional access” thrown in the test body. 这个错误应该是代码里面对一个空的optional类型的变量取值了，但是我从gdb看backtrace竟然没找到调用栈，bt出来显示的全是gtest.so的东西，导致我以为是测试的framework还不支持这个case的异常场景 后来别人说这是std::option
C++ std::optional和std::nullopt
小孔明的专栏
06-02 2262
https://www.apiref.com/cpp-zh/cpp/utility/optional.html
std::optional
生活需要深度
05-20 7368
一、前言   有时我们会用一个值来表示一种“没有什么意义”的状态，这就是C++17的std::optional的用处。   在编写程序时，我们常常遇到一种情况，那就是我们不总是有一个固定值来表示一个事物。例如，找出文本中的第一个偶数（如果存在的话）。或者一个类有一个可选的成员函数，即一个不是总需要被设置的成员函数。 在以前的代码中，这些情况一般使用魔术值（magic value）或者空指针（null pointers）来表示。一个魔术值可以是一个空的字符串、0、-1或者一个最大的非负值（例如std::st
C++中 exception 的使用
时梦的博客
09-05 1万+
std:: exception ，定义于头文件 &lt;exception&gt;，它提供一致的接口，以通过 throw 表达式处理错误。 标准库所生成的所有异常继承自 std::exception。 其继承结构如下： logic_error invalid_argument domain_error length_error out_of_range future_error(C+...
C++17新特性——std::optional
茶佬牛逼
07-04 5627
我们在写代码过程中可能经常会碰到这样的情况： 某个函数经过一系列计算后获取一个返回值，但是这个函数可能在执行过程中有异常分支，从这些异常分支中return出来的时候还没有得到这个想计算的值。 例如想计算得到一个无符号类型，我们可能会在这些异常分支return一个-1出去，用来表示计算失败，或执行有误，甚至不同的负值用来表示不同的异常情况。。。由于这些值的存在，本来返回值应该是uint32类型，为了容纳可能出现的负值和整个uint32的范围，返回值就变成了int64。。。这个int64，竟然要么表示错误码.
C++17之std::optional全方位详解
热门推荐
hhdshg的博客
12-09 4万+
文章目录引言快速上手std::optional适用场景std::optional支持的操作性能代价例程 引言 编程中，我们经常会需要表示或处理一个“可能为空”的变量，可能是一个为包含任何元素的容器，可能是一个类型的指针没有指向任何有效的对象实例，再或者是一个对象没有被赋予有效的值。通常处理这类问题意味着写更多的代码来处理这些“特殊”情况，很容易导致代码变得冗余，可读性变差或者容易出错。比如，我们很...
Java8之使用Optional进行Null处理(与jdk1.7的进行比较)
天道酬勤
01-28 2932
1.创建optional对象 empty() 方法用于创建一个没有值的Optional对象： Optional&lt;String&gt; emptyOpt = Optional.empty(); of() 方法使用一个非空的值创建Optional对象： String str = "Hello World"; Optional&lt;String&gt; notNullOpt = O...
用 Optional 取代 null
一天一夜的博客
06-26 3602
使用Optional建模一段代码引发的思考假设你需要处理下面这样的嵌套对象，这是一个拥有汽车及汽车保险的客户。public class Person { private Car car; public Car getCar() { return car; } } public class Car { private Insurance insura
java8之----Optional取代null
只有变秃 才能变强
11-24 435
java8之—-Optional取代null小结: null在历史上被引入到程序设计语言中,目的是为了表示变量值的缺失. Java 8中引入了一个新的类 java.util.Optional ，对存在或缺失的变量值进行建模。 你可以使用静态工厂 Optional.empty(), Optional.of(),Optional.ofNullable 创建Optional对象. Optional类支持多
C++标准库解析：涵盖C++17新特性
此书由Rainer Grimm编写，旨在帮助读者深入了解C++标准库的使用。 本书首先介绍了C++标准库的历史，概述了其发展过程以及标准库在软件开发中的应用方式。接着，详细讲解了标准库中的各种实用工具，如基本函数、函数...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值