Ejemplo 1:
Incluimos el archivo de encabezado 'iostream' para facilitar el uso de las funciones definidas. Luego, tenemos el 'espacio de nombres estándar'. Debajo de esto, generamos la clase llamada 'MyNewClass' y utilizamos el constructor 'público'.
En 'público', creamos la función miembro denominada 'myFunc' y declaramos 'int num' como parámetro de 'myFunc()'. Debajo de esto, usamos 'cout' e invocamos el método main() debajo de este en el que creamos el puntero de función miembro. Declaramos el puntero 'MyFuncPtr' al tipo de función miembro, especificando la clase 'MyNewClass' y el tipo de parámetro (int).
Después de esto, creamos el objeto de clase llamado 'Class_obj' y luego llamamos a la función miembro con la ayuda del puntero '*MyFuncPtr' colocando el objeto de clase con esto. Asignamos '10' como parámetro para representar esto cuando llamamos al puntero de función miembro.
Código 1:
#incluirusando el espacio de nombres estándar ;
clase MiNuevaClase {
público :
vacío miFunc ( En t en uno ) {
corte << 'El valor es' << en uno << fin ;
}
} ;
En t principal ( ) {
vacío ( Mi nueva clase ::* MiFuncPtr ) ( En t ) = & Mi nueva clase :: miFunc ;
MiNuevaClase Class_obj ;
( Clase_obj. * MiFuncPtr ) ( 10 ) ;
devolver 0 ;
}
Producción:
Esto ilustra el funcionamiento de los punteros de función miembro. El puntero de función miembro se puede utilizar para iniciar las funciones miembro dinámicamente según las condiciones actuales.
Ejemplo 2:
Para utilizar las funciones que se definen en el archivo de encabezado 'iostream' de forma sencilla, incluimos 'iostream' aquí. El 'espacio de nombres estándar' se coloca a continuación. Debajo, creamos la clase 'Prueba' y luego usamos el constructor 'público'. Definimos la función miembro 'myTestingFunc' en 'público' y configuramos 'int t_value' como parámetro para 'myTestingFunc()' en este caso. La función 'cout' se utiliza a continuación y se llama al método main(). Luego, creamos el puntero de función miembro.
Aquí especificamos la clase 'Prueba' y el puntero de función miembro '*MyTestFuncPtr'. Asignamos '&Test::myTestingFunc' al puntero de función miembro que se declara como 'void (Test::*MyTestFuncPtr)(int)'.
A continuación, generamos el objeto de clase 't_obj' y lo usamos para llamar a la función miembro colocando el objeto de clase y usando el puntero '*MyTestFuncPtr'. Para que esto se presente cuando llamamos al puntero de función miembro, asignamos '932' como parámetro.
Código 2:
#incluirusando el espacio de nombres estándar ;
prueba de clase {
público :
vacío myTestingFunc ( En t valor_t ) {
corte << 'El valor de prueba es ' << valor_t << fin ;
}
} ;
En t principal ( ) {
vacío ( Prueba ::* MiPruebaFuncPtr ) ( En t ) = & Prueba :: myTestingFunc ;
Prueba t_obj ;
( t_obj. * MiPruebaFuncPtr ) ( 932 ) ;
devolver 0 ;
}
Producción:
Se representa el resultado del código dado. Podemos ver que llamamos al 'puntero de función miembro' con el objeto de clase como se muestra aquí.
Ejemplo 3:
La clase que generamos en este código es 'MyNewCar', donde utilizamos el constructor 'público' y creamos la función miembro que es 'startCarEngine()'. En esta función, agregamos 'cout' que se representa cuando llamamos a esta función en nuestro código. Luego, creamos otra función miembro que es 'stopCarEngine()' y utilizamos 'cout' nuevamente en esta función miembro.
Después de esto, invocamos la función main() y luego declaramos el puntero de la función miembro que es “MyNewCar::*carEngineFunc()”. Debajo de esto, creamos el objeto de clase 'MyNewCar' con el nombre 'myCar_obj'. Luego, asignamos la función 'startCarEngine' al puntero 'carEngineFunc'. Debajo de esto, llamamos a esta función con la ayuda del puntero 'carEngineFunc' colocando el nombre del objeto junto a él.
A continuación, reasignamos la función 'stopCarEngine' al puntero 'carEngineFunc'. Debajo de eso, llamamos a esta función pasando el nombre del objeto junto con la referencia 'carEngineFunc'.
Código 3:
#incluirusando el espacio de nombres estándar ;
clase MyNewCar {
público :
vacío iniciarCarEngine ( ) {
corte << 'El motor del coche arranca' << fin ;
}
vacío paradaCarEngine ( ) {
corte << 'El motor del coche se para' << fin ;
}
} ;
En t principal ( ) {
vacío ( Mi auto nuevo ::* cocheEngineFunc ) ( ) ;
Mi nuevo coche myCar_obj ;
cocheEngineFunc = & Mi auto nuevo :: iniciarCarEngine ;
( miCar_obj. * cocheEngineFunc ) ( ) ;
cocheEngineFunc = & Mi auto nuevo :: paradaCarEngine ;
( miCar_obj. * cocheEngineFunc ) ( ) ;
devolver 0 ;
}
Producción:
Aquí se muestra el funcionamiento del 'puntero de función miembro'. Podemos ver que creamos el puntero de función miembro y mostramos el resultado aquí.
Ejemplo 4:
Después de incluir el archivo de encabezado y el 'espacio de nombres estándar', declaramos aquí la clase 'MyNewStudent'. La función miembro 'StudentPass()' es una de las funciones miembro que construimos para la clase 'MyStudentClass' que generamos aquí. También agregamos 'cout' a esta función que se representará cuando la llamemos en nuestro código.
A continuación, escribimos la función miembro “studentFail()” donde usamos “cout” una vez más. Luego se llama a la función main() y se declara el puntero de función miembro “(MyNewStudent::*studentResultFunc)()”. Debajo de eso, generamos el objeto 'myStd_obj' que pertenece a la clase 'MyNewStudent'.
A continuación, asignamos la función 'studentPass' al puntero 'studentResultFunc'. Debajo de eso, llamamos a esta función pasando el nombre del objeto junto con la referencia 'studentResultFunc'. La función 'studentFail' se reasigna al puntero 'studentResultFunc'. Debajo de eso, invocamos este método proporcionando la referencia 'carEngineFunc' y el nombre del objeto.
Ahora, aquí se llaman ambas funciones y se representan las declaraciones que incluimos en estas funciones.
Código 4:
#incluirusando el espacio de nombres estándar ;
clase MiNuevoEstudiante {
público :
vacío pase de estudiante ( ) {
corte << 'El pase de estudiante' << fin ;
}
vacío estudiantereprobado ( ) {
corte << 'El estudiante fracasa' << fin ;
}
} ;
En t principal ( ) {
vacío ( Mi nuevo estudiante ::* estudianteResultFunc ) ( ) ;
MiNuevoEstudiante myStd_obj ;
estudianteResultFunc = & Mi nuevo estudiante :: pase de estudiante ;
( myStd_obj. * estudianteResultFunc ) ( ) ;
estudianteResultFunc = & Mi nuevo estudiante :: estudiantereprobado ;
( myStd_obj. * estudianteResultFunc ) ( ) ;
devolver 0 ;
}
Producción:
Creamos las funciones miembro en nuestro código y luego el puntero de función miembro. Después de esto, llamamos a la función miembro y mostramos el resultado aquí.
Ejemplo 5:
En este caso se crea la “SampleClass”. Luego, el puntero de la función miembro se coloca aquí, que es “(SampleClass::*MyFunc)()”. Debajo de esto, creamos el puntero de función que es '(*MyFuncPtr)()'. Debajo, declaramos el 'nombre' de la variable 'cadena', así como el puntero de función miembro 'MyFunc f'.
Después de esto, tenemos el constructor 'público' donde definimos esta variable de función miembro. Debajo de esto, creamos las funciones miembro denominadas 'myFunc_1()' y 'myFunc_1()' y también agregamos 'cout' en cada función miembro que se mostrará cuando llamemos a esta función miembro.
Luego, llamamos a este puntero de función miembro con la ayuda de '(this->*f)()'. Luego, volvemos a colocar las funciones. Aquí cambiamos las declaraciones 'cout' que agregamos anteriormente. Luego, ahora se invoca 'main()' y el puntero de función miembro se define como 'MyFunc f = &SampleClass::myFunc_2'.
Entonces, el puntero de función también se define como “MyFuncPtr fp = myFunc_1”. Después de esto, escribimos “(a.*f)()” para utilizar el puntero de función miembro. El 'b.func' se coloca para utilizar la función miembro. Luego, colocamos “fp()” para llamar al puntero de función.
Código 5:
#incluirusando el espacio de nombres estándar ;
clase Clase de muestra ;
definición de tipo vacío ( Clase de muestra ::* MiFunc ) ( ) ;
definición de tipo vacío ( * MiFuncPtr ) ( ) ;
clase Clase de muestra {
nombre de cadena ;
MiFunc f ;
público :
Clase de muestra ( constante carbonizarse * nombre )
: nombre ( nombre ) ,
F ( & Clase de muestra :: miFunc_1 )
{ }
vacío miFunc_1 ( ) { corte << nombre << 'Aquí llamamos a la función 1' << fin ; }
vacío miFunc_2 ( ) { corte << nombre << 'Aquí llamamos a la función 2' << fin ; }
vacío función ( ) {
( este ->* F ) ( ) ;
}
} ;
vacío miFunc_1 ( ) { corte << 'La primera función' << fin ; }
vacío miFunc_2 ( ) { corte << 'La segunda función' << fin ; }
En t principal ( )
{
MiFunc f = & Clase de muestra :: miFunc_2 ;
MiFuncPtr fp = miFunc_1 ;
Clase de muestra a ( 'primero - ' ) , b ( 'segundo - ' ) ;
( a. * F ) ( ) ;
b. función ( ) ;
fp ( ) ;
}
Producción:
El resultado del código ahora se representa aquí, lo que representa el resultado en consecuencia como llamamos a las funciones en nuestro código.
Conclusión
Exploramos que los 'punteros de funciones miembro' en C++ facilitan el enlace dinámico, la encapsulación del comportamiento y el manejo flexible de la invocación de funciones dentro del contexto de la programación orientada a objetos. Aprendimos que el uso de 'punteros de funciones miembro' puede mejorar significativamente la modularidad y flexibilidad de las bases de código de C++, proporcionando una herramienta poderosa para abordar numerosos desafíos de diseño y tiempo de ejecución.