The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Passing Arguments

Next ►
►

In Fortran, passing arguments to subroutines and functions is a fundamental concept that allows for modular and reusable code. This section will cover the different ways to pass arguments, including by value and by reference, and will provide practical examples to illustrate these concepts.

Key Concepts

  1. Argument Passing Methods:

    • By Reference: The default method in Fortran, where the subroutine or function can modify the actual variable.
    • By Value: A method where a copy of the variable is passed, and modifications do not affect the original variable.

  2. Intent Attribute:

    • IN: The argument is read-only within the subroutine or function.
    • OUT: The argument is write-only and is intended to return a value.
    • INOUT: The argument can be read and modified within the subroutine or function.

  3. Explicit Interfaces: Ensuring that the subroutine or function interface is known at compile time, which helps in checking the correctness of argument types and attributes.

Practical Examples

Example 1: Passing Arguments by Reference

By default, Fortran passes arguments by reference. This means that any changes made to the arguments within the subroutine or function will affect the original variables.

program main
    implicit none
    integer :: a, b

    a = 5
    b = 10

    call swap(a, b)

    print *, "After swap: a =", a, ", b =", b
end program main

subroutine swap(x, y)
    integer, intent(inout) :: x, y
    integer :: temp

    temp = x
    x = y
    y = temp
end subroutine swap

Explanation:

  • The swap subroutine takes two integer arguments x and y with the intent(inout) attribute, meaning they can be read and modified.
  • The values of a and b are swapped within the subroutine, and the changes are reflected in the main program.

Example 2: Passing Arguments by Value

Fortran does not natively support passing arguments by value, but this can be simulated using the value attribute in Fortran 2003 and later.

program main
    implicit none
    integer :: a

    a = 5

    call increment(a)

    print *, "After increment: a =", a
end program main

subroutine increment(x)
    integer, value :: x

    x = x + 1
    print *, "Inside subroutine: x =", x
end subroutine increment

Explanation:

  • The increment subroutine takes an integer argument x with the value attribute, meaning a copy of a is passed.
  • The modification to x inside the subroutine does not affect the original variable a in the main program.

Example 3: Using Intent Attributes

Using intent attributes helps in understanding the purpose of each argument and can prevent unintended modifications.

program main
    implicit none
    integer :: a, b, result

    a = 5
    b = 10

    call add(a, b, result)

    print *, "Result of addition: ", result
end program main

subroutine add(x, y, sum)
    integer, intent(in) :: x, y
    integer, intent(out) :: sum

    sum = x + y
end subroutine add

Explanation:

  • The add subroutine takes two input arguments x and y with the intent(in) attribute, meaning they are read-only.
  • The result is stored in sum, which has the intent(out) attribute, meaning it is write-only and used to return the result.

Practical Exercises

Exercise 1: Modify a Subroutine to Use Intent Attributes

Task: Modify the following subroutine to use appropriate intent attributes.

subroutine multiply(x, y, product)
    integer :: x, y, product

    product = x * y
end subroutine multiply

Solution:

subroutine multiply(x, y, product)
    integer, intent(in) :: x, y
    integer, intent(out) :: product

    product = x * y
end subroutine multiply

Exercise 2: Create a Subroutine to Calculate the Factorial

Task: Write a subroutine that calculates the factorial of a given integer using recursion. Use appropriate intent attributes.

Solution:

program main
    implicit none
    integer :: n, result

    n = 5
    call factorial(n, result)

    print *, "Factorial of ", n, " is ", result
end program main

subroutine factorial(n, result)
    integer, intent(in) :: n
    integer, intent(out) :: result

    if (n <= 1) then
        result = 1
    else
        call factorial(n-1, result)
        result = n * result
    end if
end subroutine factorial

Explanation:

  • The factorial subroutine uses recursion to calculate the factorial of n.
  • The intent(in) attribute is used for n as it is read-only, and intent(out) is used for result to return the calculated factorial.

Common Mistakes and Tips

  • Forgetting Intent Attributes: Always specify intent attributes to avoid unintended modifications and to make the code more readable.
  • Mismatched Argument Types: Ensure that the types of arguments in the subroutine or function match those in the calling program.
  • Uninitialized Variables: Be cautious of uninitialized variables, especially when using intent(out).

Conclusion

In this section, we covered the basics of passing arguments in Fortran, including the default method of passing by reference, simulating passing by value, and using intent attributes to clarify the purpose of arguments. Understanding these concepts is crucial for writing modular and maintainable Fortran code. In the next section, we will delve into the scope and lifetime of variables, which will further enhance your understanding of how data is managed in Fortran programs.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved