如何制作 boost::variant 的简化版本？

Question

我有一套更简单的要求，不需要太多变体的机器。如果我能帮上忙，我也不想依赖 boost。

我需要存储编译时已知的任意类型（可能是void）。它要么是可移动构造的，要么是可复制构造的，如果其中任何一个抛出，则允许包含的值未定义。

除了这个值，它还可以包含::std::exception_ptr 或::std::error_code。

如果T 被允许无效，::boost::variant<T, ::std::exception_ptr, ::std::error_code> 将起作用。除了::boost::variant 提供了我在这种情况下实际上不需要的“永不空保证”。而且，如果我理解它是如何正常工作的，它与可以移动但不能复制的类型不太兼容。

现在我正在编写大量重复的代码，我不应该编写这些代码来分别处理每种类型。我还存储了每种类型和标志值的对象的副本，说明哪些是相关的。最后，void 提供了整个系统的概念，并要求我在各处编写专业。

有没有更好的办法？

这是我所拥有的一个简化示例。这基本上是一个旨在保存传输到另一个线程的结果的类，有点像未来：

template <typename ResultType>
class stored_result {
 public:
   stored_result() : is_val_(false), is_err_(false), is_exception_(false) { }

   void set_bad_result(::std::error err) {
      is_err_ = true;
      error_ = ::std::move(err);
   }
   void set_bad_result(::std::exception_ptr exception) {
      is_exception_ = true;
      exception_ = ::std::move(exception);
   }
   void set_result(ResultType res) {
      is_val_ = true;
      val_ = ::std::move(res);
   }

   ResultType result() {
      if (is_val_) {
         is_val_ = false;
         return ::std::move(val_);
      } else if (is_exception_) {
         is_exception_ = false;
         ::std::rethrow_exception(::std::move(exception_));
      } else if (is_error_) {
         is_error_ = false;
         throw ::std::system_error(error_);
      } else {
         throw ::std::runtime_error("Asked for result when there was none.");
      }
   }

 private:
   bool is_val_, is_err_, is_exception_;
   T val_;
   ::std::exception_ptr exception_;
   ::std::error_code error_;
};

Answer 1

如何使用您现在拥有的代码以透明方式处理void 的示例：

struct empty_type {};

template<typename T>
using Store = typename std::conditional<std::is_void<T>::value, empty_type, T>::type;

template<typename T>
T&&
restore(T&& t)
{
    return std::forward<T>(t);
}

void
restore(empty_type)
{}

template <typename ResultType>
class stored_result {
public:
    // snipped everything that is left unchanged

    template<
        typename U = ResultType
        , typename std::enable_if<
            !std::is_void<U>::value
            , int
        >::type = 0
    >          
    void set_result(U res) {
        is_val_ = true;
        val_ = std::move(res);
    }

    template<
        typename U = ResultType
        , typename std::enable_if<
            std::is_void<U>::value
            , int
        >::type = 0
    >          
    void set_result() {
        is_val_ = true;
    }

    ResultType result() {
        if (is_val_) {
            is_val_ = false;
            return restore(std::move(val_));
        } else if {
            // rest as before
    }

private:
    Store<T> val_;
};

虽然代码未经测试，但可能有一些问题。

Answer 2

[编辑：在我写完这个问题后，问题被编辑，添加了示例代码]。

它似乎你所追求的是一种从函数返回有效结果（任意类型）或指示失败的东西的方法。

如果是这样，那么下面的代码可以很好地解决您的问题，即返回任意类型结果的部分（这个类类似于boost::optional，它又基于 Barton 和 Nackman 的Fallible类）。

对于错误指示，只需将布尔值替换为错误信息，并将概念上的“无”替换为概念上的“失败”：

#pragma once
// #include <cpp/optional.h>
// Author: Alf P. Steinbach. License: Boost 1.0


//----------------------------------------------- Dependencies:

#include <cpp/type_properties.h>        // cpp::IsPod_
#include <cpp/throwing.h>               // cpp::hopefully, cpp::throwX
#include <vector>                       // std::vector


//----------------------------------------------- Interface:

namespace cpp {

    namespace detail {
        using std::vector;

        template< class Type, Podness::Enum podNess = Podness::isPod >
        class ValueWrapper_
        {
        private:
            Type    v_;
        public:
            Type const& ref() const { return v_; }

            ValueWrapper_() {}       // No initialization
            ValueWrapper_( Type const v ): v_( v ) {}
        };

        template< class Type >
        struct ValueWrapper_< Type, Podness::isNotPod >
        {
        private:
            vector<Type>    v_;     // General but incurs allocation overhead.
        public:
            Type const& ref() const { return v_[0]; }

            ValueWrapper_() {}       // Supports apparent no initialization.
            ValueWrapper_( Type const v ): v_( 1, v ) {}
        };
    }    // namespace detail

    template< class Type >
    class Optional_
    {
    private:
        typedef detail::ValueWrapper_<Type, Podness_<Type>::value > Wrapper;

        Wrapper const   value_;
        bool const      isNone_;

        Optional_& operator=( Optional_ const& );         // No such.

    public:
        bool isNone() const { return isNone_; }

        Type const& value() const
        {
            hopefully( !isNone_ )
                || throwX( "Optional_::value(): there is no value" );
            return value_.ref();
        }

        Optional_(): isNone_( true ) {}
        Optional_( Type const& v ): value_( v ), isNone_( false ) {}

        static Optional_ none() { return Optional_(); }
    };

    template<>
    class Optional_< void >
    {
    private:
        Optional_& operator=( Optional_ const& );         // No such.

    public:
        bool isNone() const { return true; }

        void value() const
        {
            throwX( "Optional_::value(): there is no value" );
        }

        Optional_() {}
        static Optional_ none() { return Optional_(); }
    };
}  // namespace cpp