这是一个使用 C++14 和 的解决方案boost::any，因为我没有 C++17 编译器。
我们最终得到的语法是：
const auto print =
make_any_method<void(std::ostream&)>([](auto&& p, std::ostream& t){ t << p << "\n"; });
super_any<decltype(print)> a = 7;
(a->*print)(std::cout);
这几乎是最优的。通过我认为简单的 C++17 更改，它应该如下所示：
constexpr any_method<void(std::ostream&)> print =
[](auto&& p, std::ostream& t){ t << p << "\n"; };
super_any<&print> a = 7;
(a->*print)(std::cout);
在 C++17 中，我将通过使用 a auto*...of 指针any_method而不是decltype噪声来改进这一点。
公开继承any有点冒险，好像有人把any顶层去掉并修改它，the tupleofany_method_data就会过时了。也许我们应该只模仿整个any界面而不是公开继承。
@dyp 在对 OP 的评论中写了一个概念证明。这是基于他的工作，并添加了价值语义（从 偷来的）进行清理boost::any。@cpplearner 的基于指针的解决方案被用来缩短它（谢谢！），然后我在上面添加了 vtable 优化。
首先我们使用标签来传递类型：
template<class T>struct tag_t{constexpr tag_t(){};};
template<class T>constexpr tag_t<T> tag{};
这个 trait 类获取存储的签名any_method：
这将创建一个函数指针类型和一个用于所述函数指针的工厂，给定一个any_method：
template<class any_method, class Sig=any_sig_from_method<any_method>>
struct any_method_function;
template<class any_method, class R, class...Args>
struct any_method_function<any_method, R(Args...)>
{
using type = R(*)(boost::any&, any_method const*, Args...);
template<class T>
type operator()( tag_t<T> )const{
return [](boost::any& self, any_method const* method, Args...args) {
return (*method)( boost::any_cast<T&>(self), decltype(args)(args)... );
};
}
};
现在我们不想在我们的super_any. 所以我们将函数指针捆绑到一个 vtable 中：
template<class...any_methods>
using any_method_tuple = std::tuple< typename any_method_function<any_methods>::type... >;
template<class...any_methods, class T>
any_method_tuple<any_methods...> make_vtable( tag_t<T> ) {
return std::make_tuple(
any_method_function<any_methods>{}(tag<T>)...
);
}
template<class...methods>
struct any_methods {
private:
any_method_tuple<methods...> const* vtable = 0;
template<class T>
static any_method_tuple<methods...> const* get_vtable( tag_t<T> ) {
static const auto table = make_vtable<methods...>(tag<T>);
return &table;
}
public:
any_methods() = default;
template<class T>
any_methods( tag_t<T> ): vtable(get_vtable(tag<T>)) {}
any_methods& operator=(any_methods const&)=default;
template<class T>
void change_type( tag_t<T> ={} ) { vtable = get_vtable(tag<T>); }
template<class any_method>
auto get_invoker( tag_t<any_method> ={} ) const {
return std::get<typename any_method_function<any_method>::type>( *vtable );
}
};
我们可以将其专门用于 vtable 很小的情况（例如，1 个项目），并在这些情况下使用存储在类中的直接指针以提高效率。
现在我们开始super_any. 我super_any_t用来使声明super_any更容易一些。
template<class...methods>
struct super_any_t;
这会搜索 super any 支持的 SFINAE 方法：
template<class super_any, class method>
struct super_method_applies : std::false_type {};
template<class M0, class...Methods, class method>
struct super_method_applies<super_any_t<M0, Methods...>, method> :
std::integral_constant<bool, std::is_same<M0, method>{} || super_method_applies<super_any_t<Methods...>, method>{}>
{};
print这是我们全局创建的伪方法指针，如constly。
我们将构造 this 的对象存储在any_method. 请注意，如果您使用非 lambda 构造它，事情可能会变得很复杂，因为this的类型any_method被用作调度机制的一部分。
template<class Sig, class F>
struct any_method {
using signature=Sig;
private:
F f;
public:
template<class Any,
// SFINAE testing that one of the Anys's matches this type:
std::enable_if_t< super_method_applies< std::decay_t<Any>, any_method >{}, int>* =nullptr
>
friend auto operator->*( Any&& self, any_method const& m ) {
// we don't use the value of the any_method, because each any_method has
// a unique type (!) and we check that one of the auto*'s in the super_any
// already has a pointer to us. We then dispatch to the corresponding
// any_method_data...
return [&self, invoke = self.get_invoker(tag<any_method>), m](auto&&...args)->decltype(auto)
{
return invoke( decltype(self)(self), &m, decltype(args)(args)... );
};
}
any_method( F fin ):f(std::move(fin)) {}
template<class...Args>
decltype(auto) operator()(Args&&...args)const {
return f(std::forward<Args>(args)...);
}
};
我相信 C++17 中不需要的工厂方法：
template<class Sig, class F>
any_method<Sig, std::decay_t<F>>
make_any_method( F&& f ) {
return {std::forward<F>(f)};
}
这是增强版any。它既是any, 又携带一束类型擦除函数指针，只要包含的函数指针就会改变any：
template<class... methods>
struct super_any_t:boost::any, any_methods<methods...> {
private:
template<class T>
T* get() { return boost::any_cast<T*>(this); }
public:
template<class T,
std::enable_if_t< !std::is_same<std::decay_t<T>, super_any_t>{}, int>* =nullptr
>
super_any_t( T&& t ):
boost::any( std::forward<T>(t) )
{
using dT=std::decay_t<T>;
this->change_type( tag<dT> );
}
super_any_t()=default;
super_any_t(super_any_t&&)=default;
super_any_t(super_any_t const&)=default;
super_any_t& operator=(super_any_t&&)=default;
super_any_t& operator=(super_any_t const&)=default;
template<class T,
std::enable_if_t< !std::is_same<std::decay_t<T>, super_any_t>{}, int>* =nullptr
>
super_any_t& operator=( T&& t ) {
((boost::any&)*this) = std::forward<T>(t);
using dT=std::decay_t<T>;
this->change_type( tag<dT> );
return *this;
}
};
因为我们将any_methods 存储为const对象，这使得制作super_any更容易一些：
template<class...Ts>
using super_any = super_any_t< std::remove_const_t<std::remove_reference_t<Ts>>... >;
测试代码：
const auto print = make_any_method<void(std::ostream&)>([](auto&& p, std::ostream& t){ t << p << "\n"; });
const auto wprint = make_any_method<void(std::wostream&)>([](auto&& p, std::wostream& os ){ os << p << L"\n"; });
const auto wont_work = make_any_method<void(std::ostream&)>([](auto&& p, std::ostream& t){ t << p << "\n"; });
struct X {};
int main()
{
super_any<decltype(print), decltype(wprint)> a = 7;
super_any<decltype(print), decltype(wprint)> a2 = 7;
(a->*print)(std::cout);
(a->*wprint)(std::wcout);
// (a->*wont_work)(std::cout);
double d = 4.2;
a = d;
(a->*print)(std::cout);
(a->*wprint)(std::wcout);
(a2->*print)(std::cout);
(a2->*wprint)(std::wcout);
// a = X{}; // generates an error if you try to store a non-printable
}
活生生的例子。
当我尝试在其中存储不可打印的内容时出现的错误消息至少在 clangstruct X{};中似乎是合理的：super_any
main.cpp:150:87: error: invalid operands to binary expression ('std::ostream' (aka 'basic_ostream<char>') and 'X')
const auto x0 = make_any_method<void(std::ostream&)>([](auto&& p, std::ostream& t){ t << p << "\n"; });
这发生在您尝试将 分配X{}到super_any<decltype(x0)>.
的结构与对它们可能被合并的变体any_method的作用类似的充分兼容。pseudo_method
我在这里使用了一个手动 vtable 来将类型擦除开销保持在每个super_any. 这为每个 any_method 调用增加了重定向成本。super_any我们可以很容易地将指针直接存储在super_any. 无论如何，在 1 个擦除方法的情况下，我们应该直接存储它。
相同类型的两个不同any_method的 s（例如，都包含一个函数指针）产生相同类型的super_any. 这会导致查找时出现问题。
区分它们有点棘手。如果我们将其更改super_any为 take auto* any_method，我们可以将所有相同类型any_method的 s 捆绑在 vtable 元组中，然后如果匹配指针超过 1，则对匹配指针进行线性搜索。编译器应优化线性搜索，除非您正在做一些疯狂的事情，例如将引用或指针传递给any_method我们正在使用的特定对象。
然而，这似乎超出了这个答案的范围；现在，这种改进的存在就足够了。
此外，->*可以添加在左侧接受指针（甚至是引用！）的 a，让它检测到这一点并将其传递给 lambda。这可以使它成为真正的“任何方法”，因为它适用于具有该方法的变体、super_anys 和指针。
通过一些if constexpr工作，lambda 可以在每种情况下进行 ADL 或方法调用。
这应该给我们：
(7->*print)(std::cout);
((super_any<&print>)(7)->*print)(std::cout); // C++17 version of above syntax
((std::variant<int, double>{7})->*print)(std::cout);
int* ptr = new int(7);
(ptr->*print)(std::cout);
(std::make_unique<int>(7)->*print)(std::cout);
(std::make_shared<int>(7)->*print)(std::cout);
只是“做正确的any_method事”（将价值提供给std::cout <<）。