Upload via hfc (batch)

Uploaded using hfc tool

.gitattributes

@@ -129,3 +129,14 @@ subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/03-Bibliot
 subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/03-Bibliotecas[[:space:]]estándar[[:space:]]de[[:space:]]funciones/02-Funciones[[:space:]]matemáticas[[:space:]]básicas[[:space:]]en[[:space:]]C[[:space:]]con[[:space:]]la[[:space:]]biblioteca[[:space:]]math.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/03-Bibliotecas[[:space:]]estándar[[:space:]]de[[:space:]]funciones/03-Manejo[[:space:]]de[[:space:]]Strings[[:space:]]en[[:space:]]C[[:space:]]Funciones[[:space:]]y[[:space:]]Operaciones[[:space:]]Básicas.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/03-Bibliotecas[[:space:]]estándar[[:space:]]de[[:space:]]funciones/04-Manejo[[:space:]]de[[:space:]]tiempo[[:space:]]en[[:space:]]C[[:space:]]con[[:space:]]la[[:space:]]biblioteca[[:space:]]timeh.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/03-Bibliotecas[[:space:]]estándar[[:space:]]de[[:space:]]funciones/05-Conversión[[:space:]]de[[:space:]]Decimal[[:space:]]a[[:space:]]Binario[[:space:]]en[[:space:]]C[[:space:]]usando[[:space:]]Ciclo[[:space:]]For[[:space:]]y[[:space:]]Arrays.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/04-Cierre/01-Funciones[[:space:]]Avanzadas[[:space:]]en[[:space:]]C[[:space:]]Creación[[:space:]]y[[:space:]]Uso[[:space:]]Práctico.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/01-Introducción/01-Historia[[:space:]]y[[:space:]]evolución[[:space:]]del[[:space:]]lenguaje[[:space:]]C[[:space:]]y[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/01-Introducción/01-slides-del-curso-de-c-basico_b86bef99-5598-467a-9d40-36b44adfd1ae.pdf filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/02-Entorno[[:space:]]de[[:space:]]desarrollo/01-Proceso[[:space:]]de[[:space:]]compilación[[:space:]]en[[:space:]]C[[:space:]]paso[[:space:]]a[[:space:]]paso.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/03-Conceptos[[:space:]]básicos/01-Primer[[:space:]]Programa[[:space:]]Hola[[:space:]]Mundo[[:space:]]en[[:space:]]C[[:space:]]Estructura[[:space:]]y[[:space:]]Ejecución[[:space:]]Básica.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/03-Conceptos[[:space:]]básicos/02-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]C[[:space:]]Booleanos[[:space:]]Enteros[[:space:]]Flotantes[[:space:]]y[[:space:]]Caracteres.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/03-Conceptos[[:space:]]básicos/03-Creación[[:space:]]y[[:space:]]Uso[[:space:]]de[[:space:]]Variables[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/03-Conceptos[[:space:]]básicos/04-Constantes[[:space:]]y[[:space:]]Listas[[:space:]]en[[:space:]]C[[:space:]]Uso[[:space:]]y[[:space:]]Manipulación[[:space:]]Básica.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/03-Conceptos[[:space:]]básicos/05-Operadores[[:space:]]en[[:space:]]C[[:space:]]Aritméticos[[:space:]]Comparativos[[:space:]]y[[:space:]]Lógicos.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]C[[:space:]]Básico/03-Conceptos[[:space:]]básicos/06-Manejo[[:space:]]de[[:space:]]Entrada[[:space:]]y[[:space:]]Salida[[:space:]]de[[:space:]]Datos[[:space:]]con[[:space:]]IOStream[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text

subir/Curso de C Básico/01-Introducción/01-Historia y evolución del lenguaje C y C.mp4

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

subir/Curso de C Básico/01-Introducción/01-Historia y evolución del lenguaje C y C.vtt

@@ -0,0 +1,229 @@
+WEBVTT
+
+00:00:03.040 --> 00:00:04.880
+Bienvenido al curso de programación en C más
+
+00:00:04.880 --> 00:00:06.879
+más básico. Mi nombre es Diana Martínez y
+
+00:00:06.879 --> 00:00:08.820
+voy a ser tu profesora en este curso.
+
+00:00:09.920 --> 00:00:12.320
+Para comenzar, vamos a hablar sobre la historia
+
+00:00:12.320 --> 00:00:14.445
+de C más más, pero no podemos hablar
+
+00:00:14.445 --> 00:00:16.445
+sobre C más más sin hablar primero sobre
+
+00:00:16.445 --> 00:00:19.645
+el lenguaje de programación C. Este lenguaje de
+
+00:00:19.645 --> 00:00:22.365
+programación fue desarrollado por Dennis Richie y su
+
+00:00:22.365 --> 00:00:25.645
+equipo de investigadores en los laboratorios Bell de
+
+00:00:25.645 --> 00:00:28.880
+la AT y T Corporation, mientras desarrollaban el
+
+00:00:28.880 --> 00:00:32.400
+sistema operativo Unix. Fue necesario crear un nuevo
+
+00:00:32.400 --> 00:00:35.360
+lenguaje de programación que les permitiera desarrollar de
+
+00:00:35.360 --> 00:00:38.000
+forma mucho más sencilla su sistema operativo, ya
+
+00:00:38.000 --> 00:00:40.240
+que los lenguajes de la época, en aquel
+
+00:00:40.240 --> 00:00:43.675
+momento, no estaban pensados para tal finalidad. Cuando
+
+00:00:43.675 --> 00:00:46.255
+crearon el lenguaje de programación C, las computadoras
+
+00:00:46.555 --> 00:00:50.075
+estaban en un estado bastante primitivo. Apenas existían
+
+00:00:50.075 --> 00:00:52.635
+las computadoras electrónicas y, en muchos de los
+
+00:00:52.635 --> 00:00:54.715
+casos, ni siquiera se parecían a lo que
+
+00:00:54.715 --> 00:00:57.114
+tenemos hoy en día. Por ejemplo, como puedes
+
+00:00:57.114 --> 00:00:59.550
+ver en la fotografía, las computadoras de aquella
+
+00:00:59.550 --> 00:01:02.750
+época no necesariamente tenían un monitor para mostrar
+
+00:01:02.750 --> 00:01:04.909
+los datos de salida de los resultados de
+
+00:01:04.909 --> 00:01:08.110
+los programas. En lugar de eso, utilizaban papel
+
+00:01:08.110 --> 00:01:10.990
+y tinta para mostrar por medio de una
+
+00:01:10.990 --> 00:01:13.310
+impresora cuáles habían sido de los resultados de
+
+00:01:13.310 --> 00:01:16.555
+salida. Y de la misma manera, se utilizaba
+
+00:01:16.555 --> 00:01:19.195
+un teclado bastante primitivo, muy distinto a los
+
+00:01:19.195 --> 00:01:21.755
+teclados actuales, para realizar la entrada de datos
+
+00:01:21.755 --> 00:01:24.555
+del programa. Sin embargo, ya teníamos esos dos
+
+00:01:24.555 --> 00:01:27.034
+conceptos fundamentales de la entrada y salida de
+
+00:01:27.034 --> 00:01:30.479
+datos utilizando texto. En este caso, por medio
+
+00:01:30.479 --> 00:01:32.320
+de un teclado similar al de una máquina
+
+00:01:32.320 --> 00:01:35.760
+de escribir y una impresora que mostraba los
+
+00:01:35.760 --> 00:01:37.280
+textos de la salida del programa en el
+
+00:01:37.280 --> 00:01:42.400
+papel. Estas dos características fueron bastante importantes para
+
+00:01:42.400 --> 00:01:44.885
+la creación del lenguaje de programación C, ya
+
+00:01:44.885 --> 00:01:47.405
+que cuando se desarrolló, pues, esta era la
+
+00:01:47.405 --> 00:01:52.265
+forma principal de utilizar las computadoras. Más tarde,
+
+00:01:52.965 --> 00:01:56.405
+John Stroustrop desarrolló una nueva versión o una
+
+00:01:56.405 --> 00:01:59.500
+nueva implementación del lenguaje de programación C al
+
+00:01:59.500 --> 00:02:01.659
+que llamó C con clases, ya que le
+
+00:02:01.659 --> 00:02:05.340
+agregó la capacidad de soportar el paradigma orientado
+
+00:02:05.340 --> 00:02:09.039
+a objetos, es decir, la capacidad de generar
+
+00:02:09.500 --> 00:02:12.060
+aplicaciones con un mayor nivel de abstracción que
+
+00:02:12.060 --> 00:02:15.435
+el original del lenguaje de programación C. Para
+
+00:02:15.435 --> 00:02:17.675
+esto, pasaron algunos años antes de que él
+
+00:02:17.675 --> 00:02:19.275
+comenzara a llamar a su nuevo lenguaje de
+
+00:02:19.275 --> 00:02:22.875
+programación C más más. Es importante destacar que
+
+00:02:22.875 --> 00:02:25.915
+para cuando Jans Trotstrap comenzó a desarrollar C
+
+00:02:25.915 --> 00:02:28.040
+más más, ya habían pasado poco más de
+
+00:02:28.040 --> 00:02:31.240
+diez años y la computación había evolucionado bastante
+
+00:02:31.240 --> 00:02:34.300
+desde entonces. Por lo tanto, cuando él desarrolló,
+
+00:02:34.600 --> 00:02:37.420
+ya estaba el concepto de un sistema operativo
+
+00:02:37.480 --> 00:02:40.665
+y de desarrollar aplicaciones sobre él mismo, sin
+
+00:02:40.665 --> 00:02:43.265
+necesidad de entender cómo funcionaba por debajo la
+
+00:02:43.265 --> 00:02:45.905
+computadora a nivel de hardware. Estas son una
+
+00:02:45.905 --> 00:02:49.205
+de las mayores diferencias entre el lenguaje de
+
+00:02:49.265 --> 00:02:51.745
+programación C original y C más más. Sin
+
+00:02:51.745 --> 00:02:55.489
+embargo, muchas de las características de C son
+
+00:02:55.489 --> 00:02:57.410
+heredadas por el lenguaje de programación C más
+
+00:02:57.410 --> 00:03:00.209
+más. La mayor parte de las que veremos
+
+00:03:00.209 --> 00:03:03.090
+en este curso son compatibles con ambos. Por
+
+00:03:03.090 --> 00:03:06.129
+último, me gustaría que vieras, en comparación, cómo
+
+00:03:06.129 --> 00:03:09.895
+evoluciona la computación entre los dos lenguajes de
+
+00:03:09.895 --> 00:03:12.935
+programación. Entre los sesentas y los setentas, cuando
+
+00:03:12.935 --> 00:03:15.255
+Denis Richie y los investigadores de su equipo
+
+00:03:15.255 --> 00:03:19.255
+estuvieron investigando sobre lenguajes de programación y sobre
+
+00:03:19.255 --> 00:03:22.215
+sistemas operativos, y desarrollaron la primera versión de
+
+00:03:22.215 --> 00:03:26.070
+Unix, o los ochentas, cuando GeneStrolStrow tuvo la
+
+00:03:26.070 --> 00:03:28.790
+oportunidad de desarrollar su propia implementación de C
+
+00:03:28.790 --> 00:03:31.910
+más más. Dicho esto, te invito a nuestra
+
+00:03:31.910 --> 00:03:34.890
+siguiente clase, donde hablaremos sobre el entorno desarrollo
+
+00:03:35.030 --> 00:03:38.421
+y el proceso de compilación. Además, realizaremos la
+
+00:03:38.641 --> 00:03:41.201
+instalación de las herramientas necesarias para trabajar con
+
+00:03:41.201 --> 00:03:42.741
+estos lenguajes de programación.

subir/Curso de C Básico/01-Introducción/01-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/curso-basico-c-plus-plus

subir/Curso de C Básico/01-Introducción/01-slides-del-curso-de-c-basico_b86bef99-5598-467a-9d40-36b44adfd1ae.pdf

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

subir/Curso de C Básico/02-Entorno de desarrollo/01-Lecturas recomendadas.txt

@@ -0,0 +1,3 @@
+https://platzi.com/cursos/prework-windows/
+https://platzi.com/cursos/prework-macos/
+https://code.visualstudio.com/

subir/Curso de C Básico/02-Entorno de desarrollo/01-Proceso de compilación en C paso a paso.mp4

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

subir/Curso de C Básico/02-Entorno de desarrollo/01-Proceso de compilación en C paso a paso.vtt

@@ -0,0 +1,259 @@
+WEBVTT
+
+00:00:02.960 --> 00:00:05.040
+Vamos a hablar sobre el proceso de compilación
+
+00:00:05.040 --> 00:00:07.779
+del lenguaje C más más. Como bien sabes,
+
+00:00:08.000 --> 00:00:10.320
+el lenguaje de programación C y el lenguaje
+
+00:00:10.320 --> 00:00:12.980
+de programación C más más son lenguajes compilados,
+
+00:00:13.120 --> 00:00:15.875
+es decir, requieren de un programa compilador que
+
+00:00:15.875 --> 00:00:18.135
+convierta el código fuente que vas a escribir
+
+00:00:18.275 --> 00:00:21.155
+durante el proceso de programación y generen un
+
+00:00:21.155 --> 00:00:22.835
+archivo ejecutable, que es el que le vas
+
+00:00:22.835 --> 00:00:25.635
+a entregar a tus usuarios. El proceso de
+
+00:00:25.635 --> 00:00:29.340
+compilación es el siguiente. En primer lugar, vas
+
+00:00:29.340 --> 00:00:31.260
+a escribir el código fuente en un editor
+
+00:00:31.260 --> 00:00:33.980
+de código o IDE. Este es tu entorno
+
+00:00:33.980 --> 00:00:36.800
+de desarrollo integrado o el editor de código
+
+00:00:36.860 --> 00:00:39.660
+de tu preferencia, donde vas a escribir código
+
+00:00:39.660 --> 00:00:42.095
+en C más más. Ahí vas a generar
+
+00:00:42.095 --> 00:00:44.415
+archivos de código fuente que pueden tener la
+
+00:00:44.415 --> 00:00:47.155
+extensión punto h o la extensión punto CVP.
+
+00:00:47.455 --> 00:00:50.035
+Esto le va a indicar a tu preprocesador
+
+00:00:50.655 --> 00:00:52.415
+que estos son los archivos de código fuente
+
+00:00:52.415 --> 00:00:55.680
+que va a utilizar más adelante. El paso
+
+00:00:55.680 --> 00:00:59.440
+dos es el preprocesamiento, y aquí se ejecuta
+
+00:00:59.440 --> 00:01:02.320
+un pequeño programa conocido como el preprocesador, que
+
+00:01:02.320 --> 00:01:05.200
+se encarga de tomar los diferentes archivos de
+
+00:01:05.200 --> 00:01:08.160
+código fuente que están en texto plano, justo
+
+00:01:08.160 --> 00:01:11.755
+como tú los habías escrito, para ser utilizados
+
+00:01:12.135 --> 00:01:15.095
+por el preprocesador, de forma que este los
+
+00:01:15.095 --> 00:01:17.575
+pueda juntar en un único archivo o en
+
+00:01:17.575 --> 00:01:20.875
+los archivos necesarios para realizar los pasos posteriores.
+
+00:01:22.450 --> 00:01:25.570
+A continuación, sucedería el paso tres, que es
+
+00:01:25.570 --> 00:01:28.930
+el proceso de compilación. El compilador es el
+
+00:01:28.930 --> 00:01:30.930
+programa que realiza la mayor parte de la
+
+00:01:30.930 --> 00:01:33.890
+magia durante este proceso, y se trata de
+
+00:01:33.890 --> 00:01:35.650
+un programa que va a tomar el código
+
+00:01:35.650 --> 00:01:37.435
+fuente que tú hayas escrito y lo va
+
+00:01:37.435 --> 00:01:41.055
+a convertir en un código objeto. Este código
+
+00:01:41.515 --> 00:01:43.275
+objeto es un código que ya está mucho
+
+00:01:43.275 --> 00:01:45.775
+más cercano a lo que la máquina necesita
+
+00:01:46.075 --> 00:01:48.075
+para interpretar, es un código que ya no
+
+00:01:48.075 --> 00:01:49.915
+es legible para un ser humano de una
+
+00:01:49.915 --> 00:01:52.495
+forma sencilla, como lo es el código fuente.
+
+00:01:53.680 --> 00:01:57.920
+El paso número cuatro sería el linker. Este
+
+00:01:57.920 --> 00:02:00.159
+programa se va a encargar de juntar tu
+
+00:02:00.159 --> 00:02:03.039
+código fuente después de haber sido procesado y
+
+00:02:03.039 --> 00:02:08.095
+compilado en código objeto con las librerías o
+
+00:02:08.095 --> 00:02:11.135
+dependencias que tú hayas indicado que necesita tu
+
+00:02:11.135 --> 00:02:16.675
+programa durante el proceso de linkkeado. A continuación,
+
+00:02:16.855 --> 00:02:20.660
+ya durante la ejecución del programa, se realizaría
+
+00:02:21.200 --> 00:02:23.880
+el paso número cinco, que es la carga,
+
+00:02:23.880 --> 00:02:26.240
+y esto es realizado por el loader. El
+
+00:02:26.240 --> 00:02:29.760
+loader es un pequeño programa que arranca la
+
+00:02:29.760 --> 00:02:31.780
+ejecución de tu código en C más más
+
+00:02:31.785 --> 00:02:33.385
+y que va a importar todas aquellas librerías
+
+00:02:33.385 --> 00:02:37.645
+que tú hayas indicado que pueden ser obtenidas
+
+00:02:37.785 --> 00:02:40.685
+de forma dinámica, es decir, que no necesariamente
+
+00:02:41.465 --> 00:02:44.280
+necesitan incluirse dentro del ejecutable de tu programa,
+
+00:02:44.360 --> 00:02:46.520
+sino que pueden ya estar instaladas en el
+
+00:02:46.520 --> 00:02:49.980
+sistema operativo destino para que este pueda invocarlas,
+
+00:02:50.520 --> 00:02:53.880
+como comunicarse con otros programas y depender de
+
+00:02:53.880 --> 00:02:57.800
+ellas, pero de una forma dinámica. Y el
+
+00:02:57.800 --> 00:03:01.695
+último paso sería la ejecución. Aquí nuestro programa
+
+00:03:01.695 --> 00:03:03.455
+va a ser montado en la memoria y
+
+00:03:03.455 --> 00:03:06.755
+va a poder acceder y ejecutar sus instrucciones
+
+00:03:06.815 --> 00:03:09.535
+una tras otra en nuestra CPU, donde va
+
+00:03:09.535 --> 00:03:11.695
+a poder recibir los datos de entrada y
+
+00:03:11.695 --> 00:03:14.100
+generar los datos de salida. Ahora que ya
+
+00:03:14.100 --> 00:03:16.020
+sabes cómo es el proceso de compilación de
+
+00:03:16.020 --> 00:03:18.200
+C más más, sabes que vamos a necesitar
+
+00:03:18.340 --> 00:03:21.080
+dos herramientas principales para trabajar con este curso.
+
+00:03:21.220 --> 00:03:23.940
+La primera es nuestro editor de código. En
+
+00:03:23.940 --> 00:03:26.500
+este curso vamos a estar utilizando Visual Studio
+
+00:03:26.500 --> 00:03:29.135
+Code, que tú ya deberías tener instalado. Si
+
+00:03:29.135 --> 00:03:31.535
+no lo tienes instalado, te invito a realizar
+
+00:03:31.535 --> 00:03:33.795
+el curso de prework de Platzi, donde aprenderás
+
+00:03:34.335 --> 00:03:37.375
+todos los pasos necesarios para su instalación. La
+
+00:03:37.375 --> 00:03:41.055
+segunda será nuestro compilador. En este caso, vamos
+
+00:03:41.055 --> 00:03:44.300
+a estar utilizando la herramienta de compilación GCC,
+
+00:03:44.300 --> 00:03:47.660
+de código de código libre, que, en el
+
+00:03:47.660 --> 00:03:50.400
+caso de los sistemas operativos Linux, ya viene
+
+00:03:50.540 --> 00:03:52.380
+instalado, así que no necesitarás realizar nada más
+
+00:03:52.380 --> 00:03:55.820
+que instalar tu editor de código. Y, en
+
+00:03:55.820 --> 00:03:58.380
+el caso de los sistemas operativos Windows y
+
+00:03:58.380 --> 00:04:01.505
+Mac, te dejaremos dos lecciones en texto donde
+
+00:04:01.505 --> 00:04:04.145
+aprenderás cómo realizar la instalación para tu sistema
+
+00:04:04.145 --> 00:04:07.505
+operativo. Te invito a la siguiente clase, donde
+
+00:04:07.505 --> 00:04:10.565
+por primera vez comenzaremos a realizar nuestro código
+
+00:04:11.185 --> 00:04:12.325
+con C más más.

subir/Curso de C Básico/03-Conceptos básicos/01-Lecturas recomendadas.txt

@@ -0,0 +1,3 @@
+https://github.com/platzi/curso-basico-c-plus-plus/tree/estructura-base
+https://marketplace.visualstudio.com/items?itemName=danielpinto8zz6.c-cpp-compile-run
+https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools

subir/Curso de C Básico/03-Conceptos básicos/01-Primer Programa Hola Mundo en C Estructura y Ejecución Básica.mp4

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

subir/Curso de C Básico/03-Conceptos básicos/01-Primer Programa Hola Mundo en C Estructura y Ejecución Básica.vtt

@@ -0,0 +1,355 @@
+WEBVTT
+
+00:00:03.199 --> 00:00:05.600
+Por fin, vamos a realizar nuestro primer ejemplo
+
+00:00:05.600 --> 00:00:08.639
+de código en este curso. Vamos a hablar
+
+00:00:08.639 --> 00:00:11.219
+sobre nuestro hola mundo y la estructura básica
+
+00:00:11.280 --> 00:00:13.674
+de un programa en C más más. Ahora
+
+00:00:13.674 --> 00:00:15.514
+que ya estamos en nuestro editor de código,
+
+00:00:15.514 --> 00:00:18.154
+voy a crear un archivo donde voy a
+
+00:00:18.154 --> 00:00:21.775
+generar todo el código fuente de mi programa
+
+00:00:21.835 --> 00:00:24.395
+de Hola Mundo. Este archivo lo voy a
+
+00:00:24.395 --> 00:00:26.154
+guardar en una carpeta que yo ya creé
+
+00:00:26.154 --> 00:00:28.410
+para las clases. Tú lo puedes crear en
+
+00:00:28.410 --> 00:00:32.409
+cualquier carpeta limpia que tú necesites trabajar de
+
+00:00:32.409 --> 00:00:34.270
+la forma en que te convenga más organizarlo.
+
+00:00:34.730 --> 00:00:36.750
+Vamos a dejarte el código en unos repositorios
+
+00:00:37.050 --> 00:00:39.550
+de Github para que puedas tenerlo de referencia.
+
+00:00:41.505 --> 00:00:44.045
+En este caso, vamos a comenzar a programar
+
+00:00:44.065 --> 00:00:48.145
+nuestro archivo llamado, siempre con una extensión punto
+
+00:00:48.145 --> 00:00:50.545
+CPP. Yo le voy a poner main punto
+
+00:00:50.545 --> 00:00:52.945
+CPP para mantener ese estándar a lo largo
+
+00:00:52.945 --> 00:00:56.690
+de todos los ejemplos de este curso. Por
+
+00:00:56.690 --> 00:00:58.530
+lo tanto, aquí en esta carpeta voy a
+
+00:00:58.530 --> 00:01:00.449
+empezar a escribir el nombre del archivo main
+
+00:01:00.449 --> 00:01:05.170
+punto CPY ahora sí, ya tengo creado mi
+
+00:01:05.170 --> 00:01:07.509
+archivo de código fuente de c más más.
+
+00:01:09.174 --> 00:01:11.354
+Con esto puedo comenzar a escribir el código
+
+00:01:11.735 --> 00:01:15.515
+que necesite para realizar mi programa. Por ejemplo,
+
+00:01:15.814 --> 00:01:20.314
+voy a realizar esta instrucción que se conoce
+
+00:01:20.615 --> 00:01:22.650
+como include, que lo que me permite es
+
+00:01:22.650 --> 00:01:26.170
+incluir o importar una librería de código que
+
+00:01:26.170 --> 00:01:29.450
+contiene funcionalidades necesarias que yo pueda llegar a
+
+00:01:29.450 --> 00:01:32.250
+utilizar. Por ejemplo, voy a utilizar una que
+
+00:01:32.250 --> 00:01:36.535
+se llama iostream. Esta librería me permite obtener
+
+00:01:36.535 --> 00:01:39.015
+datos de entrada del programa o mostrar datos
+
+00:01:39.015 --> 00:01:40.935
+de salida por medio de la terminal de
+
+00:01:40.935 --> 00:01:45.195
+comandos, y eso va a ser posible también
+
+00:01:45.495 --> 00:01:47.495
+gracias a otra línea de código que siempre
+
+00:01:47.495 --> 00:01:50.340
+vamos a poner en nuestros programas, ya veremos
+
+00:01:50.340 --> 00:01:56.039
+después por qué, que se llama usync namespace
+
+00:01:57.860 --> 00:02:02.439
+std. Esta línea lo que hace es permitirnos
+
+00:02:02.659 --> 00:02:04.740
+utilizar el espacio de nombres estándar de C
+
+00:02:04.740 --> 00:02:07.175
+más más, es decir, todas esas cosas que
+
+00:02:07.175 --> 00:02:09.175
+tienen un nombre dentro de nuestro programa, que
+
+00:02:09.175 --> 00:02:13.415
+pueden ser piezas de código reutilizables para poder
+
+00:02:13.415 --> 00:02:16.455
+importarlas sin necesidad de escribir desde dónde las
+
+00:02:16.455 --> 00:02:20.120
+estamos importando y aún así poder utilizarlas. Por
+
+00:02:20.660 --> 00:02:25.220
+ejemplo, vamos a crear un código que es
+
+00:02:25.220 --> 00:02:29.000
+esta estructura básica, que es la estructura básica
+
+00:02:29.300 --> 00:02:31.300
+de cualquier programa en C más más, siempre
+
+00:02:31.300 --> 00:02:33.075
+que queremos un programa en C más más
+
+00:02:33.155 --> 00:02:34.995
+o en el lenguaje de programación C, vamos
+
+00:02:34.995 --> 00:02:36.834
+a tener que escribir esta línea de código
+
+00:02:36.834 --> 00:02:38.754
+que aparece aquí en la línea cinco de
+
+00:02:38.754 --> 00:02:42.355
+nuestro editor, que es la función main. Más
+
+00:02:42.355 --> 00:02:44.355
+adelante vamos a hablar sobre las funciones y
+
+00:02:44.355 --> 00:02:46.680
+sobre por qué tienen esta estructura, pero, de
+
+00:02:46.680 --> 00:02:49.580
+momento, me gustaría que sepas que todos los
+
+00:02:49.720 --> 00:02:52.680
+programas comienzan por donde esté la función main,
+
+00:02:52.680 --> 00:02:55.720
+es decir, si queremos arrancar un programa de
+
+00:02:55.720 --> 00:02:57.640
+editor de video o un programa de editor
+
+00:02:57.640 --> 00:03:00.225
+de audio, cualquier tipo de programa que que
+
+00:03:00.765 --> 00:03:03.005
+realicemos en C más más siempre lo que
+
+00:03:03.005 --> 00:03:05.165
+coloquemos dentro de la función main es lo
+
+00:03:05.165 --> 00:03:06.685
+primero que se va a ejecutar de nuestro
+
+00:03:06.685 --> 00:03:10.865
+programa. Es conocido como el punto de entrada.
+
+00:03:11.940 --> 00:03:14.659
+Dentro de la función main, podemos escribir cualquier
+
+00:03:14.659 --> 00:03:16.920
+cantidad de código que queremos que se ejecute
+
+00:03:16.980 --> 00:03:19.620
+una vez arranque nuestro programa. En este caso,
+
+00:03:19.620 --> 00:03:21.780
+vamos a escribir un texto que nos va
+
+00:03:21.780 --> 00:03:24.585
+a decir hola mundo. La forma en que
+
+00:03:24.585 --> 00:03:26.985
+lo vamos a hacer es utilizando una funcionalidad
+
+00:03:26.985 --> 00:03:30.505
+que nos ofrece la librería iOStream, que es
+
+00:03:30.505 --> 00:03:37.730
+utilizar c out. C out y utilizar estos
+
+00:03:37.790 --> 00:03:41.490
+pequeños símbolos de menor que dos veces, nos
+
+00:03:41.870 --> 00:03:44.370
+permitirán escribir a continuación una cadena de texto
+
+00:03:44.590 --> 00:03:48.030
+que puede contener cualquier texto que queramos. La
+
+00:03:48.030 --> 00:03:51.160
+única condición es que debe ir entre comillas
+
+00:03:51.160 --> 00:03:53.765
+dobles, de esta forma. Por ejemplo, si yo
+
+00:03:53.765 --> 00:03:55.925
+quiero hacer mi programa de hola mundo, puedo
+
+00:03:55.925 --> 00:04:02.644
+poner hola mundo. Y una vez que termino
+
+00:04:02.644 --> 00:04:05.140
+de darle esta instrucción a mi programa, en
+
+00:04:05.140 --> 00:04:07.300
+el lenguaje de programación C y en los
+
+00:04:07.300 --> 00:04:10.580
+lenguajes que siguen al lenguaje programación C, como
+
+00:04:10.580 --> 00:04:13.379
+C más más, siempre, cada vez que terminamos
+
+00:04:13.379 --> 00:04:15.220
+de darle una orden a nuestro a nuestra
+
+00:04:15.220 --> 00:04:17.160
+computadora por medio de una línea de código,
+
+00:04:17.300 --> 00:04:19.794
+debemos terminar con un punto y coma. Si
+
+00:04:19.794 --> 00:04:21.794
+te das cuenta, la línea tres y la
+
+00:04:21.794 --> 00:04:24.275
+línea seis de nuestro editor de código terminan
+
+00:04:24.275 --> 00:04:25.955
+en punto y coma, porque le están dando
+
+00:04:25.955 --> 00:04:29.794
+una orden a la computadora. Las líneas cinco,
+
+00:04:29.794 --> 00:04:32.194
+la siete y la uno no necesitan un
+
+00:04:32.194 --> 00:04:34.060
+punto y coma, ya que estas no son
+
+00:04:34.060 --> 00:04:36.000
+órdenes directas que le damos a la computadora.
+
+00:04:38.380 --> 00:04:40.300
+Una vez que tenemos armado nuestro ejemplo de
+
+00:04:40.300 --> 00:04:43.340
+hola mundo, vamos a ejecutarlo. La forma fácil
+
+00:04:43.340 --> 00:04:46.380
+de hacerlo dentro de Visual Studio Code es
+
+00:04:46.380 --> 00:04:49.435
+instalando esta extensión que se llama C C
+
+00:04:49.435 --> 00:04:55.375
+más más Compile Run. La voy a instalar
+
+00:04:55.435 --> 00:04:57.535
+simplemente haciendo clic en el botón de instalación
+
+00:04:58.075 --> 00:05:00.095
+y, una vez que yo la tengo lista,
+
+00:05:00.155 --> 00:05:03.320
+ya está instalada. Como aquí dice en la
+
+00:05:03.320 --> 00:05:07.080
+documentación, podemos utilizar la tecla f seis para
+
+00:05:07.080 --> 00:05:09.639
+realizar la compilación de este programa y ver
+
+00:05:09.639 --> 00:05:12.120
+el resultado. Y es lo que voy a
+
+00:05:12.120 --> 00:05:16.540
+hacer a continuación. Aquí está, voy a oprimir
+
+00:05:16.760 --> 00:05:19.525
+f seis, y en este momento se está
+
+00:05:19.525 --> 00:05:22.965
+compilando nuestro programa y se ejecuta una vez
+
+00:05:22.965 --> 00:05:25.685
+que termina de compilar. Lo que nos muestra
+
+00:05:25.685 --> 00:05:29.285
+en la terminal es hola mundo. Felicidades, ya
+
+00:05:29.285 --> 00:05:31.045
+realizaste tu primer hola mundo en C más
+
+00:05:31.045 --> 00:05:33.830
+más. Este es el programa mínimo que puedes
+
+00:05:33.830 --> 00:05:37.110
+escribir en este lenguaje de programación, y esta
+
+00:05:37.110 --> 00:05:38.870
+misma base de código la vamos a estar
+
+00:05:38.870 --> 00:05:40.950
+utilizando para el resto de los ejemplos que
+
+00:05:40.950 --> 00:05:43.578
+vamos a realizar en este curso. Espero que
+
+00:05:43.578 --> 00:05:45.898
+te haya gustado muchísimo la forma en que
+
+00:05:45.898 --> 00:05:47.418
+funciona C más Más y que te haya
+
+00:05:47.418 --> 00:05:50.478
+causado muchísima curiosidad para que puedas seguirlo aprendiendo.
+
+00:05:50.618 --> 00:05:52.478
+Nos vemos en la próxima clase.

subir/Curso de C Básico/03-Conceptos básicos/01-estructura-base.zip

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

subir/Curso de C Básico/03-Conceptos básicos/02-Tipos de Datos en C Booleanos Enteros Flotantes y Caracteres.mp4

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

subir/Curso de C Básico/03-Conceptos básicos/02-Tipos de Datos en C Booleanos Enteros Flotantes y Caracteres.vtt

@@ -0,0 +1,403 @@
+WEBVTT
+
+00:00:03.280 --> 00:00:04.799
+Ahora vamos a hablar de otro tema que
+
+00:00:04.799 --> 00:00:06.879
+es súper importante para el lenguaje de programación
+
+00:00:06.879 --> 00:00:08.900
+C más más, igual que en otros lenguajes
+
+00:00:09.040 --> 00:00:11.599
+inspirados en C. Y este es los tipos
+
+00:00:11.599 --> 00:00:14.420
+de datos. Los tipos de datos son diferentes
+
+00:00:15.085 --> 00:00:17.645
+valores que podemos meter a una computadora. Por
+
+00:00:17.645 --> 00:00:22.205
+ejemplo, cuando queremos manipular información, como edades, nombres
+
+00:00:22.205 --> 00:00:26.125
+de personas o diferentes tipos de datos más
+
+00:00:26.125 --> 00:00:29.050
+complejos que queremos crear durante nuestro programa, necesitamos
+
+00:00:29.109 --> 00:00:32.229
+indicarle a nuestro lenguaje de programación cuáles son
+
+00:00:32.229 --> 00:00:34.550
+los datos que va a utilizar y también
+
+00:00:34.550 --> 00:00:37.030
+de qué tipos son. Esto nos va a
+
+00:00:37.030 --> 00:00:38.809
+permitir y le va a permitir al compilador
+
+00:00:39.110 --> 00:00:42.164
+entender, dependiendo del tipo de datos, qué son
+
+00:00:42.164 --> 00:00:44.004
+las cosas que puede hacer con estos datos
+
+00:00:44.004 --> 00:00:45.364
+y cómo las va a hacer, ¿no? Le
+
+00:00:45.364 --> 00:00:47.445
+va a permitir arrojarnos errores cuando lo hagamos
+
+00:00:47.445 --> 00:00:49.364
+mal y le va a permitir realizar operaciones
+
+00:00:49.364 --> 00:00:52.245
+cuando lo hagamos bien. Los diferentes tipos de
+
+00:00:52.245 --> 00:00:56.230
+datos que existen son muchísimos. Sin embargo, los
+
+00:00:56.230 --> 00:00:59.110
+principales son los que tienes aquí. La mayoría
+
+00:00:59.110 --> 00:01:00.790
+de los compiladores van a tener este tipo
+
+00:01:00.790 --> 00:01:02.390
+de datos, si no es que todos, ya
+
+00:01:02.390 --> 00:01:04.390
+que son parte del estándar. Y aquí es
+
+00:01:04.390 --> 00:01:07.510
+algo importante mencionar que en lenguajes como seis,
+
+00:01:07.510 --> 00:01:10.435
+C más más, aunque están estandarizados, todavía existen
+
+00:01:10.435 --> 00:01:13.715
+muchos compiladores independientes que se han creado que
+
+00:01:13.715 --> 00:01:15.315
+no cumplen al cien por ciento con todos
+
+00:01:15.315 --> 00:01:18.595
+los estándares, e incluso, dependiendo de la arquitectura
+
+00:01:18.595 --> 00:01:20.115
+de la computadora para la que vayas a
+
+00:01:20.115 --> 00:01:22.995
+compilar, es posible que, por ejemplo, los tamaños
+
+00:01:22.995 --> 00:01:25.719
+de bytes de estos tipos de datos cambien,
+
+00:01:25.719 --> 00:01:28.219
+por lo tanto, cambiando el tamaño de las
+
+00:01:28.219 --> 00:01:31.020
+cosas que pueden almacenar o el número máximo
+
+00:01:31.020 --> 00:01:33.979
+o mínimo de valores que pueden almacenar. Es
+
+00:01:33.979 --> 00:01:36.460
+importante que tomes esto en cuenta para que
+
+00:01:36.460 --> 00:01:40.219
+cuando programes para alguna plataforma real, siempre tengas
+
+00:01:40.219 --> 00:01:43.545
+en cuenta investigar cuáles son las los tamaños
+
+00:01:43.545 --> 00:01:45.545
+de bytes de reales de estos valores y
+
+00:01:45.545 --> 00:01:47.625
+de estos tipos de datos, y también cuáles
+
+00:01:47.625 --> 00:01:49.545
+son los tipos de datos soportados por tu
+
+00:01:49.545 --> 00:01:52.985
+compilador. Los principales tipos de datos, sin embargo,
+
+00:01:52.985 --> 00:01:55.810
+para continuar hablando del tema, son los siguientes.
+
+00:01:55.830 --> 00:01:58.330
+El primero es el valor booleano o bull.
+
+00:01:58.630 --> 00:02:01.350
+Son valores lógicos, es decir, verdadero y falso,
+
+00:02:01.350 --> 00:02:04.550
+esos dos estados o esos dos valores, que
+
+00:02:04.550 --> 00:02:07.190
+nuestro lenguaje de programación nos puede almacenar en
+
+00:02:07.190 --> 00:02:10.955
+cuatro bytes. Estos cuatro bytes se utilizan porque,
+
+00:02:10.955 --> 00:02:13.355
+aunque en realidad un verdadero y falso o
+
+00:02:13.355 --> 00:02:15.595
+uno cero los podríamos almacenar precisamente en un
+
+00:02:15.595 --> 00:02:17.515
+bit de información, la verdad es que los
+
+00:02:17.515 --> 00:02:21.810
+compiladores se facilitan la vida utilizando un tamaño
+
+00:02:21.810 --> 00:02:24.769
+completo de una variable para almacenar este valor,
+
+00:02:24.769 --> 00:02:27.250
+de forma que puedan acceder de una forma
+
+00:02:27.250 --> 00:02:29.510
+mucho más sencilla a estos valores sin necesidad
+
+00:02:30.129 --> 00:02:31.890
+de estar accediendo a cada uno de sus
+
+00:02:31.890 --> 00:02:34.390
+bits a buscar cuál es su valor real.
+
+00:02:34.645 --> 00:02:37.685
+Entonces, utilizamos todo el tamaño disponible, que es
+
+00:02:37.685 --> 00:02:40.325
+cuatro bytes, en este caso, para una variable
+
+00:02:40.325 --> 00:02:43.925
+de tipo booleano. A continuación, el siguiente tipo
+
+00:02:43.925 --> 00:02:46.165
+es el tipo entero, que se pone como
+
+00:02:46.165 --> 00:02:48.905
+int. Este tipo de datos nos permite almacenar
+
+00:02:48.965 --> 00:02:51.250
+números. Lo mismo, se almacena en un tamaño
+
+00:02:51.250 --> 00:02:54.050
+de cuatro bytes de datos, lo que significa
+
+00:02:54.050 --> 00:02:57.170
+que podemos almacenar valores bastante grandes y nos
+
+00:02:57.170 --> 00:03:01.090
+permite además manejar números positivos o negativos utilizando
+
+00:03:01.090 --> 00:03:03.145
+un bit para mantener el signo, y si
+
+00:03:03.145 --> 00:03:07.345
+decidimos utilizar ese bit sin signo, podemos utilizarlo
+
+00:03:07.345 --> 00:03:11.025
+para almacenar un número todavía más grande. El
+
+00:03:11.025 --> 00:03:12.785
+siguiente tipo de datos es el tipo de
+
+00:03:12.785 --> 00:03:17.489
+datos float, o números de punto flotante. Los
+
+00:03:17.489 --> 00:03:20.609
+números decimales en las computadoras se almacenan en
+
+00:03:20.609 --> 00:03:22.370
+otra forma de representar los que tiene las
+
+00:03:22.370 --> 00:03:24.709
+matemáticas, que es por medio de los exponentes.
+
+00:03:25.010 --> 00:03:27.730
+Almacenas la base y el exponente, y esa
+
+00:03:27.730 --> 00:03:30.730
+es la representación interna que utilizan los lenguajes
+
+00:03:30.730 --> 00:03:33.325
+de programación como C0C más más para almacenar
+
+00:03:33.385 --> 00:03:36.025
+nuestros números decimales. Tú podrías almacenar un valor
+
+00:03:36.025 --> 00:03:39.005
+como cero punto cinco, y la computadora utilizará
+
+00:03:39.065 --> 00:03:42.425
+cuatro bytes para almacenar toda la información necesaria
+
+00:03:42.425 --> 00:03:45.900
+para representar ese cero punto cinco. Nos permite
+
+00:03:45.900 --> 00:03:49.020
+un rango bastante amplio de valores decimales, pero
+
+00:03:49.020 --> 00:03:50.780
+más amplio es el rango que nos permite
+
+00:03:50.780 --> 00:03:52.460
+el siguiente tipo de dato, que es el
+
+00:03:52.460 --> 00:03:55.200
+tipo de dato double, es decir, un número
+
+00:03:55.340 --> 00:03:58.455
+de punto flotante, pero de doble precisión. Como
+
+00:03:58.455 --> 00:04:00.775
+ves, la diferencia es que ya no solamente
+
+00:04:00.775 --> 00:04:03.975
+utilizarás cuatro bytes, sino en lugar utilizarás ocho
+
+00:04:03.975 --> 00:04:07.015
+bytes para almacenar toda la información necesaria. Eso
+
+00:04:07.015 --> 00:04:10.315
+significa que puedes eso significa que puedes almacenar
+
+00:04:10.710 --> 00:04:15.270
+números mucho mayores de tipo coma flotante. Y
+
+00:04:15.270 --> 00:04:18.970
+por último, tienes los caracteres asky. La variable
+
+00:04:19.750 --> 00:04:22.710
+puede tener un tipo char y se pueden
+
+00:04:22.710 --> 00:04:27.905
+almacenar valores numéricos que significan o representan letras.
+
+00:04:28.205 --> 00:04:29.965
+La forma en la que funciona es que
+
+00:04:29.965 --> 00:04:32.465
+cuando comenzó toda la era de la computación,
+
+00:04:32.685 --> 00:04:35.325
+pues era una era demasiado temprana donde solamente
+
+00:04:35.325 --> 00:04:38.360
+se utilizaban números para realizar, pues, todos los
+
+00:04:38.360 --> 00:04:41.100
+cálculos o operaciones de un algoritmo, y fue
+
+00:04:41.320 --> 00:04:44.940
+posteriormente cuando fue necesario representar letras para mostrarlas
+
+00:04:45.320 --> 00:04:48.380
+en un monitor o para imprimirlas en papel,
+
+00:04:48.955 --> 00:04:51.515
+que se necesitó estandarizar cómo se iban a
+
+00:04:51.515 --> 00:04:54.315
+representar esas letras para la computadora. Allí surgió
+
+00:04:54.315 --> 00:04:56.715
+la tabla ASCII, que es una tabla con
+
+00:04:56.715 --> 00:04:58.875
+doscientos cincuenta y seis valores del cero al
+
+00:04:58.875 --> 00:05:01.615
+doscientos cincuenta y cinco, que contienen una correlación
+
+00:05:01.835 --> 00:05:04.155
+donde cada número de la tabla representa una
+
+00:05:04.155 --> 00:05:06.970
+letra o un carácter del alfabeto. En este
+
+00:05:06.970 --> 00:05:09.210
+caso, pueden ser las letras de la a
+
+00:05:09.210 --> 00:05:12.330
+a la z, mayúsculas, minúsculas, y algunos caracteres
+
+00:05:12.330 --> 00:05:16.750
+adicionales como espacios, signos de interrogación, asteriscos, etcétera.
+
+00:05:17.165 --> 00:05:20.045
+Todos estos caracteres tienen asociado, como vimos, un
+
+00:05:20.045 --> 00:05:22.445
+número en en la tabla. Por lo tanto,
+
+00:05:22.445 --> 00:05:24.685
+el tipo char dentro de seis, C más
+
+00:05:24.685 --> 00:05:27.425
+más, nos permitirán escribir este tipo de caracteres,
+
+00:05:27.565 --> 00:05:29.805
+ya sea el valor del carácter entre comillas
+
+00:05:29.805 --> 00:05:34.810
+simples o su equivalente numérico. Para esto, solamente
+
+00:05:34.810 --> 00:05:37.130
+tenemos doscientos cincuenta y seis valores, por lo
+
+00:05:37.130 --> 00:05:40.330
+que solamente necesitará un byte para almacenar esta
+
+00:05:40.330 --> 00:05:43.850
+información. La forma en que lo hace internamente
+
+00:05:43.850 --> 00:05:47.450
+cada compilador puede variar, incluso si utilizamos algún
+
+00:05:47.450 --> 00:05:51.345
+otro sistema, por ejemplo, sistemas embebidos, también puede
+
+00:05:51.345 --> 00:05:54.225
+variar. Lo que significa que no debemos confiarnos
+
+00:05:54.225 --> 00:05:56.385
+y, volviendo al inicio de la clase, siempre
+
+00:05:56.385 --> 00:05:59.745
+debemos investigar cuáles son las características soportadas por
+
+00:05:59.745 --> 00:06:02.865
+nuestros compiladores y cuáles son los valores por
+
+00:06:02.865 --> 00:06:04.940
+defecto de tamaños que va a utilizar para
+
+00:06:04.940 --> 00:06:07.980
+cada tipo de dato. Algunos compiladores tendrán otros
+
+00:06:07.980 --> 00:06:11.020
+tipos de datos adicionales y algunos se limitarán
+
+00:06:11.020 --> 00:06:15.340
+a cumplir con el estándar. Bien, pues ahora
+
+00:06:15.340 --> 00:06:17.180
+vamos a pasar a la siguiente clase, donde
+
+00:06:17.180 --> 00:06:20.088
+aprenderás cómo aplicar estos tipos de datos para
+
+00:06:20.088 --> 00:06:22.808
+crear variables y constantes que podrás utilizar en
+
+00:06:22.808 --> 00:06:24.748
+tu programa más adelante.

subir/Curso de C Básico/03-Conceptos básicos/03-Creación y Uso de Variables en C.mp4

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

subir/Curso de C Básico/03-Conceptos básicos/03-Creación y Uso de Variables en C.vtt

@@ -0,0 +1,340 @@
+WEBVTT
+
+00:00:03.120 --> 00:00:05.839
+Vamos a hablar de otra característica muy importante
+
+00:00:05.839 --> 00:00:08.559
+para los lenguajes de programación. Vamos a hablar
+
+00:00:08.559 --> 00:00:11.200
+de las variables. Las variables son la forma
+
+00:00:11.200 --> 00:00:14.155
+que nos da nuestro lenguaje de programación para
+
+00:00:14.155 --> 00:00:16.555
+almacenar todos los datos relacionados con la ejecución
+
+00:00:16.555 --> 00:00:19.435
+de nuestro programa. Por ejemplo, si queremos crear
+
+00:00:19.435 --> 00:00:22.814
+un programa que almacene una lista de usuarios
+
+00:00:23.115 --> 00:00:26.075
+o que almacene todas las tareas relacionadas a
+
+00:00:26.075 --> 00:00:29.490
+una persona, esto va a ser almacenado en
+
+00:00:29.630 --> 00:00:33.230
+variables durante la ejecución del programa. Para esto,
+
+00:00:33.230 --> 00:00:35.410
+podemos crear variables en C más más utilizando
+
+00:00:35.470 --> 00:00:37.550
+los tipos de datos que ya vimos en
+
+00:00:37.550 --> 00:00:40.989
+la clase anterior. Como puedes ver, aquí tenemos
+
+00:00:40.989 --> 00:00:43.864
+en pantalla el ejemplo anterior, nuestro hola mundo.
+
+00:00:44.324 --> 00:00:46.324
+Como puedes ver, ahí siguen todas las partes
+
+00:00:46.324 --> 00:00:48.245
+básicas de un programa en C más más
+
+00:00:48.245 --> 00:00:50.725
+como la función main, la importación de la
+
+00:00:50.725 --> 00:00:53.204
+librería iostream y el uso del espacio de
+
+00:00:53.204 --> 00:00:56.644
+nombres estándar. Ahora, vamos a comenzar a crear
+
+00:00:56.644 --> 00:01:00.600
+nuestras primeras variables. Esto lo podemos hacer indicando
+
+00:01:00.600 --> 00:01:02.300
+el tipo de dato que vamos a almacenar,
+
+00:01:02.360 --> 00:01:05.180
+un nombre para la variable, y si lo
+
+00:01:05.319 --> 00:01:07.880
+necesitamos podemos darle un valor inicial, lo cual
+
+00:01:07.880 --> 00:01:10.840
+además es una buena práctica. Por ejemplo, si
+
+00:01:10.840 --> 00:01:13.965
+quisiéramos almacenar la edad de una persona, estaríamos
+
+00:01:13.965 --> 00:01:16.645
+pensando en un valor de tipo numérico, por
+
+00:01:16.645 --> 00:01:19.045
+lo tanto, lo primero que podemos hacer es
+
+00:01:19.045 --> 00:01:23.064
+almacenar, es indicarle que es del tipo entero,
+
+00:01:23.125 --> 00:01:29.119
+por ejemplo, int. A continuación, necesitaríamos escoger un
+
+00:01:29.119 --> 00:01:31.600
+buen nombre para una variable. Los buenos nombres
+
+00:01:31.600 --> 00:01:34.159
+para las variables nos hablan sobre de qué
+
+00:01:34.159 --> 00:01:36.320
+se trata ese valor. En este caso, si
+
+00:01:36.320 --> 00:01:38.880
+hablábamos de la edad de una persona, pues
+
+00:01:38.880 --> 00:01:44.005
+podría ser la palabra edad. Es importante que
+
+00:01:44.005 --> 00:01:46.965
+recuerdes que en lenguajes como CYC más más
+
+00:01:46.965 --> 00:01:50.005
+las variables necesitan cumplir con ciertas reglas. Por
+
+00:01:50.005 --> 00:01:52.585
+ejemplo, no pueden contener espacios y no pueden
+
+00:01:52.805 --> 00:01:56.270
+contener caracteres extraños. Por lo tanto, la palabra
+
+00:01:56.270 --> 00:01:58.830
+edad está bien, pero si tuviéramos dos o
+
+00:01:58.830 --> 00:02:02.030
+más palabras podríamos mejor separarlas con guion bajo
+
+00:02:02.030 --> 00:02:06.430
+para no utilizar espacios. Ahora, ya tenemos creada
+
+00:02:06.430 --> 00:02:09.389
+nuestra variable tipo entero con la con el
+
+00:02:09.389 --> 00:02:12.595
+nombre edad. Si quisiéramos asignarle un valor inicial,
+
+00:02:12.895 --> 00:02:16.715
+podríamos hacerlo utilizando el símbolo de igual. Y
+
+00:02:17.375 --> 00:02:19.615
+ahora, podemos pensar cuál es el mejor valor
+
+00:02:19.615 --> 00:02:21.855
+por defecto que puede tener una variable, eso
+
+00:02:21.855 --> 00:02:23.970
+dependerá del caso de uso. En este caso,
+
+00:02:24.030 --> 00:02:26.190
+si queremos darle un valor por defecto a
+
+00:02:26.190 --> 00:02:28.990
+una variable edad, pues podría ser una edad
+
+00:02:28.990 --> 00:02:31.790
+estándar, por ejemplo dieciocho años, o podría ser
+
+00:02:31.790 --> 00:02:34.370
+simplemente el número cero. Yo voy a utilizar
+
+00:02:34.430 --> 00:02:38.475
+el valor del número cero. No debemos olvidar
+
+00:02:38.475 --> 00:02:40.155
+que como esto se trata de una instrucción
+
+00:02:40.155 --> 00:02:41.915
+de código que le estamos dando a la
+
+00:02:41.915 --> 00:02:46.235
+computadora, como una orden necesitamos indicarle el fin
+
+00:02:46.235 --> 00:02:48.075
+de esta orden por medio de un punto
+
+00:02:48.075 --> 00:02:52.150
+y coma. Y ahora sí, tenemos nuestra variable
+
+00:02:52.150 --> 00:02:55.190
+lista para ser utilizada en nuestro programa. Esta
+
+00:02:55.190 --> 00:02:57.830
+variable ahora contiene el valor de cero, por
+
+00:02:57.830 --> 00:02:59.770
+lo tanto, siempre que yo en mi programa
+
+00:02:59.910 --> 00:03:02.470
+utilice la palabra edad, vamos a hacer referencia
+
+00:03:02.470 --> 00:03:05.894
+a su valor cero. ¿Cómo yo podría mostrar
+
+00:03:05.894 --> 00:03:08.694
+el valor de la variable edad para que
+
+00:03:08.694 --> 00:03:11.334
+se muestre en nuestra terminal? Pues, de la
+
+00:03:11.334 --> 00:03:13.015
+misma manera que lo hicimos con el hola
+
+00:03:13.015 --> 00:03:16.295
+mundo. Yo voy a cambiar el valor de
+
+00:03:16.295 --> 00:03:18.150
+la cadena de texto que dice hola mundo
+
+00:03:18.390 --> 00:03:22.230
+por el valor de la variable edad, lo
+
+00:03:22.230 --> 00:03:25.510
+coloco de esta manera. Ahora le estoy diciendo
+
+00:03:25.510 --> 00:03:27.590
+a mi programa que muestre como salida de
+
+00:03:27.590 --> 00:03:30.470
+su ejecución el valor de edad, en este
+
+00:03:30.470 --> 00:03:36.325
+caso es cero. Vamos a ejecutarlo. Como recordarás,
+
+00:03:36.784 --> 00:03:39.424
+podemos utilizar la tecla f seis gracias a
+
+00:03:39.424 --> 00:03:43.344
+la extensión que instalamos en clases anteriores. Y
+
+00:03:43.344 --> 00:03:45.504
+aquí lo tenemos, una vez que se compiló
+
+00:03:45.504 --> 00:03:47.340
+y ejecutó el programa, su valor de salida
+
+00:03:47.340 --> 00:03:51.560
+ha sido cero. Esto es el valor de
+
+00:03:51.560 --> 00:03:54.280
+la variable edad. Vamos a probar qué pasa
+
+00:03:54.280 --> 00:03:56.120
+si yo le pongo otro valor a esta
+
+00:03:56.120 --> 00:03:58.520
+variable, por ejemplo, el diez, y de nuevo
+
+00:03:58.520 --> 00:04:02.245
+le doy compilar y ejecutar. Ahora nos muestra
+
+00:04:02.245 --> 00:04:05.605
+el valor diez como salida. Las variables, como
+
+00:04:05.605 --> 00:04:07.685
+su nombre lo indica, pueden cambiar a lo
+
+00:04:07.685 --> 00:04:10.325
+largo de la ejecución del programa, y aquí
+
+00:04:10.325 --> 00:04:13.079
+es donde entra su verdadera utilidad, ya que
+
+00:04:13.379 --> 00:04:16.500
+podemos manipularlas para tomar decisiones o por el
+
+00:04:16.500 --> 00:04:19.139
+simple hecho de mostrarlas al usuario de alguna
+
+00:04:19.139 --> 00:04:21.459
+u otra manera. Lo que podemos hacer con
+
+00:04:21.459 --> 00:04:24.680
+las variables para modificarlas es utilizar el símbolo
+
+00:04:24.740 --> 00:04:28.075
+de igual. Por ejemplo, si yo tengo un
+
+00:04:28.075 --> 00:04:33.515
+valor inicial para la variable que fuera cero,
+
+00:04:33.515 --> 00:04:37.035
+esta variable edad tal vez querría actualizarla en
+
+00:04:37.035 --> 00:04:39.515
+algún momento para ponerle la edad real de
+
+00:04:39.515 --> 00:04:43.830
+algún usuario. Supongamos que este usuario estamos validando
+
+00:04:43.970 --> 00:04:46.050
+que sea mayor de dieciocho años o de
+
+00:04:46.050 --> 00:04:48.770
+dieciocho años, pues podríamos pedirle la edad y
+
+00:04:48.770 --> 00:04:50.930
+la edad podría contener un número, por ejemplo,
+
+00:04:50.930 --> 00:04:55.425
+el número dieciocho. Para hacer esto, simplemente necesitamos
+
+00:04:55.425 --> 00:04:57.664
+en una nueva línea de código actualizar el
+
+00:04:57.664 --> 00:05:00.145
+valor de la variable, por ejemplo, puedo escribir
+
+00:05:00.145 --> 00:05:06.064
+edad igual a dieciocho, y como se trata
+
+00:05:06.064 --> 00:05:07.425
+de una instrucción que le damos a la
+
+00:05:07.425 --> 00:05:10.440
+computadora, podríamos terminar con punto y coma. Esto
+
+00:05:11.780 --> 00:05:14.020
+actualizará el valor de nuestra variable edad a
+
+00:05:14.020 --> 00:05:16.600
+dieciocho, ya no vale cero, ahora vale dieciocho.
+
+00:05:16.660 --> 00:05:20.354
+¿Qué pasaría si ejecutamos este programa? Pues, el
+
+00:05:20.354 --> 00:05:23.875
+valor de salida será dieciocho. De esta forma,
+
+00:05:23.875 --> 00:05:26.354
+podemos reasignarle valores una y otra vez a
+
+00:05:26.354 --> 00:05:30.115
+todas nuestras variables para poder realizar todos los
+
+00:05:30.115 --> 00:05:33.191
+procesos que necesitemos en nuestro programa. Te invito
+
+00:05:33.191 --> 00:05:35.531
+a ver la próxima clase donde continuaremos hablando
+
+00:05:35.671 --> 00:05:39.351
+sobre ciertas características de las variables, cómo serían
+
+00:05:39.351 --> 00:05:42.891
+las constantes y algunos otros tipos de datos.

subir/Curso de C Básico/03-Conceptos básicos/03-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/curso-basico-c-plus-plus/tree/variables

subir/Curso de C Básico/03-Conceptos básicos/03-variables.zip

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

subir/Curso de C Básico/03-Conceptos básicos/04-Constantes y Listas en C Uso y Manipulación Básica.mp4

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

subir/Curso de C Básico/03-Conceptos básicos/04-Constantes y Listas en C Uso y Manipulación Básica.vtt

@@ -0,0 +1,676 @@
+WEBVTT
+
+00:00:03.040 --> 00:00:05.680
+Vamos a hablar sobre dos características muy importantes
+
+00:00:05.680 --> 00:00:08.240
+de las variables en C más más, estos
+
+00:00:08.240 --> 00:00:11.840
+son las constantes y las listas. Vamos al
+
+00:00:11.840 --> 00:00:14.400
+código. Como puedes ver, aquí tenemos el ejemplo
+
+00:00:14.400 --> 00:00:16.765
+de la clase anterior, donde hablamos sobre cuál
+
+00:00:16.765 --> 00:00:19.244
+es la estructura básica de las variables. Vimos
+
+00:00:19.244 --> 00:00:21.244
+que primero vas a declarar el tipo de
+
+00:00:21.244 --> 00:00:23.244
+dato, en segundo lugar, vas a ponerle un
+
+00:00:23.244 --> 00:00:26.445
+nombre y, finalmente, puedes opcionalmente agregarle un valor.
+
+00:00:26.445 --> 00:00:30.044
+Vimos el ejemplo con el tipo de dato
+
+00:00:30.044 --> 00:00:32.659
+entero y la variable edad, pero no está
+
+00:00:32.659 --> 00:00:34.739
+de más recordarte que esta es la misma
+
+00:00:34.739 --> 00:00:37.059
+estructura que vas a poder utilizar para cualquier
+
+00:00:37.059 --> 00:00:39.460
+otro tipo de dato, ya sean datos que
+
+00:00:39.460 --> 00:00:41.620
+vengan por defecto en tu compilador o que
+
+00:00:41.620 --> 00:00:44.260
+más adelante puedas crear definiendo tus propios tipos
+
+00:00:44.260 --> 00:00:47.605
+de datos. Las variables, por ejemplo, se podrían
+
+00:00:47.985 --> 00:00:49.745
+declarar si fueras a hablar de una variable
+
+00:00:49.745 --> 00:00:54.545
+de tipo carácter utilizando char, luego le podrías
+
+00:00:54.545 --> 00:00:57.205
+poner cualquier nombre que tú desees, por ejemplo,
+
+00:00:57.265 --> 00:01:00.110
+letra, siempre que se cumplan las reglas de
+
+00:01:00.110 --> 00:01:01.989
+las que hablamos en la clase anterior, esto
+
+00:01:01.989 --> 00:01:04.590
+estará bien. La única diferencia con letra es
+
+00:01:04.590 --> 00:01:06.510
+que, a la hora de hacerle la asignación
+
+00:01:06.510 --> 00:01:08.430
+de un valor, vas a tener que escribir
+
+00:01:08.430 --> 00:01:12.414
+el carácter dentro de comillas simples. Y, como
+
+00:01:12.414 --> 00:01:14.335
+sabes, vas a tener que utilizar el punto
+
+00:01:14.335 --> 00:01:16.174
+y coma, dado que es una orden que
+
+00:01:16.174 --> 00:01:18.735
+le estás dando a la computadora. En este
+
+00:01:18.735 --> 00:01:21.715
+caso, yo quisiera almacenar la letra a, por
+
+00:01:22.095 --> 00:01:24.255
+ejemplo, entonces, esta es la forma en la
+
+00:01:24.255 --> 00:01:27.259
+que lo haría. Si yo quisiera imprimir el
+
+00:01:27.259 --> 00:01:30.479
+valor de la letra a, podría simplemente agregar
+
+00:01:30.780 --> 00:01:33.179
+una línea de seout, podría editar la que
+
+00:01:33.179 --> 00:01:34.780
+ya tengo o podría agregar una nueva, yo
+
+00:01:34.780 --> 00:01:37.259
+voy a agregar una nueva con la que
+
+00:01:37.259 --> 00:01:41.995
+voy a poder imprimir su valor. Algo importante
+
+00:01:42.295 --> 00:01:44.295
+para el uso de SEOut es que podemos
+
+00:01:44.295 --> 00:01:46.135
+realizar cambios de línea para que no se
+
+00:01:46.135 --> 00:01:49.595
+nos amontonen todos los valores utilizando otra característica
+
+00:01:49.815 --> 00:01:53.910
+de la librería ioStream, que es endline, y
+
+00:01:53.910 --> 00:01:57.830
+se coloca utilizando los mismos símbolos de menor
+
+00:01:57.830 --> 00:02:03.190
+que y agregando end l al final. Esto
+
+00:02:03.190 --> 00:02:05.590
+lo que hará es, al final, después de
+
+00:02:05.590 --> 00:02:08.195
+esa, en este caso, agregar la edad a
+
+00:02:08.195 --> 00:02:10.514
+la salida de la terminal, nos va a
+
+00:02:10.514 --> 00:02:12.595
+realizar un cambio de línea y en la
+
+00:02:12.595 --> 00:02:14.835
+nueva línea es donde comenzará a escribir los
+
+00:02:14.835 --> 00:02:18.915
+nuevos valores, en este caso, la letra. Vamos
+
+00:02:18.915 --> 00:02:20.835
+a compilar y ejecutar nuestro código con la
+
+00:02:20.835 --> 00:02:23.600
+tecla f seis y ahí tienes el resultado.
+
+00:02:24.060 --> 00:02:26.620
+Muestra primero el dieciocho, que es respecto a
+
+00:02:26.620 --> 00:02:29.420
+la edad de la persona, y ahora mostramos
+
+00:02:29.420 --> 00:02:33.420
+la letra a. Ya que tienes esta este
+
+00:02:33.420 --> 00:02:36.140
+conocimiento de cómo se realizan los diferentes tipos
+
+00:02:36.140 --> 00:02:38.665
+de datos, cómo se utilizan para crear variables,
+
+00:02:39.045 --> 00:02:41.364
+es importante que sepas que existe una forma
+
+00:02:41.364 --> 00:02:42.965
+de fijar esos valores para que no se
+
+00:02:42.965 --> 00:02:46.504
+puedan editar. Como viste, en la variable de
+
+00:02:46.564 --> 00:02:48.805
+edad tú podías asignarle un nuevo valor, que
+
+00:02:48.805 --> 00:02:50.885
+en este caso era dieciocho, a ese a
+
+00:02:50.885 --> 00:02:54.570
+esa variable. En algunas ocasiones, es importante que
+
+00:02:54.570 --> 00:02:56.570
+fijes que no se debe poder editar ese
+
+00:02:56.570 --> 00:02:58.810
+valor durante la ejecución de tu programa, ya
+
+00:02:58.810 --> 00:03:01.290
+sea porque podría causar un un problema o
+
+00:03:01.290 --> 00:03:04.970
+porque simplemente necesitas que el compilador no no
+
+00:03:04.970 --> 00:03:07.450
+realice optimizaciones para que se les puedan asignar
+
+00:03:07.450 --> 00:03:10.448
+valores, que solamente lo tome como un valor
+
+00:03:10.448 --> 00:03:13.445
+inicial y que nunca se asigna. En ese
+
+00:03:13.445 --> 00:03:16.725
+caso, puedes utilizar la palabra const para decirle
+
+00:03:16.725 --> 00:03:18.725
+que esta variable es fija y nunca debe
+
+00:03:18.725 --> 00:03:21.460
+poder reasignarse. La forma en que lo harías
+
+00:03:21.460 --> 00:03:24.040
+sería antes de la declaración de la variable,
+
+00:03:24.100 --> 00:03:27.380
+vamos a escribir la palabra const antes de
+
+00:03:27.380 --> 00:03:30.040
+la declaración de nuestra variable, y con esto
+
+00:03:30.260 --> 00:03:33.300
+ya tendríamos declarado que no podemos modificar el
+
+00:03:33.300 --> 00:03:36.005
+valor de la variable letra, en este caso,
+
+00:03:36.005 --> 00:03:38.725
+siempre va a ser la letra a. ¿Qué
+
+00:03:38.725 --> 00:03:41.925
+pasa si yo quiero ejecutar este código? Pues,
+
+00:03:41.925 --> 00:03:43.685
+va a funcionar de forma normal, pero ¿qué
+
+00:03:43.685 --> 00:03:46.710
+pasaría si yo quisiera editar el valor de
+
+00:03:46.950 --> 00:03:50.710
+esta variable letra, yo quisiera asignarle un nuevo
+
+00:03:50.710 --> 00:03:53.130
+valor que sea, por ejemplo, la letra b?
+
+00:03:56.710 --> 00:03:58.790
+En primer lugar, mi editor de código me
+
+00:03:58.790 --> 00:04:01.575
+va a decir que esta es una constante,
+
+00:04:01.575 --> 00:04:04.635
+por lo tanto, no debería tratar de modificarlo.
+
+00:04:05.415 --> 00:04:07.355
+¿Y qué pasa si yo trato de compilarlo
+
+00:04:07.415 --> 00:04:09.095
+de todos modos? Pues, me va a dar
+
+00:04:09.095 --> 00:04:10.935
+un error, me va a indicar que en
+
+00:04:10.935 --> 00:04:15.095
+la línea nueve, en el carácter número trece
+
+00:04:15.095 --> 00:04:16.954
+de esa línea, aquí me lo está diciendo,
+
+00:04:18.120 --> 00:04:19.959
+Justamente, aquí me pone una flechita sobre la
+
+00:04:19.959 --> 00:04:21.560
+b y me dice que esto es un
+
+00:04:21.560 --> 00:04:23.660
+valor de solo lectura, yo no puedo editarlo,
+
+00:04:24.120 --> 00:04:26.060
+así que no me va a dejar compilar.
+
+00:04:26.920 --> 00:04:29.400
+Esta es la forma que podemos utilizar, como
+
+00:04:29.400 --> 00:04:32.914
+mencionaba, para proteger ciertos datos o ciertos tipos
+
+00:04:32.914 --> 00:04:35.634
+de valores para que los usuarios no tengan
+
+00:04:35.634 --> 00:04:37.974
+acceso a editarlos o nadie trate de modificarlos
+
+00:04:38.115 --> 00:04:42.755
+por accidente. Voy a quitar esta línea de
+
+00:04:42.755 --> 00:04:44.594
+código que trato de modificar y voy a
+
+00:04:44.594 --> 00:04:48.500
+compilar de nuevo, y ahí está, funcionando una
+
+00:04:48.500 --> 00:04:52.180
+vez más. Ahora, ya hablamos sobre las constantes
+
+00:04:52.180 --> 00:04:54.580
+y ya hablamos sobre las variables. Así como
+
+00:04:54.580 --> 00:04:57.540
+yo creé tipos enteros, tipo carácter, yo podría
+
+00:04:57.540 --> 00:05:01.104
+haber creado tipos booleanos, flotantes, etcétera, y seguiría
+
+00:05:01.725 --> 00:05:03.645
+funcionando. Vamos a hablar de otro tema que
+
+00:05:03.645 --> 00:05:05.965
+también es importante dentro de C más más,
+
+00:05:05.965 --> 00:05:08.445
+y es cómo vamos a hacer para hacer
+
+00:05:08.445 --> 00:05:11.565
+conjuntos de valores. Supongamos que tú tienes una
+
+00:05:11.565 --> 00:05:14.750
+lista de personas, pero no necesitas saber todos
+
+00:05:14.750 --> 00:05:17.150
+sus datos, tal vez solamente quieres obtener cuál
+
+00:05:17.150 --> 00:05:20.190
+es la edad promedio. En este caso, solamente
+
+00:05:20.190 --> 00:05:23.790
+necesitarías las edades de cada persona. Por lo
+
+00:05:23.790 --> 00:05:26.625
+tanto, tendrías una lista de edades. Si tú
+
+00:05:26.625 --> 00:05:29.305
+quisieras hacer un proceso con estas edades, no
+
+00:05:29.305 --> 00:05:32.185
+sería muy eficiente crear una variable por cada
+
+00:05:32.185 --> 00:05:35.145
+edad, porque, en primer lugar, estarías escribiendo edad
+
+00:05:35.145 --> 00:05:37.465
+uno, edad dos, edad tres, edad cuatro como
+
+00:05:37.465 --> 00:05:41.340
+variables, lo cual haría muy cansado y muy
+
+00:05:41.340 --> 00:05:44.860
+tedioso la programación. Y, en segundo lugar, en
+
+00:05:44.860 --> 00:05:46.940
+la ejecución de tu programa, realmente, no vas
+
+00:05:46.940 --> 00:05:49.740
+a saber cuántos elementos tiene la lista, cuántas
+
+00:05:49.740 --> 00:05:53.495
+personas vas a sacar el promedio. Entonces, una
+
+00:05:53.495 --> 00:05:56.255
+forma mejor de hacerlo es utilizar las listas
+
+00:05:56.255 --> 00:05:58.735
+de c más más, y esto es por
+
+00:05:58.735 --> 00:06:02.355
+medio de la siguiente sintaxis. En primer lugar,
+
+00:06:02.575 --> 00:06:04.910
+vas a crear una variable, como cualquier otra,
+
+00:06:04.910 --> 00:06:07.790
+supongamos que queremos almacenar la lista de edades
+
+00:06:07.790 --> 00:06:10.910
+de una serie de personas. Primero indicarías de
+
+00:06:10.910 --> 00:06:13.389
+qué tipo. Como sabemos que van a ser
+
+00:06:13.389 --> 00:06:15.550
+las edades, sabemos que todas son variables numéricas,
+
+00:06:15.550 --> 00:06:17.550
+en C más más no puedes combinar estos
+
+00:06:17.550 --> 00:06:20.305
+tipos, no podrías poner algo como entero y
+
+00:06:20.305 --> 00:06:23.505
+luego que otro valor sea un carácter, sino
+
+00:06:23.505 --> 00:06:25.585
+que tienen que ser todos enteros, en este
+
+00:06:25.585 --> 00:06:29.505
+caso. La lista sería, por ejemplo, lista de
+
+00:06:29.505 --> 00:06:31.265
+edades, por lo tanto, le puedo poner ese
+
+00:06:31.265 --> 00:06:39.380
+ese nombre, lista edades, y le puedo asignar
+
+00:06:39.380 --> 00:06:41.060
+un valor inicial, voy a poner el punto
+
+00:06:41.060 --> 00:06:43.780
+y coma para que aparezca desde este momento,
+
+00:06:43.780 --> 00:06:46.020
+para que no se me olvide. Ahora, ¿cómo
+
+00:06:46.020 --> 00:06:48.660
+yo puedo indicarle que quiero una lista de
+
+00:06:48.660 --> 00:06:51.695
+edades? Bueno, necesito añadir dos cosas. En primer
+
+00:06:51.695 --> 00:06:54.895
+lugar, necesito agregarle, pues, la lista de valores
+
+00:06:54.895 --> 00:06:57.135
+uno tras otro y, en segundo lugar, necesito
+
+00:06:57.135 --> 00:06:59.055
+indicarle a mi lenguaje qué se trata de
+
+00:06:59.055 --> 00:07:01.854
+una lista. Para indicarle qué se trata de
+
+00:07:01.854 --> 00:07:04.335
+una lista, voy a utilizar estos símbolos de
+
+00:07:04.335 --> 00:07:06.840
+corchetes que me permiten, que le permiten a
+
+00:07:06.840 --> 00:07:08.280
+C más más saber que aquí se trata
+
+00:07:08.280 --> 00:07:11.000
+de una lista. Y para agregarle una lista
+
+00:07:11.000 --> 00:07:15.800
+de valores, voy a utilizar estas llaves donde
+
+00:07:15.800 --> 00:07:18.040
+C más más me va a permitir agregar,
+
+00:07:18.040 --> 00:07:19.880
+pues, todos los valores que yo quiera guardar
+
+00:07:19.880 --> 00:07:23.465
+en esa lista de edades, por ejemplo. Aquí,
+
+00:07:23.465 --> 00:07:25.305
+la única condición es que yo separe los
+
+00:07:25.305 --> 00:07:28.104
+valores por comas. Si yo quisiera tener solamente
+
+00:07:28.104 --> 00:07:30.345
+un valor que tenga la primera edad, por
+
+00:07:30.345 --> 00:07:34.419
+ejemplo, dieciocho, podría tenerlo así, Pero si yo
+
+00:07:34.419 --> 00:07:37.699
+quiero tener una lista de diez, veinte, treinta
+
+00:07:37.699 --> 00:07:40.500
+edades, tal vez solo unas cuantas edades, como
+
+00:07:40.500 --> 00:07:43.460
+tres, lo que tendría que hacer es separarlas
+
+00:07:43.460 --> 00:07:48.115
+por coma. La forma sería, por ejemplo, de
+
+00:07:48.115 --> 00:07:51.315
+esta forma. Con esto, yo ya tengo una
+
+00:07:51.315 --> 00:07:54.435
+lista de edades que tiene almacenados una lista
+
+00:07:54.435 --> 00:07:56.995
+de valores reales que yo ya puedo procesar.
+
+00:07:56.995 --> 00:07:58.995
+Esto me va a dar varias facilidades más
+
+00:07:58.995 --> 00:08:01.075
+adelante en en los ejemplos que vamos a
+
+00:08:01.075 --> 00:08:03.720
+ver, de momento, es importante que sepas que
+
+00:08:03.720 --> 00:08:06.140
+las listas se declaran de esta manera y
+
+00:08:06.200 --> 00:08:07.960
+cómo sería la forma de acceder a estos
+
+00:08:07.960 --> 00:08:11.160
+valores. Ahora, te estarás preguntando, ok, si yo
+
+00:08:11.160 --> 00:08:13.720
+quisiera imprimir el valor de la edad, la
+
+00:08:13.720 --> 00:08:15.300
+la primera variable que se encuentra en la
+
+00:08:15.300 --> 00:08:17.384
+línea seis, que se llama edad, es simple,
+
+00:08:17.384 --> 00:08:20.985
+solamente digo se out, edad y listo. ¿Cómo
+
+00:08:20.985 --> 00:08:24.185
+imprimiría yo solamente un valor de la lista?
+
+00:08:24.185 --> 00:08:26.504
+Por ejemplo, solo el dieciocho o solo el
+
+00:08:26.504 --> 00:08:29.305
+veinticuatro o solo el dieciséis. La forma que
+
+00:08:29.305 --> 00:08:30.905
+nos da C más más es acceder por
+
+00:08:30.905 --> 00:08:32.830
+el número de lista, es lo que se
+
+00:08:32.830 --> 00:08:35.990
+conoce como el índice, y en programación comenzamos
+
+00:08:35.990 --> 00:08:38.410
+a contar los elementos a partir de cero.
+
+00:08:38.630 --> 00:08:41.429
+Por lo tanto, el primer valor se encuentra
+
+00:08:41.429 --> 00:08:43.910
+en el índice cero, el segundo valor se
+
+00:08:43.910 --> 00:08:46.545
+encuentra en el índice uno, y el tercer
+
+00:08:46.545 --> 00:08:48.945
+valor se encuentra en el índice, que como
+
+00:08:48.945 --> 00:08:51.525
+ya vimos es un número de lista, número
+
+00:08:51.585 --> 00:08:55.025
+dos. Y esto nos va a permitir acceder
+
+00:08:55.025 --> 00:08:57.125
+a esos valores por medio del índice utilizando
+
+00:08:57.505 --> 00:09:00.449
+los corchetes. Por ejemplo, si yo quiero imprimir
+
+00:09:00.589 --> 00:09:02.750
+la lista, el valor de la lista que
+
+00:09:02.750 --> 00:09:05.630
+es el número veinticuatro, tendría que decirle, quiero
+
+00:09:05.630 --> 00:09:08.610
+de la lista de edades el índice uno.
+
+00:09:09.550 --> 00:09:13.475
+Voy a realizar el ejemplo con un c
+
+00:09:13.475 --> 00:09:15.555
+out, en este caso, voy a darle un
+
+00:09:15.555 --> 00:09:18.035
+end l para que termine esa línea, haga
+
+00:09:18.035 --> 00:09:20.275
+un cambio de línea, y voy a agregar
+
+00:09:20.275 --> 00:09:23.955
+uno nuevo. Y la forma en que yo
+
+00:09:23.955 --> 00:09:27.139
+podría hacerlo es comenzar a escribir lista de
+
+00:09:27.440 --> 00:09:32.240
+edades, así, utilizar unos corchetes, y dentro de
+
+00:09:32.240 --> 00:09:36.740
+los corchetes yo puedo indicarle cuál es el
+
+00:09:36.879 --> 00:09:38.835
+índice al que quiero acceder. Por ejemplo, si
+
+00:09:38.995 --> 00:09:41.395
+yo quiero acceder al número veinticuatro, tengo que
+
+00:09:41.395 --> 00:09:48.755
+es la posición uno. Ahí está. Como te
+
+00:09:48.755 --> 00:09:50.755
+das cuenta, nuestro editor de código ya no
+
+00:09:50.755 --> 00:09:52.515
+se queja, ya nos deja hacerlo, y si
+
+00:09:52.515 --> 00:09:54.830
+yo le doy ejecutar a nuestro programa, voy
+
+00:09:54.830 --> 00:09:58.110
+a obtener el último valor de nuestra ejecución
+
+00:09:58.110 --> 00:10:00.510
+que está aquí, el veinticuatro, es el valor
+
+00:10:00.510 --> 00:10:03.390
+al que yo quería acceder. Accedí gracias a
+
+00:10:03.390 --> 00:10:05.650
+su número de lista, que es su índice,
+
+00:10:05.710 --> 00:10:07.630
+y el nombre de la variable. De esta
+
+00:10:07.630 --> 00:10:10.885
+misma manera, yo podría asignarle un valor. Por
+
+00:10:10.885 --> 00:10:13.285
+ejemplo, si yo quiero asignarle un nuevo valor
+
+00:10:13.285 --> 00:10:15.945
+que, en lugar de ser veinticuatro, ese elemento
+
+00:10:16.084 --> 00:10:20.165
+sea veintiséis, podría hacerlo. Lo haría de la
+
+00:10:20.165 --> 00:10:25.130
+siguiente manera, lista de edades, el índice igual
+
+00:10:26.070 --> 00:10:28.310
+a, y el nuevo valor que yo quiero
+
+00:10:28.310 --> 00:10:32.870
+asignarle. Una vez hecho esto, guardo y vuelvo
+
+00:10:32.870 --> 00:10:36.790
+a compilar, y listo, ahora me aparece el
+
+00:10:36.790 --> 00:10:43.041
+número veintiséis. Esto es cómo crear variables constantes
+
+00:10:43.421 --> 00:10:45.901
+y listas en C más más. Te veo
+
+00:10:45.901 --> 00:10:47.041
+en la próxima clase.

subir/Curso de C Básico/03-Conceptos básicos/04-Lecturas recomendadas.txt

@@ -0,0 +1,2 @@
+https://platzi.com/cursos/programacion-basica/
+https://github.com/platzi/curso-basico-c-plus-plus/tree/constantes-listas

subir/Curso de C Básico/03-Conceptos básicos/04-constantes-listas.zip

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

subir/Curso de C Básico/03-Conceptos básicos/05-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/curso-basico-c-plus-plus/tree/operadores

subir/Curso de C Básico/03-Conceptos básicos/05-Operadores en C Aritméticos Comparativos y Lógicos.mp4

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

subir/Curso de C Básico/03-Conceptos básicos/05-Operadores en C Aritméticos Comparativos y Lógicos.vtt

@@ -0,0 +1,799 @@
+WEBVTT
+
+00:00:03.199 --> 00:00:05.279
+Vamos a hablar sobre otro tema muy importante
+
+00:00:05.279 --> 00:00:08.400
+de la programación, que son los operadores. En
+
+00:00:08.400 --> 00:00:12.320
+C más más existen diferentes tipos de operadores.
+
+00:00:12.320 --> 00:00:15.474
+En primer lugar, existen los operadores aritméticos, como
+
+00:00:15.474 --> 00:00:19.715
+la suma, la resta, multiplicación, división, división entera,
+
+00:00:19.715 --> 00:00:21.795
+que son los operadores matemáticos de toda la
+
+00:00:21.795 --> 00:00:24.275
+vida que, seguramente, si realizaste el curso de
+
+00:00:24.275 --> 00:00:28.275
+programación básica, ya conoces. Además de estos, existen
+
+00:00:28.275 --> 00:00:31.160
+los de comparación, por ejemplo, el doble igual
+
+00:00:31.160 --> 00:00:34.200
+nos ayuda a verificar si dos valores tienen,
+
+00:00:34.200 --> 00:00:37.239
+pues, una exactitud de igualdad, es decir, si
+
+00:00:37.239 --> 00:00:39.640
+dos es igual a dos o si un
+
+00:00:39.640 --> 00:00:42.440
+número es igual a otro, sea el número
+
+00:00:42.440 --> 00:00:46.015
+que sea, si si usáramos variables, y otros
+
+00:00:46.015 --> 00:00:48.975
+tipos de comparadores, por ejemplo, menor que, mayor
+
+00:00:48.975 --> 00:00:54.435
+que, diferente de, etcétera. La asignación nos permite
+
+00:00:55.455 --> 00:00:57.055
+añadirle una nuevo un nuevo valor a una
+
+00:00:57.055 --> 00:00:59.500
+variable a la vez que realizamos una operación
+
+00:00:59.500 --> 00:01:03.040
+matemática. Por ejemplo, tenemos más igual, menos igual,
+
+00:01:03.100 --> 00:01:05.660
+que lo que harían es permitirnos sumarle un
+
+00:01:05.660 --> 00:01:08.220
+número a la variable actual y almacenar el
+
+00:01:08.220 --> 00:01:10.479
+resultado en la misma variable que le indicamos.
+
+00:01:12.155 --> 00:01:14.635
+Adicionalmente, tenemos los operadores lógicos, que son los
+
+00:01:14.635 --> 00:01:19.295
+que realizan operaciones booleanas, como ant, or o
+
+00:01:19.295 --> 00:01:24.175
+not, que es una negación. También tenemos otros
+
+00:01:24.370 --> 00:01:27.170
+tipos de operadores, enzimas más, como size off
+
+00:01:27.170 --> 00:01:29.869
+o los operadores que hemos estado utilizando con
+
+00:01:30.130 --> 00:01:32.770
+el c out de io stream para la
+
+00:01:32.770 --> 00:01:36.610
+asignación de streams. En este caso, vamos a
+
+00:01:36.610 --> 00:01:39.330
+hablar sobre size off y sobre algunos de
+
+00:01:39.330 --> 00:01:43.165
+los operadores aritméticos y tal vez algún otro.
+
+00:01:44.505 --> 00:01:47.465
+Vamos a ver un ejemplo de código. Como
+
+00:01:47.465 --> 00:01:49.465
+puedes ver, ya tengo preparado para ti la
+
+00:01:49.465 --> 00:01:51.384
+base de código que vamos a estar utilizando
+
+00:01:51.384 --> 00:01:54.520
+en todos los ejercicios de este curso. Tenemos
+
+00:01:54.520 --> 00:01:57.080
+la librería de iStream, la función main y
+
+00:01:57.080 --> 00:01:59.960
+el espacio de nombres estándar. Vamos a comenzar
+
+00:01:59.960 --> 00:02:03.259
+a realizar nuestros ejercicios de operadores. En primer
+
+00:02:03.360 --> 00:02:05.720
+lugar, vamos a declarar, tal vez, un par
+
+00:02:05.720 --> 00:02:08.199
+de variables para poder realizar las operaciones con
+
+00:02:08.199 --> 00:02:11.505
+ellas. Para probar los operadores aritméticos, vamos a
+
+00:02:11.505 --> 00:02:14.625
+necesitar realizar operaciones entre números, por lo tanto,
+
+00:02:14.625 --> 00:02:18.385
+vamos a declarar dos números. Por ejemplo, vamos
+
+00:02:18.385 --> 00:02:21.585
+a crear la variable a, que contiene el
+
+00:02:21.585 --> 00:02:25.760
+número dos, y vamos a crear la variable
+
+00:02:25.760 --> 00:02:31.120
+b, que contiene el número tres. Vamos a
+
+00:02:31.120 --> 00:02:33.600
+realizar una salida de los datos para poder
+
+00:02:33.600 --> 00:02:36.340
+visualizar cuál es el resultado de nuestras operaciones
+
+00:02:36.685 --> 00:02:39.004
+después de ejecutar nuestro programa, así que vamos
+
+00:02:39.004 --> 00:02:42.364
+a utilizar la funcionalidad de COUT que nos
+
+00:02:42.364 --> 00:02:45.724
+ofrece iOStream, y ahí vamos a mostrar los
+
+00:02:45.724 --> 00:02:49.325
+resultados de nuestras operaciones. No olvidemos nunca poner
+
+00:02:49.325 --> 00:02:51.200
+el punto y coma después de cada orden
+
+00:02:51.200 --> 00:02:54.520
+que le damos a la computadora. Ahora, vamos
+
+00:02:54.520 --> 00:02:56.740
+a hablar sobre un par de operadores aritméticos.
+
+00:02:57.200 --> 00:02:59.840
+Por ejemplo, el operador de más. El operador
+
+00:02:59.840 --> 00:03:02.560
+de más, simplemente, como su nombre lo dice,
+
+00:03:02.560 --> 00:03:05.254
+suma a los dos números que le entreguemos.
+
+00:03:05.395 --> 00:03:07.235
+Por ejemplo, si queremos el resultado de la
+
+00:03:07.235 --> 00:03:11.235
+suma de dos más tres, sería cinco, podemos
+
+00:03:11.235 --> 00:03:15.555
+sumar a más b. Esta sería la forma
+
+00:03:15.555 --> 00:03:19.319
+de hacerlo. Esta operación, en este caso, va
+
+00:03:19.319 --> 00:03:22.680
+a realizar la suma, va a obtener el
+
+00:03:22.680 --> 00:03:25.640
+valor resultante y lo va a mostrar a
+
+00:03:25.640 --> 00:03:29.879
+la salida en la terminal. Voy a utilizar
+
+00:03:29.879 --> 00:03:36.675
+f seis para compilar y ejecutar. Y ahí
+
+00:03:36.675 --> 00:03:39.015
+está, ahora tenemos el valor cinco como salida
+
+00:03:39.075 --> 00:03:41.795
+de nuestro programa. Como puedes ver, la operación
+
+00:03:41.795 --> 00:03:45.095
+se realizó correctamente. Algo que es importante que
+
+00:03:45.395 --> 00:03:48.200
+notes es que la operación de suma de
+
+00:03:48.200 --> 00:03:50.380
+a más b se realizó antes del c
+
+00:03:50.680 --> 00:03:53.000
+out, pero no necesariamente tendría que estar ahí,
+
+00:03:53.000 --> 00:03:55.959
+podríamos realizar la operación y asignarse la otra
+
+00:03:55.959 --> 00:03:58.680
+variable. Por ejemplo, si yo tomo este valor
+
+00:03:58.680 --> 00:04:04.995
+de aquí, lo voy a cortar. Bueno, lo
+
+00:04:04.995 --> 00:04:09.474
+voy a copiar, y lo voy a pegar
+
+00:04:09.474 --> 00:04:12.515
+en una nueva variable que se llame c
+
+00:04:12.515 --> 00:04:18.820
+tal vez. Bueno, creo que no no se
+
+00:04:18.820 --> 00:04:20.660
+cortó y copió bien, pero lo voy a
+
+00:04:20.660 --> 00:04:25.700
+poner manualmente, a más b. Entonces, yo podría
+
+00:04:25.700 --> 00:04:28.445
+simplemente imprimir el valor de c a la
+
+00:04:28.445 --> 00:04:31.546
+salida de c out. Con esto, yo estoy
+
+00:04:31.546 --> 00:04:34.125
+realizando la operación en dos pasos. En primer
+
+00:04:34.125 --> 00:04:37.405
+lugar, realizo la suma, obtengo su resultado, lo
+
+00:04:37.405 --> 00:04:39.405
+almaceno en en la variable c, que es
+
+00:04:39.405 --> 00:04:41.485
+una nueva variable, y luego esa es la
+
+00:04:41.485 --> 00:04:43.520
+que muestro. ¿A qué voy con todo esto?
+
+00:04:43.520 --> 00:04:46.400
+Que en tus programas vas a poder utilizar
+
+00:04:46.400 --> 00:04:49.440
+todas las funcionalidades combinadas. Si tú aprendiste a
+
+00:04:49.440 --> 00:04:52.240
+utilizar la creación de variables, el uso de
+
+00:04:52.240 --> 00:04:55.140
+operadores y también cómo funciona SEOut, esos conocimientos
+
+00:04:55.280 --> 00:04:57.040
+tú los puedes combinar, como lo hemos estado
+
+00:04:57.040 --> 00:04:59.505
+haciendo, y con todas las demás lecciones que
+
+00:04:59.505 --> 00:05:01.905
+vamos a poder realizar en el curso, también
+
+00:05:01.905 --> 00:05:03.745
+quiero que sepas que todas esas cosas se
+
+00:05:03.745 --> 00:05:07.104
+pueden combinar entre sí. Y también es bueno
+
+00:05:07.104 --> 00:05:09.264
+que entiendas que estas operaciones, como la de
+
+00:05:09.264 --> 00:05:12.216
+suma, funcionan de forma independiente, no necesitarías utilizar
+
+00:05:12.223 --> 00:05:14.830
+c out para realizar una suma, por ejemplo.
+
+00:05:15.610 --> 00:05:17.710
+Entonces, ya tenemos el ejemplo de la suma,
+
+00:05:17.770 --> 00:05:20.330
+¿qué otras operaciones podemos realizar? Las operaciones que
+
+00:05:20.330 --> 00:05:24.855
+ya conoces, sumas, restas, multiplicaciones, divisiones. Por ejemplo,
+
+00:05:24.855 --> 00:05:27.255
+si yo quiero realizar una multiplicación de a
+
+00:05:27.255 --> 00:05:31.735
+por b, podría hacerlo. Simplemente tengo que ejecutar
+
+00:05:31.735 --> 00:05:33.835
+mi programa una vez más y ahora tengo
+
+00:05:34.375 --> 00:05:36.375
+el número seis, que es el resultado de
+
+00:05:36.375 --> 00:05:39.789
+multiplicar, dos por tres. De la misma manera,
+
+00:05:39.789 --> 00:05:44.930
+podría realizar todas las demás operaciones aritméticas. Existen
+
+00:05:44.990 --> 00:05:47.389
+otro tipo de operadores, como vimos, como podrían
+
+00:05:47.389 --> 00:05:51.229
+ser los operadores relacionales. Los operadores relacionales nos
+
+00:05:51.229 --> 00:05:53.944
+van a dar valores de verdadero o falso
+
+00:05:53.944 --> 00:05:57.145
+dependiendo si esa condición es real. Por ejemplo,
+
+00:05:57.145 --> 00:05:59.224
+si queremos relacionar el número a con el
+
+00:05:59.224 --> 00:06:03.245
+número b por medio de compararlos, podríamos pensar
+
+00:06:03.465 --> 00:06:04.745
+en si es mayor que o si es
+
+00:06:04.745 --> 00:06:07.560
+menor que o si es igual, entonces podríamos
+
+00:06:07.560 --> 00:06:10.680
+hacerlo de la siguiente manera. Podríamos utilizar el
+
+00:06:10.680 --> 00:06:15.319
+operador menor que, por ejemplo, para comparar si
+
+00:06:15.319 --> 00:06:17.419
+el valor de a es menor que b.
+
+00:06:17.800 --> 00:06:21.175
+Si esto es verdadero, la el valor de
+
+00:06:21.175 --> 00:06:23.735
+c ahora sería un valor booleano, por lo
+
+00:06:23.735 --> 00:06:26.135
+tanto, vamos a cambiar el tipo de dato
+
+00:06:26.135 --> 00:06:28.775
+de la variable c para que respetemos el
+
+00:06:28.775 --> 00:06:30.375
+tipo de valor que nos va a devolver
+
+00:06:30.375 --> 00:06:35.070
+esa operación. Y aquí estaríamos cambiando por bul.
+
+00:06:35.870 --> 00:06:38.450
+Con esto, nuestra variable c ya puede almacenar
+
+00:06:38.670 --> 00:06:41.630
+el resultado de este tipo de operaciones y
+
+00:06:41.630 --> 00:06:43.950
+nos va a almacenar, en este caso, tenemos
+
+00:06:43.950 --> 00:06:46.110
+que dos es menor que tres, por lo
+
+00:06:46.110 --> 00:06:50.355
+tanto, debería devolvernos true o verdadero. Vamos a
+
+00:06:50.355 --> 00:06:57.555
+ejecutar el programa. Listo. Ahora, como puedes ver,
+
+00:06:57.555 --> 00:06:59.315
+nos está mostrando un número uno. ¿Qué es
+
+00:06:59.315 --> 00:07:01.875
+lo que pasó aquí? Bueno, muy simple. Para
+
+00:07:01.875 --> 00:07:04.590
+la computadora, en lenguajes de programación de bajo
+
+00:07:04.590 --> 00:07:07.790
+nivel, como seis e más más, el verdadero
+
+00:07:07.790 --> 00:07:10.110
+va a ser equivalente a decir un uno
+
+00:07:10.110 --> 00:07:11.970
+en binario y el falso va a ser
+
+00:07:12.190 --> 00:07:14.590
+equivalente a decir un cero en binario. Por
+
+00:07:14.590 --> 00:07:18.255
+lo tanto, esta operación se realizó correctamente. Del
+
+00:07:18.255 --> 00:07:20.495
+al realizar, pues, la operación y darnos true,
+
+00:07:20.495 --> 00:07:23.295
+pues, nos muestra el número uno, porque c
+
+00:07:23.295 --> 00:07:25.935
+out no puede interpretar si se trata de
+
+00:07:25.935 --> 00:07:28.355
+una variable booleana o de una variable numérica
+
+00:07:28.815 --> 00:07:31.875
+de forma tan fácil. Eso lo podríamos corregir
+
+00:07:32.015 --> 00:07:35.419
+después, sin embargo, este es un valor, es
+
+00:07:35.419 --> 00:07:39.340
+un resultado correcto que esperaríamos. Ahora, ¿qué pasaría
+
+00:07:39.340 --> 00:07:42.380
+si yo hago la operación contraria? Si yo
+
+00:07:42.380 --> 00:07:45.015
+quiero verificar si a es mayor que b,
+
+00:07:45.415 --> 00:07:47.895
+esto nos daría falso, porque estaríamos diciendo que
+
+00:07:47.895 --> 00:07:49.975
+dos es mayor que tres, lo cual, pues,
+
+00:07:49.975 --> 00:07:52.135
+es falso. Esto se va a almacenar el
+
+00:07:52.135 --> 00:07:53.975
+c y cuando lo mostremos, vamos a volver
+
+00:07:53.975 --> 00:07:56.215
+a ejecutar nuestro programa, pues, nos va a
+
+00:07:56.215 --> 00:07:58.135
+dar un cero, que es decir, es un
+
+00:07:58.135 --> 00:08:02.610
+valor falso. Así funcionan los comparadores, que son
+
+00:08:02.610 --> 00:08:05.330
+otro tipo de operador que tenemos disponible en
+
+00:08:05.330 --> 00:08:07.729
+C más más y que seguramente habrás utilizado
+
+00:08:07.729 --> 00:08:11.570
+si ya tienes nociones de programación básica. Otro
+
+00:08:11.570 --> 00:08:14.050
+tipo de operadores que puedes aprender son los
+
+00:08:14.050 --> 00:08:16.294
+operadores de asignación, que lo que van a
+
+00:08:16.294 --> 00:08:18.595
+hacer es asignarle un nuevo valor a una
+
+00:08:18.655 --> 00:08:22.095
+variable a partir de el valor anterior más
+
+00:08:22.095 --> 00:08:24.354
+un cambio que tú le quieras agregar. Por
+
+00:08:24.735 --> 00:08:27.775
+ejemplo, si yo tengo la letra a, la
+
+00:08:27.775 --> 00:08:30.580
+variable a, que contiene el valor dos, yo
+
+00:08:30.580 --> 00:08:32.919
+puedo hacer que ahora su valor sea tres,
+
+00:08:33.220 --> 00:08:36.200
+incrementándola en uno. Por ejemplo, si yo creo
+
+00:08:36.500 --> 00:08:39.460
+para almacenar mi resultado esta variable c, le
+
+00:08:39.460 --> 00:08:44.915
+asigno a más igual uno, le estoy diciendo
+
+00:08:44.915 --> 00:08:49.015
+que quiero que la variable a más uno,
+
+00:08:49.235 --> 00:08:50.995
+eso va a ser cinco, va a incrementar
+
+00:08:50.995 --> 00:08:53.715
+y se va a almacenar en c. Esto
+
+00:08:53.715 --> 00:08:56.275
+es una forma resumida de hacerlo, porque yo
+
+00:08:56.275 --> 00:08:59.949
+podría simplemente reasignar a la variable a de
+
+00:08:59.949 --> 00:09:02.190
+esta forma, ¿no? Yo podría decirle cuál es
+
+00:09:02.190 --> 00:09:07.329
+el valor de a y súmale uno, ¿ok?
+
+00:09:08.750 --> 00:09:10.750
+Esto evita, en primer lugar, pues que tengamos
+
+00:09:10.750 --> 00:09:13.585
+que utilizar otra variable como c para realizar
+
+00:09:13.585 --> 00:09:17.265
+nuestra operación y almacenar su resultado, y al
+
+00:09:17.265 --> 00:09:18.945
+mismo tiempo nos damos cuenta que se repite
+
+00:09:18.945 --> 00:09:20.705
+dos veces la variable a. Entonces, lo que
+
+00:09:20.705 --> 00:09:23.153
+nos permite hacer es esta operación de suma
+
+00:09:23.153 --> 00:09:25.655
+que vemos aquí y esta operación de igualdad
+
+00:09:25.655 --> 00:09:30.640
+que vemos aquí en una sola operación. De
+
+00:09:30.640 --> 00:09:33.040
+manera que podríamos terminar con esta línea de
+
+00:09:33.040 --> 00:09:35.280
+código y ese es la operación que vamos
+
+00:09:35.280 --> 00:09:37.560
+a realizar. Vamos a tomar el valor original
+
+00:09:37.560 --> 00:09:40.155
+de a, vamos a asignarle el valor de
+
+00:09:40.395 --> 00:09:42.715
+anterior de a más uno, y ese va
+
+00:09:42.715 --> 00:09:44.875
+a ser el nuevo valor de a. Vamos
+
+00:09:44.875 --> 00:09:51.835
+a ejecutarlo con f seis. Ok, ahora vemos
+
+00:09:51.835 --> 00:09:55.190
+que nuestra variable a terminó valiendo tres, es
+
+00:09:55.190 --> 00:09:57.990
+decir, originalmente valía dos, le incrementó uno, y
+
+00:09:57.990 --> 00:10:00.470
+sobre la misma variable a guardó el resultado
+
+00:10:00.470 --> 00:10:05.029
+que es tres. Existen otros operadores, por ejemplo,
+
+00:10:05.029 --> 00:10:07.845
+los operadores como size off, que son operadores
+
+00:10:08.705 --> 00:10:10.465
+especiales dentro de C más más que nos
+
+00:10:10.465 --> 00:10:13.665
+permiten, pues, conocer cosas sobre las variables. En
+
+00:10:13.665 --> 00:10:16.545
+este caso, size off nos permite obtener el
+
+00:10:16.545 --> 00:10:18.785
+tamaño en bytes de un valor, de un
+
+00:10:18.785 --> 00:10:22.145
+dato. Por ejemplo, si tenemos el la variable
+
+00:10:22.145 --> 00:10:24.680
+b, que es un tipo entero, sabemos que
+
+00:10:24.680 --> 00:10:26.760
+en dependiendo del sistema operativo y de la
+
+00:10:26.760 --> 00:10:29.420
+computadora puede variar, pero en este caso podrían
+
+00:10:29.480 --> 00:10:32.680
+ser dos bytes, cuatro bytes, dependiendo de el
+
+00:10:32.680 --> 00:10:36.140
+sistema operativo. Esto es lo que nos va
+
+00:10:36.360 --> 00:10:38.735
+a devolver el operador size off, y la
+
+00:10:38.735 --> 00:10:42.975
+forma de utilizarlo es simplemente diciéndole a nuestro
+
+00:10:42.975 --> 00:10:46.654
+compilador que queremos obtener el tamaño de esa
+
+00:10:46.654 --> 00:10:50.815
+variable. Por ejemplo, si yo tengo size off
+
+00:10:50.815 --> 00:11:00.260
+a, de esta manera, le estoy pidiendo el
+
+00:11:00.260 --> 00:11:03.940
+valor del tamaño en bytes de la variable
+
+00:11:03.940 --> 00:11:06.995
+a para que lo muestre en pantalla. Vamos
+
+00:11:06.995 --> 00:11:12.435
+a ejecutarlo. Y me está diciendo que la
+
+00:11:12.435 --> 00:11:15.955
+variable a ocupa cuatro bytes de tamaño. ¿Esto
+
+00:11:15.955 --> 00:11:17.875
+por qué nos es útil? Bueno, porque size
+
+00:11:17.875 --> 00:11:20.200
+off nos va a permitir realizar algunas operaciones,
+
+00:11:20.260 --> 00:11:22.820
+por ejemplo, con listas. Si yo quisiera saber
+
+00:11:22.820 --> 00:11:26.180
+cuántos elementos tiene una lista, podría utilizar size
+
+00:11:26.180 --> 00:11:29.020
+off y una operación de división para obtener
+
+00:11:29.020 --> 00:11:31.620
+cuántos elementos tiene de forma inteligente. Vamos a
+
+00:11:31.620 --> 00:11:33.315
+ver el ejemplo de cómo se realiza esto.
+
+00:11:33.315 --> 00:11:35.815
+Si yo tuviera una lista, por ejemplo, inspirándonos
+
+00:11:35.955 --> 00:11:38.115
+en el ejemplo de la clase anterior, una
+
+00:11:38.115 --> 00:11:44.195
+lista de edades. Yo tengo la variable edades
+
+00:11:44.195 --> 00:11:47.680
+de tipo entero, le indico con corchetes que
+
+00:11:47.680 --> 00:11:49.360
+va a ser una variable que va a
+
+00:11:49.360 --> 00:11:52.160
+almacenar una lista de valores, y con llaves
+
+00:11:52.160 --> 00:11:54.340
+puedo indicar la lista de valores que tiene
+
+00:11:54.560 --> 00:11:59.600
+adentro. Por ejemplo, puedo tener veinticuatro, cuarenta y
+
+00:11:59.600 --> 00:12:04.295
+siete. Si yo quisiera saber cuántos elementos tiene
+
+00:12:04.295 --> 00:12:07.095
+esta lista, no siempre es fácil en C
+
+00:12:07.095 --> 00:12:09.415
+más más obtener ese tamaño, sin embargo, un
+
+00:12:09.415 --> 00:12:12.135
+truco que podemos hacer es tomar el número
+
+00:12:12.135 --> 00:12:15.319
+de el del tamaño total de la lista
+
+00:12:15.319 --> 00:12:18.120
+y dividirlo entre cuánto mide cada uno de
+
+00:12:18.120 --> 00:12:20.839
+sus elementos que tiene adentro. Por ejemplo, si
+
+00:12:20.839 --> 00:12:25.995
+tenemos tres elementos, nuestra lista mediría doce bytes,
+
+00:12:26.455 --> 00:12:28.455
+y si lo dividimos entre los cuatro bytes
+
+00:12:28.455 --> 00:12:31.595
+que tiene cada elemento, sabríamos que tiene tres
+
+00:12:32.135 --> 00:12:35.895
+elementos. La forma rápida de hacerlo sería size
+
+00:12:35.895 --> 00:12:43.340
+off, la variable edades, y eso dividirlo entre
+
+00:12:43.340 --> 00:12:46.060
+el size off de la variable de un
+
+00:12:46.060 --> 00:12:48.940
+número. En este caso, podríamos utilizar la letra
+
+00:12:48.940 --> 00:12:50.780
+a, ya que también es tipo entero y
+
+00:12:50.780 --> 00:12:53.340
+van a tener el mismo tamaño que cualquier
+
+00:12:53.340 --> 00:12:56.485
+otro número, o podríamos utilizar directamente un valor
+
+00:12:56.485 --> 00:12:59.785
+de la lista de edades. Por ejemplo, acceder
+
+00:12:59.845 --> 00:13:02.084
+a cualquiera de los valores, supongamos el valor
+
+00:13:02.084 --> 00:13:04.644
+cero, que sería el número veinticuatro. Va a
+
+00:13:04.644 --> 00:13:07.685
+obtener cuántos bytes se necesitan para almacenar el
+
+00:13:07.685 --> 00:13:10.180
+número veinticuatro y ese va a ser el
+
+00:13:10.180 --> 00:13:13.160
+resultado de ese size off. Entonces, dividiríamos, dividiríamos
+
+00:13:13.460 --> 00:13:15.700
+los doce bytes que miden total la lista
+
+00:13:15.700 --> 00:13:19.220
+de edades entre los cuatro bytes que mide
+
+00:13:19.220 --> 00:13:22.305
+solamente el primer valor de la lista. Si
+
+00:13:22.305 --> 00:13:25.904
+yo ejecuto y muestro el resultado, obtengo que
+
+00:13:25.904 --> 00:13:29.105
+tiene tres elementos. Ahora que ya sabes cómo
+
+00:13:29.105 --> 00:13:31.345
+funcionan los operadores en C más más y
+
+00:13:31.345 --> 00:13:33.550
+que viste que existen muchos otros, te reto
+
+00:13:33.550 --> 00:13:36.030
+a aprender a utilizarlos y que nos pongas
+
+00:13:36.030 --> 00:13:38.210
+en la sección de comentarios qué otros operadores
+
+00:13:38.350 --> 00:13:41.150
+existen y que realices experimentos con ellos para
+
+00:13:41.150 --> 00:13:43.470
+que aprendas mucho más y se te quede
+
+00:13:43.470 --> 00:13:46.110
+mucho más claro cómo funcionan. Nos vemos en
+
+00:13:46.110 --> 00:13:47.170
+la próxima clase.

subir/Curso de C Básico/03-Conceptos básicos/05-operadores.zip

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

subir/Curso de C Básico/03-Conceptos básicos/06-Manejo de Entrada y Salida de Datos con IOStream en C.mp4

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

subir/Curso de C Básico/03-Conceptos básicos/06-Manejo de Entrada y Salida de Datos con IOStream en C.vtt

@@ -0,0 +1,418 @@
+WEBVTT
+
+00:00:03.040 --> 00:00:05.120
+Un concepto que hemos estado utilizando, pero que
+
+00:00:05.120 --> 00:00:07.759
+no hemos visto correctamente, es el de entrada
+
+00:00:07.759 --> 00:00:10.320
+y salida de datos, el uso de la
+
+00:00:10.320 --> 00:00:14.115
+librería IOStream. Vamos al código. Como puedes ver
+
+00:00:14.115 --> 00:00:16.114
+en pantalla, aquí te tengo de nuevo el
+
+00:00:16.114 --> 00:00:19.555
+código base de nuestros ejercicios en clase. En
+
+00:00:19.555 --> 00:00:22.035
+primer lugar, la línea número uno tiene la
+
+00:00:22.035 --> 00:00:26.410
+librería Pero esta librería, ¿qué significa? Bueno, a
+
+00:00:26.410 --> 00:00:29.050
+grandes rasgos, lo que nos permite es realizar
+
+00:00:29.050 --> 00:00:30.830
+el manejo de entrada y salida de datos.
+
+00:00:31.130 --> 00:00:33.370
+¿Cómo lo hace? Por medio de streams, como
+
+00:00:33.370 --> 00:00:35.850
+lo menciona ahí, es decir, un stream es
+
+00:00:35.850 --> 00:00:38.830
+como un flujo de datos que van moviéndose,
+
+00:00:39.275 --> 00:00:41.515
+pues, como un flujo de información, como los
+
+00:00:41.515 --> 00:00:46.815
+streamers de video, ¿no? Entonces, este esta librería
+
+00:00:46.875 --> 00:00:48.875
+de stream lo que nos da es esa
+
+00:00:48.875 --> 00:00:52.235
+capacidad de streamear datos a través de la
+
+00:00:52.235 --> 00:00:54.630
+entrada y salida, en este caso, de nuestra
+
+00:00:54.630 --> 00:00:58.090
+terminal de comandos a nivel de texto, pero
+
+00:00:58.390 --> 00:01:01.590
+incluso nos permitiría una librería hermana a a
+
+00:01:01.590 --> 00:01:04.870
+stream que, pues, permita manejo de streams, tal
+
+00:01:04.870 --> 00:01:07.990
+vez hacerlo con archivos de cualquier tipo de
+
+00:01:07.990 --> 00:01:10.295
+formato, por ejemplo, de audio o de video.
+
+00:01:10.915 --> 00:01:13.895
+De esta manera, el sistema operativo se comunica
+
+00:01:14.275 --> 00:01:16.995
+con nuestro programa en C más más y
+
+00:01:16.995 --> 00:01:19.075
+recibe esos datos, y es como los puede
+
+00:01:19.075 --> 00:01:21.415
+mostrar en pantalla a través de nuestra terminal.
+
+00:01:22.560 --> 00:01:25.840
+Tiene dos principales funcionalidades, la primera ya la
+
+00:01:25.840 --> 00:01:29.119
+vimos, que es c out, que se escribe
+
+00:01:29.119 --> 00:01:32.479
+de la siguiente manera, c out, y a
+
+00:01:32.479 --> 00:01:35.460
+continuación se ponen dos símbolos de menor que,
+
+00:01:35.840 --> 00:01:38.865
+de esta forma. Estos símbolos lo que representan
+
+00:01:39.085 --> 00:01:41.485
+para C más más es un operador, de
+
+00:01:41.485 --> 00:01:44.545
+hecho. La única diferencia es que este operador
+
+00:01:44.924 --> 00:01:48.284
+está escrito para que iOsTime lo utilice como
+
+00:01:48.284 --> 00:01:51.744
+una forma de entrar datos hacia la terminal.
+
+00:01:51.884 --> 00:01:54.650
+Es decir, cuando yo escribo aquí mi hola
+
+00:01:54.650 --> 00:02:00.970
+mundo de esta forma, hola mundo, lo que
+
+00:02:00.970 --> 00:02:03.290
+le estoy diciendo a la computadora es, toma
+
+00:02:03.290 --> 00:02:06.110
+cada una de estas letras y veslas mandando
+
+00:02:06.490 --> 00:02:08.590
+hacia la salida de la terminal de comandos.
+
+00:02:08.835 --> 00:02:10.595
+Lo que haría primero es tomar la letra
+
+00:02:10.595 --> 00:02:13.555
+h y mostrarla, luego la letra o, y
+
+00:02:13.555 --> 00:02:17.875
+así secuencialmente. De esta forma, estamos streameando esta
+
+00:02:17.875 --> 00:02:21.315
+cadena hacia la terminal. Pues, podemos hacer algo
+
+00:02:21.315 --> 00:02:24.420
+muy similar para la entrada de datos. De
+
+00:02:24.420 --> 00:02:27.699
+la misma manera que existe, si out, existe
+
+00:02:27.699 --> 00:02:31.480
+c in. La forma de usarlo es con
+
+00:02:31.780 --> 00:02:35.780
+escribiendo c in. La única diferencia es que
+
+00:02:35.780 --> 00:02:39.504
+ahora las los símbolos van a ser de
+
+00:02:39.504 --> 00:02:42.625
+mayor que, como una especie de flechita que
+
+00:02:42.625 --> 00:02:44.224
+nos indica la dirección en la que el
+
+00:02:44.224 --> 00:02:47.345
+stream sucede. ¿Y qué podemos hacer ahora con
+
+00:02:47.345 --> 00:02:49.745
+esos datos de entrada? Pues almacenarlos en una
+
+00:02:49.745 --> 00:02:52.625
+variable para después hacer algo con ellos. Por
+
+00:02:52.625 --> 00:02:55.430
+ejemplo, supongamos que en lugar de un hola
+
+00:02:55.430 --> 00:02:57.110
+mundo, yo estoy haciendo un programa que le
+
+00:02:57.110 --> 00:03:00.090
+pide a un usuario cuál es su edad.
+
+00:03:00.390 --> 00:03:03.910
+Entonces, le preguntaríamos algo así como, ¿cuál es
+
+00:03:03.910 --> 00:03:07.185
+tu edad? O introduce tu edad, o simplemente
+
+00:03:07.285 --> 00:03:12.565
+edad. De esta forma, le mostraríamos ese mensaje
+
+00:03:12.565 --> 00:03:14.645
+en la terminal de comandos a el usuario
+
+00:03:14.645 --> 00:03:18.245
+de nuestro programa. Ahora, para poder almacenar la
+
+00:03:18.245 --> 00:03:20.724
+respuesta del usuario, vamos a necesitar primero crear
+
+00:03:20.724 --> 00:03:23.000
+una variable. Por lo tanto, en la línea
+
+00:03:23.000 --> 00:03:24.840
+número seis yo voy a agregar una variable
+
+00:03:24.840 --> 00:03:27.480
+que contenga la edad del usuario y la
+
+00:03:27.480 --> 00:03:32.680
+voy a inicializar con el valor cero. Ahora
+
+00:03:32.680 --> 00:03:36.385
+que la variable existe, podemos asignarle nuevos valores
+
+00:03:36.444 --> 00:03:39.325
+utilizando c in, y la forma sería simplemente
+
+00:03:39.325 --> 00:03:42.064
+escribir la variable edad después del c in.
+
+00:03:42.525 --> 00:03:44.924
+De esta forma, lo que va a suceder
+
+00:03:44.924 --> 00:03:47.485
+es que el la terminal de comandos va
+
+00:03:47.485 --> 00:03:49.750
+a recibir el dato, el sistema operativo se
+
+00:03:49.750 --> 00:03:52.530
+lo va a streamear a nuestro programa y
+
+00:03:52.790 --> 00:03:55.210
+va a recibirlo en nuestro programa para tenerlo
+
+00:03:55.670 --> 00:03:58.230
+ahora en su propia memoria. Pero, ¿cómo yo
+
+00:03:58.230 --> 00:04:01.870
+sé que realmente introduje una edad correcta? Pues,
+
+00:04:01.870 --> 00:04:04.150
+a lo mejor puedo darle feedback feedback al
+
+00:04:04.150 --> 00:04:06.045
+usuario de forma que le muestre yo, pues,
+
+00:04:06.045 --> 00:04:09.004
+la edad que introdujo anteriormente. Entonces, yo podría
+
+00:04:09.004 --> 00:04:14.364
+de nuevo hacer seout y decirle algo así
+
+00:04:14.364 --> 00:04:21.100
+como tu edad es Y la forma en
+
+00:04:21.100 --> 00:04:24.720
+que podemos unir los diferentes streams es siguiendo
+
+00:04:25.020 --> 00:04:28.780
+utilizando, como habíamos visto, el símbolo de el
+
+00:04:28.780 --> 00:04:32.300
+operador de stream. Entonces, lo que vamos a
+
+00:04:32.300 --> 00:04:34.555
+hacer es tomar tu edad es, se lo
+
+00:04:34.555 --> 00:04:36.635
+vamos a mandar a la pantalla, y luego
+
+00:04:36.635 --> 00:04:39.675
+podemos meter la variable de edad de esta
+
+00:04:39.675 --> 00:04:41.595
+forma, y también se lo mandamos a la
+
+00:04:41.595 --> 00:04:43.835
+pantalla. Entonces, al final, lo que va a
+
+00:04:43.835 --> 00:04:45.275
+aparecer, pues, es la edad que la persona
+
+00:04:45.275 --> 00:04:48.815
+haya introducido durante la ejecución de el sein.
+
+00:04:49.300 --> 00:04:52.580
+Vamos a ejecutarlo. En primer lugar, nos va
+
+00:04:52.580 --> 00:04:54.259
+a aparecer una pregunta que nos va a
+
+00:04:54.259 --> 00:04:56.419
+decir, edad o cuál es tu edad. En
+
+00:04:56.419 --> 00:04:58.660
+este caso, me pregunta ahí, ¿cuál es la
+
+00:04:58.660 --> 00:05:01.875
+edad? Supongamos que esta persona tiene dieciocho años.
+
+00:05:02.915 --> 00:05:06.515
+Introduce el número dieciocho y pulsa enter. Y,
+
+00:05:06.515 --> 00:05:09.175
+a continuación, le dice inmediatamente, tu edad es
+
+00:05:09.315 --> 00:05:12.515
+dieciocho. Esto es porque nuestro programa ha funcionado
+
+00:05:12.515 --> 00:05:15.600
+correctamente. Una cosa que es importante que sepas
+
+00:05:15.760 --> 00:05:17.760
+es que la forma en la que define
+
+00:05:17.760 --> 00:05:19.680
+cómo va a almacenar esos datos depende del
+
+00:05:19.680 --> 00:05:21.120
+tipo de dato de la variable que hayas
+
+00:05:21.120 --> 00:05:24.080
+creado. Si tú creaste una variable tipo entero,
+
+00:05:24.080 --> 00:05:25.600
+va a asumir que se trata de un
+
+00:05:25.600 --> 00:05:28.160
+número. Por lo tanto, si yo tomara esa
+
+00:05:28.160 --> 00:05:31.895
+edad y quisiera hacer operaciones aritméticas con ella,
+
+00:05:31.895 --> 00:05:34.615
+podría hacerlo. Si, en todo caso, yo la
+
+00:05:34.615 --> 00:05:37.415
+declarara como otro tipo, como un carácter, entonces,
+
+00:05:37.415 --> 00:05:39.815
+yo no podría realizar las operaciones que le
+
+00:05:39.815 --> 00:05:42.215
+corresponden solo a los números. Esto es importante
+
+00:05:42.215 --> 00:05:43.575
+porque es la forma en la que C
+
+00:05:43.575 --> 00:05:46.370
+más más va a saber cómo manejar esos
+
+00:05:46.370 --> 00:05:48.130
+valores que introduce el usuario a través de
+
+00:05:48.130 --> 00:05:52.290
+Zin. Adicionalmente, y es que no te lo
+
+00:05:52.290 --> 00:05:54.850
+había comentado en los episodios anteriores, en los
+
+00:05:54.850 --> 00:05:58.210
+capítulos anteriores, es cómo realizar comentarios en un
+
+00:05:58.210 --> 00:06:00.375
+código en C más más. Y existen dos
+
+00:06:00.375 --> 00:06:02.630
+formas súper básicas que si tú ya has
+
+00:06:02.630 --> 00:06:05.014
+programado en otros lenguajes hermanos o descendientes de
+
+00:06:05.014 --> 00:06:08.555
+C más más, pues, seguramente conocerás. La primera
+
+00:06:08.694 --> 00:06:14.700
+es utilizar las doble slash. Estas doble slash
+
+00:06:14.700 --> 00:06:17.020
+nos va a permitir comenzar a escribir aquí
+
+00:06:17.020 --> 00:06:20.560
+cualquier comentario. Por ejemplo, esto es un comentario.
+
+00:06:26.485 --> 00:06:28.805
+¿Listo? Esa es la primera forma y es
+
+00:06:28.805 --> 00:06:30.965
+una forma de escribir comentarios de una sola
+
+00:06:30.965 --> 00:06:33.625
+línea. Y si quisiéramos escribir comentarios de múltiples
+
+00:06:34.005 --> 00:06:36.665
+líneas, podemos utilizar esa sintaxis que es slash
+
+00:06:37.045 --> 00:06:41.700
+asterisco como apertura, escribir todas las líneas de
+
+00:06:41.700 --> 00:06:44.100
+comentario que querramos, y luego podemos cerrar con
+
+00:06:44.100 --> 00:06:49.140
+asterisco slash. Y esto es un comentario de
+
+00:06:49.140 --> 00:07:02.685
+múltiples líneas. Listo. Ahora que conoces cuáles son
+
+00:07:02.685 --> 00:07:05.060
+las dos formas básicas de realizar comentarios y
+
+00:07:05.060 --> 00:07:07.620
+cómo utilizar los operadores de entrada y salida
+
+00:07:07.620 --> 00:07:10.820
+de datos con iOStream, podemos pasar a nuestra
+
+00:07:10.820 --> 00:07:13.700
+siguiente a nuestra siguiente clase donde hablaremos sobre
+
+00:07:13.700 --> 00:07:14.200
+condicionales.

subir/Curso de C Básico/03-Conceptos básicos/06-entrada-salida-datos.zip

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

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/04-Lecturas recomendadas.txt

@@ -0,0 +1,2 @@
+https://www.tutorialspoint.com/c_standard_library/time_h.htm
+https://www.timeanddate.com/

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/05-Conversión de Decimal a Binario en C usando Ciclo For y Arrays.mp4

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

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/05-Conversión de Decimal a Binario en C usando Ciclo For y Arrays.vtt

@@ -0,0 +1,989 @@
+WEBVTT
+
+00:03.423 --> 00:05.500
+Bien, llegó el momento
+de ver otro ejemplo.
+
+00:05.500 --> 00:08.000
+Aquí te voy a enseñar
+cómo podemos utilizar
+
+00:08.000 --> 00:11.000
+unas librerías o bibliotecas nuevas,
+
+00:11.000 --> 00:15.000
+que es la biblioteca stdlib,
+la biblioteca estándar.
+
+00:15.000 --> 00:17.300
+Quiero simplemente mostrarte
+un comando system,
+
+00:17.300 --> 00:19.800
+pero también quiero que veas
+un código de ejemplo
+
+00:19.800 --> 00:22.900
+de cómo podemos agarrar
+un número en decimal
+
+00:22.900 --> 00:25.300
+y convertirlo a un número en binario.
+
+00:25.576 --> 00:27.300
+Vamos a Visual Studio Code.
+
+00:29.563 --> 00:31.718
+Como siempre
+abrimos nuestra nueva pestaña,
+
+00:32.212 --> 00:35.166
+guardamos, le vamos a poner
+a nuestro programa
+
+00:35.292 --> 00:41.031
+decimal to binary.c
+
+00:43.292 --> 00:45.292
+Muy bien,
+este es un programa bien clásico
+
+00:45.418 --> 00:48.319
+en donde vamos a aprender a
+utilizar principalmente el ciclo for.
+
+00:48.565 --> 00:50.908
+Lo primero que te quiero mostrar
+es el algoritmo
+
+00:51.034 --> 00:52.196
+que vamos a estar siguiendo.
+
+00:52.322 --> 00:54.936
+Si nunca has trabajado con divisiones
+
+00:55.062 --> 00:56.907
+de un valor decimal a binario,
+
+00:57.033 --> 00:58.578
+te explico brevemente el algoritmo.
+
+00:58.838 --> 01:01.418
+El primer paso de nuestro algoritmo
+
+01:01.544 --> 01:08.384
+va a ser dividir el valor entre dos.
+
+01:10.039 --> 01:12.652
+Y almacenar
+
+01:15.831 --> 01:18.428
+el remainder, el restante,
+
+01:18.554 --> 01:21.834
+el resto o el mod o como le llames tú,
+
+01:22.320 --> 01:24.315
+a en un array.
+
+01:26.599 --> 01:27.599
+Muy bien.
+
+01:27.725 --> 01:29.140
+El segundo paso
+
+01:32.222 --> 01:34.572
+va a ser dividir
+
+01:37.136 --> 01:38.249
+otra vez
+
+01:39.327 --> 01:41.150
+entre dos
+
+01:42.005 --> 01:47.300
+y almacenar el restante.
+
+01:48.627 --> 01:50.174
+Si es cero o si es uno,
+
+01:51.332 --> 01:53.551
+lo que conocemos
+como el módulo de la operación.
+
+01:54.691 --> 01:59.875
+Y por último, repetirlo hasta que
+
+02:03.403 --> 02:08.376
+nuestro número
+
+02:10.103 --> 02:13.267
+ya no se pueda dividir.
+
+02:13.393 --> 02:15.485
+Ahora sí, comencemos con nuestro código.
+
+02:16.445 --> 02:18.300
+Lo primero es utilizar include
+
+02:18.300 --> 02:20.604
+para llamar nuestras bibliotecas.
+
+02:20.730 --> 02:23.676
+La primera que voy a utilizar es stdio.h.
+
+02:24.283 --> 02:25.667
+La segunda que voy a utilizar,
+
+02:25.793 --> 02:28.593
+como ya te lo había spoileado al principio,
+
+02:28.719 --> 02:31.300
+va a ser stdlib.h.
+
+02:31.300 --> 02:32.300
+Excelente.
+
+02:32.300 --> 02:35.807
+Ya con esto vamos a proceder a declarar
+
+02:35.933 --> 02:37.300
+nuestro código main.
+
+02:37.788 --> 02:41.948
+Antes voy a declarar una serie de variables
+de tipo entero que voy a estar utilizando.
+
+02:42.402 --> 02:46.300
+Voy a tener un array en donde
+voy a guardar mis resultados.
+
+02:47.200 --> 02:49.679
+No vamos a hacer conversiones de números
+muy grandes,
+
+02:49.946 --> 02:54.300
+así que voy a decirle
+que sea de 12 posiciones
+
+02:54.300 --> 02:57.300
+para poder crear un número binario
+de hasta 12 dígitos.
+
+02:58.261 --> 03:00.300
+Asimismo vamos a tener dos auxiliares,
+
+03:00.300 --> 03:03.833
+el auxiliar n para nuestro número
+que vamos a recibir
+
+03:04.033 --> 03:07.300
+y el auxiliar i para nuestros arrays
+
+03:07.300 --> 03:09.300
+que vamos a estar trabajando.
+
+03:09.300 --> 03:11.300
+Para nuestros ciclos también.
+
+03:11.653 --> 03:14.300
+Punto y coma,
+ya declaramos todas nuestras variables.
+
+03:14.300 --> 03:15.300
+Está excelente.
+
+03:15.943 --> 03:18.300
+Ahora sí vamos a proceder
+a escribir nuestro main.
+
+03:20.300 --> 03:22.300
+Ya sabes, abrimos todo,
+
+03:23.134 --> 03:27.300
+nuestras llaves y colocamos return 0.
+
+03:28.517 --> 03:29.533
+Perfecto.
+
+03:30.054 --> 03:31.300
+Ya que tenemos nuestro main,
+
+03:31.300 --> 03:33.545
+pues podemos comenzar con nuestro código.
+
+03:33.671 --> 03:36.300
+Lo primero que vamos a hacer
+es pedirle al usuario
+
+03:36.300 --> 03:38.300
+que nos diga cuál es el número
+que quiere convertir.
+
+03:38.533 --> 03:39.638
+Es lo lógico.
+
+03:40.131 --> 03:44.300
+Entonces ingrese un valor decimal.
+
+03:46.733 --> 03:47.733
+Perfecto.
+
+03:48.169 --> 03:50.935
+Y vamos a poner nuestro salto de línea,
+
+03:51.061 --> 03:52.300
+punto y coma.
+
+03:52.843 --> 03:55.485
+Vamos a necesitar crear un ciclo for
+
+03:55.611 --> 03:58.300
+en el cual vamos a estar
+constantemente iterando
+
+03:58.300 --> 04:02.300
+para que se vaya resolviendo
+nuestro problema que tenemos acá.
+
+04:02.905 --> 04:05.978
+Este ciclo for como siempre va a comenzar
+en i igual a 0,
+
+04:06.104 --> 04:08.715
+pero la condición si va
+a tener un pequeño cambio
+
+04:08.841 --> 04:11.300
+y no vamos a utilizar i,
+
+04:11.300 --> 04:13.771
+vamos a utilizar n, que es el número,
+
+04:13.897 --> 04:15.704
+siempre que el número sea mayor a 0.
+
+04:15.830 --> 04:18.934
+Pero aquí te deberías estar preguntando
+¿por qué n?
+
+04:19.060 --> 04:20.702
+Bueno, te explico fácilmente.
+
+04:20.828 --> 04:23.072
+Porque n es el número
+que estamos metiendo,
+
+04:23.198 --> 04:26.118
+es la variable en donde ingresamos
+el valor que vamos a convertir.
+
+04:26.244 --> 04:29.300
+Y mientras este valor no haya llegado a 0
+
+04:29.300 --> 04:31.634
+en nuestro proceso
+de divisiones entre 2,
+
+04:31.861 --> 04:33.983
+pues nosotros tenemos
+que seguirlo dividiendo.
+
+04:34.109 --> 04:36.711
+Es decir, si n es mayor a 0,
+
+04:36.837 --> 04:39.379
+entonces seguimos repitiendo el ciclo for,
+
+04:39.505 --> 04:41.300
+porque lo vamos a seguir
+dividiendo entre 2,
+
+04:41.300 --> 04:43.495
+hasta que como te lo expliqué
+en el algoritmo,
+
+04:43.621 --> 04:46.300
+hasta que nuestro número
+ya no se pueda dividir.
+
+04:46.300 --> 04:48.800
+¿Por qué?
+Porque ya lo dividimos al máximo,
+
+04:48.926 --> 04:50.300
+es decir, porque ya es 0.
+
+04:50.300 --> 04:51.300
+Perfecto.
+
+04:51.970 --> 04:54.300
+Muy bien,
+vamos a poner nuestro iterador
+
+04:54.300 --> 04:55.300
+que va a ser i más más,
+
+04:55.576 --> 04:57.727
+porque este i más más justamente,
+
+04:57.853 --> 05:01.300
+nos va a estar sirviendo
+para recorrer una posición en el array
+
+05:01.554 --> 05:03.610
+y así cada resultado de la división,
+
+05:03.736 --> 05:06.511
+automáticamente lo vamos
+a estar guardando
+
+05:06.637 --> 05:08.335
+en una posición nueva de nuestro array.
+
+05:08.461 --> 05:10.585
+Esto es maravilloso, es muy útil
+
+05:10.711 --> 05:14.300
+y es una forma bastante importante
+que quiero que te quedes,
+
+05:14.300 --> 05:16.300
+de cómo puedes utilizar un ciclo for.
+
+05:16.867 --> 05:19.300
+Muy bien, ahora sí procedamos
+a escribir el código.
+
+05:19.928 --> 05:22.800
+Lo primero es que aquí
+vamos a utilizar nuestro array,
+
+05:23.143 --> 05:24.300
+que le puse a the array.
+
+05:26.891 --> 05:29.300
+Este array, de hecho le voy
+a cambiar el nombre a la variable,
+
+05:29.300 --> 05:34.722
+para que sea un nombre mucho más fácil
+para ti de recordar.
+
+05:34.942 --> 05:37.300
+Binary number.
+
+05:37.812 --> 05:38.831
+Perfecto.
+
+05:38.957 --> 05:41.300
+Ahora nuestro array
+se llama binary number
+
+05:41.300 --> 05:44.174
+y aquí es donde vamos a almacenar,
+como su nombre lo indica,
+
+05:44.543 --> 05:46.300
+nuestro número binario.
+
+05:46.654 --> 05:47.654
+Perfecto.
+
+05:47.780 --> 05:52.300
+Con esto dicho, vamos a hacer
+a binary number en la posición i.
+
+05:52.300 --> 05:55.562
+Como sabes, la posición i
+va a comenzar en 0.
+
+05:56.688 --> 05:58.300
+Entonces eso está muy bien.
+
+05:58.623 --> 06:01.300
+Vamos a tener la primera iteración, etc.
+
+06:01.523 --> 06:04.300
+y aquí vamos a ir guardando
+todos nuestros residuos.
+
+06:04.491 --> 06:08.300
+Para poder guardar nuestros residuos,
+simple y sencillamente,
+
+06:08.532 --> 06:11.800
+tenemos que usar n igual a n,
+
+06:13.300 --> 06:15.800
+con el módulo de la división entre 2.
+
+06:16.043 --> 06:18.800
+Eso es lo que significa esta operación
+que acabo de hacer aquí.
+
+06:18.800 --> 06:20.300
+Y por último,
+
+06:21.523 --> 06:25.300
+n va a ser igual a n...
+
+06:26.591 --> 06:29.300
+va a ser igual a n sobre 2.
+
+06:30.853 --> 06:32.153
+Punto y coma.
+Excelente.
+
+06:32.279 --> 06:35.581
+Entonces, aquí vamos a tener binary number,
+
+06:35.866 --> 06:40.040
+esto va a almacenar el módulo
+de nuestra operación,
+
+06:40.166 --> 06:42.166
+del módulo de lo que sería
+la división entre 2
+
+06:42.693 --> 06:46.300
+y luego efectivamente vamos
+a proceder a hacer la división.
+
+06:46.300 --> 06:48.300
+¿Por qué están en dos renglones diferentes?
+
+06:48.300 --> 06:50.300
+Porque este solo calcula el módulo
+
+06:50.300 --> 06:52.300
+y este sí que calcula la división.
+
+06:52.300 --> 06:55.300
+Entonces, el módulo del valor
+actual lo guardamos
+
+06:55.640 --> 06:58.800
+en nuestro array en donde va a estar
+nuestro número binario
+
+06:58.800 --> 07:01.300
+y luego procedemos
+a hacer la división entre 2.
+
+07:01.300 --> 07:04.300
+Si esta división entre 2 fue correcta,
+
+07:04.300 --> 07:06.800
+si esta división entre 2 todavía no...
+
+07:06.800 --> 07:08.800
+todavía nos da un resultado
+que es mayor a 0,
+
+07:08.800 --> 07:11.800
+significa que se puede
+volver a dividir entre 2
+
+07:11.800 --> 07:13.800
+y entonces le vamos
+a volver a sacar el módulo
+
+07:13.800 --> 07:15.300
+y volver a dividir entre 2
+
+07:15.300 --> 07:18.300
+y esto así sucesivamente hasta el final.
+
+07:18.860 --> 07:22.800
+Bueno, eso sería el for
+que se va a encargar de nuestro...
+
+07:23.208 --> 07:26.800
+de nuestro cálculo de binario...
+de decimal a binario, ¿no?
+
+07:26.800 --> 07:29.300
+Ahora hay que hacer un for para imprimir
+nuestro array,
+
+07:29.300 --> 07:30.800
+entonces vamos a hacer un print,
+
+07:32.473 --> 07:34.973
+vamos a ponerle el resultado,
+
+07:35.800 --> 07:37.800
+la conversión...
+mejor...
+
+07:39.413 --> 07:41.413
+la conversión de...
+
+07:42.135 --> 07:45.674
+y aquí vamos a pasarle primero
+el número original
+
+07:47.076 --> 07:48.800
+para que lo imprima,
+
+07:49.364 --> 07:51.300
+ingrese un valor en decimal, muy bien,
+
+07:51.300 --> 07:53.300
+como aquí vamos a estar modificando n
+
+07:53.300 --> 07:54.800
+porque no se lo estamos...
+
+07:54.800 --> 07:58.800
+entonces si tenemos que imprimir n antes,
+
+07:58.800 --> 08:00.800
+ingrese el valor de un decimal, perfecto,
+
+08:01.541 --> 08:02.908
+vamos a poner aquí otro print,
+
+08:04.800 --> 08:08.366
+usted, porque siempre
+hay que ser respetuosos,
+
+08:08.492 --> 08:12.093
+va a convertir el número
+
+08:13.680 --> 08:16.800
+%d a binario
+
+08:18.131 --> 08:21.800
+y aquí le pasamos nuestra variable n,
+punto y coma.
+
+08:22.634 --> 08:24.800
+La conversión de la...
+
+08:26.418 --> 08:28.573
+ok, el resultado es...
+
+08:31.543 --> 08:33.800
+el resultado es...
+
+08:34.800 --> 08:37.040
+y si han estado poniendo
+mucho cuidado en los cursos,
+
+08:37.166 --> 08:39.290
+se debieron de haber dado cuenta
+que a mí me faltó acá
+
+08:39.416 --> 08:42.300
+un %n,
+un diagonal invertida n,
+
+08:42.426 --> 08:44.300
+ya se lo puse, entonces todo bien.
+
+08:44.577 --> 08:46.800
+El resultado de la conversión
+
+08:48.729 --> 08:50.800
+es 2 puntos
+
+08:50.800 --> 08:54.475
+y aquí le vamos a pasar nuestro número
+en binario,
+
+08:54.601 --> 08:55.800
+así que bueno,
+
+08:55.800 --> 08:58.800
+de momento no lo voy
+a hacer en este print,
+
+08:58.800 --> 09:00.300
+así que no voy a dejar un %n,
+
+09:00.300 --> 09:05.300
+quiero que lo que voy a imprimir
+abajo se haga continuo,
+
+09:05.842 --> 09:08.800
+simplemente voy a dejar el
+espacio en blanco acá, perfecto,
+
+09:09.047 --> 09:11.034
+y voy a escribir un ciclo for,
+
+09:11.160 --> 09:13.111
+¿por qué vamos a utilizar otro ciclo for?
+
+09:13.237 --> 09:14.800
+porque tenemos un array
+
+09:14.800 --> 09:17.800
+y este array, simple y sencillamente,
+
+09:17.800 --> 09:20.800
+lo vamos a utilizar para
+ir imprimiendo este vector,
+
+09:21.122 --> 09:25.300
+pues como ya te dije,
+es una serie de valores
+
+09:25.300 --> 09:28.105
+que se almacenan en línea recta,
+por decirlo así,
+
+09:28.231 --> 09:29.800
+y cada uno toma una posición
+
+09:29.800 --> 09:32.300
+y podemos tener hasta 12 posiciones
+de memoria,
+
+09:32.558 --> 09:33.800
+es decir, vamos a tener...
+
+09:33.800 --> 09:36.564
+en la primera iteración vamos
+a tener un número
+
+09:36.690 --> 09:37.800
+que puede ser 0 1,
+
+09:37.800 --> 09:40.800
+en la segunda vamos a tener otro número
+que puede ser 0 1,
+
+09:40.800 --> 09:42.800
+en la tercera vamos a tener otro número
+
+09:42.800 --> 09:44.800
+y así se van a guardar sucesivamente
+
+09:44.800 --> 09:46.800
+en las 12 posiciones de nuestro array,
+
+09:47.143 --> 09:50.300
+entonces, ahora hay que sacarle
+esas posiciones de nuestro array,
+
+09:50.300 --> 09:53.008
+para esto vamos a recorrer nuestro vector.
+
+09:53.134 --> 09:54.300
+Ahora que ya sabes de qué...
+
+09:54.300 --> 09:55.800
+por qué necesitaremos otro for,
+
+09:55.800 --> 09:57.300
+te explico qué va a ir adentro.
+
+09:57.687 --> 09:59.582
+Recuerda que nuestro auxiliar i,
+
+09:59.708 --> 10:03.300
+nos llegaba hasta la parte final
+de nuestro array,
+
+10:03.300 --> 10:05.300
+en donde había guardado el último dígito,
+
+10:05.575 --> 10:07.300
+simple y sencillamente
+este incrementador
+
+10:07.300 --> 10:09.648
+nos dejaba ahí, si guardamos 5 dígitos,
+
+10:09.774 --> 10:11.898
+nos lo dejaba en el valor 5
+
+10:12.024 --> 10:15.300
+y así sucesivamente,
+nos lo dejaba en el último valor
+
+10:15.300 --> 10:17.300
+que habíamos grabado, eso es genial,
+
+10:17.300 --> 10:19.300
+pero aquí abajo, entonces,
+
+10:19.300 --> 10:20.800
+tenemos que empezar a imprimir
+
+10:20.800 --> 10:22.300
+y vamos a comenzar a imprimir
+
+10:22.300 --> 10:24.300
+desde el último valor de nuestro array,
+
+10:24.300 --> 10:26.800
+porque es el último dato que se generó,
+
+10:26.800 --> 10:29.300
+hasta el primero, vamos a ver
+cómo funciona esto.
+
+10:31.066 --> 10:33.300
+La condición acá es interesante,
+
+10:33.300 --> 10:38.532
+porque vamos a ir decrementando
+nuestro auxiliar en 1 de entrada,
+
+10:38.600 --> 10:39.673
+¿por qué?
+
+10:39.699 --> 10:42.800
+Porque recuerda que los arrays
+empiezan a contar del 0,
+
+10:42.800 --> 10:45.800
+si entonces estábamos
+en el número 5 que se guardó,
+
+10:46.099 --> 10:49.800
+la posición real del array,
+del quinto valor, es el 4,
+
+10:49.800 --> 10:50.800
+entonces te explico,
+
+10:51.051 --> 10:53.800
+un array siempre comienza en 0,
+en la posición 0,
+
+10:54.239 --> 10:57.300
+0, 1, 2, 3, 4,
+
+10:57.300 --> 10:59.800
+en el número...
+en la posición 4 de nuestro array,
+
+11:00.124 --> 11:02.300
+tenemos el quinto valor, ¿ok?
+
+11:02.583 --> 11:04.300
+Con esto dicho, seguimos.
+
+11:04.676 --> 11:08.300
+Vamos aquí a nuestro auxiliar,
+a la parte de la condición,
+
+11:08.300 --> 11:13.300
+entonces, si es mayor que o igual,
+
+11:13.624 --> 11:16.800
+si es mayor o igual a 0, es decir
+que no hemos terminado
+
+11:17.003 --> 11:20.800
+nuestro array o que estamos por terminarlo,
+
+11:21.002 --> 11:23.800
+y i menos menos,
+vamos a ir decremental,
+
+11:23.800 --> 11:25.800
+estamos recorriéndolo
+del final de nuestro array,
+
+11:26.005 --> 11:27.800
+al principio de nuestro array.
+
+11:28.133 --> 11:30.300
+Ahora, el código que vamos a poner aquí,
+
+11:30.439 --> 11:31.800
+va a ser súper simple,
+
+11:32.161 --> 11:33.800
+vamos a poner un print,
+
+11:33.800 --> 11:35.800
+vamos a poner paréntesis,
+
+11:36.229 --> 11:37.800
+%d,
+
+11:38.800 --> 11:39.800
+coma,
+
+11:40.541 --> 11:43.993
+y le vamos a pasar el valor
+que tengamos almacenado
+
+11:44.119 --> 11:46.800
+en nuestro binary number,
+
+11:46.800 --> 11:48.800
+que es nuestro array del resultado,
+
+11:48.800 --> 11:51.397
+es decir, i, punto y coma.
+
+11:51.631 --> 11:54.800
+¿Te acuerdas que utilizamos
+la biblioteca STDELIV?
+
+11:54.800 --> 11:56.800
+Esto nos da una función súper chévere,
+
+11:56.800 --> 11:57.800
+que es system,
+
+11:58.095 --> 12:00.800
+en system nosotros
+le vamos a pasar argumentos
+
+12:00.800 --> 12:02.300
+que van directo al sistema,
+
+12:02.300 --> 12:05.300
+al sistema en el que estamos trabajando,
+
+12:05.300 --> 12:07.300
+entonces, yo le voy a pasar CLS,
+
+12:07.300 --> 12:09.300
+que nos va a servir
+para limpiar la terminal,
+
+12:09.300 --> 12:12.300
+y también le voy a pasar system color,
+
+12:12.300 --> 12:15.555
+que nos va a servir para cambiar
+el color de las letras
+
+12:15.681 --> 12:18.030
+que estamos trabajando
+en nuestra terminal,
+
+12:18.156 --> 12:21.476
+0 es negro y 9 llega a light blue,
+
+12:21.602 --> 12:24.800
+también tenemos los códigos de letras,
+
+12:24.800 --> 12:26.800
+porque estamos hablando
+de valores hexadecimales,
+
+12:26.800 --> 12:28.800
+que van desde blanco brilloso,
+
+12:28.800 --> 12:30.800
+hasta amarillo, aqua,
+
+12:30.800 --> 12:32.800
+te voy a dejar un link
+para que los consultes
+
+12:32.800 --> 12:34.800
+en la sección de enlaces, los colores,
+
+12:34.800 --> 12:37.229
+en esto, para esta función.
+
+12:37.355 --> 12:39.800
+Entonces, tengo un typo acá,
+
+12:39.800 --> 12:41.800
+tengo que poner color, no colar,
+
+12:41.800 --> 12:45.800
+y le voy a poner 9f,
+
+12:45.800 --> 12:46.800
+a ver qué pasa,
+
+12:46.800 --> 12:50.800
+que es 9 del azul ligero
+y f de blanco brilloso.
+
+12:50.800 --> 12:53.300
+Vamos a ejecutar esto
+para ver cómo funciona,
+
+12:53.559 --> 12:56.800
+vamos a darle, ya sabes, f6 o fnf6,
+
+12:57.060 --> 12:58.800
+compila de manera exitosa,
+
+12:58.800 --> 13:00.800
+y tenemos nuestras letras blancas
+
+13:00.800 --> 13:02.800
+con un fondo azul,
+
+13:02.800 --> 13:04.800
+esto está muy, muy chévere.
+
+13:04.800 --> 13:06.800
+Muy bien, ahora dice,
+ingrese un valor decimal,
+
+13:06.800 --> 13:09.135
+vamos a pasarle el valor 30,
+
+13:09.261 --> 13:11.800
+dice, usted va a convertir
+el número 30 a binario,
+
+13:11.800 --> 13:14.800
+el resultado de la conversión es 11110.
+
+13:15.114 --> 13:16.800
+Ahora, vamos a Google Chrome,
+
+13:16.800 --> 13:18.674
+porque quiero validar esto,
+por supuesto,
+
+13:19.349 --> 13:21.800
+y en Google Chrome vamos a decirle,
+
+13:22.631 --> 13:27.800
+11110 binary to decimal.
+
+13:29.138 --> 13:31.019
+Y Google Chrome, que nos entiende bien,
+
+13:31.145 --> 13:33.800
+nos pasa esta tabla, genial, maravilloso,
+
+13:33.931 --> 13:37.800
+y 11110 efectivamente es 30.
+
+13:37.800 --> 13:38.926
+Y lo tenemos,
+
+13:39.052 --> 13:41.501
+logramos hacer un programa
+que es un poco más avanzado
+
+13:41.627 --> 13:43.131
+de los que hemos ido haciendo en el curso,
+
+13:43.257 --> 13:47.223
+en donde implementamos
+una conversión de binario a decimal.
+
+13:47.469 --> 13:50.105
+También fue tu primera introducción
+a los arrays,
+
+13:50.231 --> 13:54.227
+y eso es un tema que vemos mucho
+más a profundidad en el próximo curso,
+
+13:54.353 --> 13:56.234
+en donde sin duda espero poder verte.
+
+13:56.360 --> 14:00.900
+Nos vemos en la próxima clase.

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/05-Lecturas recomendadas.txt

@@ -0,0 +1,2 @@
+https://www.tutorialspoint.com/c_standard_library/stdlib_h.htm
+https://www.w3schools.com/colors/colors_picker.asp

subir/Curso de Funciones en C/03-Bibliotecas estándar de funciones/05-decimaltobinary_fe30b38b-6b12-47d7-913b-ea0e08976f1a.c

@@ -0,0 +1,33 @@
+// 1er paso Dividir el valor entre 2 yalmacenar el resto, mod, en un array
+// 2do paso dividir otra vez entre 2 y almacenar el restante 
+// repetir hasta que nuestro número ya no se pueda dividir 
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int binaryNumber[12],n,i;
+
+main()
+{   
+    system("cls");
+    system("color 9F");
+    printf("Ingrese un valor decimal\n");
+    scanf("%d", &n);
+    printf("Usted va a convetir el numero %d a binario\n",n);
+    
+    for ( i = 0; n > 0; i++)
+    {
+        binaryNumber[i]= n%2;
+        n = n/2;
+    }
+
+    printf("El resultado de la conversion es: ");
+    for ( i= i-1 ; i >= 0; i--)
+    {
+        printf("%d",binaryNumber[i]);
+    }
+    
+    
+
+    return 0;
+}

subir/Curso de Funciones en C/04-Cierre/01-Funciones Avanzadas en C Creación y Uso Práctico.mp4

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

subir/Curso de Funciones en C/04-Cierre/01-Funciones Avanzadas en C Creación y Uso Práctico.vtt

@@ -0,0 +1,108 @@
+WEBVTT
+
+00:03.206 --> 00:08.000
+¡Ey! Muchas felicidades, llegaste al final
+de este curso de funciones en C.
+
+00:08.000 --> 00:12.000
+De verdad, espero que hayas puesto mucho
+en práctica todo lo que aprendiste,
+
+00:12.000 --> 00:15.500
+que te haya gustado este curso, 
+que me dejes tu review de 5 estrellas,
+
+00:15.500 --> 00:19.500
+eso me ayuda muchísimo y que continues 
+con esta ruta de cursos de C.
+
+00:19.500 --> 00:22.500
+Si de verdad te interesan, 
+compárteme tu diploma en Twitter,
+
+00:22.500 --> 00:26.500
+en la red social que quieras, Twitter,
+LinkedIn, en Twitter soy CelisMx,
+
+00:26.500 --> 00:30.500
+ahí me puedes seguir para cualquier duda,
+también te reto obviamente
+
+00:30.500 --> 00:33.500
+a que termines el examen para que puedas
+obtener ese diploma
+
+00:33.500 --> 00:37.500
+y no te olvides de practicar muchísimo
+todo lo que aprendimos.
+
+00:37.500 --> 00:42.500
+Solo por último, para cerrar, recuerda 
+que hay muchísimas bibliotecas en C
+
+00:42.500 --> 00:44.699
+y cada una tiene 
+una gran cantidad de funciones,
+
+00:44.825 --> 00:46.500
+así que es imposible cubrirlas todas,
+
+00:46.500 --> 00:50.500
+porque además, siendo honestos,
+difícilmente vas a utilizar todas.
+
+00:50.500 --> 00:54.500
+Pero sí que cubrimos las más importantes 
+y quiero que te quedes con eso.
+
+00:54.500 --> 00:57.993
+Ya sabes crear tus propias funciones,
+definir tus propias funciones
+
+00:58.119 --> 01:02.500
+y también ya sabes cómo puedes tú utilizar
+las funciones que vienen
+
+01:02.500 --> 01:05.500
+en diversas bibliotecas 
+del programa de lenguaje C.
+
+01:06.023 --> 01:09.027
+Con esto dicho, te reto a que explores
+todas las bibliotecas,
+
+01:09.153 --> 01:11.500
+a que pienses, ah, ok, esto me puede
+servir para esto,
+
+01:11.500 --> 01:15.500
+esto me puede servir para lo otro 
+y que nunca pares de aprender.
+
+01:15.785 --> 01:19.500
+Obviamente nos vemos en el próximo curso
+de este Learning Path de C,
+
+01:19.500 --> 01:21.500
+en donde hablaremos 
+de estructuras de datos.
+
+01:21.710 --> 01:24.500
+Y con esto dicho, nos vemos 
+en la próxima ocasión.
+
+01:24.824 --> 01:26.500
+Gracias por haber tomado este curso,
+
+01:26.500 --> 01:30.500
+yo soy Ricardo Celis y pues nada, 
+quedo súper pendiente
+
+01:30.500 --> 01:32.500
+a cualquier duda o comentario que tengas,
+
+01:32.500 --> 01:34.500
+me encantaría si me sigues en Twitter.
+
+01:34.500 --> 01:40.200
+Nos vemos en la próxima.

subir/Curso de Funciones en C/04-Cierre/01-Lecturas recomendadas.txt

@@ -0,0 +1,2 @@
+https://twitter.com/celismx
+https://platzi.com/iot/