Upload via hfc (batch)

Uploaded using hfc tool

.gitattributes

@@ -240,3 +240,18 @@ subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a
 subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/01-Memoria[[:space:]]dinámica/03-Uso[[:space:]]de[[:space:]]Punteros[[:space:]]en[[:space:]]C[[:space:]]Variables[[:space:]]y[[:space:]]Memoria[[:space:]]Dinámica.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/02-Estructuras[[:space:]]de[[:space:]]datos/01-Estructuras[[:space:]]de[[:space:]]Datos[[:space:]]Personalizadas[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/02-Estructuras[[:space:]]de[[:space:]]datos/02-Creación[[:space:]]y[[:space:]]uso[[:space:]]de[[:space:]]estructuras[[:space:]]y[[:space:]]punteros[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/02-Estructuras[[:space:]]de[[:space:]]datos/03-Uniones[[:space:]]y[[:space:]]Enumeraciones[[:space:]]en[[:space:]]C[[:space:]]Gestión[[:space:]]Eficiente[[:space:]]de[[:space:]]Memoria.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/03-Introducción[[:space:]]a[[:space:]]la[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/01-Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]en[[:space:]]C[[:space:]]Conceptos[[:space:]]Básicos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/03-Introducción[[:space:]]a[[:space:]]la[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/02-Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]Creación[[:space:]]de[[:space:]]Clases[[:space:]]y[[:space:]]Objetos[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/03-Introducción[[:space:]]a[[:space:]]la[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/03-Ciclo[[:space:]]de[[:space:]]Vida[[:space:]]de[[:space:]]Objetos[[:space:]]en[[:space:]]C[[:space:]]Constructores[[:space:]]y[[:space:]]Destructores.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/04-Principios[[:space:]]de[[:space:]]la[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/01-Encapsulación[[:space:]]de[[:space:]]Atributos[[:space:]]en[[:space:]]C[[:space:]]Prácticas[[:space:]]Seguras.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/04-Principios[[:space:]]de[[:space:]]la[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/02-Uso[[:space:]]del[[:space:]]Puntero[[:space:]]This[[:space:]]en[[:space:]]C[[:space:]]para[[:space:]]Desambiguación[[:space:]]y[[:space:]]Autorreferencia.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/04-Principios[[:space:]]de[[:space:]]la[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/03-Atributos[[:space:]]y[[:space:]]Métodos[[:space:]]Estáticos[[:space:]]en[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/04-Principios[[:space:]]de[[:space:]]la[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/04-Herencia[[:space:]]en[[:space:]]C[[:space:]]Implementación[[:space:]]y[[:space:]]Ejemplos[[:space:]]Prácticos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/04-Principios[[:space:]]de[[:space:]]la[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/05-Herencia[[:space:]]Múltiple[[:space:]]en[[:space:]]C[[:space:]]Implementación[[:space:]]y[[:space:]]Ejemplos[[:space:]]Prácticos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/04-Principios[[:space:]]de[[:space:]]la[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/06-Polimorfismo[[:space:]]en[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]con[[:space:]]C/05-Despedida/01-Evaluación[[:space:]]Final[[:space:]]Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]Práctico[[:space:]]de[[:space:]]C/01-Introducción[[:space:]]a[[:space:]]C/01-Programación[[:space:]]de[[:space:]]Videojuegos[[:space:]]con[[:space:]]C[[:space:]]desde[[:space:]]Cero.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]Práctico[[:space:]]de[[:space:]]C/01-Introducción[[:space:]]a[[:space:]]C/02-Programación[[:space:]]en[[:space:]]C[[:space:]]Fundamentos[[:space:]]y[[:space:]]Aplicaciones[[:space:]]Prácticas.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]Práctico[[:space:]]de[[:space:]]C/02-Conceptos[[:space:]]Generales[[:space:]]de[[:space:]]C/01-Historia[[:space:]]y[[:space:]]uso[[:space:]]del[[:space:]]compilador[[:space:]]GCC[[:space:]]en[[:space:]]programación.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]Práctico[[:space:]]de[[:space:]]C/03-Preparando[[:space:]]el[[:space:]]entorno[[:space:]]de[[:space:]]trabajo/01-Instalación[[:space:]]de[[:space:]]CodeBlocks[[:space:]]en[[:space:]]Windows[[:space:]]paso[[:space:]]a[[:space:]]paso.mp4 filter=lfs diff=lfs merge=lfs -text

subir/Curso Práctico de C/01-Introducción a C/01-Programación de Videojuegos con C desde Cero.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62fe5d8e9c5c228b6debb70f5906b618b2d4f0c8d80d86f2c7f19ced72c1ff81
+size 16918611

subir/Curso Práctico de C/01-Introducción a C/01-Programación de Videojuegos con C desde Cero.vtt

@@ -0,0 +1,71 @@
+WEBVTT
+
+00:03.839 --> 00:06.799
+Hola. Como estan? Bien mios. El curso, ese más más de Platzi.
+
+00:06.830 --> 00:10.259
+Soy Init Dorado y en este curso vamos a aprender muchas cosas.
+
+00:10.289 --> 00:16.079
+Pero antes, quién soy yo y Yago Yo médico. Hacer juegos desde juegos móviles hasta juegos para PC
+
+ --> 
+.
+
+00:16.109 --> 00:19.149
+Me pueden seguir en arroba En últil os tienen dudas del curso?
+
+00:19.179 --> 00:23.550
+No dude en escribirme. Ahí trabajó en un estudio de juegos mexicano llamado Jairo
+
+00:23.550 --> 00:26.690
+Wilkins. Hacemos muchos juegos móviles. Fue de más.
+
+00:26.690 --> 00:31.460
+Por favor, Y también. Dígame qué les parece? Es son los juegos He participado en casi todos de ellos
+
+00:31.469 --> 00:35.750
+y van desde jugados quinientos de gatitos hasta Tags noches y como miembro a los que les van a gustar
+
+ --> 
+.
+
+00:36.240 --> 00:39.649
+Pero bueno, hacemos el curso que vamos a hacer en este curso.
+
+00:40.140 --> 00:44.250
+En este curso vamos a aprender los conceptos básicos de se más, más para que ustedes puedan partir
+
+00:44.250 --> 00:49.549
+de una manera muy fácil. También ver El paradigma de programación llamado cuarenta Add objetos que
+
+00:49.549 --> 00:52.020
+no sé si lo ha escuchado antes. No eres muy usado.
+
+00:52.049 --> 00:55.909
+Y también vamos a ser un videojuego en aquí, en la consola, que es un vídeo.
+
+00:55.909 --> 00:59.850
+Problemas que la consola no. Así las películas han visto los Jagger más son la terminal.
+
+00:59.939 --> 01:04.609
+Todo ser un juego hay es un laberinto. Tienen cuales ustedes van a moverse, personaje, encontrar
+
+01:04.609 --> 01:08.209
+tesoros, ganar, perder. Vamos a las coaliciones, el cargo de los archivos y
+
+01:08.209 --> 01:12.090
+todos sus temas complicados. Pero no se preocupen, los vamos a hacerlo de manera muy simple y
+
+01:12.090 --> 01:18.120
+muy sencilla. Quien debe Atom al curso Tú, obviamente porque porque se más, más, muy divertido.
+
+01:18.129 --> 01:22.349
+Te va a gustar, agrandadas intimidante y nos va a avanzar mucho.
+
+01:23.939 --> 01:28.790
+Pero bueno, se más vamos a puede prender sólo en un solo vídeo, así que te invito a que sigamos viendo
+
+01:28.790 --> 01:32.150
+los siguientes. Ya hacemos poco a poco aprendiendo este maravilloso lenguaje.
+

subir/Curso Práctico de C/01-Introducción a C/02-Programación en C Fundamentos y Aplicaciones Prácticas.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf5c86b6ac8dcffa8ad2efc9804101cf4d0dbb6f4ba50db83b4f9ca35eb308b4
+size 20657607

subir/Curso Práctico de C/01-Introducción a C/02-Programación en C Fundamentos y Aplicaciones Prácticas.vtt

@@ -0,0 +1,80 @@
+WEBVTT
+
+00:03.640 --> 00:09.859
+que es programar es el proceso de crear algoritmos y sistemas usando lenguajes de programación para
+
+00:09.859 --> 00:13.050
+comunicarnos con las computadoras y poder crear programas.
+
+00:13.080 --> 00:16.460
+Que es eso, básicamente ante los ojos de las personas.
+
+00:16.489 --> 00:21.129
+Es nuevo, es una varita mágica. Con los demás de programación echamos, hechiza la computadora y nos
+
+00:21.129 --> 00:28.289
+obedece. Sí, sí lo es. No Este. Tenemos lenguajes de programación, los cuales nos
+
+00:28.289 --> 00:32.990
+permiten comunicarnos para crear archivos binarios y podemos en la computadora.
+
+00:33.020 --> 00:40.060
+Vamos a ver con detalle un poquito más adelante eso, pero porque queremos aprenderse más, más Se
+
+ --> 
+,
+
+00:40.060 --> 00:46.039
+más, más Es veloz porque su manejo de memoria no tiene una máquina virtual ni un recolector de basura
+
+ --> 
+,
+
+00:46.070 --> 00:49.420
+a diferencia del Chava y fichar. Y es complejo. Quieres ir?
+
+00:49.420 --> 00:55.070
+Que existe una gran del claro ETA de librerías implementaciones y es constantemente actualizado por
+
+00:55.070 --> 00:58.020
+los creadores y un gran grupo de fans y personas.
+
+00:58.049 --> 01:03.600
+Constantemente este crecimiento nunca terminan. Sí, como son algunos de estos juegos o
+
+01:03.600 --> 01:07.530
+motores de juegos fueron muchos. Hace más más. Por ejemplo, un real que hizo
+
+01:07.530 --> 01:10.540
+for night creación Engine, Brian, Ching incluso.
+
+01:10.569 --> 01:15.780
+Y Unity está basado en se más, más. Ustedes lo saben fichar, pero el compilado de la aplicación y
+
+01:15.780 --> 01:22.459
+Unity está hecho hace más más es usado para aplicaciones que requieren una optimización de recursos
+
+01:22.469 --> 01:28.129
+y manejo de memoria como prioridad al mismo tiempo de ser escalable, modular, instruido en muchísimas
+
+01:28.129 --> 01:33.819
+plataformas, ustedes se van a encargar de manipular la memoria de manualmente, no haber nadie que
+
+01:33.819 --> 01:38.370
+no se tenga. Entonces, incluso si lo hacen mal, pueden creación una computadora o
+
+01:38.370 --> 01:41.939
+dejar Next de memoria que eventualmente van a hacer que su programa se trague Pero
+
+ --> 
+.
+
+01:41.939 --> 01:46.250
+Esta libertad nos permite ser muy veloces y saber lo que está pasando por detrás.
+
+01:46.840 --> 01:52.349
+Asi que los invito a abrir este libro de Sé más más y continuemos aprendiendo los conceptos básicos
+
+ --> 
+.
+

subir/Curso Práctico de C/02-Conceptos Generales de C/01-Historia y uso del compilador GCC en programación.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9ca87d38e3787b1d2b94b85fadb29cc219d5ec44b78b3f0e360b1b855fcc68e
+size 18818997

subir/Curso Práctico de C/02-Conceptos Generales de C/01-Historia y uso del compilador GCC en programación.vtt

@@ -0,0 +1,71 @@
+WEBVTT
+
+00:03.740 --> 00:08.429
+ahora que ya sabes, dicen los más antes de ponerte a programar ni estados ver un poco de la historia
+
+ --> 
+.
+
+00:08.429 --> 00:14.339
+Y donde viene? No señaló, como decías a él, pero les ya es un científico de sistemas que
+
+00:14.339 --> 00:17.239
+se encargó de crearse más más durante su carrera.
+
+00:17.250 --> 00:21.719
+Cuando estaba estudiando empezó con C y lo que hizo fue agarrarlo y transformarlo en
+
+00:21.719 --> 00:24.800
+poniéndole programación, alentado objetos. Y lo convirtió en salas más.
+
+00:24.829 --> 00:28.609
+Incluso su primer proyecto sea base con objetos Que.
+
+00:28.609 --> 00:32.729
+Literal es la deficion se los más. Si vemos las diferencias entre los dos es que ese es
+
+00:32.729 --> 00:36.799
+un lenguaje Por eso rural. Y se más, más Tienen las mismas capacidades que se pero
+
+00:36.799 --> 00:40.350
+tiene soporte para Clancy lento objetos. No te preocupes sobre qué es eso?
+
+00:40.350 --> 00:46.070
+Lo vamos a ver con detalle El futuro. Pero bueno, Szifron fue uno de los primeros compiladores temas
+
+00:46.070 --> 00:50.119
+más que salió en mil novecientos ochenta y tres, pero que es un compilador.
+
+00:50.149 --> 00:55.329
+Un compilador es un traductor que convierte un programa escrito en lenguaje de programación a
+
+00:55.329 --> 00:59.090
+código Machine Un pocas palabras es Tú tienes tu código.
+
+00:59.119 --> 01:04.200
+El compilador lo que hace es agarrarlo, traducirlo a ceros y unos y dárselo a la máquina que
+
+01:04.200 --> 01:09.319
+son los binarios. Esto la computadora lo pueden tender y así puedes juntar tu programa El
+
+01:09.319 --> 01:13.920
+compilador que vamos Al se llama GC se porque vamos a este compilador porque es Open
+
+01:13.920 --> 01:18.040
+sols? Es que decir que hay múltiples programadores diferenciadas del mundo gratuitamente
+
+01:18.069 --> 01:25.280
+ayudando al proyecto no tiene ningún costo y la parte es público, es completamente gratis y
+
+01:25.280 --> 01:30.560
+aparte nuestro y de que vamos a estar, que es el programa del cual nos permite crear desarrollo este
+
+01:30.560 --> 01:36.969
+fácilmente de nuestro código Es cobros, al igual que Jeff, ese es un y de gratuito
+
+01:37.000 --> 01:41.760
+que no cuesta nada y no hay ningún problema cómo usarlo y aparte está siendo utilizado por
+
+01:41.760 --> 01:42.989
+diferentes programados del mundo.
+

subir/Curso Práctico de C/03-Preparando el entorno de trabajo/01-Instalación de CodeBlocks en Windows paso a paso.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3af61a3b1a7ea983c46d502815110b2b245ee93f4af725a7e9dbea9fc47b24f9
+size 32360328

subir/Curso Práctico de C/03-Preparando el entorno de trabajo/01-Instalación de CodeBlocks en Windows paso a paso.vtt

@@ -0,0 +1,143 @@
+WEBVTT
+
+00:03.439 --> 00:07.639
+Bueno, ahora que ya habíamos que vamos a usar destruida, que es el lugar donde va a escribir el código
+
+ --> 
+,
+
+00:07.639 --> 00:12.429
+ponerle play y ejecutar en estos programas Slash más vamos a la computadora para que dice Sánchez paso
+
+00:12.429 --> 00:19.550
+por paso como esta larga Ya estados. Ningún lo que van a hacer es escribir como blogs épicamente
+
+00:20.140 --> 00:24.179
+y el primer link que les va a salir. Todos los puntos tengan mucho cuidado, que no voy a hacer un
+
+00:24.179 --> 00:29.649
+Lin que este pirata de la AN click y va a quebrar la página oficial de cobros.
+
+00:30.039 --> 00:34.689
+Aquí dice con blogs es un hombre, es una plataforma Open shorts para hacer serás
+
+00:34.689 --> 00:40.240
+más y Ford tracked lo vamos a ver, parece más, más van a Iraq a la parte de arriba donde hice descargas
+
+ --> 
+,
+
+00:40.270 --> 00:45.759
+le van a dar clic y van a parar muchas opciones. Puede descargar el código fuente, que eso sería que
+
+00:45.759 --> 00:50.960
+usted quiere evitar, pero ahorita para la clase nos va a decir a esta parte de acá te dice descargar
+
+00:50.960 --> 00:56.619
+los binarios, le damos click y nos van a ser muchas opciones dependiendo de su sistema operativo.
+
+00:56.630 --> 01:04.340
+Es cual vamos a bajar Hay para Linux también hay para Mac pero en mi computadora yo estoy usando buenos
+
+ --> 
+.
+
+01:04.370 --> 01:09.439
+No cambia mucho la diferencia entre ambos y, por si acaso, puede dejar un escrito con Life los diferentes
+
+01:09.439 --> 01:13.239
+pasos de Windows Mac. Pero bueno, Para este ejemplo.
+
+01:13.269 --> 01:19.709
+Vamos cargar la versión de Windows que se llama con los diecisiete doce mil doble once top ex
+
+ --> 
+.
+
+01:19.739 --> 01:24.379
+Tengo mucho cuidado cuando descargarlas, otras porque la diferencia enrollado nosotras y esta es que
+
+01:24.379 --> 01:27.450
+está ya tiene el compilador instalado y no tienen que ser ningún paso.
+
+01:27.450 --> 01:30.849
+Esta va a ser le Clica son los foros para bajarlo.
+
+01:32.239 --> 01:34.760
+Y cuándo habrá les va a pedir que esperen tantito.
+
+01:34.790 --> 01:41.219
+Esto es para ver que no SandBox y ya cuando termine de empezar instalación SSL, el archivo que usted
+
+01:41.219 --> 01:48.420
+va en tren que bajar y lo van a guardar i grans. A la magia de la edición ya se terminó descargar.
+
+01:48.450 --> 01:54.650
+Entonces le pitó el botón de ejecutar y se abrir mi ventana.
+
+01:55.140 --> 01:57.879
+Voy a pedir permisos. A veces, así tienen no desactivados.
+
+01:57.879 --> 02:02.569
+Seguridad les puede pedir premio Estoy computadora y le van a poner que si no se preocupen, no es nada
+
+02:02.569 --> 02:07.530
+malo y le va a salir el instalador Hay que les va a salir que bienvenidos al se to óptico blogs usted
+
+02:07.530 --> 02:12.110
+le van a poner siguiente les a seguir la displicencia Si la quien a leer con detalle para saber que
+
+02:12.110 --> 02:14.310
+nos están vendiendo su alma Al diablo pueden hacerlo?
+
+02:14.310 --> 02:17.530
+Si, ningún problema. Pero yo no lo voy a hacer porque es una persona muy responsable y
+
+02:17.530 --> 02:22.740
+le voy a poner que estoy acuerdo. Me va a seguir todas sus opciones de las cuales yo Git instalar Todas
+
+02:22.740 --> 02:27.659
+vienen por de folk Palomeras Pero si quieren checar que es este las suyas estén Palomeras, Por favor
+
+ --> 
+,
+
+02:27.659 --> 02:30.849
+háganlo luego. A veces depende la computadora sea loca y no lo deja.
+
+02:31.240 --> 02:35.909
+Pero bueno, voy a poner siguiente y nada. Pero me va a poner la dirección en la cual yo quiero instalar
+
+02:35.909 --> 02:39.460
+mi programa. Me voy a poner la de fútbol. Pero ustedes pueden elegir aquí una
+
+02:39.460 --> 02:41.939
+específica en caso de que tengan otro disco duro o algo así.
+
+02:41.969 --> 02:47.389
+Y le voy a poner Instalar CTO En todos. Nos sale un montón de opciones y está viendo como locomotora
+
+02:47.389 --> 02:50.409
+trabaja y otra vez con el poder mágico de la dirección.
+
+02:50.439 --> 02:54.669
+Mi programa está listo para instalarse. Entonces me va a preguntar Quiero instalarme programa.
+
+02:54.699 --> 02:58.750
+Quiero poner mi programa de le decir que sí y lo ejecutaron.
+
+02:59.139 --> 03:01.530
+Listo? Acaba de instalar su programa Deco. Blogs.
+
+03:01.560 --> 03:06.819
+Muy bien, felicidades. O nos ha parecido antes de que termináramos este mensaje, que quiere decir
+
+03:06.819 --> 03:10.310
+que nuestro compilador se acuerdan que les enseñe el dibujo del toro.
+
+03:10.340 --> 03:15.629
+Es el GNU Jesse, compañero, Nuestro compiladores temas más está instalado correctamente y
+
+03:15.639 --> 03:20.250
+le ponemos o que yo y ahora sí, ya con eso tenemos instalado con los
+

subir/Curso Práctico de C/03-Preparando el entorno de trabajo/01-Lecturas recomendadas.txt

@@ -0,0 +1,2 @@
+http://www.codeblocks.org/
+https://sourceforge.net/projects/codeblocks/files/Binaries/17.12/Windows/codeblocks-17.12mingw-setup.exe/download

subir/Curso de Programación Orientada a Objetos con C/02-Estructuras de datos/02-Creación y uso de estructuras y punteros en C.vtt

@@ -0,0 +1,403 @@
+WEBVTT
+
+00:00:03.199 --> 00:00:05.839
+Vamos a continuar hablando sobre las estructuras de
+
+00:00:05.839 --> 00:00:08.080
+datos en C más más Para esto, vamos
+
+00:00:08.080 --> 00:00:10.880
+a crear nuestra primera estructura en código. Vamos
+
+00:00:10.880 --> 00:00:13.599
+a comenzar a crear nuestra primera estructura en
+
+00:00:13.599 --> 00:00:16.145
+el código. Esto lo vamos a hacer con
+
+00:00:16.145 --> 00:00:18.145
+el ejemplo de la clase anterior, donde estábamos
+
+00:00:18.145 --> 00:00:21.665
+hablando de cómo crear, pues información relacionada con
+
+00:00:21.665 --> 00:00:24.224
+una persona. Para esto vamos a utilizar la
+
+00:00:24.224 --> 00:00:27.220
+palabra reservada de C más más Struct. La
+
+00:00:27.220 --> 00:00:31.160
+forma de hacerlo sería generar en nuestro código
+
+00:00:31.619 --> 00:00:34.899
+lo siguiente. Struct el nombre de la estructura
+
+00:00:34.899 --> 00:00:36.900
+que vamos a crear. En este caso podemos
+
+00:00:36.900 --> 00:00:40.579
+llamarlo persona y a continuación vamos a abrir
+
+00:00:40.579 --> 00:00:42.600
+un par de llaves donde vamos a definir
+
+00:00:42.865 --> 00:00:45.265
+las características o los atributos que va a
+
+00:00:45.265 --> 00:00:49.025
+tener cada persona. En este caso, hablamos de
+
+00:00:49.025 --> 00:00:52.065
+el nombre y la edad. Como puedes ver,
+
+00:00:52.065 --> 00:00:54.465
+yo ya tengo importada mi librería para manejar
+
+00:00:54.465 --> 00:00:56.545
+cadenas de texto, así que puedo utilizar el
+
+00:00:56.545 --> 00:01:02.680
+tipo string. Entonces, string y el nombre de
+
+00:01:02.680 --> 00:01:04.840
+la variable que queremos crear, en este caso,
+
+00:01:04.840 --> 00:01:11.415
+el nombre. Terminamos con punto y coma, y
+
+00:01:11.415 --> 00:01:14.375
+a continuación podemos escribir otro dato que necesitemos,
+
+00:01:14.375 --> 00:01:16.455
+por ejemplo, la edad de la persona. En
+
+00:01:16.455 --> 00:01:23.140
+este caso sería un entero. Como puedes ver,
+
+00:01:23.140 --> 00:01:24.740
+no se está marcando un error y es
+
+00:01:24.740 --> 00:01:29.299
+porque necesitamos terminar con punto y coma. Ahora
+
+00:01:29.299 --> 00:01:31.619
+tenemos nuestra primera estructura de datos creada y
+
+00:01:31.619 --> 00:01:34.340
+podemos comenzar a utilizarla como un tipo de
+
+00:01:34.340 --> 00:01:37.445
+dato más. Vamos a utilizar nuestra estructura tipo
+
+00:01:37.445 --> 00:01:39.685
+persona para crear una variable. La forma de
+
+00:01:39.685 --> 00:01:42.564
+hacerlo sería indicando el tipo primero, como con
+
+00:01:42.564 --> 00:01:45.604
+todas las variables, así como utilizamos, por ejemplo,
+
+00:01:45.604 --> 00:01:48.325
+int, y para crear una variable de tipo
+
+00:01:48.325 --> 00:01:52.100
+entero llamada I, podemos utilizar la palabra persona
+
+00:01:52.100 --> 00:01:54.759
+que acabamos de definir como un tipo y
+
+00:01:56.020 --> 00:01:58.500
+podemos crear una variable para que la utilice.
+
+00:01:58.500 --> 00:02:00.200
+En este caso, yo la voy a nombrar
+
+00:02:00.259 --> 00:02:04.285
+p. Yo podría terminar la declaración de mi
+
+00:02:04.285 --> 00:02:08.125
+variable allí. Sin embargo, también podría definirle un
+
+00:02:08.125 --> 00:02:10.525
+valor inicial como lo hemos realizado con otras
+
+00:02:10.525 --> 00:02:13.005
+variables. En este caso, yo podría ponerle que
+
+00:02:13.005 --> 00:02:18.590
+es tipo persona y con paréntesis, y esto
+
+00:02:18.590 --> 00:02:20.750
+lo que va a hacer es inicializar un
+
+00:02:20.750 --> 00:02:24.190
+nuevo valor de persona y almacenarlo dentro de
+
+00:02:24.190 --> 00:02:27.230
+mi variable p. Esta es una forma de
+
+00:02:27.230 --> 00:02:30.285
+hacerlo en la que nuestro compilador, desde el
+
+00:02:30.285 --> 00:02:33.084
+proceso de del del tiempo de compilación, va
+
+00:02:33.084 --> 00:02:35.405
+a crear la persona y va a reservar
+
+00:02:35.405 --> 00:02:38.765
+su memoria. Sin embargo, podemos querer hacerlo por
+
+00:02:38.765 --> 00:02:41.565
+memoria dinámica, y para esto podemos utilizar los
+
+00:02:41.565 --> 00:02:44.900
+punteros. La forma de hacerlo sería utilizar, en
+
+00:02:44.900 --> 00:02:48.280
+lugar de crear una variable persona p, podríamos
+
+00:02:48.500 --> 00:02:51.300
+crear un puntero que pueda apuntar a una
+
+00:02:51.300 --> 00:02:54.995
+persona. La forma sería utilizar el asterisco y
+
+00:02:54.995 --> 00:02:56.355
+aquí, pues, ahora me va a dar un
+
+00:02:56.355 --> 00:02:58.394
+error y la razón es que yo ya
+
+00:02:58.394 --> 00:03:01.875
+no estoy creando este espacio tipo persona, sino
+
+00:03:01.875 --> 00:03:05.015
+es un puntero a persona. Para generar dinámicamente
+
+00:03:05.875 --> 00:03:08.114
+una nueva persona y almacenarla en la variable
+
+00:03:08.114 --> 00:03:11.953
+p, dado que esta es un puntero, tendría
+
+00:03:11.959 --> 00:03:15.320
+que utilizar la palabra reservada new. Con esto
+
+00:03:15.320 --> 00:03:16.920
+me va a dejar de dar el error,
+
+00:03:16.920 --> 00:03:18.780
+porque lo que está pasando aquí es que
+
+00:03:19.080 --> 00:03:21.960
+va primero a generar un puntero y durante
+
+00:03:21.960 --> 00:03:25.015
+la ejecución, ya no durante la compilación, con
+
+00:03:25.015 --> 00:03:28.415
+new vamos a crear una nueva persona. Las
+
+00:03:28.415 --> 00:03:31.075
+dos formas son válidas y la única variación
+
+00:03:31.295 --> 00:03:33.694
+sería a la hora de utilizarlas. Si yo
+
+00:03:33.694 --> 00:03:38.515
+quisiera utilizar la variable p de forma tradicional,
+
+00:03:38.680 --> 00:03:42.040
+podría realizarlo con un punto. Por ejemplo, si
+
+00:03:42.040 --> 00:03:45.000
+yo quiero acceder al nombre de la persona,
+
+00:03:45.000 --> 00:03:50.680
+podría utilizar p punto nombre. Con esto, como
+
+00:03:50.680 --> 00:03:53.000
+cualquier otra variable, yo estaría accediendo a ese
+
+00:03:53.000 --> 00:03:56.795
+valor. Yo podría leerlo, por ejemplo, mostrarlo en
+
+00:03:56.795 --> 00:03:59.674
+un si out o podría asignarle un nuevo
+
+00:03:59.674 --> 00:04:03.674
+valor, por ejemplo, con una cadena de texto.
+
+00:04:03.674 --> 00:04:05.775
+En este caso podría poner, por ejemplo, Diana
+
+00:04:06.820 --> 00:04:08.660
+y ahí está. Por ejemplo, ahí le puedo
+
+00:04:08.660 --> 00:04:11.460
+poner Diana, luego le puedo poner otro valor
+
+00:04:11.460 --> 00:04:13.620
+para la edad también. Por ejemplo, yo puedo
+
+00:04:13.620 --> 00:04:17.140
+poner veintiséis y por ejemplo, vamos a mostrarlo
+
+00:04:17.140 --> 00:04:20.694
+con Seattle. Primero vamos a mostrar el nombre
+
+00:04:25.715 --> 00:04:27.574
+y voy a hacer un cambio de línea.
+
+00:04:29.875 --> 00:04:35.610
+Y ahora vamos a mostrar la edad. Si
+
+00:04:35.610 --> 00:04:38.889
+ejecutamos esto con la tecla F seis, vamos
+
+00:04:38.889 --> 00:04:40.990
+a ver que el resultado de nuestro programa
+
+00:04:41.370 --> 00:04:44.250
+es primero, se muestra el nombre de la
+
+00:04:44.250 --> 00:04:47.310
+persona y a continuación se muestra la edad.
+
+00:04:48.125 --> 00:04:50.764
+Lo siguiente que podemos hacer es probar la
+
+00:04:50.764 --> 00:04:54.445
+versión con punteros. Para esto, convertimos la variable
+
+00:04:54.445 --> 00:04:58.544
+p en tipo puntero y utilizamos el operador
+
+00:04:58.764 --> 00:05:01.810
+new. Ahora nos va a dar un error
+
+00:05:01.810 --> 00:05:03.810
+a la hora de tratar leer la variable
+
+00:05:03.810 --> 00:05:06.210
+nombre y la variable edad utilizando la anotación
+
+00:05:06.210 --> 00:05:08.290
+de punto. Lo que tenemos que hacer es
+
+00:05:08.290 --> 00:05:12.690
+utilizando es utilizar la anotación de flecha para
+
+00:05:12.690 --> 00:05:16.395
+poder indicarle que estamos haciendo uso de punteros.
+
+00:05:17.574 --> 00:05:19.975
+De esta manera, nuestro programa va a volver
+
+00:05:19.975 --> 00:05:22.134
+a funcionar. Lo mismo a la hora de
+
+00:05:22.134 --> 00:05:29.275
+leerlo. Ahora puedo volver a ejecutar mi programa
+
+00:05:29.569 --> 00:05:31.830
+y va a funcionar de la misma manera
+
+00:05:32.050 --> 00:05:35.490
+en que funcionó antes. La diferencia, como habíamos
+
+00:05:35.490 --> 00:05:38.229
+visto, es que si tú creas una variable
+
+00:05:38.370 --> 00:05:41.569
+tipo persona que no sea puntero, eso se
+
+00:05:41.569 --> 00:05:45.065
+va a reservar como, pues, memoria desde que
+
+00:05:45.065 --> 00:05:48.344
+se está compilando. Mientras que su si tú
+
+00:05:48.344 --> 00:05:51.865
+utilizas un asterisco y la palabra new, estás
+
+00:05:51.865 --> 00:05:54.664
+ejecutando el programa y durante la ejecución se
+
+00:05:54.664 --> 00:05:57.980
+va a crear esta persona. Se está gestionando
+
+00:05:57.980 --> 00:06:01.740
+la memoria de forma dinámica. La representación de
+
+00:06:01.740 --> 00:06:03.820
+la persona que acabamos de crear en la
+
+00:06:03.820 --> 00:06:07.580
+memoria sería la siguiente, suponiendo que creamos sin
+
+00:06:07.580 --> 00:06:12.225
+punteros esta información o con punteros, igualmente el
+
+00:06:12.605 --> 00:06:15.645
+lenguaje de programación lo que va a realizar
+
+00:06:15.645 --> 00:06:18.365
+es apartar un segmento de memoria del tamaño
+
+00:06:18.365 --> 00:06:21.645
+de bytes que, pues, dependiendo si declaramos, por
+
+00:06:21.645 --> 00:06:24.130
+ejemplo, el nombre como string, pues va a
+
+00:06:24.130 --> 00:06:26.970
+almacenar la cantidad de caracteres necesarios para almacenar
+
+00:06:26.970 --> 00:06:30.570
+el nombre y el carácter de cierre, que
+
+00:06:30.570 --> 00:06:34.010
+es el carácter vacío, y además le va
+
+00:06:34.010 --> 00:06:36.650
+a sumar, pues la cantidad de memoria necesaria
+
+00:06:36.650 --> 00:06:39.815
+para almacenar la edad. Funcionaría de la forma
+
+00:06:39.815 --> 00:06:41.655
+en que lo estás viendo en pantalla y,
+
+00:06:41.655 --> 00:06:43.975
+por lo tanto, si tú quisieras acceder, ya
+
+00:06:43.975 --> 00:06:46.295
+sea a los valores de los punteros, al
+
+00:06:46.295 --> 00:06:48.695
+valor de la variable, tanto de nombre como
+
+00:06:48.695 --> 00:06:53.230
+de edad, podrías, pues, imprimirlo con COUT y
+
+00:06:53.230 --> 00:06:54.830
+ver que lo que se muestra en el
+
+00:06:54.830 --> 00:06:58.050
+recuadro negro sería correcto. Te invito a probarlo
+
+00:06:58.430 --> 00:07:01.070
+en tu computadora, puedes hacer COUT y realizar
+
+00:07:01.070 --> 00:07:03.596
+cada una de las siguientes operaciones para que,
+
+00:07:03.596 --> 00:07:06.736
+pues, tengas la experiencia de cómo funcionan internamente
+
+00:07:06.796 --> 00:07:07.536
+los punteros.

subir/Curso de Programación Orientada a Objetos con C/02-Estructuras de datos/03-Uniones y Enumeraciones en C Gestión Eficiente de Memoria.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:343969521c85b77eb6e865becdbeeda36524402bb7bbcfe481dff8258e305e7d
+size 102710230

subir/Curso de Programación Orientada a Objetos con C/02-Estructuras de datos/03-Uniones y Enumeraciones en C Gestión Eficiente de Memoria.vtt

@@ -0,0 +1,559 @@
+WEBVTT
+
+00:00:03.360 --> 00:00:05.859
+Ahora vamos a hablar sobre uniones y enumeraciones.
+
+00:00:06.480 --> 00:00:09.540
+Son dos conceptos bastante importantes y bastante útiles
+
+00:00:09.679 --> 00:00:11.599
+a la hora de gestionar la memoria, ya
+
+00:00:11.599 --> 00:00:15.075
+que nos permiten, pues, ahorrar espacios de memoria
+
+00:00:15.215 --> 00:00:18.035
+en la RAM para almacenar datos que sabemos
+
+00:00:18.175 --> 00:00:20.735
+que pueden compartir la memoria porque no van
+
+00:00:20.735 --> 00:00:23.294
+a existir al mismo tiempo. Vamos al ejemplo
+
+00:00:23.294 --> 00:00:25.615
+de código. Lo primero que vamos a hacer
+
+00:00:25.615 --> 00:00:28.410
+es utilizar las uniones. Las uniones son un
+
+00:00:28.410 --> 00:00:29.850
+tipo de estructura especial que nos va a
+
+00:00:29.850 --> 00:00:32.729
+servir para almacenar en el mismo espacio de
+
+00:00:32.729 --> 00:00:37.130
+memoria diferentes valores. Por ejemplo, si quisiera una
+
+00:00:37.130 --> 00:00:39.770
+unión que me permita almacenar un número o
+
+00:00:39.770 --> 00:00:42.165
+una letra, pero solo una a la vez,
+
+00:00:42.325 --> 00:00:45.765
+podría realizarlo de la siguiente manera. Comenzamos con
+
+00:00:45.765 --> 00:00:50.005
+la palabra reservada unión. Ahora le podemos poner
+
+00:00:50.005 --> 00:00:56.300
+un un nombre, por ejemplo, número letra. Aquí
+
+00:00:56.300 --> 00:01:00.460
+me faltó la número letra. Ahora podemos darle,
+
+00:01:00.460 --> 00:01:02.540
+pues, una definición de qué tipo de valores
+
+00:01:02.540 --> 00:01:04.540
+va a almacenar, y eso lo hacemos, pues,
+
+00:01:04.540 --> 00:01:06.620
+muy similar a las estructuras utilizando un par
+
+00:01:06.620 --> 00:01:10.455
+de llaves. Y ahora sí, de la misma
+
+00:01:10.455 --> 00:01:12.155
+forma en que lo hacíamos en las estructuras,
+
+00:01:12.615 --> 00:01:16.055
+podemos indicarle los diferentes valores alternativos que va
+
+00:01:16.055 --> 00:01:18.695
+a poder almacenar. Por ejemplo, si yo quiero
+
+00:01:18.695 --> 00:01:22.055
+almacenar un entero, puedo indicarle un int y
+
+00:01:22.055 --> 00:01:26.009
+que se va a llamar número, Puedo no
+
+00:01:26.009 --> 00:01:30.170
+inicializarlo y dejarlo vacío y puedo crear ahora,
+
+00:01:30.170 --> 00:01:32.429
+por ejemplo, la letra podría ser tipo carácter
+
+00:01:35.289 --> 00:01:37.450
+y listo. Con esto lo que tengo es
+
+00:01:37.450 --> 00:01:39.844
+una unión que es capaz de almacenar, pues,
+
+00:01:39.844 --> 00:01:42.164
+en el mismo espacio de memoria RAM, tanto
+
+00:01:42.164 --> 00:01:44.005
+un número como una letra, y lo va
+
+00:01:44.005 --> 00:01:46.804
+a interpretar de diferente manera gracias a que
+
+00:01:46.804 --> 00:01:48.645
+le indicamos que uno lo va a interpretar
+
+00:01:48.645 --> 00:01:51.600
+como int, la palabra, la variable número, y
+
+00:01:51.600 --> 00:01:54.020
+cuando lo invoquemos como letra, va a saber,
+
+00:01:54.080 --> 00:01:56.420
+gracias a esta declaración, que es un carácter.
+
+00:01:56.800 --> 00:01:58.880
+Vamos a utilizarlo de la siguiente manera. Vamos
+
+00:01:58.880 --> 00:02:02.240
+a realizar, por ejemplo, una asignación y se
+
+00:02:02.240 --> 00:02:04.720
+utiliza como un tipo. Por ejemplo, yo quiero
+
+00:02:04.720 --> 00:02:07.140
+crear una variable que sea tipo número letra,
+
+00:02:09.655 --> 00:02:12.635
+la crearía escribiendo el tipo y a continuación
+
+00:02:12.935 --> 00:02:15.655
+el nombre. Yo solo voy a ponerle x
+
+00:02:15.655 --> 00:02:19.334
+por fines de practicidad y la única condición
+
+00:02:19.334 --> 00:02:22.135
+o la única diferencia con una variable normal
+
+00:02:22.135 --> 00:02:24.190
+es que esto se comporta más o menos
+
+00:02:24.190 --> 00:02:28.130
+como una lista porque necesitamos colocarlo entre llaves.
+
+00:02:28.510 --> 00:02:30.670
+Ahora sí, podemos indicarle cuál va a ser
+
+00:02:30.670 --> 00:02:33.069
+su valor. En este caso, supongamos que yo
+
+00:02:33.069 --> 00:02:35.550
+quiero almacenar una letra, por ejemplo, la letra
+
+00:02:35.550 --> 00:02:38.370
+a. Lo podría realizar de la siguiente manera.
+
+00:02:38.955 --> 00:02:42.474
+Con esto, yo creé una variable que es
+
+00:02:42.474 --> 00:02:45.754
+tipo número letra, que se llama x. Esta
+
+00:02:45.754 --> 00:02:48.394
+yo la puedo imprimir en pantalla y leerla,
+
+00:02:48.394 --> 00:02:50.715
+ya sea como número o como letra, dependiendo
+
+00:02:50.715 --> 00:02:53.910
+de cómo la invoque. Vamos a hacerlo. Puedo
+
+00:02:54.210 --> 00:02:56.610
+escribir un c out y vamos a ver
+
+00:02:56.610 --> 00:03:07.385
+que se muestre x como un número. Vamos
+
+00:03:07.385 --> 00:03:13.185
+a invocarla con el nombre de la variable
+
+00:03:13.185 --> 00:03:15.505
+y a continuación, dado que es una unión,
+
+00:03:15.505 --> 00:03:17.985
+ya nuestro editor de código nos va a
+
+00:03:17.985 --> 00:03:20.385
+recomendar, pues, las dos posibilidades. En este caso,
+
+00:03:20.385 --> 00:03:22.480
+si lo quiero leer como número, lo puedo
+
+00:03:22.480 --> 00:03:24.560
+leer así y voy a hacer un cambio
+
+00:03:24.560 --> 00:03:28.880
+de línea. Y lo mismo sucedería si lo
+
+00:03:28.880 --> 00:03:38.505
+quiero leer, pues como una letra. Puedo realizar
+
+00:03:39.365 --> 00:03:42.025
+el nombre de la variable punto y letra.
+
+00:03:43.205 --> 00:03:45.545
+Ahora vamos a ver qué sucede al ejecutarlo.
+
+00:03:50.420 --> 00:03:52.900
+Lo que puedes observar es que, de una
+
+00:03:52.900 --> 00:03:55.780
+forma u otra, nuestro compilador imprime el valor
+
+00:03:55.780 --> 00:03:59.560
+que estamos esperando. Como mencionaba, esto es posible
+
+00:03:59.780 --> 00:04:03.645
+gracias a que la letra a está almacenada
+
+00:04:03.645 --> 00:04:06.045
+en la misma dirección de memoria. Por lo
+
+00:04:06.045 --> 00:04:08.045
+tanto, cuando la imprimimos como número, lo que
+
+00:04:08.045 --> 00:04:10.465
+nos va a dar es su equivalente numérico
+
+00:04:11.085 --> 00:04:13.725
+en la tabla ASCII. Como vimos en las
+
+00:04:13.725 --> 00:04:16.990
+primeras clases, los caracteres se almacenan en, pues,
+
+00:04:16.990 --> 00:04:19.729
+su equivalente numérico dentro de la memoria RAM,
+
+00:04:20.029 --> 00:04:22.830
+mientras que cuando le pedimos la el mismo
+
+00:04:22.830 --> 00:04:24.750
+valor, pero en forma de letra, nos va
+
+00:04:24.750 --> 00:04:28.365
+a devolver directamente la letra a. Una forma
+
+00:04:28.365 --> 00:04:31.245
+de comprobarlo sería si yo tomara ese número
+
+00:04:31.245 --> 00:04:35.085
+y lo convirtiera de forma estática en un
+
+00:04:35.085 --> 00:04:37.565
+carácter en lugar de en un número. Lo
+
+00:04:37.565 --> 00:04:39.485
+podría hacer justo como lo hemos realizado en
+
+00:04:39.485 --> 00:04:42.045
+otras clases, indicándole que yo lo quiero como
+
+00:04:42.045 --> 00:04:46.229
+carácter. De esta manera, vamos a forzar esa
+
+00:04:46.229 --> 00:04:49.189
+conversión y las dos ocasiones nos va a
+
+00:04:49.189 --> 00:04:51.750
+mostrar una letra a. Lo mismo pasaría si
+
+00:04:51.750 --> 00:04:54.870
+yo tengo esta letra y la quiero interpretar,
+
+00:04:54.870 --> 00:04:57.030
+pero como un número. Podría decirle que lo
+
+00:04:57.030 --> 00:05:00.055
+quiero como un entero y cuando realice la
+
+00:05:00.055 --> 00:05:02.135
+ejecución, ahora me va a dar el número
+
+00:05:02.135 --> 00:05:05.575
+sesenta y cinco. La siguiente estructura sería las
+
+00:05:05.575 --> 00:05:08.535
+enumeraciones, y las enumeraciones nos sirven para algo
+
+00:05:08.535 --> 00:05:12.615
+muy parecido, ahorrar memoria utilizando el mismo registro
+
+00:05:12.615 --> 00:05:15.460
+dentro de la memoria RAM, sabiendo que no
+
+00:05:15.460 --> 00:05:17.380
+vamos a utilizar dos de sus valores a
+
+00:05:17.380 --> 00:05:19.220
+la vez, solo uno. Y la forma en
+
+00:05:19.220 --> 00:05:21.139
+que funcionan es la siguiente. Tú vas a
+
+00:05:21.139 --> 00:05:24.100
+escribir la palabra reservada en un para comenzar
+
+00:05:24.100 --> 00:05:27.495
+a declarar una enumeración y su utilidad es
+
+00:05:27.895 --> 00:05:29.435
+por la que vamos a ver a continuación.
+
+00:05:29.495 --> 00:05:31.435
+En este caso, si yo quisiera, por ejemplo,
+
+00:05:32.615 --> 00:05:35.735
+establecer un calendario en el que asistes o
+
+00:05:35.735 --> 00:05:39.014
+en el que realizas alguna actividad, pues probablemente
+
+00:05:39.014 --> 00:05:41.514
+esa actividad va a tener una fecha, un
+
+00:05:41.574 --> 00:05:44.380
+día, un mes, etcétera, ¿no? Ahora, si yo
+
+00:05:44.380 --> 00:05:46.460
+quisiera solo almacenar una fecha y no todas
+
+00:05:46.460 --> 00:05:49.280
+las fechas posibles, por ejemplo, yo quisiera almacenar
+
+00:05:49.660 --> 00:05:51.100
+solo un día de la semana en el
+
+00:05:51.100 --> 00:05:53.440
+que sucedió o va a suceder esa acción,
+
+00:05:53.820 --> 00:05:56.240
+pues puedo dar por hecho que puedo almacenar
+
+00:05:56.300 --> 00:05:58.544
+los días de la semana en una misma
+
+00:05:58.604 --> 00:06:01.724
+variable y que dependiendo, pues, esa actividad, es
+
+00:06:01.724 --> 00:06:04.604
+el día que voy a almacenar. Yo podría
+
+00:06:04.604 --> 00:06:07.405
+hacer esto de la siguiente manera. Podría indicarle
+
+00:06:07.405 --> 00:06:09.324
+una variable que se llame días de la
+
+00:06:09.324 --> 00:06:18.510
+semana. Con esto estaría definiendo un tipo de
+
+00:06:18.510 --> 00:06:21.729
+dato que ya puedo invocar y que puedo
+
+00:06:21.870 --> 00:06:24.030
+crear cuáles son los diferentes días de la
+
+00:06:24.030 --> 00:06:26.845
+semana, los diferentes valores que puede obtener. En
+
+00:06:26.845 --> 00:06:31.665
+este caso podríamos introducirlos, por ejemplo, lunes, martes,
+
+00:06:33.645 --> 00:06:38.045
+miércoles. A partir de ese momento, yo ya
+
+00:06:38.045 --> 00:06:40.650
+puedo crear variables que sean de tipo días
+
+00:06:40.650 --> 00:06:43.450
+de la semana. Por ejemplo, si yo tengo
+
+00:06:43.450 --> 00:06:45.450
+una variable tipo días de la semana llamada
+
+00:06:45.450 --> 00:06:53.210
+día, yo ya puedo inicializarla con alguno de
+
+00:06:53.210 --> 00:07:02.384
+los valores posibles, por ejemplo, martes. Ahora, ¿qué
+
+00:07:02.384 --> 00:07:05.345
+pasaría si yo quisiera imprimir el valor de
+
+00:07:05.345 --> 00:07:07.585
+esta variable que se llama día? Vamos a
+
+00:07:07.585 --> 00:07:14.280
+hacerlo. Voy a terminar la línea anterior en
+
+00:07:14.280 --> 00:07:17.000
+cambio de línea para que haga, para que
+
+00:07:17.000 --> 00:07:21.880
+lo muestre en el siguiente renglón. Como puedes
+
+00:07:21.880 --> 00:07:24.120
+ver, al final de la salida, mi terminal
+
+00:07:24.120 --> 00:07:26.625
+está imprimiendo el número uno. ¿Por qué pasa
+
+00:07:26.625 --> 00:07:29.985
+esto? Porque cuando yo creo la enumeración, en
+
+00:07:29.985 --> 00:07:32.145
+ese momento empiezo a escribir una serie de
+
+00:07:32.145 --> 00:07:35.345
+valores posibles que yo puedo, pues leer como
+
+00:07:35.345 --> 00:07:37.985
+ser humano. Sin embargo, para la computadora esto
+
+00:07:37.985 --> 00:07:40.860
+debe tener, pues alguna representación numérica por debajo.
+
+00:07:40.860 --> 00:07:42.939
+Como no tiene otra forma de saber cuál
+
+00:07:42.939 --> 00:07:46.879
+es esa representación, representación numérica, asume que estamos
+
+00:07:47.099 --> 00:07:49.020
+tratando de una lista ordenada y, por lo
+
+00:07:49.020 --> 00:07:51.259
+tanto, lo va a manejar como si fuera
+
+00:07:51.259 --> 00:07:53.500
+un array. Simplemente, el primer valor va a
+
+00:07:53.500 --> 00:07:55.259
+ser cero, el segundo valor va a ser
+
+00:07:55.259 --> 00:07:58.285
+uno y así sucesivamente hasta la cantidad de
+
+00:07:58.285 --> 00:08:01.645
+valores que tengamos dentro de nuestra enumeración. De
+
+00:08:01.645 --> 00:08:04.285
+esta manera, si yo quisiera almacenar en la
+
+00:08:04.285 --> 00:08:07.085
+variable día un número de la semana, solamente
+
+00:08:07.085 --> 00:08:10.205
+va a almacenar el valor correspondiente a ese
+
+00:08:10.205 --> 00:08:13.530
+día. Ahora, ¿qué sucedería si yo quisiera cambiar
+
+00:08:13.530 --> 00:08:16.169
+el comportamiento por defecto de las enumeraciones para
+
+00:08:16.169 --> 00:08:18.490
+que tengan un valor no numérico? Pues yo
+
+00:08:18.490 --> 00:08:21.470
+podría hacerlo asignándole a cada una de sus
+
+00:08:21.690 --> 00:08:25.115
+de sus posibles valores una equivalencia. Por ejemplo,
+
+00:08:25.115 --> 00:08:27.294
+si yo quisiera que el lunes se represente
+
+00:08:27.835 --> 00:08:30.155
+internamente como un carácter, podría ser algo como
+
+00:08:30.155 --> 00:08:33.755
+esto, podría indicar un símbolo de igual y
+
+00:08:33.755 --> 00:08:37.169
+el carácter l, por ejemplo, para indicar, pues,
+
+00:08:37.329 --> 00:08:39.970
+que es lunes podría ser cualquier carácter. Y
+
+00:08:39.970 --> 00:08:41.889
+para el martes voy a utilizar, por ejemplo,
+
+00:08:41.889 --> 00:08:45.250
+una m y para el miércoles, para no
+
+00:08:45.250 --> 00:08:47.329
+repetir, pues voy a utilizar una x, por
+
+00:08:47.329 --> 00:08:50.690
+ejemplo. De esta manera, si ahora yo quiero
+
+00:08:50.690 --> 00:08:54.055
+imprimir el valor en pantalla, verás que obtendré,
+
+00:08:54.115 --> 00:08:55.955
+pues aquí lo que sucedió es que muestra
+
+00:08:55.955 --> 00:08:59.555
+el carácter, pues ASCII, el equivalente numérico, pero
+
+00:08:59.555 --> 00:09:01.715
+si yo lo imprimo, aquí le pido que
+
+00:09:01.715 --> 00:09:06.610
+lo haga como carácter. Voy a obtener, pues,
+
+00:09:06.610 --> 00:09:08.050
+la letra que yo haya seleccionado para el
+
+00:09:08.050 --> 00:09:12.930
+valor que establecí para mi enumeración. Como puedes
+
+00:09:12.930 --> 00:09:15.570
+ver, las uniones y las enumeraciones pueden ser
+
+00:09:15.570 --> 00:09:18.690
+bastante útiles cuando queremos optimizar el espacio en
+
+00:09:18.690 --> 00:09:21.255
+memoria, ya que de esta manera, pues nos
+
+00:09:21.255 --> 00:09:23.815
+permiten almacenar en el mismo registro de la
+
+00:09:23.815 --> 00:09:26.214
+memoria RAM, pues todos los datos que puedan
+
+00:09:26.214 --> 00:09:28.454
+llegar a tener o llegar a suceder para
+
+00:09:28.454 --> 00:09:31.495
+una variable. Y esto lo podemos combinar con
+
+00:09:31.495 --> 00:09:35.690
+nuestro conocimiento de punteros y de estructuras. Realmente,
+
+00:09:35.910 --> 00:09:39.110
+pues, este es un tema bastante complejo y
+
+00:09:39.110 --> 00:09:42.150
+bastante diverso dentro del lenguaje programación C más
+
+00:09:42.150 --> 00:09:44.870
+más, y ahora vamos a pasar al siguiente
+
+00:09:44.870 --> 00:09:47.530
+tema, que es la programación orientada a objetos.

subir/Curso de Programación Orientada a Objetos con C/03-Introducción a la Programación Orientada a Objetos/01-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://platzi.com/cursos/oop/

subir/Curso de Programación Orientada a Objetos con C/03-Introducción a la Programación Orientada a Objetos/01-Programación Orientada a Objetos en C Conceptos Básicos.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44bf5da0e75f85698dd5c15f735473a05a60b3c7191ba86e2393561fbf5ce592
+size 55711549

subir/Curso de Programación Orientada a Objetos con C/03-Introducción a la Programación Orientada a Objetos/01-Programación Orientada a Objetos en C Conceptos Básicos.vtt

@@ -0,0 +1,307 @@
+WEBVTT
+
+00:00:03.520 --> 00:00:05.759
+Vamos a comenzar con este nuevo tema, que
+
+00:00:05.759 --> 00:00:09.040
+es la programación orientada a objetos. La programación
+
+00:00:09.040 --> 00:00:11.280
+orientada a objetos, como vimos, es la gran
+
+00:00:11.280 --> 00:00:13.405
+diferencia entre seis e más más. Es el
+
+00:00:13.405 --> 00:00:16.925
+paradigma que Jern Strollstruft agregó al compilador de
+
+00:00:16.925 --> 00:00:18.925
+C más más para, al compilador de C
+
+00:00:18.925 --> 00:00:22.125
+para crear C más más. Con todo esto,
+
+00:00:22.125 --> 00:00:25.185
+la capacidad de programación orienta a objetos es,
+
+00:00:25.360 --> 00:00:26.880
+pues, muy diversa. La verdad es que es
+
+00:00:26.880 --> 00:00:30.740
+bastante completo el ecosistema de programación de objetos,
+
+00:00:31.040 --> 00:00:33.840
+muchos lenguajes de programación lo soportan y es
+
+00:00:33.840 --> 00:00:36.160
+todo un tema de estudio. Por lo tanto,
+
+00:00:36.160 --> 00:00:39.280
+quiero recordarte que en estas clases solamente vamos
+
+00:00:39.280 --> 00:00:42.375
+a hablar sobre cómo funciona o cómo se
+
+00:00:42.375 --> 00:00:45.094
+implementa una programación orientada a objetos en C
+
+00:00:45.094 --> 00:00:47.975
+más más. Sin embargo, si quieres conocer, pues,
+
+00:00:47.975 --> 00:00:50.875
+a mayor profundidad y con mayor contexto y
+
+00:00:51.254 --> 00:00:53.015
+teoría lo que es la programación orientada a
+
+00:00:53.015 --> 00:00:55.050
+objetos y todo lo que implica, te invito
+
+00:00:55.050 --> 00:00:57.610
+a realizar el curso de Platzi de programación
+
+00:00:57.610 --> 00:01:00.350
+orientada a objetos. Pero, ¿qué es un objeto?
+
+00:01:00.650 --> 00:01:03.850
+Pues, un objeto es una, pues, entidad que
+
+00:01:03.850 --> 00:01:06.350
+puede existir en el mundo físico o no,
+
+00:01:06.410 --> 00:01:09.985
+pero que tiene las siguientes características. Tiene una
+
+00:01:09.985 --> 00:01:12.885
+clase, es decir, es cierto tipo de objeto,
+
+00:01:13.065 --> 00:01:15.105
+tiene un nombre, que es lo que le
+
+00:01:15.105 --> 00:01:18.785
+da su identidad, y tiene una serie de
+
+00:01:18.785 --> 00:01:21.925
+propiedades y métodos. Las propiedades son todas estas,
+
+00:01:22.120 --> 00:01:26.700
+pues, características que son descriptivas. Por ejemplo, si
+
+00:01:26.760 --> 00:01:28.600
+un carro tiene un color, eso es una
+
+00:01:28.600 --> 00:01:31.820
+propiedad. Si un animal, pues, es de cierta
+
+00:01:31.960 --> 00:01:35.215
+especie, eso también es una propiedad. Y los
+
+00:01:35.215 --> 00:01:37.295
+métodos son las cosas que el objeto puede
+
+00:01:37.295 --> 00:01:40.335
+hacer. Por ejemplo, si un carro puede acelerar
+
+00:01:40.335 --> 00:01:42.994
+o frenar, esas son acciones que puede realizar.
+
+00:01:43.295 --> 00:01:45.854
+Si una persona puede hablar o saludar, esas
+
+00:01:45.854 --> 00:01:48.940
+también son acciones que puede realizar. En programación
+
+00:01:49.080 --> 00:01:51.640
+orientada a objetos, como paradigma, lo que tratamos
+
+00:01:51.640 --> 00:01:55.180
+de hacer es escribir nuestros programas pensando en
+
+00:01:55.480 --> 00:01:58.700
+entidades y cómo estas funcionan y se colaboran
+
+00:01:59.000 --> 00:02:02.844
+para intercambiar información. Por ejemplo, si quisiéramos modelar,
+
+00:02:02.844 --> 00:02:06.125
+pues, una empresa por medio de programación de
+
+00:02:06.125 --> 00:02:08.845
+orientación a objetos, podríamos hablar de que una
+
+00:02:08.845 --> 00:02:12.685
+persona puede tener un correo electrónico institucional y
+
+00:02:12.685 --> 00:02:15.832
+si puede realizar ciertas acciones, que serían sus
+
+00:02:15.832 --> 00:02:19.380
+métodos, pues podría ser enviar correos. Con esto
+
+00:02:19.380 --> 00:02:23.300
+tenemos una definición completa que no solamente define,
+
+00:02:23.300 --> 00:02:26.520
+como lo vimos anteriormente, una estructura de datos,
+
+00:02:27.220 --> 00:02:30.100
+pues que almacena información, sino que además nos
+
+00:02:30.100 --> 00:02:34.235
+permite agregar comportamiento a la identidad de cada
+
+00:02:34.235 --> 00:02:36.875
+objeto o de cada entidad. Pero, ¿qué es
+
+00:02:36.875 --> 00:02:39.435
+la programación orientada a objetos para C más
+
+00:02:39.435 --> 00:02:41.355
+más? Pues, para C más más, como para
+
+00:02:41.355 --> 00:02:44.015
+muchos otros lenguajes, es una serie de conceptos
+
+00:02:44.155 --> 00:02:45.995
+que se van a implementar al mismo. En
+
+00:02:45.995 --> 00:02:48.630
+este caso, tenemos dos conceptos principales de los
+
+00:02:48.630 --> 00:02:49.910
+que vamos a hablar en este momento y
+
+00:02:49.910 --> 00:02:51.690
+algunos otros de los que vamos a hablar
+
+00:02:51.750 --> 00:02:54.490
+en el resto del curso. Estos dos son,
+
+00:02:54.630 --> 00:02:57.930
+pues, la abstracción, que es la capacidad de
+
+00:02:57.990 --> 00:03:00.390
+realizar programas a partir de definiciones abstractas, es
+
+00:03:00.390 --> 00:03:03.165
+decir, en lugar de estar programando para cómo
+
+00:03:03.165 --> 00:03:06.444
+funciona internamente la computadora, como habría sido programar
+
+00:03:06.444 --> 00:03:10.125
+en C, ahora pensaríamos en términos de objetos
+
+00:03:10.125 --> 00:03:13.405
+y de ideas de entidades abstractas que tienen
+
+00:03:13.405 --> 00:03:16.290
+sus atributos y sus métodos. Y por medio
+
+00:03:16.290 --> 00:03:19.769
+de esto, también solo mostrar la información esencial
+
+00:03:19.769 --> 00:03:22.730
+y ocultar los detalles de implementación. Por ejemplo,
+
+00:03:22.730 --> 00:03:26.090
+volviendo, pues, a una persona respecto a una
+
+00:03:26.090 --> 00:03:29.545
+empresa, pues podríamos pensar que puede tener un
+
+00:03:29.545 --> 00:03:31.905
+método para enviar un correo, pero el código
+
+00:03:31.905 --> 00:03:34.305
+de cómo lo hace puede estar oculto en
+
+00:03:34.305 --> 00:03:38.065
+la implementación de él mismo. Y el segundo
+
+00:03:38.065 --> 00:03:41.285
+concepto que, pues sería para introducirnos a este
+
+00:03:41.425 --> 00:03:44.560
+paradigma sería la encapsulación, que es la capacidad
+
+00:03:44.560 --> 00:03:47.920
+de agrupar los datos bajo una misma unidad.
+
+00:03:47.920 --> 00:03:51.060
+Como lo vimos en programas anteriores, solamente utilizábamos
+
+00:03:51.440 --> 00:03:55.540
+variables como nombre, edad, de forma separada, luego,
+
+00:03:55.599 --> 00:03:58.777
+gracias a las estructuras, podemos unificarlo, pero aquí
+
+00:03:58.777 --> 00:04:01.840
+además agregamos la capacidad de realizar, pues, acciones
+
+00:04:01.840 --> 00:04:04.555
+por medio de los métodos y, pues, una
+
+00:04:04.555 --> 00:04:07.834
+clase puede ocultar características para hacerlas inaccesibles a
+
+00:04:07.834 --> 00:04:10.470
+los demás, a diferencia de una estructura. Por
+
+00:04:10.470 --> 00:04:13.610
+ejemplo, si yo tengo una propiedad que solamente
+
+00:04:13.909 --> 00:04:16.949
+sirve para mi funcionamiento interno o para que
+
+00:04:16.949 --> 00:04:19.669
+yo realice mis propias acciones o métodos, pero
+
+00:04:19.669 --> 00:04:22.150
+no quiero compartir esa información con el resto
+
+00:04:22.150 --> 00:04:25.585
+del mundo, pues puedo hacerla privada y solamente
+
+00:04:25.805 --> 00:04:28.765
+desde mis propios métodos acceder a ella. Algo
+
+00:04:28.765 --> 00:04:30.945
+que no sucedía, por ejemplo, con las estructuras,
+
+00:04:31.165 --> 00:04:33.565
+donde todos los datos, si tú tienes una
+
+00:04:33.565 --> 00:04:37.105
+persona y tiene nombre, edad, eran completamente accesibles
+
+00:04:37.325 --> 00:04:41.560
+desde fuera. Estas dos características son la gran
+
+00:04:41.560 --> 00:04:43.560
+diferencia entre las clases, que es lo que
+
+00:04:43.560 --> 00:04:45.419
+vamos a ver ahora en C más más,
+
+00:04:45.520 --> 00:04:49.000
+y las estructuras. Por lo demás, realmente funcionan
+
+00:04:49.000 --> 00:04:51.375
+de una forma, pues muy similar. Lo único
+
+00:04:51.375 --> 00:04:53.215
+que cambia es la forma en la que
+
+00:04:53.215 --> 00:04:55.775
+pensamos nuestros programas. Vamos a pasar a la
+
+00:04:55.775 --> 00:04:58.354
+siguiente clase, que vamos a comenzar a realizar
+
+00:04:58.495 --> 00:05:01.634
+nuestros primeros ejercicios de programación orientada a objetos
+
+00:05:01.775 --> 00:05:02.595
+en código.

subir/Curso de Programación Orientada a Objetos con C/03-Introducción a la Programación Orientada a Objetos/02-Programación Orientada a Objetos Creación de Clases y Objetos en C.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f5cbbe70d65e2ead1c347faf2d27621383e97134a2c36ac3d2ef1de5deadae3
+size 84956229

subir/Curso de Programación Orientada a Objetos con C/03-Introducción a la Programación Orientada a Objetos/02-Programación Orientada a Objetos Creación de Clases y Objetos en C.vtt

@@ -0,0 +1,445 @@
+WEBVTT
+
+00:00:03.520 --> 00:00:05.120
+Ahora que ya vimos lo que es la
+
+00:00:05.120 --> 00:00:07.359
+programación orientada a objetos desde un punto de
+
+00:00:07.359 --> 00:00:09.920
+vista teórico, vamos a pasar a realizar nuestros
+
+00:00:09.920 --> 00:00:13.195
+primeros ejercicios en código. Vamos al editor. Vamos
+
+00:00:13.195 --> 00:00:16.395
+a comenzar a escribir nuestra primera clase. Para
+
+00:00:16.395 --> 00:00:18.895
+esto, vamos a definir con la palabra class
+
+00:00:19.915 --> 00:00:22.875
+nuestra primera nuestro primer objeto. Vamos a seguir
+
+00:00:22.875 --> 00:00:25.289
+con el ejemplo de las personas. Para esto
+
+00:00:25.289 --> 00:00:28.009
+vamos a replicar exactamente lo mismo que habíamos
+
+00:00:28.009 --> 00:00:30.650
+hecho con estructuras, que es utilizar el nombre
+
+00:00:30.650 --> 00:00:32.809
+y la edad de una persona. Vamos a
+
+00:00:32.809 --> 00:00:37.210
+comenzar con la palabra reservada plus. Con esto
+
+00:00:37.210 --> 00:00:42.105
+nuestro intérprete, nuestro compilador sabe que estamos tratando
+
+00:00:42.105 --> 00:00:50.185
+de un objeto. Ahora le di el nombre
+
+00:00:50.185 --> 00:00:52.720
+de persona y de una forma muy similar
+
+00:00:52.720 --> 00:00:54.960
+a como lo hacemos con las estructuras, dentro
+
+00:00:54.960 --> 00:00:57.040
+de un bloque de llaves vamos a comenzar
+
+00:00:57.040 --> 00:01:00.560
+a escribir las propiedades de esta persona. Sin
+
+00:01:00.560 --> 00:01:04.080
+embargo, como vimos, el concepto de clase incluye
+
+00:01:04.080 --> 00:01:07.945
+la capacidad de encapsulación y la forma en
+
+00:01:07.945 --> 00:01:10.345
+que lo hace es que, por defecto, todos
+
+00:01:10.345 --> 00:01:12.905
+los atributos de la persona van a ser
+
+00:01:12.905 --> 00:01:14.905
+privados, no se van a poder acceder desde
+
+00:01:14.905 --> 00:01:17.705
+fuera. Por lo tanto, para poder leerlos desde
+
+00:01:17.705 --> 00:01:20.765
+fuera en nuestro ejemplo, vamos a realizar una
+
+00:01:21.720 --> 00:01:24.440
+modificación al comportamiento por defecto, que es utilizar
+
+00:01:24.440 --> 00:01:27.720
+la palabra pública. Con esto, lo que vamos
+
+00:01:27.720 --> 00:01:30.040
+a hacer es indicarle al compilador que las
+
+00:01:30.040 --> 00:01:33.720
+siguientes variables o propiedades del objeto se pueden
+
+00:01:33.720 --> 00:01:36.575
+acceder desde fuera del mismo. En este caso,
+
+00:01:36.575 --> 00:01:39.335
+vamos a seguir con el ejemplo anterior y
+
+00:01:39.335 --> 00:01:41.594
+vamos a crear el nombre de la persona,
+
+00:01:42.454 --> 00:01:45.174
+nombre. Si yo quiero, puedo darle un valor
+
+00:01:45.174 --> 00:01:48.630
+inicial. Por ejemplo, le puedo poner Diana punto
+
+00:01:48.630 --> 00:01:52.150
+y coma, y también puedo agregar la cantidad
+
+00:01:52.150 --> 00:01:53.750
+de atributos que yo quiera. En este caso
+
+00:01:53.750 --> 00:01:58.230
+puede ser edad y de esta forma tengo
+
+00:01:58.230 --> 00:02:00.730
+creada mi primer clase, que es la clase
+
+00:02:00.790 --> 00:02:04.115
+persona. Con esto yo puedo ir a mi
+
+00:02:04.115 --> 00:02:06.595
+sección main y comenzar a crear personas. Por
+
+00:02:06.595 --> 00:02:10.755
+ejemplo, yo puedo utilizar de la misma forma
+
+00:02:10.755 --> 00:02:14.135
+en que funciona con estructuras el tipo persona,
+
+00:02:14.410 --> 00:02:16.730
+crear la variable p que va a contener
+
+00:02:16.730 --> 00:02:24.830
+a nuestra primera persona y puedo inicializarlo. Ahora,
+
+00:02:24.890 --> 00:02:27.690
+cuando estoy creando la persona, desde ese momento
+
+00:02:27.690 --> 00:02:29.450
+ya la definí, que todas las personas que
+
+00:02:29.450 --> 00:02:31.585
+yo creé tienen el nombre de Diana y
+
+00:02:31.585 --> 00:02:34.145
+la edad de veintiséis años. Vamos a ver
+
+00:02:34.145 --> 00:02:37.665
+si podemos obtener esta información con c out
+
+00:02:37.665 --> 00:02:48.480
+p punto nombre y lo ejecutamos. Como puedes
+
+00:02:48.480 --> 00:02:50.580
+ver, aquí tenemos la salida de la terminal
+
+00:02:50.800 --> 00:02:53.520
+y dice Diana. Sabes que lo mismo pasaría
+
+00:02:53.520 --> 00:02:57.254
+con edad. Ahora, esta es la forma en
+
+00:02:57.254 --> 00:03:00.668
+la que podemos realizar, pues, las personas con
+
+00:03:00.668 --> 00:03:03.415
+memoria, pues, estática. Si yo quisiera utilizar la
+
+00:03:03.415 --> 00:03:05.495
+memoria dinámica y hacer el uso de los
+
+00:03:05.495 --> 00:03:08.694
+punteros, podría hacerlo, podría utilizar de la misma
+
+00:03:08.694 --> 00:03:11.020
+forma que lo hicimos con struots el asterisco
+
+00:03:11.020 --> 00:03:13.600
+para indicar que la variable p es tipo
+
+00:03:13.980 --> 00:03:17.340
+puntero para almacenar personas y utilizar la palabra
+
+00:03:17.340 --> 00:03:21.819
+reservada new para crear a la persona. De
+
+00:03:21.819 --> 00:03:23.980
+la misma manera, vamos a reemplazar la anotación
+
+00:03:23.980 --> 00:03:27.315
+de punto por la anotación de flecha. Si
+
+00:03:27.315 --> 00:03:30.515
+ejecutamos este programa, ahora vamos a obtener de
+
+00:03:30.515 --> 00:03:33.715
+nuevo el nombre Diana. Como ya vimos en
+
+00:03:33.715 --> 00:03:36.435
+la clase de punteros y de estructuras, pues
+
+00:03:36.435 --> 00:03:38.835
+la diferencia es en qué momento se crea
+
+00:03:38.835 --> 00:03:40.500
+la persona. Si lo hacemos por medio de
+
+00:03:40.500 --> 00:03:43.959
+punteros, esta memoria se está reservando durante la
+
+00:03:43.980 --> 00:03:48.900
+ejecución del programa. Otra cosa que podemos hacer
+
+00:03:48.900 --> 00:03:50.579
+con los objetos, y que esa es la
+
+00:03:50.579 --> 00:03:53.480
+gran diferencia con las estructuras, es añadir comportamiento
+
+00:03:53.540 --> 00:03:56.395
+a los mismos. Por ejemplo, una persona puede
+
+00:03:56.395 --> 00:03:58.715
+no solo tener sus atributos como nombre y
+
+00:03:58.715 --> 00:04:01.515
+edad, sino realizar acciones. En este caso, vamos
+
+00:04:01.515 --> 00:04:04.955
+a hacer que nuestra persona pueda saludar. Y
+
+00:04:04.955 --> 00:04:07.755
+para eso podemos, en lugar de definir una
+
+00:04:07.755 --> 00:04:11.969
+variable, definir una función. Se definiría exactamente cómo
+
+00:04:11.969 --> 00:04:16.452
+se definen todas las funciones. Esto es utilizar,
+
+00:04:16.556 --> 00:04:21.570
+por ejemplo, un tipo, void, y un nombre
+
+00:04:21.570 --> 00:04:26.074
+para la función, por ejemplo, saludar. A continuación,
+
+00:04:26.134 --> 00:04:30.294
+entre paréntesis, podemos mencionar los diferentes atributos que
+
+00:04:30.294 --> 00:04:33.574
+puede recibir o simplemente dejarlo vacío. En este
+
+00:04:33.574 --> 00:04:39.250
+caso, vamos a escribir un ceo. Cuando se
+
+00:04:39.250 --> 00:04:41.750
+ejecute la función, va a mostrar el nombre
+
+00:04:45.810 --> 00:04:48.710
+Diana. Vamos a hacer que el al saludar,
+
+00:04:48.930 --> 00:04:51.975
+pues cada persona diga su propio nombre. Esto
+
+00:04:51.975 --> 00:04:54.135
+vamos a pasar a ejecutarlo en lugar de
+
+00:04:54.135 --> 00:04:55.895
+yo hacer un SEOut que diga el nombre
+
+00:04:55.895 --> 00:04:57.895
+en esta línea de código. Lo que puedo
+
+00:04:57.895 --> 00:05:02.055
+hacer es reemplazarlo e invocar. Como estoy utilizando
+
+00:05:02.055 --> 00:05:05.870
+punteros, uso la anotación de flecha e invoco
+
+00:05:05.930 --> 00:05:08.810
+de esta manera esa función. Si te das
+
+00:05:08.810 --> 00:05:10.750
+cuenta, es la misma forma en que hubiéramos
+
+00:05:10.810 --> 00:05:13.050
+accedido a los atributos como la edad y
+
+00:05:13.050 --> 00:05:15.290
+el nombre, solamente que, como se trata de
+
+00:05:15.290 --> 00:05:19.615
+una función, vamos a utilizarlo con paréntesis. Al
+
+00:05:19.615 --> 00:05:22.675
+ejecutar esto, yo voy a observar qué sucede
+
+00:05:22.735 --> 00:05:25.535
+el mismo comportamiento que antes, pero la ventaja
+
+00:05:25.535 --> 00:05:28.335
+de esta implementación es que la persona o
+
+00:05:28.335 --> 00:05:31.315
+cada persona tiene dentro de su propio código
+
+00:05:31.455 --> 00:05:34.850
+el cómo saludar. De esta manera, podemos abstraer
+
+00:05:34.850 --> 00:05:38.450
+el cómo funciona de, pues, internamente cada objeto
+
+00:05:38.450 --> 00:05:40.370
+o cada tipo de objeto, en este caso,
+
+00:05:40.370 --> 00:05:44.850
+pues, para realizar esta acción. Es importante que
+
+00:05:44.850 --> 00:05:47.330
+notes que cada persona va a acceder a
+
+00:05:47.330 --> 00:05:49.705
+su propio nombre. Por ejemplo, supongamos que yo
+
+00:05:49.705 --> 00:05:52.845
+quiero crear otra persona que sea la persona
+
+00:05:53.476 --> 00:06:01.065
+número dos, podría crear otra variable y crear
+
+00:06:01.065 --> 00:06:06.960
+una nueva persona para ella. Por defecto, sabemos
+
+00:06:06.960 --> 00:06:08.720
+que el nombre de la persona número dos
+
+00:06:08.720 --> 00:06:12.180
+también sería Diana, pero supongamos que queremos asignarle
+
+00:06:12.240 --> 00:06:14.879
+otro nombre, sabes que podemos hacerlo utilizando la
+
+00:06:14.879 --> 00:06:17.379
+notación de punteros, en este caso una flecha,
+
+00:06:17.599 --> 00:06:20.020
+y la variable o atributo que queremos modificar.
+
+00:06:23.185 --> 00:06:26.005
+Vamos a ponerle otro nombre, por ejemplo, Ximena,
+
+00:06:28.545 --> 00:06:30.225
+y vamos a hacer que la persona número
+
+00:06:30.225 --> 00:06:37.599
+dos también salude. Vamos a ejecutar el código
+
+00:06:38.219 --> 00:06:40.620
+y como puedes observar, pues a excepción de
+
+00:06:40.620 --> 00:06:42.780
+que falta un cambio de línea, pero está
+
+00:06:42.780 --> 00:06:46.139
+funcionando correctamente, estamos hablando de que la primera
+
+00:06:46.139 --> 00:06:49.039
+persona dijo Diana y la segunda dijo Ximena.
+
+00:06:49.705 --> 00:06:52.985
+Esto sucede porque cada persona, pues, almacena su
+
+00:06:52.985 --> 00:06:56.125
+propia información. Cada vez que utilizamos la palabra
+
+00:06:56.825 --> 00:07:00.105
+reservada new, creamos una persona distinta, y cuando
+
+00:07:00.105 --> 00:07:02.505
+a la persona número dos le reasignamos el
+
+00:07:02.505 --> 00:07:05.280
+nombre, solamente se le asigna a esa persona,
+
+00:07:05.280 --> 00:07:07.200
+no a todas las demás. Esta es una
+
+00:07:07.200 --> 00:07:10.400
+de las ventajas de utilizar, pues, programación orientada
+
+00:07:10.400 --> 00:07:13.440
+a objetos para almacenar, pues, los atributos y
+
+00:07:13.440 --> 00:07:16.400
+métodos. Lo mismo sucede con saludar, aunque en
+
+00:07:16.400 --> 00:07:18.255
+la persona uno y en la persona dos
+
+00:07:18.495 --> 00:07:21.375
+existe la función saludar, cada una accede a
+
+00:07:21.375 --> 00:07:23.135
+su propio nombre a la hora de realizar
+
+00:07:23.135 --> 00:07:26.575
+este ceo. Como sabes, podríamos haber utilizado una
+
+00:07:26.575 --> 00:07:29.535
+función independiente que se llamara saludar y que
+
+00:07:29.535 --> 00:07:32.355
+recibiera como parámetro el nombre de cada persona.
+
+00:07:32.680 --> 00:07:36.139
+Las ventajas de realizarlo como lo realizamos utilizando
+
+00:07:36.280 --> 00:07:39.099
+la función como parte de la clase persona
+
+00:07:39.160 --> 00:07:41.800
+es que así cada persona tiene su propio
+
+00:07:41.800 --> 00:07:45.180
+comportamiento y su propio código de cómo saludar,
+
+00:07:45.565 --> 00:07:48.445
+y cada una accede a su propio valor
+
+00:07:48.445 --> 00:07:51.085
+con su propio nombre. En este caso, la
+
+00:07:51.085 --> 00:07:53.405
+persona número dos con un nombre distinto al
+
+00:07:53.405 --> 00:07:56.695
+de la persona número uno. Nos vemos en
+
+00:07:56.695 --> 00:07:59.495
+la próxima clase, donde comenzaremos a hablar sobre
+
+00:07:59.495 --> 00:08:01.895
+cómo funcionan los objetos y su ciclo de
+
+00:08:01.895 --> 00:08:02.395
+vida.

subir/Curso de Programación Orientada a Objetos con C/03-Introducción a la Programación Orientada a Objetos/03-Ciclo de Vida de Objetos en C Constructores y Destructores.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6656a54ff8663bb928b18724d1442337f16cb6709d10450eadeb6156fa354699
+size 110875287

subir/Curso de Programación Orientada a Objetos con C/03-Introducción a la Programación Orientada a Objetos/03-Ciclo de Vida de Objetos en C Constructores y Destructores.vtt

@@ -0,0 +1,619 @@
+WEBVTT
+
+00:00:03.040 --> 00:00:04.960
+Vamos a hablar sobre el ciclo de vida
+
+00:00:04.960 --> 00:00:08.080
+de un objeto en C más más. Un
+
+00:00:08.080 --> 00:00:10.639
+objeto en C más más es una entidad,
+
+00:00:10.639 --> 00:00:12.639
+pero al mismo tiempo es como una especie
+
+00:00:12.639 --> 00:00:14.400
+de estructura que se va a almacenar en
+
+00:00:14.400 --> 00:00:18.215
+memoria. Es por esto que durante diferentes etapas
+
+00:00:18.215 --> 00:00:20.475
+de su proceso, pues puede estar en diferentes
+
+00:00:20.535 --> 00:00:24.055
+estados. Vamos a ver el diagrama que tienes
+
+00:00:24.055 --> 00:00:26.615
+en pantalla. En primer lugar, se va a
+
+00:00:26.615 --> 00:00:29.380
+reservar un espacio en memoria. Esto sucede cuando
+
+00:00:29.380 --> 00:00:33.240
+realizas una asignación, por ejemplo, utilizando la palabra
+
+00:00:33.300 --> 00:00:36.180
+reservada new hacia un puntero que puede almacenar
+
+00:00:36.180 --> 00:00:40.020
+ese objeto. Luego, se va a invocar una
+
+00:00:40.020 --> 00:00:42.420
+función que tiene todo objeto, que es el
+
+00:00:42.420 --> 00:00:44.515
+constructor, que lo que va a hacer es
+
+00:00:44.515 --> 00:00:47.655
+inicializar todos los valores necesarios dentro del objeto.
+
+00:00:47.954 --> 00:00:50.195
+Por ejemplo, si le asignamos un valor inicial
+
+00:00:50.195 --> 00:00:52.754
+a el nombre de una persona, esto va
+
+00:00:52.754 --> 00:00:56.170
+a suceder durante esta etapa. A continuación, va
+
+00:00:56.170 --> 00:00:57.969
+a entrar en un ciclo de período de
+
+00:00:57.969 --> 00:01:00.449
+actividad donde el objeto va a existir en
+
+00:01:00.449 --> 00:01:02.870
+memoria durante todo el tiempo que sea necesario
+
+00:01:03.170 --> 00:01:06.450
+hasta que ya no lo necesitemos. Entonces, debemos
+
+00:01:06.450 --> 00:01:10.275
+invocar una función que se llama destructor. Por
+
+00:01:10.275 --> 00:01:14.035
+defecto, el compilador, pues, tiene un destructor vacío
+
+00:01:14.035 --> 00:01:17.155
+que hace la función básica de liberar toda
+
+00:01:17.155 --> 00:01:20.355
+la memoria que el mismo compilador reserva cuando
+
+00:01:20.355 --> 00:01:23.510
+crea el objeto, pero si tenemos algún tipo
+
+00:01:23.890 --> 00:01:26.390
+de creación de memoria dinámica dentro de nuestro
+
+00:01:26.770 --> 00:01:29.670
+objeto, es una buena práctica utilizar el destructor
+
+00:01:30.050 --> 00:01:33.090
+para comenzar a limpiar la memoria manualmente. A
+
+00:01:33.090 --> 00:01:35.485
+diferencia de otros lenguajes de programación, C más
+
+00:01:35.485 --> 00:01:37.965
+más no tiene un recolector de basura que
+
+00:01:37.965 --> 00:01:41.005
+elimine todas esas variables o información que ya
+
+00:01:41.005 --> 00:01:43.965
+no estemos utilizando cuando lo detecten, sino que
+
+00:01:43.965 --> 00:01:46.845
+necesitamos limpiar la memoria de forma manual, o
+
+00:01:46.845 --> 00:01:49.939
+de lo contrario, podemos tener muchos problemas porque
+
+00:01:49.939 --> 00:01:53.780
+se sature o se haya un consumo excesivo
+
+00:01:53.780 --> 00:01:57.299
+de memoria. Finalmente, una vez que se ha
+
+00:01:57.299 --> 00:02:00.340
+invocado el destructor, se libera el espacio de
+
+00:02:00.340 --> 00:02:03.875
+memoria y el compilador o el durante el
+
+00:02:03.875 --> 00:02:06.915
+proceso de ejecución, pues, se asume que ya
+
+00:02:06.915 --> 00:02:10.115
+esa memoria está desocupada para estar disponible para
+
+00:02:10.115 --> 00:02:14.609
+cualquier otra información. Vamos a ver cómo se
+
+00:02:14.609 --> 00:02:17.829
+implementan los constructores y los destructores en código.
+
+00:02:18.209 --> 00:02:20.849
+Para este ejemplo, vamos a seguir utilizando el
+
+00:02:20.849 --> 00:02:23.489
+mismo que en las clases anteriores, que es
+
+00:02:23.489 --> 00:02:27.365
+el ejemplo de una persona. Como sabes, creamos
+
+00:02:27.365 --> 00:02:29.605
+una persona que es capaz de almacenar su
+
+00:02:29.605 --> 00:02:33.765
+nombre, su edad y saludar. Esto mismo podemos
+
+00:02:33.765 --> 00:02:37.925
+realizarlo con constructores y destructores. Para comenzar, vamos
+
+00:02:37.925 --> 00:02:40.825
+a definir un constructor. Una de las formas
+
+00:02:41.569 --> 00:02:43.730
+en las que nos es útil tener un
+
+00:02:43.730 --> 00:02:46.629
+constructor es porque, pues, podemos inicializar los valores.
+
+00:02:46.849 --> 00:02:49.090
+En este caso, hicimos que, por defecto, los
+
+00:02:49.090 --> 00:02:51.650
+nombres de todas las personas fueran Diana y
+
+00:02:51.650 --> 00:02:54.925
+sus edades fueran veintiséis años. Sin embargo, esto
+
+00:02:54.925 --> 00:02:58.444
+no debería suceder en una aplicación de la
+
+00:02:58.444 --> 00:03:01.084
+vida real, ya que es cada persona debería
+
+00:03:01.084 --> 00:03:03.484
+tener, pues, su propio nombre o ninguno, o
+
+00:03:03.484 --> 00:03:06.125
+su propiedad o ninguna, o en todo caso
+
+00:03:06.125 --> 00:03:08.444
+inicializar con un valor en ceros o una
+
+00:03:08.444 --> 00:03:11.560
+cadena vacía. Para esto, vamos a hacer uso
+
+00:03:11.560 --> 00:03:14.120
+de los constructores, y los constructores se definen
+
+00:03:14.120 --> 00:03:16.700
+como cualquier otra función, pero con dos condiciones,
+
+00:03:17.080 --> 00:03:20.120
+no retornan un tipo y debe ser el
+
+00:03:20.120 --> 00:03:22.280
+mismo nombre que el de la clase. Por
+
+00:03:22.280 --> 00:03:24.465
+ejemplo, si yo quiero crear el constructor para
+
+00:03:24.465 --> 00:03:27.345
+una persona, utilizaría ese mismo nombre como un
+
+00:03:27.345 --> 00:03:33.185
+método, persona. Paréntesis y como sabemos, no debe
+
+00:03:33.185 --> 00:03:35.945
+retornar nada, así que no necesita un void
+
+00:03:35.945 --> 00:03:40.030
+o un int para funcionar. Solamente necesitamos crear
+
+00:03:40.090 --> 00:03:42.569
+sus par de llaves, donde vamos a escribir
+
+00:03:42.569 --> 00:03:46.090
+todo lo que va a realizar. Como toda
+
+00:03:46.090 --> 00:03:49.209
+función, la persona que acabamos de crear puede
+
+00:03:49.209 --> 00:03:53.355
+recibir un par de atributos o argumentos que
+
+00:03:53.355 --> 00:03:56.315
+se pongan dentro de el paréntesis. Podríamos, por
+
+00:03:56.315 --> 00:04:00.335
+ejemplo, aprovechar esa característica para recibir un nombre.
+
+00:04:00.395 --> 00:04:02.475
+Entonces, si yo quiero recibir el nombre de
+
+00:04:02.475 --> 00:04:05.195
+la persona desde su constructor, lo definiría lo
+
+00:04:05.195 --> 00:04:08.580
+definiría de la siguiente manera string, una variable
+
+00:04:08.580 --> 00:04:12.040
+que guarde temporalmente ese valor y a continuación
+
+00:04:12.580 --> 00:04:15.140
+podría hacer uso de él. Como cualquier otra
+
+00:04:15.140 --> 00:04:17.720
+función, como la función saludar, yo tengo acceso
+
+00:04:18.180 --> 00:04:20.985
+al contexto de la persona, por lo tanto,
+
+00:04:20.985 --> 00:04:24.025
+yo podría realizar una asignación como la siguiente,
+
+00:04:24.025 --> 00:04:28.745
+nombre igual a n. En ese momento, la
+
+00:04:28.745 --> 00:04:32.664
+variable nombre de esta persona en específico comenzaría
+
+00:04:32.664 --> 00:04:34.185
+a ser el valor que se le haya
+
+00:04:34.185 --> 00:04:39.070
+pasado durante su construcción. De modo que cuando
+
+00:04:39.210 --> 00:04:41.530
+utilicemos la función de saludar, ese es el
+
+00:04:41.530 --> 00:04:44.330
+nombre que va a mostrar. Ahora, como te
+
+00:04:44.330 --> 00:04:46.570
+darás cuenta, ya nos marca un error nuestro
+
+00:04:46.570 --> 00:04:48.970
+editor de código en el momento de crear
+
+00:04:48.970 --> 00:04:50.570
+personas, y es que a la hora de
+
+00:04:50.570 --> 00:04:53.105
+modificar el constructor, C más más ya nos
+
+00:04:53.105 --> 00:04:55.525
+pide que cumplamos con lo que definimos aquí.
+
+00:04:55.665 --> 00:04:58.145
+En este caso, nos pide que pasemos ese
+
+00:04:58.145 --> 00:04:59.825
+esa cadena de texto que va a contener
+
+00:04:59.825 --> 00:05:03.345
+el nombre. Así que yo puedo pasar, como
+
+00:05:03.345 --> 00:05:06.830
+cualquier otra función, el nombre Diana al primer
+
+00:05:07.370 --> 00:05:09.230
+a la primera persona y a la segunda,
+
+00:05:09.290 --> 00:05:11.370
+pues para respetar el ejemplo anterior, le voy
+
+00:05:11.370 --> 00:05:15.370
+a poner Jimena. Eso hace que esta línea
+
+00:05:15.370 --> 00:05:17.530
+de código ya no sea necesaria, así que
+
+00:05:17.530 --> 00:05:19.930
+la voy a eliminar y ahora voy a
+
+00:05:19.930 --> 00:05:24.155
+ejecutar el código. Las dos personas van a
+
+00:05:24.155 --> 00:05:27.514
+realizar su saludo, pues mencionando su nombre y
+
+00:05:27.514 --> 00:05:30.095
+aquí está, está Diana y Jimena. Para acomodar
+
+00:05:30.155 --> 00:05:33.675
+esto un poquito voy a escribir endline al
+
+00:05:33.675 --> 00:05:38.160
+final del ceo de saludar Y listo. Ya
+
+00:05:38.160 --> 00:05:40.320
+tengo primero el nombre de Diana, que se
+
+00:05:40.320 --> 00:05:43.220
+está mostrando cuando realizamos en la línea veintidós
+
+00:05:43.920 --> 00:05:47.360
+la función, el método de saludar, y luego
+
+00:05:47.360 --> 00:05:50.865
+en la veintitrés para Ximena. De esta manera,
+
+00:05:50.865 --> 00:05:54.225
+los constructores nos permiten inicializar las variables sin
+
+00:05:54.225 --> 00:05:57.025
+necesidad de recurrir a valores por defecto y
+
+00:05:57.025 --> 00:05:58.945
+al mismo tiempo de una forma mucho más
+
+00:05:58.945 --> 00:06:02.465
+ordenada. Incluso, como es una función, podríamos invocar
+
+00:06:02.465 --> 00:06:05.536
+a cualquiera de las otras funciones o métodos
+
+00:06:05.536 --> 00:06:08.835
+que tiene nuestro objeto y podríamos realizar procesos
+
+00:06:08.835 --> 00:06:12.060
+más complejos, como reservar más espacios en memoria
+
+00:06:12.060 --> 00:06:16.860
+o realizar alguna otra acción. Algo importante que
+
+00:06:16.860 --> 00:06:19.435
+seguramente habrás notado es que a la hora
+
+00:06:19.435 --> 00:06:22.075
+de tener mis métodos dentro de la persona,
+
+00:06:22.075 --> 00:06:24.955
+por ejemplo, a la hora de escribir el
+
+00:06:24.955 --> 00:06:27.595
+código de saludar, yo pude en un en
+
+00:06:27.595 --> 00:06:29.935
+una sola línea de código agregar el endline
+
+00:06:31.035 --> 00:06:33.600
+y eso funcionó para las dos personas. Esa
+
+00:06:33.600 --> 00:06:35.600
+es una de las ventajas de realizar las
+
+00:06:35.600 --> 00:06:39.040
+cosas con programación orientada a objetos. Para continuar
+
+00:06:39.040 --> 00:06:40.880
+con el tema de el ciclo de vida
+
+00:06:40.880 --> 00:06:43.280
+de los objetos, vamos a hablar sobre los
+
+00:06:43.280 --> 00:06:45.200
+la segunda, el segundo tipo de función que
+
+00:06:45.200 --> 00:06:47.200
+le puedes definir a una clase, que es
+
+00:06:47.200 --> 00:06:50.795
+su destructor. El destructor va a funcionar prácticamente
+
+00:06:50.855 --> 00:06:53.655
+igual que el constructor, pero la diferencia es
+
+00:06:53.655 --> 00:06:59.015
+que comienza con este símbolo y eso le
+
+00:06:59.015 --> 00:07:01.575
+va a indicar a nuestro compilador que estamos
+
+00:07:01.575 --> 00:07:05.509
+hablando de un destructor. La forma en la
+
+00:07:05.509 --> 00:07:07.750
+que lo vamos a definir es exactamente la
+
+00:07:07.750 --> 00:07:10.229
+misma que el constructor y esto nos puede
+
+00:07:10.229 --> 00:07:12.650
+ser útil para limpiar algún valor en memoria.
+
+00:07:12.789 --> 00:07:14.870
+En este caso, no tenemos la necesidad de
+
+00:07:14.870 --> 00:07:19.405
+hacerlo porque no estamos reservando memoria adicional dinámica
+
+00:07:19.544 --> 00:07:22.764
+usando punteros. Si tuviéramos alguna de estas variables
+
+00:07:23.865 --> 00:07:26.264
+definida como un puntero, sí tendríamos que realizar
+
+00:07:26.264 --> 00:07:30.345
+una limpieza manual por medio de utilizar, pues,
+
+00:07:30.345 --> 00:07:34.080
+alguna instrucción que limpie la memoria. ¿Cuándo vamos
+
+00:07:34.080 --> 00:07:37.120
+a utilizar los destructores o cuándo se invocan
+
+00:07:37.120 --> 00:07:39.280
+los destructores? Bueno, la forma en que se
+
+00:07:39.280 --> 00:07:41.280
+invocan los destructores y lo vamos a ver
+
+00:07:41.280 --> 00:07:43.760
+para ver cuándo se ejecuta. Voy a ponerle
+
+00:07:43.760 --> 00:07:51.755
+aquí un c out que diga destructor con
+
+00:07:51.755 --> 00:07:55.275
+un cambio de línea. Ahora, cuando se ejecuta
+
+00:07:55.275 --> 00:07:59.515
+un destructor es cuando terminamos de usar un
+
+00:07:59.515 --> 00:08:02.930
+objeto. En este caso, nuestro compilador asume que
+
+00:08:02.930 --> 00:08:05.570
+cuando salimos de la función main nuestro programa
+
+00:08:05.570 --> 00:08:08.449
+ha terminado, por lo tanto, si ejecutamos este
+
+00:08:08.449 --> 00:08:10.210
+código de la forma en la que está,
+
+00:08:10.210 --> 00:08:13.410
+nuestros destructores se van a ejecutar justo antes
+
+00:08:13.410 --> 00:08:15.330
+de terminar la función main, después de haber
+
+00:08:15.330 --> 00:08:18.685
+saludado. Pero esta no es la única forma,
+
+00:08:18.685 --> 00:08:20.604
+y es que cuando utilizamos la palabra reservada
+
+00:08:20.604 --> 00:08:26.044
+new estamos, pues, reservando memoria para utilizarla en
+
+00:08:26.044 --> 00:08:29.324
+nuestras personas, en este caso. Pues existe su
+
+00:08:29.324 --> 00:08:31.645
+función contraria, que es limpiar la memoria que
+
+00:08:31.645 --> 00:08:35.460
+habíamos reservado previamente. Esto funciona de la siguiente
+
+00:08:35.460 --> 00:08:37.460
+manera, si yo tengo, por ejemplo, a la
+
+00:08:37.460 --> 00:08:40.980
+persona número dos y quiero liberar la memoria
+
+00:08:40.980 --> 00:08:43.800
+donde está almacenada, puedo utilizar la palabra reservada
+
+00:08:44.020 --> 00:08:48.295
+delete. La palabra delete lo que va a
+
+00:08:48.295 --> 00:08:50.535
+hacer es eliminar todo lo que haya en
+
+00:08:50.535 --> 00:08:53.495
+esa memoria. Por ejemplo, yo puedo eliminar todo
+
+00:08:53.495 --> 00:08:56.615
+lo que hay dentro de P2. De esta
+
+00:08:56.615 --> 00:09:00.280
+manera, cuando llegue la línea veintiocho, en realidad
+
+00:09:00.280 --> 00:09:02.360
+la persona ya no va a existir y
+
+00:09:02.360 --> 00:09:05.720
+eso va a fallar. Vamos a realizar la
+
+00:09:05.720 --> 00:09:11.080
+ejecución y aquí está. En primer lugar, podemos
+
+00:09:11.080 --> 00:09:13.560
+ver que se muestra el saludo de la
+
+00:09:13.560 --> 00:09:15.565
+persona número uno, que es Diana, y en
+
+00:09:15.565 --> 00:09:18.065
+segundo lugar nos muestra un error de segmentación
+
+00:09:18.365 --> 00:09:21.084
+falt. Esto sucede porque el objeto ya no
+
+00:09:21.084 --> 00:09:24.365
+existe cuando estamos tratando de saludar con la
+
+00:09:24.365 --> 00:09:28.144
+persona número dos. Y también podemos notar que
+
+00:09:28.204 --> 00:09:30.945
+el destructor fue invocado, por eso se imprimió
+
+00:09:31.460 --> 00:09:34.500
+el y se mostró en consola la palabra
+
+00:09:34.500 --> 00:09:37.700
+destructor antes de el saludo de Diana, porque
+
+00:09:37.700 --> 00:09:40.420
+se destruyó el objeto número dos desde la
+
+00:09:40.420 --> 00:09:43.460
+línea veinticinco y el saludo de Diana sucedió
+
+00:09:43.460 --> 00:09:45.795
+hasta la línea veintisiete. Esta es la forma
+
+00:09:45.795 --> 00:09:48.275
+en la que se invocan los destructores, ya
+
+00:09:48.275 --> 00:09:50.855
+sea la forma por defecto o la forma
+
+00:09:50.915 --> 00:09:54.835
+manual, que es utilizar delete. De modo que
+
+00:09:54.835 --> 00:10:00.050
+si utilizáramos alguna memoria reservada dinámicamente dentro de
+
+00:10:00.050 --> 00:10:03.670
+nuestra clase, una forma de limpiarla sería utilizar
+
+00:10:04.130 --> 00:10:07.410
+delete dentro de nuestro destructor para limpiar alguna
+
+00:10:07.410 --> 00:10:10.210
+variable que también tenga, pues, algún otro objeto
+
+00:10:10.210 --> 00:10:13.105
+o algo que hayamos reservado previamente. Esta es
+
+00:10:13.105 --> 00:10:15.105
+la forma en la que funcionan el ciclo
+
+00:10:15.105 --> 00:10:16.865
+de vida de un objeto en C más
+
+00:10:16.865 --> 00:10:19.025
+más el uso de los constructores y los
+
+00:10:19.025 --> 00:10:22.385
+destructores para reservar o liberar la memoria, y
+
+00:10:22.385 --> 00:10:25.045
+también, en el caso de los constructores, inicializar
+
+00:10:25.265 --> 00:10:27.858
+algunas variables. Vamos a hablar en la próxima
+
+00:10:27.858 --> 00:10:30.038
+clase sobre el concepto de encapsulación.

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/01-Encapsulación de Atributos en C Prácticas Seguras.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c1a6612acc6e230e09675dc55f3617be5564291ab118d62eeb05503d0731e7c
+size 59364658

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/01-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://platzi.com/cursos/oop/

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/02-Uso del Puntero This en C para Desambiguación y Autorreferencia.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83cf5b321ca1051e376f1668a131f8778cfa8651f9ad44e01c45d1dd679950e1
+size 120051606

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/02-Uso del Puntero This en C para Desambiguación y Autorreferencia.vtt

@@ -0,0 +1,589 @@
+WEBVTT
+
+00:00:04.240 --> 00:00:06.580
+Vamos a hablar sobre un puntero muy importante
+
+00:00:07.040 --> 00:00:09.200
+dentro de la programación orientada a objetos en
+
+00:00:09.200 --> 00:00:11.840
+C más más que es el puntero DIS.
+
+00:00:11.840 --> 00:00:14.684
+Este puntero es muy especial porque nos permite
+
+00:00:14.684 --> 00:00:18.125
+hacer una autorreferencia dentro de una clase o
+
+00:00:18.125 --> 00:00:21.025
+un objeto. Por ejemplo, si tratamos el tema
+
+00:00:21.485 --> 00:00:24.125
+de las personas de, como en los ejemplos
+
+00:00:24.125 --> 00:00:27.325
+anteriores, podemos pensar que cada persona es una
+
+00:00:27.325 --> 00:00:31.340
+entidad independiente asignada a una variable distinta. Esto
+
+00:00:31.340 --> 00:00:34.220
+es muy útil, pero no es suficiente cuando
+
+00:00:34.220 --> 00:00:38.300
+necesitamos que una persona realice algunas operaciones sobre
+
+00:00:38.300 --> 00:00:40.940
+sí misma. Sabemos que cada persona de las
+
+00:00:40.940 --> 00:00:44.145
+que creamos es independiente, aunque sean de la
+
+00:00:44.145 --> 00:00:48.705
+misma clase, pero en algunas ocasiones necesitamos resolver
+
+00:00:48.705 --> 00:00:52.465
+ambigüedades o realizar algunas acciones que solamente se
+
+00:00:52.465 --> 00:00:55.585
+pueden realizar gracias al puntero DIS. Vamos a
+
+00:00:55.585 --> 00:00:58.720
+ver cómo se utiliza en el código. Vamos
+
+00:00:58.720 --> 00:01:01.840
+a retomar el mismo ejercicio de código de
+
+00:01:01.840 --> 00:01:03.920
+la clase persona que hemos utilizado en las
+
+00:01:03.920 --> 00:01:08.180
+clases anteriores, pero vamos a eliminar la inicialización
+
+00:01:08.320 --> 00:01:12.115
+inline de estos parámetros para devolverlo a la
+
+00:01:12.115 --> 00:01:15.315
+forma original. En este caso, podríamos asignar la
+
+00:01:15.315 --> 00:01:20.915
+variable nombre al valor que traiga n y
+
+00:01:20.915 --> 00:01:25.020
+la variable edad al valor que traiga e.
+
+00:01:25.020 --> 00:01:27.680
+Esta sería una forma bastante sencilla de hacerlo
+
+00:01:27.820 --> 00:01:32.619
+y puede ser bastante correcta realmente, pero en
+
+00:01:32.619 --> 00:01:35.420
+algunos casos tal vez lo mejor sería utilizar
+
+00:01:35.420 --> 00:01:37.744
+el nombre, pues, de la variable. Por ejemplo,
+
+00:01:37.744 --> 00:01:41.185
+yo no quisiera utilizar n en algunos ejemplos
+
+00:01:41.185 --> 00:01:43.265
+de código real porque puede ser ambiguo de
+
+00:01:43.265 --> 00:01:46.304
+qué se trata. Entonces, yo realmente quisiera poder
+
+00:01:46.304 --> 00:01:49.024
+utilizar la palabra nombre también aquí, de esta
+
+00:01:49.024 --> 00:01:51.655
+manera, y en esta parte quisiera poder utilizar
+
+00:01:51.655 --> 00:01:56.210
+la palabra edad de esta forma. Sin embargo,
+
+00:01:56.210 --> 00:01:58.690
+si yo hiciera esto, tendría que realizar esa
+
+00:01:58.690 --> 00:02:03.430
+misma asignación de esta manera, nombre y edad.
+
+00:02:05.010 --> 00:02:07.730
+Hacerlo así sería tal vez lo correcto y
+
+00:02:07.730 --> 00:02:11.665
+lo más razonable, sin embargo, para el compilador
+
+00:02:11.885 --> 00:02:14.525
+va a significar una ambigüedad, ya que no
+
+00:02:14.525 --> 00:02:16.605
+sabes si te refieres a el nombre que
+
+00:02:16.605 --> 00:02:18.765
+está declarado aquí o a este que está
+
+00:02:18.765 --> 00:02:20.925
+declarado aquí, sobre todo en la parte de
+
+00:02:20.925 --> 00:02:24.349
+asignación. Y aunque si tú hubieras creado este
+
+00:02:24.349 --> 00:02:26.270
+lenguaje de programación podrías decir, bueno, a la
+
+00:02:26.270 --> 00:02:28.430
+izquierda es el de la clase y a
+
+00:02:28.430 --> 00:02:30.430
+la derecha es el valor que se pasó
+
+00:02:30.430 --> 00:02:32.590
+en el constructor, pues eso no es así
+
+00:02:32.590 --> 00:02:35.410
+en C más más. Entonces, es una es
+
+00:02:35.470 --> 00:02:38.510
+necesario realizar una desambiguación de estas de estas
+
+00:02:38.510 --> 00:02:41.525
+situaciones y esto es una de las formas
+
+00:02:41.525 --> 00:02:44.325
+de utilizar el puntero this. El puntero this
+
+00:02:44.325 --> 00:02:47.465
+se utilizaría como cualquier otro puntero, solamente que
+
+00:02:48.965 --> 00:02:53.040
+es esa palabra. Entonces, esta sería la forma
+
+00:02:53.040 --> 00:02:56.320
+correcta de utilizarlo con la con la asignación
+
+00:02:56.320 --> 00:02:57.760
+por medio de una flecha, ya que se
+
+00:02:57.760 --> 00:03:02.160
+trata de un puntero y así es. De
+
+00:03:02.160 --> 00:03:04.980
+esta manera, cuando nos referimos a this nombre
+
+00:03:05.040 --> 00:03:07.215
+en esta línea, nos referimos a la variable
+
+00:03:07.215 --> 00:03:09.695
+que está declarada en la línea número ocho,
+
+00:03:09.695 --> 00:03:12.435
+y cuando accedemos por dis edad, nos referimos
+
+00:03:12.895 --> 00:03:14.575
+a la variable que está declarada en la
+
+00:03:14.575 --> 00:03:17.695
+línea nueve. Así es como el compilador puede
+
+00:03:17.695 --> 00:03:21.230
+saber cuál es cuál. Otra forma de utilizar
+
+00:03:21.230 --> 00:03:24.349
+this es cuando necesitamos acceder, pues, a la
+
+00:03:24.349 --> 00:03:26.110
+instancia en sí misma, a la entidad en
+
+00:03:26.110 --> 00:03:29.709
+sí misma, pero desde ella. Entonces, por ejemplo,
+
+00:03:29.709 --> 00:03:33.834
+si yo quisiera realizar una asignación que retorne,
+
+00:03:34.135 --> 00:03:36.694
+pues, el objeto en sí mismo, podría hacerlo
+
+00:03:36.694 --> 00:03:39.275
+de la siguiente manera. Supongamos que yo quiero
+
+00:03:39.895 --> 00:03:43.015
+hacer que esta persona pueda actualizar su nombre
+
+00:03:43.015 --> 00:03:45.819
+y actualizar su edad. Como vimos en clases
+
+00:03:45.819 --> 00:03:49.099
+pasadas, la sección de estas dos variables es
+
+00:03:49.099 --> 00:03:51.819
+privada, por lo tanto, necesitamos crear un par
+
+00:03:51.819 --> 00:03:55.019
+de funciones que nos ayuden a actualizarlas. La
+
+00:03:55.019 --> 00:03:57.180
+forma de hacerlo sería crear un par de
+
+00:03:57.180 --> 00:04:00.285
+métodos. En este caso, supongamos que yo quiero
+
+00:04:00.285 --> 00:04:02.605
+un método que no retorne nada, solamente actualice
+
+00:04:02.605 --> 00:04:06.365
+el valor, podría ser tipo void y podría
+
+00:04:06.365 --> 00:04:09.325
+llamarse de alguna forma que sea descriptiva. En
+
+00:04:09.325 --> 00:04:11.165
+este caso, si quiero cambiar el nombre, podría
+
+00:04:11.165 --> 00:04:18.680
+llamarse establecer nombre. Y establecer nombre podría recibir
+
+00:04:18.680 --> 00:04:23.640
+una cadena de texto que traiga el nuevo
+
+00:04:23.640 --> 00:04:28.514
+nombre. Dentro de lo que hace esta función,
+
+00:04:28.514 --> 00:04:31.655
+pues sería acceder a el valor this nombre
+
+00:04:32.595 --> 00:04:36.375
+y actualizarlo con el argumento nombre de la
+
+00:04:37.315 --> 00:04:39.634
+función. Lo mismo si yo quisiera cambiar la
+
+00:04:39.634 --> 00:04:42.690
+edad, Por ejemplo, podría tener voy establecer edad,
+
+00:04:45.949 --> 00:04:50.190
+que recibe un entero llamado edad y que
+
+00:04:50.190 --> 00:04:55.354
+modifica el valor de this edad para asignarle
+
+00:04:55.495 --> 00:04:59.895
+el valor que recibió por argumento. Ahora yo
+
+00:04:59.895 --> 00:05:03.495
+soy capaz de ejecutar llamadas a estas funciones,
+
+00:05:03.495 --> 00:05:05.655
+a estos métodos, de la misma manera en
+
+00:05:05.655 --> 00:05:07.600
+que lo hice con saludar. Por ejemplo, yo
+
+00:05:07.600 --> 00:05:10.160
+podría hacer esta llamada de la siguiente manera
+
+00:05:10.160 --> 00:05:14.560
+establecer nombre y a Diana podría cambiarle el
+
+00:05:14.560 --> 00:05:22.294
+nombre a Jimena y dejar que solamente Diana
+
+00:05:22.294 --> 00:05:27.255
+salude. De hecho, voy a eliminar la variable
+
+00:05:27.255 --> 00:05:29.815
+que tiene la segunda persona para hacer más
+
+00:05:29.815 --> 00:05:32.794
+claro el ejemplo. Vamos a ejecutar este código
+
+00:05:32.854 --> 00:05:37.020
+y ahora podemos ver que la salida de
+
+00:05:37.020 --> 00:05:40.419
+saludar lo hace con la con la palabra
+
+00:05:40.419 --> 00:05:43.900
+Jimena. Esto es porque hemos actualizado su valor
+
+00:05:43.900 --> 00:05:46.460
+por medio de este método. Lo mismo podríamos
+
+00:05:46.460 --> 00:05:50.275
+hacer con la edad, por ejemplo, p establecer
+
+00:05:50.275 --> 00:05:55.335
+edad, que originalmente la definimos en diez. Ahora
+
+00:05:55.475 --> 00:05:57.794
+podríamos definirla en cualquier otro número, por ejemplo,
+
+00:05:57.794 --> 00:06:01.794
+veintiséis. Y si yo ejecuto este código, voy
+
+00:06:01.794 --> 00:06:05.640
+a obtener como resultado, pues, de de momento
+
+00:06:05.640 --> 00:06:07.800
+tengo solamente el nombre, así que voy a
+
+00:06:07.800 --> 00:06:10.680
+hacer que saludar sea un poco más completo
+
+00:06:10.680 --> 00:06:12.760
+y nos diga también la edad. En saludar,
+
+00:06:12.760 --> 00:06:18.755
+entonces, voy a poner algo así como hola,
+
+00:06:18.755 --> 00:06:23.395
+soy, y que diga el nombre, y después
+
+00:06:23.395 --> 00:06:28.755
+le voy a agregar y que diga mi
+
+00:06:28.755 --> 00:06:36.820
+edad es y que diga la edad. De
+
+00:06:36.820 --> 00:06:41.140
+esta manera, si yo ejecuto el código, me
+
+00:06:41.140 --> 00:06:43.780
+dice que tengo un error. Ah, me faltó
+
+00:06:43.780 --> 00:06:52.845
+aquí un menor que Listo. Me dice hola,
+
+00:06:52.845 --> 00:06:55.884
+soy Jimena y mi edad es veintiséis. En
+
+00:06:55.884 --> 00:06:58.685
+este caso, hemos, pues, realizado la actualización de
+
+00:06:58.685 --> 00:07:01.380
+las variables correctamente, pero todavía no hemos visto
+
+00:07:01.380 --> 00:07:03.780
+cómo es que puede servir this aquí. Y
+
+00:07:03.780 --> 00:07:06.020
+bueno, este es un ejemplo de un caso
+
+00:07:06.020 --> 00:07:10.100
+muy especial, pero supongamos que yo quiero utilizar
+
+00:07:10.100 --> 00:07:13.139
+el objeto this para, cada vez que se
+
+00:07:13.139 --> 00:07:16.715
+invoque, establecer nombre, obtener, pues, la instancia o
+
+00:07:16.715 --> 00:07:19.195
+el objeto en sí mismo. Supongamos que yo
+
+00:07:19.195 --> 00:07:22.555
+quiero que cuando se establezca el nombre, esto
+
+00:07:22.555 --> 00:07:26.555
+retorne también a la persona, de manera que
+
+00:07:26.555 --> 00:07:28.795
+esa otra variable que la reciba, de nuevo,
+
+00:07:28.795 --> 00:07:32.070
+pueda invocar sus métodos. Es una forma fácil
+
+00:07:32.450 --> 00:07:34.370
+o sencilla de decir que yo quiero poder
+
+00:07:34.370 --> 00:07:38.530
+llamar, establecer nombre y establecer edad en una
+
+00:07:38.530 --> 00:07:42.930
+sola línea sin necesidad de cambiar, de utilizar
+
+00:07:42.930 --> 00:07:46.395
+dos veces esta sección que es p y
+
+00:07:46.395 --> 00:07:49.995
+la función de flecha, ¿no? Entonces, yo puedo
+
+00:07:49.995 --> 00:07:54.395
+utilizar una concatenación realizando un return que devuelva
+
+00:07:54.395 --> 00:07:57.435
+la identidad o la entidad de esta persona
+
+00:07:57.435 --> 00:07:59.800
+en específico. La forma en que yo podría
+
+00:07:59.800 --> 00:08:04.200
+hacerlo es indicarle que quiero retornar un puntero
+
+00:08:04.200 --> 00:08:07.960
+que es this, pero como esto es tipo
+
+00:08:07.960 --> 00:08:12.794
+puntero, yo necesito indicarlo con mi asterisco y
+
+00:08:13.014 --> 00:08:16.235
+aquí también necesito indicar que mi función devuelve
+
+00:08:16.455 --> 00:08:18.314
+un valor, que es una dirección de memoria,
+
+00:08:18.615 --> 00:08:22.235
+utilizando ampersand. Lo mismo voy a realizar aquí
+
+00:08:22.669 --> 00:08:26.350
+para que también establecer edad devuelva a la
+
+00:08:26.350 --> 00:08:31.310
+persona en sí misma. Una vez hecho esto,
+
+00:08:31.310 --> 00:08:33.870
+yo voy a poder invocar la función o
+
+00:08:33.870 --> 00:08:36.669
+invocar estos métodos de la persona de forma
+
+00:08:36.669 --> 00:08:44.505
+concatenada. Por ejemplo, así voy a ejecutar la
+
+00:08:44.505 --> 00:08:50.185
+función y me dice que esto no retorna
+
+00:08:50.185 --> 00:08:52.029
+nada porque es void. Esto es cierto, no
+
+00:08:52.029 --> 00:08:56.050
+actualizamos lo que retornan. En este caso, debe
+
+00:08:56.190 --> 00:09:07.025
+retornar un tipo persona. Y ahora sí voy
+
+00:09:07.025 --> 00:09:16.705
+a realizar la ejecución. Y ahí está. Me
+
+00:09:16.705 --> 00:09:18.865
+está diciendo, hola, soy Jimena, mi edad es
+
+00:09:18.865 --> 00:09:22.540
+veintiséis años. ¿Por qué funciona esto? Porque cuando
+
+00:09:22.600 --> 00:09:26.199
+yo ejecuto establecer nombre, lo hago con la
+
+00:09:26.199 --> 00:09:28.199
+anotación de puntero, porque la variable p es
+
+00:09:28.199 --> 00:09:32.040
+un puntero. Esto va a retornar, pues, a
+
+00:09:32.040 --> 00:09:34.515
+la persona en sí misma. Por lo tanto,
+
+00:09:34.575 --> 00:09:36.755
+este bloque de código que estoy seleccionando aquí
+
+00:09:37.214 --> 00:09:40.095
+ejecuta la actualización del nombre y, al mismo
+
+00:09:40.095 --> 00:09:44.015
+tiempo, contiene una referencia hacia la persona como
+
+00:09:44.015 --> 00:09:46.575
+retorno. Por lo tanto, ahora que yo tengo
+
+00:09:46.575 --> 00:09:49.589
+a una persona, yo también puedo establecerle su
+
+00:09:49.589 --> 00:09:53.350
+edad. Y como hice, pues, uso de this,
+
+00:09:53.350 --> 00:09:56.790
+pues, se trata de la misma persona. Entonces,
+
+00:09:56.790 --> 00:10:00.569
+esto también puede devolver, de hecho, esta línea
+
+00:10:01.350 --> 00:10:04.110
+completa también puede devolver o está devolviendo a
+
+00:10:04.110 --> 00:10:06.045
+la persona en sí misma, y yo podría
+
+00:10:06.045 --> 00:10:08.645
+asignárselo a un valor de una variable o
+
+00:10:08.645 --> 00:10:11.905
+seguir concatenando elementos. Por ejemplo, si yo quiero
+
+00:10:12.285 --> 00:10:16.285
+ahora establecer otro nombre, podría realizarlo. Por ejemplo,
+
+00:10:16.285 --> 00:10:18.385
+solo le voy a poner de nuevo Diana.
+
+00:10:19.790 --> 00:10:22.670
+Y de esta manera, si yo ejecuto este
+
+00:10:22.670 --> 00:10:26.449
+código, voy a obtener mi saludar, mi saludo.
+
+00:10:26.910 --> 00:10:29.149
+Pero ahora dice hola, soy Diana, mi edad
+
+00:10:29.149 --> 00:10:32.149
+es veintiséis. ¿Qué fue lo que sucedió? Bueno,
+
+00:10:32.149 --> 00:10:35.170
+estableció el nombre, retornó el objeto que contiene
+
+00:10:35.545 --> 00:10:39.545
+el nombre de Diana, perdón, Jimena, le estableció
+
+00:10:39.545 --> 00:10:41.945
+la edad de veintiséis años y también se
+
+00:10:41.945 --> 00:10:45.145
+retornó a sí mismo, y luego vino y
+
+00:10:45.145 --> 00:10:47.785
+estableció el nombre a Diana una vez más
+
+00:10:47.785 --> 00:10:49.870
+y se retornó a sí mismo. Para cuando
+
+00:10:49.870 --> 00:10:52.670
+yo ejecuté la función celular, el nombre ya
+
+00:10:52.670 --> 00:10:55.550
+era Diana. Como puedes ver, el puntero DIS
+
+00:10:55.550 --> 00:10:57.790
+es una herramienta muy importante dentro de la
+
+00:10:57.790 --> 00:11:00.430
+programación orientada a objetos, no solamente en C
+
+00:11:00.430 --> 00:11:02.670
+más más, sino es parte del paradigma y
+
+00:11:02.670 --> 00:11:05.145
+en todos los lenguajes que lo implementan. Te
+
+00:11:05.145 --> 00:11:08.525
+invito a aprender más formas de cómo se
+
+00:11:08.825 --> 00:11:11.865
+utiliza este puntero para realizar, pues, cosas más
+
+00:11:11.865 --> 00:11:14.664
+complejas en programación orientada a objetos. Nos vemos
+
+00:11:14.664 --> 00:11:17.544
+en la próxima clase, donde hablaremos sobre cómo
+
+00:11:17.544 --> 00:11:21.324
+los objetos pueden compartir información de forma estática.

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/03-Atributos y Métodos Estáticos en Programación Orientada a Objetos.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:efc57cedc6a0b861df938e95cad95303c5915856b6b84a0e764f9ef33c0c309e
+size 80746352

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/03-Atributos y Métodos Estáticos en Programación Orientada a Objetos.vtt

@@ -0,0 +1,448 @@
+WEBVTT
+
+00:00:03.360 --> 00:00:05.920
+Vamos a hablar sobre otra característica de la
+
+00:00:05.920 --> 00:00:08.720
+programación orientada a objetos, que es la capacidad
+
+00:00:08.720 --> 00:00:14.160
+de las clases para mantener métodos o atributos
+
+00:00:14.160 --> 00:00:16.824
+estáticos. Esto es una forma en la que
+
+00:00:16.824 --> 00:00:20.765
+las clases pueden intercambiar mensajes, pero sin realizar
+
+00:00:20.824 --> 00:00:24.585
+una implementación por cada copia del objeto. Volviendo
+
+00:00:24.585 --> 00:00:27.500
+al ejemplo de las personas, si teníamos, pues,
+
+00:00:27.880 --> 00:00:30.520
+por ejemplo, una copia por cada persona, cada
+
+00:00:30.520 --> 00:00:34.060
+una podía tener su propio nombre. La variante
+
+00:00:34.680 --> 00:00:38.120
+estática de esto es que se almacenará un
+
+00:00:38.120 --> 00:00:40.760
+único registro de memoria para todas las clases
+
+00:00:40.760 --> 00:00:43.825
+y ese se compartiera. En ese caso, vamos
+
+00:00:43.825 --> 00:00:47.525
+a realizar un ejemplo con la implementación estática
+
+00:00:47.825 --> 00:00:50.545
+de los atributos de persona. Voy a agregar
+
+00:00:50.545 --> 00:00:53.605
+un atributo estático a nuestra clase de persona.
+
+00:00:53.905 --> 00:00:56.305
+Para esto, lo único que necesito es utilizar
+
+00:00:56.305 --> 00:00:58.760
+la palabra static antes de crear, el atributo.
+
+00:00:58.760 --> 00:01:01.899
+En este caso, si yo quiero almacenar, por
+
+00:01:02.120 --> 00:01:05.479
+ejemplo, cuántas personas existen, podría crear un atributo
+
+00:01:05.479 --> 00:01:07.720
+que sea tipo entero y que sea número
+
+00:01:07.720 --> 00:01:14.634
+de personas. Número guión bajo persona. En este
+
+00:01:14.634 --> 00:01:17.515
+caso, voy a utilizar esta variable precisamente para
+
+00:01:17.515 --> 00:01:19.435
+que cada vez que yo cree una nueva
+
+00:01:19.435 --> 00:01:22.634
+copia o de el objeto personas, que cree
+
+00:01:22.634 --> 00:01:25.515
+yo una nueva persona, en ese momento agregue
+
+00:01:25.515 --> 00:01:29.420
+yo un, pues, sume yo en uno esta
+
+00:01:29.420 --> 00:01:31.900
+variable y, por lo tanto, tendría yo que
+
+00:01:31.900 --> 00:01:34.700
+modificar el constructor para que esa operación de
+
+00:01:34.700 --> 00:01:38.320
+incremento se ejecute. Pero para esto tengo dos
+
+00:01:39.180 --> 00:01:41.260
+limitantes. Más bien, es una limitante que tiene
+
+00:01:41.260 --> 00:01:45.174
+dos efectos. El primero es que los atributos
+
+00:01:45.475 --> 00:01:48.835
+y métodos estáticos no pueden ser accedidos de
+
+00:01:48.835 --> 00:01:52.354
+forma dinámica, y como los miembros que estamos
+
+00:01:52.354 --> 00:01:54.715
+definiendo aquí para la persona, tanto el constructor,
+
+00:01:54.715 --> 00:01:57.390
+el instructor y estos métodos, Todo eso se
+
+00:01:57.390 --> 00:01:59.390
+va a crear una copia por cada vez
+
+00:01:59.390 --> 00:02:01.810
+que creemos una persona para que el compilador,
+
+00:02:02.030 --> 00:02:05.950
+pues, pueda mantener su autorreferencia. Sin embargo, esto
+
+00:02:05.950 --> 00:02:08.370
+nos bloquea y, por lo tanto, tenemos que
+
+00:02:08.509 --> 00:02:11.694
+cambiar ese comportamiento por defecto. C más más
+
+00:02:11.694 --> 00:02:14.575
+nos provee una forma que es definir estos
+
+00:02:14.575 --> 00:02:17.614
+métodos fuera de el cuerpo inicial de la
+
+00:02:17.614 --> 00:02:20.894
+clase, y la forma sería utilizar el nombre
+
+00:02:20.894 --> 00:02:23.694
+de la clase de la siguiente forma persona,
+
+00:02:23.694 --> 00:02:28.860
+por ejemplo, persona y dos veces dos puntos.
+
+00:02:28.860 --> 00:02:30.940
+A partir de ahí ya podemos acceder tanto
+
+00:02:30.940 --> 00:02:33.740
+a los métodos como a los atributos de
+
+00:02:33.740 --> 00:02:37.815
+la persona para definirlos. Es importante, por ejemplo,
+
+00:02:38.055 --> 00:02:41.692
+notar que si yo quisiera realizar una asignación
+
+00:02:41.692 --> 00:02:45.330
+o una inicialización de mi de mi propiedad
+
+00:02:45.330 --> 00:02:48.455
+estática, número de personas, no me dejaría el
+
+00:02:48.455 --> 00:02:52.560
+compilador realizar algo como esto, porque al ser
+
+00:02:52.560 --> 00:02:55.120
+este atributo estático, pues está bloqueado para que
+
+00:02:55.120 --> 00:02:58.560
+no pueda realizarse ese tipo de asignaciones. La
+
+00:02:58.560 --> 00:03:02.480
+forma correcta sería hacerlo desde fuera. Por ejemplo,
+
+00:03:02.480 --> 00:03:07.765
+yo crear el tipo entero persona, el nombre
+
+00:03:07.765 --> 00:03:09.625
+de mi variable, que es número de personas,
+
+00:03:10.325 --> 00:03:13.605
+número de personas. Y ahora sí, ya podría
+
+00:03:13.605 --> 00:03:16.084
+darle un valor inicial con el que va
+
+00:03:16.084 --> 00:03:18.805
+a funcionar. Si te das cuenta, la forma
+
+00:03:18.805 --> 00:03:21.480
+en que el compilador tiene para reconocerlo es
+
+00:03:21.480 --> 00:03:24.840
+que estoy utilizando este esta sintaxis con la
+
+00:03:24.840 --> 00:03:27.420
+que indico a qué clase pertenece este atributo.
+
+00:03:28.440 --> 00:03:30.760
+Lo mismo puedo hacer con los métodos. Por
+
+00:03:30.760 --> 00:03:35.250
+ejemplo, este método saludar yo podría extraerlo y
+
+00:03:35.250 --> 00:03:43.174
+traerlo afuera. Por ejemplo, void saludar y podría
+
+00:03:43.174 --> 00:03:45.735
+escribir el cuerpo de la función. Para esto
+
+00:03:45.735 --> 00:03:48.295
+tendría que indicarle igual que lo hice con
+
+00:03:48.295 --> 00:03:50.935
+mi atributo número de personas, a qué clase
+
+00:03:50.935 --> 00:03:54.510
+pertenece. Voy a cortar la línea veintiocho de
+
+00:03:54.510 --> 00:03:56.270
+mi función saludar, que es su cuerpo lo
+
+00:03:56.270 --> 00:03:58.670
+que lo que la función realiza y lo
+
+00:03:58.670 --> 00:04:02.910
+voy a traer a su nueva definición. Con
+
+00:04:02.910 --> 00:04:05.010
+esto, pues lo que estoy haciendo es reescribir
+
+00:04:05.135 --> 00:04:08.174
+el mismo comportamiento, solamente que con la sintaxis
+
+00:04:08.174 --> 00:04:11.055
+en la que le indico que esta clase
+
+00:04:11.055 --> 00:04:14.515
+tiene este método, pero de forma externa. Entonces,
+
+00:04:14.974 --> 00:04:16.894
+lo que va a suceder aquí es que
+
+00:04:16.894 --> 00:04:19.539
+yo necesito quitar este juego de llaves para
+
+00:04:19.539 --> 00:04:23.699
+que mi compilador reconozca que esta función sí
+
+00:04:23.699 --> 00:04:26.100
+la estoy declarando como que pertenece a la
+
+00:04:26.100 --> 00:04:29.220
+clase persona. Por lo tanto, sí debo tenerla
+
+00:04:29.220 --> 00:04:31.620
+aquí, pero a la hora de definir cómo
+
+00:04:31.620 --> 00:04:35.675
+funciona, lo estoy realizando desde fuera. Este comportamiento
+
+00:04:35.675 --> 00:04:38.095
+de saludar se va a mantener intacto, solamente
+
+00:04:38.155 --> 00:04:40.975
+cambia la forma de escribirlo. Lo mismo sucedería,
+
+00:04:41.514 --> 00:04:44.415
+por ejemplo, con el constructor. El constructor no
+
+00:04:44.555 --> 00:04:46.315
+retorna un tipo, así que, por ejemplo, este
+
+00:04:46.315 --> 00:04:49.082
+void no iría, pero el resto de la
+
+00:04:49.082 --> 00:04:51.450
+sintaxis sí sería igual. En este caso, voy
+
+00:04:51.450 --> 00:04:53.850
+a copiar el constructor para poder definirlo desde
+
+00:04:53.850 --> 00:04:57.210
+fuera y voy a eliminar su cuerpo de
+
+00:04:57.210 --> 00:04:59.850
+esta parte. Lo que voy a hacer es
+
+00:04:59.850 --> 00:05:03.935
+terminar de declararlo aquí abajo como parte de
+
+00:05:03.935 --> 00:05:09.694
+la clase de persona y ahí está. De
+
+00:05:09.694 --> 00:05:11.794
+este modo, ahora yo voy a poder acceder
+
+00:05:12.014 --> 00:05:14.655
+a los miembros estáticos de mi clase, por
+
+00:05:14.655 --> 00:05:16.669
+ejemplo, al número de personas. Y lo que
+
+00:05:16.669 --> 00:05:18.509
+voy a poder hacer es una asignación como
+
+00:05:18.509 --> 00:05:23.470
+la siguiente número de personas es un incremento
+
+00:05:23.470 --> 00:05:26.289
+más uno, por ejemplo, el número anterior más
+
+00:05:26.509 --> 00:05:29.675
+uno, más igual uno. Y ahora sí voy
+
+00:05:29.675 --> 00:05:32.695
+a darle compilar para ver el comportamiento de
+
+00:05:32.695 --> 00:05:36.615
+mi función. Esto va a mandar el mismo
+
+00:05:36.615 --> 00:05:39.675
+mensaje de salida que teníamos implementado. La diferencia
+
+00:05:39.735 --> 00:05:41.885
+es que ahora, durante la creación de la
+
+00:05:41.885 --> 00:05:44.810
+instancia del objeto, estamos incrementando en más uno
+
+00:05:44.810 --> 00:05:47.770
+el contador de personas. Vamos a mostrar el
+
+00:05:47.770 --> 00:05:51.389
+resultado de cuántas personas tienen, pues, la lista
+
+00:05:52.010 --> 00:05:54.370
+o la clase, mejor dicho, a la hora
+
+00:05:54.370 --> 00:05:57.130
+de crear. Entonces, después de esta línea, vamos
+
+00:05:57.130 --> 00:05:59.185
+a imprimir se out y el número de
+
+00:05:59.185 --> 00:06:02.305
+personas. Para acceder a un miembro estático no
+
+00:06:02.305 --> 00:06:06.305
+necesitamos crear una persona como tal, sino podemos
+
+00:06:06.305 --> 00:06:09.025
+acceder directamente desde la clase. Por ejemplo, podemos
+
+00:06:09.025 --> 00:06:17.100
+poner persona, dos puntos, número, personas. Con esto
+
+00:06:18.040 --> 00:06:20.440
+voy a hacer un cambio de línea y
+
+00:06:20.440 --> 00:06:22.360
+le voy a poner aquí un texto para
+
+00:06:22.360 --> 00:06:24.120
+que sepamos qué es lo que estamos viendo
+
+00:06:24.120 --> 00:06:26.700
+y le voy a poner número de personas.
+
+00:06:27.960 --> 00:06:34.555
+Con esto vamos a ejecutarlo. Podemos acceder y
+
+00:06:34.575 --> 00:06:38.035
+dice, ah, es privado. Olvidamos que se declaró
+
+00:06:38.415 --> 00:06:41.375
+dentro de la parte privada de la función,
+
+00:06:41.375 --> 00:06:43.235
+entonces la voy a cambiar a la sección
+
+00:06:43.710 --> 00:06:47.389
+pública de nuestra clase, perdón, para que pueda
+
+00:06:47.389 --> 00:06:50.190
+ser accedida desde fuera. Con esto voy a
+
+00:06:50.190 --> 00:06:54.349
+realizar la ejecución una vez más y ahora
+
+00:06:54.349 --> 00:06:57.250
+sí tengo la salida del número de personas.
+
+00:06:57.634 --> 00:07:00.195
+En este momento que se realizó la ejecución,
+
+00:07:00.195 --> 00:07:01.794
+me dice que el número de personas es
+
+00:07:01.794 --> 00:07:04.854
+uno y si yo quisiera crear más personas
+
+00:07:04.995 --> 00:07:07.875
+podría hacerlo. Por ejemplo, voy a duplicar la
+
+00:07:07.875 --> 00:07:10.870
+declaración de la primera persona para crear una
+
+00:07:10.870 --> 00:07:14.790
+segunda persona aquí que se llame P2, que
+
+00:07:14.790 --> 00:07:16.950
+puede tener de hecho los mismos valores, así
+
+00:07:16.950 --> 00:07:19.350
+que no hay problema. Voy a ejecutarlo y
+
+00:07:19.350 --> 00:07:21.590
+ahora me dice que hay dos personas a
+
+00:07:21.590 --> 00:07:23.030
+la hora de llegar a la línea cuarenta
+
+00:07:23.030 --> 00:07:26.175
+y tres. Con esto hemos utilizado un miembro
+
+00:07:26.175 --> 00:07:29.235
+estático y hemos accedido a él desde una,
+
+00:07:29.935 --> 00:07:35.055
+pues, de un constructor. Los miembros estáticos pueden
+
+00:07:35.055 --> 00:07:38.574
+ser muy útiles para intercambiar mensajes entre clases
+
+00:07:38.574 --> 00:07:41.630
+y también las diferentes copias de la clase
+
+00:07:41.630 --> 00:07:44.910
+pueden hacer, pues, acceso, pero tenemos debemos tener
+
+00:07:44.910 --> 00:07:46.430
+cuidado con la forma en lo que lo
+
+00:07:46.430 --> 00:07:48.670
+hacemos para que el compilador no nos lance
+
+00:07:48.670 --> 00:07:51.310
+ninguna clase de error. Vamos a pasar a
+
+00:07:51.310 --> 00:07:53.870
+la siguiente sección, donde vamos a hablar sobre
+
+00:07:53.870 --> 00:07:54.370
+herencia.

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/04-Herencia en C Implementación y Ejemplos Prácticos.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fe79143ba74a01f6bc4b6623738a4e3f9db0d29fed69be92779c8f2ac1d4a1f
+size 127774520

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/04-Herencia en C Implementación y Ejemplos Prácticos.vtt

@@ -0,0 +1,673 @@
+WEBVTT
+
+00:00:04.640 --> 00:00:07.120
+Una de las características más importantes de la
+
+00:00:07.120 --> 00:00:10.160
+programación orientada a objetos es la herencia, y
+
+00:00:10.160 --> 00:00:12.340
+dentro de C más más también podemos implementarla.
+
+00:00:12.755 --> 00:00:15.575
+La herencia es la capacidad que tienen las
+
+00:00:16.035 --> 00:00:19.715
+clases de heredar, pues, habilidades o características de
+
+00:00:19.715 --> 00:00:22.755
+otras clases, de una o más clases. La
+
+00:00:22.755 --> 00:00:25.415
+herencia nos va a permitir continuar con la
+
+00:00:25.930 --> 00:00:28.730
+abstracción de la orientación a objetos y pensar
+
+00:00:28.730 --> 00:00:33.610
+todo como entidades, y estas pueden estar relacionadas.
+
+00:00:33.610 --> 00:00:36.830
+Por ejemplo, una persona puede tener una especialización
+
+00:00:37.130 --> 00:00:39.770
+que sea, pues, en este caso, un alumno
+
+00:00:39.770 --> 00:00:43.073
+de Platzi o una profesora. Estas serían clases
+
+00:00:43.073 --> 00:00:45.974
+que heredan de una persona o de un
+
+00:00:45.974 --> 00:00:48.545
+ser humano sus características, como la capacidad de
+
+00:00:48.545 --> 00:00:50.945
+tener un hombre o una edad. Del mismo
+
+00:00:50.945 --> 00:00:54.704
+modo, podemos realizar herencia, pues, muy compleja. Por
+
+00:00:54.704 --> 00:00:58.090
+ejemplo, si tuviéramos una serie de clases como
+
+00:00:58.090 --> 00:01:01.949
+la clase animal, podríamos tener, pues, varias, pues,
+
+00:01:02.170 --> 00:01:05.630
+especializaciones como podrían ser un carnívoro, un herbívoro
+
+00:01:05.689 --> 00:01:08.235
+o un omnívoro. Y cada uno de estos
+
+00:01:08.235 --> 00:01:11.115
+no solamente heredaría las habilidades de ser un
+
+00:01:11.115 --> 00:01:14.315
+animal, sino tendría características muy únicas de su
+
+00:01:14.315 --> 00:01:18.015
+propia clase. Vamos a realizar algunos ejemplos en
+
+00:01:18.035 --> 00:01:21.195
+código sobre la herencia. En esta ocasión, primero
+
+00:01:21.195 --> 00:01:22.940
+voy a mostrarte un ejemplo que he escrito
+
+00:01:22.940 --> 00:01:25.880
+para ahorrarnos tiempo en la clase, que es
+
+00:01:26.580 --> 00:01:28.980
+simplemente utilizar todos los conceptos que hemos estado
+
+00:01:28.980 --> 00:01:32.020
+viendo anteriormente en el curso, cómo es la
+
+00:01:32.020 --> 00:01:36.100
+definición de una clase con, pues, sus propiedades,
+
+00:01:36.100 --> 00:01:39.915
+métodos estáticos, con la capacidad de acceder a
+
+00:01:40.135 --> 00:01:42.855
+estas, pues, diferentes variables, como el número de
+
+00:01:42.855 --> 00:01:45.735
+animales. Algo muy similar a lo que realicé
+
+00:01:45.735 --> 00:01:48.775
+con personas fue, pues, realizar el conteo del
+
+00:01:48.775 --> 00:01:51.575
+número de animales utilizando el constructor y el
+
+00:01:51.575 --> 00:01:54.830
+destructor de esta clase. Por ejemplo, cada vez
+
+00:01:54.830 --> 00:01:57.150
+que se crea un nuevo animal, pues se
+
+00:01:57.150 --> 00:01:58.710
+va a incrementar en uno y además va
+
+00:01:58.710 --> 00:02:00.830
+a dar un mensaje en la terminal. Y
+
+00:02:00.830 --> 00:02:03.630
+también cada vez que se elimina, pues un
+
+00:02:03.630 --> 00:02:06.030
+animal, pues vamos a tener el mensaje de
+
+00:02:06.030 --> 00:02:09.305
+que se eliminó el animal que se eliminó
+
+00:02:09.305 --> 00:02:12.505
+y, en este caso, pues estaríamos restándole uno
+
+00:02:12.505 --> 00:02:15.945
+al conteo total de animales. También tengo un
+
+00:02:15.945 --> 00:02:19.485
+método en lugar de una de simplemente acceder
+
+00:02:19.705 --> 00:02:23.250
+al atributo estático para poderlo mantener privado. De
+
+00:02:23.250 --> 00:02:25.010
+esta forma, si te das cuenta, el que
+
+00:02:25.010 --> 00:02:27.569
+está en la sección de private y aquí
+
+00:02:27.569 --> 00:02:31.010
+con este método puedo retornarlo. Si te das
+
+00:02:31.010 --> 00:02:32.450
+cuenta, la forma en que lo utilicé en
+
+00:02:32.450 --> 00:02:34.849
+la línea cuarenta y tres es como cualquier
+
+00:02:34.849 --> 00:02:37.970
+otro método de una, pues como si fuera
+
+00:02:37.970 --> 00:02:41.165
+una función, pero siendo parte de la clase
+
+00:02:41.305 --> 00:02:45.805
+animal. Aquí tengo un ejemplo de cómo funcionaría
+
+00:02:46.185 --> 00:02:48.765
+y la forma sería crear un nuevo animal
+
+00:02:49.225 --> 00:02:51.705
+y además le agregué, pues, un par de
+
+00:02:51.705 --> 00:02:55.150
+secciones. En primer lugar, tiene una un método
+
+00:02:55.150 --> 00:02:57.150
+comer que va a mostrar un mensaje de
+
+00:02:57.150 --> 00:02:59.650
+que este animal está comiendo, va a mostrar
+
+00:02:59.870 --> 00:03:01.390
+cuál es el tipo de alimento que está
+
+00:03:01.390 --> 00:03:04.670
+comiendo y ñom ñom. Y una vez que
+
+00:03:04.670 --> 00:03:07.490
+hayamos realizado la ejecución de la función comer,
+
+00:03:07.630 --> 00:03:10.325
+vamos a eliminar este animal y vamos a
+
+00:03:10.325 --> 00:03:12.984
+ver cuál es el número de animales actualizado
+
+00:03:13.125 --> 00:03:15.444
+después de destruir. En este caso, solo tenemos
+
+00:03:15.444 --> 00:03:16.965
+un animal, así que tendrá que volver a
+
+00:03:16.965 --> 00:03:20.825
+cero. Pero también deberemos poder ver el mensaje
+
+00:03:21.034 --> 00:03:25.410
+que pusimos al destructor para mostrar el borrando
+
+00:03:25.410 --> 00:03:30.610
+animal. Vamos a ejecutarlo. Listo. Ahora tenemos, pues,
+
+00:03:30.610 --> 00:03:33.430
+los siguientes mensajes. En primer lugar, se mencionó
+
+00:03:33.569 --> 00:03:37.155
+el creando un nuevo animal, porque a la
+
+00:03:37.155 --> 00:03:40.695
+hora de que utilizamos el la palabra reservada
+
+00:03:40.755 --> 00:03:43.175
+new, en ese momento se invoca el constructor
+
+00:03:43.555 --> 00:03:47.075
+y se hace el ceoT correspondiente. Después, vamos
+
+00:03:47.075 --> 00:03:49.155
+a tener el número de animales de la
+
+00:03:49.155 --> 00:03:52.750
+línea cuarenta y tres. A continuación, se realiza
+
+00:03:52.750 --> 00:03:55.790
+la ejecución de el método comer y, en
+
+00:03:55.790 --> 00:03:57.630
+este caso, no sabe qué es lo que
+
+00:03:57.630 --> 00:04:00.430
+está comiendo exactamente, se quedó una una cadena
+
+00:04:00.430 --> 00:04:02.750
+vacía por defecto. Por lo tanto, solo dice
+
+00:04:02.750 --> 00:04:05.334
+el animal está comiendo ñom ñom. Y a
+
+00:04:05.334 --> 00:04:07.895
+continuación podemos ver que se borró el animal
+
+00:04:07.895 --> 00:04:11.334
+y luego el conteo bajó a cero. Voy
+
+00:04:11.334 --> 00:04:14.255
+a hacer una segunda ejecución solamente para agregar
+
+00:04:14.255 --> 00:04:16.695
+un ejemplo de cómo funcionaría si tuviera ya
+
+00:04:16.695 --> 00:04:19.349
+algún alimento asignado. En este caso, si yo
+
+00:04:19.349 --> 00:04:22.310
+quisiera hacer que el animal por defecto tenga
+
+00:04:22.310 --> 00:04:28.550
+un alimento, por ejemplo, aquí arriba, podemos darle
+
+00:04:28.550 --> 00:04:31.895
+un valor por defecto, que sea carne. A
+
+00:04:34.435 --> 00:04:36.595
+la hora de realizar la ejecución, me diría,
+
+00:04:36.595 --> 00:04:40.995
+este animal está comiendo carne. Vamos a pasar
+
+00:04:40.995 --> 00:04:44.595
+ahora a realizar, pues, la implementación de una
+
+00:04:44.595 --> 00:04:48.450
+clase que herede de la clase animal. Para
+
+00:04:48.450 --> 00:04:51.170
+esto, vamos a aprovechar el espacio justo donde
+
+00:04:51.170 --> 00:04:54.230
+terminamos de definir todo lo relacionado con animal
+
+00:04:54.370 --> 00:04:57.410
+para crear una nueva clase. La clase podría
+
+00:04:57.410 --> 00:04:59.890
+ser una especialización de animal, que podría ser
+
+00:04:59.890 --> 00:05:06.245
+herbívoro. Y herbívoro se definiría como cualquier otra
+
+00:05:06.385 --> 00:05:09.445
+clase, pero como va a heredar desde animal,
+
+00:05:09.665 --> 00:05:12.945
+necesitamos agregarle esa referencia. Por lo tanto, la
+
+00:05:12.945 --> 00:05:15.669
+forma de hacerlo sería usar dos puntos y
+
+00:05:15.669 --> 00:05:17.910
+el nombre de la clase que vamos a
+
+00:05:17.910 --> 00:05:20.710
+heredar. En este caso, vamos a heredar de
+
+00:05:20.710 --> 00:05:22.810
+la clase animal, por lo que yo podría
+
+00:05:23.270 --> 00:05:27.849
+colocar el nombre de esa clase. Sin embargo,
+
+00:05:28.150 --> 00:05:32.525
+el compilador también tiene un voy a cerrar
+
+00:05:32.525 --> 00:05:34.445
+la terminal para que se vea más completo
+
+00:05:34.445 --> 00:05:38.525
+el código. Ok, entonces mencionábamos que la clase
+
+00:05:38.525 --> 00:05:40.685
+herbívoro va a heredar sobre la clase animal,
+
+00:05:40.685 --> 00:05:44.065
+por lo tanto, para hacer esta indicación necesitamos
+
+00:05:44.380 --> 00:05:46.620
+escribir dos puntos, el nombre de la clase
+
+00:05:46.620 --> 00:05:50.460
+de la que queremos, pues, heredar, y así
+
+00:05:50.460 --> 00:05:53.660
+sería la asignación de la herencia. Sin embargo,
+
+00:05:53.660 --> 00:05:56.860
+por defecto, como sabemos, igual que, pues, los
+
+00:05:56.860 --> 00:05:59.705
+miembros por defecto de una clase pueden ser
+
+00:05:59.705 --> 00:06:02.664
+privados y debemos mostrar que son públicos para
+
+00:06:02.664 --> 00:06:05.224
+poder utilizarlos desde fuera. Lo mismo pasa en
+
+00:06:05.224 --> 00:06:07.625
+la herencia, así que podemos utilizar la palabra
+
+00:06:07.625 --> 00:06:11.164
+public antes de animal para que esa herencia
+
+00:06:11.305 --> 00:06:14.639
+funcione de la forma que estamos esperando. Ahora
+
+00:06:14.639 --> 00:06:16.820
+que tenemos creada la base de nuestra clase
+
+00:06:18.160 --> 00:06:21.360
+herbívoro, podemos realizar la especialización, pues, de lo
+
+00:06:21.360 --> 00:06:23.600
+que realiza un herbívoro. En este caso, si
+
+00:06:23.600 --> 00:06:26.259
+estamos hablando de cómo un animal, pues, come,
+
+00:06:26.835 --> 00:06:29.555
+podríamos estar hablando de de aprovechar el constructor,
+
+00:06:29.555 --> 00:06:35.235
+por ejemplo, herbívoro, para que el animal se
+
+00:06:35.235 --> 00:06:39.075
+haga asimismo comer, por ejemplo, pasto, ¿no? Entonces
+
+00:06:39.075 --> 00:06:43.630
+podríamos decirle, este tipo de animales come un
+
+00:06:44.410 --> 00:06:52.570
+alimento que es pasto o plantas. ¿Listo? Entonces,
+
+00:06:52.570 --> 00:06:54.730
+esto podría parecer que va a funcionar, pero
+
+00:06:54.730 --> 00:06:57.034
+nos falta una pequeña cosa. Es que cuando
+
+00:06:57.034 --> 00:06:59.754
+vamos a hacer herencia y queremos utilizar nuestros
+
+00:06:59.754 --> 00:07:02.794
+constructores o destructores, necesitamos, si los vamos a
+
+00:07:02.794 --> 00:07:07.375
+utilizar, indicarle que es estamos usando el constructor
+
+00:07:07.514 --> 00:07:10.340
+de cierta clase. Por ejemplo, aquí sería el
+
+00:07:10.340 --> 00:07:12.659
+constructor de animal, por lo tanto, también se
+
+00:07:12.659 --> 00:07:18.280
+lo tengo que indicar. Si mi constructor recibiera
+
+00:07:18.340 --> 00:07:21.555
+argumentos, tendría que agregarle los argumentos que recibe,
+
+00:07:21.555 --> 00:07:24.035
+pero de momento no recibe ningún argumento, solamente
+
+00:07:24.035 --> 00:07:26.514
+nos sirve para que nuestra clase pueda tener
+
+00:07:26.514 --> 00:07:30.275
+acceso a el a la propiedad alimento de
+
+00:07:30.275 --> 00:07:33.955
+animal. Entonces, ahora, sin necesidad de que hayamos
+
+00:07:33.955 --> 00:07:39.219
+definido la propiedad alimento dentro de animal, podríamos
+
+00:07:39.379 --> 00:07:42.600
+asumir que estamos accediendo a la definición que
+
+00:07:42.600 --> 00:07:45.479
+creamos, pero en la clase animal. Como puedes
+
+00:07:45.479 --> 00:07:48.039
+ver, la clase animal tiene aquí designada la
+
+00:07:48.039 --> 00:07:51.905
+variable alimento y la clase herbívoro no tiene
+
+00:07:51.905 --> 00:07:55.505
+esa asignación. Aquí nos está marcando un error
+
+00:07:55.505 --> 00:07:58.385
+de sintaxis y lo que nos dice es
+
+00:07:58.385 --> 00:08:01.585
+que esto no tiene, no es accesible. Esto
+
+00:08:01.585 --> 00:08:04.850
+es porque nos falta simplemente agregar aquí que
+
+00:08:04.850 --> 00:08:07.490
+esto va a ser público. Ok, me sigue
+
+00:08:07.490 --> 00:08:09.410
+diciendo que es inaccesible y es que me
+
+00:08:09.410 --> 00:08:11.650
+falta una cosa más relacionada con la forma
+
+00:08:11.650 --> 00:08:14.950
+de acceder y es que en la clase
+
+00:08:15.090 --> 00:08:19.655
+animal, pues original, utilice esto como privado para
+
+00:08:19.655 --> 00:08:23.655
+cuando utilicemos herencia. Si queremos acceder a los
+
+00:08:23.655 --> 00:08:27.194
+elementos privados de la clase base, necesitamos cambiar
+
+00:08:27.254 --> 00:08:29.495
+esto a una tercera palabra que se llama
+
+00:08:29.495 --> 00:08:32.730
+protected. Va a tener una forma de funcionar
+
+00:08:32.889 --> 00:08:35.690
+muy similar a si fuera privado, excepto porque
+
+00:08:35.690 --> 00:08:37.789
+cuando hablemos de herencia sí vamos a poder,
+
+00:08:38.169 --> 00:08:40.250
+pues de las clases que heredan, acceder a
+
+00:08:40.250 --> 00:08:44.329
+estos elementos. Ahora sí, ya tengo, ya está
+
+00:08:44.329 --> 00:08:46.785
+libre de errores y ya puedo, yo podría
+
+00:08:46.785 --> 00:08:49.365
+realizar una ejecución, solo que no sucedería nada.
+
+00:08:49.745 --> 00:08:52.944
+Voy a seguir modificando la forma en que
+
+00:08:52.944 --> 00:08:55.985
+se comporta la clase herbívoro y esto no
+
+00:08:55.985 --> 00:08:58.510
+está escrito en animal, sino que esto es
+
+00:08:58.510 --> 00:09:00.990
+solo específico de los herbívoros, que podría ser,
+
+00:09:00.990 --> 00:09:03.630
+por ejemplo, pastar. En este caso, voy a
+
+00:09:03.630 --> 00:09:05.710
+crear, pues, un método que se llama que
+
+00:09:05.710 --> 00:09:11.964
+sea tipo void pastar, porque los herbívoros, pues,
+
+00:09:11.985 --> 00:09:14.705
+pueden ir y comer pasto. Entonces, voy a
+
+00:09:14.705 --> 00:09:18.805
+poner seout y va a mencionar este animal
+
+00:09:21.265 --> 00:09:28.700
+está pastando. Con esto me voy a dar
+
+00:09:28.700 --> 00:09:31.340
+cuenta cuando yo realicé, pues la ejecución de
+
+00:09:31.340 --> 00:09:37.340
+pastar, que esto está sucediendo. Entonces vamos a
+
+00:09:37.340 --> 00:09:39.680
+utilizar esta clase. Por ejemplo, si yo regreso
+
+00:09:40.140 --> 00:09:46.335
+aquí, puedo crear ahora un herbívoro y le
+
+00:09:46.335 --> 00:09:54.190
+voy a poner solo h, new herbívoro. Y
+
+00:09:54.190 --> 00:09:57.070
+ahora voy a poder realizar algo con ese
+
+00:09:57.070 --> 00:10:01.150
+herbívoro. Por ejemplo, puedo hacer que vaya a
+
+00:10:01.150 --> 00:10:04.910
+pastar. Voy a realizar esta ejecución y, como
+
+00:10:04.910 --> 00:10:08.825
+puedes darte cuenta, el número de animales en
+
+00:10:08.825 --> 00:10:11.625
+este en esta ejecución. Ahora será dos, el
+
+00:10:11.625 --> 00:10:15.865
+animal, pues genérico, solamente está comiendo, no se
+
+00:10:15.865 --> 00:10:18.745
+sabe qué y dice ñom ñom. El animal
+
+00:10:18.745 --> 00:10:20.425
+que está pastando, pues dice este animal está
+
+00:10:20.425 --> 00:10:22.860
+pastando y después se borra un animal, que
+
+00:10:22.860 --> 00:10:25.980
+es el el animal gen��rico, y el número
+
+00:10:25.980 --> 00:10:29.020
+de animales disminuye a uno. Este es el
+
+00:10:29.020 --> 00:10:32.060
+comportamiento esperado y de la misma manera en
+
+00:10:32.060 --> 00:10:36.215
+que creamos nuestra especialización de herbívoro a partir
+
+00:10:36.215 --> 00:10:40.295
+de la clase base animal, podríamos crear la
+
+00:10:40.295 --> 00:10:44.535
+especialización para carnívoro. Con esto hemos creado dos
+
+00:10:44.535 --> 00:10:48.235
+especializaciones de la clase base animal. Hemos creado
+
+00:10:48.295 --> 00:10:52.690
+dos clases que heredan de la clase animal.
+
+00:10:52.830 --> 00:10:57.410
+Yo podría realizar una instancia, por ejemplo, herbívoro,
+
+00:10:58.750 --> 00:11:02.750
+perdón, carnívoro, que se llame C, por ejemplo,
+
+00:11:02.750 --> 00:11:10.085
+igual a new carnívoro. Y a continuación, yo
+
+00:11:10.085 --> 00:11:12.725
+puedo hacer a cualquier animal comer, pero solamente
+
+00:11:12.725 --> 00:11:15.285
+los carnívoros pueden cazar. Entonces, voy a hacer
+
+00:11:15.285 --> 00:11:21.470
+que mi carnívoro vaya y case. Así que
+
+00:11:21.470 --> 00:11:24.050
+cuando yo realice la ejecución de este programa,
+
+00:11:24.390 --> 00:11:29.170
+pues nuestro animal genérico va a comer, los
+
+00:11:29.630 --> 00:11:31.950
+herbívoros van a pastar y los carnívoros van
+
+00:11:31.950 --> 00:11:36.185
+a cazar. Esto ya es una expansión de
+
+00:11:36.185 --> 00:11:38.985
+las funcionalidades básicas que tiene Animal y esa
+
+00:11:38.985 --> 00:11:40.765
+es una de las ventajas de la herencia.
+
+00:11:41.144 --> 00:11:45.225
+Estamos pudiendo asignarle tipos de alimento, pero además
+
+00:11:45.225 --> 00:11:48.800
+estamos pudiendo asignarles, pues, algo más de lo
+
+00:11:48.800 --> 00:11:51.279
+que solamente puede realizar un animal en sí
+
+00:11:51.279 --> 00:11:55.120
+mismo. Si yo quisiera crear una especialización, por
+
+00:11:55.120 --> 00:11:58.399
+ejemplo, para crear un omnívoro, podría realizarlo de
+
+00:11:58.399 --> 00:12:00.399
+la misma manera en la que lo he
+
+00:12:00.399 --> 00:12:02.395
+estado haciendo con herbívoro y carnívoro, Pero los
+
+00:12:02.395 --> 00:12:06.635
+omnívoros, pues, sabemos que son una forma de
+
+00:12:06.635 --> 00:12:11.595
+definirlos, sería que solamente pueden comer cualquier cosa,
+
+00:12:11.595 --> 00:12:13.755
+¿no? O sea, realmente pueden comer cualquier cosa.
+
+00:12:13.755 --> 00:12:15.995
+Entonces, podríamos decir que es un herbívoro y
+
+00:12:15.995 --> 00:12:17.979
+un carnívoro a la vez, y esto lo
+
+00:12:17.979 --> 00:12:20.779
+podemos hacer por medio de herencia múltiple. Vamos
+
+00:12:20.779 --> 00:12:22.859
+a la siguiente clase donde hablaremos de este
+
+00:12:22.859 --> 00:12:23.359
+tema.

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/05-Herencia Múltiple en C Implementación y Ejemplos Prácticos.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd6484b3bf64c8b62e099c1ad25415e2dd37d37c011c5e959a9dba9202ff440f
+size 78600171

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/05-Herencia Múltiple en C Implementación y Ejemplos Prácticos.vtt

@@ -0,0 +1,403 @@
+WEBVTT
+
+00:00:00.000 --> 00:00:05.279
+Como vimos, la herencia es una de las
+
+00:00:05.279 --> 00:00:08.639
+características más importantes dentro de la programación orientada
+
+00:00:08.639 --> 00:00:11.920
+a objetos, y una de sus variantes es
+
+00:00:11.920 --> 00:00:14.545
+la herencia múltiple. La herencia múltiple lo que
+
+00:00:14.545 --> 00:00:16.705
+nos va a permitir es heredar de más
+
+00:00:16.705 --> 00:00:19.265
+de una clase base y la herencia múltiple
+
+00:00:19.265 --> 00:00:22.145
+nos va a permitir, pues, implementar de una
+
+00:00:22.145 --> 00:00:25.365
+forma más eficiente casos como el ejemplo anterior.
+
+00:00:25.760 --> 00:00:29.120
+Si tenemos una clase origen animal y tenemos
+
+00:00:29.120 --> 00:00:32.120
+dos herencias o dos clases heredadas que se
+
+00:00:32.120 --> 00:00:35.040
+llaman herbívoro y carnívoro, tal vez una mejor
+
+00:00:35.040 --> 00:00:38.420
+forma de implementar el omnívoro sería más bien
+
+00:00:38.720 --> 00:00:41.795
+heredando de los dos anteriores, de forma que
+
+00:00:41.795 --> 00:00:44.755
+no tengas que repetir funcionalidades que vendrían, a
+
+00:00:44.755 --> 00:00:47.715
+lo mejor, implementadas tanto en carnívoro como en
+
+00:00:47.715 --> 00:00:52.915
+herbívoro si trajeras la herencia solamente desde animal.
+
+00:00:52.915 --> 00:00:55.230
+Entonces, vamos a realizar un ejemplo de código
+
+00:00:55.310 --> 00:00:59.149
+sobre cómo sería esta especialización. Para continuar con
+
+00:00:59.149 --> 00:01:02.030
+el ejemplo que veníamos realizando en la clase
+
+00:01:02.030 --> 00:01:05.869
+anterior, vamos a realizar la especialización omnívoro a
+
+00:01:05.869 --> 00:01:08.030
+partir de la de las clases herbívoro y
+
+00:01:08.030 --> 00:01:11.345
+carnívoro. La forma de escribirlo sería muy similar.
+
+00:01:12.045 --> 00:01:16.945
+Sería, por ejemplo, clase y omnívoro, que sería
+
+00:01:18.525 --> 00:01:24.625
+omnívoro. Listo. Y heredaría de, heredaría públicamente de
+
+00:01:24.850 --> 00:01:28.390
+la clase herbívoro y de la clase carnívoro.
+
+00:01:31.970 --> 00:01:34.690
+Y a continuación podríamos comenzar a realizar, pues,
+
+00:01:34.690 --> 00:01:38.050
+el código relacionado con esta clase. Por ejemplo,
+
+00:01:38.050 --> 00:01:46.185
+el constructor sería omnívoro y heredaría de las
+
+00:01:46.185 --> 00:01:48.985
+dos clases anteriores. La forma en lo que
+
+00:01:48.985 --> 00:01:51.485
+en la que lo realizaríamos sería igual utilizando,
+
+00:01:52.185 --> 00:01:55.700
+pues, el nombre de la clase base, coma
+
+00:01:55.700 --> 00:01:59.860
+el nombre de la otra clase base. Y
+
+00:01:59.860 --> 00:02:02.820
+así ya tenemos, pues, definido el constructor. En
+
+00:02:02.820 --> 00:02:04.740
+este caso, no lo vamos a utilizar, pero
+
+00:02:04.740 --> 00:02:09.145
+es importante notar que tanto en la definición
+
+00:02:09.145 --> 00:02:11.545
+de la clase como en su constructor, tendríamos
+
+00:02:11.545 --> 00:02:14.745
+que utilizar para poder utilizar más de uno
+
+00:02:14.745 --> 00:02:18.585
+separación por comas. Eso es una regla que
+
+00:02:18.585 --> 00:02:20.025
+C más más nos va a obligar a
+
+00:02:20.025 --> 00:02:22.310
+utilizar. Aquí me están marcando un error porque
+
+00:02:22.310 --> 00:02:25.350
+me falta un punto y coma. Listo. Y
+
+00:02:25.350 --> 00:02:29.210
+ahora, otra característica que implementamos en la clase
+
+00:02:29.830 --> 00:02:33.190
+animal fue comer, y esto, pues, nos permitía
+
+00:02:33.190 --> 00:02:35.935
+imprimir, pues, exactamente qué tipo de alimento estaba
+
+00:02:35.935 --> 00:02:38.894
+comiendo el animal, y no lo probamos dentro
+
+00:02:38.894 --> 00:02:41.614
+de las clases herbívoro y carnívoro, así que
+
+00:02:41.614 --> 00:02:45.534
+vamos a hacerlo. Para estos, pongamos que el
+
+00:02:45.534 --> 00:02:48.120
+animal herbívoro no solo sale a pastar, sino
+
+00:02:48.120 --> 00:02:51.420
+que además está saliendo a comer, y esto
+
+00:02:51.560 --> 00:02:53.480
+es una de las ventajas de la programación
+
+00:02:53.480 --> 00:02:57.100
+orientada a objetos, podemos trabajar con conceptos abstractos.
+
+00:03:00.695 --> 00:03:04.215
+Lo mismo sucede con el carnívoro. Entonces, vamos
+
+00:03:04.215 --> 00:03:08.935
+a realizar esta ejecución y, como puedes ver
+
+00:03:08.935 --> 00:03:12.135
+en pantalla, no solamente muestra este animal está
+
+00:03:12.135 --> 00:03:14.940
+pastando, sino que, además, cuando el animal pastando
+
+00:03:14.940 --> 00:03:19.260
+dice este animal está comiendo plantas, y cuando
+
+00:03:19.260 --> 00:03:22.460
+está cazando luego muestra este animal está comiendo
+
+00:03:22.460 --> 00:03:25.580
+carne. Esto es porque, aunque en las clases
+
+00:03:25.580 --> 00:03:28.525
+herbívoro y carnívoro no definimos como tal la
+
+00:03:28.525 --> 00:03:31.085
+variable alimento, sí la reasignamos a la hora
+
+00:03:31.085 --> 00:03:34.765
+de utilizar el constructor. Lo interesante sucede cuando
+
+00:03:34.765 --> 00:03:37.265
+queremos realizar la misma acción con el omnívoro.
+
+00:03:37.485 --> 00:03:39.805
+Vamos a implementar un ejemplo. Por ejemplo, si
+
+00:03:39.805 --> 00:03:42.340
+yo quiero crear un omnívoro, puedo crear el
+
+00:03:42.340 --> 00:03:47.320
+tipo omnívoro y le voy a poner o
+
+00:03:47.540 --> 00:03:51.460
+new omnívoro. Con esto estoy creando un nuevo
+
+00:03:51.460 --> 00:03:56.194
+animal que es clase omnívoro, el cual supondría
+
+00:03:56.334 --> 00:03:59.135
+puede comer igual que cualquier otro animal. Sin
+
+00:03:59.135 --> 00:04:01.235
+embargo, vamos a tratar de hacer el ejemplo
+
+00:04:02.015 --> 00:04:04.415
+y si te das cuenta, ni siquiera mi
+
+00:04:04.415 --> 00:04:06.515
+auto completado me lo va a mostrar porque
+
+00:04:06.655 --> 00:04:10.420
+realmente ya no está disponible como pensaríamos. Si
+
+00:04:10.420 --> 00:04:14.900
+yo quisiera compilarlo, por ejemplo, comer y darle
+
+00:04:14.900 --> 00:04:17.620
+compilar, esto me va a dar un error.
+
+00:04:17.620 --> 00:04:19.940
+Voy a cerrar esto para que no estorbe
+
+00:04:19.940 --> 00:04:21.540
+a la hora de leer el código, pero
+
+00:04:21.540 --> 00:04:22.979
+la razón por la que me está dando
+
+00:04:22.979 --> 00:04:25.485
+el error es porque para C más más
+
+00:04:25.564 --> 00:04:28.224
+la forma en que funciona la herencia múltiple
+
+00:04:28.245 --> 00:04:31.245
+es que si queremos utilizar, por ejemplo, herbívoro
+
+00:04:31.245 --> 00:04:34.685
+y carnívoro para crear el omnívoro, estamos en
+
+00:04:34.685 --> 00:04:36.764
+realidad diciéndole que es de los dos tipos
+
+00:04:36.764 --> 00:04:38.540
+a la vez. Por lo tanto, es como
+
+00:04:38.540 --> 00:04:41.440
+si tuviéramos tanto un carnívoro como un omnívoro
+
+00:04:41.580 --> 00:04:45.660
+existiendo dentro de esta variable o. Para esto
+
+00:04:45.660 --> 00:04:49.030
+tendríamos que decirle una forma de quitar esa
+
+00:04:49.030 --> 00:04:51.765
+ambigüedad y la forma correcta sería indicar por
+
+00:04:51.765 --> 00:04:54.245
+medio de qué padre o de qué base
+
+00:04:54.245 --> 00:04:56.645
+va a realizar esta acción. Por ejemplo, yo
+
+00:04:56.645 --> 00:05:03.760
+puedo pedirle que coma como un herbívoro Y
+
+00:05:03.760 --> 00:05:10.080
+entonces ejecutar el código. Si puedes ver, ahora
+
+00:05:10.080 --> 00:05:14.640
+puedo, ahora tengo un último log desde mi
+
+00:05:14.640 --> 00:05:16.980
+terminal que me dice este animal está comiendo
+
+00:05:17.280 --> 00:05:19.755
+plantas. Para diferenciarlo, antes de esto te voy
+
+00:05:19.755 --> 00:05:22.535
+a poner un c out que diga humano,
+
+00:05:24.115 --> 00:05:26.835
+porque un humano es un omnívoro, por ejemplo.
+
+00:05:26.835 --> 00:05:34.830
+O voy a poner omnívoro. Y voy a
+
+00:05:36.289 --> 00:05:43.530
+realizar la ejecución. Ahora sí, entonces vemos que
+
+00:05:43.530 --> 00:05:45.290
+justo después de que se muestra el mensaje
+
+00:05:45.290 --> 00:05:48.255
+de omnívoro, está ejecutándose esta línea de código
+
+00:05:48.255 --> 00:05:50.495
+y ahora sí podemos tener la certeza de
+
+00:05:50.495 --> 00:05:52.575
+que esta se trata de que alguien está
+
+00:05:52.575 --> 00:05:55.695
+comiendo plantas. ¿Qué pasaría si yo lo hago
+
+00:05:55.695 --> 00:05:57.455
+desde la clase de carnívoro? Pues me va
+
+00:05:57.455 --> 00:06:03.170
+a mostrar que, carnívoro, me va a mostrar
+
+00:06:03.170 --> 00:06:05.250
+en esta ocasión que la persona está comiendo
+
+00:06:05.250 --> 00:06:09.890
+carne. Entonces, esta es una forma de quitarle
+
+00:06:09.890 --> 00:06:13.250
+esa ambigüedad y realmente podríamos encontrar, pues, muchas
+
+00:06:13.250 --> 00:06:17.395
+otras situaciones y podríamos incluso pensar en reescribir
+
+00:06:17.775 --> 00:06:20.975
+la capacidad de el omnívoro de cómo realizar
+
+00:06:20.975 --> 00:06:23.535
+su acción comer. Para esto, si yo no
+
+00:06:23.535 --> 00:06:26.575
+quisiera tener esta ambigüedad, podría reescribirlo y simplemente
+
+00:06:26.575 --> 00:06:28.495
+poner un mensaje de que este animal, pues,
+
+00:06:28.495 --> 00:06:30.975
+come todo tipo de alimentos para que funcione
+
+00:06:30.975 --> 00:06:33.430
+algo como esto. La forma en que lo
+
+00:06:33.430 --> 00:06:36.250
+haría sería venir aquí a la clase omnívoro
+
+00:06:36.710 --> 00:06:41.510
+y agregarle un método que se llame, que
+
+00:06:41.510 --> 00:06:46.805
+reescribe básicamente, el método comer original. Y a
+
+00:06:46.805 --> 00:06:49.705
+partir de este podría ser el siguiente mensaje.
+
+00:06:55.205 --> 00:06:59.765
+Este animal come lo que sea. Ahora, si
+
+00:06:59.765 --> 00:07:05.060
+realizo la ejecución, aquí me estaba sobrando un
+
+00:07:05.060 --> 00:07:08.620
+menor que listo. Si realizo la ejecución de
+
+00:07:08.620 --> 00:07:11.520
+esta línea de código que es o comer,
+
+00:07:11.819 --> 00:07:15.120
+ahora un omnívoro puede comer fácilmente y ya
+
+00:07:15.259 --> 00:07:18.885
+tengo la forma correcta en que está implementado
+
+00:07:19.265 --> 00:07:23.025
+o reimplementado este método para poder utilizarlo sin
+
+00:07:23.025 --> 00:07:26.465
+ninguna ambigüedad. Esta es la forma en que
+
+00:07:26.465 --> 00:07:28.785
+funciona la herencia múltiple dentro de C más
+
+00:07:28.785 --> 00:07:31.220
+más Te recuerdo que si quieres aprender mucho
+
+00:07:31.220 --> 00:07:34.740
+más sobre los conceptos teóricos de la programación
+
+00:07:34.740 --> 00:07:36.740
+orientada a objetos, puedes realizar el curso de
+
+00:07:36.740 --> 00:07:39.620
+programación orientada a objetos de Platzi. Nos vemos
+
+00:07:39.620 --> 00:07:42.740
+en la próxima clase, donde hablaremos sobre el
+
+00:07:42.740 --> 00:07:43.240
+polimorfismo.

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/06-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://platzi.com/cursos/oop/

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/06-Polimorfismo en Programación Orientada a Objetos.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04c2173287c17c6d3ec871d5c67f421ecac6e2873417762f311d8399f8323d28
+size 53503118

subir/Curso de Programación Orientada a Objetos con C/04-Principios de la Programación Orientada a Objetos/06-Polimorfismo en Programación Orientada a Objetos.vtt

@@ -0,0 +1,313 @@
+WEBVTT
+
+00:00:03.120 --> 00:00:05.920
+La última característica que vamos a ver sobre
+
+00:00:05.920 --> 00:00:08.500
+programación orientada a objetos en este curso es
+
+00:00:08.559 --> 00:00:11.679
+el polimorfismo. El polimorfismo es una de esas
+
+00:00:11.679 --> 00:00:15.085
+cosas que son importantes dentro de este paradigma,
+
+00:00:15.385 --> 00:00:17.405
+porque nos va a ayudar a la reutilización
+
+00:00:17.625 --> 00:00:20.185
+de código, pero también a que el código
+
+00:00:20.185 --> 00:00:22.365
+no se convierta en un dolor de cabeza.
+
+00:00:22.505 --> 00:00:24.570
+Esto lo vamos a hacer por medio de
+
+00:00:24.810 --> 00:00:28.010
+permitir que las diferentes clases y objetos interactúen
+
+00:00:28.010 --> 00:00:31.230
+intercambiando mensajes entre ellos de una forma estandarizada
+
+00:00:32.090 --> 00:00:34.830
+o común, de forma que un mismo mensaje
+
+00:00:34.890 --> 00:00:37.770
+o forma de llamar a cierto bloque de
+
+00:00:37.770 --> 00:00:41.375
+código siempre sea compatible para que se reemplace,
+
+00:00:41.375 --> 00:00:43.695
+por ejemplo, con una clase heredada o con
+
+00:00:43.695 --> 00:00:47.075
+una clase base. Vamos a realizar algún ejemplo
+
+00:00:47.135 --> 00:00:50.495
+de código. Para retomar el mismo ejercicio que
+
+00:00:50.495 --> 00:00:54.355
+hemos venido manejando sobre los animales, herbívoros y
+
+00:00:54.470 --> 00:00:57.770
+omnívoros, vamos a realizar un ejemplo de polimorfismo.
+
+00:00:58.070 --> 00:01:00.149
+En realidad ya lo hemos realizado, y es
+
+00:01:00.149 --> 00:01:03.670
+que el polimorfismo es tener, pues, una interfaz
+
+00:01:03.670 --> 00:01:06.010
+en común o una forma común de trabajar
+
+00:01:06.150 --> 00:01:08.995
+con las diferentes clases. En este caso lo
+
+00:01:08.995 --> 00:01:12.915
+implementamos en clases anteriores cuando trabajamos la característica
+
+00:01:12.915 --> 00:01:16.755
+de que tanto animales herbívoros como carnívoros y
+
+00:01:16.755 --> 00:01:19.955
+omnívoros puedan realizar la acción de comer. En
+
+00:01:19.955 --> 00:01:22.455
+este caso, las tres clases tienen una implementación
+
+00:01:22.515 --> 00:01:25.390
+de un modo u otro que les permite
+
+00:01:25.390 --> 00:01:26.990
+a agentes externos o a quien vaya a
+
+00:01:26.990 --> 00:01:30.590
+consumir esa clase simplemente usar ese método sin
+
+00:01:30.590 --> 00:01:33.170
+necesidad de pensar en cuál de las tres
+
+00:01:33.470 --> 00:01:35.390
+clases es de la que se tratará. Para
+
+00:01:35.390 --> 00:01:37.950
+ejemplificar un poco más esto, vamos a realizar
+
+00:01:37.950 --> 00:01:40.855
+una un pequeño cambio a nuestra clase de
+
+00:01:40.855 --> 00:01:44.855
+animal en el método de comer. Y aquí
+
+00:01:44.855 --> 00:01:47.975
+algo que sucedía durante la creación de animal,
+
+00:01:47.975 --> 00:01:50.375
+cuando no heredas ninguna clase, sino que solo
+
+00:01:50.375 --> 00:01:53.850
+instancias animal, es que, pues al mostrar el
+
+00:01:53.850 --> 00:01:56.090
+alimento, pues mostraba un elemento vacío. Vamos a
+
+00:01:56.090 --> 00:01:58.650
+cambiar un poco el comportamiento por defecto de
+
+00:01:58.650 --> 00:02:01.369
+esto o el comportamiento de esto, y vamos
+
+00:02:01.369 --> 00:02:03.930
+a permitirle recibir qué tipo de animal es
+
+00:02:03.930 --> 00:02:05.790
+el que va a comer. En este caso,
+
+00:02:06.505 --> 00:02:07.945
+pues le voy a indicar que es un
+
+00:02:07.945 --> 00:02:11.385
+tipo animal y lo voy a llamar a,
+
+00:02:11.385 --> 00:02:14.365
+de manera que yo pueda pasarle cualquier animal
+
+00:02:14.905 --> 00:02:17.885
+como argumento a este método y aún así
+
+00:02:17.945 --> 00:02:21.085
+pueda mostrar su alimento. Entonces voy a poder
+
+00:02:21.250 --> 00:02:23.970
+reemplazar aquí para que se utilice el animal
+
+00:02:23.970 --> 00:02:25.970
+que se haya pasado por argumento y se
+
+00:02:25.970 --> 00:02:30.450
+obtenga el alimento de ese animal. Algo, pues,
+
+00:02:30.450 --> 00:02:33.349
+importante al respecto es que entonces ya no
+
+00:02:33.810 --> 00:02:37.085
+podríamos utilizar la función, el método comer, como
+
+00:02:37.085 --> 00:02:39.585
+lo estamos haciendo aquí, sin pasarle el argumento
+
+00:02:39.645 --> 00:02:42.945
+correcto. En este caso, ya no necesitamos invocar
+
+00:02:44.125 --> 00:02:46.925
+comer, podríamos invocar comer desde la implementación, por
+
+00:02:46.925 --> 00:02:49.390
+ejemplo, del herbívoro o del carnívoro, pero a
+
+00:02:49.390 --> 00:02:53.730
+lo mejor algo más limpio podría ser realizarlo.
+
+00:02:54.430 --> 00:02:57.310
+Y vamos a comentar entonces comer, porque la
+
+00:02:57.310 --> 00:03:01.330
+forma sería utilizar a lo mejor esta otra,
+
+00:03:01.895 --> 00:03:03.735
+que es utilizar la clase base, la clase
+
+00:03:03.735 --> 00:03:06.395
+animal para tener un código un poco más
+
+00:03:06.535 --> 00:03:09.655
+general. Y ahora sí puede recibir cualquier animal
+
+00:03:09.655 --> 00:03:12.235
+como argumento, por ejemplo, el herbívoro que tenemos
+
+00:03:12.295 --> 00:03:16.615
+implementado aquí y más abajo podríamos reutilizarlo para
+
+00:03:16.615 --> 00:03:20.829
+el carnívoro. De esta forma, cuando ejecutamos nuestro
+
+00:03:20.829 --> 00:03:24.269
+código, podemos ver que, bueno, en primer lugar,
+
+00:03:24.269 --> 00:03:27.489
+aquí me está devolviendo un error de código
+
+00:03:32.125 --> 00:03:34.844
+porque me dice que esta línea, la número
+
+00:03:34.844 --> 00:03:37.825
+setenta y siete, ya necesito pasarle un animal.
+
+00:03:37.965 --> 00:03:39.965
+Entonces la voy a comentar y voy a
+
+00:03:39.965 --> 00:03:44.480
+ejecutar de nuevo. Listo. Ahora, tanto mi herbívoro
+
+00:03:44.540 --> 00:03:46.380
+como mi carnívoro se le están pasando como
+
+00:03:46.380 --> 00:03:50.460
+argumento y de nuevo tenemos que, pues, están
+
+00:03:50.460 --> 00:03:53.680
+comiendo el herbívoro plantas y el carnívoro está
+
+00:03:54.140 --> 00:03:58.255
+está comiendo carne y el carnívoro está comiendo
+
+00:03:58.255 --> 00:04:04.195
+carne. Entonces podemos observar que realmente la misma
+
+00:04:04.335 --> 00:04:07.295
+función o método comer puede recibir cualquier tipo
+
+00:04:07.295 --> 00:04:10.335
+de animal y sin importar cuál sea el
+
+00:04:10.335 --> 00:04:12.580
+tipo que reciba, va a poder obtener su
+
+00:04:12.580 --> 00:04:15.300
+nombre. Esta es una interfaz en común que
+
+00:04:15.300 --> 00:04:17.620
+estamos definiendo a la hora de programar. No
+
+00:04:17.620 --> 00:04:19.700
+es tanto un concepto que se escriba en
+
+00:04:19.700 --> 00:04:22.660
+código, sino es una intención que debemos tener
+
+00:04:22.660 --> 00:04:25.940
+siempre que realicemos código con programación orientada a
+
+00:04:25.940 --> 00:04:29.275
+objetos. El polimorfismo se puede implementar de muchas
+
+00:04:29.275 --> 00:04:32.715
+maneras. Esto es por medio de cambiar, pues
+
+00:04:32.715 --> 00:04:35.115
+las clases. También se puede hacer por medio
+
+00:04:35.115 --> 00:04:38.315
+de modificar las funciones para que, dependiendo del
+
+00:04:38.315 --> 00:04:40.875
+tipo de dato que reciban, se puedan comportar
+
+00:04:40.875 --> 00:04:43.810
+de una u otra manera. Y hay muchos
+
+00:04:43.810 --> 00:04:46.790
+otros usos. Realmente, el polimorfismo es un tema
+
+00:04:47.010 --> 00:04:49.170
+bastante amplio y si quieres aprender más sobre
+
+00:04:49.170 --> 00:04:50.930
+él, te invito a realizar el curso de
+
+00:04:50.930 --> 00:04:54.870
+Programación Orientada a Objetos de Platzi. El polimorfismo
+
+00:04:55.170 --> 00:04:57.694
+se puede implementar de muchas maneras. En realidad,
+
+00:04:57.914 --> 00:05:00.314
+este fue solo un ejemplo de un caso
+
+00:05:00.314 --> 00:05:04.074
+específico, donde utilizamos la clase animal para que
+
+00:05:04.074 --> 00:05:07.034
+se le pueda pasar como argumento cualquier tipo
+
+00:05:07.034 --> 00:05:09.935
+de animal a esta función, pero realmente existen
+
+00:05:09.995 --> 00:05:13.000
+muchas formas y muy variadas de hacerlo. Para
+
+00:05:13.000 --> 00:05:15.320
+que puedas entender más a fondo el concepto
+
+00:05:15.320 --> 00:05:17.720
+de polimorfismo, te invito a realizar el curso
+
+00:05:17.720 --> 00:05:20.520
+de programación orientado a objetos de Platzi. Nos
+
+00:05:20.520 --> 00:05:21.980
+vemos en la próxima clase.

subir/Curso de Programación Orientada a Objetos con C/05-Despedida/01-Evaluación Final Programación Orientada a Objetos en C.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7cc7e4ca26292603504ba7b2d59deb6a6c52e6b599ca029aa4737c5639a0172
+size 8619408

subir/Curso de Programación Orientada a Objetos con C/05-Despedida/01-Evaluación Final Programación Orientada a Objetos en C.vtt

@@ -0,0 +1,46 @@
+WEBVTT
+
+00:00:03.439 --> 00:00:06.000
+Felicidades. Ya llegaste al final del curso de
+
+00:00:06.000 --> 00:00:08.880
+programación orientada a objetos con C más más,
+
+00:00:08.880 --> 00:00:12.080
+donde aprendiste una cantidad de conocimientos variados, como
+
+00:00:12.080 --> 00:00:14.824
+el concepto de manejo de memoria, estructuras de
+
+00:00:14.824 --> 00:00:17.805
+datos y cómo aplicar el paradigma orientado a
+
+00:00:18.025 --> 00:00:20.505
+objetos en este lenguaje. Recuerda que todo esto
+
+00:00:20.505 --> 00:00:23.145
+se puede aplicar en una gran variedad de
+
+00:00:23.145 --> 00:00:25.805
+soluciones de software, como el desarrollo de videojuegos
+
+00:00:26.025 --> 00:00:28.690
+o el software de ingeniería. Te invito a
+
+00:00:28.690 --> 00:00:31.530
+realizar tu examen para evaluar tus conocimientos y
+
+00:00:31.530 --> 00:00:34.510
+también para dejarme una calificación de cinco estrellas
+
+00:00:34.730 --> 00:00:37.210
+para que puedas seguir trayéndote más cursos a
+
+00:00:37.210 --> 00:00:40.325
+través de Platzi. No olvides compartirme tu certificado
+
+00:00:40.545 --> 00:00:43.665
+a través de Twitter por arroba Diana guion
+
+00:00:43.665 --> 00:00:46.405
+bajo nerd y nunca pares de aprender.