Custom callback function cannot take overloads

Question

I have the following class for building callback functions to any subset of function type, be it static function, lambda, lambda w/ capture list, static class functions or member class functions. Problem is that it doesn't take overloads because there's no parameter resolution when passing functions to the templated constructor(s):

template<typename... A>
class callback {
protected:
    /// Unique identifying hash code.
    size_t hash;
    /// The function bound to this callback.
    std::function<void(A...)> bound;

public:
    /// Binds a static or lambda function.
    template<class Fx>
    void bind_callback(Fx func) {
        bound = [func = std::move(func)](A... args) { std::invoke(func, args...); };
        hash = bound.target_type().hash_code();
    }

    /// Binds the a class function attached to an instance of that class.
    template<typename T, class Fx>
    void bind_callback(T* obj, Fx func) {
        bound = [obj, func = std::move(func)](A... args) { std::invoke(func, obj, args...); };
        hash = std::hash<T*>{}(obj) ^ bound.target_type().hash_code();
    }

    /// Create a callback to a static or lambda function.
    template<typename T, class Fx> callback(T* obj, Fx func) { bind_callback(obj, func); }

    /// Create a callback to a class function attached to an instance of that class.
    template<class Fx> callback(Fx func) { bind_callback(func); }

    /// Compares the underlying hash_code of the callback function(s).
    bool operator == (const callback<A...>& cb) { return hash == cb.hash; }

    /// Inequality Compares the underlying hash_code of the callback function(s).
    bool operator != (const callback<A...>& cb) { return hash != cb.hash; }

    /// Returns the unique hash code for this callback function.
    constexpr size_t hash_code() const throw() { return hash; }

    /// Invoke this callback with required arguments.
    callback<A...>& invoke(A... args) { bound(args...); return (*this); }
};

Usage: (fails on overloads, remove overloads and it compiles)

myclass {
public:
    void function(float x) {}
    void function(int x) {}
    static inline void static_function(float x) {}
    static inline void static_function(int x) {}
}

static inline void function(float x) {}
static inline void function(int x) {}

int main() {
    myclass inst;
    callback<int> mycallback(&inst, &myclass::function);
    callback<int> mycallback(&function);
    callback<int> mycallback(&myclass::static_function);
}

Answer 1

With the help of someone on the Together C & C++ discord, the recommendation of using std::type_identity_t in C++20 can't help solve the problem for static class members because it can't deduce the type between the function parameters and the class: template<typename T> callback(std::type_identity_t<void (T::*)(A...)> func).

In the end the only solution is to completely ignore handling these cases and just accept std::function forcing the end-user to resolve conflicts with the function definitions on their own, e.g. using a lambda:

/// Source: https://stackoverflow.com/questions/9568150/what-is-a-c-delegate/9568485#9568485
/// Source: https://en.cppreference.com/w/cpp/utility/functional/invoke
#pragma once
#ifndef INVOKABLE_CALLBACKS
#define INVOKABLE_CALLBACKS
    #include <functional>
    #include <vector>
    #include <mutex>
    #include <utility>
    #include <type_traits>

    template<typename... A>
    class callback {
    protected:
        /// Unique identifying hash code.
        size_t hash;
        /// The function bound to this callback.
        std::function<void(A...)> bound;

    public:
        callback(std::function<void(A...)> func) {
            bound = [func = std::move(func)](A... args) { std::invoke(func, args...); };
            hash = bound.target_type().hash_code();
        }

        /// Compares the underlying hash_code of the callback function(s).
        bool operator == (const callback<A...>& cb) { return hash == cb.hash; }
        
        /// Inequality Compares the underlying hash_code of the callback function(s).
        bool operator != (const callback<A...>& cb) { return hash != cb.hash; }
        
        /// Returns the unique hash code for this callback function.
        constexpr size_t hash_code() const throw() { return hash; }
        
        /// Invoke this callback with required arguments.
        callback<A...>& invoke(A... args) { bound(args...); return (*this); }

        /// Operator() invoke this callback with required arguments.
        void operator()(A... args) { bound(args...); }
    };

    template<typename... A>
    class invokable {
    protected:
        /// Resource lock for thread-safe accessibility.
        std::mutex safety_lock;
        /// Record of stored callbacks to invoke.
        std::vector<callback<A...>> callbacks;

    public:
        /// Adds a callback to this event, operator +=
        invokable<A...>& hook(const callback<A...> cb) {
            std::lock_guard<std::mutex> g(safety_lock);
            if (std::find(callbacks.begin(), callbacks.end(), cb) == callbacks.end())
                callbacks.push_back(cb);
            return (*this);
        }

        /// Removes a callback from this event, operator -=
        invokable<A...>& unhook(const callback<A...> cb) {
            std::lock_guard<std::mutex> g(safety_lock);
            std::erase_if(callbacks, [cb](callback<A...> c){ return cb.hash_code() == c.hash_code(); });
            return (*this);
        }

        /// Removes all registered callbacks and adds a new callback, operator =
        invokable<A...>& rehook(const callback<A...> cb) {
            std::lock_guard<std::mutex> g(safety_lock);
            callbacks.clear();
            callbacks.push_back(cb);
            return (*this);
        }

        /// Removes all registered callbacks.
        invokable<A...>& empty() {
            std::lock_guard<std::mutex> g(safety_lock);
            callbacks.clear();
            return (*this);
        }

        /// Execute all registered callbacks, operator ()
        invokable<A...>& invoke(A... args) {
            std::lock_guard<std::mutex> g(safety_lock);
            for(callback<A...> cb : callbacks) cb.invoke(args...);
            return (*this);
        }
    };

#endif

This removes the original bind_callback() and callback constructors in favor of just accepting std::function<void(A...)> or just accepting a basic function callback.

Which means that you'd need to use a lambda to resolve overloads, member functions, etc.

class myclass {
public:
    void function(float xx) { ... }
    void function(int xx) { ... }
}

myclass myinst;
callback<float> mycallback([&myinst](int xx){ myinst.function(xx); });