Los métodos pueden ser definidos como regulares y como virtuales.

Regulares

La mayor parte de los métodos de una clase se definen como métodos regulares a no ser que se indique lo contrario. Una de las características de los métodos regulares es que el compilador es capaz de determinar la dirección del método en tiempo de ejecución. Por otra parte si un método regular es declarado en una clase descendiente, con .el mismo nombre y número de parámetros que en la clase ancestro, lo que ocurrirá es que reemplazará al método de la clase ancestro.

Virtuales

Los métodos definidos como virtuales tienen la particularidad de que su dirección es detrminada en tiempo de ejecución. Los mecanismos de C++ permiten determinar qué método invocar en función de la clase que se esta utilizando.

Para poder identificar un método como virtual basta con anteponer al nombre del método la palabra reservada virtual. ¿Que ocurre cuando el compilador encuentra la palabra reservada virtual ?. La respuesta es muy sencilla. Para todos los mètodos definidos como virtuales el compilador crea una tabla con las direcciones de los métodos virtuales. Cuando el compilador encuentra la palabra reservada virtual realiza una entrada en la tabla de métodos virtuales(VMT). Esta tabla es la que se utiliza para determinar a qué método llamar en función de la clase invocada.

Cada una de las clases tiene su propia tabla de métodos virtuales de manera que se sobreescriben los métodos de la clase base.

Los Métodos y las propiedades

Como vamos a ver otra de las aplicaciones que podemos dar a los métodos es la de ampliar la funcionalidad de las propiedades para obtener el valor de las propiedades y para modificar su valor.

Una vez que tenemos el componente creado se nos plantea un problema. ¿Qué ocurre si queremos realizar alguna tarea en función de la activación o desactivación de la propiedad Active ?. La respuesta es muy sencilla, en lugar de acceder directamente a la propiedad FActive deberíamos hacerlo a través de dos funciones, una función de escritura y de una función de lectura.

La función de lectura debería devolver un valor del mismo tipo que el la propiedad FActive. En el caso de la función de escritura deberíamos pasar un parámetro del mismo tipo que la propiedad FActive.

La nomenclatura que se utiliza para denominar a estas funciones suelen empezar por Set... y Get... de manera que se pueda identificar de manera rápida y visual qué tarea desempeña cada una de las funciones.

En el caso que tratamos el código quedaría de la siguiente manera en el archivo CPP:

//--------------------------------------------------------------------------- void __fastcall TGestionErrores::SetActivar(Boolean Valor) { if (Valor != FActivar) { FActivar = Valor; } } //--------------------------------------------------------------------------- Boolean __fastcall TGestionErrores::GetActivar(void) { return FActivar; }

En el archivo de cabecera quedaría de la siguiente manera :

//--------------------------------------------------------------------------- class PACKAGE TGestionErrores : public TComponent { private: Boolean FActivar; protected: void __fastcall SetActivar(Boolean Valor); Boolean __fastcall GetActivar(void); public: __fastcall TGestionErrores(TComponent* Owner); __published: __property Boolean Activar = {read = GetActivar,write=SetActivar}; };