El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Mòduls i Interfícies

Següent ►
►

En aquest mòdul, explorarem els mòduls i les interfícies en Fortran, que són eines poderoses per organitzar i modularitzar el codi. Els mòduls permeten agrupar dades i subrutines relacionades, mentre que les interfícies proporcionen una manera de definir com es poden cridar les subrutines i funcions.

Continguts

  1. Introducció als Mòduls
  2. Creació i Ús de Mòduls
  3. Interfícies
  4. Exemples Pràctics
  5. Exercicis

Introducció als Mòduls

Els mòduls en Fortran són blocs de codi que poden contenir dades, subrutines, funcions i altres mòduls. Són útils per organitzar el codi en components reutilitzables i per compartir dades entre diferents parts del programa.

Beneficis dels Mòduls

  • Reutilització del Codi: Permeten agrupar funcionalitats relacionades que es poden reutilitzar en diferents parts del programa.
  • Encapsulació: Permeten ocultar la implementació interna i exposar només les interfícies necessàries.
  • Mantenibilitat: Faciliten la gestió i l'actualització del codi.

Creació i Ús de Mòduls

Definició d'un Mòdul

Un mòdul es defineix amb la paraula clau module i es tanca amb end module. Aquí teniu un exemple bàsic:

module math_operations
  implicit none
  contains
    function add(a, b)
      integer :: add
      integer, intent(in) :: a, b
      add = a + b
    end function add

    function subtract(a, b)
      integer :: subtract
      integer, intent(in) :: a, b
      subtract = a - b
    end function subtract
end module math_operations

Ús d'un Mòdul

Per utilitzar un mòdul en un programa o en un altre mòdul, es fa servir la paraula clau use:

program main
  use math_operations
  implicit none
  integer :: result

  result = add(5, 3)
  print *, "5 + 3 =", result

  result = subtract(5, 3)
  print *, "5 - 3 =", result
end program main

Interfícies

Les interfícies en Fortran permeten definir com es poden cridar les subrutines i funcions. Això és especialment útil per a subrutines i funcions externes o per a sobrecarregar operadors.

Definició d'una Interfície

Una interfície es defineix amb la paraula clau interface i es tanca amb end interface. Aquí teniu un exemple:

module math_operations
  implicit none
  interface
    function add(a, b)
      integer :: add
      integer, intent(in) :: a, b
    end function add

    function subtract(a, b)
      integer :: subtract
      integer, intent(in) :: a, b
    end function subtract
  end interface
end module math_operations

Ús d'una Interfície

Les interfícies es poden utilitzar per definir subrutines i funcions externes o per sobrecarregar operadors. Aquí teniu un exemple de sobrecàrrega d'operadors:

module math_operations
  implicit none
  interface operator(+)
    function add(a, b)
      integer :: add
      integer, intent(in) :: a, b
    end function add
  end interface
contains
  function add(a, b)
    integer :: add
    integer, intent(in) :: a, b
    add = a + b
  end function add
end module math_operations

Exemples Pràctics

Exemple 1: Mòdul amb Funcions Matemàtiques

module math_operations
  implicit none
  contains
    function add(a, b)
      integer :: add
      integer, intent(in) :: a, b
      add = a + b
    end function add

    function subtract(a, b)
      integer :: subtract
      integer, intent(in) :: a, b
      subtract = a - b
    end function subtract
end module math_operations

program main
  use math_operations
  implicit none
  integer :: result

  result = add(10, 5)
  print *, "10 + 5 =", result

  result = subtract(10, 5)
  print *, "10 - 5 =", result
end program main

Exemple 2: Interfície per a Funcions Externes

module external_functions
  implicit none
  interface
    function external_add(a, b)
      integer :: external_add
      integer, intent(in) :: a, b
    end function external_add
  end interface
end module external_functions

program main
  use external_functions
  implicit none
  integer :: result

  result = external_add(7, 3)
  print *, "7 + 3 =", result
end program main

Exercicis

Exercici 1: Crear un Mòdul

Descripció: Crea un mòdul anomenat geometry que contingui funcions per calcular l'àrea d'un cercle i d'un rectangle.

Solució:

module geometry
  implicit none
  contains
    function circle_area(radius)
      real :: circle_area
      real, intent(in) :: radius
      circle_area = 3.14159 * radius * radius
    end function circle_area

    function rectangle_area(length, width)
      real :: rectangle_area
      real, intent(in) :: length, width
      rectangle_area = length * width
    end function rectangle_area
end module geometry

program main
  use geometry
  implicit none
  real :: area

  area = circle_area(5.0)
  print *, "Area of circle with radius 5.0 =", area

  area = rectangle_area(4.0, 6.0)
  print *, "Area of rectangle with length 4.0 and width 6.0 =", area
end program main

Exercici 2: Crear una Interfície

Descripció: Crea una interfície per a una funció externa que calculi el producte de dos nombres enters.

Solució:

module external_functions
  implicit none
  interface
    function external_multiply(a, b)
      integer :: external_multiply
      integer, intent(in) :: a, b
    end function external_multiply
  end interface
end module external_functions

program main
  use external_functions
  implicit none
  integer :: result

  result = external_multiply(4, 5)
  print *, "4 * 5 =", result
end program main

Conclusió

En aquest mòdul, hem après sobre els mòduls i les interfícies en Fortran. Els mòduls ens permeten organitzar el codi en components reutilitzables, mentre que les interfícies ens ajuden a definir com es poden cridar les subrutines i funcions. Hem vist exemples pràctics i hem realitzat exercicis per reforçar els conceptes apresos. En el proper mòdul, explorarem la sobrecàrrega d'operadors i altres temes avançats.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats