1
00:00:00,000 --> 00:00:03,250
>> 1 SPEAKER: בואו עכשיו לכתוב תכנית
הם באמת משווה שתי מחרוזות

2
00:00:03,250 --> 00:00:04,245
תווים של אופי.

3
00:00:04,245 --> 00:00:06,830
בואו נשתמש להשוות 0 כמו
נקודת המוצא שלנו.

4
00:00:06,830 --> 00:00:11,550
אבל בואו הקליפה הראשונה של חזרה בשכבה ה
הוא סוג המחרוזת ולכתוב אותו מחדש

5
00:00:11,550 --> 00:00:14,120
עבור מה שהיא באמת היא, ש
הוא כוכב char.

6
00:00:14,120 --> 00:00:17,740
זה הוא הכתובת של אופי,
במיוחד התו הראשון ב

7
00:00:17,740 --> 00:00:21,010
רצף של תווים שכולנו היינו יותר
בדרך כלל יודע כמו מחרוזת.

8
00:00:21,010 --> 00:00:21,880
>> אותו דבר עבור t.

9
00:00:21,880 --> 00:00:25,660
בואו לשכתב כי הצהרת מחרוזת
ככוכב char.

10
00:00:25,660 --> 00:00:28,690
ועכשיו אנחנו צריכים כבר לא
להשוות ים נגד t, שמא

11
00:00:28,690 --> 00:00:30,150
אנו משווים את שתי כתובות.

12
00:00:30,150 --> 00:00:33,180
אנחנו רוצים באמת להשוות
שתי מחרוזות בעצמם.

13
00:00:33,180 --> 00:00:37,520
כדי לעשות זאת, אנחנו יכולים להשתמש בפונקציה
הכריז בstring.h.

14
00:00:37,520 --> 00:00:40,920
אז אני אוסיף שכולל
על גבי הקובץ שלי.

15
00:00:40,920 --> 00:00:43,130
>> ואז אני הולך לשינוי
הקו הזה כאן.

16
00:00:43,130 --> 00:00:47,920
במקום להשוות ים נגד t, אני
הולך לקרוא חינמון מערבבים פונקציה,

17
00:00:47,920 --> 00:00:52,290
למחרוזת להשוות, ולהעביר
כבטיעוני S ו-T.

18
00:00:52,290 --> 00:00:56,480
אנחנו לדחות אז למחרוזת להשוות
להבין אם זה ולא הם אכן שווים

19
00:00:56,480 --> 00:00:59,870
ולתת לו להבין איך להשוות
אותם תווים של אופי.

20
00:00:59,870 --> 00:01:02,410
>> כעת, על פי התיעוד
למחרוזת להשוות, זה בעצם

21
00:01:02,410 --> 00:01:06,920
הולך להחזיר 0 אם שתי המחרוזות
הצביע על ידי ים ולא הם אותם.

22
00:01:06,920 --> 00:01:09,490
זה הולך להחזיר מספר שלילי
אם זה צריך לבוא לפני t

23
00:01:09,490 --> 00:01:13,740
בסדר אלפביתי או מספר חיובי אם
ים צריך לבוא אחרי לא לפי סדר אלפביתי.

24
00:01:13,740 --> 00:01:16,090
>> אבל לעת עתה, אכפת לנו רק
על שוויון.

25
00:01:16,090 --> 00:01:19,270
אז אני הולך פשוט כדי לבדוק אם
ערך החזרה של מחרוזת להשוות,

26
00:01:19,270 --> 00:01:21,450
עובר בים ולא, שווה 0.

27
00:01:21,450 --> 00:01:24,940
ואם כן, אני הולך טוען כי
שתי המחרוזות זהות.

28
00:01:24,940 --> 00:01:26,820
>> אבל אני הולך לעשות אחד
שינוי אחר גם כן.

29
00:01:26,820 --> 00:01:30,410
מתברר כי מחרוזת גט, לכולה
תיעוד, לפעמים יכול לחזור

30
00:01:30,410 --> 00:01:34,320
null, ערך זקיף כי, על פי
כדי לקבל תיעוד מחרוזות, אמצעים

31
00:01:34,320 --> 00:01:35,450
משהו רע קרה.

32
00:01:35,450 --> 00:01:38,830
לדוגמא, נגמרו לנו זיכרון או
המשתמש איכשהו לא שיתף פעולה.

33
00:01:38,830 --> 00:01:41,080
>> מחרוזת להשוות, בינתיים,
הוא מעט שביר.

34
00:01:41,080 --> 00:01:44,730
אם אתה עובר אותו ריק גם עבורה
ראשון או טענה שנייה, רע

35
00:01:44,730 --> 00:01:45,650
דברים יכולים לקרות.

36
00:01:45,650 --> 00:01:47,970
דברים רעים בדרך כלל מעורבים
תקלות פילוח.

37
00:01:47,970 --> 00:01:52,210
אז כדי למנוע את פוטנציאל שלגמרי,
אני הולך ראשון לעטוף את השימוש הזה של

38
00:01:52,210 --> 00:01:56,350
מחרוזת להשוות ידי הפנמה לכל זה
בלוק של הקוד והראשון עושה רק

39
00:01:56,350 --> 00:02:03,140
כי אם זה לא שווה null
ולא הוא לא שווה ל null.

40
00:02:03,140 --> 00:02:08,280
>> עטיפה שאם אחר לבנות לי כי
הקליד קודם לכן עם סוגריים מסולסלים כמו

41
00:02:08,280 --> 00:02:12,270
כן, כך שהפעם אני נוגע רק
ים ולא אם אני בטוח ש

42
00:02:12,270 --> 00:02:13,450
הם לא ריקים.

43
00:02:13,450 --> 00:02:17,220
בואו עכשיו להציל, לקמפל, ו
להפעיל מחדש את התכנית.

44
00:02:17,220 --> 00:02:22,240
>> הפוך להשוות לוכסן נקודה 1 להשוות 1.

45
00:02:22,240 --> 00:02:23,950
אני אגיד שלום שוב.

46
00:02:23,950 --> 00:02:25,890
ואחריו עדיין שלום שוב.

47
00:02:25,890 --> 00:02:28,110
והפעם, אני אכן
הקלד את אותו הדבר.

48
00:02:28,110 --> 00:02:30,255