C ++ 17 invoke_result и static_assert для функции func param

Question

Это просто для получения дополнительных знаний при выполнении общего программирования. Как я могу обеспечить возвращаемый тип функции, передаваемой в качестве аргумента шаблона другой функции, которая может принимать различное количество параметров (от 0 до N).

EDIT: Я пытаюсь использовать std::invoke_result и static_assert(), чтобы обеспечить правильный тип возвращаемого значения для зарегистрированных заводских методов. Я использовал лучший пример, чем первый опубликованный, для большей ясности.

#include <string>
#include <memory>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>

using namespace std;

class Factory final
{
public:
    template<typename My_Type, typename Func>
    static bool Register(Func func)
    {
        // issue is these two lines of code, when trying to register Derived1 and Derived2 create functions
        typename invoke_result<Func>::type result;
        static_assert(is_same<decltype(result), unique_ptr<My_Type>>::value, "Not a unique pointer to type 'My_Type'");

        bool isRegistered = false;

        if (GetCreateFunctions().end() == GetCreateFunctions().find(typeid(My_Type)))
        {
            GetCreateFunctions()[typeid(My_Type)] = reinterpret_cast<void*>(func);
            isRegistered = true;
        }

        return isRegistered;
    }

    template<typename My_Type, typename... Args>
    static unique_ptr<My_Type> Create(Args&&... args)
    {
        unique_ptr<My_Type> type = nullptr;
        auto iter = GetCreateFunctions().find(typeid(My_Type));

        if (GetCreateFunctions().end() != iter)
        {
            typedef unique_ptr<My_Type>(*create_func)(Args&&...);
            auto create = reinterpret_cast<create_func>(iter->second);
            type = create(forward<Args>(args)...);
        }

        return type;
    }

private:
    static unordered_map<type_index, void*>& GetCreateFunctions()
    {
        static unordered_map<type_index, void*> map;
        return map;
    }
};

class Base
{
public:
    Base(unique_ptr<string>&& moveString)
        :
        _moveString(move(moveString))
    {
    }

    virtual ~Base() = default;
    virtual void DoSomething() const = 0;

protected:
    unique_ptr<string> _moveString;
};

class Derived1 final : public Base
{
public:
    Derived1(unique_ptr<string>&& moveString)
        :
        Base(move(moveString))
    {
    }

    ~Derived1() = default;

    void DoSomething() const override
    {
        if (_moveString)
        {
            // do something...
        }
    }

private:
    static const bool _isRegistered;

    static unique_ptr<Derived1> Create(unique_ptr<string>&& moveString)
    {
        return make_unique<Derived1>(move(moveString));
    }
};

const bool Derived1::_isRegistered = Factory::template Register<Derived1>(&Derived1::Create);

class Derived2 final : public Base
{
public:
    Derived2()
        :
        Base(make_unique<string>("Default"))
    {
    }

    ~Derived2() = default;

    void DoSomething() const override
    {
        if (_moveString)
        {
            // do something...
        }
    }

private:
    static const bool _isRegistered;

    static unique_ptr<Derived2> Create()
    {
        return make_unique<Derived2>();
    }
};

const bool Derived2::_isRegistered = Factory::template Register<Derived2>(&Derived2::Create);


int main(int argc, char** argv)
{
    string moveString = "moveString";
    unique_ptr<Base> myBase_Derived1 = Factory::template Create<Derived1>(make_unique<string>(move(moveString)));
    unique_ptr<Base> myBase_Derived2 = Factory::template Create<Derived2>();

    if (myBase_Derived1)
        printf("Success\n");

    if (myBase_Derived2)
        printf("Success\n");

    return 0;
}

Answer 1

Это работает не во всех функциональных случаях, но с указателями функций должно работать.

Если вы определяете пользовательский шаблон следующим образом

template <typename>
struct baz;

template <typename R, typename ... Args>
struct baz<R(*)(Args...)>
 { using retType = R; };

ваш пример станет

template <typename T, typename Func>
void Example(Func func)
 {
   static_assert(std::is_same<typename baz<Func>::retType,
                              std::unique_ptr<T>>::value,  "!");
 }

Ниже приводится полный пример компиляции

#include <type_traits>
#include <memory>

template <typename>
struct baz;

template <typename R, typename ... Args>
struct baz<R(*)(Args...)>
 { using retType = R; };

template <typename T, typename Func>
void Example(Func func)
 {
   static_assert(std::is_same<typename baz<Func>::retType,
                              std::unique_ptr<T>>::value,  "!");
 }

struct Foo
 {
   Foo (int i) : My_I{i}
    { }

   Foo () : My_I{99}
    { }

   ~Foo() = default;

   int My_I;
 };

std::unique_ptr<Foo> bar0 ()
{ return std::make_unique<Foo>(11); }

std::unique_ptr<Foo> bar1 (int)
{ return std::make_unique<Foo>(11); }

std::unique_ptr<Foo> bar2 (int, long)
{ return std::make_unique<Foo>(11); }

int main ()
 {
   Example<Foo>(&bar0);
   Example<Foo>(&bar1);
   Example<Foo>(&bar2);
 }

К сожалению, это решение работает только с указателями на функции, а не с (например) лямбда-функцией (если она не конвертируется в указатели на функции) или с классами с operator().

Если вы можете использовать C ++ 17 - и я полагаю, что это ваш случай, если вы используете std::invoke_result - вы также можете использовать автоматические направляющие вычеты для std::function.

Итак, в C ++ 17 вы можете забыть структуру baz и просто написать

template <typename T, typename Func>
void Example(Func func)
 {        
   static_assert(std::is_same<
       typename decltype(std::function{func})::result_type,
       std::unique_ptr<T>>::value,  "!");
 }

или, по вашему Register() методу

template<typename My_Type, typename Func>
static bool Register(Func func)
{
    static_assert(std::is_same<
       typename decltype(std::function{func})::result_type,
       std::unique_ptr<My_Type>>::value,  "!");

    bool isRegistered = false;

    if (GetCreateFunctions().end() == GetCreateFunctions().find(typeid(My_Type)))
    {
        GetCreateFunctions()[typeid(My_Type)] = reinterpret_cast<void*>(func);
        isRegistered = true;
    }

    return isRegistered;
}

Answer 2

у вас было дополнительно () на

static_assert(std::is_same<decltype(result), std::unique_ptr<T>/* here */ >::value, "Not a unique pointer to type 'T'");

и

typename std::invoke_result<Func/* here */>::type result;

A и A() - это два разных типа. A() - это функция, возвращающая A и не имеющая аргументов.

окончательный код должен быть

#include <type_traits>
#include <memory>

using namespace std;

template<typename T, typename Func>
void Example(Func)
{
    // func can have params, or have no params
    typename std::invoke_result<Func>::type result;
    static_assert(std::is_same<decltype(result), std::unique_ptr<T> >::value, "Not a unique pointer to type 'T'"); // can't get this correct (tried different variations, looked over stackoverflow, etc.)
}

class Foo
{
public:
    Foo(int i)
        : My_I(i)
    {
    }

    Foo()
        : My_I(99)
    {
    }

    ~Foo() = default;

    int My_I;
};

unique_ptr<Foo> CreateWithInt()
{
    return make_unique<Foo>(11);
}

int main()
{
    Example<Foo>(&CreateWithInt);
    return 0;
}