0

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

将函数调用存储在数组中，即有一个双精度数组和一个返回双精度的函数....我想在调用例如数组的一个元素时，比如说 myArray[0]，它应该调用函数myArray，返回一个双精度。

double myFunction(){return mydouble}

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

6 回答 6

5

对于 C++ 查找std::function，对于 C 阅读更多关于函数指针的信息。

函数指针也可以在 C++ 中使用，但不如std::function.

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';

用于myArray[0]查找lambda 函数的赋值，并用于myArray[1]查找查找std::bind。

于 2013-03-06T09:47:52.920 回答
3

然后你应该有一个函数指针数组来实现这个：

typedef double(*MyArray)();

MyArray MA[3];

您可以将带有签名的函数存储double function_name()到数组中，例如：

MA[0] = MyFunction;

cout<< MA[0]()<<endl;

于 2013-03-06T09:53:57.187 回答
1

在 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;
}
于 2013-03-06T09:59:15.197 回答
1 
    double myFunction()
{
    double mydouble = 1;
  return mydouble;
}

int main()
{
  double myArray[3] = {0,0,0};
  for(int i=0;i<3;i++)
  {
    myArray[i] = myFunction();
    cout << myArray[i];
  }

}
于 2013-03-06T09:59:25.160 回答
1

解决方案在 C 和 C++ 中不同，在 C++11 和 pre-C++11 中也不同。

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

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

调用函数：

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

这是非常有限的，因为这意味着所讨论的函数不能依赖于任何其他数据。出于这个原因，通常在 C 中创建一个struct：

struct F
{
    double (*pf)( void* );
    void*    data;
};

F array[3] = { { &f1, NULL }, { &f2, someData }, { &f3, NULL } };

std::cout << (*array[i].pf)( &data ) << 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;

最后，在 C++11 中，有一个标准对象std::function 封装了所有这些。（但是，您必须自己查找。像大多数人一样，我还没有使用完全支持 C++11 的编译器，因此无法练习。）

于 2013-03-06T10:02:51.847 回答
1

像这样简单的事情怎么样？：

#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;
}

输出（ideone）：

1.25
于 2013-03-06T10:14:27.130 回答