你可以创建自己的特征，比如：

template <typename F> struct my_result_of;

template <typename F> struct my_result_of<F*> : my_result_of<F> {};

template <typename Ret, typename ... Ts>
struct my_result_of<Ret(Ts...)>
{
    using type = Ret;
};

template <typename F> using my_result_of_t = typename my_result_of<F>::type;

字符串
并像这样使用它（假设x没有过载）：

std::vector<my_result_of_t<decltype(x)>::type> results;

型

假设T是调用函数的模板参数：

std::vector<decltype(x(std::declval<T>()))> results;

字符串

您可以滥用std::function::result_type：

int x(int y);
static_assert(std::is_same_v<int,std::function<decltype(x)>::result_type>);

字符串
当然，这只适用于x是一个函数的情况。如果x是一个任意的函数对象，那么它的结果类型可能取决于它的参数类型，在这种情况下，如果不指定参数，你就无法知道它的结果类型。

我假设你可以使用最新的标准修订版，因为你没有指定它。
下面是一个最小的工作示例：

#include<vector>
#include<functional>
#include<utility>

template<std::size_t... I, typename F, typename... A>
auto gen(std::index_sequence<I...>, F &&f, A... args) {
    return std::vector<decltype(std::forward<F>(f)(args...))>{
        (I, std::forward<F>(f)(args...))...
    };
}

template<std::size_t N, typename F, typename... A>
auto gen(F &&f, A... args) {
    return gen(std::make_index_sequence<N>{}, std::forward<F>(f), args...);
}

int f(int, char) { return 0; }

int main() {
    auto vec = gen<10>(&f, 0, 'c');
}

字符串
函数的返回类型很容易推断为：

decltype(std::forward<F>(f)(args...))

型
我想创建一个容器来包含这个函数的n次调用。然后我想执行它那么多次。
为此，我使用std::index_sequence创建了一个大小合适的参数包。
然后向量本身被初始化如下：

(I, std::forward<F>(f)(args...))...

型
其基本思想是利用逗号运算符来解包上面提到的参数包，并执行N次函数。f调用返回的值用于填充向量。
请注意，args并没有完全转发到f。
如果在第一次执行期间消耗了可移动对象，则可能会导致问题。