模拟std::函数功能

Question

我正在尝试模拟下面的std::function功能，但遇到了以下错误

class Player
{
public:
void move_to(Point location);
};
std::function<void(Player&, Point)> fun = &Player::move_to;
Player hero;
fun(hero, point{ 2, 4 });

fp.cc:32:33: error: variable ‘fun<void(Player&, Point)> f’ has initializer but incomplete type
32 |    fun<void(Player &, Point p)> f = &Player::move_to;

#include <iostream>
using namespace std;
template <typename T>
struct fun;
template <typename Ret, typename T, typename ...Args>
struct fun <Ret(*)(T&, Args...)>{
char *data;
using fptr = Ret(T::*)(Args...);
fun(fptr p) : data(p) {}
Ret operator()(T &t, Args... args) {
if (std::is_same_v<Ret, void>) {
(t.*((fptr)data))(args...);
}
return (t.*((fptr)data))(args...); 
}
};
struct Point {
int x;
int y;
};
struct Player {
void move_to(Point p) {
cout << __PRETTY_FUNCTION__ << endl;
}
};
int main() {
fun<void(Player &, Point p)> f = &Player::move_to;
Point p{1,2};
Player pl;
//   f(pl, p);
}

Answer 1

struct unused_t {};
// can store any of a function pointer, member function pointer, or other
// pointer.  It is a bit annoying, and not complete even.
union state_t {
void(unused_t::*pm)();
void(*pf)();
void*pv;
state_t():pv(nullptr){}
template<class R0, class...A0s>
state_t(R0(*f)(A0s...)):pf(reinterpret_cast<void(*)()>(f)) {}
template<class X, class R0, class...A0s>
state_t(R0(X::*f)(A0s...)):pm(reinterpret_cast<void(unused_t::*)()>(f)) {}
template<class X, class R0, class...A0s>
state_t(R0(X::*f)(A0s...) const):pm(reinterpret_cast<void(unused_t::*)()>(f)) {}
// add in & and && overloads of member function pointers here
template<class T>
state_t(T* p):pv((void*)p) {}
};
template<class Sig>
struct fun;
template <class R, class...As>
struct fun <R(As...)>{
using pf_t = R(*)(state_t, As&&...);
state_t state;
pf_t pf = nullptr;
fun() = default;
explicit operator bool() const { return pf; }
template<class R0, class...A0s>
fun( R0(*f)(A0s...) ):
state(f),
pf([](state_t state, As&&...as)->R{
auto f = (R0(*)(A0s...))(state.pf);
return std::invoke( f, std::forward<As>(as)... );
})
{}
template<class T, class R0, class...A0s>
fun( R0(T::*f)(A0s...) ):
state(f),
pf([](state_t state, As&&...as)->R{
auto f = (R0(T::*)(A0s...))(state.pm);
return std::invoke( f, std::forward<As>(as)... );
})
{}
template<class T, class R0, class...A0s>
fun( R0(T::*f)(A0s...) const ):
state(f),
pf([](state_t state, As&&...as)->R{
auto f = (R0(T::*)(A0s...) const)(state.pm);
return std::invoke( f, std::forward<As>(as)... );
})
{}
R operator()(As... args) const {
return pf( state, std::forward<As>(args)... );
}
};

这确实使用了CCD_ 2。

测试代码：

struct bob {
int foo() const { return 3; };
};
int main() {
fun<int(bob&)> f = &bob::foo;
bob b;
std::cout << f(b);
}

活生生的例子。

这是一个c++20版本：

struct unused_t {};
// can store any of a function pointer, member function pointer, or other
// pointer.  It is a bit annoying, and not complete even.
union state_t {
void(unused_t::*pm)();
void(*pf)();
void*pv;
state_t():pv(nullptr){}
template<class R0, class...A0s>
state_t(R0(*f)(A0s...)):pf(reinterpret_cast<void(*)()>(f)) {}
template<class X, class R0, class...A0s>
state_t(R0(X::*f)(A0s...)):pm(reinterpret_cast<void(unused_t::*)()>(f)) {}
template<class X, class R0, class...A0s>
state_t(R0(X::*f)(A0s...) const):pm(reinterpret_cast<void(unused_t::*)()>(f)) {}
// add in & and && overloads of member function pointers here
template<class T>struct tag_t {};
template<class T>using type_t = T;
template<class R, class...As>
type_t<R(*)(As...)> extract( tag_t<R(*)(As...)>) const {
return (R(*)(As...))pf;
}
template<class T, class R, class...As>
type_t<R(T::*)(As...)> extract( tag_t<R(T::*)(As...)>) const {
return (R(T::*)(As...))pm;
}
template<class T, class R, class...As>
type_t<R(T::*)(As...) const> extract( tag_t<R(T::*)(As...) const>) const {
return (R(T::*)(As...) const)pm;
}
template<class T>
type_t<T*> extract( tag_t<T*>) const {
return (T*)pv;
}
template<class T>
state_t(T* p):pv((void*)p) {}
};
template<class Sig>
struct fun;
template <class R, class...As>
struct fun <R(As...)>{
using pf_t = R(*)(state_t, As&&...);
state_t state;
pf_t pf = nullptr;
fun() = default;
explicit operator bool() const { return pf; }
template<std::invocable<As...> F>
requires std::is_convertible_v< std::invoke_result_t<F, As...>, R >
fun( F f ):
state(std::forward<F>(f)),
pf([](state_t state, As&&...as)->R{
auto f = state.extract(state_t::tag_t<F>{});
return std::invoke( f, std::forward<As>(as)... );
})
{}
R operator()(As... args) const {
return pf( state, std::forward<As>(args)... );
}
};

令人讨厌的部分是以统一的方式存储指向成员函数、指针或函数指针的指针。C++标准规定，这三种类型的指针不能保证兼容。

因此，state_t类型可以将3中的任何一个存储在并集中，但需要一堆样板来统一处理它们。

Answer 2

您的代码很接近，但有几个小错误：

• 您只为Ret(*)(T&, Args...)提供了fun的定义，但fun<void(Player &, Point p)>与此模板不匹配。所以我删除了(*)，这在你的专业中并不是真正需要的。

• 函数指针不能转换为char *，所以我将data的类型更改为fptr，使其与参数类型匹配。

导螺杆连杆

#include <iostream>
using namespace std;
template <typename T>
struct fun;
template <typename Ret, typename T, typename ...Args>
struct fun <Ret(T&, Args...)>{
using fptr = Ret(T::*)(Args...);
fptr data;
fun(fptr p) : data(p) {}
Ret operator()(T &t, Args... args) {
if (std::is_same_v<Ret, void>) {
(t.*((fptr)data))(args...);
}
return (t.*((fptr)data))(args...); 
}
};
struct Point {
int x;
int y;
};
struct Player {
void move_to(Point p) {
cout << __PRETTY_FUNCTION__ << endl;
}
};
int main() {
fun<void(Player &, Point p)> f = &Player::move_to;
Point p{1,2};
Player pl;
f(pl, p);
}