Purpose
A TYPE type declaration statement specifies the type and attributes of objects and functions of derived type. Initial values can be assigned to objects.
Format
>>-TYPE--(--type_name--)--+-+----+----------------+------------->
| '-::-' |
'-,--attr_spec_list--::-'
>--entity_decl_list--------------------------------------------><
|
where:
|
attr_spec |
|---|
|
ALLOCATABLE AUTOMATIC DIMENSION (array_spec) EXTERNAL INTENT (intent_spec) INTRINSIC OPTIONAL PARAMETER POINTER PRIVATE PUBLIC SAVE STATIC TARGET VOLATILE |
or =>NULL()
appears as part of any entity_decl.
>>-a--+------------------+-------------------------------------->
'-(--array_spec--)-'
>--+-----------------------------------+-----------------------><
| (1) |
'-+-/--initial_value_list--/------+-'
+- = --initialization_expr------+
| (2) |
'- => --NULL()------------------'
Notes:
|
+-------------------------------IBM Extension--------------------------------+
+----------------------------End of IBM Extension----------------------------+
+---------------------------------Fortran 95---------------------------------+
+-----------------------------End of Fortran 95------------------------------+
Rules
+---------------------------------Fortran 95---------------------------------+
Within the context of a derived type definition:
If => appears for a variable, the object must have the POINTER attribute.
+-----------------------------End of Fortran 95------------------------------+
If initialization_expr appears for a variable, the object cannot have the POINTER attribute.
Entities in type declaration statements are constrained by the rules of any attributes specified for the entities, as detailed in the corresponding attribute statements.
Once a derived type has been defined, you can use it to define your data items using the TYPE type declaration statement. When an entity is explicitly declared to be of a derived type, that derived type must have been previously defined in the scoping unit or is accessible by use or host association.
The data object becomes an object of derived type or a structure. Each structure component is a subobject of the object of derived type.
If you specify the DIMENSION attribute, you are creating an array whose elements have a data type of that derived type.
Other than in specification statements, you can use objects of derived type as actual and dummy arguments, and they can also appear as items in input/output lists (unless the object has a component with the POINTER attribute), assignment statements, structure constructors, and the right side of a statement function definition. If a structure component is not accessible, a derived-type object cannot be used in an input/output list or as a structure constructor.
Objects of nonsequence derived type cannot be used as data items in EQUIVALENCE and COMMON statements. Objects of nonsequence data types cannot be integer pointees.
A nonsequence derived-type dummy argument must specify a derived type that is accessible through use or host association to ensure that the same derived-type definition defines both the actual and dummy arguments.
The type declaration statement overrides the implicit type rules in effect.
An object cannot be initialized in a type declaration statement if it is a
dummy argument, allocatable object, pointer, function result, object in blank common, integer pointer,
external name, intrinsic name, or automatic object. Nor can an object
be initialized if it has the AUTOMATIC attribute. The object
may be initialized if it appears in a named common block in a block data
program unit
or if it appears in a named common block in a module.
+---------------------------------Fortran 95---------------------------------+
In Fortran 95, a pointer can be initialized. Pointers can only be initialized by the use of => NULL().
+-----------------------------End of Fortran 95------------------------------+
The specification expression of an array_spec can be a nonconstant expression if the specification expression appears in an interface body or in the specification part of a subprogram. Any object being declared that uses this nonconstant expression and is not a dummy argument or a pointee is called an automatic object.
An attribute cannot be repeated in a given type declaration statement, nor can an entity be explicitly given the same attribute more than once in a scoping unit.
initialization_expr must be specified if the statement contains
the PARAMETER attribute. If the entity you are declaring is a
variable, and initialization_expr
or NULL()
is specified, the variable is initially defined.
+---------------------------------Fortran 95---------------------------------+
If the entity you are declaring is a derived type component, and initialization_expr or NULL() is specified, the derived type has default initialization.
+-----------------------------End of Fortran 95------------------------------+
a becomes defined with the value determined by
initialization_expr, in accordance with the rules for intrinsic
assignment. If the entity is an array, its shape must be specified
either in the type declaration statement or in a previous specification
statement in the same scoping unit. A variable or variable subobject
cannot be initialized more than once. If a is a variable, the
presence of initialization_expr
or NULL()
implies that a is a saved object, except for an object in a named
common block. The initialization of an object could affect the
fundamental storage class of an object.
An array_spec specified in the entity_decl takes precedence over the array_spec in the DIMENSION attribute.
An array function result that does not have the POINTER attribute must have an explicit-shape array specification.
If the entity declared is a function, it must not have an accessible explicit interface unless it is an intrinsic function. The derived type can be specified on the FUNCTION statement, provided the derived type is defined within the body of the function or is accessible via host or use association.
+-------------------------------IBM Extension--------------------------------+
If T or F, defined previously as the name of a constant, appears in a type declaration statement, it is no longer an abbreviated logical constant but the name of the named constant.
+----------------------------End of IBM Extension----------------------------+
TYPE PEOPLE ! Defining derived type PEOPLE INTEGER AGE CHARACTER*20 NAME END TYPE PEOPLE TYPE(PEOPLE) :: SMITH = PEOPLE(25,'John Smith') END
Related Information