1
00:00:00,810 --> 00:00:04,230
Bien, vamos a continuar con nuestro ejercicio para trabajar con el ciclo while.

2
00:00:04,950 --> 00:00:09,750
Bien, del lado derecho les vamos a dejar la sintaxis para que nos estemos apoyando y sepamos qué es

3
00:00:09,750 --> 00:00:11,670
lo que vamos a escribir en nuestro ciclo while.

4
00:00:11,970 --> 00:00:16,020
Así que ya sabemos, vamos a realizar nuestro ejercicio de ciclo while.

5
00:00:16,500 --> 00:00:21,330
Recordemos que todas las palabras reservadas o también conocido como keywords en inglés, todas estas

6
00:00:21,330 --> 00:00:25,680
palabras reservadas como es la palabra while, tenemos que escribirlas en minúscula.

7
00:00:25,920 --> 00:00:30,930
Ya sabemos que el lenguaje c es un lenguaje sensible a mayúsculas y minúsculas, y todas las palabras

8
00:00:30,930 --> 00:00:32,880
reservadas están escritas en minúscula.

9
00:00:33,380 --> 00:00:37,890
Bien, así que vamos a hacer lo siguiente En este ejercicio, básicamente lo que vamos a hacer es mandar

10
00:00:37,890 --> 00:00:40,800
a imprimir los números del uno al cinco.

11
00:00:41,370 --> 00:00:48,840
Entonces, el ejercicio consiste en lo siguiente imprimir los números del uno al cinco obviamente parece

12
00:00:48,840 --> 00:00:50,160
una tarea bastante sencilla.

13
00:00:50,430 --> 00:00:55,110
Sin embargo, si fueran muchos más números, entonces ya no podríamos hacer ese tipo de impresiones

14
00:00:55,110 --> 00:00:55,920
manualmente.

15
00:00:56,100 --> 00:01:01,470
Si lo hiciéramos manualmente, simplemente tendríamos que repetir esta línea de código cinco veces.

16
00:01:01,980 --> 00:01:04,140
Vamos a mandar a imprimir el valor, por ejemplo, de uno.

17
00:01:04,560 --> 00:01:07,230
Posteriormente imprimimos el valor de dos.

18
00:01:09,200 --> 00:01:12,050
Y así sucesivamente tantas veces como necesitemos.

19
00:01:12,230 --> 00:01:18,530
Por ejemplo, en este caso vamos a mandar a imprimir todavía los valores de tres, cuatro y cinco.

20
00:01:19,760 --> 00:01:25,210
Si ejecutamos prácticamente con eso, ya tenemos la impresión del uno al cinco de nuestros números.

21
00:01:25,250 --> 00:01:27,740
Como hemos comentado, parece una tarea bastante sencilla.

22
00:01:27,920 --> 00:01:31,850
Sin embargo, qué pasa si queremos imprimir de esta misma forma bastantes más números?

23
00:01:32,000 --> 00:01:36,920
Es decir, mil números, 10.000 números, 100.000 números, etcétera Entonces, obviamente, ese tipo

24
00:01:36,920 --> 00:01:43,010
de tareas ya no sería tan sencillo, tanto programarlo de manera manual ni tampoco realizar modificaciones

25
00:01:43,010 --> 00:01:44,090
sobre ese código.

26
00:01:44,300 --> 00:01:48,800
Por lo tanto, precisamente para esto surge la necesidad del uso de ciclos en la programación.

27
00:01:49,100 --> 00:01:53,300
Así que ahora lo que vamos a hacer es que en lugar de mandar a imprimir estos números manualmente,

28
00:01:53,540 --> 00:01:59,210
vamos a utilizar una variable y esta variable la vamos a ir incrementando hasta que logremos imprimir

29
00:01:59,210 --> 00:02:00,560
todos los números deseados.

30
00:02:00,770 --> 00:02:02,510
Así que vamos a definir una variable.

31
00:02:02,840 --> 00:02:07,850
Normalmente, cuando trabajamos con ciclos, a este tipo de variables se les conoce como variables de

32
00:02:07,850 --> 00:02:13,580
tipo contador, ya que precisamente nos va a permitir contabilizar cuántas veces se está ejecutando

33
00:02:13,580 --> 00:02:14,390
nuestro ciclo.

34
00:02:14,660 --> 00:02:16,940
Así que en este caso definimos una variable.

35
00:02:17,210 --> 00:02:23,030
La variable se llama contador y también definimos una variable para saber cuántas repeticiones deseamos.

36
00:02:25,200 --> 00:02:29,850
Por ejemplo, En este caso vamos a definir nuestra variable de repeticiones con el valor de cinco.

37
00:02:30,180 --> 00:02:35,760
La variable de contador va a iniciar en uno, ya que es el primer número que queremos imprimir y queremos

38
00:02:35,760 --> 00:02:38,190
llegar hasta el límite de cinco.

39
00:02:38,730 --> 00:02:40,740
Así que si se incluye el valor de cinco.

40
00:02:42,180 --> 00:02:45,530
Así que controlamos ahora la ejecución de nuestro ciclo while.

41
00:02:46,020 --> 00:02:48,750
Vamos a utilizar la sintaxis que estamos observando.

42
00:02:49,410 --> 00:02:53,340
Tenemos la palabra reservada while y posteriormente vamos a agregar una condición.

43
00:02:53,430 --> 00:02:56,130
Recordemos que esta condición es una condición de tipo booleano.

44
00:02:56,400 --> 00:03:03,180
Así que para ello hacemos lo siguiente Vamos a preguntar si la variable de contador es menor o igual

45
00:03:03,390 --> 00:03:06,210
que el número de repeticiones que hemos indicado.

46
00:03:06,600 --> 00:03:11,760
Así que básicamente con esta condición podemos observar lo siguiente Necesitamos incrementar de alguna

47
00:03:11,760 --> 00:03:17,010
forma la variable de contador para que esta condición en algún punto del valor de falso.

48
00:03:17,280 --> 00:03:19,620
Así que las revisiones van a ser de la siguiente forma.

49
00:03:19,770 --> 00:03:25,500
Por ejemplo, si la variable de contador vale uno, vamos a preguntar la expresión seria si la variable

50
00:03:25,500 --> 00:03:29,970
de uno es menor o igual que el valor de cinco, que es el límite de repeticiones.

51
00:03:30,210 --> 00:03:37,170
Entonces, si uno es menor que cinco, regresa el valor de true, ya que uno si es menor que cinco y

52
00:03:37,170 --> 00:03:42,120
por lo tanto, mientras la expresión sea verdadera, entonces se va a ejecutar el bloque de código de

53
00:03:42,120 --> 00:03:42,930
este ciclo while.

54
00:03:43,860 --> 00:03:49,350
Así que con esto entonces vamos a buscar que de manera interna esta variable de contador se vaya incrementando.

55
00:03:49,590 --> 00:03:55,110
Vamos a hacer lo siguiente vamos a abrir nuestro bloque de código y entonces nuestro bloque de código

56
00:03:55,110 --> 00:03:56,370
va a mandar a imprimir.

57
00:03:56,850 --> 00:04:02,760
Precisamente la variable de contador es un valor de tipo entero, así que agregamos este especificados

58
00:04:02,760 --> 00:04:07,680
de formato para imprimir un valor de tipo entero y posteriormente vamos a utilizar esta variable de

59
00:04:07,680 --> 00:04:08,280
contador.

60
00:04:08,520 --> 00:04:13,590
Sin embargo, si dejamos hasta aquí nuestro código, esta variable de contador no se va a incrementar

61
00:04:13,590 --> 00:04:14,520
en ningún momento.

62
00:04:14,700 --> 00:04:16,980
Por lo tanto, vamos a caer en un ciclo infinito.

63
00:04:17,400 --> 00:04:21,750
De momento ustedes no lo ejecuten, pero yo lo voy a ejecutar para que vean en qué consiste un ciclo

64
00:04:21,750 --> 00:04:22,320
infinito.

65
00:04:22,830 --> 00:04:28,050
Y podemos observar que nuestro ciclo infinito manda a imprimir el valor de uno, que es el valor que

66
00:04:28,050 --> 00:04:29,580
siempre va a tener esta variable.

67
00:04:29,640 --> 00:04:33,120
Como no se está modificando en ningún momento dentro de nuestro ciclo.

68
00:04:33,330 --> 00:04:36,630
Entonces de manera infinita manda a imprimir este valor de uno.

69
00:04:37,080 --> 00:04:41,880
Obviamente esto no es lo deseable en la mayoría de los casos de los ciclos while hay que tener mucho

70
00:04:41,880 --> 00:04:44,640
cuidado para que no caigamos en ciclos infinitos.

71
00:04:45,120 --> 00:04:49,890
En este caso en particular, de alguna manera tenemos que incrementar esta variable para que en algún

72
00:04:49,890 --> 00:04:54,240
momento de la ejecución de nuestro código esta expresión del valor de falso.

73
00:04:54,510 --> 00:04:57,270
Ya que de lo contrario vamos a caer en un ciclo infinito.

74
00:04:57,570 --> 00:05:02,640
Así que después de mandar a imprimir nuestra variable de contador, entonces podemos utilizar el operador

75
00:05:02,970 --> 00:05:07,710
de incremento, en este caso el operador de incremento más más para que se incremente el valor de esta

76
00:05:07,710 --> 00:05:08,700
variable en uno.

77
00:05:09,300 --> 00:05:15,000
Recordemos que este operador incrementa el valor de la variable en uno.

78
00:05:15,660 --> 00:05:21,420
Ahora recordemos que podemos utilizar el operador de incremento o el operador de pos incremento.

79
00:05:21,720 --> 00:05:26,160
Sin embargo, debido a que esta variable se va a volver a utilizar hasta la siguiente vez que se haga

80
00:05:26,160 --> 00:05:31,830
esta revisión de esta condición, entonces no hay ningún problema si utilizamos el pre incremento o

81
00:05:31,830 --> 00:05:32,980
el pos incremento.

82
00:05:33,060 --> 00:05:37,560
Cualquiera de las dos opciones puede funcionar, ya que esta variable no importa si se modifica en esta

83
00:05:37,560 --> 00:05:40,800
línea de código o hasta la siguiente vez que se vuelva a utilizar.

84
00:05:41,010 --> 00:05:45,420
En este caso, debido a que estamos utilizando el incremento, se va a incrementar hasta la siguiente

85
00:05:45,420 --> 00:05:46,800
vez que la volvamos a utilizar.

86
00:05:46,950 --> 00:05:53,080
Es decir, cuando se revisa esta condición y si ponemos el incremento, entonces esta variable se incrementaría

87
00:05:53,100 --> 00:05:58,530
en esta misma línea de código, ya no tendría ningún incremento pendiente, pero debido a que esta variable

88
00:05:58,530 --> 00:06:03,150
se va a utilizar hasta que se vuelva a ejecutar esta condición, entonces no hay ningún problema.

89
00:06:03,150 --> 00:06:05,940
Podemos utilizar el pre o el pos incremento.

90
00:06:06,400 --> 00:06:08,640
Bien, con esto vamos a ejecutar de nueva cuenta.

91
00:06:09,000 --> 00:06:14,610
Ahora sí pueden ejecutarlo y podemos observar que tenemos la impresión de los números del uno al cinco,

92
00:06:14,910 --> 00:06:17,040
así que ya tenemos exactamente el mismo resultado.

93
00:06:17,220 --> 00:06:23,190
Pero obviamente, en este caso, si modificamos la cantidad de repeticiones que deseamos, por ejemplo,

94
00:06:23,190 --> 00:06:27,000
en lugar de cinco impresiones, ahora queremos 100 impresiones.

95
00:06:27,420 --> 00:06:31,740
Entonces podemos observar cómo se incrementa de manera automática la impresión de nuestra variable de

96
00:06:31,740 --> 00:06:32,340
contador.

97
00:06:32,800 --> 00:06:37,590
Bien, ahora, para que se pueda visualizar esto de mejor manera, vamos a agregar un salto de línea.

98
00:06:38,660 --> 00:06:43,250
Y entonces ahora sí podemos observar la impresión de los valores del uno al 100.

99
00:06:43,550 --> 00:06:44,930
Ese sería el último valor.

100
00:06:45,170 --> 00:06:51,500
Y también de igual manera, si queremos imprimir ahora mil números del uno al mil, tampoco tenemos

101
00:06:51,500 --> 00:06:52,190
ningún problema.

102
00:06:52,670 --> 00:06:57,530
Y entonces ésta es la razón de utilizar ciclos en la programación, en particular en la programación

103
00:06:57,530 --> 00:06:59,690
estructurada, como en el caso del lenguaje C.

104
00:07:00,500 --> 00:07:02,270
Bien, vamos a regresar aquí la impresión.

105
00:07:02,270 --> 00:07:04,220
Solamente vamos a imprimir cinco números.

106
00:07:04,370 --> 00:07:08,450
Si volvemos a imprimir, entonces ya tenemos la impresión del uno al cinco.

107
00:07:08,780 --> 00:07:13,670
Debido a que agregamos un salto de línea al inicio, tenemos un salto de línea al principio.

108
00:07:13,790 --> 00:07:15,080
Voy a ponerlo al final.

109
00:07:16,160 --> 00:07:17,270
Volvemos a ejecutar.

110
00:07:17,840 --> 00:07:20,390
Y ahora si ya tenemos la impresión del uno al cinco.

111
00:07:20,900 --> 00:07:22,040
Bien, vamos a detener hasta aquí.

112
00:07:22,040 --> 00:07:25,520
Y en el siguiente vídeo vamos a ver la ejecución paso a paso de este código.

113
00:07:25,730 --> 00:07:28,330
Eso es todo por este vídeo y continuamos en el siguiente.

114
00:07:28,340 --> 00:07:28,910
Saludos.
