Ich versuche, eine Routine zu schreiben, mit der eine Zeichenfolge basierend auf unbegrenztem Polymorphismus in verschiedene Datentypen konvertiert werden kann. Die Idee ist, dass der Benutzer diese Routine aufruft, indem er die Variable an die Stelle weitergibt, an der die Daten gespeichert werden sollen, und die Routine, um die Konvertierung basierend auf dem Variablen- / Argumenttyp zu definieren.

Ein Auszug dieser Routine ist hier:

subroutine GetAsScalar (this, value, status)
    !Arguments-------------------------------------------------------------
    class(TKeyword)                                 ::  this
    class(*)                                        ::  value
    logical, optional                               ::  status

    !Local-----------------------------------------------------------------
    integer                                         ::  stat        

    !----------------------------------------------------------------------  

    stat = 0

    select type (value)
    type is (REAL(real32))      !single precision
        read (this%fValue, *, IOSTAT = stat) value           
    type is (REAL(real64))      !double precision
        read (this%fValue, *, IOSTAT = stat) value
    type is (LOGICAL)
        read (this%fValue, *, IOSTAT = stat) value
    type is (INTEGER(int32))    !integer
        read (this%fValue, *, IOSTAT = stat) value
    type is (INTEGER(int64))    !long integer
        read (this%fValue, *, IOSTAT = stat) value
    type is (CHARACTER(*))
        value = this%fValue
    class default            
        this%Message = "Invalid data type"
        status = .false.
        return
    end select

    if (present (status)) then
        if (stat /= 0) then
            status = .false.
        else                    
            status = .true.
        endif
    endif

end subroutine GetAsScalar

"this% fValue" ist ein "Zeichen (len = :), zuweisbarer" String. Wenn ich versuche, diese Routine zu verwenden, die eine zuweisbare Zeichenfolge übergibt, wird sie mit Erfolg beendet, es werden keine Fehler / Ausnahmen ausgelöst:

character(len=:), allocatable :: value
call keyword%GetAsScalar(value)

Aber der String "value" ist immer leer. Auch innerhalb der Routine ist der Wert nach der Zuweisung von "value = this% fValue" leer (len (value) ist 0).

Es scheint, dass der Compiler nicht erkennen kann, dass das Argument vom Typ Zeichen ist (len = :), zuweisbar, und daher den Wert nicht zuweisen kann.

Natürlich habe ich einige Alternativen, aber die Idee, einen einzelnen Berg und ohne optionale Argumente für verschiedene Arten von Daten zu verwenden, ist wirklich schön.

Ich kann einen benutzerdefinierten Typ verwenden, den ich erstellt habe, um beispielsweise Zeichenfolgen zu verarbeiten.

Aber ich würde gerne wissen, ob dies das Standardverhalten in Fortran 2008 ist. Und wenn es eine Möglichkeit gibt, dies mithilfe dieser Routine mit einem einzelnen "class (*)" - Dummy-Argument zu erreichen, um verschiedene Typen zu konvertieren, einschließlich das zugewiesene zuweisbare Zeichen. Es gibt eine Möglichkeit, die Zuweisung innerhalb der Routine zu erzwingen, zum Beispiel?

Ich freue mich über eure Kommentare. Prost, Eduardo