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

2
00:00:00,520 --> 00:00:03,530
>> SPEAKER: Scriviamo un programma che
richiede all'utente due stringhe e

3
00:00:03,530 --> 00:00:07,170
quindi di segnalare se quelle stringhe
sono uguali o non uguali.

4
00:00:07,170 --> 00:00:10,290
Ho già ci cominciato qui da
chiamare printf due volte e chiamando

5
00:00:10,290 --> 00:00:14,520
GetString due volte, memorizzare il ritorno
valori di s e t, rispettivamente.

6
00:00:14,520 --> 00:00:17,960
>> Ora, il mio istinto di confrontare questi due
stringhe sarebbe quella di utilizzare il familiare

7
00:00:17,960 --> 00:00:19,160
uguaglianza operatore -

8
00:00:19,160 --> 00:00:22,070
se s è uguale uguale a t.

9
00:00:22,070 --> 00:00:28,120
Poi ho intenzione di andare avanti e di stampa
out "È stato digitato la stessa cosa!

10
00:00:28,120 --> 00:00:35,190
Altrimenti, se questo non è vero, io sono semplicemente
andando a digitare printf ("Hai digitato

11
00:00:35,190 --> 00:00:37,880
cose diverse!

12
00:00:37,880 --> 00:00:38,850
>> Abbastanza semplice -

13
00:00:38,850 --> 00:00:41,820
Sto semplicemente confrontando s contro
t, e se sono uguali,

14
00:00:41,820 --> 00:00:43,250
la stampa di tanto.

15
00:00:43,250 --> 00:00:45,450
Facciamo compilare ed eseguire questo programma.

16
00:00:45,450 --> 00:00:51,950
Fai Confronta 0. / Confrontare
0, dire qualcosa, ciao,

17
00:00:51,950 --> 00:00:54,200
dire qualcosa, ciao.

18
00:00:54,200 --> 00:00:56,870
>> Purtroppo, il programma pensa che io ho
digitato cose diverse, anche se

19
00:00:56,870 --> 00:00:59,530
chiaramente digitato "ciao" l'
Allo stesso modo entrambe le volte.

20
00:00:59,530 --> 00:01:00,850
Ora, perché potrebbe essere?

21
00:01:00,850 --> 00:01:03,750
>> Beh, si scopre che tutto questo
tempo, le stringhe sono stati un po 'più

22
00:01:03,750 --> 00:01:06,780
complesso di una sequenza di caratteri
sotto la cappa.

23
00:01:06,780 --> 00:01:11,450
In realtà, una stringa è un puntatore o un
indirizzo, in particolare l'indirizzo

24
00:01:11,450 --> 00:01:14,640
del primo carattere in quel
sequenza di caratteri.

25
00:01:14,640 --> 00:01:18,640
>> E così quando mettiamo a confronto s contro t
con il segno di uguale uguale, siamo

26
00:01:18,640 --> 00:01:23,200
in realtà chiedendo, è questo indirizzo
uguale uguale a questo indirizzo?

27
00:01:23,200 --> 00:01:26,850
E non sta andando essere il caso se
l'utente ha digitato in due diversi

28
00:01:26,850 --> 00:01:30,370
stringhe e abbiamo chiamato GetString due volte
per farli, perché la memoria

29
00:01:30,370 --> 00:01:34,480
GetString che utilizza per memorizzare il primo
stringa potrebbe essere qui in RAM, ma l'

30
00:01:34,480 --> 00:01:37,120
memoria che GetString utilizza per memorizzare
la seconda stringa sta

31
00:01:37,120 --> 00:01:38,760
di essere qui in RAM.

32
00:01:38,760 --> 00:01:42,380
E, naturalmente, poi, quei due pezzi di
memoria hanno indirizzi diversi per

33
00:01:42,380 --> 00:01:44,220
dai primi caratteri.

34
00:01:44,220 --> 00:01:46,120
>> Così è s uguale uguale a t?

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

36
00:01:46,885 --> 00:01:50,510
Se s e t puntano a diversi
blocchi di memoria, in quanto sarebbero da

37
00:01:50,510 --> 00:01:54,140
chiamando GetString due volte, non lo sono,
infatti, sarà il medesimo.

38
00:01:54,140 --> 00:01:57,700
Così sembra essere il caso che a
confrontare due stringhe in intuitivo

39
00:01:57,700 --> 00:02:01,050
modo che ci aspettiamo, dei caratteri per
carattere, abbiamo bisogno di un'altra tecnica

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

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