Upload folder using huggingface_hub

.gitattributes

@@ -176,3 +176,20 @@ prompt-engineering/4-Cómo[[:space:]]definir[[:space:]]roles[[:space:]]efectivos
 prompt-engineering/6-Comparación[[:space:]]práctica[[:space:]]de[[:space:]]ChatGPT,[[:space:]]Claude,[[:space:]]Gemini[[:space:]]y[[:space:]]Microsoft[[:space:]]Copilot.mp4 filter=lfs diff=lfs merge=lfs -text
 prompt-engineering/7-Técnicas[[:space:]]zero[[:space:]]shot[[:space:]]y[[:space:]]few[[:space:]]shot[[:space:]]para[[:space:]]prompts[[:space:]]efectivos.mp4 filter=lfs diff=lfs merge=lfs -text
 prompt-engineering/8-Estructura[[:space:]]de[[:space:]]prompts[[:space:]]con[[:space:]]etiquetas[[:space:]]XML[[:space:]]para[[:space:]]IA.mp4 filter=lfs diff=lfs merge=lfs -text
+01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/01-Fundamentos[[:space:]]del[[:space:]]Lenguaje[[:space:]]de[[:space:]]Programación[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/01-presentacion-curso-de-introduccion-a-c_03d52e2b-ae7d-4f48-a639-97796abeae8f.pdf filter=lfs diff=lfs merge=lfs -text
+01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/02-Programación[[:space:]]en[[:space:]]C[[:space:]]Estructuras[[:space:]]Funciones[[:space:]]y[[:space:]]Memoria.mp4 filter=lfs diff=lfs merge=lfs -text
+01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/03-Cómo[[:space:]]una[[:space:]]computadora[[:space:]]interpreta[[:space:]]datos[[:space:]]binarios.mp4 filter=lfs diff=lfs merge=lfs -text
+01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/04-Fundamentos[[:space:]]del[[:space:]]Lenguaje[[:space:]]C[[:space:]]para[[:space:]]Microcontroladores.mp4 filter=lfs diff=lfs merge=lfs -text
+01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/05-Configuración[[:space:]]de[[:space:]]Entorno[[:space:]]para[[:space:]]Programar[[:space:]]en[[:space:]]C[[:space:]]en[[:space:]]Windows.mp4 filter=lfs diff=lfs merge=lfs -text
+01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/06-Instalación[[:space:]]y[[:space:]]Ejecución[[:space:]]de[[:space:]]Programas[[:space:]]C[[:space:]]en[[:space:]]Linux.mp4 filter=lfs diff=lfs merge=lfs -text
+02-Estructura[[:space:]]de[[:space:]]un[[:space:]]programa[[:space:]]C/01-Estructura[[:space:]]Básica[[:space:]]de[[:space:]]un[[:space:]]Programa[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+03-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/01-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]C[[:space:]]Enteros[[:space:]]y[[:space:]]Flotantes.mp4 filter=lfs diff=lfs merge=lfs -text
+03-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/02-Uso[[:space:]]del[[:space:]]Tipo[[:space:]]de[[:space:]]Dato[[:space:]]Void[[:space:]]en[[:space:]]Programación[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+03-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/03-Enums[[:space:]]en[[:space:]]C[[:space:]]Uso[[:space:]]y[[:space:]]Ejemplos[[:space:]]Prácticos[[:space:]]para[[:space:]]Constantes.mp4 filter=lfs diff=lfs merge=lfs -text
+03-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/04-Tipos[[:space:]]de[[:space:]]datos[[:space:]]char[[:space:]]y[[:space:]]unsigned[[:space:]]char[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+04-Variables[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/01-Declaración[[:space:]]y[[:space:]]uso[[:space:]]de[[:space:]]variables[[:space:]]en[[:space:]]lenguaje[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+04-Variables[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/02-Manejo[[:space:]]de[[:space:]]Variables[[:space:]]Externas[[:space:]]en[[:space:]]C[[:space:]]y[[:space:]]Precisión[[:space:]]Numérica.mp4 filter=lfs diff=lfs merge=lfs -text
+04-Variables[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/03-Uso[[:space:]]de[[:space:]]Constantes[[:space:]]y[[:space:]]Literales[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+04-Variables[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/04-Uso[[:space:]]de[[:space:]]define[[:space:]]y[[:space:]]const[[:space:]]para[[:space:]]constantes[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+05-Conclusiones/01-Funciones[[:space:]]Básicas[[:space:]]del[[:space:]]Lenguaje[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text

01-Introducción al lenguaje C/01-Fundamentos del Lenguaje de Programación C.mp4

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

01-Introducción al lenguaje C/01-Fundamentos del Lenguaje de Programación C.vtt

@@ -0,0 +1,270 @@
+WEBVTT
+
+00:00.000 --> 00:07.000
+Hola, bienvenida o bienvenido a este curso
+de introducción a C.
+
+00:07.000 --> 00:10.640
+Este es un lenguaje de programación que yo
+de verdad amo muchísimo
+
+00:10.640 --> 00:14.960
+porque me ayudó a crear robótica y a crear
+robots que me permitieron
+
+00:14.960 --> 00:19.360
+participar en competencias nacionales,
+ganarlas en competencias internacionales,
+
+00:19.360 --> 00:23.760
+obviamente con un gran equipo de trabajo,
+pero de verdad es que me permitió programar
+
+00:23.760 --> 00:28.120
+microcontroladores y me abrió las puertas
+a todo un mundo de posibilidades.
+
+00:28.120 --> 00:32.040
+En este curso yo te voy a enseñar las
+bases del lenguaje,
+
+00:32.040 --> 00:36.440
+solo lo introductorio. Vas a aprender cómo
+funciona un programa típico en C,
+
+00:36.440 --> 00:40.880
+vas a aprender cómo declarar variables,
+qué tipos de datos puedes usar en este lenguaje
+
+00:40.880 --> 00:45.640
+y vas a aprender por qué deberías usar
+cierto tipo de datos en lugar de otro.
+
+00:45.640 --> 00:50.800
+Es muy importante también que te vayas
+aprendiendo aquí que C es un lenguaje tipado,
+
+00:50.800 --> 00:56.760
+es decir, siempre vas a tener que declarar
+qué tipo de datos va a acompañar una variable
+
+00:56.760 --> 01:00.440
+para que el lenguaje sepa cuánta memoria
+reservar en nuestra computadora
+
+01:00.440 --> 01:02.200
+o en el sistema que estemos programando.
+
+01:02.200 --> 01:06.200
+Quiero contarte además un poco sobre cómo
+estamos atacando ahora
+
+01:06.200 --> 01:08.400
+los lenguajes de programación aquí en Platzi.
+
+01:08.400 --> 01:12.240
+Antes sacábamos un solo curso que era
+relativamente largo,
+
+01:12.240 --> 01:15.240
+pero no era lo suficientemente largo para
+cubrir todo el lenguaje,
+
+01:15.240 --> 01:19.240
+deberían de ser 100 clases, 150 clases en
+algunos casos.
+
+01:19.240 --> 01:23.680
+¿Por qué? Porque un lenguaje tiene cosas
+desde lo más básico como tipos de datos,
+
+01:23.680 --> 01:27.000
+cómo se crea una estructura básica en un
+programa,
+
+01:27.000 --> 01:30.800
+hasta cuestiones avanzadas como en el caso
+de C, manejo de memoria,
+
+01:30.800 --> 01:33.040
+testing en algunos otros
+casos,
+
+01:33.040 --> 01:36.720
+todas estas cuestiones que ya son mucho
+más complejas
+
+01:36.720 --> 01:42.160
+y esto siempre se quedaba muy corto en
+estos cursos de lenguajes de programación.
+
+01:42.160 --> 01:46.040
+Queremos cambiar eso, por eso ahora
+dividimos cada lenguaje de programación
+
+01:46.040 --> 01:47.200
+en varios
+cursos.
+
+01:47.200 --> 01:50.120
+Por ejemplo, la ruta de C que tengo
+planeada para ti
+
+01:50.120 --> 01:52.040
+y que espero que tomes de principio a
+fin
+
+01:52.040 --> 01:54.120
+es el curso de introducción a
+C,
+
+01:54.120 --> 01:56.120
+en donde veremos lo básico,
+básico.
+
+01:56.120 --> 01:59.080
+Luego, el curso de programación en C,
+
+01:59.080 --> 02:02.200
+que este sí es un curso en donde vas a
+aprender a usar ciclos,
+
+02:02.200 --> 02:04.880
+donde vas a poder definir el orden de un
+programa,
+
+02:04.880 --> 02:07.920
+cómo hacer que de una parte de tu código
+te vayas a otra
+
+02:07.920 --> 02:10.040
+y generar código mucho más complejo,
+
+02:10.040 --> 02:12.880
+ahí aprenderemos sobre if, for, while,
+
+02:12.880 --> 02:15.960
+todas estas cuestiones, también
+aprenderemos algunas estructuras
+
+02:15.960 --> 02:18.560
+de datos importantísimas en el lenguaje.
+
+02:18.560 --> 02:21.800
+Luego, nos pasaremos al curso número 3,
+
+02:21.800 --> 02:24.000
+en donde aprenderemos de todas las
+funciones
+
+02:24.000 --> 02:25.400
+que trae el lenguaje
+C,
+
+02:25.400 --> 02:27.480
+vamos a explorar muchas de las
+bibliotecas
+
+02:27.480 --> 02:28.840
+que vienen por
+defecto,
+
+02:28.840 --> 02:31.160
+o las bibliotecas estándar del lenguaje,
+
+02:31.160 --> 02:33.200
+vamos a explorar todas las
+funcionalidades
+
+02:33.200 --> 02:34.440
+que vienen dentro de
+ellas,
+
+02:34.440 --> 02:37.400
+y en el cuarto curso vamos a explorar
+cuestiones
+
+02:37.400 --> 02:38.680
+mucho más
+avanzadas,
+
+02:38.680 --> 02:41.000
+como manejo de memoria
+dinámica,
+
+02:41.000 --> 02:44.360
+obviamente ya aprenderás a manejar punteros,
+
+02:44.360 --> 02:47.200
+vamos a aprender a dominar ya el
+lenguaje
+
+02:47.200 --> 02:48.680
+a un nivel
+experto.
+
+02:48.680 --> 02:51.880
+Entonces, te doy la bienvenida a este
+primer curso
+
+02:51.880 --> 02:53.680
+y te cuento que yo soy Ricardo Célis,
+
+02:53.680 --> 02:55.960
+si no me conoces, trabajo en Platzi,
+
+02:55.960 --> 02:57.760
+soy profesor de muchos
+cursos,
+
+02:57.760 --> 03:00.640
+amo programar, también amo la robótica,
+
+03:00.640 --> 03:03.080
+y en este caso, amo
+enseñar,
+
+03:03.080 --> 03:05.480
+más que nada, es lo que me mueve como
+profesor.
+
+03:05.480 --> 03:08.400
+Yo en Platzi he desarrollado muchos roles,
+
+03:08.400 --> 03:10.600
+desde estar a cargo de las sesiones en vivo,
+
+03:10.600 --> 03:12.840
+hacer curso director y guiar a los
+profesores
+
+03:12.840 --> 03:14.240
+a que hagan cursos
+increíbles,
+
+03:14.240 --> 03:16.480
+y hoy en día estoy a cargo de todos los
+cursos
+
+03:16.480 --> 03:18.240
+que tienen que ver con desarrollo de software,
+
+03:18.240 --> 03:19.520
+así que aprovecha
+igual,
+
+03:19.520 --> 03:21.160
+si tienes alguna duda o algún
+curso
+
+03:21.160 --> 03:23.160
+que te gustaría ver en Platzi que aún no
+existe,
+
+03:23.160 --> 03:25.120
+cuéntamelo en los
+comentarios.
+
+03:25.120 --> 03:50.120
+Te quiero dar la bienvenida y nos vemos.
+

01-Introducción al lenguaje C/01-presentacion-curso-de-introduccion-a-c_03d52e2b-ae7d-4f48-a639-97796abeae8f.pdf

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

01-Introducción al lenguaje C/02-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://platzi.com/clases/pic/

01-Introducción al lenguaje C/02-Programación en C Estructuras Funciones y Memoria.mp4

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

01-Introducción al lenguaje C/02-Programación en C Estructuras Funciones y Memoria.vtt

@@ -0,0 +1,1536 @@
+WEBVTT
+
+00:00.000 --> 00:03.000
+¿Cómo ejecutar un código en
+C?
+
+00:03.500 --> 00:06.200
+El lenguaje C es un lenguaje de
+programación
+
+00:06.200 --> 00:07.900
+de tipo
+estructurada,
+
+00:07.900 --> 00:10.200
+es decir, vamos a ir ejecutando las
+instrucciones
+
+00:10.200 --> 00:13.500
+de nuestro código en una orden
+específico
+
+00:13.500 --> 00:14.700
+que nosotros
+tengamos.
+
+00:14.700 --> 00:16.900
+Suele ser, comienza en la primera
+línea
+
+00:16.900 --> 00:19.000
+y de ahí para abajo,
+simplemente,
+
+00:19.000 --> 00:21.300
+vamos a ir ejecutando línea a
+línea
+
+00:21.300 --> 00:22.900
+todo el código que
+tengamos.
+
+00:22.900 --> 00:25.400
+Obviamente, vamos a poder utilizar librerías,
+
+00:25.400 --> 00:26.800
+vamos a poder
+utilizar...
+
+00:26.800 --> 00:29.300
+Aquí no existe tal cosa como, por ejemplo,
+
+00:29.300 --> 00:30.800
+las clases y los
+objetos,
+
+00:30.800 --> 00:32.300
+pero existen los
+structs,
+
+00:32.300 --> 00:35.100
+que puedes verlo como los abuelitos de
+clases y objetos
+
+00:35.100 --> 00:37.500
+si vienes del paradigma orientado a objetos.
+
+00:37.500 --> 00:39.700
+Vamos a poder también crear
+funciones
+
+00:39.700 --> 00:42.100
+y todo esto nos va a permitir hacer
+programas
+
+00:42.100 --> 00:44.900
+que tengan el flujo que nosotros querramos.
+
+00:44.900 --> 00:47.200
+Ahora, C es un lenguaje, como te digo,
+
+00:47.200 --> 00:50.600
+de programación con el paradigma estructurado.
+
+00:50.600 --> 00:53.300
+Este es un lenguaje que soporta
+recursividad
+
+00:53.300 --> 00:55.300
+o
+recursión,
+
+00:55.300 --> 00:58.400
+es un lenguaje que también tiene un estado,
+
+00:58.400 --> 01:01.300
+un tipo estático de
+tipado,
+
+01:01.300 --> 01:03.600
+es un lenguaje que se podría
+considerar
+
+01:03.600 --> 01:04.900
+fuertemente
+tipado.
+
+01:04.900 --> 01:06.100
+Tienes que
+decirle
+
+01:06.100 --> 01:08.300
+de qué tipo de datos van a ser tus variables,
+
+01:08.300 --> 01:11.300
+cuánta capacidad de memoria vas a poder
+almacenar,
+
+01:11.300 --> 01:14.000
+qué tamaño van a tener tus
+datos
+
+01:14.000 --> 01:15.000
+que vas a estar
+manejando.
+
+01:15.000 --> 01:16.100
+Eso es muy
+maravilloso
+
+01:16.100 --> 01:18.400
+y lo vamos a ver en cursos más avanzados,
+
+01:18.400 --> 01:20.200
+todo lo que tiene que ver con manejo de
+memoria.
+
+01:20.200 --> 01:22.000
+De hecho, ese va a ser un curso
+entero
+
+01:22.000 --> 01:24.500
+de la ruta de estudio que yo te
+propongo
+
+01:24.500 --> 01:26.100
+que tomes para aprender en
+C.
+
+01:26.100 --> 01:29.600
+Y es un lenguaje que se ocupa
+muchísimo
+
+01:29.600 --> 01:33.500
+en aplicaciones como sistemas operativos,
+
+01:33.500 --> 01:35.300
+software de
+aplicación,
+
+01:35.300 --> 01:38.100
+se ocupa muchísimo en drivers, por ejemplo,
+
+01:38.100 --> 01:40.700
+se ocupa mucho en algunas
+supercomputadoras
+
+01:40.700 --> 01:42.200
+para hacer cálculos
+veloces,
+
+01:42.200 --> 01:45.200
+se ocupa sobre todo en sistemas embebidos,
+
+01:45.200 --> 01:47.900
+es el rey que tú vas a
+encontrar.
+
+01:47.900 --> 01:50.500
+Por ejemplo, el firmware del tablero de tu
+coche,
+
+01:50.500 --> 01:52.100
+de tu
+vehículo,
+
+01:52.100 --> 01:54.700
+ves que el tablero ya son
+digitales
+
+01:54.700 --> 01:58.200
+y tienen pantallitas y tienen el tacómetro
+digital
+
+01:58.200 --> 02:00.700
+y tienen el sensor que mide cuánta
+gasolina te queda
+
+02:00.700 --> 02:02.800
+y tienen el sensor de temperatura en el motor,
+
+02:02.800 --> 02:04.800
+todo eso, ¿adivina quién lo
+coordina?
+
+02:04.800 --> 02:08.100
+Lo coordina un código en C de bajo
+nivel
+
+02:08.100 --> 02:09.800
+que se comunica con los
+sensores,
+
+02:09.800 --> 02:12.900
+los puede leer y te puede mostrar luego la
+información
+
+02:12.900 --> 02:15.200
+comunicándose con las
+pantallas.
+
+02:15.200 --> 02:18.700
+C es un lenguaje que de verdad está en
+todos lados,
+
+02:18.700 --> 02:19.900
+en todo lo que
+ocupas,
+
+02:19.900 --> 02:25.100
+muy probablemente algunos firmware o sistemas,
+
+02:25.100 --> 02:27.700
+código de bajo nivel dentro de tu
+celular
+
+02:27.700 --> 02:29.900
+va a estar escrito con
+C.
+
+02:30.800 --> 02:32.400
+En la industria, los
+PLCs,
+
+02:32.400 --> 02:34.900
+que son Programmable Logic
+Controller
+
+02:34.900 --> 02:36.900
+o controlador lógico
+programable,
+
+02:36.900 --> 02:40.300
+son microcontroladores que tienen
+circuitos específicos
+
+02:40.300 --> 02:43.000
+para poder ser
+circuitos
+
+02:43.000 --> 02:44.800
+que le permiten ser
+industriales,
+
+02:44.800 --> 02:46.300
+soportar voltajes más
+altos,
+
+02:46.300 --> 02:49.500
+soportar ciertos entornos, temperaturas,
+humedades,
+
+02:49.500 --> 02:51.700
+que el fabricante te va a permitir decir.
+
+02:51.700 --> 02:53.900
+También tienen firmware
+específico
+
+02:53.900 --> 02:56.400
+para que estos te permitan ser
+programados
+
+02:56.400 --> 02:58.900
+con el propio software que te da el
+fabricante.
+
+02:58.900 --> 03:01.200
+Muchas veces no tienes que escribir
+directamente
+
+03:01.200 --> 03:02.300
+código como
+tal,
+
+03:02.300 --> 03:03.600
+no tienes que escribir código en
+C
+
+03:03.600 --> 03:05.500
+porque ya te dan una simplificación,
+
+03:05.500 --> 03:08.000
+un nivel arriba que algunos de forma
+gráfica
+
+03:08.000 --> 03:09.200
+puedes ir
+escribiendo,
+
+03:09.200 --> 03:12.700
+otros muy tradicionalmente en el famoso
+lenguaje
+
+03:12.700 --> 03:15.200
+o del sistema de programación de escalera,
+
+03:15.200 --> 03:17.600
+en donde vas poniendo las instrucciones
+que quieres que haga,
+
+03:17.600 --> 03:19.600
+haces los bucles y eso es
+todo.
+
+03:19.600 --> 03:25.200
+También estos son el pan de cada día en la
+industria.
+
+03:25.200 --> 03:26.500
+Muchos
+sistemas,
+
+03:26.500 --> 03:28.800
+o yo diría que la gran mayoría de los
+sistemas,
+
+03:28.800 --> 03:29.900
+si no es que
+todos,
+
+03:29.900 --> 03:32.100
+hoy en día están en las
+industrias,
+
+03:32.100 --> 03:33.600
+en las
+fábricas,
+
+03:33.600 --> 03:35.900
+en las tiras de
+ensamblaje,
+
+03:35.900 --> 03:37.400
+están hechos con
+PLCs,
+
+03:37.400 --> 03:39.100
+están controlando todo
+esto
+
+03:39.100 --> 03:42.300
+y C, obviamente, está adentro de ellos.
+
+03:42.300 --> 03:44.800
+Muchas veces no programas directamente en C,
+
+03:44.800 --> 03:46.600
+pero el software que te da el fabricante,
+
+03:46.600 --> 03:49.700
+lo que hace es pasar ese código a un
+lenguaje intermedio
+
+03:49.700 --> 03:50.800
+que podría ser
+C
+
+03:50.800 --> 03:53.000
+y después a el lenguaje
+máquina
+
+03:53.000 --> 03:55.700
+que va a entender nuestro
+microcontrolador
+
+03:55.700 --> 03:57.100
+adentro del
+PLC.
+
+03:57.100 --> 03:59.900
+Ahora, si te interesa todo este mundo de
+hardware,
+
+03:59.900 --> 04:01.000
+tengo un curso para
+ti
+
+04:01.000 --> 04:03.200
+que es el curso de programación de
+microcontroladores.
+
+04:03.200 --> 04:06.000
+Dicho esto, veamos más sobre
+C.
+
+04:06.000 --> 04:09.200
+Este lenguaje fue creado por el genio de
+la computación,
+
+04:09.200 --> 04:11.900
+conocido como de las ciencias de la
+computación
+
+04:11.900 --> 04:12.900
+para hacer de
+honor,
+
+04:12.900 --> 04:14.900
+conocido como Dennis
+Ritchie.
+
+04:14.900 --> 04:17.200
+Él trabajaba en los laboratorios de
+Bell
+
+04:17.200 --> 04:21.900
+y lo desarrolló durante 1972 y 1973.
+
+04:21.900 --> 04:24.300
+La idea era que él quería un
+lenguaje
+
+04:24.300 --> 04:25.800
+que fuera más
+comprensible,
+
+04:25.800 --> 04:29.100
+que fuera principalmente
+útil
+
+04:29.100 --> 04:30.500
+para desarrollar
+aplicaciones
+
+04:30.500 --> 04:32.700
+en el sistema operativo
+Unix,
+
+04:32.700 --> 04:35.800
+que se podría decir es el papá de sistemas
+operativos
+
+04:35.800 --> 04:38.200
+que conocemos hoy en día como Linux,
+por ejemplo,
+
+04:38.200 --> 04:39.900
+si estás familiarizado con
+ellos,
+
+04:39.900 --> 04:42.000
+muchas cosas del mundo corren en Linux,
+
+04:42.000 --> 04:43.200
+sobre todo
+servidores
+
+04:43.200 --> 04:46.800
+y cuestiones más de computación
+profesional
+
+04:46.800 --> 04:48.100
+y de alto
+rendimiento,
+
+04:48.100 --> 04:49.600
+o inclusive de algunas
+personas
+
+04:49.600 --> 04:52.300
+que simplemente no quieren utilizar
+software privativo,
+
+04:52.300 --> 04:54.400
+sino que prefieren utilizar software libre,
+
+04:54.400 --> 04:56.800
+como Ubuntu, por poner algún ejemplo,
+
+04:56.800 --> 05:00.100
+o cualquiera de las algunas otras
+distribuciones Linux
+
+05:00.100 --> 05:03.000
+que cumplen con la licencia
+GNU.
+
+05:03.000 --> 05:06.000
+Dicho esto, el señor Dennis
+Ritchie
+
+05:06.000 --> 05:07.900
+fue el creador de este
+lenguaje.
+
+05:07.900 --> 05:09.000
+Él quería hacer un
+lenguaje
+
+05:09.000 --> 05:11.800
+que también fuera compatible con otros
+sistemas operativos
+
+05:11.800 --> 05:13.800
+y que permitiera la
+portabilidad.
+
+05:13.800 --> 05:16.600
+Y aquí quiero darte una información muy
+importante.
+
+05:16.600 --> 05:19.300
+El lenguaje C es un lenguaje compilado.
+
+05:19.300 --> 05:20.500
+¿Qué quiere decir
+esto?
+
+05:20.500 --> 05:23.600
+Es un lenguaje que tú necesitas pasar por
+el compilador,
+
+05:23.600 --> 05:24.600
+decirle al
+compilador
+
+05:24.600 --> 05:27.000
+a qué sistema operativo quieres que apunte,
+
+05:27.000 --> 05:28.600
+si quieres que sea para
+Unix
+
+05:28.600 --> 05:29.900
+o para alguna otra
+distribución
+
+05:29.900 --> 05:31.500
+de algún otro sistema
+operativo.
+
+05:31.500 --> 05:33.800
+Por ejemplo, hoy en día podemos
+decir
+
+05:33.800 --> 05:35.100
+si quieres que sea para
+Linux,
+
+05:35.100 --> 05:36.600
+si quieres que sea para
+Windows,
+
+05:36.600 --> 05:38.300
+tienes que decirle al
+compilador
+
+05:38.300 --> 05:39.700
+y el compilador se va a
+encargar
+
+05:39.700 --> 05:41.700
+de agarrar tu código escrito en lenguaje
+C
+
+05:41.700 --> 05:45.300
+y vas a poder generar un
+ejecutable
+
+05:45.300 --> 05:47.200
+ya sea para el sistema operativo
+Windows
+
+05:47.200 --> 05:49.400
+o para el sistema operativo
+Linux.
+
+05:49.400 --> 05:52.100
+Ahora, muchas veces el
+código
+
+05:52.100 --> 05:53.900
+no va a funcionar
+directamente
+
+05:53.900 --> 05:56.500
+en los otros sistemas operativos sin cambios.
+
+05:57.000 --> 06:00.400
+Hay que ser conscientes de que para que un
+código en C
+
+06:00.400 --> 06:02.500
+pueda usarse en otros sistemas operativos,
+
+06:02.500 --> 06:05.600
+tienes que diseñar el código con
+portabilidad en mente.
+
+06:05.600 --> 06:08.400
+Y ahí es que sigas los estándares de ANSI
+C
+
+06:08.400 --> 06:10.500
+y que seas capaz de
+decidir,
+
+06:10.500 --> 06:12.100
+ah, ok, esta es una
+librería
+
+06:12.100 --> 06:14.300
+que me va a funcionar específicamente en
+Windows,
+
+06:14.300 --> 06:17.200
+ok, entonces voy a escribir una función
+para Windows
+
+06:17.200 --> 06:19.100
+y puedo escribir con
+portabilidad,
+
+06:19.100 --> 06:21.400
+puedo decir que según el
+código,
+
+06:21.400 --> 06:23.800
+el sistema operativo que estoy compilando
+en este momento,
+
+06:23.800 --> 06:27.600
+entonces utilice esta función o utilice
+esta función.
+
+06:27.600 --> 06:29.300
+Son cosas que se pueden hacer en
+C,
+
+06:29.300 --> 06:32.000
+lo vamos a ver de nuevo en los cursos más
+avanzados.
+
+06:32.000 --> 06:33.900
+Ahora, con esto
+dicho,
+
+06:33.900 --> 06:37.400
+no quiere decir que sea como por ejemplo
+JavaScript
+
+06:37.400 --> 06:39.000
+que lo puedes ejecutar en el
+navegador
+
+06:39.000 --> 06:40.800
+de cualquier sistema
+operativo,
+
+06:40.800 --> 06:43.700
+porque JavaScript tiene su
+motor,
+
+06:43.700 --> 06:46.100
+su runtime en donde se va a ejecutar.
+
+06:46.100 --> 06:49.300
+Por ejemplo, Node.js es un runtime
+environment,
+
+06:49.300 --> 06:52.400
+un ambiente de tiempo de ejecución para
+JavaScript,
+
+06:52.400 --> 06:56.600
+o V8, que es el motor con el que los
+navegadores como Chrome
+
+06:56.600 --> 07:00.100
+pueden utilizar o pueden ejecutar código
+JavaScript, ok.
+
+07:00.100 --> 07:03.200
+Eso es lo que se encarga de traducir ese
+código
+
+07:03.200 --> 07:05.800
+a tu computadora, el motor del navegador.
+
+07:05.800 --> 07:08.500
+¿Por qué? Porque JavaScript no es un
+lenguaje
+
+07:08.500 --> 07:10.000
+que necesite ser
+compilado.
+
+07:10.000 --> 07:11.400
+En cambio C,
+sí.
+
+07:11.400 --> 07:14.000
+Esta compilación simplemente es que le das
+clic a un botón,
+
+07:14.000 --> 07:17.000
+el compilador se va a encargar de traducir
+tu código en C
+
+07:17.000 --> 07:20.200
+al código máquina del sistema al que tú le
+estás apuntando,
+
+07:20.200 --> 07:22.400
+y entonces te va a permitir ejecutarlo.
+
+07:22.400 --> 07:25.700
+Ese paso de compilación hay muchos
+lenguajes
+
+07:25.700 --> 07:27.700
+que no necesariamente lo van a tener.
+
+07:27.700 --> 07:31.900
+Por ejemplo, Java es un lenguaje que es
+mucho más portable
+
+07:31.900 --> 07:36.600
+porque se ejecuta en la Java Virtual Machine,
+JVM.
+
+07:36.600 --> 07:38.700
+Y eso le permite que un solo código,
+
+07:38.700 --> 07:40.900
+sin ningún cambio en su
+escritura,
+
+07:40.900 --> 07:43.400
+se pueda ejecutar en varios sistemas
+operativos.
+
+07:43.400 --> 07:45.200
+Eso es una de las claves que hizo que
+Java
+
+07:45.200 --> 07:47.800
+se volviera muy, muy popular en su
+tiempo
+
+07:47.800 --> 07:49.200
+y hasta hoy en
+día.
+
+07:49.200 --> 07:53.000
+Tenemos otros casos de lenguajes, como por
+ejemplo C Sharp,
+
+07:53.000 --> 07:56.300
+que buscan cierto nivel de
+equilibrio
+
+07:56.300 --> 07:59.700
+entre rendimiento y entre tiempo de
+ejecución
+
+07:59.700 --> 08:00.900
+y facilidad de
+escribir.
+
+08:00.900 --> 08:04.200
+Ahora, C, ¿qué gana al ser un lenguaje
+compilado?
+
+08:04.200 --> 08:07.800
+¿Qué es un lenguaje que te permite tener
+mucho control de la memoria?
+
+08:07.800 --> 08:09.700
+¿Es un lenguaje que te permite
+tener
+
+08:09.700 --> 08:11.800
+mucha velocidad en tiempo de
+ejecución?
+
+08:11.800 --> 08:14.200
+Y justo vamos a ver eso volviendo a mis
+slides.
+
+08:14.200 --> 08:18.600
+Quiero empezar diciéndote que C es un
+lenguaje de nivel intermedio.
+
+08:18.600 --> 08:22.400
+Es decir, aquí quiero repasar un
+poquito
+
+08:22.400 --> 08:24.400
+los niveles de los lenguajes de programación.
+
+08:24.400 --> 08:27.400
+Recuerda que los lenguajes de más alto
+nivel
+
+08:27.400 --> 08:29.600
+van a ser los lenguajes más fáciles de
+entender
+
+08:29.600 --> 08:31.200
+para los humanos, para
+nosotros.
+
+08:31.200 --> 08:34.800
+Por ejemplo, aquí tenemos Perl, Python, Shell,
+JavaScript.
+
+08:34.800 --> 08:38.400
+Son lenguajes que generalmente son
+interpretados.
+
+08:38.400 --> 08:41.100
+Es decir, van a correr en su propio
+intérprete
+
+08:41.100 --> 08:44.400
+que luego se va a encargar de pasarlo a la
+computadora.
+
+08:44.400 --> 08:45.600
+Hablemos de
+JavaScript.
+
+08:45.600 --> 08:49.200
+Y es que aquí quiero que veas cómo C y C++
+existen en todo.
+
+08:49.200 --> 08:51.700
+JavaScript es un lenguaje interpretado.
+
+08:51.700 --> 08:53.900
+Ya te dije, se interpreta por su motor.
+
+08:53.900 --> 08:54.500
+¿Ok?
+
+08:54.500 --> 08:57.700
+Este intérprete, el intérprete de JavaScript,
+
+08:57.700 --> 08:59.300
+o el motor que nos va a permitir ejecución,
+
+08:59.300 --> 09:01.100
+¿en qué lenguaje crees que esté
+escrito?
+
+09:01.100 --> 09:02.200
+Pues
+sí.
+
+09:02.200 --> 09:04.900
+Por ejemplo, el motor B8 que utiliza
+Chrome
+
+09:04.900 --> 09:07.500
+para poder interpretar el JavaScript del
+navegador
+
+09:07.500 --> 09:11.900
+está escrito en el lenguaje
+C++,
+
+09:11.900 --> 09:15.400
+que es como una evolución que existió más
+adelante.
+
+09:15.400 --> 09:17.500
+Eso te dice mucho,
+¿no?
+
+09:17.500 --> 09:19.600
+De por qué pasan estas
+cosas,
+
+09:19.600 --> 09:22.700
+por qué JavaScript no puede correr
+directamente en el hardware.
+
+09:22.700 --> 09:24.100
+Necesita ser
+interpretado.
+
+09:24.100 --> 09:25.300
+Así es como
+funciona.
+
+09:25.300 --> 09:27.900
+Tenemos lenguajes de alto o medio nivel,
+
+09:27.900 --> 09:29.700
+como C y
+C++,
+
+09:29.700 --> 09:32.700
+que son lenguajes ya mucho más abstractos.
+
+09:32.700 --> 09:34.800
+Estos no se ocupan tanto en
+aplicaciones
+
+09:34.800 --> 09:37.300
+que son gráficas o para el
+usuario.
+
+09:37.300 --> 09:40.400
+En el caso de C, en el caso de C++, sí,
+
+09:40.400 --> 09:42.300
+porque tiene muchas facilidades para esto.
+
+09:42.300 --> 09:43.400
+Tiene más
+librerías,
+
+09:43.400 --> 09:44.800
+tiene
+más...
+
+09:44.800 --> 09:47.500
+Como todo el paradigma orientado a
+objetos
+
+09:47.500 --> 09:49.200
+ya está implementado en
+C++.
+
+09:49.200 --> 09:51.600
+Y, de hecho, es un lenguaje que siguen
+manteniendo.
+
+09:51.600 --> 09:54.800
+Y, bueno, simplemente Bjorn Strostrup,
+
+09:54.800 --> 09:56.400
+que es el creador de
+C++,
+
+09:56.400 --> 09:59.700
+todavía sigue trabajando en él y creando
+nuevos features.
+
+09:59.700 --> 10:01.300
+No salen cada
+año.
+
+10:01.300 --> 10:04.200
+Salen cada cuatro a veces los años que les
+tomen,
+
+10:04.200 --> 10:07.000
+pero pueden seguir generando nuevas cosas.
+
+10:07.000 --> 10:08.700
+Esto es, por
+ejemplo,
+
+10:08.700 --> 10:11.700
+el lenguaje en el que está escrito la
+mayoría del malware.
+
+10:11.700 --> 10:12.900
+¿Por
+qué?
+
+10:12.900 --> 10:14.500
+Y aquí quiero que
+pienses.
+
+10:15.500 --> 10:17.600
+Simple y sencillamente porque son
+lenguajes
+
+10:17.600 --> 10:19.300
+que te dejan acceder a la
+memoria,
+
+10:19.300 --> 10:20.700
+que te dejan acceder a
+cosas
+
+10:20.700 --> 10:23.800
+muy, muy adentro de tu
+computadora
+
+10:23.800 --> 10:25.600
+que estos otros lenguajes
+no.
+
+10:25.600 --> 10:27.800
+¿Y para qué sirve acceder a la
+memoria?
+
+10:27.800 --> 10:31.400
+Bueno, con estos lenguajes un hacker puede
+hacer cosas increíbles,
+
+10:31.400 --> 10:34.700
+como detectar si un software que estás
+corriendo, digamos, un...
+
+10:35.400 --> 10:37.500
+Hablemos de un software general que te
+bajaste
+
+10:37.500 --> 10:40.300
+para poder grabar tu
+pantalla.
+
+10:40.300 --> 10:43.200
+Ahorita está de moda esto de capturar
+pantalla,
+
+10:43.200 --> 10:44.200
+generar
+video.
+
+10:44.200 --> 10:45.900
+Bueno, estás capturando tu pantalla,
+
+10:45.900 --> 10:48.600
+bajaste un software que fue desarrollado
+sin buenas prácticas
+
+10:48.600 --> 10:51.100
+y ese software tiene un leak de memoria.
+
+10:51.100 --> 10:52.600
+¿Qué significa un leak de
+memoria?
+
+10:52.600 --> 10:56.200
+Que hay ciertas variables que habían
+declarado
+
+10:56.200 --> 10:57.400
+o algo por el
+estilo
+
+10:57.400 --> 11:01.200
+y no estaban
+entrando
+
+11:01.200 --> 11:03.900
+en la cantidad de memoria reservado para
+esas variables.
+
+11:03.900 --> 11:06.000
+O algún error como que, por ejemplo,
+
+11:06.000 --> 11:09.800
+el software tenía o accedía a un permiso
+que no debería
+
+11:09.800 --> 11:13.100
+y dejaba guardadas las credenciales en la
+memoria.
+
+11:13.100 --> 11:15.100
+¿Por qué? Porque no estaban con la buena
+práctica
+
+11:15.100 --> 11:16.800
+de tenerlo encriptado, lo que
+sea.
+
+11:16.800 --> 11:18.100
+¿Qué pasa
+ahí?
+
+11:18.100 --> 11:21.300
+Bueno, tú con C puedes acceder a la
+memoria de la computadora,
+
+11:21.300 --> 11:24.900
+empezar a buscar y puedes encontrar estos
+exploits,
+
+11:24.900 --> 11:26.400
+puedes abusar de
+ellos
+
+11:26.400 --> 11:28.700
+y puedes generar un caos en las computadoras.
+
+11:28.700 --> 11:32.700
+De hecho, muchos hackers que de verdad
+encuentran exploits
+
+11:32.700 --> 11:35.700
+a nivel como los que han pasado con los
+CPUs Intel,
+
+11:35.700 --> 11:39.000
+en donde son cosas que pasan durante el
+tiempo de ejecución
+
+11:39.000 --> 11:42.100
+dentro del caché del CPU, cosas de ese estilo,
+
+11:42.100 --> 11:46.300
+se hacen con mucho código directo, código C,
+
+11:46.300 --> 11:48.000
+que es de mucho más bajo
+nivel
+
+11:48.000 --> 11:50.500
+y les permite tener acceso a estas
+cosas
+
+11:50.500 --> 11:52.700
+que normalmente nunca tendrías
+acceso
+
+11:52.700 --> 11:54.300
+con un lenguaje de alto
+nivel.
+
+11:54.300 --> 11:57.900
+¿Por qué? Porque el intérprete no te
+dejaría pasar a ello.
+
+11:57.900 --> 12:01.700
+Luego, tenemos lenguaje de montaje o
+lenguaje ensamblador.
+
+12:01.700 --> 12:05.200
+El lenguaje ensamblador puede ser el Intel
+x86,
+
+12:05.200 --> 12:10.400
+que son los sets de instrucciones que da
+el fabricante del CPU.
+
+12:10.400 --> 12:12.200
+Entonces, aquí por
+suerte,
+
+12:12.200 --> 12:14.200
+hubo una época en donde se
+estandarizó
+
+12:14.200 --> 12:16.200
+e Intel sacó
+x86,
+
+12:16.200 --> 12:19.100
+que es un set de instrucciones para sus CPUs,
+
+12:19.100 --> 12:20.800
+principalmente de 32
+bits,
+
+12:20.800 --> 12:22.500
+y AMD lo adaptó
+también,
+
+12:22.500 --> 12:24.500
+que eran los principales fabricantes de CPUs.
+
+12:24.500 --> 12:26.700
+AMD sacó
+AMD64,
+
+12:26.700 --> 12:28.700
+que era una extensión a los
+sets
+
+12:28.700 --> 12:32.700
+o a todo lo que tenían como set de
+instrucciones de x86,
+
+12:32.700 --> 12:34.600
+que había sacado originalmente Intel,
+
+12:34.600 --> 12:38.500
+y se volvió el estándar para CPUs de 64 bits.
+
+12:38.500 --> 12:40.600
+El hecho de que esto sea
+estándar
+
+12:40.600 --> 12:43.800
+permite que tú tengas una computadora con
+un CPU AMD
+
+12:43.800 --> 12:45.400
+o con un CPU
+Intel
+
+12:45.400 --> 12:47.000
+y que no pase
+nada
+
+12:47.000 --> 12:49.300
+de que tú simplemente puedes instalarle
+Windows
+
+12:49.300 --> 12:50.600
+a cualquiera de las
+dos
+
+12:50.600 --> 12:52.800
+y no tienes que bajarte una versión de
+Windows
+
+12:52.800 --> 12:55.200
+para AMD y una versión de Windows para Intel.
+
+12:55.200 --> 12:55.900
+¿Por
+qué?
+
+12:55.900 --> 12:58.300
+Porque todos los CPUs modernos hoy en
+día
+
+12:58.300 --> 13:01.800
+ocupan el set de instrucciones AMD64.
+
+13:01.800 --> 13:04.100
+Simple y sencillamente, ese es el estándar.
+
+13:04.100 --> 13:06.100
+Tienen interfaces de 64
+bits
+
+13:06.100 --> 13:09.100
+y es lo que tenemos hoy en
+día.
+
+13:09.100 --> 13:12.400
+Antes, cuando existían CPUs en el mercado
+de 32 bits
+
+13:12.400 --> 13:15.400
+y de 64 bits, sí existe
+software.
+
+13:15.400 --> 13:18.600
+De hecho, todavía existe software que te
+pide forzosamente
+
+13:18.600 --> 13:21.700
+que tengas instalado un CPU de 64 bits,
+
+13:21.700 --> 13:24.000
+pero no importa si es AMD o
+Intel.
+
+13:24.000 --> 13:26.100
+Aquí quiero que veas la maravilla que
+pasó
+
+13:26.100 --> 13:28.400
+de que se lograron poner de acuerdo dos
+compañías
+
+13:28.400 --> 13:29.800
+que son
+competencia
+
+13:29.800 --> 13:31.100
+y tuvieron un
+estándar.
+
+13:31.100 --> 13:33.200
+Esto nos permite mucha
+portabilidad
+
+13:33.200 --> 13:35.500
+en software a nivel sistema operativo.
+
+13:35.500 --> 13:38.800
+Repito, si tú tienes un CPU Intel o un AMD,
+
+13:38.800 --> 13:41.200
+no importa, te bajas Windows 10 y lo instalas.
+
+13:41.200 --> 13:43.400
+Te bajas Ubuntu y lo
+instalas.
+
+13:43.400 --> 13:46.200
+Ahí, si tienes una computadora muy
+vieja
+
+13:46.200 --> 13:47.700
+que es de 32
+bits,
+
+13:47.700 --> 13:49.400
+entonces sí tienes que
+buscar
+
+13:49.400 --> 13:52.100
+sistemas operativos compatibles a 32 bits,
+
+13:52.100 --> 13:54.400
+pero de nuevo, dentro de los de 32 bits,
+
+13:54.400 --> 13:56.000
+es decir, de
+x86,
+
+13:56.000 --> 13:58.500
+no importa si es AMD o
+Intel,
+
+13:58.500 --> 14:00.300
+si te bajas un Windows de 32
+bits,
+
+14:00.300 --> 14:01.900
+lo vas a poder instalar
+ahí.
+
+14:01.900 --> 14:04.300
+¿Ok? Todo en orden
+entonces.
+
+14:04.300 --> 14:07.200
+Por último, tenemos representación
+hexadecimal,
+
+14:07.200 --> 14:08.400
+que es el lenguaje
+máquina.
+
+14:08.400 --> 14:11.900
+Esto ya es lo que directamente termina en
+los archivos finales
+
+14:11.900 --> 14:13.800
+para que nuestro sistema
+operativo
+
+14:13.800 --> 14:15.500
+lo pueda
+interpretar.
+
+14:15.500 --> 14:17.500
+Y tenemos el código
+binario,
+
+14:17.500 --> 14:20.300
+que ya es lo único que pueden leer los CPUs.
+
+14:20.300 --> 14:23.600
+Los CPUs funcionan a base de
+transistores
+
+14:23.600 --> 14:25.800
+y a base de código binario, ceros y unos.
+
+14:25.800 --> 14:29.100
+Eso es todo lo que mueve nuestro mundo actual.
+
+14:29.100 --> 14:33.200
+La tecnología, el software, todo es ceros
+y unos.
+
+14:33.200 --> 14:35.500
+Y eso se llama código
+binario.
+
+14:36.100 --> 14:39.200
+Ahora, aquí quiero que veas esta imagen de
+apoyo.
+
+14:39.200 --> 14:41.000
+Recuerda que puedes descargar estos slides.
+
+14:41.000 --> 14:43.500
+Aquí tenemos como el nivel del lenguaje,
+
+14:43.500 --> 14:45.200
+si es de bajo o alto
+nivel.
+
+14:45.200 --> 14:47.800
+Esto no quiere decir que es un lenguaje
+malo o bueno, para nada.
+
+14:47.800 --> 14:49.800
+Hay un lenguaje para cada aplicación.
+
+14:49.800 --> 14:51.800
+Por ejemplo, C y C++ para videojuegos,
+
+14:51.800 --> 14:54.000
+C para hardware
+embedido,
+
+14:54.000 --> 14:55.600
+para todo lo que ya te
+dije,
+
+14:55.600 --> 14:58.000
+sistema de desarrollo de drivers para tu
+computadora,
+
+14:58.000 --> 15:00.100
+cuestiones de alto
+rendimiento.
+
+15:00.100 --> 15:04.100
+Y tenemos como Python para todo lo que es
+data science,
+
+15:04.100 --> 15:06.900
+tenemos Python para desarrollo web, sobre
+todo backend.
+
+15:06.900 --> 15:08.800
+Tenemos JavaScript para desarrollo web,
+
+15:08.800 --> 15:11.100
+principalmente frontend, también se puede
+backend.
+
+15:11.100 --> 15:13.900
+Tenemos un lenguaje para cada aplicación.
+
+15:13.900 --> 15:16.300
+Por favor, nunca te cierres a aprender un
+solo lenguaje
+
+15:16.300 --> 15:18.300
+y querer hacer todo con ese lenguaje.
+
+15:18.300 --> 15:19.300
+No.
+
+15:19.300 --> 15:22.000
+Aprende un lenguaje según la aplicación
+que tú tengas.
+
+15:22.000 --> 15:24.500
+Total, si entiendes de verdad de computación,
+
+15:24.500 --> 15:27.000
+vas a poder entender cualquier
+lenguaje
+
+15:27.000 --> 15:29.900
+porque todos tienen muchos principios muy
+similares.
+
+15:29.900 --> 15:31.600
+Entonces, siguiendo con
+esto,
+
+15:31.600 --> 15:34.700
+vamos a tener que la velocidad de
+ejecución del programa,
+
+15:34.700 --> 15:37.100
+mientras más cercano al
+hardware,
+
+15:37.100 --> 15:41.100
+mientras más cercano al fierro, al CPU de
+tu computadora,
+
+15:41.100 --> 15:42.900
+pues mucho más rápido va a
+ser
+
+15:42.900 --> 15:47.100
+y también la lectura humana más difícil va
+a ser,
+
+15:47.100 --> 15:50.600
+mientras más de bajo nivel sea el lenguaje
+de programación.
+
+15:50.600 --> 15:52.400
+Y mientras más de alto
+nivel,
+
+15:52.400 --> 15:54.200
+la lectura humana va a ser más fácil,
+
+15:54.200 --> 15:57.000
+pero el programa va a ser más lento en
+tiempo de ejecución
+
+15:57.000 --> 16:00.200
+y el nivel de lenguaje va a ser más
+alto
+
+16:00.200 --> 16:01.800
+porque así se les denomina.
+Punto.
+
+16:01.800 --> 16:03.100
+En la siguiente
+clase,
+
+16:03.100 --> 16:05.800
+vamos a ver por qué a mí en particular me
+gusta C
+
+16:05.800 --> 16:09.100
+y luego de eso vamos a comenzar a preparar
+nuestro entorno.
+
+16:09.100 --> 16:11.100
+Hasta ahorita, déjame qué dudas tienes,
+
+16:11.100 --> 16:38.100
+cuéntame si te emociona el curso y nos
+vemos en la próxima.
+

01-Introducción al lenguaje C/03-Cómo una computadora interpreta datos binarios.mp4

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

01-Introducción al lenguaje C/03-Cómo una computadora interpreta datos binarios.vtt

@@ -0,0 +1,503 @@
+WEBVTT
+
+00:00.000 --> 00:08.000
+¡Hey! Bienvenido o bienvenido a esta clase
+pública de nuestro curso de algoritmos en Platzi.
+
+00:08.000 --> 00:12.000
+Yo, Ricardo Celis, tu profesor, te voy a
+enseñar en esta clase
+
+00:12.000 --> 00:17.000
+cómo entiende las cosas una computadora de
+una forma súper gráfica y rápida.
+
+00:17.000 --> 00:19.000
+¿Qué esperas? ¡Comienza a aprender
+ya!
+
+00:19.000 --> 00:22.000
+Antes de que comiences este increíble
+curso de algoritmos,
+
+00:22.000 --> 00:25.000
+hablemos de para quién le hacemos los
+programas,
+
+00:25.000 --> 00:28.000
+quién se va a encargar de ejecutar este
+código que escribimos.
+
+00:28.000 --> 00:32.000
+Ese es el hardware o, más específicamente,
+la computadora.
+
+00:32.000 --> 00:36.000
+Las computadoras nacen de esta necesidad
+humana
+
+00:36.000 --> 00:42.000
+de tener herramientas que nos van a
+permitir hacer nuestros trabajos del día a día más fácilmente,
+
+00:42.000 --> 00:48.000
+como las armas para cazar, las
+herramientas para sembrar y construir
+
+00:48.000 --> 00:53.000
+que nos permitieron tener mejores
+alimentos y asentarnos como humanidad
+
+00:53.000 --> 00:58.000
+o, inclusive, más adelante, como la
+electricidad.
+
+00:58.000 --> 01:02.000
+En un principio, las computadoras nos
+ayudaban a trabajar con números
+
+01:02.000 --> 01:06.000
+de forma mucho más rápida y eficiente de
+la que nosotros podríamos hacerlo.
+
+01:06.000 --> 01:10.000
+Simplemente les dábamos un input, un
+número de input a calcular.
+
+01:10.000 --> 01:12.000
+Esta sería la
+entrada.
+
+01:12.000 --> 01:15.000
+La computadora almacenaba la información,
+
+01:15.000 --> 01:18.000
+le solicitábamos las operaciones que
+necesitamos,
+
+01:18.000 --> 01:22.000
+luego, con una serie de pasos previamente
+definidos,
+
+01:22.000 --> 01:27.000
+procesaban la información y nos generaban
+un resultado de salida.
+
+01:27.000 --> 01:31.000
+Hoy en día, las computadoras han avanzado
+a pasos agigantados,
+
+01:31.000 --> 01:34.000
+permitiéndonos tener teléfonos inteligentes,
+
+01:34.000 --> 01:38.000
+altavoces con asistentes de voz, vehículos
+que se manejan solos
+
+01:38.000 --> 01:42.000
+e, inclusive, robots que llegan a Marte.
+
+01:42.000 --> 01:47.000
+Estos dispositivos que mencionamos no
+manejan solamente números y operaciones matemáticas.
+
+01:47.000 --> 01:52.000
+No, puedes manejar foto, video, juegos,
+música, etc.
+
+01:52.000 --> 01:54.000
+¿Cómo lo hacen?
+Veamos.
+
+01:54.000 --> 01:57.000
+Hablemos de lo que ocurre dentro de una
+computadora.
+
+01:57.000 --> 02:01.000
+Y seguramente has visto en películas o
+series que cuando está ocurriendo
+
+02:01.000 --> 02:04.000
+algún proceso en la pantalla, puedes ver
+ceros y unos.
+
+02:04.000 --> 02:07.000
+Esto que has visto son los números binarios.
+
+02:07.000 --> 02:10.000
+Y aunque ya nadie escribe programas en
+binario,
+
+02:10.000 --> 02:14.000
+estos son el tipo de señales que existen
+dentro de tu computadora.
+
+02:14.000 --> 02:19.000
+Piensa en el cable que conecta el
+interruptor de luz de tu habitación con la lámpara.
+
+02:19.000 --> 02:22.000
+Este cable puede tener dos
+estados.
+
+02:22.000 --> 02:25.000
+Este puede ser ON, que sería un
+1,
+
+02:25.000 --> 02:28.000
+u OFF, que sería un
+0.
+
+02:28.000 --> 02:32.000
+Así puedes representar un sí o un no,
+un ON o un OFF,
+
+02:32.000 --> 02:34.000
+un true o false en
+computación.
+
+02:34.000 --> 02:38.000
+Dentro de una computadora tenemos millones
+de dispositivos electrónicos,
+
+02:38.000 --> 02:40.000
+conocidos como
+transistores,
+
+02:40.000 --> 02:46.000
+que van a almacenar estos ceros o unos,
+tal como lo hiciera el cable en nuestro ejemplo anterior.
+
+02:46.000 --> 02:49.000
+A este dato que puede valer 0 o
+1,
+
+02:49.000 --> 02:52.000
+se le conoce en computación como un
+bit
+
+02:52.000 --> 02:55.000
+y es la unidad mínima de información que
+podemos manejar.
+
+02:55.000 --> 02:58.000
+Y los cables, bueno, los cables dentro de
+un circuito
+
+02:58.000 --> 03:02.000
+solamente se van a encargar de llevar la
+información de un lado a otro.
+
+03:02.000 --> 03:07.000
+Las computadoras utilizan transistores en
+diferentes acomodos
+
+03:07.000 --> 03:11.000
+para poder hacer todas las funcionalidades
+que necesitan,
+
+03:11.000 --> 03:14.000
+almacenar información, hacer operaciones y
+más.
+
+03:14.000 --> 03:17.000
+A continuación veremos cómo ocurre eso.
+
+03:17.000 --> 03:23.000
+La base que se utiliza para poder tener
+números, imágenes, textos y audios
+
+03:23.000 --> 03:27.000
+con este sistema de sólo valores como 0 y 1,
+es el sistema binario.
+
+03:27.000 --> 03:29.000
+Vamos a ver cómo
+funciona.
+
+03:29.000 --> 03:33.000
+Nosotros estamos acostumbrados a trabajar
+con el número decimal.
+
+03:33.000 --> 03:36.000
+Por ejemplo, este número sería el número 12.
+
+03:36.000 --> 03:40.000
+O este otro número sería el número 48.
+
+03:40.000 --> 03:44.000
+En número binario nosotros no vamos a
+funcionar así.
+
+03:44.000 --> 03:47.000
+En número decimal tenemos, por ejemplo,
+los miles,
+
+03:47.000 --> 03:52.000
+tenemos cientos, tenemos decimales y
+tenemos unidades.
+
+03:52.000 --> 03:59.000
+Entonces este número son mil, doscientos,
+cuarenta y ocho unidades.
+
+03:59.000 --> 04:05.000
+En el sistema binario, en cambio, nosotros
+solamente vamos a poder utilizar 0 y 1.
+
+04:05.000 --> 04:11.000
+Entonces podemos tener combinaciones
+numéricas que sean como la siguiente.
+
+04:11.000 --> 04:13.000
+1, 1,
+1.
+
+04:13.000 --> 04:18.000
+En sistema binario la primera posición
+vale 1 y se van multiplicando por 2 cada vez.
+
+04:18.000 --> 04:21.000
+Entonces la segunda posición son 2, la
+tercera posición son 4
+
+04:21.000 --> 04:25.000
+y la cuarta posición sería
+8.
+
+04:25.000 --> 04:29.000
+Por ejemplo, este número binario que acabo
+de formar aquí sería 8,
+
+04:29.000 --> 04:34.000
+más 4, 12, más 2, 14, más 1,
+15.
+
+04:34.000 --> 04:37.000
+Hemos formado el número 15 en binario.
+
+04:37.000 --> 04:41.000
+Ahora que ya sabes cómo la computadora
+puede entender los números binarios,
+
+04:41.000 --> 04:44.000
+quizás te estás preguntando, ¿y las letras
+de dónde salen?
+
+04:44.000 --> 04:47.000
+Existen convenciones, como el código ASCII,
+
+04:47.000 --> 04:51.000
+que nos dice que cada letra va a tener un
+valor numérico.
+
+04:51.000 --> 04:54.000
+Por ejemplo, la letra T en valor decimal
+va a ser 84
+
+04:54.000 --> 04:58.000
+y si tú presionas Alt 84 en tu computadora,
+
+04:58.000 --> 05:01.000
+vas a poder ver cómo se escribe el carácter T.
+
+05:01.000 --> 05:06.000
+Luego, la computadora no entiende el
+número 84 porque está usando el sistema decimal,
+
+05:06.000 --> 05:09.000
+pero la computadora sí va a entender el
+siguiente número,
+
+05:09.000 --> 05:20.000
+que sería 0, 0, 1, 0, 1, 0,
+1.
+
+05:20.000 --> 05:26.000
+Este número decimal de 8 bits, 1, 2, 3, 4, 5,
+6, 7
+
+05:26.000 --> 05:30.000
+y un bit de más que no estamos ocupando,
+un 0 a la izquierda que no cuenta,
+
+05:30.000 --> 05:34.000
+es un número que nos permite almacenar un
+carácter.
+
+05:34.000 --> 05:37.000
+Entonces, acabas de ver cómo las
+computadoras manejan
+
+05:37.000 --> 05:40.000
+de binario a
+letras.
+
+05:40.000 --> 05:45.000
+Ahora, un documento de texto no es otra
+cosa más que una colección de caracteres
+
+05:45.000 --> 05:49.000
+que no son otra cosa más que ceros y unos
+que la computadora puede entender.
+
+05:49.000 --> 05:54.000
+Una imagen va a ser la representación de
+muchos pixeles juntos
+
+05:54.000 --> 05:58.000
+y cada uno de estos pixeles va a tener
+ciertas características.
+
+05:58.000 --> 06:01.000
+Así como existe el estándar para los
+caracteres,
+
+06:01.000 --> 06:03.000
+tenemos estándares para las imágenes,
+
+06:03.000 --> 06:08.000
+que te van a decir que vas a tener una
+colección de, por ejemplo,
+
+06:08.000 --> 06:11.000
+imagínate que cada una de estas líneas es
+un pixel
+
+06:11.000 --> 06:13.000
+y este pixel va a tener
+colores.
+
+06:13.000 --> 06:17.000
+Estos colores van a estar representados
+con ceros y unos
+
+06:17.000 --> 06:21.000
+que la computadora puede almacenar y
+entender el mismo.
+
+06:21.000 --> 06:25.000
+Entonces, ahora cuando escuches una imagen
+que tiene tantos megapixeles,
+
+06:25.000 --> 06:28.000
+eso significa tantos millones de
+pixeles
+
+06:28.000 --> 06:33.000
+y cada uno de esos millones de pixeles va
+a ser información en binario
+
+06:33.000 --> 06:37.000
+que pintan la imagen de un color y la
+colección de todos los colores
+
+06:37.000 --> 06:40.000
+forman la fotografía, el dibujo o el diseño.
+
+06:40.000 --> 06:43.000
+Esto mismo aplica, por ejemplo, para un video,
+
+06:43.000 --> 06:47.000
+que además de que tiene imágenes una por una,
+
+06:47.000 --> 06:51.000
+junta 24 imágenes por segundo al menos,
+o 60 o 120
+
+06:51.000 --> 06:54.000
+y las guarda en otro formato
+más.
+
+06:54.000 --> 06:56.000
+Pero al final, ¿qué está usando? Imágenes.
+
+06:56.000 --> 07:00.000
+Y al final, cada una de esas imágenes se
+descompone en ceros y unos.
+
+07:00.000 --> 07:03.000
+¿Y la música? ¿Qué pasa con la
+música?
+
+07:03.000 --> 07:07.000
+Bueno, la música son archivos que tú
+almacenas en tu computadora
+
+07:07.000 --> 07:10.000
+que son representaciones, efectivamente,
+en binario
+
+07:10.000 --> 07:14.000
+de cuál es el valor que debe estar
+reproduciendo la computadora.
+
+07:14.000 --> 07:17.000
+Ahora, con todo esto claro, hablemos de
+los programas.
+
+07:17.000 --> 07:20.000
+El software son las series de
+instrucciones
+
+07:20.000 --> 07:22.000
+que tú le vas a dar a la
+computadora
+
+07:22.000 --> 07:25.000
+para que esta pueda llevar a cabo los
+procesos.
+
+07:25.000 --> 07:28.000
+El flujo que todo programa va a
+seguir
+
+07:28.000 --> 07:31.000
+es el de tener un input, una entrada,
+¿cierto?
+
+07:31.000 --> 07:35.000
+Vamos a tener un CPU y una
+memoria
+
+07:35.000 --> 07:38.000
+que se van a encargar de comunicar para
+hacer todo el trabajo
+
+07:38.000 --> 07:40.000
+de procesar la información, guardar variables,
+
+07:40.000 --> 07:42.000
+mantener la información
+correcta
+
+07:42.000 --> 07:46.000
+y después procesar un resultado final.
+
+07:46.000 --> 07:49.000
+Estos resultados finales son los que vas a
+aprender a generar
+
+07:49.000 --> 07:52.000
+en el curso de Algoritmos y Estructuras de
+Datos.
+
+07:52.000 --> 07:55.000
+En este curso aprenderás a enseñarle a la
+computadora
+
+07:55.000 --> 07:59.000
+los pasos a seguir para resolver problemas
+simples o complejos
+
+07:59.000 --> 08:02.000
+y quitarte el miedo a cualquier
+desafío
+
+08:02.000 --> 08:04.000
+que tengas en tu vida
+profesional.
+
+08:04.000 --> 08:19.000
+Nos vemos en el curso de Algoritmos.
+

01-Introducción al lenguaje C/03-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://platzi.com/clases/ordenamiento/

01-Introducción al lenguaje C/04-Fundamentos del Lenguaje C para Microcontroladores.mp4

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

01-Introducción al lenguaje C/04-Fundamentos del Lenguaje C para Microcontroladores.vtt

@@ -0,0 +1,230 @@
+WEBVTT
+
+00:00.000 --> 00:08.580
+Hola, aquí te quiero contar porque a mí me
+parece que sé, deberías aprenderlo y aquí
+
+00:08.580 --> 00:13.700
+esta es la clase que yo digo quiero que
+digas ok, me quedo aquí. A partir de esta clase todo va a
+
+00:13.700 --> 00:17.640
+ser práctico, vamos a aprender todo sobre
+el lenguaje, pero de verdad quiero contarte esto
+
+00:17.640 --> 00:23.100
+porque tiene mucho valor. Lo primero que
+te quiero decir es que sé es un lenguaje que ayuda a entender
+
+00:23.100 --> 00:28.660
+los fundamentos de teoría de computación.
+¿Cómo así? Y mira, aquí te quiero hablar desde mi
+
+00:28.660 --> 00:35.220
+experiencia. Yo aprendí computación,
+aprendí sobre desarrollo de software, aprendí todo esto,
+
+00:35.220 --> 00:40.540
+aprendí sobre programación porque
+programaba microcontroladores. Los microcontroladores son
+
+00:40.540 --> 00:45.980
+estas pequeñas computadoras que valen
+desde 20 centavos de dólar hasta 10, 15 o 20 dólares,
+
+00:45.980 --> 00:51.820
+que se ocupan en todo. Por ejemplo, en el
+control de tu lavadora, en una cámara, en celulares, en
+
+00:51.820 --> 00:57.140
+tableros de coches, de verdad están en
+todo lado que tenga cierto código, que tenga cierto nivel
+
+00:57.140 --> 01:01.660
+de software en donde puedas configurar algo,
+presionar botones, pero que no llegue a tener
+
+01:01.660 --> 01:07.300
+la necesidad de mucho procesamiento.
+Por ejemplo, la cámara, una cámara fotográfica va a tener un
+
+01:07.300 --> 01:13.340
+CPU muy poderoso que se encarga de
+procesar las imágenes digitales de vídeo que capta el sensor,
+
+01:13.340 --> 01:17.420
+pero además puede tener microcontroladores
+para todo lo que es el manejo de botones,
+
+01:17.420 --> 01:22.340
+un microcontrolador podría sin problema
+controlar el motor que se encarga del autofocus en una
+
+01:22.340 --> 01:27.660
+cámara, detectar cuando se presionó el
+obturador, porque son cámaras digitales hoy en día y aunque
+
+01:27.660 --> 01:32.780
+el obturador te da una sensación de ser
+algo mecánico, en realidad es 100% digital y esto
+
+01:32.780 --> 01:40.700
+te permite tener mucho código en las cosas,
+te permite meterle el código a lo que sea,
+
+01:40.700 --> 01:44.500
+casi de verdad podrías hacer con un
+microcontrolador un regador de plantas automático,
+
+01:44.500 --> 01:49.380
+un alimentador de gatos automático, o que
+tu refrigerador se conecte a wifi, o que tu
+
+01:49.380 --> 01:53.980
+refrigerador se conecte a bluetooth y te
+avise cuál es la temperatura y si hay partículas
+
+01:53.980 --> 02:00.340
+contaminantes ahí a través de sensores o
+gases, lo que quieras. Y estos microcontroladores son
+
+02:00.340 --> 02:05.260
+como computadoras a escala pero que no
+tienen un sistema operativo y al no tener un sistema
+
+02:05.260 --> 02:09.660
+operativo yo tenía que programar todo,
+yo tenía que programar cómo iba a accesar a la memoria,
+
+02:09.660 --> 02:14.540
+cuáles iban a ser las entradas, cuáles
+iban a ser las salidas de mi programa, todo esto lo
+
+02:14.540 --> 02:21.620
+hacía yo a través de puro código C y el
+hecho de que se utilice C es porque se te permite tener
+
+02:21.620 --> 02:26.780
+acceso al control de memoria de un programa,
+por ejemplo tiene muchas cosas de bajo nivel que son
+
+02:26.780 --> 02:32.300
+excelentes para esto y por eso aquí quiero
+decirte que C es un lenguaje que te va a ayudar a entender
+
+02:32.300 --> 02:37.340
+los fundamentos de teoría de computación,
+si te sigues con este curso y los siguientes de lenguaje
+
+02:37.340 --> 02:43.140
+te aseguro que vas a entender mucho más a
+fondo cómo funciona la memoria, qué es un stack overflow,
+
+02:43.140 --> 02:49.540
+que estoy muy seguro que has escuchado ese
+sitio web cuando tienes algún bug en tu código o algo
+
+02:49.540 --> 02:54.500
+por el estilo, vas a stack overflow,
+revisas qué está pasando, encuentras la solución, la copias,
+
+02:54.500 --> 03:00.980
+la pegas en tu programa, se vale y ya,
+pero qué significa un stack overflow, con C puedes entender
+
+03:00.980 --> 03:06.380
+de verdad qué significa un stack overflow
+y verlo verlo suceder, vamos a entender cuestiones como
+
+03:06.380 --> 03:11.220
+todo lo que son apuntadores, todo lo que
+son operadores a nivel de bits, vamos a entender
+
+03:11.220 --> 03:17.340
+cosas de teoría de computación que un
+lenguaje de alto nivel no nos permite porque no se meten con
+
+03:17.340 --> 03:23.260
+estas cosas y te van a servir muchísimo si
+quieres de verdad, no sé, en un futuro llegar a ser
+
+03:23.260 --> 03:28.480
+compiladores, en un futuro de ser un
+verdadero científico de computación, así que eso es lo que
+
+03:28.480 --> 03:34.260
+vamos a ir logrando con estos cursos de C.
+Luego C tiene pocas librerías principalmente porque
+
+03:34.260 --> 03:39.500
+cuando se desarrolló no existía todo esto,
+lo que son comunidades de desarrollo, muchos conceptos,
+
+03:39.500 --> 03:46.180
+por ejemplo yo aprendí en un libro todavía
+y creo que es una gran forma de aprenderlo, pero no tiene
+
+03:46.180 --> 03:51.140
+muchas librerías, es decir, si tú quieres
+desarrollar una aplicación específica probablemente te toque
+
+03:51.140 --> 03:56.540
+hacer las librerías a ti y eso es lo que a
+nosotros justo nos pasaba cuando programamos robots o con
+
+03:56.540 --> 04:01.300
+microcontroladores y es que no había una
+librería para control de motores, no había una librería
+
+04:01.300 --> 04:06.780
+para control de sensores y nosotros
+aprendíamos cómo desarrollar esto desde cero, es maravilloso,
+
+04:06.780 --> 04:13.140
+porque de verdad entiendes más cómo están
+pasando las cosas, llegas a tener mucho mayor comprensión
+
+04:13.140 --> 04:17.940
+de lo que está pasando adentro de, que de
+hecho en Platzi nos encanta que tú sepas qué hay detrás
+
+04:17.940 --> 04:22.940
+de las cosas, por eso tenemos un curso
+como el curso taller de creación de single page
+
+04:22.940 --> 04:27.700
+application router en donde te enseño cómo
+funcionaría un router por dentro sin utilizar
+
+04:27.700 --> 04:32.700
+ninguna librería, utilizando javascript puro,
+si te interesa javascript pues vete para allá, bueno,
+
+04:32.700 --> 04:38.340
+además C es el lenguaje más utilizado en
+programación de circuitos embebidos, lo que ya te
+
+04:38.340 --> 04:43.500
+hablé mucho en este curso, todo lo que son
+microcontroladores hasta arduino lo puedes programar
+
+04:43.500 --> 04:48.940
+con este lenguaje de programación C que de
+verdad es maravilloso y te va a permitir hacer cosas que
+
+04:48.940 --> 04:53.420
+no te imaginas gracias a poder trabajar
+con hardware y aquí te recomiendo el curso de
+
+04:53.420 --> 04:59.140
+microcontroladores con C. Por último C es
+muy rápido en tiempo de ejecución, si de verdad tienes
+
+04:59.140 --> 05:05.020
+que hacer algo en donde el tiempo es
+crucial entonces deberías irte por el lenguaje C,
+
+05:05.020 --> 05:30.020
+no hay de otra, con esto dicho nos vemos
+en la próxima clase.
+

01-Introducción al lenguaje C/04-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://platzi.com/clases/singlepage-app/

01-Introducción al lenguaje C/05-Configuración de Entorno para Programar en C en Windows.mp4

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

01-Introducción al lenguaje C/05-Configuración de Entorno para Programar en C en Windows.vtt

@@ -0,0 +1,374 @@
+WEBVTT
+
+00:00.000 --> 00:08.440
+Hola, en esta clase vamos a preparar
+nuestro entorno de trabajo para poder programar C,
+
+00:08.440 --> 00:12.360
+para poder ejecutar nuestro código. Ya sabes,
+tenemos que escribirlo,
+
+00:12.360 --> 00:17.600
+luego tendremos que compilarlo y luego
+pasaremos a ver qué nos dice nuestro código cuando se ejecute.
+
+00:17.600 --> 00:21.600
+Para esto, lo primero es que quiero que me
+acompañes a tu navegador y vayas a
+
+00:21.600 --> 00:31.520
+surforge.net slash project slash orwell
+dev c++ o dev cpp. Esta url recuerda que la verás en la
+
+00:31.520 --> 00:37.720
+plataforma en la sección de enlaces.
+Una vez estés aquí, dale al botón de download. Esto va a tener
+
+00:37.720 --> 00:44.240
+un pequeño timer para que comience la
+descarga y una vez la descarga esté arrancando, vamos a darle
+
+00:44.240 --> 00:50.760
+guardar. Es una descarga bastante ligera,
+deben de ser aproximadamente 50 megas y vamos a esperar
+
+00:50.760 --> 00:56.680
+a que termine de descargarse. Una vez se
+termine de descargar, dale clic ejecuta el programa y
+
+00:56.680 --> 01:03.840
+windows te va a preguntar por permisos.
+Dale que sí. Quiero contarte que es dev c++, es una IDE
+
+01:03.840 --> 01:10.000
+integrated development environment
+ambiente de desarrollo integrado que nos va a servir para
+
+01:10.000 --> 01:17.560
+poder desarrollar todo el código en C y
+C++ que queramos. Lo desarrolla esta persona. Muchas
+
+01:17.560 --> 01:24.520
+gracias. Es gratis, portable, fast y simple.
+Es la verdad bueno y funcional. Una vez ya tengas esto
+
+01:24.520 --> 01:31.840
+listo, vamos a darle que sí en inglés.
+Esto nos va a abrir una ventana de license agreement. Es
+
+01:31.840 --> 01:37.240
+una licencia de tipo GNU, está ok.
+Básicamente es software que se está distribuyendo de forma
+
+01:37.240 --> 01:42.560
+gratuita. Recuerda tú deberías de darle a
+aceptar y aquí nos va a decir oye que quieres instalar.
+
+01:42.560 --> 01:50.640
+Bueno vamos a dejarlo todo en standard y
+vamos a proceder a instalar. Vamos a darle install.
+
+01:50.640 --> 01:57.000
+Todo listo, no modifiques nada y vamos a
+esperar a que termine de extraer absolutamente todo y
+
+01:57.000 --> 02:03.120
+tengamos la instalación finalizada. Una
+vez se termine no hace falta que lo ejecutemos, simplemente
+
+02:03.120 --> 02:09.400
+dale clic en finish. Ahora yo voy a hacer
+la instalación un poquito más allá porque quiero
+
+02:09.400 --> 02:17.080
+que tengas facilidad de ejecutar desde la
+terminal código en windows. Para esto vas a ir a tu
+
+02:17.080 --> 02:24.120
+menú windows, vas a apretar la tecla
+windows y esto te va a abrir el menú. Quiero que ahí le busques
+
+02:24.120 --> 02:31.040
+environment variables o variables de entorno,
+variables de ambiente. Vas a darle clic y esto
+
+02:31.040 --> 02:36.080
+te va a abrir esta ventana de system
+properties. Voy a cerrar aquí el navegador para que no nos
+
+02:36.080 --> 02:41.320
+estorbe y en la ventana de system
+properties o propiedades del sistema vamos a darle clic a
+
+02:41.320 --> 02:47.840
+variables de entorno. Vas a hacer clic
+aquí y simple y sencillamente vamos a agregar nuestras
+
+02:47.840 --> 02:56.200
+variables de entorno. Vamos a darle clic
+en new y quiero que escribas el variable name va a ser
+
+02:57.120 --> 03:04.400
+devc y el variable value quiero que sea
+este que vamos a tener aquí que es la ruta en donde
+
+03:04.400 --> 03:10.080
+estamos guardando nuestro software y donde
+estamos guardando nuestro compilador. Vamos a darle ok
+
+03:10.080 --> 03:15.680
+y vamos a darle ok. Con eso ya agregamos
+una variable de entorno esto nos va a servir para
+
+03:15.680 --> 03:22.360
+que ya siempre que llamemos desde otro
+programa o querramos ejecutar un código en C ya vamos a
+
+03:22.360 --> 03:29.120
+saber a dónde debería estar llamando
+nuestro compilador. Eso es todo lo que va a pasar.
+
+03:29.120 --> 03:36.720
+Luego vamos a darle vamos a probar que se
+haya hecho de forma correcta para eso vamos a ir a
+
+03:36.720 --> 03:44.240
+cmd igual aprieta la tecla windows y
+escribe cmd te va a aparecer command prompt y este terminal
+
+03:44.240 --> 03:50.680
+que acabamos de abrir es lo que yo necesitaba.
+Para validar que se configuró correctamente
+
+03:50.680 --> 03:57.600
+nuestro compilador vamos a escribir gcc y
+me dice gcc is not recognized. ¿Por qué no lo reconoce?
+
+03:57.600 --> 04:03.080
+Bueno muy simple vamos a otra vez nuestros
+environment variables vamos a configurar la
+
+04:03.080 --> 04:10.920
+que acabamos de agregar y en variable name
+ponle gcc le damos ok y le damos ok. Muy bien cierras
+
+04:10.920 --> 04:19.440
+tu cmd lo vuelves a abrir vamos a ver
+ahora si funciona gcc luego vas a seleccionar la que dice
+
+04:19.440 --> 04:25.920
+path y le vas a dar doble clic y aquí te
+vas a asegurar de darle new y de pegar esta variable
+
+04:25.920 --> 04:31.000
+que estoy poniendo en pantalla justo así
+como la estoy poniendo a menos que tengas todo instalado
+
+04:31.000 --> 04:36.480
+en otro disco duro entonces tendrías que
+poner la dirección en donde tienes instalado dev cpp min
+
+04:36.480 --> 04:43.640
+gw pin por eso te dije que no lo cambiaras
+ok una vez la agregas simplemente le vas a dar en ok y
+
+04:43.640 --> 04:48.800
+listo yo si te das cuenta quedé con dos
+déjame borrar una no está bien que tengamos dos no hay
+
+04:48.800 --> 04:55.160
+necesidad vamos a dar ok y ok con esto ya
+cerramos todo el siguiente paso es que vuelvas a apretar la
+
+04:55.160 --> 05:01.800
+tecla windows y escribas cmd esto nos va a
+abrir nuestra terminal como decía como command prompt
+
+05:01.800 --> 05:10.160
+y vamos a escribir gcc y perfecto dice gcc
+fatal error no input files compilation terminated pero
+
+05:10.160 --> 05:15.200
+por qué pues porque no le hemos pasado
+ningún archivo en c y esto está bien no lo necesitamos
+
+05:15.200 --> 05:19.920
+aún simplemente quería verificar que en mi
+computadora se había instalado el compilador
+
+05:19.920 --> 05:27.080
+y se llama escribiendo gcc todo está en
+orden todo está maravilloso ahora lo que vamos a hacer
+
+05:27.080 --> 05:36.240
+es ir a nuestro navegador otra vez y
+descargar visual studio code visual estudio code vamos a
+
+05:36.240 --> 05:41.400
+ir a la página de microsoft directo donde
+dice download visual estudio code vamos a darle clic
+
+05:41.400 --> 05:48.680
+aquí en download for windows 10 vamos a
+descargar el instalador de 64 bits muy bien y vamos a darle
+
+05:48.680 --> 05:55.440
+clic acá no ya esto nos lo descarga
+simplemente ya estábamos en esa página vamos a esperar a que
+
+05:55.440 --> 06:00.960
+termine de descargarse esto se descargó
+súper rápido muy bien hacemos doble clic ejecutamos
+
+06:00.960 --> 06:06.080
+nuestro programa y windows nos va a decir
+oye aceptas en la licencia le voy a decir que sí por
+
+06:06.080 --> 06:11.560
+supuesto que acepto vamos a darle a todo
+todo está bien a tu pad absolutamente todo lo tienes que
+
+06:11.560 --> 06:17.920
+dejar marcado le vas a dar en install y
+vamos a esperar a que termine ojo para que termine de
+
+06:17.920 --> 06:23.600
+forma efectiva tienes que reiniciar tu
+computadora así que lo siento tendrás que hacerlo una vez
+
+06:23.600 --> 06:29.200
+termine la instalación nos vemos y
+continuamos exactamente en este instante en esta parte de
+
+06:29.200 --> 06:35.360
+la clase ahora que tenemos listo visual
+estudio code vamos a proceder a ejecutarlo busca visual
+
+06:35.360 --> 06:42.200
+estudio code o visual estudio code como le
+quieras decir no pasa nada se va a abrir esta bella ventana
+
+06:42.200 --> 06:47.600
+y es nuestro editor de código que vamos a
+estar manejando ahora per se este programa no nos permite
+
+06:47.600 --> 06:56.160
+trabajar con código c no para nada para
+eso vamos a buscar una extensión y esta extensión se va a
+
+06:56.160 --> 07:06.040
+llamar c slash c más más esto es si te das
+cuenta es directo de microsoft entonces todo perfecto
+
+07:06.040 --> 07:16.760
+instálala por favor se llama c más más
+también vamos a instalar c c más más compile and run esta
+
+07:16.760 --> 07:22.400
+es una herramienta que nos va a permitir
+hacer la compilación directamente desde aquí con al
+
+07:22.400 --> 07:34.000
+presionar f6 o f7 muy bien vamos a
+instalarlo y listo ya tenemos todo lo que necesitábamos para
+
+07:34.000 --> 07:39.680
+poder comenzar a programar ahora voy a
+cerrar esto no tenemos ningún folder abierto no tenemos
+
+07:39.680 --> 07:46.400
+ningún repositorio no te preocupes
+simplemente quiero que vayas acá a la ventana le des file y
+
+07:46.400 --> 07:52.880
+le des en new file este archivo nuevo
+presiona control s y esto te va a abrir esta ventana yo
+
+07:52.880 --> 08:01.960
+voy a ir a mi escritorio y aquí le voy a
+poner en file name le voy a poner hola hello world
+
+08:01.960 --> 08:10.520
+hello world punto c ya con esto vamos a
+saber que es un archivo de tipo c y nos va a tener el
+
+08:10.520 --> 08:17.800
+highlight de la sintaxis ahora vamos a
+escribir nuestro primer programa en c para esto vamos a
+
+08:17.800 --> 08:23.280
+poner hashtag include esta es una
+instrucción que vamos a utilizar para poder incluir librerías en
+
+08:23.280 --> 08:28.800
+nuestro código vamos a poner nuestro
+teclado en inglés es un tip que yo siempre te paso teclado
+
+08:28.800 --> 08:37.040
+en inglés es lo mejor para programar vamos
+a invocar la librería es stdio punto h estándar
+
+08:37.040 --> 08:45.280
+input output eso es lo que hace esta
+librería manejo de entradas y salidas estándares las
+
+08:45.280 --> 08:49.880
+básicas por decirlo así que quiere decir
+esto que nos va a servir para tener funciones como
+
+08:49.880 --> 08:55.680
+por ejemplo print que es una función que
+nos sirve para hacer un output a la terminal o imprimir
+
+08:55.680 --> 09:01.960
+algo en la terminal vamos a declarar
+nuestro main que es donde va a estar contenido todo nuestro
+
+09:01.960 --> 09:09.360
+código principal del programa vamos a
+abrir y cerrar llavecitas muy bien y vamos a escribir
+
+09:09.360 --> 09:16.520
+print que es la función que nos sirve para
+poder escribir algo a terminal vamos a poner hello
+
+09:16.520 --> 09:24.280
+platzi que es mi versión custom del hello
+world esto es así que punto y coma al final vamos a
+
+09:24.280 --> 09:31.760
+darle el return 0 esto retorcer o
+simplemente es la instrucción que vamos a tener para finalizar
+
+09:31.760 --> 09:38.360
+nuestro programa en c vamos a darle
+control s si te das cuenta no tenemos ningún problema nada que
+
+09:38.360 --> 09:46.400
+nos indique el editor vamos a apretar f6
+que es la extensión que descargamos y veamos lo que pasa
+
+09:46.400 --> 09:51.480
+si te das cuenta después de que apretamos
+f6 se nos abrió la terminal automáticamente dice windows
+
+09:51.480 --> 09:57.760
+power shell copyright a microsoft ok
+saludos a microsoft y dice trae de nucleus platform ok no
+
+09:57.760 --> 10:04.400
+no vamos a hacer eso de momento y vamos a
+ver qué pasa si te das cuenta nuestro programa ejecutó
+
+10:04.400 --> 10:10.160
+directamente todo lo que teníamos que
+hacer y nos dio la salida en terminal y luego se cerró
+
+10:10.160 --> 10:15.600
+maravilloso tenemos listo nuestro entorno
+de desarrollo en windows en la próxima vamos a
+
+10:15.600 --> 10:45.600
+aprender cómo hacerlo en un sistema
+linux
+

01-Introducción al lenguaje C/05-Lecturas recomendadas.txt

@@ -0,0 +1,2 @@
+https://sourceforge.net/projects/orwelldevcpp/
+https://code.visualstudio.com/

01-Introducción al lenguaje C/06-Instalación y Ejecución de Programas C en Linux.mp4

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

01-Introducción al lenguaje C/06-Instalación y Ejecución de Programas C en Linux.vtt

@@ -0,0 +1,214 @@
+WEBVTT
+
+00:00.000 --> 00:08.320
+Hola, en esta clase te voy a enseñar cómo
+instalar C en Linux. Vamos a abrir nuestra
+
+00:08.320 --> 00:16.840
+terminal. Ya la tengo aquí lista. Tengo
+Ubuntu. Si te das cuenta, aquí en la terminal simplemente
+
+00:16.840 --> 00:21.680
+tienes que empezar como administrador y la
+primera instrucción que vamos a utilizar es sudo app.
+
+00:21.680 --> 00:29.400
+Vamos a dar utilizar install y vamos a
+instalar GCC. Aquí en Linux es súper fácil, simplemente
+
+00:29.400 --> 00:30.520
+ponemos nuestro
+password
+
+00:33.120 --> 00:39.880
+y vamos a esperar a que termine. Te dice, oye,
+van a ser 115 megabytes. Pues sí, no hay problema.
+
+00:39.880 --> 00:45.840
+Esperamos a que termine. Vamos a ver qué
+nos arrojan. Todo debería de ser exitoso. Lo estamos
+
+00:45.840 --> 00:52.200
+haciendo con permisos de administrador y
+todo lo que necesitamos. Ahora, para verificar que la
+
+00:52.200 --> 01:01.280
+instalación fue correcta, vamos a escribir
+GCC y veamos qué nos indica. Esto significa que la
+
+01:01.280 --> 01:08.560
+instalación falló. Cuando esto falle en tu
+distribución de Ubuntu o Debian, lo que estés
+
+01:08.560 --> 01:14.480
+utilizando, simplemente vamos a darle
+update que nos va a actualizar todos los enlaces a donde
+
+01:14.480 --> 01:20.680
+podemos descargar información. Vamos a
+esperar a que termine. Listo y ya tenemos nuestros packages
+
+01:20.680 --> 01:27.080
+upgradeados, actualizados. Ahora sí vamos
+a proceder a instalar. Vamos a esperar a que termine. Nos
+
+01:27.080 --> 01:32.360
+vuelve a preguntar que van a ser 118 megas.
+Le volvemos a decir que sí y esperamos a que termine
+
+01:32.360 --> 01:37.560
+la instalación. Una vez se terminó de
+instalar, te recomiendo que aprietes el comando clear para
+
+01:37.560 --> 01:42.320
+que todo esté bien. Regresamos a la parte
+superior de nuestra consola y vamos a escribir el comando
+
+01:42.320 --> 01:51.120
+gcc-version. Esto nos va a decir la
+versión que tenemos instalada de GCC y todo está bien.
+
+01:51.120 --> 01:56.160
+Vemos que tenemos instalado GCC, nos dice
+que está instalado en nuestro Ubuntu, nos dice que tenemos
+
+01:56.160 --> 02:03.880
+un Ubuntu 18.04. Muy bien. Esta es
+información sobre Ubuntu, esta es la información de nuestro
+
+02:03.880 --> 02:14.200
+GCC que es la versión 7.5.0. Muy bien,
+excelente. Ahora vamos a darle y fíjate que dicen que no
+
+02:14.200 --> 02:19.240
+hay garantía, que esto es software gratis.
+A ver, esto es software gratis pero es software muy bueno que
+
+02:19.240 --> 02:24.880
+se ha desarrollado por muchos años pero de
+todos modos ellos hacen el disclaimer de que no te van
+
+02:24.880 --> 02:29.760
+a pagar nada si los demandas porque no
+programaste bien. ¿Qué ha pasado? Te voy a dejar el link a un
+
+02:29.760 --> 02:35.880
+artículo súper interesante de no programar
+bien utilizando los estándares sobre todo en código C
+
+02:35.880 --> 02:41.720
+y lo que permitió que pasara. De hecho lo
+veremos en una clase más adelante en donde hablemos de la
+
+02:41.720 --> 02:48.480
+importancia de ser muy responsables al
+momento de escribir código. Pero con esto dicho vamos a
+
+02:48.480 --> 02:53.040
+escribir nuestro primer programa. Para
+esto voy a utilizar la instrucción touch para crear un nuevo
+
+02:53.040 --> 03:00.240
+archivo y voy a crear un archivo que se
+llame hello.c. Si te das cuenta ahora presionando ls
+
+03:00.240 --> 03:06.200
+aquí aparece nuestro nuevo archivo hello.
+c así que vamos a abrirlo. Voy a abrirlo con beam el editor
+
+03:06.200 --> 03:13.040
+de código que ya trae la terminal de
+ubuntu hello.c. Esto nos abre beam, te recomiendo que presiones
+
+03:13.040 --> 03:20.320
+y para comenzar a insertar caracteres y
+vamos a escribir nuestro código que sería hashtag include
+
+03:20.320 --> 03:29.720
+le vamos a decir que incluya stdio.h es el
+mismo código que hicimos en la clase anterior para el
+
+03:29.720 --> 03:35.280
+hola mundo en windows sólo que ahora desde
+linux luego vamos a declarar nuestro main en donde va
+
+03:35.280 --> 03:41.920
+a estar toda la parte principal de nuestro
+código abrimos y cerramos y abrimos nuestras llaves
+
+03:41.920 --> 03:49.680
+cerramos nuestras llaves muy bien y aquí
+adentro de estas dos llaves va a estar el código. Este
+
+03:49.680 --> 03:57.640
+código bueno pues ya sabes vamos a
+utilizar print y en print vamos a poner hello.c
+
+03:58.560 --> 04:09.040
+cerramos nuestro print punto y coma al
+final y por último un return 0 punto y coma vamos a guardar
+
+04:09.040 --> 04:15.480
+casi presionó control s pero esto es beam
+no se guarda así así que el comando para guardar
+
+04:15.480 --> 04:22.800
+en beam es dos puntos wq no pero no lo voy
+a poner acá uy bueno aquí está bien todo sigue cerrado
+
+04:22.800 --> 04:30.520
+vamos a salir del modo de insertar presión
+escape y ahora escribe dos puntos w q y este es el comando
+
+04:30.520 --> 04:36.720
+para salvar y para salirnos del archivo
+todo bien ya logramos guardar nuestro archivo y logramos
+
+04:36.720 --> 04:45.480
+salirnos ahora tenemos que proceder a
+ejecutar nuestro código en c para esto vamos a utilizar la
+
+04:45.480 --> 04:50.360
+instrucción gcc que es lo que recién
+instalamos nuestro compilador le vamos a pasar el flag de
+
+04:50.360 --> 04:57.320
+o y el archivo que estamos compilando que
+se llama hello este es el archivo de output que vamos a
+
+04:57.320 --> 05:05.040
+tener ok por eso el flag y luego vamos a
+pasarle el archivo que va a compilar que es hello punto c
+
+05:05.040 --> 05:13.960
+vamos a darle enter y listo aquí qué es lo
+que acabamos de hacer aquí compilamos nuestro archivo
+
+05:13.960 --> 05:21.360
+de c hello punto c y lo guardamos en un
+archivo hello veamos con ls y mira que ahora aparece en
+
+05:21.360 --> 05:26.920
+verde nuestro nuevo ejecutable este es el
+archivo en donde está el código el source file el código
+
+05:26.920 --> 05:33.480
+fuente y este es el ejecutable que
+acabamos de compilar así que lo que hay que hacer es ejecutarlo
+
+05:33.480 --> 05:40.720
+como valga la redundancia vamos a poner
+punto y slash hello para ejecutar y mira que nos aparece
+
+05:40.720 --> 05:49.120
+un bellísimo hello platzi muy bien
+logramos terminar la instalación en sistemas de tipo
+
+05:49.120 --> 05:54.000
+linux ya sabes cómo te vas a manejar en la
+terminal de ahora en adelante hiciste tu primer
+
+05:54.000 --> 06:03.600
+hola mundo en la próxima clase
+comenzaremos a aprender todo sobre este lenguaje vamos para allá
+

01-Introducción al lenguaje C/06-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+http://xina.uoc.es/prestatgeries/PV00_75009_00197/mcomplement/faqcerrc.html

02-Estructura de un programa C/01-Estructura Básica de un Programa en C.mp4

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

02-Estructura de un programa C/01-Estructura Básica de un Programa en C.vtt

@@ -0,0 +1,146 @@
+WEBVTT
+
+00:00.000 --> 00:08.520
+En esta clase vamos a estudiar cómo es la
+estructura de un programa en el lenguaje C.
+
+00:08.520 --> 00:13.280
+Vamos a nuestro Visual Studio Code, si
+estás en Ubuntu igual es compatible, si estás en Mac
+
+00:13.280 --> 00:18.840
+igual es compatible, no te preocupes en
+absoluto que todo va a funcionar perfectamente y quiero
+
+00:18.840 --> 00:24.480
+platicarte justo sobre cómo es la
+estructura general de un programa en el lenguaje C.
+
+00:24.480 --> 00:31.120
+Lo primero que vamos a tener en todo
+programa en C es la zona donde incluimos nuestras librerías.
+
+00:31.120 --> 00:38.880
+Esta zona oficialmente se conoce como
+preprocessor commands, básicamente son comandos que le van a
+
+00:38.880 --> 00:45.480
+decir al compilador que incluyan estos
+archivos antes de comenzar la compilación. ¿Por qué?
+
+00:45.480 --> 00:50.480
+Porque dentro del código hacemos uso de
+una función que está en esta librería.
+
+00:50.480 --> 00:57.200
+Estos se conocen como preprocessor commands.
+Muy bien, la siguiente línea que tenemos es el
+
+00:57.200 --> 01:04.520
+comando main, esta es la función principal
+en donde la ejecución del programa comienza. Todo
+
+01:04.520 --> 01:11.760
+el código que podamos tener va a estar
+aquí adentro, dentro de mi función main. Luego quiero
+
+01:11.760 --> 01:19.360
+poner un pequeño comentario para que sepas
+cómo se usan, esto lo vamos a poner con barra y asterisco,
+
+01:19.360 --> 01:33.520
+adentro vamos a poner first hello world in
+C language. Muy bien y vamos a cerrar nuestro comentario.
+
+01:35.440 --> 01:41.760
+Date cuenta que el comentario se abre con
+este símbolo que se forma de barra y asterisco,
+
+01:41.760 --> 01:47.400
+luego pones lo que sea y de verdad cuando
+digo lo que sea puede ser absolutamente todo el código,
+
+01:47.400 --> 01:53.960
+por ejemplo, si quisiéramos podemos
+comentar esto, copiar nuestro print, vamos a crear una nueva línea,
+
+01:53.960 --> 01:58.680
+vamos a pegarlo, vamos a identarlo, tiene
+que estar bien ordenado, recuerda que la identación
+
+01:58.680 --> 02:04.200
+es bien importante, básicamente cada nivel
+adentro del código hay que hacerlo visual, por eso dejo
+
+02:04.200 --> 02:10.320
+esta tabulación aquí y vamos a cambiarle
+lo que dice de hello platsip for hello student.
+
+02:10.320 --> 02:18.600
+Listo, vamos a guardar y recuerda que para
+compilar tienes que apretar f6, si tienes una laptop en
+
+02:18.600 --> 02:23.400
+donde por defecto hacen otras cosas como
+subirle el volumen, subir el brillo, tienes que utilizar
+
+02:23.400 --> 02:30.480
+la tecla function f6 que es fn y f6,
+vamos a apretarlo, vamos a esperar a que termine de
+
+02:30.480 --> 02:37.960
+compilar y listo compiló y mira que ahora
+dice hello student y el compilador ignora todo
+
+02:37.960 --> 02:43.400
+lo que teníamos por acá. Muy bien, ya
+entendiste cómo funcionan los comentarios, lo siguiente que
+
+02:43.400 --> 02:48.400
+tenemos es la línea del print, si te das
+cuenta estoy haciendo un repaso de toda la estructura
+
+02:48.400 --> 02:53.920
+principal de un programa en C, esto es una
+función que está disponible en C
+
+02:53.920 --> 03:01.360
+que causa que se imprima en terminal el
+mensaje que nosotros colocamos adentro y la última línea
+
+03:01.360 --> 03:08.520
+pero no menos importante es return 0,
+esto es lo que termina mi función principal main, siempre
+
+03:08.520 --> 03:15.320
+que pongas el return 0 dentro de un main
+se va a cerrar nuestra función principal y esto va a
+
+03:15.320 --> 03:22.480
+terminar la ejecución del programa, mira
+qué pasa si pongo el return 0 antes del print, vas a ver lo
+
+03:22.480 --> 03:29.560
+que ocurre, todo se debería romper, vamos
+a guardar y vamos a compilar y ejecutar nuestro programa, ya
+
+03:29.560 --> 03:35.720
+sabes esto lo hacemos con f6 y mira que
+simple y sencillamente lo compila, lo ejecuta pero no imprime
+
+03:35.720 --> 03:42.360
+nada, porque aquí se salió el programa,
+vamos a borrar eso, guardamos y vuelve a ejecutar y
+
+03:42.360 --> 03:50.480
+vas a ver cómo ahora sí va a aparecer
+hello student, con esto dicho ya sabes compilar un programa en C,
+
+03:50.480 --> 03:56.800
+sabes ejecutar un programa en C, sabes
+todo y sabes sobre todo cómo funciona la estructura de un
+
+03:56.800 --> 04:01.880
+programa básico en lenguaje C, estamos
+listos por esta clase, nos vemos en la próxima.
+

03-Tipos de Datos en el lenguaje C/01-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://es.science19.com/what-is-e10-11567

03-Tipos de Datos en el lenguaje C/01-Tipos de Datos en C Enteros y Flotantes.mp4

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

03-Tipos de Datos en el lenguaje C/01-Tipos de Datos en C Enteros y Flotantes.vtt

@@ -0,0 +1,522 @@
+WEBVTT
+
+00:00.000 --> 00:08.560
+Hola, en esta clase vamos a aprender sobre
+los tipos de datos de C. Esto va a ser fundamental
+
+00:08.560 --> 00:15.000
+para comenzar a entender cómo funciona
+este lenguaje de programación. Recuerda que C es
+
+00:15.000 --> 00:19.920
+un lenguaje de programación tipado, es decir,
+siempre tienes que declarar de qué tipo de
+
+00:19.920 --> 00:23.960
+dato va a ser tu variable, pero no te
+preocupes, igual si es tu primer curso de programación,
+
+00:23.960 --> 00:28.320
+lo vas a entender todo paso a paso, pero
+si vienes de otro lenguaje, pues para que te vayas
+
+00:28.320 --> 00:34.320
+familiarizando con él, desde ahora. Vamos
+a mi editor de código. Tengo el archivo hello world.c,
+
+00:34.320 --> 00:39.280
+que es el archivo que ya habíamos trabajado,
+y quiero usarlo para escribirte o contarte un
+
+00:39.280 --> 00:46.200
+par de cosas aquí en mi pantalla. En C
+vamos a tener los basic types,
+
+00:48.840 --> 00:53.200
+que van a ser tipos básicos de datos en
+donde nosotros vamos a poder tener
+
+00:53.200 --> 00:59.320
+o vamos a poder almacenar información
+aritmético. Entonces aquí vamos a poder
+
+00:59.320 --> 01:05.920
+tener en los basics, nos vamos a dividir
+en tipos de datos aritméticos
+
+01:08.360 --> 01:16.160
+y tipos de datos, que lo voy a guardar con
+B aquí para que tengas la referencia, flotantes
+
+01:17.840 --> 01:19.680
+o de punto
+flotante.
+
+01:19.680 --> 01:28.520
+¿Qué es lo que se suele declarar como
+float? Y en aritméticos es lo que podríamos declarar
+
+01:28.520 --> 01:33.680
+como integer, entre otros. Vamos a tener
+diferentes tipos de integer según la cantidad
+
+01:33.680 --> 01:40.440
+de información que querramos almacenar.
+Por ejemplo, en tipo de datos aritméticos vamos
+
+01:40.440 --> 01:48.200
+a tener que van a existir integer normales,
+este es de 2 a o 4 bytes según el compilador
+
+01:48.200 --> 01:55.960
+que estés usando y esto nos permitiría
+tener un rango numérico de aproximadamente
+
+01:57.360 --> 02:11.320
+menos 32.768, si es un integer de 2 bytes,
+a 32.768 o de menos 2.147.000.000, no, esto es mucho más que
+
+02:11.320 --> 02:26.520
+2.147.483.648 hasta 2.147.000.000, etcétera,
+etcétera, en positivo. Nota como todos estos rangos numéricos
+
+02:26.520 --> 02:33.240
+cuando estamos trabajando con una variable
+simple, una variable de tipo entero, nos va desde un rango
+
+02:33.240 --> 02:38.080
+que va en números negativos hasta un rango
+en números positivos. Hay ocasiones en las que tú
+
+02:38.080 --> 02:43.280
+estás programando y no necesariamente
+necesitas los números negativos y quizás te preguntas,
+
+02:43.280 --> 02:49.320
+pero cuando voy a no necesitar eso? Primero,
+para cuando no necesitas números negativos vamos a usar
+
+02:49.320 --> 02:56.600
+la instrucción unsigned int, este es un
+tipo de datos que es sin signo, es decir, no nos permite
+
+02:56.600 --> 03:03.240
+tener números negativos, entonces el rango
+de este número, de esta variable o de este
+
+03:03.240 --> 03:16.200
+tipo de datos que estaríamos declarando,
+sería de 0 a 65.000 o de 0 a 4.294.000.000. Date cuenta que esto
+
+03:16.960 --> 03:25.280
+y esto es la misma cantidad de datos,
+va del 0 al 65.000 y aquí va de la mitad, casi, de 32.768
+
+03:25.280 --> 03:33.440
+negativo a 32.767 negativos. Son la misma
+cantidad de datos que tenemos, simplemente que aquí,
+
+03:33.440 --> 03:38.400
+cuando tenemos integer, como tenemos la
+misma cantidad de memoria, y aquí quiero que te quede
+
+03:38.400 --> 03:44.080
+claro esto, si tenemos por ejemplo,
+hablemos de integers de 2 bytes solamente, entonces quitemos
+
+03:44.080 --> 03:50.160
+esto para que sea clara la explicación y
+quitemos esto, entonces también tendríamos que quitar esta
+
+03:50.160 --> 03:58.560
+parte. ¿Qué pasa? Quiero que te quede bien
+claro el concepto, entonces tenemos que este es de 2 bytes
+
+03:58.560 --> 04:05.440
+y tenemos que este de abajo también sería
+de 2 bytes. Lo que te quiero decir aquí es que a veces
+
+04:05.440 --> 04:10.320
+vas a tener variables que van a tener
+resultados negativos, por ejemplo, imagínate que estás
+
+04:10.320 --> 04:17.140
+haciendo una operación de deudas o de
+sumas o una operación, una calculadora, estás haciendo algún
+
+04:17.140 --> 04:23.120
+tipo de programa en donde te vas a mover
+un robot de un lado izquierdo a un lado derecho y utilizas
+
+04:23.120 --> 04:26.440
+los números positivos para el lado
+izquierdo y los números negativos para el lado derecho,
+
+04:26.440 --> 04:34.480
+entonces ahí tendrías que tener un valor
+de tipo signet, o sea, int entero, que nos va a ir desde
+
+04:34.480 --> 04:39.520
+los negativos hasta los positivos. En cambio,
+si tú simplemente estuvieras trabajando con valores
+
+04:39.520 --> 04:45.360
+positivos y nunca vas a tener restas,
+entonces no necesitarías tener la capacidad de irte a
+
+04:45.360 --> 04:51.640
+números negativos porque tu programa nunca
+va a recurrir a esto. Aquí te quiero decir algo,
+
+04:51.640 --> 04:56.400
+en C siempre tienes que estar pensando
+cuáles son los valores que se van a almacenar en tus
+
+04:56.400 --> 05:02.000
+variables. Una de las mejores prácticas
+que te puedo pasar es que antes de que tú lances un
+
+05:02.000 --> 05:09.520
+código al funcionamiento, a producción,
+a un robot, a lo que sea, debes de hacer los cálculos de
+
+05:09.520 --> 05:14.760
+cuáles van a ser los rangos mínimos y
+cuáles van a ser los rangos máximos de los valores que vas a
+
+05:14.760 --> 05:20.600
+tener en tu programa. ¿Por qué? Porque de
+esto depende que sepas qué tipo de dato vas a elegir,
+
+05:20.600 --> 05:27.320
+también necesitas saber tu compilador que
+estás ocupando, cómo los hace, en qué tamaños los
+
+05:27.320 --> 05:32.480
+guarda, todo esto igual lo puedes consultar,
+no hay ningún problema, el estándar hoy en día son
+
+05:32.480 --> 05:38.800
+los mayores, entonces el estándar hoy en
+día es que un tipo int va a ser de 4 bytes, eso es ya
+
+05:38.800 --> 05:46.640
+el estándar hoy por hoy y lo que lo que
+pasa con esto es que tú tienes que siempre ser capaz de
+
+05:46.640 --> 05:52.800
+decir ok esta variable puede llegar a un
+valor de 85 millones y ese es el máximo que puede llegar,
+
+05:52.800 --> 05:59.560
+entonces ¿qué tipo de dato le asigno? Ah
+bueno pues aplica tal tipo de dato o este código puede
+
+05:59.560 --> 06:05.280
+llegar a menos 100 y quizás te preguntas y
+si no sé cuánto tú tienes que saber, en C debes de tener
+
+06:05.280 --> 06:11.920
+el control siempre ¿por qué? porque si no
+vas a permitir que haya leaks de memoria o que sea
+
+06:11.920 --> 06:17.880
+simple y sencillamente ¿qué pasaría si tú
+tienes una calculadora y el límite de tus variables es
+
+06:17.880 --> 06:28.280
+del 0 al 10? ¿qué pasaría si tú sumas 9
+más 9? 18, ya no podría guardar, no podrías almacenar más
+
+06:28.280 --> 06:33.760
+que hasta el 10, eso es lo que quiero que
+entiendas, volvamos a la pantalla, si tú estás trabajando por
+
+06:33.760 --> 06:40.400
+ejemplo con puros números positivos pero
+declaras el int así y la suma total de tus datos daba
+
+06:40.400 --> 06:46.520
+40 mil en una parte de tu programa,
+entonces ¿tú crees que podrías almacenar 42 mil en tu variable
+
+06:46.520 --> 06:53.480
+de tipo entero? no, no podrías almacenar
+40 mil, no podrías almacenar 42 mil, nada más allá de
+
+06:53.480 --> 07:03.000
+32 mil 767, es más seamos exactos no
+podrías almacenar un valor que te diera 32 mil 768 y
+
+07:03.000 --> 07:07.680
+te preguntas bueno pero un 1 ¿qué pasa
+aquí? imagínate que estás programando una aplicación
+
+07:07.680 --> 07:12.880
+de nómina, si no puedes almacenar a más de
+un valor entonces puedes dejar a gente sin su pago
+
+07:12.880 --> 07:17.120
+completo o imagínate que estás haciendo
+una aplicación que se encarga de medir distancias
+
+07:17.120 --> 07:25.920
+a través de un sensor láser y el máximo
+que tu variable puede llegar es a 128 ¿no? de menos 128
+
+07:25.920 --> 07:35.480
+a más 128 ¿qué pasaría ahí? de menos 128 a
+más 127, ponle ¿qué pasaría aquí? pues entonces si
+
+07:35.480 --> 07:41.120
+tuvieras que guardar un valor numérico de
+200 ya no cabría y la máxima distancia que estaría midiendo
+
+07:41.120 --> 07:48.240
+tu sensor sería 127 ¿y qué pasa si hay un
+cálculo importantísimo que te iba a servir ahí? bueno,
+
+07:48.240 --> 07:53.560
+¿me explico? es súper esencial que sepas
+de qué tamaño vas a estar usando tus tipos de datos,
+
+07:53.560 --> 08:00.480
+ahora continuemos aprendiendo más tipos de
+datos que hay en C, otro tipo de datos que puede ser
+
+08:00.480 --> 08:06.400
+muy común para operaciones simples va a
+ser el short, el tipo de datos short te va a servir,
+
+08:06.400 --> 08:14.160
+este si es de 2 bytes, no importa qué
+compilador estés usando está estandarizado en 2 bytes y va
+
+08:14.160 --> 08:20.720
+a llegar a esta misma distancia, déjame
+ponerlo en 4 bytes el otro para que nos vayamos con el
+
+08:20.720 --> 08:35.440
+estándar vamos a ponerle 4 bytes y vamos a
+ponerle sus valorcitos, ese es para el que va de números
+
+08:35.440 --> 08:45.000
+pues de números negativos a números
+positivos y vamos a poner la versión de 4 bytes cuando es
+
+08:45.000 --> 08:50.120
+un signet, entonces ya espero que te haya
+quedado muy claro, estoy seguro que te ha quedado muy
+
+08:50.120 --> 08:56.360
+claro cuándo debes usar un signed int y
+cuándo debes usar int, ahora vamos a ver el short, de
+
+08:56.360 --> 09:01.640
+momento todavía no vamos a entrar a punto
+flotante entonces short todavía sigue siendo aritmético,
+
+09:01.640 --> 09:07.720
+vamos a ponerlo aquí, hay que ser muy
+ordenados para que nuestro código esté claro y legible,
+
+09:07.720 --> 09:13.720
+el short todos los tipos de datos van con
+letra minúscula entonces tenemos el short listo,
+
+09:13.720 --> 09:21.680
+muy bien, obviamente existe un signet short,
+todas tienen su versión unsigned, short y la
+
+09:21.680 --> 09:32.080
+versión de unsigned short va de 0 a 65 mil,
+es de 2 bytes y va de 0 hasta 65 mil, aquí hay otro
+
+09:32.080 --> 09:43.280
+tipo de datos que vamos a poder tener para
+números enteros que va a ser long, el número long también
+
+09:43.280 --> 09:51.080
+puede ser como ya sabes del tipo normal
+que sería con signos y del tipo normal sin signos, así que
+
+09:51.080 --> 09:59.680
+podemos declarar long, long va a ser una
+variable de 8 bytes y nos va a dar estos rangos, la verdad
+
+09:59.680 --> 10:08.000
+son números que ya ni siquiera puedo leer,
+mira aquí hay 700 mil, aquí hay 854 millones, sí bueno
+
+10:08.000 --> 10:15.280
+tú te das cuenta son ya para cuando tienes
+cifras muchísimo más grandes y también tenemos unsigned
+
+10:15.280 --> 10:24.120
+long, quizás dices, bueno esta clase me la
+puedo saltar, no, esto es importantísimo en C
+
+10:24.120 --> 10:29.520
+porque todos tus programas van a depender
+de esto, ya cuando tú sabes cuál puede ser el valor máximo
+
+10:29.520 --> 10:35.640
+en tu código de los números, como tú
+tienes control de todo cuando estás programando en C, pues
+
+10:35.640 --> 10:41.400
+entonces puedes poner restricciones en tus
+cajas de texto, restricciones en tus inputs para que no
+
+10:41.400 --> 10:47.000
+aceptes números más grandes a x cantidades
+porque si no tú sabes que tu código se rompería, a eso
+
+10:47.000 --> 10:54.280
+me refiero con que todo debe de estar
+precalculado, volvamos a nuestro código y date cuenta que estos
+
+10:54.280 --> 11:01.040
+son, quiero decirte que estos son los tres
+tipos de datos que vamos a tener aritméticos, es
+
+11:01.040 --> 11:11.960
+decir que son valores íntegros, valores
+enteros, valores enteros, muy bien todo en orden, ahora
+
+11:11.960 --> 11:20.320
+veamos los tipos de datos de punto
+flotante que vamos a tener, para tipo flotante tenemos las
+
+11:20.320 --> 11:26.240
+siguientes herramientas, los siguientes
+tipos de datos, que el primero va a ser el clásico float,
+
+11:26.240 --> 11:38.080
+este es de 4 bytes y su rango es el siguiente,
+además tiene seis lugares o seis posiciones
+
+11:38.080 --> 11:45.480
+decimales, muy bien, si te das cuenta aquí
+lo estamos expresando en notación científica, si no
+
+11:45.480 --> 11:50.320
+conoces la notación científica te voy a
+dejar un enlace que te lo explica súper fácil en la sección
+
+11:50.320 --> 11:56.640
+de links, no nada, pero yo creo que ya
+deberías saberlo, vamos a tener también aquí el tipo double,
+
+11:58.640 --> 12:05.880
+double, recuerda que la notación
+científica se ocupa para escribir números muy grandes de
+
+12:05.880 --> 12:13.960
+forma legible, vamos a ir aquí, mira que
+este va a tener 308 posiciones, o sea en lo negativo el
+
+12:13.960 --> 12:20.920
+punto se recorrería 308 hacia un lado y en
+lo positivo el punto se recorrería 308 hacia el
+
+12:20.920 --> 12:28.360
+otro lado para darnos una cantidad
+astronómica tal como la tenemos aquí arriba, ahora aquí
+
+12:28.360 --> 12:34.320
+por qué los números no son como estos que
+son tan grandes, porque aquí tenemos las posiciones
+
+12:34.320 --> 12:43.640
+decimales, 15 decimal places, qué
+significa 6 decimal places, 15 decimal places, que aquí vas a
+
+12:43.640 --> 12:49.880
+poder tener 15 datos después del punto,
+aquí vas a poder tener 6, si te das cuenta la precisión
+
+12:49.880 --> 12:58.880
+aquí es gigantesca y por último vamos a
+tener long double y si te das cuenta estos valores no
+
+12:58.880 --> 13:09.280
+pueden ser un SIN, simplemente los tienen
+en SIN y ya, y este es de 10 bytes y los valores que puede
+
+13:09.280 --> 13:20.680
+tener son los siguientes y este tiene 19
+posiciones decimales, es decir nos permite tener 19 valores
+
+13:20.680 --> 13:27.920
+después del punto, es muy importante que
+en estas variables tengas la claridad de cuántos puntos
+
+13:27.920 --> 13:33.200
+decimales necesitas y aquí te voy a pasar
+un tip súper rápido, si tú estás trabajando cuestiones
+
+13:33.200 --> 13:38.560
+financieras pues obviamente no te va a
+servir 6 puntos decimales, deberías tener más quizás,
+
+13:38.560 --> 13:48.880
+por qué? quizás dices pero no tengo,
+o sea con 6 ya puedo tener punto 263 521 centavos, claro pero
+
+13:48.880 --> 13:57.480
+si te faltaron 5 o 6 dígitos después para
+que tengas el número exacto, qué pasa cuando sumas
+
+13:57.480 --> 14:04.320
+unas 100.000 veces esos datos que estaban
+faltando la información, sin duda el número final te va a
+
+14:04.320 --> 14:09.760
+fallar, por eso es que ellos pensaron
+cuando se desarrolló este lenguaje o en general en muchos
+
+14:09.760 --> 14:17.240
+lenguajes en que tú seas capaz de tener el
+control de cuánto o qué información vas a poder guardar,
+
+14:17.240 --> 14:23.600
+qué pasa con más valores o qué pasa si yo
+pongo más puntos decimales simplemente no los guardaría,
+
+14:23.600 --> 14:29.120
+así que tienes que tener mucho cuidado con
+eso porque si no usas el correcto estarías simple y
+
+14:29.120 --> 14:34.440
+sencillamente perdiendo información,
+pero si simplemente usas long double en todo entonces
+
+14:34.440 --> 14:41.040
+estarías desperdiciando memoria, por eso
+te digo en C tienes que aprender a calcular lo que vas a
+
+14:41.040 --> 14:51.440
+utilizar. Con esto terminamos los tipos de
+datos aritméticos, que es una forma fancy de decir
+
+14:51.440 --> 14:58.000
+números o de tipos de datos numéricos pero
+es la correcta y los tipos aritméticos se dividen en dos
+
+14:58.000 --> 15:05.600
+en valores enteros que vamos a tener y en
+valores de punto flotante, el primero siendo float y double
+
+15:05.600 --> 15:12.240
+y long double en respecto a los puntos
+flotantes y valores enteros siendo int, short, long, los tres
+
+15:12.240 --> 15:17.920
+con sus versiones unsigned. En la próxima
+clase aprenderás cómo puedes usar estos tipos de datos
+
+15:17.920 --> 15:28.160
+declarando variables y qué deberías
+almacenar en cada una de ellas. Nos vemos allá.
+

03-Tipos de Datos en el lenguaje C/02-Uso del Tipo de Dato Void en Programación en C.mp4

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

03-Tipos de Datos en el lenguaje C/02-Uso del Tipo de Dato Void en Programación en C.vtt

@@ -0,0 +1,242 @@
+WEBVTT
+
+00:00.000 --> 00:08.280
+En esta clase vas a aprender sobre otro
+tipo de datos que es esencial en el lenguaje de
+
+00:08.280 --> 00:13.640
+programación en C. Si bien los más
+populares que vas a estar manejando son los aritméticos,
+
+00:13.640 --> 00:18.720
+ya sea con valores flotantes o con valores
+enteros, igual vas a necesitar este nuevo
+
+00:18.720 --> 00:23.680
+tipo de datos y los próximos que veremos.
+Todos son igual de importantes, solo que en
+
+00:23.680 --> 00:31.240
+programación muchas veces lo que más
+utilizamos son números. Vamos a nuestro editor de código,
+
+00:32.280 --> 00:39.080
+vamos a escribir acá el tipo de dato nuevo
+que te quiero mostrar. Este tipo de dato nuevo que te
+
+00:39.080 --> 00:46.480
+quiero mostrar es el tipo de dato void,
+entonces vamos a escribirlo y esto lo vas a ver en muchas
+
+00:46.480 --> 00:57.720
+partes a lo largo del lenguaje C. Esto
+void lo que hace es que especifica que no hay valor
+
+00:57.720 --> 01:10.880
+disponible. Eso es lo que nos va a
+especificar y se usa en tres escenarios, por decirlo así.
+
+01:10.880 --> 01:34.560
+Bueno, el primero es que una función
+retorna un tipo de datos void. ¿Qué quiere decir esto? Que
+
+01:34.560 --> 01:42.800
+una función cuando la ejecutes no nos va a
+retornar ningún valor. Por ejemplo, una función como la que
+
+01:42.800 --> 01:49.840
+vemos acá en el main nos da un return 0.
+Esta función es del tipo entero porque nos retorna
+
+01:49.840 --> 01:57.120
+un valor de 0. Si tú le pusieras esta
+función void entonces no retornaría ningún valor y se
+
+01:57.120 --> 02:02.560
+rompería todo nuestro código en C. Esta
+función no puede ser de tipo void porque entonces cuando
+
+02:02.560 --> 02:08.200
+nos está retornando este 0 se no detecta
+que el main retorna 0 y eso va a hacer que el programa
+
+02:08.200 --> 02:12.760
+pues no se cerraría, simplemente el
+compilador puede que no te lo deje hacer, son muchas cosas.
+
+02:12.760 --> 02:18.840
+Por eso esta función main que es de tipo
+entero, que ahora ya sabes qué onda, nos retorna el valor
+
+02:18.840 --> 02:32.080
+0. Una función que se declara de la
+siguiente manera void function, esta sería una función
+
+02:32.080 --> 02:37.760
+que no nos va a retornar ningún valor y
+quizás te preguntas ¿para qué voy a querer utilizar una
+
+02:37.760 --> 02:42.040
+función que no nos va a retornar ningún
+valor? Primero veremos funciones más adelante en el
+
+02:42.040 --> 02:47.400
+curso pero te doy el pequeño spoiler y es
+que muchas veces vas a querer configurar variables
+
+02:47.400 --> 02:52.720
+adentro de tu función, cambiar valores,
+pero no necesariamente vas a querer que la función te
+
+02:52.720 --> 02:58.640
+regrese un resultado de una operación
+aritmética o te regrese alguna expresión en caracteres,
+
+02:58.640 --> 03:04.400
+no vas a querer nada, entonces ahí le
+tendrías que poner void para que el programa no espere
+
+03:04.400 --> 03:10.480
+que la función retorne algún tipo de salida.
+Las funciones pueden ser de todo tipo, char,
+
+03:10.480 --> 03:15.120
+las funciones pueden ser float, con todos
+los tipos de datos que hemos aprendido a usar pero
+
+03:15.120 --> 03:21.080
+eso lo veremos más adelante, solo quiero
+que te quede claro que void uno de sus usos es ese.
+
+03:21.080 --> 03:30.200
+Vamos a dejar aquí unos espacios con
+nuestro tabulador, vamos a poner el punto 2,
+
+03:30.200 --> 03:44.960
+function tiene argumentos de tipo void.
+Bueno esto es otro caso de uso, van a existir funciones
+
+03:44.960 --> 03:50.640
+que no aceptan ningún parámetro, una
+función que no acepta ningún parámetro va a ser una
+
+03:50.640 --> 03:58.520
+función que debe de tener void adentro,
+por ejemplo imagínate que declaramos una función
+
+03:58.520 --> 04:04.520
+para que nos dé un valor random, se puede
+utilizar el void ahí, entonces esta función que estoy
+
+04:04.520 --> 04:11.640
+declarando random no necesita ningún
+número como argumento, los argumentos de la función van a ir
+
+04:11.640 --> 04:17.880
+aquí adentro, y mira que esta función si
+nos va a retornar un valor en la salida, porque se puede
+
+04:17.880 --> 04:24.440
+declarar del tipo void. Vamos a poner de
+los ejemplos acá, solo quiero que tengas bien claro
+
+04:24.440 --> 04:37.320
+este tipo de dato que es void, void función,
+una función del tipo int que va a tener void,
+
+04:37.320 --> 04:42.440
+y mira que los tipos de datos también se
+ocupan en funciones, se ocupan en variables y en eso,
+
+04:42.440 --> 04:54.600
+vamos a tener el caso de uso número 3,
+puntero o apuntador, puntero o apuntador que va a la dirección
+
+04:56.000 --> 05:07.080
+en memoria de un objeto en la memoria
+física de tu computadora, pero no le importa el tipo de objeto
+
+05:07.080 --> 05:19.680
+que tenga, el tipo de dato que tenga, ok,
+what does this mean? qué significa esto? lo que pasa en el
+
+05:19.680 --> 05:26.360
+tercer caso es que tú puedes apuntar a una
+dirección de memoria para obtener un dato pero no necesariamente
+
+05:26.360 --> 05:32.880
+vas a ser capaz de que te diga cuál va a
+ser el tipo de datos que vas a estar trabajando, qué
+
+05:32.880 --> 05:38.200
+significa esto? bueno cuando estás
+trabajando con memoria las cosas se ponen complicadas pero no te
+
+05:38.200 --> 05:42.720
+preocupes que más adelante tenemos una
+clase bien buena que te va a explicar todo lo de los punteros,
+
+05:42.720 --> 05:49.800
+mientras tanto te cuento, tú en C puedes
+acceder directo a la memoria a través de apuntar a una
+
+05:49.800 --> 05:55.560
+dirección específica, si tú le pones void,
+si le pones que el puntero sea un dato como void,
+
+05:55.560 --> 06:02.160
+entonces no te va a importar el tipo de
+datos que tenga eso que tú estás manejando en la memoria,
+
+06:02.160 --> 06:09.080
+y esto te va a permitir hacer un casteo de
+este dato a cualquier tipo de datos, un casteo es
+
+06:09.080 --> 06:15.720
+agarrar una información y pasarla o
+transformarla a otro a un tipo de datos específico, los casteos
+
+06:15.720 --> 06:21.240
+son bien importantes porque a veces
+necesitas castear de números enteros a números flotantes
+
+06:21.240 --> 06:26.400
+ya que si no pues cómo vas a hacer la suma,
+qué deberías esperar al final, idealmente deberías
+
+06:26.400 --> 06:32.560
+de si quieres si estás trabajando con
+datos flotantes y por alguna razón había un número
+
+06:32.560 --> 06:36.880
+entero, bueno primero idealmente hubieras
+declarado todo como flotante pero si no tú
+
+06:36.880 --> 06:43.120
+puedes hacer un casteo para convertir tu
+número entero a un número de tipo flotante, existen
+
+06:43.120 --> 06:48.640
+varios casteos en C por defecto y también
+tú puedes programar casteos si quisieras a través
+
+06:48.640 --> 06:53.880
+de pues el código que se te permite escribir,
+con esto dicho ya hemos estudiado el tipo de
+
+06:53.880 --> 06:58.800
+dato void y espero que te quede claro,
+puede ser un poco confuso porque es avanzado pero si tienes
+
+06:58.800 --> 07:03.680
+dudas no te preocupes una vez vayamos
+viendo funciones, una vez vayamos viendo punteros,
+
+07:03.680 --> 07:08.120
+todo esto que acabas de aprender aquí va a
+ser todavía mucho más click pero mientras
+
+07:08.120 --> 07:26.520
+nos vemos en la siguiente
+clase.
+

03-Tipos de Datos en el lenguaje C/03-Enums en C Uso y Ejemplos Prácticos para Constantes.mp4

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

03-Tipos de Datos en el lenguaje C/03-Enums en C Uso y Ejemplos Prácticos para Constantes.vtt

@@ -0,0 +1,498 @@
+WEBVTT
+
+00:00.000 --> 00:09.200
+En esta clase vas a aprender sobre los
+enums o enumerations en el lenguaje C. Esto es una
+
+00:09.200 --> 00:14.760
+especie de lista, es un tipo de datos que
+nos va a servir para guardar valores constantes.
+
+00:14.760 --> 00:20.320
+¿Cómo así? Vamos a Visual Studio Code.
+Lo primero que voy a hacer es guardar todo lo
+
+00:20.320 --> 00:25.560
+que había escrito en la clase anterior y
+voy a ir a File, voy a crear un new file y lo voy
+
+00:25.560 --> 00:35.640
+a guardar como enums.c. Básico. Espero que
+hagas lo mismo y me acompañes a lo largo de esta clase.
+
+00:35.640 --> 00:41.040
+Veamos un ejemplo directo en código para
+que nos vaya quedando claro. Una de las grandes formas
+
+00:41.040 --> 00:47.440
+de explicar los enums, imagínate que tú
+tienes un caso de uso en donde vas a tener datos constantes
+
+00:47.440 --> 00:52.840
+que vas a necesitar en tu programa y que
+van a pertenecer a un mismo grupo de datos. Por ejemplo,
+
+00:52.840 --> 00:59.920
+los días de la semana de lunes a domingo.
+Eso quedaría perfecto en un enum porque puedes
+
+00:59.920 --> 01:05.360
+guardar los días lunes, martes, miércoles,
+jueves, viernes, sábado y domingo y entonces puedes crear
+
+01:05.360 --> 01:11.680
+tu enum que se llame semana. Tienes tus
+valores constantes que son los días de la semana adentro
+
+01:11.680 --> 01:17.360
+de un enum que contiene toda la semana.
+Esta es la lógica que debes usar cuando tengas que
+
+01:17.360 --> 01:23.480
+tomar la decisión si deberías usar un enum
+o no. Otro caso de un enum sería para quizás estás
+
+01:23.480 --> 01:30.360
+pensando un juego y vas a declarar que tal
+tipo de carta tiene tal tipo de ataque. Por ejemplo,
+
+01:30.360 --> 01:36.480
+entonces puedes crear un enum en donde
+crees la carta mazos, la carta espadas, la carta copas,
+
+01:36.480 --> 01:41.920
+la carta no sé cuál es la otra carta en la
+franja española pero tú me entiendes y a cada uno de
+
+01:41.920 --> 01:47.600
+estos tipos de carta le asignas un peso
+entonces tendrías todas las cartas guardadas en una
+
+01:47.600 --> 01:53.800
+variable que se llame dec o monte de cartas.
+Ese es otro ejemplo. Puedes pensar en tus propios
+
+01:53.800 --> 02:00.800
+ejemplos y me los puedes dejar en la
+sección de comentarios. Solo quiero comentarte que los enums,
+
+02:00.800 --> 02:07.600
+los valores o las variables dentro de un
+enum sólo pueden tener un valor. Entonces los enums
+
+02:07.600 --> 02:12.920
+pueden tener constantes como sería el caso
+de uso de los días de la semana y los enums también
+
+02:12.920 --> 02:18.440
+pueden tener variables que van a ser los
+datos que van a estar cambiando. ¿Por qué deberías usar
+
+02:18.440 --> 02:22.360
+variables dentro de un enum? Porque si en
+tu juego estamos hablando del juego de cartas,
+
+02:22.360 --> 02:27.680
+vas a más adelante a hacer un balance
+entre todas las cartas para que tengan diferentes o
+
+02:27.680 --> 02:32.440
+nuevos poderes de ataque por decir algo o
+nuevos valores numéricos por decir algo, entonces
+
+02:32.440 --> 02:37.640
+simplemente vas al enum, haces los cambios
+ahí y todo tu código, toda la lógica del juego sigue
+
+02:37.640 --> 02:43.280
+igual porque las cartas siguen siendo las
+mismas. Vamos a verlo en código. Otro ejemplo que te
+
+02:43.280 --> 02:47.800
+quiero mostrar y ya quiero que entremos en
+los detalles de cómo declararíamos un enum que va
+
+02:47.800 --> 02:53.560
+a tener variables. Imagínate que estás
+haciendo un sistema en donde los elementos de diseño van
+
+02:53.560 --> 03:01.840
+a ser súper importantes entonces yo podría
+poner design elements porque obviamente debes escribir
+
+03:01.840 --> 03:05.840
+código en inglés por favor si escribes
+código en español no lo hagas por nada del mundo.
+
+03:07.360 --> 03:15.000
+Design elements, vamos a abrir nuestras
+llaves y adentro vamos a declarar nuestro enum entonces
+
+03:15.000 --> 03:23.240
+vamos a decir que por decirlo así italics
+va a ser igual a 1 para que si alguien selecciona 1
+
+03:23.240 --> 03:33.800
+se ponga en italic o para que bold sea
+igual a 2 y para que underline o strike
+
+03:38.600 --> 03:43.720
+sea igual a 3 entonces estos son valores
+que vamos a estar definiendo en nuestro código
+
+03:43.720 --> 03:48.560
+obviamente estos números tendrían algún
+impacto en nuestra lógica más adelante ahora hagamos el
+
+03:48.560 --> 03:53.520
+ejemplo con los días de la semana pero ya
+hagámoslo con un código más completo voy a traerme aquí mi
+
+03:53.520 --> 03:59.320
+esqueleto básico de un programa en C ok
+para poder imprimir cositas voy a pegarlo en enums
+
+03:59.320 --> 04:06.600
+solamente tengo el stdio ya sabes tengo el
+main y arriba voy a declarar mi enum vamos a hacer justo
+
+04:06.600 --> 04:14.440
+eso no quiero imprimir hola mundo o ni
+hola estudiante vamos a declarar mi enum. Te acuerdas
+
+04:14.440 --> 04:18.760
+que te dije del ejemplo de los días de la
+semana veamos ese ejemplo en código cómo se podría
+
+04:18.760 --> 04:27.640
+mostrar ya sabes vamos a declarar nuestro
+enum y eso es todo ahora vamos a ponerle weekdays date
+
+04:27.640 --> 04:32.040
+cuenta que yo escribo en camel casing es
+decir siempre vas a empezar con minúscula y después
+
+04:32.040 --> 04:39.200
+cada letra va a estar en mayúscula cada
+palabra nueva va a empezar con su letra en mayúscula la
+
+04:39.200 --> 04:46.960
+primera entonces weekdays of month por
+ejemplo ese sería un caso de uso de mi camel casing que estoy
+
+04:46.960 --> 04:52.960
+teniendo pero no sólo weekdays es más que
+suficiente vamos a abrir nuestro enum vamos a
+
+04:52.960 --> 05:01.440
+crear nuestra listita sunday aquí estamos
+declarando una enumeración de valores constantes así que
+
+05:01.440 --> 05:08.800
+debes de separarlos por comas simple y
+sencillamente va a ser una vil y cruel lista una sencilla lista
+
+05:08.800 --> 05:17.400
+Tuesday, Sunday, Monday, Tuesday, Wednesday,
+tengo problemas siempre en pronunciar esa palabra a
+
+05:17.400 --> 05:25.000
+veces detalles no soy profe de inglés
+Friday y Saturday muy bien ya nos sabemos los días en
+
+05:25.000 --> 05:31.120
+inglés además de saber utilizar los enums
+luego vamos a nuestro main vamos a importar o llamar
+
+05:31.120 --> 05:38.400
+nuestro enum y vamos a decirle oye pásame
+el día de hoy week y quiero un valor que se llame
+
+05:38.400 --> 05:45.000
+today y aquí quizás te preguntas what que
+sería today bueno hay que declararlo entonces today
+
+05:47.240 --> 05:52.320
+today va a ser igual a
+Wednesday
+
+05:54.600 --> 06:02.560
+Wednesday y luego le voy a preguntar a se
+que me diga oye qué día es hoy por favor vamos a ponerle
+
+06:02.560 --> 06:09.520
+%d más adelante vamos a entrar a detalle
+en cómo son los estándares para escribir esto no te
+
+06:09.520 --> 06:17.120
+preocupes por nada entonces de ahí luego
+%d que es para darle formato a la salida quiero sacar
+
+06:17.120 --> 06:23.480
+un número decimal porque quiero saber cuál
+es el día del miércoles ok entonces va a ser today
+
+06:23.480 --> 06:30.560
+más uno y aquí quizás te preguntas por qué
+más uno por qué y esto es un concepto importantísimo
+
+06:30.560 --> 06:38.560
+en el mundo de la programación este valor
+en mi enumeración es el valor 0 mira aquí dice
+
+06:38.560 --> 06:45.840
+sunday igual a 0 es la posición 0 que
+tenemos en nuestro enum y sábado es la posición 5 pero
+
+06:45.840 --> 06:53.120
+nosotros como humanos no tenemos un día 0
+de la semana tenemos el día 1 y tenemos el día 6 de la
+
+06:53.120 --> 07:01.640
+semana sábanse lunes martes miércoles
+jueves viernes sábado domingo ok tenemos del día 1 al
+
+07:01.640 --> 07:08.360
+día 7 de la semana y en código nunca
+empieza desde el 1 en código siempre empezamos desde la posición
+
+07:08.360 --> 07:18.680
+0 así que sería posición 0 posición 1
+posición 2 posición 3 posición 4 y posición 5 y justo con
+
+07:18.680 --> 07:23.840
+esto de conteo que acabo de hacer de las
+posiciones me he dado cuenta que nos faltaba el jueves con
+
+07:23.840 --> 07:30.520
+razón aquí sólo había seis días de la
+semana muy bien tuesday justamente hoy es un día jueves de una
+
+07:30.520 --> 07:36.520
+fecha que no te voy a decir pero es
+curioso que se me haya pasado justo el jueves vamos a guardar
+
+07:36.520 --> 07:42.120
+control s ya actualizamos esto ahora sí
+todo está bien tenemos nuestros siete días sólo que va de
+
+07:42.120 --> 07:48.280
+la posición 0 a la posición 6 tal cual
+como debería ser y como es en el mundo real por eso
+
+07:48.280 --> 07:55.400
+nosotros a today le sumamos un número 1
+para que no empiece en 0 sino que empiece en 1 por ejemplo
+
+07:55.400 --> 08:05.760
+sonde vamos a guardar y vamos a correr
+nuestro código recuerda que lo corres con f6 si tienes
+
+08:05.760 --> 08:11.880
+la configuración igualita la mía y tenemos
+un error claro nos faltó un punto y coma acá muy bien
+
+08:11.880 --> 08:18.360
+y nos faltó un punto y coma acá típico de
+c es bueno que lo veas siempre siempre checa por los
+
+08:18.360 --> 08:27.800
+puntos y comas vamos a volver a ejecutar
+nuestro código ok déjame ir a la terminal y hacer no
+
+08:27.800 --> 08:36.120
+no me está dejando ok claro que no vamos a
+darle clear y vamos acá control s y vamos a volver a
+
+08:36.120 --> 08:44.280
+ejecutar nuestro código esperemos a ver y
+dice que todavía tenemos un error y mira que no sólo
+
+08:44.280 --> 08:49.600
+tenemos el problema de los puntos y comas
+lo que pasa aquí es que nos dice oye no sé de qué hablas
+
+08:49.600 --> 08:55.560
+cuál es el storage size de en un week
+today y aquí es medio deceiving si no tienes experiencia es
+
+08:55.560 --> 09:01.800
+medio confuso si no tienes experiencia
+porque porque today no es el problema el problema es
+
+09:01.800 --> 09:07.440
+que nosotros escribimos week en nuestro en
+un cuando en realidad se llama weekdays vamos a
+
+09:07.440 --> 09:13.160
+actualizar esto guardamos ejecutamos el
+código y esto que acabo de hacer yo esto que te acabo
+
+09:13.160 --> 09:20.440
+de mostrar se conoce como debugging mira
+que ya me dijo que el día sonday es el primer día de la
+
+09:20.440 --> 09:25.880
+semana hagamos un pequeño cambio sólo
+porque en realidad en nuestro sistema todo empieza en el
+
+09:25.880 --> 09:32.480
+lunes entonces vamos a poner un sonday y
+este proceso que hicimos que fue buscar los errores
+
+09:32.480 --> 09:39.880
+leer el output ver qué estaba ocurriendo
+se conoce como debugging es decir vamos a estar buscando en
+
+09:39.880 --> 09:45.320
+dónde están los errores en nuestro código
+es bien importante que siempre leas las líneas y veas qué
+
+09:45.320 --> 09:52.600
+está pasando aquí el set te lo indica pero
+siempre te va a indicar muchas veces un espacio más adelante
+
+09:52.600 --> 09:58.800
+de lo que está mal entonces en este caso
+nos decía hoy el today que pero en realidad el problema era
+
+09:58.800 --> 10:04.040
+porque week no estaba declarado bien era
+weekdays espero que te haya quedado súper claro veamos
+
+10:04.040 --> 10:09.160
+ahora qué pasa con sonde y sólo quiero que
+tengas súper claro el funcionamiento de todo esto vamos a
+
+10:09.160 --> 10:15.400
+correrlo otra vez vamos a nuestro terminal
+y listo tenemos que vamos del día 1 al día 7 ahora hagamos
+
+10:15.400 --> 10:23.320
+el ejemplo con lo que yo te decía de las
+cartas o no sé quizás enemigos en un videojuego lo que sea
+
+10:23.320 --> 10:31.240
+vamos a poder vamos a tener values en un
+proyecto real tendrías que usar nombres de variables mucho
+
+10:31.240 --> 10:37.840
+más nombres de tu genomes mucho más
+específicos de hecho le voy a poner el nombre deck de deck
+
+10:37.840 --> 10:44.240
+de cartas y le voy a poner mi y voy a
+declarar mis variables cuando estoy trabajando con cuando
+
+10:44.240 --> 10:50.400
+estás trabajando con variables siempre es
+mejor que dejes espacio acá que abras y cierres y entonces
+
+10:50.400 --> 11:00.160
+lo escribas vamos a decirle esta va a ser
+mi carta 0 coma luego vamos a tener diamantes este podría
+
+11:00.160 --> 11:09.720
+ser mi carta con un valor de 5 vamos a
+ponerle 5 coma además de diamantes si no me equivoco en los
+
+11:09.720 --> 11:17.840
+juegos de cartas hay corazones entonces
+corazones sería igual a 10 y date cuenta que cada carta va
+
+11:17.840 --> 11:26.880
+teniendo mucho mayor valor y la última
+carta que hay son espadas spades vamos a decirle que espadas
+
+11:26.880 --> 11:32.600
+sería un valor de 15 así sale una carta de
+espadas tienes 15 puntos y matas a los otros no el que
+
+11:32.600 --> 11:38.000
+tenga más puntos al final gana esa es la
+lógica detrás de este juego estamos declarando el deck
+
+11:38.000 --> 11:44.000
+y obviamente un deck va a tener cartas
+vamos a decirle vamos a pasarle el valor card
+
+11:46.800 --> 11:53.280
+y vamos a imprimir esto entonces todo lo
+que habíamos escrito ya nos sirve vamos a pasarle
+
+11:53.280 --> 11:59.640
+la relación de que nuestra carta viene de
+mí en un no nuestra carta que queremos seleccionar la
+
+11:59.640 --> 12:04.760
+primera yo quiero que sea spades aquí
+obviamente esto lo podrías hacer random más adelante con
+
+12:04.760 --> 12:09.640
+una función que aleatoriamente eligiera
+una de las cuatro posiciones dentro de tu en un
+
+12:10.640 --> 12:15.200
+vamos a ponerle eso todo listo y luego
+vamos a imprimir
+
+12:20.640 --> 12:26.880
+por ejemplo que podemos hacer con esto lo
+que te digo sacar aleatoriamente una carta podemos hacer
+
+12:26.880 --> 12:33.000
+muchas muchas cosas pero lo primero que
+quiero es que veamos qué pasa si simplemente utilizamos
+
+12:33.000 --> 12:42.320
+el código que ya tenemos cart ok vamos a
+darle safe y vamos a darle fn f6 en el caso de mi laptop
+
+12:42.320 --> 12:50.120
+en tu caso es solo f6 y mira dice de 15
+porque porque le escribimos de acá porque está esto
+
+12:50.120 --> 13:02.440
+está quemado en el código entonces cart
+value o cart power por ejemplo vamos a darle guardar
+
+13:02.440 --> 13:09.240
+y vamos a otra vez compilar el código y
+ejecutarlo vamos a ver qué sale y mira ya dice cart power
+
+13:09.240 --> 13:15.880
+igual a 15 tal como lo tenemos acá vamos a
+ver qué tanto pesa o cuál es el tamaño de mi variable
+
+13:15.880 --> 13:26.880
+vamos a escribir size of variable y la
+variable cuyo tamaño quiero es la carta pero vamos a
+
+13:26.880 --> 13:33.280
+utilizar una instrucción nueva que se
+llama size of esta es una función que va a sacarme el tamaño
+
+13:33.280 --> 13:40.680
+de la carta cerramos bien nuestros
+paréntesis vamos a guardar y al permitirnos guardar variables
+
+13:40.680 --> 13:46.520
+de tipo enteros simple y sencillamente ya
+sabes que tienes límites de la información que puedes
+
+13:46.520 --> 13:52.960
+guardar por defecto en un en un con esto
+dicho ya sabes para qué son los enums en lenguaje c la
+
+13:52.960 --> 13:58.160
+verdad es que este es un feature o una
+característica del lenguaje que yo personalmente ocupo muchísimo
+
+13:58.160 --> 14:02.760
+aquí te acabo de dar un par de ejemplos
+importantes espero que me cuentes en qué
+
+14:02.760 --> 14:23.760
+lo ocuparías tú y nos vemos en la próxima
+clase!
+

03-Tipos de Datos en el lenguaje C/04-Tipos de datos char y unsigned char en C.mp4

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

03-Tipos de Datos en el lenguaje C/04-Tipos de datos char y unsigned char en C.vtt

@@ -0,0 +1,70 @@
+WEBVTT
+
+00:00.000 --> 00:10.060
+Hay otro tipo de dato que tenemos que
+discutir en el lenguaje C y es que existe el tipo de datos
+
+00:10.060 --> 00:18.120
+char que nos va a servir para almacenar
+idealmente caracteres pero que está internamente constituido
+
+00:18.120 --> 00:25.320
+por un rango de valores igual que
+cualquier rango de los números enteros. Veamos, vamos a escribirlo
+
+00:25.320 --> 00:36.280
+aquí este sería char y también vamos a
+tener un signet char o char de carácter vamos a tener que
+
+00:36.280 --> 00:45.040
+un char va a ser de un byte nada más y
+nada menos y un signet char va a ser igual de un byte. Ahora
+
+00:45.040 --> 00:54.000
+esto va a tener un rango de menos 128 a
+127 porque es un solo byte tenemos 256 valores que podemos
+
+00:54.000 --> 01:04.520
+almacenar y vamos a ir de 0 a 255 aquí
+están los mismos 256 valores toma que toma en cuenta que 0
+
+01:04.520 --> 01:12.840
+es el valor 1 y 255 sería el valor 256
+aquí simplemente estamos podemos guardar un total de
+
+01:12.840 --> 01:23.560
+256 datos o números diferentes del 0 al
+255 porque porque es de un solo byte y el char idealmente se
+
+01:23.560 --> 01:30.280
+va a utilizar en variables que nos van a
+servir para poder almacenar un carácter. Hasta ahorita
+
+01:30.280 --> 01:35.960
+con esto ya vimos todos los tipos de datos
+que existen en el lenguaje C hay unos más que se
+
+01:35.960 --> 01:43.000
+conocen tipos de datos derivados o derived
+data types o derived types que son derivaciones o que
+
+01:43.000 --> 01:49.400
+combinan ciertos tipos de datos esenciales
+para formar estructuras más complejas eso lo veremos
+
+01:49.400 --> 01:57.360
+mucho más adelante en el curso y son
+pointer types, array types, los strokes y los union types así como
+
+01:57.360 --> 02:02.480
+los function types todo eso lo veremos te
+digo más adelante en nuestros cursos de lenguaje C
+
+02:02.480 --> 02:07.880
+no te preocupes estos que ya sabes son los
+tipos de datos esenciales y en la próxima clase
+
+02:07.880 --> 02:19.880
+comenzaremos viendo justamente cómo
+utilizarlos para crear variables con esto dicho nos vemos en la próxima!
+

04-Variables en el lenguaje C/01-Declaración y uso de variables en lenguaje C.mp4

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

04-Variables en el lenguaje C/01-Declaración y uso de variables en lenguaje C.vtt

@@ -0,0 +1,478 @@
+WEBVTT
+
+00:00.000 --> 00:09.240
+Una variable en el lenguaje C, y en
+realidad en cualquier lado, no es nada más que la definición
+
+00:09.240 --> 00:15.320
+o el nombre que le vamos a dar a un
+espacio reservado de la memoria para poder almacenar
+
+00:15.320 --> 00:21.240
+información que nosotros tengamos en
+nuestro programa. Cada variable en C va a tener un
+
+00:21.240 --> 00:26.800
+tipo específico y esos tipos son los que
+vimos en clases anteriores, los tipos de datos de los
+
+00:26.800 --> 00:33.880
+que hablamos, y esto va a determinar el
+tamaño y la estructura que estamos reservando en la memoria.
+
+00:33.880 --> 00:40.680
+Entonces recuerda, tú sabes que yendo aquí
+a mi pantalla en una variable de tipo char,
+
+00:40.680 --> 00:47.320
+pues iba a poder tener la capacidad de
+reservar un byte de memoria, que son 8 bits, 8 espacios
+
+00:47.320 --> 00:54.400
+básicos de la memoria, y va a poder
+almacenar valores de menos 128 a 127, un unsigned int va
+
+00:54.400 --> 01:02.960
+a poder almacenar valores de 0 a 4.294
+millones, etcétera, y esto es el espacio que estamos
+
+01:02.960 --> 01:09.160
+reservando y a este espacio le tenemos que
+dar una etiqueta o un nombre definitivo, un nombre
+
+01:09.160 --> 01:15.160
+que vamos a manejar en todo nuestro programa.
+Vamos al código. Vamos a declarar una serie
+
+01:15.160 --> 01:19.440
+de variables simplemente para que vayas
+viendo cómo funciona la declaración y quiero enseñarte
+
+01:19.440 --> 01:25.960
+un par de cosas. Tú puedes declarar
+variables afuera de tu main y tenerlas todas ordenadas en
+
+01:25.960 --> 01:34.920
+un archivo bastante claro, por ejemplo
+podríamos declarar que vamos a tener nuestra variable int
+
+01:34.920 --> 01:42.440
+y esta variable int puede ser un número o
+un elemento auxiliar que suelen llamarse i, j y k
+
+01:42.440 --> 01:53.480
+en el lenguaje de programación C. También
+podemos tener valores enteros como minutos estacionados,
+
+01:54.920 --> 01:59.680
+por ejemplo asumiendo que estás haciendo
+una aplicación de estacionamiento en donde tienes
+
+01:59.680 --> 02:06.800
+que llevar tracking de cuántos minutos
+estacionado lleva un auto, por ejemplo, y aquí sabrías que
+
+02:06.800 --> 02:15.920
+este auto se podría estacionar hasta 2.
+147 millones de minutos negativos, pero en un
+
+02:15.920 --> 02:21.360
+estacionamiento un auto no debería tener
+minutos negativos, ¿o sí? Pues en realidad sí, es probable
+
+02:21.360 --> 02:26.800
+que un auto pague por adelantado minutos y
+entonces esos serían minutos negativos porque no se los
+
+02:26.800 --> 02:31.600
+tendrías que sumar a una cuenta de cobro.
+¿Ves? Eso es lo que tienes que pensar cuando estás programando
+
+02:31.600 --> 02:36.680
+en C, cuál es el tipo de datos que te va a
+servir más. Igual yo sí no creo que en un auto prepague
+
+02:36.680 --> 02:46.240
+2.147 millones de minutos, pero
+definitivamente puede llegar a prepagar más de 128 minutos,
+
+02:46.240 --> 02:54.640
+que son menos de tres horas, imagínate son
+dos horas que tendría prepagadas, muy
+
+02:54.640 --> 02:59.880
+chiquito. Esto sin duda no aplicaría para
+un estacionamiento, entonces nos podríamos ir con
+
+02:59.880 --> 03:07.800
+int sin ningún problema o podrías irte con
+short, quizás si los cálculos te dan. Ahora volvamos a
+
+03:07.800 --> 03:13.400
+los tipos de variables que vamos a tener,
+recuerda que las variables siempre en lenguaje C tienen
+
+03:13.400 --> 03:20.520
+que empezar con una letra o tienen que
+empezar con underscore, es lo que tiene que pasar
+
+03:20.520 --> 03:28.160
+por definición, si tú por ejemplo empiezas
+a declarar una variable con un símbolo entonces
+
+03:28.160 --> 03:35.120
+esto no lo reconoce y mira que mi editor
+no me lo marca de color azulito, esto sería un error.
+
+03:35.120 --> 03:41.560
+Ahora aquí quiero que veas que tú puedes
+declarar varias variables de un mismo tipo y simplemente
+
+03:41.560 --> 03:47.520
+separarlas por comas, también las
+variables pueden estar inicializadas en un valor o no,
+
+03:47.520 --> 03:54.520
+por ejemplo puedo inicializar mi variable
+en minutos estacionados asumiendo que un estacionamiento de
+
+03:54.520 --> 03:59.720
+coches te cobra 30 minutos de entrada,
+no importa que te quede solamente 10 que de hecho estos
+
+03:59.720 --> 04:04.560
+comportamientos si pasan en los
+estacionamientos tienen como una tarifa mínima, entonces puedes
+
+04:04.560 --> 04:15.800
+inicializar tu variable o crear variables
+tarifa minutos mínimos, esto en inglés sería
+
+04:15.800 --> 04:24.160
+minimum minutes. Este es otro ejemplo de
+cómo les puedes dar un uso a las variables, recuerda que
+
+04:24.160 --> 04:29.080
+este es el tipo int, podemos guardar
+números negativos simplemente los escribes si tuviéramos
+
+04:29.080 --> 04:37.760
+un sinet int entonces no estaría bien que
+guardaras números de tipo negativos simplemente no puede
+
+04:37.760 --> 04:44.600
+hacerlo. Muy bien ahora vamos a quitar
+esto porque se ve feo, van a decir que el profe no sabe y eso
+
+04:44.600 --> 04:50.800
+no es cierto, vamos a continuar ya tenemos
+un int, tenemos un sinet int, ¿qué más quisieras declarar?
+
+04:50.800 --> 04:57.480
+bueno nosotros podemos declarar variables
+de tipo char, imagínate que vas a tener un carácter no
+
+04:57.480 --> 05:05.280
+sé char y y esto va a ser igual a
+efectivamente el carácter y, estos son los tipos de cosas que
+
+05:05.280 --> 05:10.240
+se pueden hacer con la variable char o
+carácter, también tú con la variable char puedes declarar
+
+05:10.240 --> 05:19.640
+números, no pasa nada te permite hacerlo
+el lenguaje c, por ejemplo f horas horas worked hours,
+
+05:19.640 --> 05:31.560
+horas trabajadas, diarias, daily, worked
+hours, esta es una variable que como el día tiene 24 horas sin
+
+05:31.560 --> 05:38.000
+duda podemos hacerla de tipo carácter
+porque porque cabe en el rango numérico que nosotros vamos a
+
+05:38.000 --> 05:44.040
+tener entonces para un día tú puedes tener
+tus horas trabajadas, puedes tener horas trabajadas
+
+05:44.040 --> 05:50.920
+negativas no, así que lo ideal sería
+hacerlo de tipo un sinet char daily worked hours y esta variable
+
+05:50.920 --> 05:56.160
+pues puedes inicializarla en cero sin
+ningún problema o dejarla como está que también estaría
+
+05:56.160 --> 06:03.520
+con un valor de cero de entrada, en
+realidad o sea siempre siempre siempre tus variables van a estar
+
+06:03.520 --> 06:08.280
+en cero si no las inicializas y si tú las
+inicializas igual está correcto, me parece que es
+
+06:08.280 --> 06:14.280
+una muy buena práctica que dejes siempre
+tus variables inicializadas excepto cuando son variables
+
+06:14.280 --> 06:20.040
+de este tipo que son simples y sencillos
+auxiliares a menos que necesites que tu auxiliar que tu número
+
+06:20.040 --> 06:24.640
+auxiliar empiece en un valor dado, más
+adelante los vamos a aprender a usar en cuestiones como
+
+06:24.640 --> 06:30.120
+control de flujo y todo eso. Con esto ya
+viste cómo se declaran las variables todas funcionan
+
+06:30.120 --> 06:35.280
+con esta misma lógica ahora quiero hacer
+unos pequeños demos de cómo las podemos utilizar y
+
+06:35.280 --> 06:40.640
+manipular en un programa en C, vamos a
+darle archivo nuevo archivo vamos a copiar nuestra
+
+06:40.640 --> 06:46.520
+estructura básica, no el archivo no se va
+a llamar así vamos a guardarlo y le voy a poner de nombre
+
+06:46.520 --> 06:56.720
+variables, variables, variables, muy bien
+punto C, todo en orden vamos a ver qué pasa primero voy a
+
+06:56.720 --> 07:03.800
+borrar todo lo que tenía declarado no lo
+necesito para este ejemplo vamos a hacerlo luego voy a
+
+07:03.800 --> 07:08.520
+dejar el print siempre es bienvenido ese
+print lo vamos a necesitar y vamos a declarar nuestras
+
+07:08.520 --> 07:17.960
+variables aquí siempre es bueno que
+empieces con un comentario variable declarations para que si
+
+07:17.960 --> 07:22.920
+alguien más lee tu código sepa que todo lo
+que va a estar aquí son declaraciones de variables,
+
+07:22.920 --> 07:28.360
+este símbolo que estamos usando es
+diferente al otro de comentarios este comentario sólo
+
+07:28.360 --> 07:33.400
+aplica para la línea actual y nada más que
+la línea actual no no es como el anterior que te
+
+07:33.400 --> 07:39.480
+había enseñado que nos va a servir para
+todo y también quiero enseñarte algo más en C existe
+
+07:39.480 --> 07:45.440
+el comando extern que te va a permitir
+declarar variables cuando las vas a ocupar en diferentes
+
+07:45.440 --> 07:52.200
+archivos a lo largo de tu código esto no
+siempre lo necesitas a menos que estés trabajando en
+
+07:52.200 --> 07:59.400
+proyectos mucho mucho más grandes y que
+estás usando múltiples archivos de C, no para nada
+
+07:59.400 --> 08:03.920
+esto lo vamos a hacer en este primer curso
+recuerda que esta es la introducción pero si más adelante
+
+08:03.920 --> 08:09.680
+en la carrera sin duda lo veremos ocurrir
+pero de todos modos tienes que saberlo desde ya porque si
+
+08:09.680 --> 08:15.680
+por alguna razón te topas con algo que
+están utilizando la directiva extern entonces ya sabes
+
+08:15.680 --> 08:20.840
+a qué se refiere es para que el compilador
+sepa que esa variable es externa y que se va a estar
+
+08:20.840 --> 08:26.720
+usando a lo largo de todo tu proyecto
+entonces ya no necesitará más información cuando esté compilando
+
+08:26.720 --> 08:33.320
+es una buena práctica nosotros no estamos
+con varios archivos y entonces no vamos a hacerlo
+
+08:33.320 --> 08:38.360
+vamos a declarar todas nuestras variables
+la primera que voy a declarar va a ser una variable
+
+08:38.360 --> 08:47.360
+de tipo entero a y una variable de tipo
+entero b punto y coma también voy a declarar una variable
+
+08:47.360 --> 08:57.680
+que se hace vamos a declarar la k mi
+variable c muy bien punto y coma y vamos a hacer lo mismo
+
+08:57.680 --> 09:08.520
+para una variable de tipo float que van a
+ser la variable f g h muy bien todo en orden tenemos a
+
+09:08.520 --> 09:15.640
+b c f g h aquí tenemos tres variables
+enteras tres variables flotantes hagamos algo con estas variables
+
+09:15.640 --> 09:21.720
+para trabajar con estas variables lo que
+yo voy a hacer simplemente es escribir un par de sumas
+
+09:21.720 --> 09:27.400
+vamos a inicializar mis variables les voy
+a dar su primer valor les voy a decir que a va a ser
+
+09:27.400 --> 09:35.760
+igual a cuánto podemos ponerle unos para
+que sea una suma bastante simple para nosotros sin ningún
+
+09:35.760 --> 09:44.240
+problema y vamos a poner b que va a ser
+igual a 34 date cuenta todo lo que estamos haciendo acá
+
+09:44.240 --> 09:50.000
+estamos declarando nuestra variable y aquí
+estamos inicializando nuestra variable quiero que por
+
+09:50.000 --> 09:55.640
+favor te aprendas estos términos porque
+son esenciales en el lenguaje variable variable
+
+09:57.000 --> 10:05.800
+inicialización inicialización muy bien
+tenemos esto hagamos una pequeña suma vamos a sumar c
+
+10:05.800 --> 10:14.800
+esto va a ser igual a más b y vamos a
+poner un bello punto y coma al final porque estamos en el
+
+10:14.800 --> 10:24.680
+lenguaje c me gusta dejar espacio por
+buena práctica luego vamos a decirle que imprima el valor de la
+
+10:24.680 --> 10:33.360
+suma es y le vamos a pasar el elemento que
+nos va a dar el formato y ya quiero que te vayas dando
+
+10:33.360 --> 10:38.920
+cuenta que hace este esta instrucción de
+por ciento de lo que hace esta instrucción de por ciento de
+
+10:38.920 --> 10:45.560
+es que aquí justo en donde yo la estoy
+colocando va a escribir la variable que yo le pase cuál va
+
+10:45.560 --> 10:50.680
+a ser la variable que yo le voy a pasar la
+variable c ahorita te va a quedar todavía más claro con el
+
+10:50.680 --> 10:56.720
+ejemplo que tengo planeado vamos a
+imprimir esto vamos a guardar y vamos a ejecutar nuestro código
+
+10:56.720 --> 11:08.440
+y mira tenemos que ejecutó el código y la
+suma es 35 todo está excelente ahora qué pasaría si yo
+
+11:08.440 --> 11:15.000
+este por ciento de por ejemplo lo pongo en
+value off mira mira mira lo que va a pasar quiero que
+
+11:15.000 --> 11:24.800
+esto te ayude a entender para qué nos
+sirve el por ciento de vamos a ejecutarlo y mira dice
+
+11:24.800 --> 11:30.520
+value 35 de la suma es porque porque aquí
+está la variable que le estamos pasando a nuestro
+
+11:30.520 --> 11:36.440
+print pero aquí está el por ciento de en
+donde tú le pongas el tipo de dato de la variable es
+
+11:36.440 --> 11:41.800
+donde lo va a imprimir vamos a colocarlo
+bien otra vez por supuesto que no queremos que esto
+
+11:41.800 --> 11:48.600
+se rompa y mira vamos a nuestro archivo de
+hello world y cuánto es el máximo valor que podemos
+
+11:48.600 --> 11:54.040
+guardar en una variable de tipo entero
+este este es el máximo valor que podemos guardar vamos a
+
+11:54.040 --> 11:59.680
+nuestro archivo de variables y vamos a
+asignarle a ve el máximo valor que puede guardar y vamos a
+
+11:59.680 --> 12:08.800
+sumarle 1 vamos a sumarle 10 para ser
+exactos vamos a darle control s vamos a darle fn fc dice
+
+12:08.800 --> 12:15.120
+en mi caso fc dicen el tuyo si no estás en
+un laptop y vamos a ver qué pasa y mira se rompió
+
+12:15.120 --> 12:23.160
+estamos sumando dos números dos números
+positivos pero él me lo manda a los negativos porque por
+
+12:23.160 --> 12:29.560
+cómo funciona adentro en c la memoria lo
+que hicimos es que nos desbordamos los espacios que
+
+12:29.560 --> 12:35.440
+teníamos reservados para valores positivos
+y algo desbordarnos los espacios para valores positivos
+
+12:35.440 --> 12:41.760
+el número se fue a los valores para
+números negativos esto es algo maravilloso de c es algo
+
+12:41.760 --> 12:46.640
+que mucha gente dice que es el uno de los
+principales problemas de este lenguaje porque si
+
+12:46.640 --> 12:51.760
+se te van las manos si se te falla algo
+con el manejo de la memoria tu problema va a crashear
+
+12:51.760 --> 12:56.080
+si tu programa crashea puede que lo dejes
+vulnerable a ataques de seguridad puede que
+
+12:56.080 --> 13:01.280
+obviamente la experiencia de usuario no
+sea ideal pero por eso te estoy enseñando con mucho detalle
+
+13:01.280 --> 13:06.720
+a pensar en qué tipo de datos vas a usar
+cuando los vas a usar tienes que pensar en todo momento
+
+13:06.720 --> 13:11.080
+las declaraciones que estás haciendo en c
+y cuáles van a ser los valores máximos que estarías
+
+13:11.080 --> 13:17.560
+haciendo en tus operaciones nos vemos en
+la próxima clase donde profundizaremos más en las variables y
+
+13:17.560 --> 13:24.560
+su
+declaración
+

04-Variables en el lenguaje C/02-Manejo de Variables Externas en C y Precisión Numérica.mp4

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

04-Variables en el lenguaje C/02-Manejo de Variables Externas en C y Precisión Numérica.vtt

@@ -0,0 +1,178 @@
+WEBVTT
+
+00:00.000 --> 00:08.400
+Hay una última cosa que te quiero enseñar
+sobre la declaración de variables y es cómo vas a
+
+00:08.400 --> 00:13.680
+manejar variables cuando estés trabajando
+con diferentes archivos. Vamos a ello. Como ya te
+
+00:13.680 --> 00:21.440
+lo había indicado en la clase pasada,
+vamos a tener nuestras variables extern, extern, de externas,
+
+00:21.440 --> 00:27.640
+nada más, nada raro por ahí, pero al
+momento de utilizarlas dentro de nuestro código no va a ser
+
+00:27.640 --> 00:36.000
+tan simple como solamente inicializarlas y ya.
+Vamos a tener que hacer una definición nueva de
+
+00:36.000 --> 00:42.040
+nuestras variables para indicar que la
+vamos a estar utilizando adentro de nuestro código. Es
+
+00:42.040 --> 00:51.720
+decir, vamos a bajar esto por acá y vamos
+a crear un nuevo comentario que diga variable y esto sería
+
+00:51.720 --> 01:04.720
+definition. Voy a decirle que voy a tener
+mis variables int, a, b y c y ya con esto el programa
+
+01:04.720 --> 01:10.720
+sabrá que estamos trabajando con estas
+variables. Es decir, aquí estamos diciendo que van a ser
+
+01:10.720 --> 01:16.000
+externas y aquí ya estamos diciendo en
+esta parte del código las voy a utilizar, no se declara
+
+01:16.000 --> 01:22.520
+doble int, ahí se me fue un typo y ya.
+Una vez haces esto simplemente puedes guardar y puedes
+
+01:22.520 --> 01:28.240
+ejecutar tu código y vas a ver que va a
+funcionar a la perfección. Ahora obviamente no hace la suma
+
+01:28.240 --> 01:35.280
+bien porque lo hicimos a propósito,
+sumémosle 0 y veamos qué ocurre. Vamos a compilar y ejecutar
+
+01:35.280 --> 01:41.640
+otra vez nuestro programa y ya
+efectivamente estamos al máximo de la capacidad de nuestra
+
+01:41.640 --> 01:47.760
+variable. Pero ahora qué pasa si superamos
+el máximo negativo al que podemos llegar? Quiero
+
+01:47.760 --> 01:54.600
+que veas ese experimento, vamos a agarrar
+todo en negativo y vamos a sumarle menos 10, control s y
+
+01:54.600 --> 02:02.200
+vamos a ejecutar este código esperando a
+que termine y mira que nada, no pasa nada, simplemente
+
+02:02.200 --> 02:08.920
+llega al valor máximo y ya llega a un
+valor que no debería llegar, se fue a un número positivo cuando
+
+02:08.920 --> 02:15.400
+debería ser negativo y los comportamientos
+son erráticos. Ahora que ya viste estos ejemplos,
+
+02:15.400 --> 02:23.120
+hagamos ejemplos con números negativos.
+Para esto vamos a utilizar g, vamos a utilizar h y el
+
+02:23.120 --> 02:32.680
+resultado de la suma de g no es h, g y f y
+el resultado de la suma de g más f lo vamos a guardar
+
+02:32.680 --> 02:39.520
+en h. Obviamente hay que cambiarlo aquí en
+donde estábamos imprimiendo el resultado y también acá
+
+02:39.520 --> 02:44.040
+porque el porciento de es para imprimir un
+número decimal, para imprimir un número flotante
+
+02:44.040 --> 02:50.560
+necesitaremos porciento f. Vamos a ver qué
+pasa con estos valores simplemente, recuerda que esta
+
+02:50.560 --> 02:56.740
+variable es de mucho mayor espacio que la
+variable de tipo entero, vamos a ver qué pasa y mira aquí
+
+02:56.740 --> 03:02.560
+parece que si logra hacer la suma y nos
+agrega seis números decimales que es la precisión que vamos a
+
+03:02.560 --> 03:20.840
+tener. Ahora sumemos 1000 positivo punto
+999 con 1 punto 1111, estamos sumando dos números de
+
+03:20.840 --> 03:30.320
+cuatro decimales. Vamos a ver qué
+resultado nos da esto y ve todo está funcionando, simplemente
+
+03:30.320 --> 03:35.920
+tenemos nuestros cinco números decimales,
+nuestros cuatro números decimales pero ahora la suma utiliza
+
+03:35.920 --> 03:42.960
+los seis números decimales que podíamos tener,
+obviamente nos da todo muy preciso, veamos qué pasa
+
+03:42.960 --> 03:53.400
+si nosotros ahora quisiéramos sumar 999999
+en la parte decimal, o sea seis números decimales,
+
+03:53.400 --> 04:05.680
+vamos a 1 2 1 2 3 4 5 6 y borramos ese
+último 1, guardamos y ejecutamos el código,
+
+04:07.200 --> 04:12.880
+vamos a esperar a que la consola la
+terminal nos arroje un resultado, si te das cuenta la suma
+
+04:12.880 --> 04:19.400
+estuvo ok, simplemente se corta a los seis
+decimales, no le va a poner más precisión aunque
+
+04:19.400 --> 04:25.720
+nosotros hiciéramos sumas de más decimales,
+no estaríamos teniendo una afectación en cuestión
+
+04:25.720 --> 04:32.280
+de que el programa lance un error, pero sí
+que tendríamos una afectación en cuestión de que
+
+04:32.280 --> 04:39.200
+estaríamos perdiendo precisión de los datos,
+entiendes? el código no te va a decir que hay un
+
+04:39.200 --> 04:44.040
+error y es que esa es la parte tricky de C,
+C no te va a decir oye todo está mal porque declaraste
+
+04:44.040 --> 04:49.680
+estas variables y se desborda y estás
+perdiendo información, C es un lenguaje que se hizo en los
+
+04:49.680 --> 04:56.760
+70s y aunque es maravilloso no tiene ese
+nivel de un sistema o algo que se esté encargando de
+
+04:56.760 --> 05:03.440
+ayudarte a manejar las variables, no eres
+tú quien se debe de ayudar y por eso quería mostrarte estos
+
+05:03.440 --> 05:09.040
+ejemplos porque C no te marca ningún error
+pero sí que estás perdiendo precisión en los datos que
+
+05:09.040 --> 05:14.320
+estás manejando, debes tenerlo en cuenta,
+nos vemos en la próxima clase en donde te enseñaré cómo
+
+05:14.320 --> 05:39.360
+trabajar con valores
+constantes.
+

04-Variables en el lenguaje C/03-Uso de Constantes y Literales en C.mp4

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

04-Variables en el lenguaje C/03-Uso de Constantes y Literales en C.vtt

@@ -0,0 +1,246 @@
+WEBVTT
+
+00:00.000 --> 00:09.000
+En esta clase vamos a aprender todo sobre
+las constantes. Las constantes son valores que no
+
+00:09.000 --> 00:13.960
+van a cambiar en tu código, a diferencia
+de las variables, que son valores que asignas
+
+00:13.960 --> 00:19.320
+espacios en la memoria de la computadora
+en la que estás ejecutando tu código y ese espacio
+
+00:19.320 --> 00:23.640
+de memoria lo puedes llenar con la
+información que tú quieras. Puedes borrar esa información,
+
+00:23.640 --> 00:29.120
+puedes cambiar esa información y siempre
+vas a tener ese espacio de memoria reservado. Eso
+
+00:29.120 --> 00:34.520
+era una variable, la constante no va a
+estar cambiando, entonces se podría decir que sí,
+
+00:34.520 --> 00:40.400
+son valores fijos, también se conocen como
+literales y son valores que no van a cambiar,
+
+00:40.400 --> 00:46.320
+pero igual vas a tener que darles un tipo
+de dato porque esto es el lenguaje C y tienes que decirle
+
+00:46.320 --> 00:52.760
+que para esta constante reserve tanto
+espacio en memoria. Estas pueden ser cualquier tipo de
+
+00:52.760 --> 00:58.480
+dato de los que ya te enseñé, puede ser
+entero, puede ser flotante, puede ser character o puede
+
+00:58.480 --> 01:05.280
+ser un string literal, que es un dato
+nuevo que ahorita vamos a ver de qué se trata. Vamos a
+
+01:05.280 --> 01:13.040
+nuestro Visual Studio Code, archivo,
+archivo nuevo y vamos a guardar este archivo nuevo con
+
+01:13.040 --> 01:24.280
+control s como mi archivo de constantes.
+Bien ya tenemos Visual Studio listo, lo primero es que
+
+01:24.280 --> 01:30.440
+voy a empezar por contarte qué es un
+string literal. En clases anteriores has visto que
+
+01:30.440 --> 01:38.080
+nosotros utilizamos la siguiente expresión
+dentro de un elemento prim, por ejemplo es de humanos
+
+01:38.080 --> 01:48.080
+errar, algo bien poético, esto sería un
+string literal, lo que nosotros podemos colocar dentro
+
+01:48.080 --> 01:54.600
+de dos comillas dobles, estas que tenemos
+aquí dentro de C, van a ser mis string literals y esto
+
+01:54.600 --> 02:02.000
+internamente se lo está almacenando como
+un array o un arreglo, es decir una estructura de datos en
+
+02:02.000 --> 02:08.920
+donde se guarda carácter a carácter
+incluyendo los espacios en blanco y por último termina con
+
+02:08.920 --> 02:17.080
+un carácter con el comando null, un
+carácter null. Esto es un string literal en C, en C no tenemos
+
+02:17.080 --> 02:22.120
+el tipo de datos string que sí existen
+otros lenguajes de programación, te dejo este tip por
+
+02:22.120 --> 02:26.680
+si este no es tu primer lenguaje de
+programación que estás intentando aprender, pero si no, si este
+
+02:26.680 --> 02:30.960
+sí es tu primer lenguaje de programación
+no te preocupes, simplemente es que hay otros lenguajes
+
+02:30.960 --> 02:36.600
+que tienen el tipo de datos string para
+almacenar cadenas de caracteres, en C si tú quisieras
+
+02:36.600 --> 02:42.400
+trabajar con cadenas de caracteres lo que
+tendrías que hacer es un array y en ese array escribir char
+
+02:42.400 --> 02:48.000
+por char lo que tú quieres guardar, así
+que ese es un lenguaje viejito hay que creerlo con sus
+
+02:48.000 --> 02:54.320
+limitantes. Vamos a continuar entonces,
+con esto dicho nosotros vamos a poder declarar constantes
+
+02:54.320 --> 03:02.760
+de tipo int, de tipo float, de tipo char,
+pero también hay que ser muy realistas y para poder
+
+03:02.760 --> 03:09.080
+declarar las que sean constantes solamente
+hay que utilizar la palabra reservada const, entonces
+
+03:09.080 --> 03:14.480
+aquí tenemos una constante entera, vamos a
+poder también tener una constante flotante para guardar
+
+03:14.480 --> 03:21.080
+números con valores flotantes y la
+constante char que se puede usar para los mismos valores numéricos
+
+03:21.080 --> 03:30.880
+que yo ya te había enseñado previamente.
+Ahora, ¿qué podemos guardar en una variable
+
+03:30.880 --> 03:36.400
+en una constante del tipo entero? Bueno,
+podemos guardar números, por ejemplo podríamos declarar
+
+03:36.400 --> 03:48.000
+que esta variable, esta constante se llame
+costo hotdog, claramente ya tengo un poquito de hambre,
+
+03:48.000 --> 03:56.880
+costo hotdog, me salió ahí la dislexia y
+el costo de hotdog lo podemos dejar definido en 100,
+
+03:56.880 --> 04:03.800
+lo podemos dejar definido en un millón,
+lo podemos dejar definido en cualquier valor que
+
+04:03.800 --> 04:09.960
+quepa dentro de nuestro entero. También
+podemos guardar, como son constantes, podemos guardar
+
+04:09.960 --> 04:16.160
+combinaciones de números y letras, por
+ejemplo un código como 100a para indicar que esto es
+
+04:16.160 --> 04:22.520
+un elemento específico, eso se podría hacer.
+También podemos crear combinaciones y podemos
+
+04:22.520 --> 04:30.360
+decirle que sea 100u, la u es un sufijo
+que nos va a servir para decir que es un signet o para
+
+04:30.360 --> 04:36.320
+decir que sea long, podemos usar el sufijo
+L para indicar long y el sufijo u para indicar un signet
+
+04:36.320 --> 04:42.400
+respectivamente. Estos sufijos pueden ser
+en mayúscula o en minúscula y no hay problema,
+
+04:42.400 --> 04:47.640
+por eso date cuenta que nos los marca bien,
+pero si yo agrego 100w no, si yo agrego 100a no,
+
+04:47.640 --> 04:53.280
+si yo agrego 100q no. Espero que te haya
+quedado claro, estoy seguro que con esto ya te queda claro
+
+04:53.280 --> 05:03.520
+cómo funcionan los enteros. También
+podemos guardar ciertas palabras que empiecen, también
+
+05:03.520 --> 05:11.520
+podemos guardar palabras dentro de esto,
+por ejemplo guardar la palabra fill, guardar la palabra doc,
+
+05:11.520 --> 05:19.120
+podemos guardar letras y podemos guardar más.
+Recuerda que aquí estamos creando constantes
+
+05:19.120 --> 05:25.280
+enteras, entonces trata de trabajar con
+números directamente, podemos crear constantes flotantes
+
+05:25.280 --> 05:35.000
+como para decir cambio, una constante en
+donde damos el cambio de un precio o algo,
+
+05:35.000 --> 05:47.760
+cambio hay que ponerlo en inglés, esto
+sería cost, y aquí sería total bill para indicar que es la
+
+05:47.760 --> 05:59.120
+cuenta total. Ahora vamos a declararla y
+esta podría ser por ejemplo 100.57, 100.58, como está
+
+05:59.120 --> 06:07.120
+en float pues no se puede más de seis
+caracteres, pero también podríamos usar los tipos de datos
+
+06:07.120 --> 06:15.680
+flotantes que tengan más caracteres
+siempre y cuando nosotros lo indiquemos. Por último podemos
+
+06:15.680 --> 06:24.080
+declarar una constante de tipo carácter,
+aquí tú podrías llamarla por ejemplo newline, o podríamos
+
+06:24.080 --> 06:33.440
+sí, salto de línea, newline, el salto de
+línea es algo que se ocupa en el lenguaje C para poder
+
+06:33.440 --> 06:39.120
+definir que todo lo que escribamos a
+partir de cierto punto se vaya a una nueva línea en la
+
+06:39.120 --> 06:44.800
+pantalla o en la terminal y es diagonal
+invertida n, así que la podemos asignar a un char para que
+
+06:44.800 --> 06:51.160
+tenga un valor como newline, esto se puede
+hacer sin ningún problema aquí y funcionaría. En esta clase
+
+06:51.160 --> 06:56.760
+ya vimos cómo funcionan las constantes,
+quiero pasarte un par de tips en tus códigos, pero eso
+
+06:56.760 --> 07:04.720
+lo haremos en la próxima clase en donde
+aprendamos a usar el preprocesador de fine, que es excelente
+
+07:04.720 --> 07:17.360
+y es una gran herramienta para programar en C.
+Nos vemos allá.
+