subprogramas - declaración de clase fortran de argumento ficticio

guia fortran

Question

Me gustaría tener un tipo derivado, a , que está vacío. De este tipo derivado me gustaría definir más tipos que amplíen a. Supongamos que todas estas extensiones de tipo contienen algún nombre generic procedimiento, value , es decir, value => valuea1 , value => valuea2 , etc.

Si luego quiero pasar las variables de la clase a a algún otro procedimiento, necesito declarar el argumento ficticio relevante de ese procedimiento con la class(a) . Sin embargo, si hago esto, hacer referencia al value del argumento ficticio conduce a la falla de compilación porque la clase a está realmente vacía, solo las extensiones de tipo contienen el procedimiento.

Podría prescindir de esto teniendo algún procedimiento llamado value dentro de la definición de tipo de a (luego anulando en las extensiones). Sin embargo, dado que nunca quiero declarar ningún objeto con el tipo a, parece desordenado. Es posible evitar esto?

Answer 1

Sí, puede declarar un procedimiento enlazado por tipo incluso para un tipo abstract . Puede ser un procedimiento enlazado de tipo real, o simplemente una abstract interface .

type, abstract :: a
contains
procedure :: valuea1, valuea2
generic value :: value => valuea1, valuea2
end type
abstract interface
! the headers of valuea1, valuea2 here
! they should have a passed dummy argument class(a)
! and some other argument for the generic resolution
! for example:
subroutine valua1(self, x)
class(a), intent(in) :: self
real, intent(inout) :: x
end subroutine
subroutine valua2(self, x)
class(a), intent(in) :: self
integer, intent(inout) :: x
end subroutine
end interface

De esta forma, no puede crear variables de type(a) , pero puede crear tipos extendidos que implementen sus propias versiones de value .

Answer 2

Similar a la respuesta de @VladimirF, pero tomando su aclaración de que

Realmente no necesito la resolución genérica; valuea1 y valuea2 aceptan el mismo tipo de argumentos para el problema que tengo en mente, solo quiero vincularme a valuea1 en una extensión de tipo y a valuea2 en otra extensión de tipo.

Aquí, entonces, el tipo base (abstracto) define un value() procedimiento de límite de tipo diferido value() con una class(a) toma de interfaz class(a) como el argumento pasado. Se pueden agregar otros argumentos. Cada tipo de extensión define / anula este procedimiento de tipo vinculado con su propio procedimiento.

Esto significa que en nuestra test_sub subrutina final test_sub el argumento ficticio de class(a) tiene un %value() .

module types
! The base type
type, abstract :: a
contains
procedure(value_if), deferred :: value
end type a
! The interface for the type-bound procedures
abstract interface
subroutine value_if(var)
import a
class(a) var
end subroutine value_if
end interface
! The extending types, overriding the value subroutine
type, extends(a) :: a1
contains
procedure :: value => value_a1
end type a1
type, extends(a) :: a2
contains
procedure :: value => value_a2
end type a2
contains
subroutine value_a1(var)
class(a1) var
print*, "Value of a1"
end subroutine value_a1
subroutine value_a2(var)
class(a2) var
print*, "Value of a2"
end subroutine value_a2
end module types
program test
use types
type(a1) x
type(a2) y
call x%value
call y%value
call test_sub(x)
call test_sub(y)
contains
subroutine test_sub(var)
class(a) var
call var%value ! This is defined
end subroutine test_sub
end program test

Esto produce salida

Valor de a1
Valor de a2
Valor de a1
Valor de a2