6.1.20 STRUCTURE and RECORD
Record structures are a pre-Fortran-90 vendor extension to create user-defined aggregate data types. Support for record structures in GNU Fortran can be enabled with the -fdec-structure compile flag. If you have a choice, you should instead use Fortran 90’s “derived types”, which have a different syntax.
In many cases, record structures can easily be converted to derived types. To convert, replace STRUCTURE /
structure-name/
by TYPE
type-name. Additionally, replace RECORD /
structure-name/
by TYPE(
type-name)
. Finally, in the component access, replace the period (.
) by the percent sign (%
).
Here is an example of code using the non portable record structure syntax:
! Declaring a structure named ``item'' and containing three fields: ! an integer ID, an description string and a floating-point price. STRUCTURE /item/ INTEGER id CHARACTER(LEN=200) description REAL price END STRUCTURE ! Define two variables, an single record of type ``item'' ! named ``pear'', and an array of items named ``store_catalog'' RECORD /item/ pear, store_catalog(100) ! We can directly access the fields of both variables pear.id = 92316 pear.description = "juicy D'Anjou pear" pear.price = 0.15 store_catalog(7).id = 7831 store_catalog(7).description = "milk bottle" store_catalog(7).price = 1.2 ! We can also manipulate the whole structure store_catalog(12) = pear print *, store_catalog(12)
This code can easily be rewritten in the Fortran 90 syntax as following:
! ``STRUCTURE /name/ ... END STRUCTURE'' becomes ! ``TYPE name ... END TYPE'' TYPE item INTEGER id CHARACTER(LEN=200) description REAL price END TYPE ! ``RECORD /name/ variable'' becomes ``TYPE(name) variable'' TYPE(item) pear, store_catalog(100) ! Instead of using a dot (.) to access fields of a record, the ! standard syntax uses a percent sign (%) pear%id = 92316 pear%description = "juicy D'Anjou pear" pear%price = 0.15 store_catalog(7)%id = 7831 store_catalog(7)%description = "milk bottle" store_catalog(7)%price = 1.2 ! Assignments of a whole variable do not change store_catalog(12) = pear print *, store_catalog(12)
GNU Fortran implements STRUCTURES like derived types with the following rules and exceptions:
- Structures act like derived types with the
SEQUENCE
attribute. Otherwise they may contain no specifiers. - Structures may contain a special field with the name
%FILL
. This will create an anonymous component which cannot be accessed but occupies space just as if a component of the same type was declared in its place, useful for alignment purposes. As an example, the following structure will consist of at least sixteen bytes:structure /padded/ character(4) start character(8) %FILL character(4) end end structure
- Structures may share names with other symbols. For example, the following is invalid for derived types, but valid for structures:
structure /header/ ! ... end structure record /header/ header
- Structure types may be declared nested within another parent structure. The syntax is:
structure /type-name/ ... structure [/<type-name>/] <field-list> ...
The type name may be ommitted, in which case the structure type itself is anonymous, and other structures of the same type cannot be instantiated. The following shows some examples:
structure /appointment/ ! nested structure definition: app_time is an array of two 'time' structure /time/ app_time (2) integer(1) hour, minute end structure character(10) memo end structure ! The 'time' structure is still usable record /time/ now now = time(5, 30) ... structure /appointment/ ! anonymous nested structure definition structure start, end integer(1) hour, minute end structure character(10) memo end structure
- Structures may contain
UNION
blocks. For more detail see the section on UNION and MAP. - Structures support old-style initialization of components, like those described in Old-style variable initialization. For array initializers, an initializer may contain a repeat specification of the form
<literal-integer> * <constant-initializer>
. The value of the integer indicates the number of times to repeat the constant initializer when expanding the initializer list.
Next: UNION and MAP, Previous: Read/Write after EOF marker, Up: Extensions implemented in GNU Fortran [Contents][Index]
© Free Software Foundation
Licensed under the GNU Free Documentation License, Version 1.3.
https://gcc.gnu.org/onlinedocs/gcc-8.4.0/gfortran/STRUCTURE-and-RECORD.html