C++ 如何在不指定模板的情况下使用声明函数模板指针typedef？

这是不好的，因为我有许多类型的数据

dtype

，我不想为每种类型再次指定模板

那么我如何声明

算法函数函子而不是
算法函数函子

多谢各位

编辑：目标是有一个
向量函子
，而不是
向量
。由于在示例中，
res
和
resf
都可以在不指定第三个参数的模板的情况下进行计算，因此我想知道
vector
是否可行。
您不能。我怀疑这种混淆源于缺少“函数”和“函数模板”之间的区别

为了解释第一个示例的工作原理，首先让我们检查一下运行
run（a，ADD，linearlgo）时实际发生了什么。作为提醒，我们有：

模板
使用AlgoFunction=double（*）（常量std:：vector&，Op）；
样板
标准：：向量运行（常数标准：：向量和，Op，
双（*）（常数std:：vector&，Op））；

同样地，我们可以得到以下结果：

//AlgoFunction<float> functor = reverseLinearAlgo; // works, but I don't want it
AlgoFunction functor = reverseLinearAlgo;   // I want to do this. compile error

我们知道
run
，
std:：vector
的第一个参数是
std:：vector
，因此
dtype
是
double
。我们无法从第三个参数中确定关于
dtype
的任何内容，因为
linearlgo
只是一个模板，一个“模式”

因为我们知道
dtype
必须是
double
，所以我们可以选择并实例化
linearlgo
——也就是说，
linearlgo
——作为我们的函数，因为它符合我们的签名，一切正常


现在，这跟这个有什么关系

std::vector<double> a;
run(a, ADD, linearAlgo);

在本例中，我们尝试创建一个变量
reverseLinearAlgo
只是一个函数模板，而不是实际的函数，我们没有任何其他上下文来确定什么类型的
functor
。因此出现了编译器错误

此外，这究竟意味着什么？根据您使用的位置，
functor
会有不同的类型吗？如果我做了
autox=函子，请问
x
的类型是什么？如果我做了类似的事情

AlgoFunction functor=reverseLinearAlgo；
如果（测试）{
std：：向量x；
函子（x，加法）；
}否则{
std：：向量x；
函子（x，加法）；
}

这是否意味着
functor
具有动态类型？这不是适用于C++的（静态）类型系统的东西，如果这是合法的，它很快就会失控。这就是你想要的
std:：vector
：你必须存储一个具体的类型。否则，程序将需要基于运行时信息动态实例化函数：模板参数必须在编译时已知


如果您提前知道这些类型，一种可能的替代方法是使用您可以实例化的可能类型的
std:：variant
。就是说,

std:：vector；

如果向量的每个元素都应该提供一个或另一个，或者使用

std:：vector；

如果向量的每个元素都可以用于任何一种类型

这是否有用，是否值得增加复杂性，取决于您。
您不能。我怀疑这种混淆源于缺少“函数”和“函数模板”之间的区别

为了解释第一个示例的工作原理，首先让我们检查一下运行
run（a，ADD，linearlgo）时实际发生了什么。作为提醒，我们有：

模板
使用AlgoFunction=double（*）（常量std:：vector&，Op）；
样板
标准：：向量运行（常数标准：：向量和，Op，
双（*）（常数std:：vector&，Op））；

同样地，我们可以得到以下结果：

//AlgoFunction<float> functor = reverseLinearAlgo; // works, but I don't want it
AlgoFunction functor = reverseLinearAlgo;   // I want to do this. compile error

我们知道
run
，
std:：vector
的第一个参数是
std:：vector
，因此
dtype
是
double
。我们无法从第三个参数中确定关于
dtype
的任何内容，因为
linearlgo
只是一个模板，一个“模式”

因为我们知道
dtype
必须是
double
，所以我们可以选择并实例化
linearlgo
——也就是说，
linearlgo
——作为我们的函数，因为它符合我们的签名，一切正常


现在，这跟这个有什么关系

std::vector<double> a;
run(a, ADD, linearAlgo);

在本例中，我们尝试创建一个变量
reverseLinearAlgo
只是一个函数模板，而不是实际的函数，我们没有任何其他上下文来确定什么类型的
functor
。因此出现了编译器错误

此外，这究竟意味着什么？根据您使用的位置，
functor
会有不同的类型吗？如果我做了
autox=函子，请问
x
的类型是什么？如果我做了类似的事情

AlgoFunction functor=reverseLinearAlgo；
如果（测试）{
std：：向量x；
函子（x，加法）；
}否则{
std：：向量x；
函子（x，加法）；
}

这是否意味着
functor
具有动态类型？这不是适用于C++的（静态）类型系统的东西，如果这是合法的，它很快就会失控。这就是你想要的
std:：vector
：你必须存储一个具体的类型。否则，程序将需要基于运行时信息动态实例化函数：模板参数必须在编译时已知


如果您提前知道这些类型，一种可能的替代方法是使用您可以实例化的可能类型的
std:：variant
。就是说,

std:：vector；

如果向量的每个元素都应该提供一个或另一个，或者使用

std:：vector；

如果向量的每个元素都可以用于任何一种类型

这是否有用，是否值得广告
//AlgoFunction<float> functor = reverseLinearAlgo; // works, but I don't want it
AlgoFunction functor = reverseLinearAlgo;   // I want to do this. compile error

std::vector<double> run(const std::vector<dtype>&, Op, AlgoFunction<dtype>);

std::vector<double> a;
run(a, ADD, linearAlgo);

AlgoFunction functor = reverseLinearAlgo;

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct AlgoFunction {
    virtual double operator()(void *) = 0;
};

template <class T>
struct AF_Sum : public AlgoFunction {
    virtual double operator()(void * inputVec) {
        T res = T();
        vector<T>* pInput = (vector<T>*)inputVec;
        for (int i = 0; i < pInput->size(); ++i) {
            res += (*pInput)[i];
        }

        return (double) res;
    }
};

template <class T>
struct AF_Mean : public AlgoFunction {
    virtual double operator()(void * inputVec) {
        T res = T();
        vector<T>* pInput = (vector<T>*)inputVec;
        for (int i = 0; i < pInput->size(); ++i) {
            res += (*pInput)[i];
        }

        return (double) res / (double)pInput->size();
    }
};

int main()
{
    std::vector<float> vF{0.2, 0.3, 0.8};
    std::vector<int> vI{2, 5, 7};

    std::vector<AlgoFunction*> algoFunctions;

    algoFunctions.push_back(new AF_Sum<float>);
    algoFunctions.push_back(new AF_Mean<int>);

    cout << (*algoFunctions[0])(&vF) << endl;
    cout << (*algoFunctions[1])(&vI) << endl;

    return 0;
}