C++ C++；指向以模板类实例为参数的函数的指针

我在编译一个类时遇到了问题，这个类将函数指针作为成员变量。指针指向以类的实例作为参数的函数

像

这同样有效

double (*f)(Vector<double,2> v)

double（*f）（向量v）

---

但是我想要一个函数指针，用于一个以泛型向量为参数的函数。

好吧，编译器不知道在编译时，您将拥有多少个

f

（每个可能的

t

和

N

？）的函数。因此，编译器无法计算类的对象需要多少内存。这就是为什么这样的构造是被禁止的。

你不能有一个指向函数的模板指针，这是没有意义的。 但你能做的是

#include <vector>

template <typename T>
void foo(const std::vector<T>& v) {
   // do something
}

void (*ptr_foo)(const std::vector<int>&) = &foo<int>;

#包括
模板
void foo（const std:：vector&v）{
//做点什么
}
void（*ptr_foo）（const std:：vector&）=&foo；

---

（这里函数指针是模板函数，模板参数是显式设置为<代码> int >代码>）

，这不是非常有效的C++，基本上你所寻找的是模板模板参数。 解释他们的一切

---

通常，如果您陷入这种情况，您需要找到一种解决方法，因为您的代码很快就会变得难以辨认，因为您的代码与以下代码一样有意义：

struct X
{
  template < typename T >
  std::vector<T> vect;
};

结构X
{
模板
std:：vector-vect；
};

您正在尝试将成员变量设置为模板。这不是一个有效的C++构造，我非常怀疑它会是什么样子。

---

你怎么做你真正想要的？我不确定，因为我不知道您实际上想要完成什么以及为什么。

使用成员

typedef

：

template <typename T, int N>
class Vector
{
public:

    /// type of function pointer
    typedef double (*FuncPtr)( const Vector& );

};

// concrete type
typedef Vector<double,10> VecDouble10;

// actual function
double func( const VecDouble10>& );

// usage
VecDouble10::FuncPtr fp = func;

模板
类向量
{
公众：
///函数指针的类型
typedef double（*FuncPtr）（常量向量&）；
};
//混凝土类型
typedef向量向量向量机10；
//实际功能
双功能（const vectdouble10>&）；
//用法
VecDouble10:：FuncPtr fp=func；

如果你想要一个“模板指针”，你可以尝试一个函数对象。下面的示例将

1.0

添加到包装的函数模板中

struct AcceptsVector {
  template<typename T, int N>
  double operator()(Vector<T,N> v) const { return 1.0 + real_f(v); }
};

AcceptsVector f;

struct AcceptsVector{
模板
双运算符（）（向量v）常量{return 1.0+real_f（v）；}
};
接受向量f；

---

与“真实”模板指针不同的是，您不能像使用普通函数指针一样，重新放置“AcceptsVector”来调用另一个模板。绑定在编译时硬编码。但是，您可以像函数指针一样传递

f

，也可以像模板一样使用任何

向量调用
f
 你能把
f
可以指向的函数的签名贴出来吗？多点上下文有助于建议你应该做什么。我不明白第一个typedef，函数指针的别名是什么？你能解释一下你的答案吗，如果没有typedef，它为什么要与typedef一起工作呢？这没有什么魔力——它只是专门模板中具体的
typedef
的“模板”。你可以显式地使用一个类型，比如
double（*FP）（const Vector&）
，
typedef
只是让它更干净而已。哼，我还是不懂。。为什么只在函数指针中使用const-Vector&如果它是模板化的，那么它不应该是const-Vector吗？因为它在模板定义中-模板参数是假定的。
template <typename T, int N>
class Vector
{
public:

    /// type of function pointer
    typedef double (*FuncPtr)( const Vector& );

};

// concrete type
typedef Vector<double,10> VecDouble10;

// actual function
double func( const VecDouble10>& );

// usage
VecDouble10::FuncPtr fp = func;

struct AcceptsVector {
  template<typename T, int N>
  double operator()(Vector<T,N> v) const { return 1.0 + real_f(v); }
};

AcceptsVector f;