Генерация уникальных ключей, которые будут использоваться, например. unordered_map для функций-членов

Просто ради развлечения я пытаюсь создать класс, который обеспечивает «базовую функциональность насмешек». Более конкретно, вы можете установить возвращаемые значения для вызовов функций. Вот и все ;D

У меня есть решение для этой проблемы, но оно мне не очень нравится. Я покажу код, дам пояснения и расскажу, что мне в нем не нравится. Я использую С++20.

#include <any>
#include <iostream>
#include <string_view>
#include <typeindex>
#include <unordered_map>

using namespace std;

class MockHelper {
public:
    virtual ~MockHelper() = default;

    template<typename Class, typename Ret, typename ...Args>
    void
    setFunctionReturnValue(const string_view &functionName, Ret(Class::*functionPtr)(Args...), const Ret &returnValue) {
        functionsReturnValues[functionName][type_index(typeid(functionPtr))] = make_any<Ret>(returnValue);
    }

protected:
    template<typename Class, typename Ret, typename ...Args>
    Ret handleCall(const string_view &functionName, Ret(Class::*functionPtr)(Args...)) {
        const auto &returnValues = functionsReturnValues[functionName];
        const auto typeIndex = type_index(typeid(functionPtr));
        if (!returnValues.contains(typeIndex))
            return {};
        return any_cast<Ret>(returnValues.at(typeIndex));
    }

private:
    unordered_map<string_view, unordered_map<type_index, any>> functionsReturnValues;
};

class SomethingToMock : public MockHelper {
public:
    virtual int f() {
        return handleCall("f", &SomethingToMock::f);
    }

    virtual int g() {
        // g is overloaded, thus we need to provide the template arguments explicitly
        return handleCall<SomethingToMock, int>("g", &SomethingToMock::g);
    }

    int g(bool) {
        return handleCall<SomethingToMock, int, bool>("g", &SomethingToMock::g);
    }
};

int main() {
    SomethingToMock beingMocked;

    // Setup expected return values
    beingMocked.setFunctionReturnValue("f", &SomethingToMock::f, 0);
    // again, g is overloaded, thus we need to provide the template arguments explicitly
    beingMocked.setFunctionReturnValue<SomethingToMock, int>("g", &SomethingToMock::g, 1);
    beingMocked.setFunctionReturnValue<SomethingToMock, int, bool>("g", &SomethingToMock::g, 2);

    // Show that this is actually working
    std::cout << "Should be 0 and is actually " << beingMocked.f() << std::endl;
    std::cout << "Should be 1 and is actually " << beingMocked.g() << std::endl;
    std::cout << "Should be 2 and is actually " << beingMocked.g(true) << std::endl;

    return 0;
}

class MockHelper позволяет устанавливать возвращаемые значения для вызовов функций (с помощью setFunctionReturnValue) и позволяет выполнять эти вызовы функций из производных классов (с помощью handleCall).

class SomethingToMock происходит от class MockHelper и содержит 3 функции-члена, которые я использую для отображения.

В функции main мы устанавливаем возвращаемые значения и показываем, что это действительно работает.

ЖИВАЯ ДЕМО .

Мне не нравится, что мне приходится давать имена функций в виде строк всем соответствующим функциям. Это потому, что если бы я этого не сделал, я бы не смог различить функции. Например.

type_index(typeid(&SomethingToMock::f)) == type_index(typeid(static_cast<int (SomethingToMock::*)()>(&SomethingToMock::g)))

оценивается как true, что означает, что f() и g() нельзя отличить только по сигнатурам, мы также должны включить имена.

Итак, мой вопрос: можем ли мы каким-то образом сгенерировать уникальные ключи для всех функций, чтобы их можно было использовать, например. unordered_map без необходимости явно указывать имена функций? Итак, в качестве примера функция main должна выглядеть примерно так:

int main() {
    SomethingToMock beingMocked;

    // Setup expected return values
    beingMocked.setFunctionReturnValue(&SomethingToMock::f, 0);
    // again, g is overloaded, thus we need to provide the template arguments explicitly
    beingMocked.setFunctionReturnValue<SomethingToMock, int>(&SomethingToMock::g, 1);
    beingMocked.setFunctionReturnValue<SomethingToMock, int, bool>(&SomethingToMock::g, 2);

    // Show that this is actually working
    std::cout << "Should be 0 and is actually " << beingMocked.f() << std::endl;
    std::cout << "Should be 1 and is actually " << beingMocked.g() << std::endl;
    std::cout << "Should be 2 and is actually " << beingMocked.g(true) << std::endl;

    return 0;
}