함수 호출

Question

내가 어려움이 이해하고 다음 문제 구현이 : 난 것 .... 즉 두 배를 돌려 복식의 배열과 기능을 갖는 배열 함수 호출을 저장

을 예를 들어 부를 때처럼 배열의 요소는 myArray [0]을 말하면 double을 반환하는 myArray 함수를 호출해야합니다.

double myFunction(){return mydouble} 

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

Answer 1

는 std::function를 찾아 ++ C를 들어, C에 대한 더 많은 약 function pointers를 참조하십시오.

함수 포인터는 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 functions를 검색하고 myArray[1] 과제에 대한 std::bind를 찾아보십시오.

Answer 2

그럼 당신은 이것을 달성하기 위해 함수 포인터의 배열이 있어야합니다

typedef double(*MyArray)();

MyArray MA[3];

당신은 같은 배열에 서명 double function_name()와 기능을 저장할 수 있습니다 :

MA[0] = MyFunction;

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

Answer 3

이 방법으로 그것을 할 수있는 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; 
} 

Answer 4

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

} 

Answer 5

이 솔루션은 C와 C에서 다른 ++, 또한 다른 11 C++ 및 사전 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을 지원하는 컴파일러에 액세스 할 수없는, 직접이를 조회 할 것이다, 그래서 연습 없었습니다이.)

Answer 6

이 같은 간단한에 대해

#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