1
00:00:00,870 --> 00:00:01,750
Hola y bienvenidos.

2
00:00:01,800 --> 00:00:06,630
Vamos a comentar algunos temas más del manejo de cadenas y también cuando trabajamos con funciones en

3
00:00:06,630 --> 00:00:07,290
el lenguaje C.

4
00:00:08,500 --> 00:00:08,710
Bien.

5
00:00:08,710 --> 00:00:13,900
Un primer detalle que quiero comentarles antes de cerrar con este tema es que el manejo de cadenas también

6
00:00:13,900 --> 00:00:18,490
lo podemos definir de otras formas, precisamente aprovechando la sintaxis de apuntadores que ya hemos

7
00:00:18,490 --> 00:00:23,530
comentado anteriormente, en lugar de definir nuestra cadena de esta forma, tal como lo vimos en la

8
00:00:23,530 --> 00:00:27,790
definición de la función, también podríamos utilizar la sintaxis de apuntadores.

9
00:00:28,090 --> 00:00:33,730
Así que en este caso voy a poner esta definición entre comentarios y ahora vamos a utilizar la sintaxis

10
00:00:33,730 --> 00:00:35,650
como si trabajáramos con apuntadores.

11
00:00:35,920 --> 00:00:41,890
Así que voy a poner un apuntador de tipo char y se va a llamar cadena y posteriormente le puedo asignar

12
00:00:41,890 --> 00:00:42,400
una cadena.

13
00:00:42,400 --> 00:00:45,670
En este caso, por ejemplo, el valor de la cadena de Hola.

14
00:00:46,090 --> 00:00:49,990
En este caso no le estoy pidiendo al usuario que proporcione esta información, simplemente estoy poniendo

15
00:00:49,990 --> 00:00:51,310
una cadena en código duro.

16
00:00:51,520 --> 00:00:56,560
Sin embargo, si inicializamos nuestra cadena de esta forma, entonces ya no la podemos modificar dinámicamente.

17
00:00:56,770 --> 00:00:58,390
De momento, voy a quitar este código.

18
00:00:58,570 --> 00:01:01,690
Voy a dejar solamente la definición de la cadena en código duro.

19
00:01:01,990 --> 00:01:06,460
Ahora, si ejecutamos, podemos observar que se imprime mensaje.

20
00:01:06,460 --> 00:01:06,850
Hola.

21
00:01:07,090 --> 00:01:12,850
Esto quiere decir que se está creando correctamente en nuestra cadena y posteriormente se pasa la referencia

22
00:01:12,850 --> 00:01:13,810
a nuestra función.

23
00:01:14,170 --> 00:01:19,180
A su vez, esta variable apunta exactamente al mismo arreglo de caracteres y finalmente se imprime la

24
00:01:19,180 --> 00:01:24,340
cadena de hola y en memoria lo que sucede es lo siguiente Se crea en primer lugar nuestra cadena de

25
00:01:24,340 --> 00:01:24,640
hola.

26
00:01:24,880 --> 00:01:29,290
Sin embargo, al utilizar la sintaxis de apuntadores, podemos saber que se declara nuestra variable

27
00:01:29,290 --> 00:01:32,020
de cadena, que es un apuntador a un tipo carácter.

28
00:01:32,320 --> 00:01:36,700
Entonces, cuando definimos nuestra cadena de esta forma podemos observar que nuestro arreglo se crea

29
00:01:36,700 --> 00:01:38,410
en una zona de memoria diferente.

30
00:01:38,440 --> 00:01:40,390
Precisamente al utilizar esta sintaxis.

31
00:01:40,570 --> 00:01:44,960
Entonces esta cadena se crea en una zona de memoria que se conoce como de solo lectura.

32
00:01:45,040 --> 00:01:49,090
Por ello es que tenemos el mensaje que esta memoria es de solo lectura.

33
00:01:49,480 --> 00:01:54,010
Por lo tanto ya no podemos hacer modificaciones, como en el caso del ejemplo que vimos cuando trabajamos

34
00:01:54,010 --> 00:01:56,620
con valores de tipo entero y el manejo de arreglos.

35
00:01:56,770 --> 00:02:02,590
En este caso ya no podemos modificar estos caracteres ya que estamos en una zona de solo lectura y por

36
00:02:02,590 --> 00:02:08,050
ello, si por alguna razón dentro de nuestra función queremos hacer algún cambio, por ejemplo, si

37
00:02:08,050 --> 00:02:13,420
después de mandar a imprimir el mensaje quisiéramos utilizar la sintaxis de arreglos y cambiar, por

38
00:02:13,420 --> 00:02:19,960
ejemplo el índice cero en lugar de una hache mayúscula, ahora con una hache minúscula, podemos observar

39
00:02:19,960 --> 00:02:24,490
que aunque el mensaje se imprime correctamente, nuestro programa no termina con el código cero.

40
00:02:24,730 --> 00:02:28,990
Así que nuestro programa termina de manera errónea y nos manda este código con el que terminó nuestro

41
00:02:28,990 --> 00:02:29,530
programa.

42
00:02:29,530 --> 00:02:35,170
Pero es un código erróneo debido a que no podemos realizar cambios si es que inicializamos nuestra cadena

43
00:02:35,170 --> 00:02:37,840
de esta forma con la sintaxis de apuntadores.

44
00:02:38,050 --> 00:02:43,600
Así que podemos utilizar esta sintaxis para trabajar con cadenas, pero debemos de saber que en memoria

45
00:02:43,600 --> 00:02:46,990
ya no podríamos realizar cambios directamente sobre esta cadena.

46
00:02:47,260 --> 00:02:50,050
Ahora voy a poner entre comentarios la línea siete de nuestra función.

47
00:02:50,590 --> 00:02:56,590
Y qué pasa si en la variable de mensaje ahora le asigno una nueva cadena de audios?

48
00:02:57,460 --> 00:02:59,260
Vamos a ver qué es lo que sucede en memoria.

49
00:03:00,820 --> 00:03:04,270
Así que si volvemos a ejecutar, entonces se define nuestra cadena de Hola.

50
00:03:04,660 --> 00:03:07,120
La variable que es un apuntador a la cadena de hola.

51
00:03:07,450 --> 00:03:10,000
Así que en memoria se crea esta cadena.

52
00:03:10,000 --> 00:03:14,560
Pero recordemos que este arreglo se encuentra en una zona donde no podemos realizar cambios a ninguno

53
00:03:14,560 --> 00:03:15,430
de estos caracteres.

54
00:03:15,610 --> 00:03:17,260
Es una zona de sólo lectura.

55
00:03:17,500 --> 00:03:17,740
Bien.

56
00:03:17,740 --> 00:03:20,350
Posteriormente se mandan llamar nuestro método imprimir mensaje.

57
00:03:20,950 --> 00:03:22,780
Así que se manda a llamar nuestra función.

58
00:03:23,020 --> 00:03:29,560
Se define nuestra variable apuntador de mensaje que apunta a un carácter y el carácter que apunta es

59
00:03:29,560 --> 00:03:31,480
el inicio cero de nuestra cadena.

60
00:03:31,480 --> 00:03:32,440
La cadena de Hola.

61
00:03:32,650 --> 00:03:35,620
Pero de igual manera está apuntando a una zona de sólo lectura.

62
00:03:35,680 --> 00:03:38,290
Podemos observar que es exactamente la misma dirección de memoria.

63
00:03:38,590 --> 00:03:43,150
Posteriormente se manda a imprimir el mensaje de hola a la consola y entonces hasta el momento está

64
00:03:43,150 --> 00:03:44,860
funcionando correctamente en nuestro código.

65
00:03:45,160 --> 00:03:47,560
Pero aquí viene lo interesante en la línea ocho.

66
00:03:47,560 --> 00:03:53,290
Si queremos volver a asignar una cadena, entonces, debido a que esta variable es un apuntador, entonces

67
00:03:53,290 --> 00:03:55,750
se vuelve a crear una nueva cadena en memoria.

68
00:03:56,050 --> 00:04:01,360
Así que podemos observar que la cadena en memoria de hola, que está siendo apuntada por la variable

69
00:04:01,360 --> 00:04:07,030
de cadena, todavía sigue disponible en memoria, pero debido a que tenemos la sintaxis de apuntador,

70
00:04:07,150 --> 00:04:11,740
entonces ahora esta variable que es un apuntador, apunta a una nueva cadena que se está creando en

71
00:04:11,740 --> 00:04:16,300
memoria, y recordemos que esta cadena también se almacena en una zona de sólo lectura.

72
00:04:16,570 --> 00:04:20,170
Por lo tanto, es una nueva cadena y es una nueva referencia de memoria.

73
00:04:20,440 --> 00:04:25,930
Así que en este caso, esta variable apunta a un arreglo y en este caso esta variable apunta a otro

74
00:04:25,930 --> 00:04:26,350
arreglo.

75
00:04:26,650 --> 00:04:31,510
Lo que sucede es que la variable de cadena va a seguir apuntando a la cadena de hola y la variable de

76
00:04:31,510 --> 00:04:34,260
mensaje va a seguir apuntando a la cadena de Dios.

77
00:04:34,270 --> 00:04:39,280
Pero recordemos que al terminar ejecutarse nuestra función se elimina de memoria de la función también

78
00:04:39,280 --> 00:04:44,230
la variable de apuntador de mensaje y por lo tanto también perdemos la referencia de memoria de la cadena

79
00:04:44,230 --> 00:04:44,920
de adiós.

80
00:04:44,920 --> 00:04:49,240
Ya no es posible recuperar esta referencia, ya que ya no lo estamos regresando de ninguna manera.

81
00:04:49,450 --> 00:04:53,710
Y entonces el apuntador de cadena se queda apuntando a la cadena de Hola.

82
00:04:54,310 --> 00:04:58,810
Por lo tanto, cuando termina de ejecutarse nuestra función, regresamos al método principal, y si

83
00:04:58,810 --> 00:05:03,280
desde el método principal imprimimos la variable de cadena, vamos a comprobar que se vuelve a imprimir

84
00:05:03,310 --> 00:05:04,240
la cadena de Hola.

85
00:05:04,480 --> 00:05:07,450
Vamos a hacerlo simplemente para comprobarlo.

86
00:05:08,900 --> 00:05:10,440
Cadena original.

87
00:05:10,460 --> 00:05:12,140
Vamos a ver que es la cadena original.

88
00:05:13,040 --> 00:05:16,070
Es una cadena e imprimimos la variable de cadena.

89
00:05:16,250 --> 00:05:20,150
Vamos a agregar un salto de línea al inicio para que no se junte, se imprima en una nueva línea.

90
00:05:20,360 --> 00:05:25,310
Sin embargo, aquí, antes de ejecutar, voy a poner en primer lugar la modificación de la variable

91
00:05:25,310 --> 00:05:25,910
de mensaje.

92
00:05:26,870 --> 00:05:29,780
Así que dentro de la función vamos a mandar a imprimir el mensaje.

93
00:05:30,080 --> 00:05:35,420
Pero ahora se va a imprimir la cadena de audios y fuera de nuestro método principal, la cadena original

94
00:05:35,420 --> 00:05:37,400
tendría que mandar a imprimir la cadena de Hola.

95
00:05:37,730 --> 00:05:40,160
Tal como lo estamos comprobando también en nuestra animación.

96
00:05:40,380 --> 00:05:42,080
Bien, vamos a comprobar, vamos a ejecutar.

97
00:05:42,380 --> 00:05:47,150
Y entonces podemos observar que la primera impresión se está imprimiendo la variable de mensaje.

98
00:05:47,540 --> 00:05:50,720
Así que por ello la variable de mensaje imprime la cadena de audios.

99
00:05:51,050 --> 00:05:56,600
Esta variable de mensaje ahora está apuntando a una nueva cadena, pero también que no se puede modificar.

100
00:05:56,600 --> 00:05:58,310
Está en una zona de sólo lectura.

101
00:05:58,700 --> 00:06:02,810
Así que la variable de mensaje originalmente estaba apuntando a esta dirección de memoria.

102
00:06:03,050 --> 00:06:08,060
No puede modificar estos caracteres, pero eso no quiere decir que no pueda apuntar a una nueva cadena.

103
00:06:08,270 --> 00:06:13,490
Así que por ello, con esta sintaxis, lo que estamos haciendo es que apunta a una nueva cadena que

104
00:06:13,490 --> 00:06:15,920
se está creando en una zona de sólo lectura.

105
00:06:16,190 --> 00:06:19,970
Se manda a imprimir esta variable de mensaje y entonces obtenemos mensaje.

106
00:06:19,970 --> 00:06:20,480
Adiós.

107
00:06:21,110 --> 00:06:22,610
Esto es lo que se imprime en consola.

108
00:06:22,820 --> 00:06:27,200
Ya posteriormente no podríamos hacer ninguna modificación, ya que estas cadenas se encuentran en una

109
00:06:27,200 --> 00:06:31,940
zona de solo lectura y posteriormente, una vez que termina de llamarse nuestra función, se manda a

110
00:06:31,940 --> 00:06:33,440
imprimir la cadena original.

111
00:06:33,740 --> 00:06:38,240
Y podemos observar entonces que la cadena original sigue apuntando a nuestra cadena de Hola.

112
00:06:38,990 --> 00:06:42,820
Así que al terminar de ejecutarse nuestra función, se quita de memoria la función.

113
00:06:42,830 --> 00:06:46,550
También la variable apuntador de mensaje y también la cadena de audios.

114
00:06:46,550 --> 00:06:49,250
Solamente queda ya disponible la cadena de Hola.

115
00:06:49,610 --> 00:06:52,190
Y en este caso la cadena de hola nunca ha cambiado.

116
00:06:52,190 --> 00:06:56,300
Su referencia sigue apuntando exactamente a la misma referencia a la cadena de Hola.

117
00:06:56,750 --> 00:06:59,210
De igual manera, en una zona de sólo lectura.

118
00:06:59,420 --> 00:07:02,240
Así que ya no se pueden modificar estos caracteres de esta cadena.

119
00:07:02,570 --> 00:07:07,700
Bien, básicamente con esto ya tenemos muchos más elementos para entender el uso de cadenas apuntadores

120
00:07:07,700 --> 00:07:09,590
y también combinándolo con funciones.

121
00:07:09,890 --> 00:07:14,360
Bien, recuerden que también pueden ejecutar paso a paso todo este ejercicio si todavía tuvieran alguna

122
00:07:14,360 --> 00:07:14,690
duda.

123
00:07:15,020 --> 00:07:17,300
Eso es todo por esta lección y nos vemos en el siguiente vídeo.

124
00:07:17,450 --> 00:07:18,020
Saludos.
