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

2
00:00:00,520 --> 00:00:03,530
>> SPEAKER: Mari kita menulis sebuah program yang
meminta pengguna untuk dua string dan

3
00:00:03,530 --> 00:00:07,170
kemudian melaporkan apakah mereka string
adalah sama atau tidak sama.

4
00:00:07,170 --> 00:00:10,290
Aku sudah mulai kita di sini oleh
memanggil printf dua kali dan menelepon

5
00:00:10,290 --> 00:00:14,520
GetString dua kali, menyimpan return
nilai dalam s dan t masing-masing.

6
00:00:14,520 --> 00:00:17,960
>> Sekarang, naluri saya untuk membandingkan kedua
string akan menggunakan akrab

7
00:00:17,960 --> 00:00:19,160
operator kesetaraan -

8
00:00:19,160 --> 00:00:22,070
jika s sama sama t.

9
00:00:22,070 --> 00:00:28,120
Lalu aku akan pergi ke depan dan mencetak
out "Anda mengetik hal yang sama!

10
00:00:28,120 --> 00:00:35,190
Yang lain, jika itu tidak benar, aku hanya
akan mengetik printf ("Anda mengetik

11
00:00:35,190 --> 00:00:37,880
hal yang berbeda!

12
00:00:37,880 --> 00:00:38,850
>> Cukup mudah -

13
00:00:38,850 --> 00:00:41,820
Saya hanya membandingkan melawan
t, dan jika mereka sama,

14
00:00:41,820 --> 00:00:43,250
mencetak sebanyak.

15
00:00:43,250 --> 00:00:45,450
Mari kita mengkompilasi dan menjalankan program ini.

16
00:00:45,450 --> 00:00:51,950
Membuat bandingkan 0. / Membandingkan
0, mengatakan sesuatu, halo,

17
00:00:51,950 --> 00:00:54,200
mengatakan sesuatu, halo.

18
00:00:54,200 --> 00:00:56,870
>> Sayangnya, program ini mengira aku sudah
mengetik hal yang berbeda, meskipun saya

19
00:00:56,870 --> 00:00:59,530
jelas mengetik "halo" yang
cara yang sama kedua kali.

20
00:00:59,530 --> 00:01:00,850
Sekarang, mengapa bisa begitu?

21
00:01:00,850 --> 00:01:03,750
>> Nah, ternyata semua ini
waktu, string telah sedikit lebih

22
00:01:03,750 --> 00:01:06,780
kompleks daripada urutan karakter
di bawah tenda.

23
00:01:06,780 --> 00:01:11,450
Pada kenyataannya, string adalah pointer atau
alamat, khususnya alamat

24
00:01:11,450 --> 00:01:14,640
dari karakter pertama dalam
urutan karakter.

25
00:01:14,640 --> 00:01:18,640
>> Dan ketika kita membandingkan melawan t
dengan tanda sama sama, kami

26
00:01:18,640 --> 00:01:23,200
benar-benar bertanya, apakah alamat ini
sama sama dengan alamat ini?

27
00:01:23,200 --> 00:01:26,850
Dan itu tidak akan terjadi jika
pengguna telah diketik dalam dua berbeda

28
00:01:26,850 --> 00:01:30,370
string dan kami sudah menelepon dua kali GetString
untuk mendapatkan mereka, karena memori

29
00:01:30,370 --> 00:01:34,480
GetString yang menggunakan untuk menyimpan pertama
String mungkin berada di sini dalam RAM, tetapi

30
00:01:34,480 --> 00:01:37,120
memori yang GetString digunakan untuk menyimpan
string kedua akan

31
00:01:37,120 --> 00:01:38,760
berada di sini dalam RAM.

32
00:01:38,760 --> 00:01:42,380
Dan tentu saja, kemudian, kedua potongan
memori memiliki alamat yang berbeda untuk

33
00:01:42,380 --> 00:01:44,220
karakter pertama mereka.

34
00:01:44,220 --> 00:01:46,120
>> Jadi s sama sama dengan t?

35
00:01:46,120 --> 00:01:46,885
Nah, tidak ada.

36
00:01:46,885 --> 00:01:50,510
Jika s dan t menunjuk ke berbagai
potongan memori, karena mereka akan dengan

37
00:01:50,510 --> 00:01:54,140
memanggil GetString dua kali, mereka tidak,
pada kenyataannya, akan menjadi sama.

38
00:01:54,140 --> 00:01:57,700
Jadi tampaknya menjadi kasus bahwa untuk
membandingkan dua string di intuitif

39
00:01:57,700 --> 00:02:01,050
cara yang kita harapkan, karakter
karakter, kita perlu teknik lain

40
00:02:01,050 --> 00:02:02,300
sama sekali.

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