Tipos de datos definidos por el usuario

De LIDSOL

En ocaciones, es necesario el uso de tipos de datos definidos por el usuario, para crear unidades de programa más complejas, como lo son las estructuras de datos (listas, graphos, etc); que nativamente el lenguaje no implementa, por lo que existe una forma de definir datos compuestos.

Como se mencionó al principio, los tipos de datos nativos son aquellos que interpreta directamente el lenguaje. En el caso de Fostran 90, los tipos de datos nativos son: character, integer, real, double, complex. etc.

Pero si se requiere algún tipo de dato que contenga dos o más tipos nativos, para describir algún elemento necesario para la solución de un problema, entonces se puede recurir a una sentencia pensada para la definición de nuevos datos:

TYPE <nombre-tipo>
   tipos de datos nativos
END TYPE <nombre-tipo>

Donde <nombre-tipo> es el nombre con el que se describe el tipo de dato compuesto, y que se recomienda sea tan descriptivo como sea posible.

Como se observa, entre TYPE y END TYPE se encierran los elementos que componen a nuestro nuevo tipo de dato, y que son elementos conocidos por el lenguaje.

Por ejemplos, si se deseara definir un tipo de dato que represente números complejos, se puede construir de la siguiente manera:

TYPE num_complejo
   REAL:: p_real
   REAL:: p_img
END TYPE num_complejo

Y para utilizarlo, es de la siguiente manera:

  PROGRAM op_num_cpx
     IMPLICIT NONE

     TYPE num_complejo
        REAL:: pte_real !! Parte real
        REAL:: pte_img !! Parte imaginaria
     END TYPE num_complejo
     
     TYPE(num_complejo) :: cualquiera, conjugado
     
     PRINT*,'Escribir parte real: '
     READ*,cualquiera%pte_real
     PRINT*,'Escribe parte imaginaria'
     READ*,cualquiera%pte_img
     PRINT*,'Este es el numero',cualquiera%pte_real,' + i', cualquiera%pte_img
     PRINT*,'Y su conjugado'
     conjugado%pte_real=cualquiera%pte_real
     conjugado%pte_img= (-1) * cualquiera%pte_img
     PRINT*,'Este es el numero',conjugado%pte_real,' + i', conjugado%pte_img

  END PROGRAM

En el programa se define un tipo de dato derivado, que en este caso es num_complejo, se declaran dos variables del tipo num_complejo, llamadas cualquiera y conjugado, que después se utilizan.

Como se puede observar, para accesar a algún miembro del dato compuesto, se antepone el nombre de la variable, segido del caracter % seguido del nombre del miembro que se quiere accesar, en este caso para accesar a la parte imaginaria de la variable conjugado, es:

conjugado%pte_img

Tipos derivados compuestos por punteros

La estructura es la misma, con la diferencia que los elementos que conforman al tipo derivado de datos son punteros.

Por ejemplo, si se requiere tener un conjunto de vectores de diferente tipo, que representen a algún ente, se puede crear de la siguiente manera.

TYPE ente_num
   REAL,    DIMENSION(:), POINTER :: a
   INTEGER, DIMENSION(:), POINTER :: b
END TYPE ente_num

Y para usarlo, hay que asignarle memoria a los elementos que conforman al tipo derivado.

Suponiendo que se define una variable llamada un_ente_numerico

TYPE(ente_num)::un_ente_numerico

a éste se le ha de asignar memoria a cada elemento antes de poder usarlo:

ALLOCATE(un_ente_numerico%a(30))
ALLOCATE(un_ente_numerico%b(15))

es decir, ahora se tiene una variable compuesta por dos vectores, uno de longitud 30 de valores reales, y otro de 15 conformado por elementos enteros.