1
00:00:01,640 --> 00:00:02,550
Hola y bienvenidos.

2
00:00:02,630 --> 00:00:06,910
Vamos a ver a continuación la anotación simplificada para declarar un arreglo.

3
00:00:07,040 --> 00:00:07,760
Están listos?

4
00:00:07,970 --> 00:00:08,450
Vamos.

5
00:00:10,910 --> 00:00:15,620
Bien, vamos a ver la sintaxis simplificada para el manejo de arreglos en el lenguaje C Así que en primer

6
00:00:15,620 --> 00:00:20,390
lugar, especificamos el tipo de dato, posteriormente el identificador del arreglo, el nombre del

7
00:00:20,390 --> 00:00:22,600
arreglo y posteriormente entre corchetes.

8
00:00:22,610 --> 00:00:27,470
En este caso en particular hemos comentado que es opcional indicar el tamaño del arreglo.

9
00:00:27,680 --> 00:00:30,650
Así que en esa sintaxis simplificada precisamente vamos a hacer esto.

10
00:00:30,830 --> 00:00:35,780
No vamos a especificar la cantidad de elementos que vamos a trabajar en nuestro arreglo, ya que para

11
00:00:35,780 --> 00:00:40,760
ello vamos a utilizar la sintaxis simplificada siguiente Y después del operador de igual vamos a especificar

12
00:00:40,760 --> 00:00:44,810
entre llaves cuántos elementos queremos almacenar en nuestro arreglo.

13
00:00:45,110 --> 00:00:50,960
En este caso queremos almacenar cinco elementos los valores de 100, 200 300 400 y 500.

14
00:00:51,170 --> 00:00:56,060
Así que cada elemento que queremos almacenar en nuestro arreglo lo separamos por una coma, tal como

15
00:00:56,060 --> 00:00:59,360
podemos observar, y terminamos también esta línea con punto y coma.

16
00:00:59,630 --> 00:01:04,670
Así que básicamente la diferencia es que nuestros corchetes no especificamos la cantidad de elementos,

17
00:01:04,670 --> 00:01:09,710
ya que de manera automática la cantidad de memoria que se va a reservar va a ser la cantidad de elementos

18
00:01:09,710 --> 00:01:10,760
que especificamos.

19
00:01:10,760 --> 00:01:16,460
Pero del lado derecho, los elementos que especificamos entre las llaves y cada uno de los elementos

20
00:01:16,460 --> 00:01:22,640
simplemente los separamos por una coma y así podemos agregar más o menos elementos según necesitemos.

21
00:01:22,880 --> 00:01:27,920
Sin embargo, con esa sintaxis ya tenemos que conocer los valores que vamos a utilizar desde el momento

22
00:01:27,920 --> 00:01:29,300
de la creación de nuestro arreglo.

23
00:01:29,660 --> 00:01:35,180
Y en memoria sucede lo siguiente se crea nuestro arreglo, se reserva espacio de memoria, pero además

24
00:01:35,180 --> 00:01:37,460
se van asignando cada uno de los elementos.

25
00:01:37,460 --> 00:01:40,970
Por ejemplo, en este caso, en el índice cero se asigna el valor de 100.

26
00:01:41,300 --> 00:01:44,060
En el índice uno se asigna el valor de 200.

27
00:01:44,390 --> 00:01:46,520
En el índice dos, el valor de 300.

28
00:01:46,760 --> 00:01:51,650
En el tres, el valor de 400 y en el índice cuatro el valor de 500.

29
00:01:51,860 --> 00:01:56,630
Obviamente, los valores pueden ser distintos, pero los índices del arreglo, según lo que hemos estudiado,

30
00:01:56,630 --> 00:01:57,890
comienzan en cero.

31
00:01:57,950 --> 00:02:02,090
Así que en este caso son cinco elementos, es decir, que va desde cero hasta cuatro.

32
00:02:02,450 --> 00:02:07,580
Y como hemos indicado, la diferencia también es que no se especifica la cantidad de elementos, ya

33
00:02:07,580 --> 00:02:12,080
que de manera automática el compilador sabe que según la cantidad de elementos que hemos especificado

34
00:02:12,290 --> 00:02:17,030
de este mismo tamaño, se va a crear nuestro arreglo y ya no podemos modificarlo.

35
00:02:17,030 --> 00:02:19,370
Ya no podemos agregar más elementos a nuestro arreglo.

36
00:02:19,700 --> 00:02:23,480
La cantidad de elementos reservados para este arreglo ya es una cantidad fija.

37
00:02:23,920 --> 00:02:25,790
Bien, vamos a ver entonces un ejemplo.

38
00:02:26,060 --> 00:02:27,680
Vamos a modificar este código.

39
00:02:27,860 --> 00:02:33,140
Ya sabemos que de esta forma declaramos nuestro arreglo, pero ya no lo vamos a modificar de esta forma,

40
00:02:33,380 --> 00:02:35,000
así que vamos a quitar este código.

41
00:02:35,210 --> 00:02:39,560
Recuerden que en cada elección pueden descargar el código que hemos venido trabajando para que tengan

42
00:02:39,560 --> 00:02:41,000
todo el código de cada elección.

43
00:02:41,180 --> 00:02:45,950
Así que en este caso, en esta lección, este arreglo, ya no vamos a especificar la cantidad de elementos,

44
00:02:46,190 --> 00:02:50,480
sino que ahora entre llaves vamos a especificar cada uno de los valores.

45
00:02:50,720 --> 00:02:56,360
Por ejemplo, para el primer elemento o tercero de nuestro arreglo agregamos el valor de 100 y posteriormente

46
00:02:56,360 --> 00:03:02,840
el siguiente elemento separado por una coma asignamos el valor de 200 300 400 y 500.

47
00:03:03,230 --> 00:03:08,330
Así que en este caso, desde esta primera línea tanto se crea esta variable, pero también se reserva

48
00:03:08,330 --> 00:03:11,360
espacio de memoria y además se asignan los valores.

49
00:03:11,360 --> 00:03:16,580
Por lo tanto, en memoria sucede lo siguiente Se crea nuestra variable de números es un arreglo con

50
00:03:16,580 --> 00:03:22,460
los índices de 0 a 4 y cada uno de los valores ya inicializa dos desde 100 hasta 500.

51
00:03:22,880 --> 00:03:24,790
Y entonces ejecutamos nuestro código.

52
00:03:24,800 --> 00:03:27,700
Vamos a leer los valores desde el uno hasta el cinco.

53
00:03:27,710 --> 00:03:29,810
Vamos a ir recuperando cada uno de estos valores.

54
00:03:29,990 --> 00:03:30,980
Vamos a comprobarlo.

55
00:03:31,490 --> 00:03:37,310
Así que si ejecutamos para el elemento uno de nuestro arreglo, vamos a recuperar el valor de 100.

56
00:03:37,640 --> 00:03:45,260
Así que en este caso, para el inicio cero recuperamos el valor de 100, posteriormente 200 300 400

57
00:03:45,260 --> 00:03:47,300
y finalmente el valor de 500.

58
00:03:48,490 --> 00:03:52,820
Así que podemos observar que la lectura de cada uno de los valores es exactamente igual.

59
00:03:52,870 --> 00:03:55,060
No hemos modificado para nada este código.

60
00:03:55,090 --> 00:04:00,550
Lo único que modificamos fue la definición de nuestro arreglo, ya que esta es la sintaxis simplificada.

61
00:04:03,360 --> 00:04:03,600
Bien.

62
00:04:03,600 --> 00:04:08,700
Ahora, qué sucede si queremos acceder, por ejemplo, a un elemento que no está definido en nuestro

63
00:04:08,700 --> 00:04:09,120
arreglo?

64
00:04:09,300 --> 00:04:11,040
Por ejemplo, a 1/6 elemento.

65
00:04:11,580 --> 00:04:12,870
Vamos a ver qué es lo que sucede.

66
00:04:13,350 --> 00:04:15,660
Sería el 5.º índice de nuestro arreglo.

67
00:04:15,870 --> 00:04:21,180
Pero nosotros ya no hemos reservado espacio de memoria para este elemento, así que si ejecutamos,

68
00:04:21,450 --> 00:04:26,490
podemos ver que en este caso, aunque no marca un error, este 5.º elemento ya no existe en nuestro

69
00:04:26,490 --> 00:04:26,880
arreglo.

70
00:04:27,090 --> 00:04:31,020
Ya no hemos reservado espacio de memoria y por lo tanto regresa información basura.

71
00:04:31,260 --> 00:04:36,150
Así que tenemos que tener cuidado cuántos elementos recorremos en nuestro arreglo, ya que si recorremos

72
00:04:36,150 --> 00:04:40,320
más elementos no va a marcar error, simplemente va a regresar información basura.

73
00:04:40,740 --> 00:04:45,810
Pero lo que sí podemos hacer todavía es modificar los valores, así que si queremos modificarlos.

74
00:04:47,380 --> 00:04:50,050
Sería exactamente igual que la lección que vimos anteriormente.

75
00:04:50,380 --> 00:04:55,210
Vamos a acceder, por ejemplo, al índice cero y vamos a asignarle en lugar del valor de 100.

76
00:04:55,450 --> 00:04:57,820
Asignamos, por ejemplo, el valor de 120.

77
00:04:58,360 --> 00:05:04,240
Vamos a ejecutar y podemos observar que ya se ha modificado el valor al valor de 120.

78
00:05:04,480 --> 00:05:07,540
Así que todavía podríamos modificar los valores sin ningún problema.

79
00:05:07,750 --> 00:05:09,870
Eso solamente son los valores iniciales.

80
00:05:09,910 --> 00:05:14,800
Pero una vez que continúa nuestro programa, entonces podríamos modificar el valor de nuestro arreglo

81
00:05:14,800 --> 00:05:17,230
simplemente indicando el inicio que queremos modificar.

82
00:05:17,500 --> 00:05:18,580
Y la lectura no cambia.

83
00:05:18,580 --> 00:05:21,370
Es exactamente igual que lo que vimos en la lección anterior.

84
00:05:22,000 --> 00:05:24,270
Así que básicamente esta es la sintaxis simplificada.

85
00:05:24,280 --> 00:05:26,650
Ponlo en práctica y nos vemos en el siguiente video.

86
00:05:26,830 --> 00:05:27,400
Saludos.
