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

2
00:00:00,520 --> 00:00:03,530
>> COLUNA: Vamos escrever um programa que
solicita ao usuário duas cordas e

3
00:00:03,530 --> 00:00:07,170
em seguida, informa se essas cordas
são iguais ou não iguais.

4
00:00:07,170 --> 00:00:10,290
Eu já começou nos aqui por
printf chamando duas vezes e chamando

5
00:00:10,290 --> 00:00:14,520
GetString duas vezes, armazenando o retorno
Os valores de S e T, respectivamente.

6
00:00:14,520 --> 00:00:17,960
>> Agora, meus instintos para comparar esses dois
cadeias seria utilizar o familiar

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

8
00:00:19,160 --> 00:00:22,070
se s é igual é igual a t.

9
00:00:22,070 --> 00:00:28,120
Então eu estou indo para ir em frente e impressão
out "Você digitou a mesma coisa!

10
00:00:28,120 --> 00:00:35,190
Outra coisa, se isso não é verdade, eu sou simplesmente
vai digitar printf ("Você digitou

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

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

13
00:00:38,850 --> 00:00:41,820
Estou simplesmente comparando s contra
t, e se eles são iguais,

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

15
00:00:43,250 --> 00:00:45,450
Vamos compilar e executar esse programa.

16
00:00:45,450 --> 00:00:51,950
Faça comparar 0. / Compare
0, dizer algo, Olá,

17
00:00:51,950 --> 00:00:54,200
dizer algo, Olá.

18
00:00:54,200 --> 00:00:56,870
>> Infelizmente, o programa pensa que eu tenho
digitado coisas diferentes, embora eu

19
00:00:56,870 --> 00:00:59,530
claramente digitado "Olá" a
mesma forma duas vezes.

20
00:00:59,530 --> 00:01:00,850
Agora, por que pode ser isso?

21
00:01:00,850 --> 00:01:03,750
>> Bem, acontece que tudo isso
tempo, seqüências de ter sido um pouco mais

22
00:01:03,750 --> 00:01:06,780
complexo do que uma seqüência de caracteres
debaixo do capô.

23
00:01:06,780 --> 00:01:11,450
Na realidade, uma string é um ponteiro ou um
endereço, especificamente o endereço

24
00:01:11,450 --> 00:01:14,640
do primeiro caractere em que
sequência de caracteres.

25
00:01:14,640 --> 00:01:18,640
>> E assim, quando comparamos s contra t
com o sinal de igual igual, estamos

26
00:01:18,640 --> 00:01:23,200
realmente pedindo, é este endereço
igual igual a este endereço?

27
00:01:23,200 --> 00:01:26,850
E isso não vai ser o caso se
o usuário digitou em dois diferentes

28
00:01:26,850 --> 00:01:30,370
cordas e nós chamamos GetString duas vezes
para obtê-los, porque a memória

29
00:01:30,370 --> 00:01:34,480
GetString que usa para armazenar o primeiro
corda poderia estar aqui na RAM, mas o

30
00:01:34,480 --> 00:01:37,120
memória que GetString usa para armazenar
a segunda corda vai

31
00:01:37,120 --> 00:01:38,760
estar aqui na RAM.

32
00:01:38,760 --> 00:01:42,380
E, claro, então, esses dois pedaços de
memória têm endereços diferentes para

33
00:01:42,380 --> 00:01:44,220
seus primeiros personagens.

34
00:01:44,220 --> 00:01:46,120
>> Então é s igual igual a t?

35
00:01:46,120 --> 00:01:46,885
Bem, não.

36
00:01:46,885 --> 00:01:50,510
Se S e T estão apontando para diferentes
pedaços de memória, como eles seriam por

37
00:01:50,510 --> 00:01:54,140
chamando GetString duas vezes, eles não são,
na verdade, será o mesmo.

38
00:01:54,140 --> 00:01:57,700
Assim, parece ser o caso de que a
comparar duas cordas no intuitivo

39
00:01:57,700 --> 00:02:01,050
maneira que esperamos, caráter para
caráter, precisamos de uma outra técnica

40
00:02:01,050 --> 00:02:02,300
completamente.

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