如何在`std::variant`包装类中使用重载`operator==`来比较SettingVsSetting和TvsT？

html5 • • 问答

我正在尝试为operator==围绕std::variant. 这个想法是Setting该类与其他Setting对象以及变体支持的类型具有可比性。我已经在没有模板的情况下解决了这个问题，因为它很容易写出operators==，但是学习模板方式对我来说很重要。

所以，这就是我希望Setting使用的方式：

Setting s1("string");
Setting s2("string");
s1 == s2; // okay, equals true

也

Setting s3("string");
s3 == "string"; // should equal true
std::string s4 = "string";
s3 == s4; // also True

这是我到目前为止所得到的，尽管我很确定我还有很长的路要走。策略是对 进行模板化operator=，如果模板参数T是有效的变体 ( setting_t) 类型，则从变体中提取值作为类型T并执行比较（T与 比较T）。或者， whenT是 another Setting，我们可以直接比较setting_成员变量（Setting与 比较Setting）。

#include <type_traits>
#include <variant>

using setting_t = std::variant<std::string, int, double>;

/**
 * Utility which is true when
 * type T is in a variant, false otherwise.
 * For instance,
 *  std::string x("a String");
 *  bool truth = isValidVariantType<decltype(x), setting_t>(); // true
 *  
 *  unsigned long x = 4;
 *  bool truth = isValidVariantType<decltype(x), setting_t>(); // false
 */
template<typename T, typename ALL_T>
struct isValidVariantType;

template<typename T, typename... ALL_T>
struct isValidVariantType<T, std::variant<ALL_T...>>
        : public std::disjunction<std::is_same<T, ALL_T>...> {
};

class Setting {
public:
    explicit Setting(setting_t setting)
            : setting_(std::move(setting)) {}

    template <typename T,
            class = typename std::enable_if<isValidVariantType<T, setting_t>::value>::type>
    bool operator==(const T& setting){
        T val = std::get<T>(setting);
        return val == setting;
    }

private:
    setting_t setting_;
};

我现在已经花了很多时间在这上面，所以我很感激你能给我的任何建议。提前致谢！

编辑 - 编译器错误

根据要求，这是编译器当前生成的内容

当我运行 SettingTests.SettingVsSetting

TEST(SettingTests, SettingVsSetting){
    Setting setting1("a String");
    Setting setting2("a String");
//    bool truth = setting1 == setting2;
}

生成以下编译器消息：

/home/ciaran/SettingTests/SRC/TemplateTutorialTests.cpp: In member function ‘virtual void SettingTests_SettingVsSetting_Test::TestBody()’:
/home/ciaran/SettingTests/SRC/TemplateTutorialTests.cpp:11:27: error: no match for ‘operator==’ (operand types are ‘Setting’ and ‘Setting’)
   11 |     bool truth = setting1 == setting2;
      |                  ~~~~~~~~ ^~ ~~~~~~~~
      |                  |           |
      |                  Setting     Setting
In file included from /home/ciaran/SettingTests/SRC/TemplateTutorialTests.cpp:2:
/home/ciaran/SettingTests/SRC/TermplateTutorial.hpp:32:10: note: candidate: ‘template<class T, class> bool Setting::operator==(const T&)’
   32 |     bool operator==(const T& setting){
      |          ^~~~~~~~
/home/ciaran/SettingTests/SRC/TermplateTutorial.hpp:32:10: note:   template argument deduction/substitution failed:
/home/ciaran/SettingTests/SRC/TermplateTutorial.hpp:31:13: error: no type named ‘type’ in ‘struct std::enable_if<false, void>’
   31 |             class = typename std::enable_if<isValidVariantType<T, setting_t>::value>::type>
      |             ^~~~~

同时 Setting.SettingVsString

TEST(SettingTests, SettingVsString){
    Setting setting1("a String");
    std::string setting2("a String");
    bool truth = setting1 == setting2;
}

产生

/home/ciaran/SettingTests/SRC/TermplateTutorial.hpp: In instantiation of ‘bool Setting::operator==(const T&) [with T = std::__cxx11::basic_string<char>; <template-parameter-1-2> = void]’:
/home/ciaran/SettingTests/SRC/TemplateTutorialTests.cpp:17:30:   required from here
/home/ciaran/SettingTests/SRC/TermplateTutorial.hpp:33:28: error: no matching function for call to ‘get<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >(const std::__cxx11::basic_string<char>&)’
   33 |         T val = std::get<T>(setting);
      |                 ~~~~~~~~~~~^~~~~~~~~
In file included from /usr/include/c++/10/bits/unique_ptr.h:36,
                 from /usr/include/c++/10/memory:83,
                 from /home/ciaran/SettingTests/googletest/googletest/include/gtest/gtest.h:57,
                 from /home/ciaran/SettingTests/SRC/TemplateTutorialTests.cpp:1:
/usr/include/c++/10/utility:223:5: note: candidate: ‘template<long unsigned int _Int, class _Tp1, class _Tp2> constexpr typename std::tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type& std::get(std::pair<_Tp1, _Tp2>&)’
  223 |     get(std::pair<_Tp1, _Tp2>& __in) noexcept
      |     ^~~
/usr/include/c++/10/utility:223:5: note:   template argument deduction/substitution failed:
/usr/include/c++/10/utility:228:5: note: candidate: ‘template<long unsigned int _Int, class _Tp1, class _Tp2> constexpr typename std::tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&& std::get(std::pair<_Tp1, _Tp2>&&)’
  228 |     get(std::pair<_Tp1, _Tp2>&& __in) noexcept
      |     ^~~

... (it goes on like this for a while)

编辑 3 - 替代 operator==

    template<typename T,
            class = typename std::enable_if<isValidVariantType<T, setting_t>::value>::type>
    bool operator==(const T &setting) {
        if (auto val = std::get_if<T>(&setting_)){
            return *val == setting;
        };
        return false;
    }

回答

你有一个错字；您正在调用std::get该setting参数，而不是this->setting_. 修复使您的代码编译。

但是你可以做得更好。

template<class D, class T>
class SettingEqual {
    D const& self() const { return *static_cast<D const*>(this); }
    D & self() { return *static_cast<D*>(this); }
    decltype(auto) setting() { return self().setting_; }
    decltype(auto) setting() const { return self().setting_; }

    friend bool operator==( SettingEqual const& self, T const& t ) {
      if (!std::holds_alternative<T>(self.setting())) return false;
      return std::get<T>(self.setting()) == t;
    }
    friend bool operator==( T const& t, SettingEqual const& self ) {
      return (self==t);
    }
    friend bool operator!=( T const& t, SettingEqual const& self ) {
      return !(self==t);
    }
    friend bool operator!=( SettingEqual const& self, T const& t ) {
      return !(self==t);
    }
};
template<class...Ts>
class SettingT:
    public SettingEqual<SettingT<Ts...>, Ts>...
{
    template<class D, class T>
    friend class SettingEqual;
public:
    explicit SettingT(std::variant<Ts...> setting)
            : setting_(std::move(setting)) {}

private:
    std::variant<Ts...> setting_;
};
using Setting = SettingT<std::string, int, double>;

这在左侧和右侧引入了一个==和!=重载，参与重载决议。

它还检查类型是否匹配，并表示不匹配的类型不相等。

使用的技术是“CRTP”，在那里我将实现推到一个父类中，该类静态转换向下，以及 Koenig 或 ADL 朋友运算符，这让我将非模板operator==s 注入到查找中Setting == something以参与重载解析。

活生生的例子。

现在这还不错，但它遇到了将事物转换为T. 因此SettingT<std::string> == "hello"熄灭，并创建一个std::string，然后放"hello"它，然后比较std::string在SettingT进去。

真的，我们只想将 直接分派"hello"给std::string==，或者做一些更好的事情。

template<class T>
struct tag_t {using type=T;};
template<class T>
constexpr tag_t<T> tag{};

template<class T>
struct overload_detect {
  auto operator()(T const&){return tag<T>;};
};
template<class...Ts>
struct overload_detector:overload_detect<Ts>... {
  using overload_detect<Ts>::operator()...;
};
template<class T0, class...Ts>
using best_conversion = typename decltype(overload_detector<Ts...>{}( std::declval<T0 const&>() ))::type;
template<class T, class...Ts>
concept any_conversion = requires (T a) {
    { (std::void_t<best_conversion<T, Ts...>>)(0) };
};

template<class...Ts>
class SettingT
{
public:
    explicit SettingT(std::variant<Ts...> setting)
            : setting_(std::move(setting)) {}
    template<any_conversion<Ts...> U>
    friend bool operator==(SettingT const& self, U const& u) {
        using T = best_conversion<U, Ts...>;
        if (!std::holds_alternative<T>(self.setting_)) return false;
        return std::get<T>(self.setting_) == u;
    }
    template<any_conversion<Ts...> U>
    friend bool operator==(U const& u,SettingT const& self) {
        return self==u;
    }
    template<any_conversion<Ts...> U>
    friend bool operator!=(U const& u,SettingT const& self) {
        return !(self==u);
    }
    template<any_conversion<Ts...> U>
    friend bool operator!=(SettingT const& self, U const& u) {
        return !(self==u);
    }
private:
    std::variant<Ts...> setting_;
};

现在best_conversion<X, Ys...>找到Ysfor之间的最佳转换X并返回该类型，我们==不先进行转换就调度到。

== 可以自由地进行转换，或者它可以选择做一些更有效的事情。

活生生的例子。

以上是如何在`std::variant`包装类中使用重载`operator==`来比较SettingVsSetting和TvsT？的全部内容。
THE END
分享
二维码
< <上一篇
下一篇>>