notas/clases/teorica02.md (3417B)
1 # Clase 20-03-24 2 3 ## Punteros en C++ 4 5 Los punteros, al igual que en C, son variables que almacenan una dirección en 6 memoria. Para que un puntero funcione debe ser capaz de almacenar un **Word**, 7 ya que ese es el tamaño de una dirección de memoria de una computadora. 8 9 ### Sintaxis 10 11 Para imprimir la dirección de memoria de una variable se utiliza `&` 12 13 ```c++ 14 int a = 1; 15 std::cout << &a << std::end; // Imprime la dirección de memoria de `a` 16 ``` 17 18 Para declarar un puntero a un tipo de dato se utiliza el asterisco `*` luego del 19 tipo de dato. 20 21 ```c++ 22 int *p; // Se declara un puntero a un entero 23 ``` 24 25 Para asignar la dirección de memoria de una variable a un puntero se utiliza el 26 operador `=` 27 28 ```c++ 29 int a = 1; 30 int *p = &a; // p es un puntero que apunta a la variable a 31 ``` 32 33 Para imprimir el contenido al que apunta un puntero hay que *desreferenciaro*, 34 para eso se utiliza el operador asterisco `*` 35 36 ```c++ 37 int a = 1; 38 int *p = &a; 39 std::cout << *p << std::endl; // Imprime el contenido de la variable 40 // que apunta p 41 ``` 42 43 ### Punteros genéricos 44 45 Los punteros genéricos son punteros los cuales no tienen un tipo de dato 46 asignado. Todos los punteros a diferentes tipos de datos ocupan la misma 47 cantidad de memoria, un **Word**. 48 49 ```c++ 50 void *generic_pointer; 51 ``` 52 53 La ventaja de los punteros genéricos es que se puede usar un mismo puntero para 54 manipular diferentes tipos de datos, la desventaja es que para acceder al dato 55 apuntado por el puntero es necesario conocer el tamaño del tipo de dato al cual 56 apunta el puntero, ya que si se desreferencia un puntero genérico se produce un 57 error **grave** en el programa. 58 59 > No se puede desreferencia un puntero genérico a menos que se conozca el tipo 60 > de dato 61 62 ```c++ 63 int a = 1; 64 void *p = &a; 65 66 std::cout << *(int *)p << std::endl; // "cast" al puntero `p` a tipo int para 67 // acceder a la memoria que apunta 68 ``` 69 70 ## Memoria Dinámica 71 72 A diferencia de la memoria estática, que se localiza en el **stack**, la memoria 73 dinámica se localiza en el **heap**. Al finalizar el programa el stack vuelve 74 a su posición de origen y se eliminan todas las variables almacenadas allí, 75 liberando la memoria utilizada, el heap en cambio, se debe liberar por el 76 usuario antes de finalizado el programa, de lo contrario se produce una fuga de 77 memoria, un error típico y grave en lenguajes como C y C++. 78 79 El lenguaje C++ ofrece dos palabra reservadas para manipular el heap: `new` la 80 cual permite crear una nueva variable, y `delete` la cual permite eliminar una 81 variable, y por consiguiente liberar la memoria utilizada por dicha variable 82 83 ### Sintaxis 84 85 La palabra `new` puede ser utilizada para almacenar memoria en el `heap`, la 86 memoria a almacenar puede ser utilizada para variables de tipo primitivo como 87 `int`, o variables más complejas como estructuras definidas por el usuario. 88 89 ```c++ 90 int *p = new int; 91 *p = 10; 92 std::cout << *p << std::endl; 93 delete p; 94 ``` 95 96 En el siguiente ejemplo se define un nuevo tipo de dato `Vec2i`, el cual 97 representa un vector de dos elementos de tipo `int`. Luego, en la función `main` 98 se utiliza el operador `new` para alocar la variable en el heap. 99 100 ```c++ 101 #include <iostream> 102 103 typedef struct { 104 int x, y; 105 } Vec2i; 106 107 int main (void) { 108 int *pos = new Vec2i; 109 pos->x = 1; 110 pos->y = 0; 111 std::cout << "(" << p->x << "," << p->y << ")\n"; 112 delete Vec2i; 113 } 114 ```