El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Punteros

Siguiente ►
►

Introducción

Los punteros son una característica avanzada en Fortran que permite a los programadores manejar la memoria de manera más flexible y eficiente. Un puntero es una variable que almacena la dirección de otra variable. Esto puede ser útil para crear estructuras de datos dinámicas, como listas enlazadas, y para optimizar el uso de la memoria.

Conceptos Clave

  1. Declaración de Punteros: Cómo declarar punteros en Fortran.
  2. Asignación de Punteros: Cómo asignar punteros a variables y estructuras.
  3. Operaciones con Punteros: Cómo realizar operaciones básicas con punteros.
  4. Punteros y Arreglos: Uso de punteros con arreglos.
  5. Punteros y Subrutinas: Pasar punteros a subrutinas y funciones.

Declaración de Punteros

Para declarar un puntero en Fortran, se utiliza la palabra clave pointer. Aquí hay un ejemplo básico:

integer, pointer :: ptr

En este ejemplo, ptr es un puntero a una variable de tipo entero.

Asignación de Punteros

Para asignar un puntero a una variable, se utiliza la palabra clave target. Aquí hay un ejemplo:

integer, target :: var
integer, pointer :: ptr

var = 10
ptr => var

En este ejemplo, ptr ahora apunta a var.

Operaciones con Punteros

Una vez que un puntero ha sido asignado, se pueden realizar varias operaciones con él. Aquí hay algunos ejemplos:

Asignación de Valores

ptr = 20
print *, var  ! Esto imprimirá 20

Desreferenciación

Para acceder al valor al que apunta un puntero, simplemente se usa el nombre del puntero:

print *, ptr  ! Esto imprimirá 20

Nullificación

Para desasignar un puntero, se utiliza la palabra clave nullify:

nullify(ptr)

Punteros y Arreglos

Los punteros también pueden apuntar a arreglos. Aquí hay un ejemplo:

integer, target, dimension(:) :: arr
integer, pointer, dimension(:) :: ptr_arr

allocate(arr(5))
arr = (/1, 2, 3, 4, 5/)
ptr_arr => arr

print *, ptr_arr  ! Esto imprimirá 1 2 3 4 5

Punteros y Subrutinas

Los punteros pueden ser pasados a subrutinas y funciones. Aquí hay un ejemplo:

subroutine modify(ptr)
    integer, pointer :: ptr
    ptr = 30
end subroutine modify

integer, target :: var
integer, pointer :: ptr

var = 10
ptr => var

call modify(ptr)
print *, var  ! Esto imprimirá 30

Ejercicio Práctico

Ejercicio 1: Uso Básico de Punteros

  1. Declara un puntero a un entero.
  2. Declara una variable entera y asígnale un valor.
  3. Asigna el puntero a la variable.
  4. Modifica el valor de la variable a través del puntero.
  5. Imprime el valor de la variable para verificar que ha sido modificado.

Solución

program pointer_example
    integer, target :: var
    integer, pointer :: ptr

    var = 10
    ptr => var

    ptr = 20
    print *, var  ! Esto imprimirá 20
end program pointer_example

Ejercicio 2: Punteros y Arreglos

  1. Declara un puntero a un arreglo de enteros.
  2. Declara un arreglo de enteros y asígnale valores.
  3. Asigna el puntero al arreglo.
  4. Modifica los valores del arreglo a través del puntero.
  5. Imprime los valores del arreglo para verificar que han sido modificados.

Solución

program pointer_array_example
    integer, target, dimension(:) :: arr
    integer, pointer, dimension(:) :: ptr_arr

    allocate(arr(5))
    arr = (/1, 2, 3, 4, 5/)
    ptr_arr => arr

    ptr_arr = ptr_arr * 2
    print *, arr  ! Esto imprimirá 2 4 6 8 10
end program pointer_array_example

Conclusión

En esta sección, hemos cubierto los conceptos básicos de los punteros en Fortran, incluyendo su declaración, asignación y uso con variables y arreglos. Los punteros son una herramienta poderosa que permite una gestión más flexible y eficiente de la memoria. En el siguiente módulo, exploraremos la asignación dinámica de memoria, que es una extensión natural del uso de punteros.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados