Derived types

Defining a derived type

The format for defining a derived type is:

TYPE [[, access-spec] ::] type-name

 [private-sequence-statement] ...

 comp-definition-statement

 [comp-definition-statement] ...

END TYPE [type-name]

Sequence derived type

As shown in “Defining a derived type”, the SEQUENCE statement may appear in the definition of a derived type. When storage for a variable of derived type is allocated, the presence of the SEQUENCE statement in the definition of the derived type causes the compiler to arrange all components in a storage sequence that is the same as the order in which they are defined. Such a derived type is called a sequence derived type.

A sequence derived type may appear in a common block or in an equivalence set. The Standard makes requirements about the type—numeric or character—of the components in a sequence type. As an extension, HP Fortran makes no restrictions on the types of the components other than that the definition of the derived type must include the SEQUENCE statement.

Structure component

A component of a derived-type object may be referenced and used like any other variable—in an expression, on the lefthand side of an assignment statement, or as procedure argument. It may be a scalar, an array, or itself a derived-type object. The component name has the same scope as the derived-type object in which it is declared.

To reference a structure component, use the form:

parent-name[%comp-name]...%comp-name

If parent-name and comp-name are arrays, each can be followed by a section-subscript-list enclosed in parentheses. See “Array sections” for information about the syntax of section-subscript-list. The Standard imposes certain restrictions on structure component references that are array-valued, as described in “Array-valued structure component references”.

If the definition of a derived type contains a component that is of the same derived type, the component must have the POINTER attribute. The following example defines the derived type node, which includes a component (next) of the same derived type:

TYPE node  ! for use in a singly linked list
  INTEGER :: value
  TYPE(node), POINTER :: next  ! must have the POINTER attribute
END TYPE node

Declaring a derived type-object

To declare an object of derived type, use the TYPE statement, as follows:

TYPE (type-name) [[, attrib-list] :: ] entity-list

where type-name, attrib-list, and entity-list all have the same meaning as in a type declaration statement that is used to declare an object of an intrinsic type; see “Type declaration for intrinsic types”.

Structure constructor

A structure constructor constructs a scalar value of derived type. The value is constructed of a sequence of values for each component of the type. The syntax of a structure constructor is:

type-name ( expression-list )

The following restrictions apply to the use of the structure constructor:

Alignment of derived-type objects

Derived type objects have the same alignment as the component that has the most restrictive alignment requirement. (This rule also applies to records.) To ensure natural alignment, the compiler may add padding to each element in an array of derived type.

The following illustrates the alignment of an array of derived type. The definition of the derived type includes the SEQUENCE statement to ensure the order in which components are laid out in memory is the same as in the definition. The SEQUENCE statement has no effect on alignment:

! definition of a derived type
TYPE t
   SEQUENCE
   CHARACTER(LEN=7) :: c
   INTEGER(2) :: i2
   REAL(8) :: r8
   REAL(4) :: r4
END TYPE t
 
! declaration of an array variable of derived type
TYPE (t), DIMENSION(5) :: ta

Each element of t is allocated storage as shown in Table 5-4 “Example of structure storage”. The first component of t starts at an address that is a multiple of 8. The four trailing padding bytes are necessary to preserve the alignment of r8 in each element of the array.

A derived-type example

The example below, traffic.f90, illustrates how to define a derived type, declare a variable of the type, specify a value for the variable using the structure constructor, pass the variable as an argument to another procedure, and reference a structure component. The derived type is defined in a module so that it can be made accessible by use association.

For more information about modules and the USE statement, see “Modules”. The MODULE and USE statements are also described in Chapter 10.

Example 5-3 traffic.f90

PROGRAM traffic ! Illustrates derived types: defines a derived type, declares an ! to array variable of derived type, uses a structure constructor ! assign to its components, and passes a component which is ! itself another derived type to a subprogram. ! Make the definition of the derived type called hours accessible ! to this program unit USE hours_def LOGICAL :: busy INTEGER :: choice ! Define another derived type that uses hours as a component TYPE hiway INTEGER :: rte_num TYPE(hours) :: busy_hours END TYPE hiway ! Declare an array of derived-type structures. TYPE(hiway), DIMENSION(3) :: route ! Use the structure constructor to specify values for each ! element of route route(1) = hiway(128, hours(.TRUE., .FALSE.)) route(2) = hiway(93, hours(.FALSE., .TRUE.)) route(3) = hiway(97, hours(.FALSE., .FALSE.)) PRINT *, 'What road do you want to travel?'PRINT *, '1. Rte. 128' PRINT *, '2. Rte. 93' PRINT *, '3. Rte 97' READ *, choice ! Pass the busy_hours component of the selected route to ! the function busy. IF (busy(route(choice)%busy_hours)) THEN PRINT *,’Heavy commute on rte.’, route(choice)%rte_num ELSE PRINT *,’Easy commute on rte.’, route(choice)%rte_num END IF END PROGRAM traffic LOGICAL FUNCTION busy(when) ! This function accepts a derived-type argument whose definition ! is defined in the module hours_def, made accessible here by ! use association. It returns .TRUE. or .FALSE., depending on ! on the value of the user-selected component of the argument. ! Make the definition of hours accessible to this function. USE hours_def TYPE(hours) :: when INTEGER :: choice PRINT *, 'When do you want to commute:' PRINT *, '1. Morning' PRINT *, '2. Evening' READ *, choice ! Find out if the route is busy at that time of day. IF (choice .EQ. 1) THEN busy = when%am ELSE busy = when%pm END IF END FUNCTION busy MODULE hours_def ! Define a derived type, which will be passed as an argument. TYPE hours LOGICAL :: am LOGICAL :: pm END TYPE hours END MODULE hours_def

Here are the command lines to compile and execute the program, along with the output from a sample run:

$ f90 traffic.f90
$ a.out
 What road do you want to travel?
 1. Rte. 128
 2. Rte. 93
 3. Rte 97
1
 When do you want to commute:
 1. Morning
 2. Evening
1
 Heavy commute on rte. 128