如何优雅的使用 std::variant 与 std::optional

std::variant<int, double, std::string> x, y;

x = 1;
y = "1.0";
x = 2.0; // overwrite value

std::cout << "x - " << x.index() << std::endl;
std::cout << "y - " << y.index() << std::endl;

double d = std::get<double>(x);
std::string s = std::get<2>(y);

try
{
    int i = std::get<int>(x);
}
catch (std::bad_variant_access e)
{
    std::cerr << e.what() << std::endl;
}

int* i = std::get_if<int>(&x);
if (i == nullptr)
{
    std::cout << "wrong type" << std::endl;
}
else
{
    std::cout << "value is " << *i << std::endl;
}

int main()
{
  std::string text = /*...*/;
  std::optional<unsigned> opt = firstEvenNumberIn(text);
  if (opt.has_value()) 
  {
    std::cout << "The first even number is "
              << opt.value()
              << ".\n";
  }
}

// 跟迭代器的使用类似，访问没有 value 的 optional 的行为是未定义的
cout << (*ret).out1 << endl; 
cout << ret->out1 << endl;

// 当没有 value 时调用该方法将 throws std::bad_optional_access 异常
cout << ret.value().out1 << endl;

// 当没有 value 调用该方法时将使用传入的默认值
Out defaultVal;
cout << ret.value_or(defaultVal).out1 << endl;

std::variant<double, bool, std::string> var;
struct {
    void operator()(int) { std::cout << "int!\n"; }
    void operator()(std::string const&) { std::cout << "string!\n"; }
} visitor;

std::visit(visitor, var);

std::variant<int> abc, def;
abc = 3;
def = 4;
bool testval = std::visit(overloaded{
    [](int a, int b) {
        return a < b;
    },
}, abc, def);

/**
 * \brief Value visitor which converts the stored value to a type T
 */
template <typename T>
struct ConvertVisitor
{
    using result_type = T;

    template <typename U>
    T operator()(const U& value) const
    {
        // Dispatch to the proper ValueConverter
        return ponder_ext::ValueMapper<T>::from(value);
    }

    // Optimization when source type is the same as requested type
    T operator()(const T& value) const
    {
        return value;
    }
    T operator()(T&& value) const
    {
        return std::move(value);
    }

    T operator()(NoType) const
    {
        // Error: trying to convert an empty value
        PONDER_ERROR(BadType(ValueKind::None, mapType<T>()));
    }
};

/**
 * \brief Binary value visitor which compares two values using operator <
 */
struct LessThanVisitor
{
    using result_type = bool;

    template <typename T, typename U>
    bool operator()(const T&, const U&) const
    {
        // Different types : compare types identifiers
        return mapType<T>() < mapType<U>();
    }

    template <typename T>
    bool operator()(const T& v1, const T& v2) const
    {
        // Same types : compare values
        return v1 < v2;
    }

    bool operator()(NoType, NoType) const
    {
        // No type (empty values) : they're considered equal
        return false;
    }
};

/**
 * \brief Binary value visitor which compares two values using operator ==
 */
struct EqualVisitor
{
    using result_type = bool;

    template <typename T, typename U>
    bool operator()(const T&, const U&) const
    {
        // Different types : not equal
        return false;
    }

    template <typename T>
    bool operator()(const T& v1, const T& v2) const
    {
        // Same types : compare values
        return v1 == v2;
    }

    bool operator()(NoType, NoType) const
    {
        // No type (empty values) : they're considered equal
        return true;
    }
};

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

std::variant<double, bool, std::string> var;
std::visit(overloaded {
            [](auto arg) { std::cout << arg << ' '; },
            [](double arg) { std::cout << std::fixed << arg << ' '; },
            [](const std::string& arg) { std::cout << std::quoted(arg) << ' '; },
        }, var);

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

using Ts::operator()...;

template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

overloaded {
            [](auto arg) { std::cout << arg << ' '; },
            [](double arg) { std::cout << std::fixed << arg << ' '; },
            [](const std::string& arg) { std::cout << std::quoted(arg) << ' '; },
        }