1
00:00:00,920 --> 00:00:01,800
Hola y bienvenidos.

2
00:00:01,820 --> 00:00:06,200
Vamos a ver a continuación un ejemplo para combinar cadenas y el uso de funciones.

3
00:00:06,200 --> 00:00:07,070
Están listas?

4
00:00:07,100 --> 00:00:07,550
Vamos.

5
00:00:08,470 --> 00:00:08,650
Bien.

6
00:00:08,650 --> 00:00:11,290
De manera similar a lo que ya vimos con el manejo de arreglos.

7
00:00:11,530 --> 00:00:16,360
Este arreglo que hemos definido es de tipo entero, pero recordemos que también para manejar cadenas,

8
00:00:16,570 --> 00:00:19,330
entonces vamos a definir un arreglo pero de tipo char.

9
00:00:19,450 --> 00:00:24,130
Así que vamos a hacer algunos cambios en nuestro código para mandar a imprimir un mensaje que le vamos

10
00:00:24,130 --> 00:00:28,930
a solicitar al usuario y una vez que proporcione el usuario el mensaje que quiere mandar a imprimir,

11
00:00:28,930 --> 00:00:33,430
vamos a pasar este arreglo de caracteres a nuestra función para mandar a imprimir el mensaje.

12
00:00:33,430 --> 00:00:37,270
Pero desde la función bien definimos una cadena.

13
00:00:37,690 --> 00:00:42,970
En este caso vamos a reutilizar varias cosas, pero el tipo de dato que vamos a utilizar ahora es de

14
00:00:42,970 --> 00:00:46,330
tipo char, ya que vamos a almacenar únicamente cadenas de caracteres.

15
00:00:46,690 --> 00:00:51,400
Sin embargo, no lo vamos a inicializar, ya que el valor le va a proporcionar directamente el usuario.

16
00:00:51,670 --> 00:00:55,270
Así que vamos a indicar que este arreglo va almacenar cinco caracteres.

17
00:00:55,600 --> 00:01:00,040
Así es como vamos en primer lugar a definir nuestro arreglo y posteriormente vamos a asignar el valor

18
00:01:00,040 --> 00:01:01,030
de manera dinámica.

19
00:01:01,330 --> 00:01:03,070
Así que le pedimos al usuario.

20
00:01:04,120 --> 00:01:04,870
Proporciona.

21
00:01:06,710 --> 00:01:08,270
El mensaje a mostrar.

22
00:01:09,330 --> 00:01:13,350
Damos un salto de línea al final para que el mensaje se muestre en una nueva línea.

23
00:01:14,040 --> 00:01:14,730
Posteriormente.

24
00:01:14,730 --> 00:01:16,320
Utilizando la función de gets.

25
00:01:17,350 --> 00:01:20,410
Leemos la línea y lo almacenamos en la variable.

26
00:01:20,650 --> 00:01:24,490
En ese caso de argumento, esta es la cadena que estamos definiendo.

27
00:01:24,640 --> 00:01:26,620
Voy a cambiar el nombre de esta variable.

28
00:01:26,800 --> 00:01:28,480
Le voy a llamar simplemente cadena.

29
00:01:29,710 --> 00:01:29,920
Bien.

30
00:01:29,950 --> 00:01:35,050
Así que con este código ya estamos leyendo la cadena del usuario que está proporcionando y posteriormente

31
00:01:35,050 --> 00:01:40,270
lo que vamos a hacer es definir una función para mandar a imprimir el mensaje, pero desde la función.

32
00:01:40,540 --> 00:01:47,590
Así que voy a quitar este código y la función que vamos a crear se va a llamar Imprimir mensaje y el

33
00:01:47,590 --> 00:01:51,430
mensaje que vamos a enviar a la función es la cadena que ha proporcionado el usuario.

34
00:01:51,670 --> 00:01:55,340
Así que con esto ya estamos definiendo todo nuestro código del método principal.

35
00:01:55,450 --> 00:01:57,210
Ahora vamos a modificar nuestra función.

36
00:01:57,220 --> 00:02:00,370
La función no va a regresar nada, se va a llamar imprimir mensaje.

37
00:02:01,360 --> 00:02:06,700
Pero recordemos que ahora el apuntador debe de ser del mismo tipo de la variable a la cual va a apuntar.

38
00:02:06,850 --> 00:02:11,020
Así que en este caso este apuntador va a apuntar a elementos de tipo char.

39
00:02:11,290 --> 00:02:16,060
Recordemos que en este caso, al ser una cadena, vamos a recibir la dirección de memoria del primer

40
00:02:16,060 --> 00:02:20,830
carácter de nuestro arreglo, ya que es un arreglo, pero a su vez una cadena de caracteres.

41
00:02:20,830 --> 00:02:25,000
Por lo tanto, ese apuntador solamente va a apuntar al primer carácter de nuestro arreglo.

42
00:02:25,210 --> 00:02:27,280
Pero por ello tiene que ser de tipo char.

43
00:02:27,640 --> 00:02:32,560
Bien, básicamente con esto ya vamos a recibir la referencia de memoria y con esta referencia ya podemos

44
00:02:32,560 --> 00:02:34,840
mandar a imprimir el mensaje que vamos a recibir.

45
00:02:35,080 --> 00:02:36,160
Así que imprimimos.

46
00:02:37,160 --> 00:02:37,790
El mensaje.

47
00:02:39,930 --> 00:02:43,170
Van a mandar a imprimir una cadena, simplemente mandamos a imprimirlo.

48
00:02:44,100 --> 00:02:50,790
Ya sabemos que utilizamos porcentaje ese, ya que es un arreglo de caracteres y posteriormente proporcionamos

49
00:02:51,780 --> 00:02:53,730
la variable que contiene nuestra cadena.

50
00:02:53,970 --> 00:02:56,160
En este caso recordemos que este es nuestro apuntador.

51
00:02:56,430 --> 00:03:01,410
Ahora, en este caso voy a renombrar esta variable para que se llame mensaje, para que sea un poco

52
00:03:01,410 --> 00:03:05,940
más explícito que este apuntador contiene el mensaje que queremos imprimir.

53
00:03:06,110 --> 00:03:11,010
Bien, básicamente con esto ya tenemos todo nuestro código, vamos a ejecutar y entonces tenemos proporciona

54
00:03:11,010 --> 00:03:12,270
el mensaje a mostrar.

55
00:03:13,140 --> 00:03:13,830
Saludos.

56
00:03:14,040 --> 00:03:19,200
Damos enter y entonces observamos que se manda a imprimir el mensaje dos puntos y posteriormente el

57
00:03:19,200 --> 00:03:22,440
mensaje que ha proporcionado el usuario la cadena de saludos.

58
00:03:22,770 --> 00:03:27,600
Si volvemos a ejecutar, proporciona el mensaje a mostrar por ejemplo mi nombre Osvaldo Acosta.

59
00:03:27,870 --> 00:03:29,520
Doy enter y sin ningún problema.

60
00:03:29,520 --> 00:03:33,750
También se manda a imprimir el mensaje, incluso aunque tenga espacios en blanco, ya que recordemos

61
00:03:33,750 --> 00:03:37,380
que la función GET precisamente permite leer líneas completas de la consola.

62
00:03:37,890 --> 00:03:42,030
Así que con esto ya estamos mandando a imprimir el mensaje que está proporcionando el usuario.

63
00:03:42,210 --> 00:03:47,430
Sin embargo, aquí podemos utilizar dos Sintaxis Esta es la primera sintaxis de nuestra función, pero

64
00:03:47,430 --> 00:03:49,530
también podríamos utilizar la siguiente sintaxis.

65
00:03:49,770 --> 00:03:55,140
Recordemos que a final de cuentas vamos a recibir la referencia de un arreglo, así que vamos a definir

66
00:03:55,140 --> 00:03:55,770
un arreglo.

67
00:03:56,220 --> 00:03:57,330
Esta sería la sintaxis.

68
00:03:57,330 --> 00:04:02,730
En lugar de utilizar un apuntador, estamos definiendo que vamos a recibir una referencia de un arreglo,

69
00:04:03,000 --> 00:04:08,280
así que también podemos utilizar esta sintaxis, aunque es más flexible y sobre todo más poderoso el

70
00:04:08,280 --> 00:04:09,270
uso de apuntadores.

71
00:04:09,390 --> 00:04:13,500
Pero si manejamos únicamente cadenas de caracteres, esa también puede ser otra opción.

72
00:04:13,710 --> 00:04:18,210
Aunque la más común, como hemos comentado, es el uso de apuntadores, ya que esto puede apuntar no

73
00:04:18,210 --> 00:04:21,960
solamente a cadenas de caracteres, sino a cualquier tipo de dirección de memoria.

74
00:04:22,260 --> 00:04:24,000
Bien, vamos a ejecutar para comprobar.

75
00:04:24,270 --> 00:04:25,770
Proporciona el mensaje a mostrar.

76
00:04:25,770 --> 00:04:29,790
Proporcionamos la cadena de audios, damos enter y observamos que también sigue funcionando nuestro

77
00:04:29,790 --> 00:04:31,350
programa sin ningún problema.

78
00:04:31,770 --> 00:04:36,840
Así que les vamos a dejar las dos sintaxis, pero recordando que la sintaxis más común es el uso de

79
00:04:36,840 --> 00:04:42,720
apuntadores, así que por ello dejo activada la línea donde estamos utilizando la variable de tipo apuntador

80
00:04:43,290 --> 00:04:46,800
y si ejecutamos paso a paso se ejecuta nuestro método principal.

81
00:04:47,100 --> 00:04:51,810
En la línea 11 se crea nuestra variable de cadena, la cual contiene cinco elementos.

82
00:04:51,810 --> 00:04:56,580
Se está reservando espacio de memoria para cinco elementos y podemos saber que todos los elementos son

83
00:04:56,580 --> 00:04:57,240
de tipo char.

84
00:04:57,420 --> 00:05:02,160
Posteriormente pedimos proporcionar el mensaje y por ejemplo proporcionamos la cadena de hola.

85
00:05:02,580 --> 00:05:07,980
Una vez que leemos el mensaje, entonces cada uno de estos caracteres se almacena en cada uno de los

86
00:05:07,980 --> 00:05:13,380
índices de nuestro arreglo, incluyendo el carácter de fin de cadena que se almacena en el índice cuatro.

87
00:05:13,850 --> 00:05:18,460
Bien, así que con esto ya tenemos nuestra variable de cadena en memoria y posteriormente se manda llamar

88
00:05:18,460 --> 00:05:20,010
a la función de imprimir mensaje.

89
00:05:20,250 --> 00:05:24,090
Así que básicamente aquí lo que vamos a hacer es pasar la referencia de nuestro arreglo.

90
00:05:24,300 --> 00:05:30,390
Lo vamos a pasar a nuestra función de imprimir mensaje, así que para ello se crea lo siguiente en memoria

91
00:05:30,390 --> 00:05:34,770
se van a llamar nuestra función de imprimir mensaje y se crea nuestra variable apuntador.

92
00:05:35,010 --> 00:05:39,540
Podemos ver en este caso que el tipo de dato tiene que ser exactamente igual a cada uno de los elementos

93
00:05:39,540 --> 00:05:40,530
que vamos a apuntar.

94
00:05:40,530 --> 00:05:46,170
Por ello, esta variable de mensaje es un apuntador a elementos de tipo carácter, ya que vamos a almacenar

95
00:05:46,170 --> 00:05:49,080
la referencia, en este caso del primer elemento de nuestro arreglo.

96
00:05:49,320 --> 00:05:50,280
Vamos a comprobarlo.

97
00:05:50,580 --> 00:05:55,440
Si se inicializa nuestra variable de mensaje, podemos ver que tenemos la referencia únicamente del

98
00:05:55,440 --> 00:05:59,340
primer elemento de nuestro arreglo, pero con eso es suficiente para inicializar nuestra variable de

99
00:05:59,340 --> 00:06:00,090
apuntador.

100
00:06:00,090 --> 00:06:04,920
Y entonces en la línea seis, al mandar imprimir la variable de mensaje, lo que sucede es que como

101
00:06:04,920 --> 00:06:09,150
es una cadena, entonces se manda a imprimir toda la cadena, así que se ejecutamos.

102
00:06:09,150 --> 00:06:14,700
Entonces se muestra en la cadena de Hola, ya que con esta sintaxis, al ser un apuntador estamos accediendo

103
00:06:14,700 --> 00:06:19,230
al primer elemento de nuestro arreglo, pero también al ser una cadena, entonces se manda a imprimir

104
00:06:19,230 --> 00:06:22,650
toda la cadena hasta que encontremos el carácter de fin de cadena.

105
00:06:22,800 --> 00:06:27,390
Por ello es que en este caso se imprime la cadena completa de Hola y de esta manera podemos observar

106
00:06:27,390 --> 00:06:30,180
que ya no hay necesidad de recorrer cada uno de los índices.

107
00:06:30,180 --> 00:06:35,430
Simplemente al ser una cadena a la que estamos apuntando y se imprime hasta el carácter de fin de cadena.

108
00:06:36,210 --> 00:06:37,620
Básicamente este es el ejemplo.

109
00:06:37,620 --> 00:06:42,690
Podemos observar que es el mismo uso de paso por referencia, pero ya lo estamos combinando ahora con

110
00:06:42,690 --> 00:06:45,660
un arreglo de caracteres, es decir, pasando a una cadena.

111
00:06:45,840 --> 00:06:49,140
Bien, pongan en práctica lo que hemos visto y continuamos en la siguiente lección.

112
00:06:49,290 --> 00:06:49,860
Saludos.
