후기 바인딩의 이점은 무엇입니까? C++에서 함수 포인터의 문맥에서 한 가지 예를 들자.

Question

먼저, this 질문을 분명히 해두면 분명히 의심의 여지가 없다. 문맥을 깨끗하게 설정하려면. C/C++에서 함수 포인터와 관련하여 특별히이 질문을하고 있습니다.

초기 바인딩과 후기 바인딩 간의 차이점과 작동 방식을 알고 있습니다. 많은 교과서에서

,이 언급되었습니다 : 늦은 바인딩의

장점은보다 융통성이 있다는 것입니다 내가 이해하고 싶은 것은 C/C++에서 함수 포인터를 사용하여 하나의 예와 함께 다음과 같다 초기에 바인딩, 왜냐하면 어떤 함수를 호출 할 지 결정할 때 실행 시간까지 을 만들 필요가 없기 때문입니다.

또한, 언급 : 후기 바인딩으로

이 프로그램은 포인터에서 개최 된 주소를 읽은 후 해당 주소로 이동한다. 여기에는 약간의 추가 단계 인 이 포함됩니다. 여기

#include <iostream> 
using namespace std; 

int Add(int nX, int nY) 
{ 
    return nX + nY; 
} 

int Subtract(int nX, int nY) 
{ 
    return nX - nY; 
} 

int Multiply(int nX, int nY) 
{ 
    return nX * nY; 
} 

int main() 
{ 
    int nX; 
    cout << "Enter a number: "; 
    cin >> nX; 

    int nY; 
    cout << "Enter another number: "; 
    cin >> nY; 

    int nOperation; 
    do 
    { 
     cout << "Enter an operation (0=add, 1=subtract, 2=multiply): "; 
     cin >> nOperation; 
    } while (nOperation < 0 || nOperation > 2); 

    // Create a function pointer named pFcn (yes, the syntax is ugly) 
    int (*pFcn)(int, int); 

    // Set pFcn to point to the function the user chose 
    switch (nOperation) 
    { 
     case 0: pFcn = Add; break; 
     case 1: pFcn = Subtract; break; 
     case 2: pFcn = Multiply; break; 
    } 

    // Call the function that pFcn is pointing to with nX and nY as parameters 
    cout << "The answer is: " << pFcn(nX, nY) << endl; 

    return 0; 
} 

늦게 결합 아래 바람직되어야 예와 같이 초기 바인딩 사용에는 장점이 없다.

int nResult = 0; 
switch (nOperation) 
{ 
    case 0: nResult = Add(nX, nY); break; 
    case 1: nResult = Subtract(nX, nY); break; 
    case 2: nResult = Multiply(nX, nY); break; 
} 

cout << "The answer is: " << nResult << endl; 

사람은 후기 바인딩이 장점이다 왜 누군가가 초기 바인딩을 위에 그것을 선택해야 아래처럼 쉬운 예제를 통해 설명 할 수 있을까요?

Answer 1

좋아, 나는 "초기 바인딩 대 후기 바인딩"정의 질문을 건너 뛰고 "왜 누군가가 switch 문 대신 함수 포인터를 사용하겠습니까?"라고 묻는 척합니다.

함수 포인터가보다 유연하기 때문입니다. 그들은 정적이 아닙니다.의이 코드의 비즈니스 끝을 보자 : 좋은 기능이다

int InvokeOperation(int nOperation, int nX, int nY) 
{ 
    switch (nOperation) 
    { 
     case 0: return Add(nX, nY); 
     case 1: return Subtract(nX, nY); 
     case 2: return Multiply(nX, nY); 
    } 
} 

합니다. 하지만 유연하지 않습니다.. 왜? 호출 할 수있는 모든 함수는 InvokeOperation에 의해 정의되므로; 새 작업을 추가하려면 InvokeOperation을 변경할 수 있어야합니다. 당신이 더 많은 작업을 추가하려면 단지 funcs에 요소를 삽입, 지금

using Func = int(*)(int, int); 
struct Op{Func func; std::string name;}; 
std::vector<Func> funcs = 
{ 
    {&Add, "Add"}, 
    {&Subtract, "Subtract"}, 
    {&Multiply, "Multiply"}, 
}; 

int InvokeOperation(int nOperation, int nX, int nY) 
{ 
    return funcs[nOperation].func(nX, nY); 
} 

: 당신이 함수 포인터를 사용하는 경우

대조적으로, 당신은 작업의 전체 레지스트리를 구축 할 수 있습니다. InvokeOperation이 일부 라이브러리의 일부인 경우, 반드시 해당 라이브러리를 변경할 권리가 없습니다. 정적 바인딩을 사용하면 유연하지 못한 시스템을 사용할 수 있습니다. 그것이 무엇을 지원하는지는 항상을 지원합니다.

동적 바인딩을 사용하면 라이브러리를 직접 수정할 권한이 있는지 여부에 관계없이 원하는 것을 추가 할 수 있습니다.