1
00:00:00,000 --> 00:00:00,520

2
00:00:00,520 --> 00:00:03,530
>> ALTAVOZ: Vamos a escribir un programa que
solicita al usuario dos cadenas y

3
00:00:03,530 --> 00:00:07,170
informa si esas cadenas
son los mismos o no la misma.

4
00:00:07,170 --> 00:00:10,290
Yo ya he empezado a nosotros fuera de aquí por
llamar a printf dos veces y llamar

5
00:00:10,290 --> 00:00:14,520
GetString dos veces, almacenando el retorno
valores en s y t, respectivamente.

6
00:00:14,520 --> 00:00:17,960
>> Ahora, mis instintos para comparar estos dos
cuerdas sería utilizar el familiar

7
00:00:17,960 --> 00:00:19,160
operador de igualdad -

8
00:00:19,160 --> 00:00:22,070
si s es igual a es igual a t.

9
00:00:22,070 --> 00:00:28,120
Entonces voy a seguir adelante y de impresión
out "Se ha escrito la misma cosa!

10
00:00:28,120 --> 00:00:35,190
Si no, si eso no es cierto, estoy simplemente
va a escribir printf ("Se ha escrito

11
00:00:35,190 --> 00:00:37,880
cosas diferentes!

12
00:00:37,880 --> 00:00:38,850
>> Bastante sencillo -

13
00:00:38,850 --> 00:00:41,820
Yo simplemente estoy comparando s contra
t, y si son iguales,

14
00:00:41,820 --> 00:00:43,250
imprimir tanto.

15
00:00:43,250 --> 00:00:45,450
Vamos a compilar y ejecutar este programa.

16
00:00:45,450 --> 00:00:51,950
Hacer compara 0. / Comparar
0, decir algo, hola,

17
00:00:51,950 --> 00:00:54,200
decir algo, hola.

18
00:00:54,200 --> 00:00:56,870
>> Desafortunadamente, el programa piensa que he
escrito cosas diferentes, a pesar de que

19
00:00:56,870 --> 00:00:59,530
claramente escrito "hola" el
misma forma en ambas ocasiones.

20
00:00:59,530 --> 00:01:00,850
Ahora, ¿por qué será?

21
00:01:00,850 --> 00:01:03,750
>> Bueno, resulta que todo esto
tiempo, las cadenas han sido un poco más

22
00:01:03,750 --> 00:01:06,780
compleja que una secuencia de caracteres
debajo de la capucha.

23
00:01:06,780 --> 00:01:11,450
En realidad, una cadena es un puntero o un
dirección, específicamente la dirección

24
00:01:11,450 --> 00:01:14,640
del primer carácter que
secuencia de caracteres.

25
00:01:14,640 --> 00:01:18,640
>> Y así, cuando comparamos s contra t
con el signo igual igual, estamos

26
00:01:18,640 --> 00:01:23,200
en realidad preguntando, es esta dirección
igual igual a esta dirección?

27
00:01:23,200 --> 00:01:26,850
Y eso no va a ser el caso si
el usuario ha escrito en dos diferentes

28
00:01:26,850 --> 00:01:30,370
cuerdas y hemos llamado a GetString dos veces
para conseguirlos, porque la memoria

29
00:01:30,370 --> 00:01:34,480
que GetString utiliza para almacenar la primera
cadena podría estar aquí en la memoria RAM, pero el

30
00:01:34,480 --> 00:01:37,120
memoria que GetString utiliza para almacenar
la segunda cadena se va

31
00:01:37,120 --> 00:01:38,760
de estar aquí en la RAM.

32
00:01:38,760 --> 00:01:42,380
Y, por supuesto, entonces, esos dos trozos de
memoria tienen diferentes direcciones para

33
00:01:42,380 --> 00:01:44,220
sus primeros personajes.

34
00:01:44,220 --> 00:01:46,120
>> Así es s igual igual a t?

35
00:01:46,120 --> 00:01:46,885
Bueno, no.

36
00:01:46,885 --> 00:01:50,510
Si s y t están apuntando a diferentes
fragmentos de memoria, ya que sería por

37
00:01:50,510 --> 00:01:54,140
llamando GetString dos veces, no lo son,
de hecho, va a ser la misma.

38
00:01:54,140 --> 00:01:57,700
Por lo tanto, parece ser el caso de que a
comparar dos cadenas en el intuitivo

39
00:01:57,700 --> 00:02:01,050
manera que esperamos, el carácter de
carácter, necesitamos otra técnica

40
00:02:01,050 --> 00:02:02,300
por completo.

41
00:02:02,300 --> 00:02:03,902