Upload batch from C CLI

Uploaded via hf-downloader C client

.gitattributes

@@ -181,3 +181,25 @@ subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript
 subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/05-Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/02-Creación[[:space:]]y[[:space:]]Manipulación[[:space:]]de[[:space:]]Objetos[[:space:]]en[[:space:]]JavaScript.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/05-Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/03-Función[[:space:]]constructora[[:space:]]y[[:space:]]gestión[[:space:]]de[[:space:]]instancias[[:space:]]en[[:space:]]JavaScript.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/05-Programación[[:space:]]Orientada[[:space:]]a[[:space:]]Objetos/04-Clases[[:space:]]en[[:space:]]JavaScript[[:space:]]Creación[[:space:]]y[[:space:]]Uso[[:space:]]de[[:space:]]Objetos[[:space:]]con[[:space:]]Sintaxis[[:space:]]Moderna.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C/05-Cierre/02-Estructuras[[:space:]]de[[:space:]]Control[[:space:]]de[[:space:]]Flujo[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/01-Introducción[[:space:]]a[[:space:]]las[[:space:]]funciones[[:space:]]en[[:space:]]C/01-Funciones[[:space:]]en[[:space:]]C[[:space:]]Declaración[[:space:]]y[[:space:]]Uso[[:space:]]Práctico.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/01-Introducción[[:space:]]a[[:space:]]las[[:space:]]funciones[[:space:]]en[[:space:]]C/02-Funciones[[:space:]]en[[:space:]]C[[:space:]]Creación[[:space:]]y[[:space:]]Uso[[:space:]]para[[:space:]]Potencias[[:space:]]de[[:space:]]Enteros.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/01-Introducción[[:space:]]a[[:space:]]las[[:space:]]funciones[[:space:]]en[[:space:]]C/03-Creación[[:space:]]y[[:space:]]uso[[:space:]]de[[:space:]]funciones[[:space:]]en[[:space:]]lenguaje[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/01-Introducción[[:space:]]a[[:space:]]las[[:space:]]funciones[[:space:]]en[[:space:]]C/04-Tipos[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C[[:space:]]Argumentos[[:space:]]y[[:space:]]Valores[[:space:]]de[[:space:]]Retorno.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/02-Manejo[[:space:]]de[[:space:]]funciones[[:space:]]en[[:space:]]C/01-Funciones[[:space:]]en[[:space:]]C[[:space:]]Uso[[:space:]]de[[:space:]]void[[:space:]]y[[:space:]]manejo[[:space:]]de[[:space:]]return[[:space:]]types.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Funciones[[:space:]]en[[:space:]]C/02-Manejo[[:space:]]de[[:space:]]funciones[[:space:]]en[[:space:]]C/02-Paso[[:space:]]de[[:space:]]Argumentos[[:space:]]por[[:space:]]Valor[[:space:]]en[[:space:]]C[[:space:]]Conceptos[[:space:]]y[[:space:]]Ejemplos[[:space:]]Prácticos.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/01-Bibliotecas[[:space:]]estándar[[:space:]]del[[:space:]]lenguaje[[:space:]]C[[:space:]]y[[:space:]]sus[[:space:]]funciones[[:space:]]principales.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/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 Control de Flujo en C/05-Cierre/02-Estructuras de Control de Flujo en C.mp4

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

subir/Curso de Control de Flujo en C/05-Cierre/02-Estructuras de Control de Flujo en C.vtt

@@ -0,0 +1,248 @@
+WEBVTT
+
+00:03.580 --> 00:06.801
+¡Hey! Hemos llegado al final
+de nuestro curso de C,
+
+00:06.927 --> 00:10.909
+en donde nos enfocamos
+en las estructuras de control de flujo.
+
+00:11.035 --> 00:14.339
+Recuerda que esta serie de cursos
+que estás tomando del lenguaje C
+
+00:14.465 --> 00:18.074
+existen para que tal cual aprendas
+el lenguaje.
+
+00:18.200 --> 00:22.600
+Más adelante se viene el curso
+de estructuras de datos,
+
+00:22.600 --> 00:24.365
+en donde hablaremos de los arrays,
+
+00:24.491 --> 00:27.334
+hablaremos de otros elementos
+específicos de C,
+
+00:27.460 --> 00:29.865
+como por ejemplo la instrucción struct,
+
+00:30.025 --> 00:32.916
+y vamos a aprender muchísimo más
+de este lenguaje.
+
+00:33.042 --> 00:36.480
+También más adelante viene el curso
+de funciones en C,
+
+00:36.639 --> 00:39.200
+de hecho ese es el siguiente curso
+a este que acabamos de grabar.
+
+00:39.342 --> 00:41.760
+Ahí vamos a entender todo
+sobre el manejo de funciones
+
+00:41.760 --> 00:43.597
+en este maravilloso lenguaje,
+
+00:43.723 --> 00:48.085
+y con esto vamos a ir logrando dominar
+este lenguaje poco a poco.
+
+00:48.391 --> 00:50.440
+Cuéntame en los comentarios
+qué te están pareciendo
+
+00:50.440 --> 00:52.640
+estos cursos súper cortos y enfocados.
+
+00:52.858 --> 00:55.640
+A mí me encantan porque, o sea,
+yo como programador,
+
+00:55.848 --> 00:59.320
+me encantaba tener lugares de referencia
+a algo específico,
+
+00:59.607 --> 01:02.320
+y justo eso es lo que te estamos dando
+en este tipo de cursos.
+
+01:02.651 --> 01:06.781
+Si tienes dudas de cómo funciona el IF,
+el WHILE, el DO, etc.,
+
+01:06.907 --> 01:09.252
+pues simplemente te vienes a este curso,
+
+01:09.378 --> 01:11.682
+tomas las clases que necesitas y repasas,
+
+01:11.808 --> 01:15.421
+no te tienes que preocupar además
+de que haces el examen
+
+01:15.547 --> 01:18.365
+de solamente las partes
+de control de flujo.
+
+01:18.491 --> 01:21.828
+Con esto garantizamos que estás
+aprendiendo algo bien,
+
+01:21.954 --> 01:23.430
+estás aprendiendo algo a fondo,
+
+01:23.556 --> 01:26.666
+en cada parte de los cursos
+del lenguaje C.
+
+01:26.926 --> 01:29.717
+Yo soy Ricardo Celis,
+fui tu profesor en este curso,
+
+01:29.843 --> 01:32.341
+seguiré siendo tu profesor
+en el resto de cursos de C,
+
+01:32.467 --> 01:34.420
+estoy muy emocionado por verte allá.
+
+01:34.546 --> 01:36.892
+La verdad es que C es un lenguaje
+maravilloso
+
+01:37.018 --> 01:42.418
+y obviamente luego cuando termines todos
+estos cursos del lenguaje C,
+
+01:42.544 --> 01:44.777
+vas a tener un mundo de posibilidades
+para hacer.
+
+01:44.903 --> 01:47.474
+De hecho, una vez termines
+estos cursos de C,
+
+01:47.600 --> 01:49.984
+sería genial que me alcanzaras
+en los cursos de Arduino,
+
+01:50.110 --> 01:51.761
+en cursos de microcontroladores,
+
+01:51.887 --> 01:54.367
+y por qué no, cuéntame si te gustaría
+aprender robótica
+
+01:54.493 --> 01:58.135
+para que hagamos cursos de eso,
+si vemos que hay suficiente interés
+
+01:58.261 --> 02:01.360
+de parte de todas
+y todos nuestros estudiantes.
+
+02:01.609 --> 02:04.080
+Como siempre,
+te invito a que tomes el examen,
+
+02:04.080 --> 02:05.520
+a que repases mucho,
+
+02:05.520 --> 02:07.520
+recuerda que estos cursos de lenguajes
+
+02:07.520 --> 02:09.080
+que estamos haciendo ahora en Platzi,
+
+02:09.318 --> 02:11.640
+existen para que los uses
+como una referencia,
+
+02:12.002 --> 02:13.680
+tanto para cuando aprendas
+el lenguaje
+
+02:13.680 --> 02:16.680
+como para cuando quieras aplicarlo
+o tengas dudas.
+
+02:16.940 --> 02:19.560
+Recuerda que tienes que tomar
+toda nuestra carrera
+
+02:19.560 --> 02:20.760
+de Computer Science,
+
+02:20.760 --> 02:24.440
+en donde ya aprendes más las bases
+de la computación,
+
+02:24.440 --> 02:27.720
+tenemos los cursos de pensamiento
+computacional con Python,
+
+02:27.720 --> 02:30.640
+es una serie de cuatro cursos
+que son excelentes
+
+02:30.640 --> 02:34.760
+y son los primeritos en nuestra ruta
+de Computer Science
+
+02:34.760 --> 02:36.400
+que justamente existen
+
+02:36.400 --> 02:40.360
+para que puedas tener la capacidad
+de ser una persona
+
+02:40.360 --> 02:43.000
+que no tiene que aprender
+a hacer cosas puntuales
+
+02:43.000 --> 02:44.080
+y seguir tutoriales,
+
+02:44.080 --> 02:47.000
+sino que seas una persona que domina
+varios lenguajes,
+
+02:47.000 --> 02:49.120
+entiende cómo funciona la computación,
+
+02:49.120 --> 02:51.120
+sabe programar no importa qué
+
+02:51.120 --> 02:53.120
+y eso te va a separar del resto.
+
+02:53.447 --> 02:55.827
+Estoy muy feliz de que hayas terminado
+este curso,
+
+02:55.953 --> 02:59.000
+recuerda mi Twitter es @CelisMx,
+
+02:59.000 --> 03:01.600
+ahí me puedes presumir tu diploma
+cuando lo termines,
+
+03:01.840 --> 03:04.440
+a mí me encantará darle un like,
+un retweet, etcétera.
+
+03:04.657 --> 03:06.360
+También si llegas a tener dudas,
+
+03:06.360 --> 03:08.714
+mándame un tweet,
+yo feliz de la vida te ayudo
+
+03:08.993 --> 03:14.840
+y sin más, nos vemos en el próximo curso.

subir/Curso de Control de Flujo en C/05-Cierre/02-Lecturas recomendadas.txt

@@ -0,0 +1,4 @@
+https://platzi.com/clases/python-cs/
+https://platzi.com/clases/poo-python/
+https://platzi.com/clases/programacion-estocastica/
+https://platzi.com/clases/probabilistica/

subir/Curso de Funciones en C/01-Introducción a las funciones en C/01-Funciones en C Declaración y Uso Práctico.mp4

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

subir/Curso de Funciones en C/01-Introducción a las funciones en C/01-Funciones en C Declaración y Uso Práctico.vtt

@@ -0,0 +1,166 @@
+WEBVTT
+
+00:02.893 --> 00:05.324
+¡Hey! Hola, bienvenida o bienvenido
+
+00:05.450 --> 00:07.999
+a este nuevo curso de programación en C.
+
+00:08.125 --> 00:09.958
+Recuerda que este es el tercer curso
+
+00:10.083 --> 00:12.280
+de la ruta de cursos 
+de este increíble lenguaje
+
+00:12.280 --> 00:16.280
+que estoy haciendo para ti aquí en Platzi
+y que espero que vayas tomando y que vayas
+
+00:16.280 --> 00:17.940
+aprendiendo muchísimo.
+
+00:18.066 --> 00:20.681
+La idea de dividir 
+los lenguajes de programación
+
+00:20.807 --> 00:23.785
+en varios cursos cortos 
+es que sea mucho más eficiente
+
+00:23.910 --> 00:25.975
+para ti el proceso de aprendizaje,
+
+00:26.101 --> 00:29.158
+de que vayas obteniendo
+pequeños logros,
+
+00:29.283 --> 00:31.840
+como es en este caso 
+con el curso de introducción a C.
+
+00:31.840 --> 00:34.342
+Obtienes tu diploma,
+obtienes conocimiento importantísimo,
+
+00:34.468 --> 00:35.674
+te va quedando todo claro.
+
+00:35.800 --> 00:39.399
+Luego te pasas al curso
+de estructuras de control de flujo en C,
+
+00:39.525 --> 00:41.840
+en donde pues,
+como su nombre lo dice,
+
+00:41.840 --> 00:44.888
+hablamos de if, while, for, de todo eso.
+
+00:45.014 --> 00:48.520
+También hablamos de continue,
+de break y de más sentencias
+
+00:48.520 --> 00:51.087
+que te van a servir para
+darle mucho dinamismo
+
+00:51.212 --> 00:53.720
+a tu programa 
+y que haga lo que tú quieras.
+
+00:53.720 --> 00:56.158
+En este tercer curso
+te voy a explicar todo
+
+00:56.283 --> 00:57.530
+sobre las funciones en C.
+
+00:57.656 --> 01:00.932
+Vamos a entender cómo
+puedes declarar tus propias funciones,
+
+01:01.057 --> 01:03.600
+cómo les puedes
+pasar valores y obviamente
+
+01:03.600 --> 01:08.220
+vamos a explorar algunas de las funciones
+más utilizadas que de hecho
+
+01:08.220 --> 01:09.823
+tienen que ver con la manipulación 
+de strings
+
+01:09.949 --> 01:15.200
+para hacer un par de ejemplos
+de cómo puedes utilizarlas en tus códigos.
+
+01:15.326 --> 01:19.320
+Recuerda que este no es el final, 
+tenemos más temas de C que abordar,
+
+01:19.320 --> 01:22.113
+así que bueno, bienvenido a este curso 
+en donde ya,
+
+01:22.239 --> 01:24.028
+ como te conté, aprenderás todo
+
+01:24.154 --> 01:28.360
+respecto a las funciones y espero 
+que me vayas contando qué te han parecido
+
+01:28.360 --> 01:31.285
+los cursos anteriores 
+y quiero darte un pequeño,
+
+01:31.410 --> 01:34.080
+como una pequeña explicación sobre por qué
+
+01:34.080 --> 01:38.978
+estamos haciendo esto y es que descubrimos
+que es mucho más eficiente
+
+01:39.104 --> 01:42.282
+que aprendas los lenguajes
+de programación de forma segmentada.
+
+01:42.408 --> 01:45.892
+Así no te damos un curso larguísimo,
+muy difícil de consumir,
+
+01:46.018 --> 01:49.080
+que puede que no lo logres 
+y puede que lo dejes a medias
+
+01:49.080 --> 01:52.345
+o que lo dejes en el principio 
+y simplemente te desmotive.
+
+01:52.471 --> 01:56.206
+Aquí te estamos dando varios
+cursos súper cortos y enfocados,
+
+01:56.332 --> 01:59.120
+cada uno de ellos te da un
+diploma que obtienes y que puedes
+
+01:59.120 --> 02:01.451
+descargarte y presumir 
+en todas tus redes sociales
+
+02:01.576 --> 02:04.140
+y también son materiales de consulta
+
+02:04.140 --> 02:06.681
+una vez ya aprendes el
+lenguaje y es que puedes
+
+02:06.806 --> 02:10.253
+regresar a tomarlos cuantas veces quieras 
+con tu suscripción.
+
+02:10.379 --> 02:14.140
+Con esto dicho, ¿qué estás esperando? 
+¡Comencemos este curso!

subir/Curso de Funciones en C/01-Introducción a las funciones en C/01-Lecturas recomendadas.txt

@@ -0,0 +1,2 @@
+https://platzi.com/clases/lenguaje-c/
+https://platzi.com/clases/flujo-c-2020/