如何在C++中创建一个保存不同类型函数指针的容器？

Question

我正在做一个线性遗传编程项目，其中程序是通过自然进化机制孕育和进化的。他们的“DNA”基本上是一个容器（我已经成功地使用了数组和向量），其中包含指向一组可用函数的函数指针。 现在，对于简单的问题（例如数学问题），我可以使用一个类型定义的函数指针，该指针可以指向所有返回双精度值并且全部采用两个双精度值作为参数的函数。

不幸的是这不太实用。我需要能够有一个容器，它可以有不同类型的函数指针，比如一个函数指针指向一个不带参数的函数，或者一个带一个参数的函数，或者一个返回某些东西的函数，等等（你得到想法）...

有什么方法可以使用任何类型的容器来做到这一点？ 我可以使用包含多态类的容器来做到这一点，而多态类又具有各种函数指针吗？ 我希望有人能指导我找到解决方案，因为重新设计我迄今为止所做的一切将会很痛苦。

Answer 1

虚拟机的一个典型想法是拥有一个单独的堆栈，用于参数和返回值传递。

您的函数仍然可以是 void fn(void) 类型，但您需要手动传递和返回参数。

你可以做这样的事情：

class ArgumentStack {
    public:
        void push(double ret_val) { m_stack.push_back(ret_val); }

        double pop() {
             double arg = m_stack.back();
             m_stack.pop_back();
             return arg;
        }

    private:
        std::vector<double> m_stack;
};
ArgumentStack stack;

...所以一个函数可以看起来像这样：

// Multiplies two doubles on top of the stack.
void multiply() {
    // Read arguments.
    double a1 = stack.pop();
    double a2 = stack.pop();

    // Multiply!
    double result = a1 * a2;

    // Return the result by putting it on the stack.
    stack.push(result);
}

这可以这样使用：

// Calculate 4 * 2.
stack.push(4);
stack.push(2);
multiply();
printf("2 * 4 = %f\n", stack.pop());

你遵循吗？

Answer 2

您不能将多态函数放入类中，因为接受（或返回）不同内容的函数不能以相同的方式使用（具有相同的接口），而这是多态性所要求的。

让一个类为您需要的任何可能的函数类型提供虚拟函数的想法是可行的，但是（在不了解您的问题的情况下！）它的用法对我来说感觉很奇怪：派生类将具有哪些函数覆盖？你们的功能不是不相关的吗？

如果您的函数不相关（如果没有理由将它们分组为同一类的成员，或者如果它们是静态函数，因为它们不需要成员变量），您应该选择其他东西......如果您选择随机的函数你可以有几个不同的容器，一个用于函数类型，然后随机选择一个容器，然后在其中选择一个函数。

你能举一些例子来说明你的函数的作用吗？

Answer 3

你提到的本身可以通过一个容器来实现
std::function 或类似 Boost::variant 的可区分联合。
例如：

#include <functional>
#include <cstdio>
#include <iostream>

struct F {
  virtual ~F() {}
};

template< class Return, class Param = void >
struct Func : F {
  std::function< Return( Param ) >  f;
  Func( std::function< Return( Param ) > const& f ) : f( f ) {}
  Return operator()( Param const& x ) const { return f( x ); }
};

template< class Return >
struct Func< Return, void > : F {
  std::function< Return() >  f;
  Func( std::function< Return() > const& f ) : f( f ) {}
  Return operator()() const { return f(); }
};

static void f_void_void( void ) { puts("void"); }
static int f_int_int( int x ) { return x; }

int main()
{
  F  *f[] = {
    new Func< void >( f_void_void ),
    new Func< int, int >( f_int_int ),
  };

  for ( F **a = f, **e = f + 2;  a != e;  ++ a ) {
    if      ( auto p = dynamic_cast< Func< void >*     >( *a ) ) {
      (*p)();
    }
    else if ( auto p = dynamic_cast< Func< int, int >* >( *a ) ) {
      std::cout<< (*p)( 1 ) <<'\n';
    }
  }
}

但我不确定这是否真的是您想要的...
您如何看待阿尔夫·P·斯坦巴赫的评论？

Answer 4

这种事情只要稍加努力就有可能实现。首先，重要的是要理解为什么不可能做到更简单：在 C/C++ 中，将参数传递给函数的确切机制以及如何从函数获取返回值取决于参数的类型（和大小）。这是在应用程序二进制接口 (ABI) 中定义的，它是一组约定，允许不同编译器编译的 C++ 代码进行互操作。该语言还指定了在调用站点发生的一系列隐式类型转换。因此，简短而简单的答案是，在 C/C++ 中，编译器无法发出机器代码来调用编译时签名未知的函数。

现在，您当然可以用 C++ 实现 Javascript 或 Python 之类的东西，其中所有值（与这些函数相关）都是动态输入的。您可以有一个基本的“Value”类，它可以是整数、浮点数、字符串、元组、列表、映射等。您可以使用 std::variant ，但在我看来，这实际上是语法上的很麻烦，你最好自己做：

enum class Type {integer, real, str, tuple, map};

struct Value
{
  // Returns the type of this value.
  virtual Type type() const = 0;
  
  // Put any generic interfaces you want to have across all Value types here.
};

struct Integer: Value
{
  int value;

  Type type() const override { return Type::integer; }
};

struct String: Value
{
  std::string value;

  Type type() const override { return Type::str; }  
};

struct Tuple: Value
{
  std::vector<Value*> value;

  Type type() const override { return Type::tuple; };
}

// etc. for whatever types are interesting to you.

现在你可以将函数定义为任何接受单个 Value* 并返回单个 Value* 的函数。多个输入或输出参数可以作为元组或映射传入：

using Function = Value* (*)(Value*);

所有函数实现都需要获取类型并对参数执行适当的操作：

Value* increment(Value* x)
{
  switch (x->type())
  {
    Type::integer:
      return new Integer(((Integer*) x)->value + 1);
    Type::real:
      return new Real(((Real*) x)->value + 1.0);
    default:
      throw TypeError("expected an integer or real argument.")
  }
}

increment 现在与 Function 类型，可以存储在mFuncs 中。现在，您可以对未知类型的参数调用未知类型的函数，如果参数不匹配，您将收到异常；如果参数兼容，您将收到某些未知类型的结果。

您很可能希望将函数签名存储为可以内省的东西，即动态计算出函数采用的参数的数量和类型。在这种情况下，您可以使用必要的自省函数创建一个基Function类，并为其提供一个operator ()以使其看起来像调用常规函数。然后，您可以根据需要派生并实现Function。

这是一个草图，但希望包含足够的指示来指明方向。还有更多类型安全的方法来编写此代码（当我已经检查过类型时，我喜欢 C 风格的强制转换，但有些人可能坚持认为您应该使用 dynamic_cast ），但我想这不是这个问题的重点。您还必须弄清楚 Value* 对象的生命周期是如何管理的，这是一个完全不同的讨论。