使用 std::variant 的静态多态性

Posted 2023-02-23

【中文标题】使用 std::variant 的静态多态性

【英文标题】：Static polymorphism using std::variant

【发布时间】：2021-04-04 17:20:45

【问题描述】：

我正在尝试使用 std::variant 实现静态多态。我想使用 VARIANT_METHOD 或 VARIANT_METHOD_CONST 声明方法，这些方法应采用返回类型、方法名称、参数和限定符。

#include <variant>

#define VARIANT_METHOD(retType, name, ...) \
    template <typename... Args> retType name (Args&&... args) __VA_ARGS__                    \
    return std::visit([...args = std::forward<Args>(args)] <typename T>(T& self) -> retType  \
        return self.name(args...);                                                                   \
    , static_cast<variant&>(*this));                                                                \

#define VARIANT_METHOD_CONST(retType, name, ...) template <typename... Args> \
    retType name (Args&&... args) __VA_ARGS__                                                     \
    return std::visit([...args = std::forward<Args>(args)]<typename T>(const T& self) -> retType  \
        return self.name(args...);                                                                        \
    , static_cast<const variant&>(*this));                                                               \

#define VARIANT_FIELD(name) \
    decltype(auto) name() noexcept                                 \
        return std::visit([](auto& self) -> decltype(auto)         \
            return self.name;                                       \
        , static_cast<variant&>(*this));                           \
                                                                   \
    decltype(auto) name() const noexcept                           \
        return std::visit([](const auto& self) -> decltype(auto)   \
            return self.name;                                       \
        , static_cast<const variant&>(*this));                     \
    

struct A 
    int field;
    int field2;

    int func(int a) const noexcept 
        return a + field;
    
    int func(int a, int b) const noexcept 
        return a * a;
    
;

struct B 
    int field2;
    int func(int a) const noexcept 
        return a * a;
    
    int func(int a, int b) const noexcept 
        return a * a;
    
;

struct C : protected std::variant<A, B> 
    using variant::variant;

    VARIANT_FIELD(field2);
    VARIANT_METHOD_CONST(int, func, const noexcept); // (1)
;

int main() 
    std::vector<C> vec;
    vec.emplace_back(A.field = 0, .field2 = 1);
    vec.emplace_back(B.field2 = 3);

    for (auto& c : vec) 
        c.func(10);
    

我不能声明两个具有相同名称但具有不同参数的方法。我想写这样的东西：

VARIANT_METHOD_CONST(int, func, (int a), const noexcept);
VARIANT_METHOD_CONST(int, func, (int a, int b), const noexcept);

【问题讨论】：

你可以先解释你正在尝试做什么以及你遇到了什么错误。

嗯...对不起？

不，我的意思是您可以从编辑问题开始，描述您想要实现的目标以及遇到的错误。

I want to write something like this: 好的，结果应该是什么？

我的意思是字面意思，它应该在文本上产生什么结果？所以就写int func(int) int func(int, int)？ : protected std::variant 是否允许从任何 std:: 类继承？为什么不直接使用合成？为什么是所有的宏？

【参考方案1】：

我所知道的最干净的方法是滥用operator->* 并制作多态方法指针。你可以获得相同的语法（除了->* 而不是.），没有宏。

template<class F>
struct poly_member 
  F f;
  friend decltype(auto) operator->*( auto&& t, poly_member const& self) 
    return self.f(decltype(t)(t));
  
  template<class...Ts>
  friend decltype(auto) operator->*( std::variant<Ts...>& var, poly_member const& self ) 
    return std::visit( self.f, var );
  
  template<class...Ts>
  friend decltype(auto) operator->*( std::variant<Ts...>&& var, poly_member const& self ) 
    return std::visit( self.f, var );
  
  template<class...Ts>
  friend decltype(auto) operator->*( std::variant<Ts...> const& var, poly_member const& self ) 
    return std::visit( self.f, var );
  
  template<class...Ts>
  friend decltype(auto) operator->*( std::variant<Ts...> const&& var, poly_member const& self ) 
    return std::visit( self.f, var );
  
;
template<class F>
poly_member(F)->poly_member<F>;
template<class F>
struct poly_method 
  F f;
  auto operator()(auto&&...args)const 
    return poly_member[&](auto&& t)->decltype(auto)
      return f( decltype(t)(t), decltype(args)(args)... );
    ;
  
  friend auto operator->*( auto&& t, poly_method const& self) 
    return [&](auto&&...args)->decltype(auto)
      return t->*self.f(decltype(args)(args)...);
    ;
  
  friend auto operator->*( auto* t, poly_method const& self) 
    return (*t)->*self;
  
;
template<class F>
poly_method(F)->poly_method<F>;

一点c++20 字母汤。将 auto 参数替换为 template<class T> 等以获得 c++14 版本。

你最终会像这样制作 poly 成员：

constexpr poly_member field  [](auto&& t)->decltype(auto) return t.field;  ;
constexpr poly_member field2  [](auto&& t)->decltype(auto) return t.field2;  ;
constexpr poly_method func  [](auto&& t, auto&&...args)->decltype(auto) return t.func(decltype(args)(args)...);  ;

您的代码如下所示：

for (auto& c : vec) 
    c->*func(10);

现在，如果您不喜欢编写那些 constexpr lambda，您可以让它们由宏编写。

这些 poly 方法和成员适用于支持存储在其中的 lambda 的任何类的任何实例。成员和方法的区别在于方法需要一个尾随 () 并传入这些参数，而成员则不需要。

例如：

A a;
a->*func(3);

作用于a，就像作用于variant<A, other stuff>。

Live example.

如果你真的非常依赖你的语法，我建议你看看 google mock 是如何做到的。

我有时会扩展它并写

template<auto*...methods>
struct poly_any:private std::any 
  // code that makes the above alphabet soup look cute
;

并为我存储的std::any 动态构建vtables 以访问每个method，给你：

using C = poly_any< &field, &field2, &func >;
C c = A;
std::cout << c->*field;
std::cout << c->*func(2,3);

在我们输入的地方删除任何支持这些方法的内容。

但那是我个人的精神错乱。 （此扩展要求您使用部分签名信息标记 poly 成员/方法）。