Foro de elhacker.net

Alguien me pude decir como funcionan los punteros y con un ejemplo por favor

Hola @Julia13

En C, un puntero es una variable que hace referencia a una dirección de memoria, que a su vez hace referencia a un dato.

Teniendo el siguiente código:

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    int x;
    int *y = &x;
 
    x = 3;
 
    printf("%d\n", *y);
 
    return EXIT_SUCCESS;
}

Se crean dos variables. Una de tipo entero y otra un puntero que apunta a un entero.

Primero se asigna el valor 3 en la variable x, y después se asigna el valor de x a y. Se puede notar claramente un operador *, que desreferencia y permite la lectura y la escritura de lo que haya allí en esa variable.

En realidad esta no es la única forma de asignar un valor de una variable a otra.

y = &x;

Lo que hará el operador & será obtener la dirección de x y se la asignará a y, entonces ahora las dos variables apuntarán al mismo dato, pero para acceder a él, es de forma distinta.

Los punteros también son muy útiles para manejar arreglos y que a su vez pueden ser pasados a funciones.

#include <stdio.h>
#include <stdlib.h>
 
int sum_array(int *array, int length)
{
    int result = 0;
 
    while (length--)
        result += array[length];
 
    return result;
}
 
int main(void)
{
    int n_array[] = { 1, 2, 3, 4 };
    int result = sum_array(n_array, sizeof(n_array)/sizeof(n_array[0]));
 
    printf("%d\n", result);
 
    return EXIT_SUCCESS;
}

Lo que sucede en este pequeño programa es que se pasa a la función dos argumentos: el primero es la dirección donde comienza el arreglo y el segundo argumento es la cantidad de elementos que contiene.

En realidad no se ve prácticamente nada de lo que sucede. Veamos este pequeño programa en nasm:

section .data
    n_array: dq 1, 2, 3, 4
    n_array_length: equ ($-n_array)/8
 
section .text
    global _start
_start:
    mov rsi, n_array
    mov rcx, n_array_length
    xor rax, rax
    xor rbx, rbx
 
.loop:
    add rax, [rsi+rbx*8]
    inc rbx
    loop .loop

Si mira en la sección de datos se creó n_array, que básicamente es el inicio del arreglo de datos que se ven allí. Si mira la línea 8 se coloca la dirección de inicio en el registro rsi, y mucho después en el bucle .loop, se comienza a obtener los datos para sumarlo en el acumulador rax. Vea [rsi+rbx*8], prácticamente sería como un equivalente al operador * de C, ya que se obtiene ese dato al que apunta el resultado de la operación de sumar el registro rsi con rbx (multiplicado por 8, ya que cada dato del arreglo n_array pesa 8 bytes).

Este programa no se debe ejecutar como uno común, ya que nunca le pide al sistema que salga, pero para estos fines, está perfecto. Hay que mirar desde el depurador, que en mi caso es gdb.


Se recorre todo el arreglo haciendo la misma operación y al final el resultado estará en el registro rax.

Espero le haya servido.

~ DtxdF

Bueno, no, no está bien.


(1) debería llamar la atención
(2) es un error.

@Loretz

Supongo que no lo has probado. Porque parece que no.

¿Cómo asignarías un valor a un puntero?


~ DtxdF

No hace falta probarlo, estas desreferenciando un puntero indefinido como ya te dijeron, puede funcionar DE CASUALIDAD miles de veces.

c:\src\badptr.cpp(10) : warning C4700: uninitialized local variable 'y' used


Un ejemplo elemental:

int *y = new int;

Comprendo Eternal Idol y Loretz. No me había fijado, gracias por la aclaratoria.

~ DtxdF

Hola, ya veo que te dieron una explicación muy detallada arriba, tocando temas técnicos y tal. Pero trataré de enseñarte los punteros de esta forma... Un puntero no guarda datos específicamente, sino, direcciones de memoria.

Ejemplo:

Tú tienes una casa y la dirección de la casa en un papel, así que el puntero vendría siendo ese papel. Este no tiene la casa pero si su dirección.

Esto te podría servir para apuntar una variable en constante cambio, solo deberías asignarle la dirección al puntero una sola vez y te ahorrarías el tener que reasignarle el valor a cada rato (en caso de que sea una variable).

Siguiendo el ejemplo de arriba:

Resulta que a la casa le estas cambiando el color cada cierto tiempo, ya que tienes la dirección puedes ir y ver esos cambios sin ningún problema o paso de por medio.

En cambio, si hubieras guardado la casa en una variable, al revisarla te darías cuenta de que la casa no ha cambiado de color (cuando se supone que la original sí) así que te tocaría volver a guardar la casa en esa variable para poder apreciar el cambio.

Puntero a lo easy.

Un puntero es un número (cómo todo dentro de un ordenador) y ese número representa una dirección de memoria.

Por ejemplo:

#include <stdio.h>
 
int main() {
    printf("%d", *(int*)0x61FE1C);
}

En el ejemplo anterior directamente le digo a C que me muestre qué hay en la dirección de memoria 61FE1C. ¿Se puede? Sí. Por cierto, ese casting (int*) es necesario para convertir el literal en un puntero. El * que hay delante nos muestra el contenido.

* Un poco más avanzado: En este caso he hecho un programa previo para ver dónde residía la memoria de datos del programa y pudiera apuntar ahí con este ejemplo. Los sistemas operativos actuales y los microprocesadores funcionan por capas. No van a dejar que un programa de usuario pueda leer o escribir fuera de su área designada. Antes sí que se podía, o en sistemas sin protección sí puede hacerse.

Podemos usar una variable para alojar esa dirección de memoria del ejemplo anterior:

#include <stdio.h>
 
int main() {
    int *p = (int*)0x61FE1C;
    printf("%d", *p);
}

Aquí asignamos el literal a una variable puntero. Las variables puntero se denotan por anteponer el asterisco (*) delante del nombre durante su definición o declaración. Para ver la definición y declaración por separado sería así:

#include <stdio.h>
 
int main() {
    int *p;
    p = (int*)0x61FE1C;
    printf("%d", *p);
}

Nótese que cuándo se hace la definición (se le da valor) no se usa el asterisco (*), pues éste tiene la función, en sus posteriores usos, de conseguir el valor guardado en esa posición de memoria, que en este caso es la posición 0x61FE1C.

Pero cómo hemos dicho el conjunto sistema operativo/microprocesador no te deja apuntar a zonas arbitrarias de la memoria, el sistema te la tiene que dar y ahí es cuando entra C que es quien negocia con el sistema para conseguir memoria libre; nosotros no debemos preocuparnos por nada de eso (afortunadamente). Por tanto cuando haces


C se encarga de reclamar una zona de memoria donde cabe un entero y el sistema se la otorga. ¿Cuál? La verdad es que no nos importa. Ídem para


Hace lo mismo: pide al sistema una zona de memoria dónde quepa un entero y éste, si tiene, nos la da.

* Un poco más avanzado: la memoria de un programa en C está dividida en sectores que son la memoria de programa, la memoria de la pila y la memoria del montón (heap). Hay más. La pila es donde caen las variables normales como int, char, double, arrays, structs, etcétera y es C el encargado de manejarlas. En el montón van a parar los malloc, calloc y toda esa família; C no entra ahí y es el propio programador el encargado de comprobar que se ha tomado memoria, de liberarla para futuros usos demás menesteres de administración.

Lo normal de un puntero es recibir la dirección de memoria de otra variable:

El ampersand (&) es un operador que (en este caso) dice 'La dirección de'.

También es muy importante de los punteros el tipo de dato al que apuntan. Has visto en todos estos ejemplos cómo siempre han sido a entero (int *), pero pueden ser de cualquier tipo de dato: char *, double *, struct mi_estructura *, etcétera. Esto es debido  a que los diferentes tipos de datos ocupan tamaños en bytes diferentes en memoria y el compilador necesita saber cuánto ocupa para recuperarlo o para guardar algo en él. Por ejemplo un char suele ser de 1 byte y un entero de 4 bytes. Si los punteros no especificaran el tamaño con su tipo podríamos guardar un número muy grande en una posición dónde se guarda un char machacando datos vecinos: intentaríamos guardar 4 bytes dónde sólo cabe 1.

Y bueno, esto es lo básico de los punteros. Hay más cosas: punteros como argumentos en funciones y porqué usarlos; similitudes y diferencias entre punteros y arrays; punteros a funciones (sí, también se pueden apuntar a funciones); punteros a punteros (por loco que parezca muchas veces son necesarios). Pero eso ya para más adelante. Ahora intenta comprender sus bases.

¿Y si estamos trabajando en macOS (y el ASRL esta involucrado por defecto en cada ejecucion)?  :-\ En Windows si el programa tiene ASLR habilitado (por defecto en proyectos desde Visual Studio 2008) al reiniciar la direccion base tambien cambiara.

int zzz = 5;
 
int main(int argc, const char * argv[])
{
        printf("%p\n", &zzz);
        return 0;
}

---

Mejor dejemos en claro que usar direcciones hardcoded es una mala practica y nadie que este aprendiendo a usar punteros deberia emplearla.

Sí, pero para entender una cosa realmente es mejor empezar desde los cimientos y los cimientos, en punteros, son que es un número que representa una dirección de memoria. Y de ahí para arriba. Estarás de acuerdo conmigo que realmente no se puede entender C sin entender el esquema de memoria. Al menos eso me sirvió a mi: entonces todo fue más fácil. Eso y la traducción a ensamblador de la convención de llamadas a funciones, para entender las variables automáticas.

---

Supongo que no será el caso de mucha gente que visite el foro pero este lenguaje es muy habitual verlo en microcontroladores y aquí se mapean en memoria muchos registros de configuración y los puertos E/S. En PC usar constantes para acceder a memoria no es útil, pero en el mundo del firmware es la norma.

Por supuesto aunque entendi que habia sido explicado en este hilo, salvo que asumamos un desconocimiento de lo que es una direccion de memoria. Sin dudas para poder comprender cabalmente el codigo generado y depurarlo en condiciones es necesario profundizar en varias aristas pero juraria que el esquema de memoria o la convencion de llamada no son parte del standard del lenguaje sino que corren por cuenta del compilador bajo la plataforma en cuestion.

---

Habria que pensar que es mas probable, si que el que pregunto por punteros en C++ mañana compile tu ejemplo (y le de problemas) o que escriba firmware.

Entiendo tu postura de dejar las cosas lo más sencillas posibles, pero tal vez esa sencillez no sea suficiente. Estarás de acuerdo conmigo que el problema del entendimiento de los punteros es recurrente en todo el que ha estudiado este lenguaje. Yo, por mi parte, hasta que no vi a los punteros de esa forma no llegué a comprenderlos del todo y por eso, creo yo, que deberían enseñarse de esa forma.

Es cierto que el programa donde se asigna una constante como dirección de memoria no le va a funcionar. Pero sirve de ejemplo para mostrar que ocurre por debajo, y de ahí la construcción progresiva hasta llegar al puntero que recoge una dirección de una variable; es decir, es para que vaya viendo el proceso natural de lo que ocurre en la máquina.

O tal vez es que por mi curiosidad me gusta saber esas cosas.

Tienes razón, tal vez no se dedique a hacer firmwares, pero quien sabe si un estudiante de electrónica si ve este post y está interesado en saber cómo funcionan los punteros en C++. Siempre intento dar las respuestas pensando en un amplio espectro de gente que pueda leerla.

Y si, tienes razón, el esquema de memoria variará de arquitectura a arquitectura y por ende el de las llamadas a funciones. Pero también es un punto a tener en cuenta.

Espero que no sea demasiado tarde para contestar pero paso a responder, los punteros es una de las cosas que la verdad mas me costo dominar pero fue porque cuando lei documentacion pues digamos como que no explicaba bien todo al fondo y pus espero hacerme entender porque los voy a explicar como a mi me hubiera gustado que me lo explicaran, bueno, ves las variables? para este ejemplo vamos a tomar una a casa, el valor de la variable sera el numero de personas viviendo ahi, en una casa hay 5 personas viviendo y esa casa es A, sin embargo, una casa tiene una direccion verdad y digamos que dicha direccion sea la Calle Pepe no.245 como ejemplo(obviamente es una direccion falsa) ahora digamos que hay una persona que le quiere enviar una carta a uno de los integrantes de la familia de 5, esa carta tiene que tener la DIRECCION de la casa para poder enviarla asi que tendra que escribir en la carta que es para fulanito de tal para Calle Pepe no.245. Pues bueno lo mismo pasa con las compus, digamos que declaramos la variable "int a = 5"(haciendo el ejemplo de la casa), pero ahora queremos tener algo que no tenga exactamente un valor, sino que tenga una direccion de memoria, es decir, algo que le diga a la compu onta la variable a y como hacemos eso? pues nada mas y nada menos que con los punteros, en programacion c/c++ para saber la direccion de memoria de una variable se utiliza el caracter address-of que es este de aqui& y para que me entienda mejor, zy tu quieres decir la direccion de la casa A del ejemplo anterior como si fuera estilo programacion dirias &casa_A = Calle Pepe no.245 y pues como practica en lo mientras vamos a depurar un sencillo programa con gdb:

#include <stdio.h>
 
int main(void){ 
        int a = 5;
 
        return 0;
}
 

Una vez compilado este programa(yo lo compilare en linux y para hacerlo desde ahi es con: gcc nombre_programa_c.c -o nombre_programa_compilado), ahora abriremos el gdb con

gdb -q nombre_programa_compilado
 

                                                                 

ahora lo que haremos sera poner un breakpoint justo despues de que la instruccion de la declaracion de a se haya dado y eso es en la linea 5 como podras ver(int a = 5; esta en la linea 4) asi que pondremos un breakpoint en la linea 5  y ejecutaremos el programa con:

(gdb) break 5
Breakpoint 1 at 0x1129: file ejemplo.c, line 6.
(gdb) run
 

yo le puse ejemplo.c al archivo por cierto pero continuando, a tiene un valor de 5 y para comprobarlo desde gdb podemos usar:

(gdb) print a
$1 = 5
(gdb) p a
$2 = 5
 

los $1 y $2 son variables que se guardaran temporalmente, puse print y p porque muchos comandos de gbd estan abreviados y pus eso pero lo que importa es que como dice gdb a tiene un valor de 5 pero ahora queremos saber la direccion de memoria de a y para hacerlo usaremos el caracter &(address-of) antes de a, asi:

(gdb) p &a
$3 = (int *) 0x7fffffffdfcc
 

y como puedes ver la direccion de memoria de a es: 0x7fffffffdfcc(en este ejemplo esta larga porque en donde estoy corriendo el programa es de 64 bits pero en la de 32 bits es de unos 4 bytes pero ahorita no me voy a poner a explicar eso) esta direccion de memoria vendria ser como la direccion de la casa A que era Calle Pepe no.245, si queremos hacer un programa donde ya no tengamos que depurar podemos usar el formato de cadena %p en un printf asi:

include <stdio.h>
 
int main(void){
        int a = 5;
        printf("Direccion de memoria de a es: %p", &a);
        return 0;
}
 

pues ahora zy con todo esto porfin puedo pasar a explicar lo que es un puntero, hasta ahora vimos que podiamos saber la direccion de memoria de a usando el caracter & pero  ahora queremos que haya algo que pueda tener el valor de la direccion de memoria de a y aqui es donde entran los punteros, en c/c++ para declarar los punteros se utiliza el caracter * antes de poner el nombre del puntero, para entenderme mejor veamos un ejemplo:

#include <stdio.h>
 
int main(void){
        int a = 5;
        int *pa;
        pa = &a;
        return 0;
}
 

aqui tenemos a nuestro puntero pa, yo le puse de nombre pa aunque perfectamente se podia declarar como int *a; pero le pongo pa porque me gusta diferenciar punteros de variables cuando se tratan de proyectos complejos, siempre que se declaren punteros recuerda que se usa *<nombre_puntero> y una cosa tambien, es importante siempre indicar el tipo de datos del puntero que en este caso es int porque zy juntas por ejemplo uno char con uno int pues obviamente te va a salir error porque se va malinterpretar a la hora del tamaño de los bytes pero ya teniendo esto en cuenta de que zy vas a usar una variable y un punteros los uses con el mismo tipo pues explicare la parte de pa = &a; esto es asi porque recuerda que los punteros no tienen un valor sino que tienen direcciones de memoria en su lugar y con el caracter & es como indicabamos la direccion de memoria de una variable, asi zy le dices a la compu que pa es igual a la direccion de memoria de a pues te va a entender que te estas poniendo algo para saber onta a(espero que no este cantinfleando a este punto xd) pero bueno, vamos a correr este programa con gdb en la linea que esta despues de la asignacion de la direccion que tendra el puntero pa  y es la linea 7 asi:

(gdb) break 7
Breakpoint 1 at 0x1138: file ejemplo.c, line 7.
(gdb) run
 

y empezaremos a ver los ver que tienen dentro la variable y el puntero:

(gdb) p a
$1 = 5
(gdb) p &a
$2 = (int *) 0x7fffffffdfc4
(gdb) p pa
$3 = (int *) 0x7fffffffdfc4
(gdb) p &pa
$4 = (int **) 0x7fffffffdfc8
(gdb)
 

y como puedes notar a sigue teniedo el valor de 5 pero lo interesante esta en el valor de la direccion de memoria de a y la direccion a la que apunta pa que son las mismas y esa direccion es: 0x7fffffffdfc4 y es de hecho una cosa importante que se me olvido mencionar y es que la direccion a la que apuntara un puntero no sera la misma que la de su direccion de memoria, tomare nuevamente el ejemplo de la casa A, cuando alguien le mando la carta a la casa A el que la mando no estaba en la casa A, estaba en B y sus direcciones no son las misma y es que asi B puede estar en Calle Jose no.456 y que el mande la carta a Calle Pepe no.245 y pues aca pasa lo mismo, pa puede estar en un lado pero tener el donde esta otro lugar y pues hasta aca todo bien pero ahora explicare la parte donde la mayoria se confunden y es esto:

(gdb) p *pa
$5 = 5
(gdb) p pa
$6 = (int *) 0x7fffffffdfc4
(gdb)
 

cuando despues de declarar un putero volvemos a poner el signo * nos referimos al valor de la variable a la que esta apuntando el puntero, pa esta apuntando a la variable a y a tiene el valor de 5 y zy nos referimos al valor de lo apuntado tambien deberia ser 5 y es asi  como lo muestra p *pa, sin embargo cuando no ponemos de nuevo el signo * significa que nos referiremos a la direccion a la que apunta, entonces en resumen:

*pa = valor de lo que esta apuntando
pa = direccion de memoria de lo que esta apuntando

Ahora para aclarar un poco mas esto el siguiente programa lo terminara de hacer:

#include <stdio.h>
 
int main(void){
        int a = 5;
        int *pa;
        pa = &a;
        printf("El valor de la variable a la que apunta pa es: %i", *pa);
        printf("\nEl valor de la variable a es: %i", a);
        printf("\nLa direccion de memoria a la que apunta pa es: %p", pa);
        printf("\nLa direccion de memoria de a es: %p", &a);
        return 0;
}
 

Entonces cuando te sientas confundido con los punteros siempre recuerda que *pa hace referencia al valor de lo que esta apuntando y pa a la direccion de lo que apunta, y todavia esta lo de las funciones pero creo que por el momento es suficiente y por zy acaso, la salida del programa anterior es:

El valor de la variable a la que apunta pa es: 5
El valor de la variable a es: 5
La direccion de memoria a la que apunta pa es: 0x7ffdd29322f4
La direccion de memoria de a es: 0x7ffdd29322f4

y ya como ultimo te dejare aqui unos programas que hacen practicamente lo mismo(a uno nada mas le agregue una comparacion para saber cuando un usuario intenta engañar al programa pero es lo de menos), para que veas la diferencia entre usar y no los punteros:

SIN punteros:

#include <stdio.h>
#include <stdlib.h>
 
int main(void){
	int a, c, d, b = 1000;
	printf("Bienvenido a cajero automatico 1!!!, tienes 1000 varos");
	printf("\n\nOpcion 1: Retirar");
	printf("\nOpcion 2: Depositar");
	printf("\nOpcion 3: Salir");
	printf("\n\n\nEliga una opcion: ");
	scanf("%i", &a);
	switch(a){
		case 1:
			c;
			printf("\n\nIngrese la cantidad a retirar: ");
			scanf("%i", &c);
			d = b - c;
			printf("\nLa cantidad que quedo es de: %i", d);
			system("pause>nul");
			break;
 
		case 2:
			c;
			printf("\n\nIngrese la cantidad a depositar: ");
			scanf("%i", &c);
			d = b + c;
			printf("\nLa cantidad que quedo es de: %i", d);
			system("pause>nul");
			break;
 
		case 3:
			printf("\n\nSaliendo...");
			system("pause>nul");
			break;
 
		default:
			printf("Ingrese algo correcto");
			system("pause>nul");
			break;
	}
	return 0;
}
 

CON punteros:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
 
struct cajero{
	uint16_t cantidad;
	uint16_t varia;
	uint16_t deposito;
	uint16_t numero;
	uint16_t *pcantidad;
};
 
void retirar(int *cantidad_retirar, int *valor_o){
	struct cajero retir;
	if(*cantidad_retirar <= 0){
		printf("Ingrese una cantidad valida");
	}
	else{
		if(*cantidad_retirar > *valor_o){
			printf("\nNo tienes esa cantidad de dinero");
		}
		else{
			retir.varia = *valor_o - *cantidad_retirar;
			printf("\nSe han retirado %u y el saldo final es de: %u", *cantidad_retirar, retir.varia);
		}
	}
}
 
void depositar(int *depositar_cantidad, int *valor_o){
	struct cajero deposite;
	if(*depositar_cantidad <= 0){
		printf("Ingrese una cantidad valida");
	}
	else{
		deposite.deposito = *depositar_cantidad + *valor_o;
		printf("\nSe ha depositado satisfactoriamente");
		printf("\nAhora tienes en tu cuenta %u", deposite.deposito);
	}
}
 
void salir_x(void){
	printf("\nAviso!: Esta saliendo del programa");
}
 
int main(void){
	struct cajero opcion;
	opcion.cantidad = 1000;
	printf("Bienvenido a cajero automatico 2!!!, tienes 1000 varos");
	printf("\n\nOpcion 1: Retirar");
	printf("\nOpcion 2: Depositar");
	printf("\nOpcion 3: Salir");
	printf("\n\n\nEliga una opcion: ");
	scanf("%u", &opcion.numero);
	switch(opcion.numero){
		case 1:
			opcion.pcantidad = &opcion.cantidad;
			printf("\n\nIngrese la cantidad a retirar: ");
			scanf("%u", &opcion.varia);
			retirar(&opcion.varia, opcion.pcantidad);
			getch();
			break;
 
		case 2:
			opcion.pcantidad = &opcion.cantidad;
			printf("\n\nIngrese la cantidad a depositar: ");
			scanf("%u", &opcion.varia);
			depositar(&opcion.varia, opcion.pcantidad);
			getch();
			break;
 
		case 3:
			salir_x();
			getch();
			return 0;
 
		default:
			printf("Ejecute algo correcto");
			getch();
			return -1;
	}
	return 0;
}
 

Nota: si se usan los punteros es para evitar usar mucha memoria porque creeme que muchas veces en programacion vas a tener que usar el mismo valor de una variable dentro de otras funciones pero cuando son proyectos de muchas lineas de codigo puede llenar mucha memoria y con lo punteros se evita todo ese gasto de energia utilizando solamente referencias a en que parte del programa esta la variable y por el momento es todo de mi parte, zy te quedaron dudas te dejo este link de este profe:

https://www.youtube.com/watch?v=5TS1tdBcIoM&list=PLcYO0Mqfc4g87Y-XcZ0TWwrSiKlNXo0kh&index=9