예시 1:
정의된 기능을 쉽게 활용할 수 있도록 “iostream” 헤더 파일을 포함합니다. 그런 다음 '네임스페이스 std'가 있습니다. 그 아래에는 'MyNewClass'라는 클래스를 생성하고 'public' 생성자를 활용합니다.
'public'에서는 'myFunc'라는 멤버 함수를 만들고 'myFunc()'의 매개 변수로 'int num'을 선언합니다. 아래에서는 'cout'을 사용하고 멤버 함수 포인터를 생성하는 main() 메서드를 호출합니다. 'MyNewClass' 클래스와 매개변수 유형(int)을 지정하여 멤버 함수 유형에 대한 'MyFuncPtr' 포인터를 선언합니다.
그런 다음 'Class_obj'라는 클래스 개체를 만든 다음 이 클래스 개체를 배치하여 '*MyFuncPtr' 포인터의 도움으로 멤버 함수를 호출합니다. 멤버 함수 포인터를 호출할 때 이를 렌더링하기 위한 매개 변수로 '10'을 할당합니다.
코드 1:
#include네임스페이스 표준 사용 ;
클래스 MyNewClass {
공공의 :
무효의 myFunc ( 정수 하나에 ) {
시합 << '값은' << 하나에 << 끝 ;
}
} ;
정수 기본 ( ) {
무효의 ( 내새클래스 ::* MyFuncPtr ) ( 정수 ) = & 내새클래스 :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
반품 0 ;
}
산출:
이는 멤버 함수 포인터의 작동을 보여줍니다. 멤버 함수 포인터는 현재 조건에 따라 멤버 함수를 동적으로 실행하는 데 사용될 수 있습니다.
예 2:
“iostream” 헤더 파일에 정의된 기능을 간단하게 사용하기 위해 여기에 “iostream”을 포함시킵니다. '네임스페이스 표준'은 그 옆에 배치됩니다. 그 아래에는 'Test' 클래스를 만든 다음 'public' 생성자를 사용합니다. 'public'에 'myTestingFunc' 멤버 함수를 정의하고 이 인스턴스에서는 'int t_value'를 'myTestingFunc()'에 대한 매개 변수로 설정합니다. 아래에서는 'cout' 함수가 사용되며 main() 메서드가 호출됩니다. 그런 다음 멤버 함수 포인터를 만듭니다.
여기서는 'Test' 클래스와 '*MyTestFuncPtr' 멤버 함수 포인터를 지정합니다. 'void (Test::*MyTestFuncPtr)(int)'로 선언된 멤버 함수 포인터에 '&Test::myTestingFunc'를 할당합니다.
다음으로 't_obj' 클래스 개체를 생성하고 이를 사용하여 클래스 개체를 배치하고 '*MyTestFuncPtr' 포인터를 사용하여 멤버 함수를 호출합니다. 멤버 함수 포인터를 호출할 때 이를 표시하려면 '932'를 매개 변수로 할당합니다.
코드 2:
#include네임스페이스 표준 사용 ;
수업 테스트 {
공공의 :
무효의 myTestingFunc ( 정수 t_값 ) {
시합 << '테스트 값은 ' << t_값 << 끝 ;
}
} ;
정수 기본 ( ) {
무효의 ( 시험 ::* MyTestFuncPtr ) ( 정수 ) = & 시험 :: myTestingFunc ;
t_obj 테스트 ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
반품 0 ;
}
산출:
주어진 코드의 결과가 렌더링됩니다. 여기에 표시된 것처럼 클래스 개체를 사용하여 '멤버 함수 포인터'를 호출한 것을 볼 수 있습니다.
예시 3:
이 코드에서 생성하는 클래스는 'MyNewCar'입니다. 여기서 'public' 생성자를 활용하고 'startCarEngine()'이라는 멤버 함수를 생성합니다. 이 함수에는 코드에서 이 함수를 호출할 때 렌더링되는 'cout'을 추가합니다. 그런 다음 'stopCarEngine()'이라는 또 다른 멤버 함수를 만들고 이 멤버 함수에서 'cout'을 다시 활용합니다.
그런 다음 main() 함수를 호출한 다음 'MyNewCar::*carEngineFunc()'라는 멤버 함수 포인터를 선언합니다. 그 아래에는 이름이 'myCar_obj'인 'MyNewCar' 클래스 개체를 만듭니다. 그런 다음 'startCarEngine' 함수를 'carEngineFunc' 포인터에 할당합니다. 그 아래에 객체 이름을 배치하여 'carEngineFunc' 포인터를 사용하여 이 함수를 호출합니다.
다음으로, 'stopCarEngine' 함수를 'carEngineFunc' 포인터에 다시 할당합니다. 그 아래에서는 'carEngineFunc' 참조와 함께 객체 이름을 전달하여 이 함수를 호출합니다.
코드 3:
#include네임스페이스 표준 사용 ;
클래스 MyNewCar {
공공의 :
무효의 startCarEngine ( ) {
시합 << '자동차의 엔진이 시동됩니다' << 끝 ;
}
무효의 정지자동차엔진 ( ) {
시합 << '자동차의 엔진이 멈췄습니다' << 끝 ;
}
} ;
정수 기본 ( ) {
무효의 ( 나의 새 차 ::* 자동차EngineFunc ) ( ) ;
MyNewCar myCar_obj ;
자동차EngineFunc = & 나의 새 차 :: startCarEngine ;
( myCar_obj. * 자동차EngineFunc ) ( ) ;
자동차EngineFunc = & 나의 새 차 :: 정지자동차엔진 ;
( myCar_obj. * 자동차EngineFunc ) ( ) ;
반품 0 ;
}
산출:
여기에는 '멤버 함수 포인터'의 작동이 표시됩니다. 멤버 함수 포인터를 생성하고 여기에 결과를 표시한 것을 볼 수 있습니다.
예시 4:
헤더 파일과 'std 네임스페이스'를 포함시킨 후 여기서 'MyNewStudent' 클래스를 선언합니다. 'studentPass()' 멤버 함수는 여기서 생성한 'MyStudentClass' 클래스에 대해 빌드한 멤버 함수 중 하나입니다. 또한 코드에서 호출할 때 렌더링되는 이 함수에 'cout'을 추가합니다.
다음으로 'cout'을 다시 한 번 사용하는 'studentFail()' 멤버 함수를 작성합니다. 그런 다음 main() 함수가 호출되고 '(MyNewStudent::*studentResultFunc)()' 멤버 함수 포인터가 선언됩니다. 그 아래에서는 'MyNewStudent' 클래스에 속하는 ' myStd_obj ' 개체를 생성합니다.
다음으로, “studentPass” 함수를 “studentResultFunc” 포인터에 할당합니다. 그 아래에서는 'studentResultFunc' 참조와 함께 개체 이름을 전달하여 이 함수를 호출합니다. 'studentFail' 함수는 'studentResultFunc' 포인터에 다시 할당됩니다. 그 아래에서는 'carEngineFunc' 참조와 객체 이름을 제공하여 이 메서드를 호출합니다.
이제 여기서 두 함수가 모두 호출되고 이 함수에 포함된 명령문이 렌더링됩니다.
코드 4:
#include네임스페이스 표준 사용 ;
MyNewStudent 클래스 {
공공의 :
무효의 학생패스 ( ) {
시합 << '학생증' << 끝 ;
}
무효의 학생실패 ( ) {
시합 << '학생은 실패했다' << 끝 ;
}
} ;
정수 기본 ( ) {
무효의 ( 나의새학생 ::* 학생결과Func ) ( ) ;
MyNewStudent myStd_obj ;
학생결과Func = & 나의새학생 :: 학생패스 ;
( myStd_obj. * 학생결과Func ) ( ) ;
학생결과Func = & 나의새학생 :: 학생실패 ;
( myStd_obj. * 학생결과Func ) ( ) ;
반품 0 ;
}
산출:
우리는 코드에서 멤버 함수를 만든 다음 멤버 함수 포인터를 만들었습니다. 그런 다음 멤버 함수를 호출하고 여기에 결과를 표시했습니다.
예시 5:
이 인스턴스에서는 'SampleClass'가 생성됩니다. 그런 다음 '(SampleClass::*MyFunc)()'라는 멤버 함수 포인터가 여기에 배치됩니다. 그 아래에 '(*MyFuncPtr)()'라는 함수 포인터를 만듭니다. 그 아래에는 'string' 변수의 'name'과 'MyFunc f' 멤버 함수 포인터를 선언합니다.
그 다음에는 이 멤버 함수 변수를 정의하는 '공용' 생성자가 있습니다. 그 아래에는 'myFunc_1()' 및 'myFunc_1()'이라는 멤버 함수를 만들고 이 멤버 함수를 호출할 때 표시될 각 멤버 함수에 'cout'을 추가합니다.
그런 다음 '(this->*f)()'를 사용하여 이 멤버 함수 포인터를 호출합니다. 그런 다음 함수를 다시 배치합니다. 여기서는 이전에 추가한 'cout' 문을 변경합니다. 그런 다음 'main()'이 호출되고 멤버 함수 포인터가 'MyFunc f = &SampleClass::myFunc_2'로 정의됩니다.
그러면 함수 포인터도 “MyFuncPtr fp = myFunc_1”로 정의됩니다. 그런 다음 멤버 함수 포인터를 활용하기 위해 '(a.*f)()'를 입력합니다. b.func는 멤버함수를 활용하기 위해 배치한 것입니다. 그런 다음 함수 포인터를 호출하기 위해 'fp()'를 배치합니다.
코드 5:
#include네임스페이스 표준 사용 ;
클래스 SampleClass ;
형식 정의 무효의 ( 샘플클래스 ::* 마이펑크 ) ( ) ;
형식 정의 무효의 ( * MyFuncPtr ) ( ) ;
클래스 SampleClass {
문자열 이름 ;
마이펑크(MyFunc) ;
공공의 :
샘플클래스 ( const 숯 * 이름 )
: 이름 ( 이름 ) ,
에프 ( & 샘플클래스 :: myFunc_1 )
{ }
무효의 myFunc_1 ( ) { 시합 << 이름 << '여기서 fuction 1을 호출했습니다.' << 끝 ; }
무효의 myFunc_2 ( ) { 시합 << 이름 << '우리는 여기서 함수 2를 호출했습니다.' << 끝 ; }
무효의 기능 ( ) {
( 이것 ->* 에프 ) ( ) ;
}
} ;
무효의 myFunc_1 ( ) { 시합 << '첫 번째 기능' << 끝 ; }
무효의 myFunc_2 ( ) { 시합 << '두 번째 기능' << 끝 ; }
정수 기본 ( )
{
MyFunc f = & 샘플클래스 :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
샘플클래스 ( '첫 번째 - ' ) , 비 ( '두번째 - ' ) ;
( ㅏ. * 에프 ) ( ) ;
비. 기능 ( ) ;
fp ( ) ;
}
산출:
이제 코드의 결과가 여기에 렌더링되어 코드에서 함수를 호출한 대로 그에 따라 결과가 렌더링됩니다.
결론
우리는 C++의 '멤버 함수 포인터'가 OOP 컨텍스트 내에서 동적 바인딩, 동작 캡슐화 및 함수 호출의 유연한 처리를 용이하게 한다는 점을 조사했습니다. 우리는 '멤버 함수 포인터'를 사용하면 C++ 코드베이스의 모듈성과 유연성을 크게 향상시켜 수많은 디자인 및 런타임 문제를 해결하기 위한 강력한 도구를 제공할 수 있다는 것을 배웠습니다.