如何为使用“std::variant”的类型实现赋值运算符？

如何解决如何为使用“std::variant”的类型实现赋值运算符？

我正在用 c++17 中的 std::variant 替换 Variant（基于 Poco）的实现。使用以下代码，我可以在适当的情况下将 Variant 对象转换为 std::variant 持有的任何类型。但是，我在另一个方向上遇到了困难 - 即如何将其他类型隐式转换为我的 Variant。

#ifndef MINIMALVARIANT
#define MINIMALVARIANT

#include <iostream>
#include <utility>
#include <variant>
#include "gtest/gtest.h"

using variant_t = std::variant<std::string,bool,std::int32_t,std::uint32_t>;

class Variant {
public:
    explicit Variant(variant_t value)
            : variant_(std::move(value)) {};

    Variant() = default;

    template<class T>
    T *get_if() {
        return std::get_if<T>(&variant_);
    }

    template<typename T>
    operator T() const {
        return std::visit(
                [&](auto const &val) {
                    if constexpr (std::is_convertible_v<decltype(val),T>) {
                        return T(val);
                    } else {
                        // T is not supported conversion type from typeid(value_)
                        throw std::bad_variant_access{};
                        return T{}; // oddly enough,this *is* necessary
                    }
                },variant_);
    }

    bool operator==(const Variant &rhs) const {
        return variant_ == rhs.variant_;
    }

    bool operator!=(const Variant &rhs) const {
        return !(rhs == *this);
    }

    Variant &operator=(const Variant &setting) {
        if (*this != setting) {
            variant_ = setting.variant_;
        };
        return *this;
    }

    Variant &operator=(Variant &&setting) noexcept {
        if (*this != setting) {
            variant_ = std::move(setting.variant_);
        };
        return *this;
    }

private:
    variant_t variant_;
};


#endif // MINIMALVARIANT

我想要的行为几乎总结在以下测试中，如果它们确实可能的话（它们使用 Poco 实现，所以我假设它们使用 STL 实现）。

#include "gtest/gtest.h"
#include "MinimalVariant.h"

TEST(VariantTests,ImplicitConvertVariantToType){
    Variant v(1234);
    unsigned int u = v; // okay
    ASSERT_EQ(u,1234); // pass
}

TEST(VariantTests,ImplicitConvertTypeToVariant){
    unsigned int u = 1234;
    Variant v;
    // v = u; // error,assignment operators do not work
}

bool funcThatTakesAVariant(Variant v){
    if (bool x = v.get_if<bool>()){
        return x;
    } else {
        return false;
    }
}

TEST(VariantTests,ImplicitConvertFuncParameter){
    // ASSERT_TRUE(funcThatTakesAVariant(true)); // error,no implicit cast from bool to Variant
}

Variant funcThatReturnsAVariant(bool truth){
    return truth; // compile error
}

TEST(VariantTests,ImplicitConvertReturnType){
    Variant boolVariant = funcThatReturnsAVariant(true);
}

}

TEST(VariantTests,ImplicitConvertTypeToVariant){
    unsigned int u = 1234;
    Variant v;
    v = u;
}

目前，我已经尝试对赋值运算符和模板化构造函数进行模板化，但到目前为止，我尝试过的一切都失败了。