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

Sobrecàrrega d'Operadors

Següent ►
►

La sobrecàrrega d'operadors és una característica poderosa en Fortran que permet definir o redefinir el comportament dels operadors per a tipus de dades definits per l'usuari. Això pot fer que el codi sigui més llegible i natural, especialment quan es treballa amb tipus de dades complexos.

Conceptes Clau

  1. Definició d'Operadors: En Fortran, es poden sobrecarregar operadors aritmètics, lògics i de comparació.
  2. Tipus Derivats: La sobrecàrrega d'operadors s'utilitza sovint amb tipus derivats (tipus definits per l'usuari).
  3. Interfícies: Les interfícies són necessàries per declarar la sobrecàrrega d'operadors.

Exemples Pràctics

Exemple 1: Sobrecàrrega de l'Operador +

Suposem que tenim un tipus derivat vector i volem sobrecarregar l'operador + per sumar dos vectors.

module vector_operations
  implicit none
  private
  public :: vector, operator(+)

  type :: vector
    real :: x, y, z
  end type vector

  interface operator(+)
    module procedure add_vectors
  end interface

contains

  function add_vectors(v1, v2) result(v3)
    type(vector), intent(in) :: v1, v2
    type(vector) :: v3

    v3%x = v1%x + v2%x
    v3%y = v1%y + v2%y
    v3%z = v1%z + v2%z
  end function add_vectors

end module vector_operations

Explicació del Codi

  1. Definició del Mòdul: El mòdul vector_operations conté la definició del tipus vector i la sobrecàrrega de l'operador +.
  2. Tipus Derivat: El tipus vector té tres components reals: x, y i z.
  3. Interfície: La interfície operator(+) declara que la funció add_vectors s'utilitzarà per sobrecarregar l'operador +.
  4. Funció de Sobrecàrrega: La funció add_vectors suma els components corresponents de dos vectors i retorna el resultat.

Exemple 2: Sobrecàrrega de l'Operador ==

Ara, sobrecarregarem l'operador == per comparar dos vectors.

module vector_operations
  implicit none
  private
  public :: vector, operator(==)

  type :: vector
    real :: x, y, z
  end type vector

  interface operator(==)
    module procedure equal_vectors
  end interface

contains

  function equal_vectors(v1, v2) result(is_equal)
    type(vector), intent(in) :: v1, v2
    logical :: is_equal

    is_equal = (v1%x == v2%x) .and. (v1%y == v2%y) .and. (v1%z == v2%z)
  end function equal_vectors

end module vector_operations

Explicació del Codi

  1. Interfície: La interfície operator(==) declara que la funció equal_vectors s'utilitzarà per sobrecarregar l'operador ==.
  2. Funció de Sobrecàrrega: La funció equal_vectors compara els components corresponents de dos vectors i retorna true si tots els components són iguals, i false en cas contrari.

Exercicis Pràctics

Exercici 1: Sobrecàrrega de l'Operador *

Crea un mòdul que defineixi un tipus matrix i sobrecarregui l'operador * per multiplicar dues matrius.

Solució

module matrix_operations
  implicit none
  private
  public :: matrix, operator(*)

  type :: matrix
    real, dimension(:,:), allocatable :: elements
  end type matrix

  interface operator(*)
    module procedure multiply_matrices
  end interface

contains

  function multiply_matrices(m1, m2) result(m3)
    type(matrix), intent(in) :: m1, m2
    type(matrix) :: m3
    integer :: i, j, k
    integer :: n, m, p

    n = size(m1%elements, 1)
    m = size(m1%elements, 2)
    p = size(m2%elements, 2)

    allocate(m3%elements(n, p))

    m3%elements = 0.0
    do i = 1, n
      do j = 1, p
        do k = 1, m
          m3%elements(i, j) = m3%elements(i, j) + m1%elements(i, k) * m2%elements(k, j)
        end do
      end do
    end do
  end function multiply_matrices

end module matrix_operations

Explicació del Codi

  1. Tipus Derivat: El tipus matrix conté un array bidimensional elements.
  2. Interfície: La interfície operator(*) declara que la funció multiply_matrices s'utilitzarà per sobrecarregar l'operador *.
  3. Funció de Sobrecàrrega: La funció multiply_matrices realitza la multiplicació de matrius utilitzant el mètode clàssic de multiplicació de matrius.

Resum

La sobrecàrrega d'operadors en Fortran permet definir comportaments personalitzats per a operadors en tipus de dades definits per l'usuari. Això pot fer que el codi sigui més llegible i natural. Hem vist com sobrecarregar operadors aritmètics i de comparació, i hem practicat amb exercicis per reforçar els conceptes apresos.

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