C++ 作为数组元素的函数调用

我在理解和实施以下问题时遇到一些困难：

将函数调用存储在数组中，即具有一个double数组和一个返回double的函数……我想在调用数组的一个元素（比如myArray[0]）时，它应该调用返回double的函数myArray

double myFunction(){return mydouble}

double myArray[3];
...
cout<<myArray[2]<<endl; <- should call myFunction and return "mydouble"

double myFunction（）{return mydouble}
双myArray[3]；
...
CUT< P>为C++查找，对于C阅读更多有关.< /P>
函数指针也可以用在C++中，但不如<代码> STD:：函数 > 
灵活。
C++解决方案：

struct MyStruct
{
    double myStructFunction() { return 2.0; }
};

std::function<double()> myArray[3];

MyStruct myStructure;

myArray[0] = []() { return 1.0; };
myArray[1] = std::bind(&MyStruct::myStructFunction, myStructure);
myArray[2] = myFunction;

for (int i = 0; i < 3; i++)
    std::cout << "Calling `myArray[" << i << "]` : " << myArray[i]() << '\n';

struct MyStruct
{
double myStructFunction（）{return 2.0；}
};
std:：函数myArray[3]；
MyStruct myStructure；
myArray[0]=[]（）{return 1.0；}；
myArray[1]=std:：bind（&MyStruct:：myStructFunction，myStructure）；
myArray[2]=myFunction；
对于（int i=0；i<3；i++）
std:：cout那么您应该拥有函数指针数组，以实现这一点：

typedef-double（*MyArray）（）

myma数组[3]

您可以将带有签名的函数
double function\u name（）
存储到数组中，如：

MA[0]=MyFunction

cout在C中，您可以通过以下方式执行：

#include <stdio.h>

/* Functions */
static double fn_0(void){return 0.;}
static double fn_1(void){return 1.;}
static double fn_2(void){return 2.;}

int main(void)
{
    /* Declaration */
    double (*pfn[])(void) = {fn_0, fn_1, fn_2};
    int i;

    for (i = 0; i < 3; i++) {
        printf("%f\n", pfn[i]()); /* Usage */
    }
    return 0;
}

#包括
/*功能*/
静态双fn_0（void）{return 0.}
静态双fn_1（void）{return 1.}
静态双fn_2（void）{return 2.}
内部主（空）
{
/*声明*/
double（*pfn[]）（void）={fn_0，fn_1，fn_2}；
int i；
对于（i=0；i<3；i++）{
printf（“%f\n”，pfn[i]（））；/*用法*/
}
返回0；
}
double myFunction（）
{
double mydouble=1；
返回mydouble；
}
int main（）
{
双myArray[3]={0,0,0}；
对于（int i＝0；i＜p＞），C和C++中的解是不同的，并且在
C++11和C++11之前的版本

在所有这些中，您可以有一个指向的指针的简单数组
职能：

double (*array[3])() = { &f1, &f2, &f3 };

要调用函数，请执行以下操作：

std::cout << (*array[i])() << std::endl;

（然而，有很多情况，特别是在数字方面
计算，这是多余的。它主要用于
回调。）

在C++中，您也可以定义抽象基
类，并使用虚拟函数（将在每个
派生类），并将指针保存到各种
派生类：

class F
{
public:
    virtual ~F() {}
    virtual double operator()() const = 0;
};

F const* array[3] = { &obj1, &obj2, &obj3 };

std::cout<< (*array[i])() << std::endl;

F类
{
公众：
虚拟~F（）{}
虚拟双运算符（）（）常量=0；
};
F常量*数组[3]={&obj1、&obj2、&obj3}；
像这样简单的事情怎么样

#include <iostream>
#include <map>

struct O
{
  std::map<size_t,double(*)()> m;
  double operator[](size_t index)
  {
    return m[index]();
  }
};

double mydouble = 1.25;

double myFunction()
{
  return mydouble;
}

int main()
{
  O myArray;
  myArray.m[2] = &myFunction;
  std::cout << myArray[2] << std::endl;
  return 0;
}

请决定C或C++。函数不能返回普通数组。我想询问使用lambda函数的可能性，用<代码> STD::Stase。你知道这是否将与VC++或G++一起工作，以及从哪个版本起作用？（我知道这两个版本都不支持C++11，但在最近的版本中，有些东西确实可以工作——例如，我可以在VC++11中使用简单的lambda。）@JamesKanze在GCC4.7.1中构建得很好。在clang版本3.3（trunk 176337）中也进行了测试。还没有用VC++测试。@JamesKanze刚刚用VC++2012 Express检查过，在那里也很好。不过，我不能透露2010年的情况。
class F
{
public:
    virtual ~F() {}
    virtual double operator()() const = 0;
};

F const* array[3] = { &obj1, &obj2, &obj3 };

std::cout<< (*array[i])() << std::endl;

#include <iostream>
#include <map>

struct O
{
  std::map<size_t,double(*)()> m;
  double operator[](size_t index)
  {
    return m[index]();
  }
};

double mydouble = 1.25;

double myFunction()
{
  return mydouble;
}

int main()
{
  O myArray;
  myArray.m[2] = &myFunction;
  std::cout << myArray[2] << std::endl;
  return 0;
}

1.25