您可以递归地将函数参数添加到模板列表中：

template <typename Ret, std::size_t N, typename Type, typename... T>
struct RepeatFunctionArgType {
    static auto fnt() {
        if constexpr (sizeof...(T) >= N) {
            return std::function<Ret(T...)>{};
        } else {
            return RepeatFunctionArgType<Ret, N, Type, Type, T...>::fnt();
        }
    }
    using type = decltype(fnt());
};

字符串
这可以被访问为RepeatFunctionArgType<int,3,double>::type。

static int foo(double,double,double) {return 0;}
int main() {
    RepeatFunctionArgType<int,3,double>::type fn = foo;
}

型

你可以在未求值的上下文中使用lambda来获取其返回类型：

using function_type =
    decltype([]<std::size_t... I>(std::index_sequence<I...>) {
        // expand to as many `double`s as there are `I`s:
        return std::function<int(decltype((static_cast<void>(I)), double{})...)>{};
    }(std::make_index_sequence<N>{}));

字符串
交替地

using function_type =
    decltype([]<std::size_t... I>(std::index_sequence<I...>)
        // expand to as many `double`s as there are `I`s:
        -> std::function<int(decltype((static_cast<void>(I)), double{})...)> {
            // this space intentionally left blank
        }(std::make_index_sequence<N>{}));

型
A more generic solution adapted from 康桓瑋's code in the comments could look like this:

template <std::size_t, class T>
using identity = T;
template <class R, class Arg, std::size_t N>
struct repeated_arg_func {
    using type =
        typename decltype([]<std::size_t... Is>(std::index_sequence<Is...>)
                              -> std::type_identity<R(identity<Is, Arg>...)> {
        }(std::make_index_sequence<N>{}))::type;
};
template <class R, class Arg, std::size_t N>
using repeated_arg_func_t = typename repeated_arg_func<R, Arg, N>::type;
template <int N, class ArgType, class RetType>
class FunctionHolder {
public:
    using signature = repeated_arg_func_t<RetType, ArgType, N>;
    using function_type = std::function<signature>;
    FunctionHolder(const function_type& arg) : m_func(arg) {}
private:
    function_type m_func;
};

型
旁注：const function_type&成员不是一个好主意，除非您实际提供的std::function<...>比FunctionHolder寿命长。您的示例创建了一个临时std::function<...>，该临时std::function<...>将在FunctionHolder的构造完成后立即过期。
我建议将其设为常规非参考成员：

function_type m_func;

型

使用helper class template，它可能是

template <std::size_t, typename T>
using always_t = T;
template<typename Seq> class FunctionHolderImpl;
template<std::size_t... Is>
class FunctionHolderImpl<std::index_sequence<Is...>> {
public:
   using function_type = std::function<int(always_t<Is, double>... args)>;
   FunctionHolder(const function_type& arg): m_func(arg) {}
private:
   function_type m_func;
};
template <std::size_t N>
using FunctionHolder = FunctionHolderImpl<std::make_index_sequence<N>>;

字符串

下面是一个C++17的解决方案，你不需要在main（）中显式地专门化保持器，也不需要显式地声明参数的数量。

#include <type_traits>
#include <functional>
#include <iostream>
// Some helpers to check if all arguments of the function have the same argument type
template<typename arg_t, typename... args_t>
static constexpr bool all_same_as_first()
{
    return std::conjunction_v<std::is_same<arg_t, args_t>...>;
};
template<typename... args_t>
static constexpr bool all_same()
{
    // Specialized logic for 0 or 1 argument, consider them the same. 
    if constexpr (sizeof...(args_t) < 2ul)
    {
        return true;
    }
    else
    {
        return all_same_as_first<args_t...>();
    }
}
// The actual function holder
// it also needs specialization on the return value type
template<typename retval_t, typename... args_t>
class FunctionHolder
{
public:
    static_assert(all_same<args_t...>()); // check condition that all arguments are of same type
    // construct
    explicit FunctionHolder(std::function<retval_t(args_t...)> fn) :
        m_fn{ fn }
    {
    }
    // allow calls to be made through the holder directly
    retval_t operator()(args_t&&...args)
    {
        return m_fn(std::forward<args_t>(args)...);
    }
private:
    std::function<retval_t(args_t...)> m_fn;
};
// helper for type deduction of std::function type 
template<typename fn_t>
auto make_holder(fn_t fn)
{
    std::function std_fn{fn};
    return FunctionHolder{ std_fn };
}
// your function
int my_func(double arg1, double arg2)
{
    return static_cast<int>(arg1+arg2);
}
// And the usage
int main()
{
    auto holder = make_holder(my_func);
    auto retval = holder(1.0, 2.0);
    return 0;
}

字符串

像这样的东西怎么样：

#include <functional>
#include <type_traits>
template<int N, typename...Args>
struct FunctionHolder {
public:
    using function_type = std::function<int(Args...)>;
    static_assert(sizeof...(Args) == N);
    static_assert((std::is_same_v<Args, double> && ...), "");
    FunctionHolder(const function_type& arg): m_func(arg) {}
    const function_type m_func;
};
template<int N, typename...Args>
auto makeFunctionHolder(int(*f)(Args...))
{
    return FunctionHolder<N, Args...>(f);
}
int my_func(double arg1, double arg2)
{
    return arg1+arg2;
}
int my_func2(double arg1, char arg2)
{
    return arg1+arg2;
}
int my_func3(double arg1)
{
    return arg1;
}
int main() {
    auto h1 = makeFunctionHolder<2>(my_func);
    //auto h2 = makeFunctionHolder<2>(my_func2); //should fail due to types
    // auto h3 = makeFunctionHolder<2>(my_func3); //should fail to number
    auto h3 = makeFunctionHolder<1>(my_func3); //should pass
    return h1.m_func(4.0, 5.0);
}

字符串
https://godbolt.org/z/cjEq4s7Ef
当然，它使用工厂函数，但也可以使用演绎指南来实现。一切都是为了测试而公开的，根据你的喜好调整它。

可以使用std::array<double, N>作为函数的参数
（而不是单独的double参数）：

#include <array>
#include <functional>
template<int N>
class FunctionHolder {
public:
    //--------------------------------------vvvvvvvvvvvvvvvvvvvvv--------
    using function_type = std::function<int(std::array<double, N> args)>;
    FunctionHolder(const function_type& arg) : m_func(arg) {}
private:
    const function_type& m_func;
};
//----------vvvvvvvvvvvvvvvvvvvvv-------
int my_func(std::array<double, 2> arg2) {
    return 0;
}
int main() {
    FunctionHolder<2> my_holder(my_func);
}

字符串
Demo - Godbolt的