c++ 为什么std：：optional没有对引用类型进行专门化？

2guxujil  于 2024-01-09  发布在  其他
关注(0)|答案(6)|浏览(230)

为什么std::optional（std::experimental::optional目前在libc++中）没有对引用类型的专门化（与boost::optional相比）？
我认为这将是非常有用的选择。
在标准库中是否有一些对象 * 引用了可能已经存在的对象 * 语义？

c++

6条答案

按热度按时间
1qczuiv0

1qczuiv01#

当n3406（提案的修订版#2）进行了讨论，一些委员会成员对可选引用感到不安。（修订版#3），作者决定将可选引用作为一个辅助建议，以增加可选值获得批准并放入C14的机会。虽然由于各种其他原因，可选值并没有完全进入C14，委员会并不拒绝任择提及，今后如果有人提出，委员会可自由增加任择提及。

赞(0）分享  回复(0）举报  2024-01-09
ru9i0ody

ru9i0ody2#

std::optional <T&>的主要问题是-optRef = obj在以下情况下应该怎么做：

  1. optional<T&> optRef;
  2. …;
  3. T obj {…};
  4. optRef = obj; // <-- here!

字符串
变体：
1.始终重新绑定-(&optRef)->~optional(); new (&optRef) optional<T&>(obj)。
1.通过-*optRef = obj赋值（UB在!optRef之前时）。
1.如果为空则绑定，否则通过-if (optRef) {do1;} else {do2;}赋值。
1.没有赋值运算符-编译时错误“尝试使用已删除的运算符”。
各款产品的优点：

  • 始终重新绑定（由boost::optional和n1878选择）：
  • 始终满足!optRef和optRef.has_value()-后置条件**&***optRef == **&**obj时的情况之间的一致性。
  • 与通常的optional<T>在以下方面的一致性：对于通常的optional<T>，如果T::operator=被定义为破坏和构造（一些人认为它 * 必须 * 只不过是破坏和构造的优化），opt = … * 事实上 * 的行为类似于(&opt)->~optional(); new (&opt) optional<T&>(obj)。
  • 通过以下方式分配：
  • 与纯T&在以下方面保持一致：对于纯T&，ref = …通过赋值（而不是重新绑定ref）。
  • 与通常的optional<T>在以下方面保持一致：对于通常的optional<T>，当opt.has_value()时，需要通过opt = …进行赋值，而不是破坏并构造（参见n3672中的template <class U> optional<T>& optional<T>::operator=(U&& v)和on cppreference.com）。
  • 与通常的optional<T>在以下方面保持一致：两者都至少以某种方式定义了operator=。
  • 如果为空就绑定，否则赋值--我看不出有什么真实的的好处，恕我直言，只有当#1的支持者与#2的支持者争论时，这个变体才会出现，不管它在形式上与template <class U> optional<T>& optional<T>::operator=(U&& v)的要求更一致（但不符合其精神，恕我直言）。
  • 无赋值运算符（由n3406选择）：
  • 与纯T&在以下方面保持一致：纯T&不允许重新绑定自身。
  • 没有模棱两可的行为。

另请参阅：

展开查看全部
赞(0）分享  回复(0）举报  2024-01-09
8yparm6h

8yparm6h3#

确实有一些东西具有 reference tomaybeexisting object 的语义。它被称为（const）pointer。一个普通的旧的无所有权指针。reference和pointer之间有三个区别：
1.指针可以为空，引用不能。这正是std::optional要避免的区别。
1.指针可以被重定向指向其他东西。让它成为常量，这种差异也就消失了。
1.引用不需要被->或*解引用。这是纯粹的语法糖，因为1是可能的。指针语法（解引用并可转换为bool）正是std::optional提供的访问值和测试其存在的语法。

更新：optional是一个值容器。像其他容器（例如vector）一样，它不是 * 设计 * 来包含引用的。如果你想要一个可选的引用，使用指针，或者如果你确实需要一个与std::optional语法相似的接口，为指针创建一个小的（和普通的） Package 器。
**更新2：**至于问题 * 为什么 * 没有这样的专业化：因为委员会只是选择了它。理由 * 可能 * 在文件中找到。这可能是因为他们认为指针就足够了。

赞(0）分享  回复(0）举报  2024-01-09
gojuced7

gojuced74#

恕我直言，让std::optional<T&>可用是非常好的。然而，关于模板有一个微妙的问题。如果有引用，模板参数可能会变得棘手。
正如我们解决模板参数中引用问题的方法一样，我们可以使用std::reference_wrapper来规避std::optional<T&>的缺失。所以现在它变成了std::optional<std::reference_wrapper<T>>。但是我建议不要使用这种方法，因为1）它太冗长了，既要写签名，（尾随返回类型为我们节省了一点）和它的使用（我们必须调用std::reference_wrapper<T>::get()来获取真实的引用），（二）大多数程序员已经被指针折磨过了，所以当他们收到一个指针时，他们就像本能的React一样，首先测试它是否为空。现在不是什么大问题了

赞(0）分享  回复(0）举报  2024-01-09
q1qsirdb

q1qsirdb5#

如果让我大胆猜测的话，那是因为std：：experimental：：optional规范中的这句话。（第5.2节，p1）
如果一个程序需要示例化引用类型的模板optional，或者可能是cv限定的类型in_place_t或nullopt_t，那么这个程序就是病态的。

赞(0）分享  回复(0）举报  2024-01-09
nbnkbykc

nbnkbykc6#

我偶然发现了这个问题好几次，最后我决定实现我的解决方案，不依赖于boost。对于引用类型，它禁用赋值运算符，不允许比较指针或r值。它基于一个类似的work，我以前做过，它使用nullptr而不是nullopt来表示值的缺失。出于这个原因，该类型被称为nullable和编译是禁用指针类型（他们有nullptr反正）.请让我知道，如果你发现任何明显或任何不明显的问题与它.

  1. #ifndef COMMON_NULLABLE_H
  2. #define COMMON_NULLABLE_H
  3. #pragma once
  5. #include <cstddef>
  6. #include <stdexcept>
  7. #include <type_traits>
  9. namespace COMMON_NAMESPACE
  10. {
  11.     class bad_nullable_access : public std::runtime_error
  12.     {
  13.     public:
  14.         bad_nullable_access()
  15.             : std::runtime_error("nullable object doesn't have a value") { }
  16.     };
  18.     /**
  19.      * Alternative to std::optional that supports reference (but not pointer) types
  20.      */
  21.     template <typename T, typename = std::enable_if_t<!std::is_pointer<T>::value>>
  22.     class nullable final
  23.     {
  24.     public:
  25.         nullable()
  26.             : m_hasValue(false), m_value{ } { }
  28.         nullable(T value)
  29.             : m_hasValue(true), m_value(std::move(value)) { }
  31.         nullable(std::nullptr_t)
  32.             : m_hasValue(false), m_value{ } { }
  34.         nullable(const nullable& value) = default;
  36.         nullable& operator=(const nullable& value) = default;
  38.         nullable& operator=(T value)
  39.         {
  40.             m_hasValue = true;
  41.             m_value = std::move(value);
  42.             return *this;
  43.         }
  45.         nullable& operator=(std::nullptr_t)
  46.         {
  47.             m_hasValue = false;
  48.             m_value = { };
  49.             return *this;
  50.         }
  52.         const T& value() const
  53.         {
  54.             if (!m_hasValue)
  55.                 throw bad_nullable_access();
  57.             return m_value;
  58.         }
  60.         T& value()
  61.         {
  62.             if (!m_hasValue)
  63.                 throw bad_nullable_access();
  65.             return m_value;
  66.         }
  68.         bool has_value() const { return m_hasValue; }
  69.         const T* operator->() const { return &m_value; }
  70.         T* operator->() { return &m_value; }
  71.         const T& operator*() const { return m_value; }
  72.         T& operator*() { return m_value; }
  74.     public:
  75.         template <typename T2>
  76.         friend bool operator==(const nullable<T2>& lhs, const nullable<T2>& rhs);
  78.         template <typename T2>
  79.         friend bool operator!=(const nullable<T2>& lhs, const nullable<T2>& rhs);
  81.         template <typename T2>
  82.         friend bool operator==(const nullable<std::decay_t<T2>>& lhs, const nullable<T2&>& rhs);
  84.         template <typename T2>
  85.         friend bool operator!=(const nullable<std::decay_t<T2>>& lhs, const nullable<T2&>& rhs);
  87.         template <typename T2>
  88.         friend bool operator==(const nullable<T2&>& lhs, const nullable<std::decay_t<T2>>& rhs);
  90.         template <typename T2>
  91.         friend bool operator!=(const nullable<T2&>& lhs, const nullable<std::decay_t<T2>>& rhs);
  93.         template <typename T2>
  94.         friend bool operator==(const nullable<T2>& lhs, const T2& rhs);
  96.         template <typename T2>
  97.         friend bool operator==(const T2& lhs, const nullable<T2>& rhs);
  99.         template <typename T2>
  100.         friend bool operator==(const nullable<T2>& lhs, std::nullptr_t);
  102.         template <typename T2>
  103.         friend bool operator!=(const nullable<T2>& lhs, const T2& rhs);
  105.         template <typename T2>
  106.         friend bool operator!=(const T2& lhs, const nullable<T2>& rhs);
  108.         template <typename T2>
  109.         friend bool operator==(std::nullptr_t, const nullable<T2>& rhs);
  111.         template <typename T2>
  112.         friend bool operator!=(const nullable<T2>& lhs, std::nullptr_t);
  114.         template <typename T2>
  115.         friend bool operator!=(std::nullptr_t, const nullable<T2>& rhs);
  117.     private:
  118.         bool m_hasValue;
  119.         T m_value;
  120.     };
  122.     // Template spacialization for references
  123.     template <typename T>
  124.     class nullable<T&> final
  125.     {
  126.     public:
  127.         nullable()
  128.             : m_hasValue(false), m_value{ } { }
  130.         nullable(T& value)
  131.             : m_hasValue(true), m_value(&value) { }
  133.         nullable(std::nullptr_t)
  134.             : m_hasValue(false), m_value{ } { }
  136.         nullable(const nullable& value) = default;
  138.         nullable& operator=(const nullable& value) = default;
  140.         const T& value() const
  141.         {
  142.             if (!m_hasValue)
  143.                 throw bad_nullable_access();
  145.             return *m_value;
  146.         }
  148.         T& value()
  149.         {
  150.             if (!m_hasValue)
  151.                 throw bad_nullable_access();
  153.             return *m_value;
  154.         }
  156.         bool has_value() const { return m_hasValue; }
  157.         const T* operator->() const { return m_value; }
  158.         T* operator->() { return m_value; }
  159.         const T& operator*() const { return *m_value; }
  160.         T& operator*() { return *m_value; }
  162.     public:
  163.         template <typename T2>
  164.         friend bool operator==(const nullable<std::decay_t<T2>>& lhs, const nullable<T2&>& rhs);
  166.         template <typename T2>
  167.         friend bool operator!=(const nullable<std::decay_t<T2>>& lhs, const nullable<T2&>& rhs);
  169.         template <typename T2>
  170.         friend bool operator==(const nullable<T2&>& lhs, const nullable<std::decay_t<T2>>& rhs);
  172.         template <typename T2>
  173.         friend bool operator!=(const nullable<T2&>& lhs, const nullable<std::decay_t<T2>>& rhs);
  175.         template <typename T2>
  176.         friend bool operator==(const nullable<T2&>& lhs, const nullable<T2&>& rhs);
  178.         template <typename T2>
  179.         friend bool operator!=(const nullable<T2&>& lhs, const nullable<T2&>& rhs);
  181.         template <typename T2>
  182.         friend bool operator==(const nullable<T2&>& lhs, const std::decay_t<T2>& rhs);
  184.         template <typename T2>
  185.         friend bool operator!=(const nullable<T2&>& lhs, const std::decay_t<T2>& rhs);
  187.         template <typename T2>
  188.         friend bool operator==(const std::decay_t<T2>& lhs, const nullable<T2&>& rhs);
  190.         template <typename T2>
  191.         friend bool operator!=(const std::decay_t<T2>& lhs, const nullable<T2&>& rhs);
  193.         template <typename T2>
  194.         friend bool operator==(const nullable<T2>& lhs, std::nullptr_t);
  196.         template <typename T2>
  197.         friend bool operator==(std::nullptr_t, const nullable<T2>& rhs);
  199.         template <typename T2>
  200.         friend bool operator!=(const nullable<T2>& lhs, std::nullptr_t);
  202.         template <typename T2>
  203.         friend bool operator!=(std::nullptr_t, const nullable<T2>& rhs);
  205.     private:
  206.         bool m_hasValue;
  207.         T* m_value;
  208.     };
  210.     template <typename T>
  211.     using nullableref = nullable<T&>;
  213.     template <typename T2>
  214.     bool operator==(const nullable<T2>& lhs, const nullable<T2>& rhs)
  215.     {
  216.         if (lhs.m_hasValue != rhs.m_hasValue)
  217.             return false;
  219.         if (lhs.m_hasValue)
  220.             return lhs.m_value == rhs.m_value;
  221.         else
  222.             return true;
  223.     }
  225.     template <typename T2>
  226.     bool operator!=(const nullable<T2>& lhs, const nullable<T2>& rhs)
  227.     {
  228.         if (lhs.m_hasValue != rhs.m_hasValue)
  229.             return true;
  231.         if (lhs.m_hasValue)
  232.             return lhs.m_value != rhs.m_value;
  233.         else
  234.             return false;
  235.     }
  237.     template <typename T2>
  238.     bool operator==(const nullable<std::decay_t<T2>>& lhs, const nullable<T2&>& rhs)
  239.     {
  240.         if (lhs.m_hasValue != rhs.m_hasValue)
  241.             return true;
  243.         if (lhs.m_hasValue)
  244.             return lhs.m_value != *rhs.m_value;
  245.         else
  246.             return false;
  247.     }
  249.     template <typename T2>
  250.     bool operator!=(const nullable<std::decay_t<T2>>& lhs, const nullable<T2&>& rhs)
  251.     {
  252.         if (lhs.m_hasValue != rhs.m_hasValue)
  253.             return true;
  255.         if (lhs.m_hasValue)
  256.             return lhs.m_value != *rhs.m_value;
  257.         else
  258.             return false;
  259.     }
  261.     template <typename T2>
  262.     bool operator==(const nullable<T2&>& lhs, const nullable<std::decay_t<T2>>& rhs)
  263.     {
  264.         if (lhs.m_hasValue != rhs.m_hasValue)
  265.             return false;
  267.         if (lhs.m_hasValue)
  268.             return *lhs.m_value == rhs.m_value;
  269.         else
  270.             return true;
  271.     }
  273.     template <typename T2>
  274.     bool operator!=(const nullable<T2&>& lhs, const nullable<std::decay_t<T2>>& rhs)
  275.     {
  276.         if (lhs.m_hasValue != rhs.m_hasValue)
  277.             return true;
  279.         if (lhs.m_hasValue)
  280.             return *lhs.m_value != rhs.m_value;
  281.         else
  282.             return false;
  283.     }
  285.     template <typename T2>
  286.     bool operator==(const nullable<T2&>& lhs, const nullable<T2&>& rhs)
  287.     {
  288.         if (lhs.m_hasValue != rhs.m_hasValue)
  289.             return false;
  291.         if (lhs.m_hasValue)
  292.             return *lhs.m_value == *rhs.m_value;
  293.         else
  294.             return true;
  295.     }
  297.     template <typename T2>
  298.     bool operator!=(const nullable<T2&>& lhs, const nullable<T2&>& rhs)
  299.     {
  300.         if (lhs.m_hasValue != rhs.m_hasValue)
  301.             return true;
  303.         if (lhs.m_hasValue)
  304.             return *lhs.m_value != *rhs.m_value;
  305.         else
  306.             return false;
  307.     }
  309.     template <typename T2>
  310.     bool operator==(const nullable<T2&>& lhs, const std::decay_t<T2>& rhs)
  311.     {
  312.         if (!lhs.m_hasValue)
  313.             return false;
  315.         return *lhs.m_value == rhs;
  316.     }
  318.     template <typename T2>
  319.     bool operator!=(const nullable<T2&>& lhs, const std::decay_t<T2>& rhs)
  320.     {
  321.         if (!lhs.m_hasValue)
  322.             return true;
  324.         return *lhs.m_value != rhs;
  325.     }
  327.     template <typename T2>
  328.     bool operator==(const std::decay_t<T2>& lhs, const nullable<T2&>& rhs)
  329.     {
  330.         if (!rhs.m_hasValue)
  331.             return false;
  333.         return lhs == *rhs.m_value;
  334.     }
  336.     template <typename T2>
  337.     bool operator!=(const std::decay_t<T2>& lhs, const nullable<T2&>& rhs)
  338.     {
  339.         if (!rhs.m_hasValue)
  340.             return true;
  342.         return lhs != *rhs.m_value;
  343.     }
  345.     template <typename T2>
  346.     bool operator==(const nullable<T2>& lhs, const T2& rhs)
  347.     {
  348.         if (!lhs.m_hasValue)
  349.             return false;
  351.         return lhs.m_value == rhs;
  352.     }
  354.     template <typename T2>
  355.     bool operator!=(const nullable<T2>& lhs, const T2& rhs)
  356.     {
  357.         if (!lhs.m_hasValue)
  358.             return true;
  360.         return lhs.m_value != rhs;
  361.     }
  363.     template <typename T2>
  364.     bool operator==(const T2& lhs, const nullable<T2>& rhs)
  365.     {
  366.         if (!rhs.m_hasValue)
  367.             return false;
  369.         return lhs == rhs.m_value;
  370.     }
  372.     template <typename T2>
  373.     bool operator!=(const T2& lhs, const nullable<T2>& rhs)
  374.     {
  375.         if (!rhs.m_hasValue)
  376.             return true;
  378.         return lhs != rhs.m_value;
  379.     }
  381.     template <typename T2>
  382.     bool operator==(const nullable<T2>& lhs, std::nullptr_t)
  383.     {
  384.         return !lhs.m_hasValue;
  385.     }
  387.     template <typename T2>
  388.     bool operator!=(const nullable<T2>& lhs, std::nullptr_t)
  389.     {
  390.         return lhs.m_hasValue;
  391.     }
  393.     template <typename T2>
  394.     bool operator==(std::nullptr_t, const nullable<T2>& rhs)
  395.     {
  396.         return !rhs.m_hasValue;
  397.     }
  399.     template <typename T2>
  400.     bool operator!=(std::nullptr_t, const nullable<T2>& rhs)
  401.     {
  402.         return rhs.m_hasValue;
  403.     }
  404. }
  406. #endif // COMMON_NULLABLE_H

字符串

展开查看全部
赞(0）分享  回复(0）举报  2024-01-09
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com