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

Escrivint Codi Mantenible

Següent ►
►

En aquest tema, explorarem les millors pràctiques per escriure codi Fortran que sigui fàcil de mantenir, llegir i modificar. La mantenibilitat del codi és crucial per assegurar que els projectes a llarg termini siguin sostenibles i que altres desenvolupadors puguin treballar-hi sense dificultats.

  1. Importància del Codi Mantenible

Per què és important?

  • Facilitat de Lectura: El codi clar i ben documentat és més fàcil de llegir i entendre.
  • Facilitat de Modificació: El codi ben estructurat permet fer canvis i afegir noves funcionalitats amb menys risc d'introduir errors.
  • Col·laboració: Facilita el treball en equip, ja que altres desenvolupadors poden comprendre i contribuir al projecte més fàcilment.
  • Depuració i Manteniment: Redueix el temps necessari per trobar i corregir errors.

  1. Bones Pràctiques per Escriure Codi Mantenible

2.1. Nomenclatura Clara i Consistent

  • Variables: Utilitza noms de variables descriptius que reflecteixin el seu propòsit. 
    ! Evita noms com a, b, c
integer :: num_students
real :: average_score
  • Subrutines i Funcions: Els noms han de descriure clarament l'acció que realitzen. 
    subroutine calculate_average_score()
function is_prime(number) result(is_prime_flag)

2.2. Comentaris i Documentació

  • Comentaris: Escriu comentaris que expliquin el propòsit del codi, especialment en parts complexes. 
    ! Calcula la mitjana de les puntuacions dels estudiants
average_score = total_score / num_students
  • Documentació: Proporciona documentació detallada per a cada subrutina i funció. 
    !-----------------------------------------------------------------
! Subroutine: calculate_average_score
! Purpose: Calculate the average score of students
! Inputs: total_score (real), num_students (integer)
! Outputs: average_score (real)
!-----------------------------------------------------------------

2.3. Estructura i Organització del Codi

  • Modularització: Divideix el codi en mòduls, subrutines i funcions per a una millor organització. 
    module math_operations
  contains
    subroutine calculate_average_score()
    function is_prime(number) result(is_prime_flag)
  end subroutine calculate_average_score
  end function is_prime
end module math_operations
  • Indentació: Utilitza una indentació consistent per millorar la llegibilitat. 
    if (num_students > 0) then
  average_score = total_score / num_students
else
  average_score = 0.0
end if

2.4. Evitar la Repetició de Codi

  • Reutilització: Utilitza subrutines i funcions per evitar la duplicació de codi. 
    call calculate_average_score(total_score, num_students, average_score)

2.5. Gestió d'Errors

  • Comprovacions: Implementa comprovacions d'errors i gestiona les excepcions adequadament. 
    if (num_students <= 0) then
  print *, "Error: El nombre d'estudiants ha de ser positiu."
  stop
end if

  1. Exercicis Pràctics

Exercici 1: Refactorització de Codi

Refactoritza el següent codi per fer-lo més mantenible:

program main
  integer :: a, b, c
  a = 10
  b = 20
  c = a + b
  print *, "La suma és: ", c
end program main

Solució:

program main
  integer :: num1, num2, sum

  ! Assigna valors a les variables
  num1 = 10
  num2 = 20

  ! Calcula la suma
  call calculate_sum(num1, num2, sum)

  ! Mostra el resultat
  print *, "La suma és: ", sum
end program main

! Subrutina per calcular la suma de dos nombres
subroutine calculate_sum(a, b, result)
  integer, intent(in) :: a, b
  integer, intent(out) :: result

  result = a + b
end subroutine calculate_sum

Exercici 2: Documentació de Subrutines

Documenta la següent subrutina:

subroutine multiply(a, b, result)
  integer, intent(in) :: a, b
  integer, intent(out) :: result

  result = a * b
end subroutine multiply

Solució:

!-----------------------------------------------------------------
! Subroutine: multiply
! Purpose: Multiply two integers
! Inputs: a (integer), b (integer)
! Outputs: result (integer)
!-----------------------------------------------------------------
subroutine multiply(a, b, result)
  integer, intent(in) :: a, b
  integer, intent(out) :: result

  result = a * b
end subroutine multiply

  1. Resum

En aquesta secció, hem après la importància d'escriure codi mantenible i hem explorat diverses bones pràctiques per aconseguir-ho. Hem vist com utilitzar una nomenclatura clara, comentar i documentar el codi, estructurar-lo adequadament, evitar la repetició i gestionar errors. A més, hem practicat aquestes tècniques amb exercicis pràctics. Seguint aquestes directrius, podràs escriure codi Fortran que sigui fàcil de mantenir i comprendre, tant per a tu com per a altres desenvolupadors.

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