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

2
00:00:00,520 --> 00:00:03,530
>> דובר: בואו לכתוב תכנית ש
מבקש מהמשתמש שתי מחרוזות ו

3
00:00:03,530 --> 00:00:07,170
לאחר מכן מדווח אם המיתרים הללו
זהה או לא זהה.

4
00:00:07,170 --> 00:00:10,290
אני כבר התחלתי אותנו כאן על ידי
קורא printf פעמיים וקוראים

5
00:00:10,290 --> 00:00:14,520
GetString פעמיים, אחסון התמורה
ערכים בים ולא בהתאמה.

6
00:00:14,520 --> 00:00:17,960
>> עכשיו, האינסטינקטים שלי להשוות בין שני אלה
מחרוזות תהיה להשתמש מוכר

7
00:00:17,960 --> 00:00:19,160
מפעיל שוויון -

8
00:00:19,160 --> 00:00:22,070
אם זה שווה שווה לא.

9
00:00:22,070 --> 00:00:28,120
ואז אני הולך קדימה והדפסה
מתוך "אתה הקלדת את אותו הדבר!

10
00:00:28,120 --> 00:00:35,190
אחר, אם זה לא נכון, אני פשוט
הולך הקלד printf ("אתה הקלדת

11
00:00:35,190 --> 00:00:37,880
דברים שונים!

12
00:00:37,880 --> 00:00:38,850
>> פשוט למדי -

13
00:00:38,850 --> 00:00:41,820
אני פשוט השוואה של נגד
לא, ואם הם שווים,

14
00:00:41,820 --> 00:00:43,250
הדפסה החוצה באותה מידה.

15
00:00:43,250 --> 00:00:45,450
בואו לקמפל ולהריץ תכנית זו.

16
00:00:45,450 --> 00:00:51,950
הפוך להשוות 0. / להשוות
0, לומר משהו, שלום,

17
00:00:51,950 --> 00:00:54,200
לומר משהו, הלו.

18
00:00:54,200 --> 00:00:56,870
>> למרבה הצער, התכנית חושבת לי
הוקלד דברים שונים, למרות שאני

19
00:00:56,870 --> 00:00:59,530
ברור שהוקלד "שלום"
אותה דרך בשתי הפעמים.

20
00:00:59,530 --> 00:01:00,850
עכשיו, למה זה יכול להיות?

21
00:01:00,850 --> 00:01:03,750
>> ובכן, מתברר שכל זה
זמן, מיתרים היו קצת יותר

22
00:01:03,750 --> 00:01:06,780
מורכב יותר מאשר רצף של תווים
מתחת למכסת המנוע.

23
00:01:06,780 --> 00:01:11,450
במציאות, מחרוזת היא מצביע או
כתובת, במיוחד את הכתובת

24
00:01:11,450 --> 00:01:14,640
מהתו הראשון שב
רצף של תווים.

25
00:01:14,640 --> 00:01:18,640
>> ולכן כאשר אנו משווים s נגד t
בסימן השוויון שווה, אנחנו

26
00:01:18,640 --> 00:01:23,200
שואל בעצם, היא כתובת זו
שווה שווה לכתובת זו?

27
00:01:23,200 --> 00:01:26,850
וזה לא הולך להיות המקרה אם
המשתמש הקליד בשני שונים

28
00:01:26,850 --> 00:01:30,370
מחרוזות ואנחנו כבר נקראו GetString פעמיים
כדי לקבל אותם, כי הזיכרון

29
00:01:30,370 --> 00:01:34,480
GetString המשתמש לאחסון הראשון
מחרוזת יכולה להיות כאן בזכרון RAM, אבל

30
00:01:34,480 --> 00:01:37,120
זיכרון שGetString משתמש כדי לאחסן
המחרוזת השנייה הולכת

31
00:01:37,120 --> 00:01:38,760
להיות כאן בזכרון RAM.

32
00:01:38,760 --> 00:01:42,380
וכמובן, אם כן, שני גושים אלה של
יש לי זיכרון כתובות שונות עבור

33
00:01:42,380 --> 00:01:44,220
התווים הראשונים שלהם.

34
00:01:44,220 --> 00:01:46,120
>> אז הוא של שווה שווה לא?

35
00:01:46,120 --> 00:01:46,885
ובכן, לא.

36
00:01:46,885 --> 00:01:50,510
אם ים ולא מצביעים על שונה
גושים של זיכרון, כפי שהם יהיו על ידי

37
00:01:50,510 --> 00:01:54,140
קוראים GetString פעמיים, הם לא,
למעשה, הולך להיות אותו הדבר.

38
00:01:54,140 --> 00:01:57,700
אז נראה שזה המקרה של
להשוות בין שתי מחרוזות באינטואיטיבי

39
00:01:57,700 --> 00:02:01,050
אופן שבו אנו מצפים, תווים
אופי, אנחנו צריכים טכניקה נוספת

40
00:02:01,050 --> 00:02:02,300
לגמרי.

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