# Clase 17-04-24
 
 ## Templates
 
 Los templates (o plantillas) sirven para definir funciones que no dependan de un
 tipo de dato, paro que su funcionamiento es el mismo para diferentes tipos. Por
 ejemplo la función `swap` que se muestra a continuación.
 
 ```c++
 void swap(int& a, int&b) {
     int tmp = a;
     a = b;
     b = a;
 }
 ```
 
 ```c++
 void swap(float& a, float&b) {
     float tmp = a;
     a = b;
     b = a;
 }
 ```
 
 ### Sintaxis
 
 Para definir una nueva Template, se utiliza la palabra reservada `template`
 seguido del nombre para referenciar al tipo entre signos `<` y `>`, antepuesto
 de la palabra reservada `typename` o `class`. Se recomienda utilizar `typename`
 en lugar de `class` ya que es más genérico.
 
 ```c++
 template <typename Type>
 void swap(Type& a, Type& b) {
     Type tmp = a;
     a = b;
     b = tmp;
 }
 ```
 
 Cuando se utiliza Templates en una clase la cual está modularizada en dos
 archivos, `.h` y `.cpp` por ejemplo, solo se puede utilizar `template` en la
 cabecera de la misma, en el ejemplo es el archivo `.h`, ya que en caso
 contrario se produce un error durante el enlace de los orchivos objeto (link) a
 la hora de compilar el programa
 
 ### Punteros genéricos
 
 Los punteros genéricos son punteros los cuales no tienen un tipo de dato
 asignado. Todos los punteros a diferentes tipos de datos ocupan la misma
 cantidad de memoria, un **Word**.
 
 ```c++
 void *generic_pointer;
 ```
 
 La ventaja de los punteros genéricos es que se puede usar un mismo puntero para
 manipular diferentes tipos de datos, la desventaja es que para acceder al dato
 apuntado por el puntero es necesario conocer el tamaño del tipo de dato al cual
 apunta el puntero, ya que si se desreferencia un puntero genérico se produce un
 error **grave** en el programa.
 
 > No se puede desreferencia un puntero genérico a menos que se conozca el tipo
 > de dato
 
 ```c++
 int a = 1;
 void *p = &a;
 
 std::cout << *(int *)p << std::endl; // "cast" al puntero `p` a tipo int para
                                      // acceder a la memoria que apunta
 ```
 
 ## Memoria Dinámica
 
 A diferencia de la memoria estática, que se localiza en el **stack**, la memoria
 dinámica se localiza en el **heap**. Al finalizar el programa el stack vuelve
 a su posición de origen y se eliminan todas las variables almacenadas allí,
 liberando la memoria utilizada, el heap en cambio, se debe liberar por el
 usuario antes de finalizado el programa, de lo contrario se produce una fuga de
 memoria, un error típico y grave en lenguajes como C y C++.
 
 El lenguaje C++ ofrece dos palabra reservadas para manipular el heap: `new` la
 cual permite crear una nueva variable, y `delete` la cual permite eliminar una
 variable, y por consiguiente liberar la memoria utilizada por dicha variable
 
 ### Sintaxis
 
 La palabra `new` puede ser utilizada para almacenar memoria en el `heap`, la
 memoria a almacenar puede ser utilizada para variables de tipo primitivo como
 `int`, o variables más complejas como estructuras definidas por el usuario.
 
 ```c++
 int *p = new int;
 *p = 10;
 std::cout << *p << std::endl;
 delete p;
 ```
 
 En el siguiente ejemplo se define un nuevo tipo de dato `Vec2i`, el cual
 representa un vector de dos elementos de tipo `int`. Luego, en la función `main`
 se utiliza el operador `new` para alocar la variable en el heap.
 
 ```c++
 #include <iostream>
 
 typedef struct {
     int x, y;
 } Vec2i;
 
 int main (void) {
     int *pos = new Vec2i;
     pos->x = 1;
     pos->y = 0;
     std::cout << "(" << p->x << "," << p->y << ")\n";
     delete Vec2i;
 }
 ```