S.wales at 05:29, 18 March 2019

2019-03-18T05:29:16Z

ScottWales: Imported from Wikispaces

2012-12-20T05:38:51Z

Imported from Wikispaces

New page

=Classes=

Object classes are declared with the 'TYPE' keyword. This declares a class 'object' in the module 'cms_object':
<syntaxhighlight lang=fortran>
module cms_object
implicit none
type object
! ...
end type
end module
</syntaxhighlight>

To create an object of that class use 'TYPE()'
<syntaxhighlight lang=fortran>
program foo
use cms_object, only: object
type(object) :: bar
end program
</syntaxhighlight>

=Member variables=

Objects can have their own internal variables
<syntaxhighlight lang=fortran>
module cms_object
implicit none
type object
integer :: foo
real(kind=8),dimension(:),allocatable :: bar
end type
end module
</syntaxhighlight>

Variables are accessed using the '%' operator
<syntaxhighlight lang=fortran>
program foo
use cms_object, only: object
type(object) :: bar

bar%foo = 5

allocate(bar%bar(5))
bar%bar(1) = 4.9
deallocate(bar%bar)
end program
</syntaxhighlight>

=Destructors=

If an object has an 'ALLOCATABLE' variable that variable will need to be freed once you're done with it. This can be done automatically using a destructor, which will be run on the object when it goes out of scope (e.g. at the end of a function)
<syntaxhighlight lang=fortran>
module cms_object
implicit none
type object
integer :: foo
real(kind=8),dimension(:),allocatable :: bar
contains
final :: delete_object
end type
contains
subroutine delete_object(this)
type(object) :: this
if (allocated(this%bar)) then
deallocate(this%bar)
end if
end subroutine
end module
</syntaxhighlight>

The destructor can be named anything you wish, although it will be helpful to have a unique name for each object's destructor once we get to inheritance. The destructor is run automatically like

<syntaxhighlight lang=fortran>
program foo
use cms_object, only: object
type(object) :: bar

bar%foo = 5

allocate(bar%bar(5))
bar%bar(1) = 4.9

! bar is about to go out of scope at the end of the function
! The compiler automatically inserts 'call delete_object(bar)'
end program
</syntaxhighlight>

=Constructors=

Constructors are the opposite of destructors, they are run create an object. A constructor is a function or interface with the same name as the object's type

<syntaxhighlight lang=fortran>
module cms_object
implicit none
type object
integer :: foo
real(kind=8),dimension(:),allocatable :: bar
contains
final :: delete_object
end type

interface object
procedure :: constructFromCount
procedure :: constructFromArray
end interface
contains
subroutine delete_object(this)
! ...
end subroutine

function constructFromCount(count) result(this)
type(object) :: this
integer, intent(in) :: count
allocate(this%bar(count))
end function
function constructFromArray(array) result(this)
type(object) :: this
real(kind=8), dimension(:), intent(in) :: array
allocate(this%bar(size(array)))
this%bar = array
end function
end module
</syntaxhighlight>

You call the constructor as if it were a function to initialise the object

<syntaxhighlight lang=fortran>
program foo
use cms_object, only: object
type(object) :: bar

bar = object(5)
write(*,*) size(bar%bar)
end program
</syntaxhighlight>

Now the array will be both created and destroyed automatically.

=Object functions=

You can add functions to an object by adding to its interface. When the function is called with the '%' operator the object to the left of the % will be passed as the function's first argument (similar to Python)

<syntaxhighlight lang=fortran>
module cms_object
implicit none
type object
integer :: foo
real(kind=8),dimension(:),allocatable :: bar
contains
final :: delete_object
procedure :: increment
end type

interface object
procedure :: constructFromCount
procedure :: constructFromArray
end interface
contains
! ...

subroutine increment(this, value)
type(object) :: this
integer :: value

this%bar = this%bar + 1
end subroutine
end module

program foo
use cms_object
type(object) :: bar

bar = object(5)

! Really runs 'call increment(bar,2)'
call bar%increment(2)
end program
</syntaxhighlight>

=Assignment operator=

If you want to be able to convert between types you can define assignment operators for the class. You will also need to define a custom assignment if the class contains allocatable arrays. These are defined in a module interface

<syntaxhighlight lang=fortran>
module cms_object
implicit none
type object
! ...
end type
! ...
interface assignment(=)
procedure :: assignFromObject
procedure :: assignFromArray
end interface
contains
! ...
subroutine assignFromObject(this,other)
class(object),intent(inout) :: this
class(object),intent(in) :: other
allocate(this%bar(size(other%bar)))
this%foo = other%foo
this%bar = other%bar
end subroutine
subroutine assignFromArray(this,other)
class(object),intent(inout) :: this
real(kind=8),dimension(:),intent(in) :: other
allocate(this%bar(size(other)))
this%foo = 12
this%bar = other
end subroutine
end module
program foo
use cms_object
type(object) :: a,b,c
real(kind=8),dimension(5) array

a = object(5)
b = a
c = array
end program
</syntaxhighlight>

=Other operators=

You can also define operators that work on your class, either normal ones like .not., .and. &c or your own custom ones. To do this you add an operator interface to the module

<syntaxhighlight lang=fortran>
module cms_object
implicit none
type object
! ...
end type
! ...
interface operator(.eq.)
procedure :: equalsObject
end interface
interface operator(.foo.)
procedure :: fooObject
end interface
contains
! ...
function equalsObject(lhs,rhs) return(equal)
type(object), intent(in) :: lhs,rhs
logical :: equal
equal = (lhs%foo .eq. rhs%foo) .and. (lhs%bar .eq. rhs%bar)
end function
function fooObject(rhs) return(foo)
type(object),intent(in) :: rhs
integer :: foo
foo = rhs%foo
end function
end module
program foo
use cms_object
type(object) :: a,b
logical :: equal
integer :: foo

equal = a .eq. b
foo = .foo. b
end program
</syntaxhighlight>

Operators can either be unary (like .not.) or binary (like .and.). The number of arguments to the function decides which it is.

= Full Example =

You can find an example of a full object [https://github.com/ScottWales/sawlibf/blob/master/src/lib/sawlibf/string.f90 | here]. It provides a 'string' class, which handles automatic allocation and deallocation of character strings, as well as some utilities for converting between strings and character arrays.

Some things to note:

* The module name is prepended with the name of the library it is part of. This helps to avoid name collisions between different libaries
* The default access level for the module is private, meaning functions cannot be called directly unless that's explicitly permitted. This is handy when there's a lot of interface functions, you can allow calling the interfaces by prohibit calling the actual implementation functions directly, again tidying up the namespace.
* The member variables of the class are private. This way the implementation details can be changed without having to change external code, for instance if you wanted to make identical strings use the same memory.
* The length variable is accessible through a member function, however the character data isn't, again so the memory layout could be changed easily. The only way to get the character data is through assigning the string to a character(len=*).
* The class uses dynamic memory, so contains a destructor and assignment operator
* Most of the class functions can use strings and character(*) interchangeably through the use of interfaces
* The class defines a .eq. operator for checking equality, as well as a custom .append. operator to concatenate strings.
* The functions made available by 'use sawlibf_string' are set to public. Since the 'length' function wasn't declared private in the class that is automatically exported. Also exported are the interfaces, so you can call .append. but not the implementation function appendString.

← Older revision		Revision as of 05:29, 18 March 2019
Line 277:		Line 277:
	* The class defines a .eq. operator for checking equality, as well as a custom .append. operator to concatenate strings.		* The class defines a .eq. operator for checking equality, as well as a custom .append. operator to concatenate strings.
	* The functions made available by 'use sawlibf_string' are set to public. Since the 'length' function wasn't declared private in the class that is automatically exported. Also exported are the interfaces, so you can call .append. but not the implementation function appendString.		* The functions made available by 'use sawlibf_string' are set to public. Since the 'length' function wasn't declared private in the class that is automatically exported. Also exported are the interfaces, so you can call .append. but not the implementation function appendString.
		+
		+	[[Category: Fortran]]

Object-oriented Fortran - Revision history

S.wales at 05:29, 18 March 2019

ScottWales: Imported from Wikispaces