commit f10622a76012c07da28b6438fc6a4fe1f58d430a
parent 13e9e735542f1295043336cd13316af6198a8986
Author: mjkloeckner <martinjkloeckner@gmail.com>
Date: Thu, 21 Mar 2024 00:04:10 -0300
Add notes from second lecture
Diffstat:
3 files changed, 162 insertions(+), 48 deletions(-)
diff --git a/notes/clase01.md b/notes/clase01.md
@@ -1,48 +0,0 @@
-# Clase 13-03-24
-
-## Introducción a la materia
-
-* Se utilizara el lenguaje C++ versión ANSI C98
-* Recomendado utilizar un entorno de desarrollo (IDE) por sobre un editor de
- texto y un compilador de linea de comandos
-* Se recomienda compilar con la maquina virtual provista por el curso previo a
- entregar un trabajo práctico para corroborar que funcione correctamente en una
- computadora diferente
-
-## El lenguaje de programación C++
-
-### Convenciones
-
-* Capitalización de tipo *camelCase* para nombrar las variables
-* definir las constantes como `static const int valor = 1;` al comienzo del
- archivo
-* Evitar el uso de *goto*
-
-
-### Parámetros de función como referencias
-
-El pasaje de variables a una función por referencia permite a las funciones
-acceder a la memoria de la variable invocada y modificarla si la función lo
-permite.
-
-En el siguiente ejemplo la función `foo` recibe una variable `var` por
-referencia, nótese que de esta manera la función no utiliza más memoria que la
-dirección de memoria de la variable `var`, esto permite ahorrar memoria ya que
-de pasar la variable `var` por valor, la función `foo` debería hacer una copia
-local de la variable `var`
-
-```c++
-void foo(int &var) {
- return var + 1;
-}
-```
-
-Una ventaja del pasaje por referencia es que permite agregar el prefijo `const`
-el cual permite a la función acceder a la memoria del parámetro pero sin
-modificar el contenido de la memoria.
-
-```c++
-void foo(const int &var) {
- return var;
-}
-```
diff --git a/notes/teorica01.md b/notes/teorica01.md
@@ -0,0 +1,48 @@
+# Teórica 13-03-24
+
+## Introducción a la materia
+
+* Se utilizara el lenguaje C++ versión ANSI C98
+* Recomendado utilizar un entorno de desarrollo (IDE) por sobre un editor de
+ texto y un compilador de linea de comandos
+* Se recomienda compilar con la maquina virtual provista por el curso previo a
+ entregar un trabajo práctico para corroborar que funcione correctamente en una
+ computadora diferente
+
+## El lenguaje de programación C++
+
+### Convenciones utilizadas en el curso
+
+* Capitalización de tipo *camelCase* para nombrar las variables
+* Definir las constantes numéricas como `static const int valor = 1;` al
+ comienzo del archivo
+* Evitar el uso de *goto*
+
+
+### Parámetros de función como referencias
+
+El pasaje de variables a una función por referencia permite a las funciones
+acceder a la memoria de la variable invocada y modificarla si la función lo
+permite.
+
+En el siguiente ejemplo la función `foo` recibe una variable `var` por
+referencia, nótese que de esta manera la función no utiliza más memoria que la
+dirección de memoria de la variable `var`, esto permite ahorrar memoria ya que
+de pasar la variable `var` por valor, la función `foo` debería hacer una copia
+local de la variable `var`
+
+```c++
+void foo(int &var) {
+ return var + 1;
+}
+```
+
+Una ventaja del pasaje por referencia es que permite agregar el prefijo `const`
+el cual permite a la función acceder a la memoria del parámetro pero sin
+modificar el contenido de la memoria.
+
+```c++
+void foo(const int &var) {
+ return var;
+}
+```
diff --git a/notes/teorica02.md b/notes/teorica02.md
@@ -0,0 +1,114 @@
+# Clase 20-03-24
+
+## Punteros en C++
+
+Los punteros, al igual que en C, son variables que almacenan una dirección en
+memoria. Para que un puntero funcione debe ser capaz de almacenar un **Word**,
+ya que ese es el tamaño de una dirección de memoria de una computadora.
+
+### Sintaxis
+
+Para imprimir la dirección de memoria de una variable se utiliza `&`
+
+```c++
+int a = 1;
+std::cout << &a << std::end; // Imprime la dirección de memoria de `a`
+```
+
+Para declarar un puntero a un tipo de dato se utiliza el asterisco `*` luego del
+tipo de dato.
+
+```c++
+int *p; // Se declara un puntero a un entero
+```
+
+Para asignar la dirección de memoria de una variable a un puntero se utiliza el
+operador `=`
+
+```c++
+int a = 1;
+int *p = &a; // p es un puntero que apunta a la variable a
+```
+
+Para imprimir el contenido al que apunta un puntero hay que *desreferenciaro*,
+para eso se utiliza el operador asterisco `*`
+
+```c++
+int a = 1;
+int *p = &a;
+std::cout << *p << std::endl; // Imprime el contenido de la variable
+ // que apunta p
+```
+
+### 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;
+}
+```
