¿Qué es un puntero?
En Go, un puntero es una variable que almacena la dirección de otra variable. La dirección es la ubicación de memoria única donde se almacena la variable. Los punteros se crean utilizando el operador `&`, que devuelve la dirección de una variable.
Por ejemplo, digamos que tenemos una variable "número" de tipo "int". Podemos crear un puntero a `número` usando el operador `&`:
```ir
número :=10
puntero :=&número
```
La variable `puntero` ahora almacena la dirección de memoria de la variable `número`.
Desreferenciación de un puntero
Para acceder al valor de un puntero, podemos usar el operador `*`. El operador `*` elimina la referencia a un puntero y devuelve el valor almacenado en la dirección de memoria que contiene el puntero.
En nuestro ejemplo, podemos eliminar la referencia a la variable `puntero` para acceder al valor de la variable `número`:
```ir
Número desreferenciado :=*puntero
```
La variable `dereferencedNumber` ahora almacena el valor de la variable `number`, que es 10.
Aritmética de punteros
Los punteros también se pueden utilizar para realizar aritmética de punteros. La aritmética de punteros es el proceso de sumar o restar números enteros de un puntero para cambiar la dirección de memoria a la que hace referencia.
Por ejemplo, digamos que tenemos una matriz de números enteros llamada "arr" y queremos iterar a través de los elementos de la matriz. Podemos usar el operador `+` para agregar un número entero a un puntero para pasar al siguiente elemento de la matriz:
```ir
arreglo :=[5]int{1, 2, 3, 4, 5}
// Inicializa un puntero al primer elemento de la matriz.
puntero :=&arr[0]
// Iterar a través de la matriz usando aritmética de punteros
para yo :=0; yo
valor :=*puntero
// Imprime el valor
fmt.Println(valor)
// Incrementa el puntero para pasar al siguiente elemento de la matriz.
puntero ++
}
```
En este ejemplo, el puntero "puntero" se establece inicialmente en la dirección del primer elemento de la matriz. Luego, el bucle `for` recorre la matriz, eliminando la referencia al `puntero` en cada iteración para obtener el valor del elemento actual. Luego, el "puntero" se incrementa para pasar al siguiente elemento de la matriz.
Los punteros se pueden pasar como argumentos a funciones. Esto permite que las funciones manipulen directamente la dirección de memoria de las variables, en lugar de crear una copia de la variable.
Por ejemplo, digamos que tenemos una función llamada "incremento" que incrementa el valor de un número entero. Podemos pasar un puntero a un número entero como argumento a la función `incremento`, permitiendo que la función modifique directamente el valor del número entero:
```ir
incremento de función (ptr *int) {
// Elimina la referencia del puntero para obtener el valor en la dirección de memoria
valor :=*ptr
// Incrementa el valor
valor++
// Almacena el valor incrementado nuevamente en la dirección de memoria
*ptr =valor
}
función principal() {
// Crea una variable entera
número :=10
// Pasa un puntero a la variable como argumento de la función de incremento.
incremento (y número)
// Imprime el valor incrementado
fmt.Println(número) // Salida:11
}
```
En este ejemplo, la función "incremento" toma un puntero a un número entero como argumento. La función elimina la referencia del puntero para obtener el valor en la dirección de memoria, incrementa el valor,
Pasar punteros a funciones