Custom std::function-like implementation for both free and member functions - c++

Question

I needed something like std::function but then I found this which is faster (as the author claims) and can even be compared by the == operator. I adapted it to allow a dynamic return type and arguments, like this:
template<typename TReturn, typename... TArgs>
class Delegate {};
template<typename TReturn, typename... TArgs>
class Delegate<TReturn(TArgs...)> final
{
private:
typedef void* InstancePointer;
typedef TReturn (*InternalFunction)(InstancePointer, TArgs...);
private:
// Turns a free function into our internal function stub
template <TReturn (*FreeFunction)(TArgs...)>
static TReturn FreeFunctionStub(InstancePointer instance, TArgs... args) {
// We don't need the instance pointer because we're dealing with free functions
return (FreeFunction)(std::forward<TArgs>(args)...);
}
// Turns a member function into our internal function stub
template <class TClass, TReturn (TClass::*MemberFunction)(TArgs...)>
static TReturn MemberFunctionStub(InstancePointer instance, TArgs... args) {
// Cast the instance pointer back into the original class instance
return (static_cast<TClass*>(instance)->*MemberFunction)(std::forward<TArgs>(args)...);
}
public:
Delegate() = default;
// Resets this delegate to a new free function
template <TReturn(*FreeFunction)(TArgs...)>
void reset() {
m_instance = nullptr;
m_function = &FreeFunctionStub<FreeFunction>;
}
// Resets this delegate to a new member function
template <class TClass, TReturn(TClass::*MemberFunction)(TArgs...)>
void reset(TClass* instance) {
m_instance = instance;
m_function = &MemberFunctionStub<TClass, MemberFunction>;
}
// Resets this delegate to a new free function
void specialReset(TReturn(*FreeFunction)(TArgs...)) {
m_instance = nullptr;
m_function = ???
}
// Resets this delegate to a new member function
template<class TClass>
void specialReset(TClass *instance, TReturn(TClass::*MemberFunction)(TArgs...)) {
m_instance = instance;
m_function = ???
}
// Invokes this delegate
TReturn invoke(TArgs... args) const {
if (m_function == nullptr)
throw new std::runtime_error(""Unbound delegate! Call reset() first."");
return m_function(m_instance, std::forward<TArgs>(args)...);
}
private:
InstancePointer m_instance;
InternalFunction m_function;
};
The usage goes like that:
Delegate<void()> del1;
Delegate<int(double)> del2;
del1.reset<&someParameterlessVoidFreeFunction>();
del1.invoke();
del2.reset<SomeClass, &SomeClass::someIntMemberFunction>(&someClassInstance);
del2.invoke(24.2);
What I am trying to do is to achieve something like this (IMO, much cleaner and intuitive):
Delegate<void()> del1;
Delegate<int(double)> del2;
del1.reset(&someParameterlessVoidFreeFunction);
del1.invoke();
del2.reset(&SomeClass::someIntMemberFunction, &someClassInstance);
del2.invoke(24.2);
However, I dont quite understand the m_function concept. What I am trying to achive is even possible? How could I do that?
Also, what exactly is the <TReturn(TArgs...)> part of class Delegate and why do we need to define a class Delegate {}; first?

Answer 1

Right, so after days of researchs, developing and testing, I made up something that does accomplish a faster std::function/std::bind with a much better syntax.
For those wondering, take a look at Delegator. I can't paste the whole code here because it got too big to be posted here. Also, at this link you'll always have the lastest version.
With Delegator, you can do the following:
Delegate<void(void)> d1; // Blank delegate
Delegate<void(void)> d2(&freeFunction); // Delegate to a free function
Delegate<void(void)> d3(&SomeClass::someClassStaticFunction); // Delegate to a static function
Delegate<void(void)> d4(&SomeClass::someClassFunction, &someClassInstance); // Delegate to a member function
Delegate<void(void)> d5(&SomeClass::someClassConstFunction, &someClassInstance); // Delegate to a member const function
d1.reset(); // Resets the delegate
d1.reset(&freeFunction); // Resets the delegate to a free function
d1.reset(&SomeClass::someClassStaticFunction); // Resets the delegate to a static function
d1.reset(&SomeClass::someClassFunction, &someClassInstance); // Resets the delegate to a member function
d1.reset(&SomeClass::someClassConstFunction, &someClassInstance); // Resets the delegate to a member const function
d1.reset(&d2); // Resets the delegate to d2's state

Answer 2

Basically the solution for your syntax is to get closer to what we'd do to implement std::function and sacrifice speed for flexibility (due to use of run-time polymorphism instead of pure templating)
The first call can be solved by adding another member variable to your Delegate class to hold free functions:
template<typename TReturn, typename... TArgs>
class Delegate<TReturn(TArgs...)> final
{
// ...
typedef TReturn(*FreeFunctionType)(TArgs...);
FreeFunctionType m_free_function = nullptr;
};
Now you can set m_free_function within specialReset, while resetting the other members:
void specialReset(TReturn(*FreeFunction)(TArgs...)) {
m_instance = nullptr;
m_function = nullptr;
m_free_function = FreeFunction;
}
And calling it performs an additional null check:
TReturn invoke(TArgs... args) const {
if (m_function == nullptr && m_free_function == nullptr)
throw new std::runtime_error("Unbound delegate! Call reset() first.");
else if (m_function)
return m_function(m_instance, std::forward<TArgs>(args)...);
else return m_free_function(std::forward<TArgs>(args)...);
}
and a test:
void foo()
{
std::cout << "Called foo()\n";
}
int main()
{
Delegate<void()> del1;
del1.specialReset(&::foo);
del1.invoke();
}
The second one is a little trickier.
The idea for solving this is to declare an abstract base class pointer that we can derive from later for making our call:
template<typename TReturn, typename... TArgs>
class Delegate<TReturn(TArgs...)> final
{
private:
//...
struct ICall
{
virtual TReturn doCall(TArgs... args) = 0;
};
std::unique_ptr<ICall> caller;
};
Usually this pointer will be nullptr, which we can check for, but otherwise we can call the function in invoke:
// Invokes this delegate
TReturn invoke(TArgs... args) const {
if (m_function == nullptr && m_free_function == nullptr && caller == nullptr)
throw new std::runtime_error("Unbound delegate! Call reset() first.");
else if (m_function)
return m_function(m_instance, std::forward<TArgs>(args)...);
else if (caller)
return caller->doCall(std::forward<TArgs>(args)...);
else
return m_free_function(std::forward<TArgs>(args)...);
}
And finally the implementation of our second specialReset where we create a derived class and set our pointer:
template<class TClass>
void specialReset(TClass *instance, TReturn(TClass::*MemberFunc)(TArgs...)) {
m_instance = nullptr;
m_function = nullptr;
m_free_function = nullptr;
struct DerivedCall : public ICall
{
DerivedCall(TClass* _instance, TReturn(TClass::*_func)(TArgs...)) : m_instance(_instance), m_func(_func){}
TReturn doCall(TArgs... args) override
{
return (m_instance->*m_func)(std::forward<TArgs>(args)...);
}
TClass* m_instance;
TReturn(TClass::*m_func)(TArgs...);
};
caller = std::make_unique<DerivedCall>(instance, MemberFunc);
}
And a test:
struct A{
int foo(double){std::cout << "Called A::foo\n"; return 42;}
};
int main()
{
Delegate<int(double)> del2;
A a;
del2.specialReset(&a, &A::foo);
del2.invoke(24.2);
}
Demo
I'm sure someone more clever than I can come up with something better. As I said. We're probably already losing the precious speed that you advocated for over std::function because of the runtimeyness of this all, and I'm not sure what it does for the operator== (It probably became infeasible the second I created m_free_function). We cannot use specialReset with lambdas here (...yet).