问题描述
我正在尝试使用 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,...) 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,(int a),const noexcept);
VARIANT_METHOD_CONST(int,(int a,int b),const noexcept);
解决方法
我所知道的最干净的方法是滥用 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,var );
}
template<class...Ts>
friend decltype(auto) operator->*( std::variant<Ts...> const& var,var );
}
template<class...Ts>
friend decltype(auto) operator->*( std::variant<Ts...> const&& var,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字母汤。对于 c++14 版本,将 auto
参数替换为 template<class T>
等。
你最终使 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 lambdas,你可以让它们用宏来写。
这些 poly 方法和成员适用于支持存储在其中的 lambda 的任何类的任何实例。成员和方法的区别在于,方法需要尾随 () 并传入这些参数,而成员则不需要。
例如:
A a;
a->*func(3);
作用于 a
就像作用于 variant<A,other stuff>
一样。
如果你真的非常依赖你的语法,我建议你看看 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 成员/方法)。