1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [טיעוני שורת פקודה]

2
00:00:02,000 --> 00:00:04,000
[כריסטופר רתולומיאו - אוניברסיטת הרווארד]

3
00:00:04,000 --> 00:00:07,000
[זה CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
תכונה שימושית לתכנית היא לקבל קלט ממשתמש.

5
00:00:11,000 --> 00:00:15,000
עד כה, יש לנו חקרנו כמה פונקציות בתוך CS50 הספרייה

6
00:00:15,000 --> 00:00:18,000
כדי לקבל קלט משתמש, כגון "לקבל מחרוזת"

7
00:00:18,000 --> 00:00:23,000
המנחה את המשתמש, תוך היישום פועל, למחרוזת.

8
00:00:23,000 --> 00:00:28,000
>> עם זאת, יש מקרים שבם ברצונך לספק קלט התכנית שלך

9
00:00:28,000 --> 00:00:30,000
לפני זה באמת פועל.

10
00:00:30,000 --> 00:00:34,000
בדרך זו, אתה לא צריך לבקש מידע נוסף מהמשתמש שלך

11
00:00:34,000 --> 00:00:38,000
בעת ביצוע משימה פשוטה.

12
00:00:38,000 --> 00:00:42,000
קח, למשל, או פקודת mv מהלך ביוניקס.

13
00:00:42,000 --> 00:00:49,000
פקודה זו מאפשרת למשתמש להעביר קבצים ממקום אחד למשנו.

14
00:00:49,000 --> 00:00:55,000
על פי הדפים הידניים, MV מקבל שני ארגומנטים של שורת פקודה:

15
00:00:55,000 --> 00:01:00,000
הקובץ שמועבר ואת מיקום הקובץ מועבר ל.

16
00:01:00,000 --> 00:01:06,000
אז דוגמה זו יש פקודה בשני טיעונים.

17
00:01:06,000 --> 00:01:14,000
אז איך אנחנו אומרים לי תכנית C לנצל טיעוני שורת הפקודה האלה?

18
00:01:14,000 --> 00:01:20,000
>> ובכן, מתברר שראשי, בו אנו משתמשים בכל תוכניות C, יש סוד.

19
00:01:20,000 --> 00:01:26,000
עיקרי מקבלת שני פרמטרים: argc וargv.

20
00:01:26,000 --> 00:01:28,000
בואו נעבור על תנאים אלה.

21
00:01:28,000 --> 00:01:33,000
>> הפרמטר הראשון, argc, העומד לטענת רוזן,

22
00:01:33,000 --> 00:01:36,000
יש סוג נתונים של מספר שלם.

23
00:01:36,000 --> 00:01:42,000
פרמטר argc מכיל את מספר הטיעונים, לרבות הפיקוד.

24
00:01:42,000 --> 00:01:47,000
בפקודת המהלך שלנו, למרות שנשארנו לנו רק שני טיעונים המוצגים,

25
00:01:47,000 --> 00:01:50,000
הערך של argc יהיה 3.

26
00:01:50,000 --> 00:01:56,000
הפרמטר השני, argv, העומד לטענת וקטור,

27
00:01:56,000 --> 00:02:01,000
הוא מערך של מצביעי char המצביעים על מייתרים.

28
00:02:01,000 --> 00:02:06,000
>> משמעות הדבר הוא שכל רכיב בargv, מתחיל מאפס,

29
00:02:06,000 --> 00:02:09,000
מכיל את הפקודה וטיעונים.

30
00:02:09,000 --> 00:02:16,000
לדוגמה, argv [0], שבו אני מתייחס אליו כargv אפס,

31
00:02:16,000 --> 00:02:20,000
תמיד מכיל את הפקודה שמתנהלת -

32
00:02:20,000 --> 00:02:22,000
במקרה זה, MV.

33
00:02:22,000 --> 00:02:28,000
argv [1] יכיל את הטענה הראשונה, file.txt,

34
00:02:28,000 --> 00:02:37,000
וargv [2] יכיל את הטיעון השני, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
הטיעון האחרון של argv תמיד יהיה ריק.

36
00:02:42,000 --> 00:02:46,000
אז בואו ליישם טיעונים אלה שורת פקודה.

37
00:02:46,000 --> 00:02:53,000
בתרגילים הקודמים, אנו מניחים את הריק, ללא משמעות, כפרמטר של ראשי.

38
00:02:53,000 --> 00:02:57,000
עם זאת, על מנת שאוכל להשתמש בטיעונים של שורת פקודה,

39
00:02:57,000 --> 00:03:12,000
אנחנו צריכים להסיר בתוך חלל ומקום של int argc הראשי, char * argv [].

40
00:03:12,000 --> 00:03:17,000
עכשיו, כדי לגשת לכל האלמנט מargv, שהם הטיעונים שלך,

41
00:03:17,000 --> 00:03:21,000
אתה פשוט יכול לחזר, או לולאה, באמצעות מערך כזה.

42
00:03:21,000 --> 00:03:27,000
אז, בתוך גופו של ראשי, אנחנו הולכים קדימה והקלידו ללולאה:

43
00:03:27,000 --> 00:03:37,000
עבור (אני int = 0; i <argc; אני + +).

44
00:03:37,000 --> 00:03:41,000
>> אנחנו לא צריכים סד מתולתל כאן כי אנחנו רק ביצוע שורה אחת של קוד

45
00:03:41,000 --> 00:03:44,000
בתוך הגוף של הלולאה הזו.

46
00:03:44,000 --> 00:03:47,000
נלך קדימה ופגענו בכרטיסייה אחת,

47
00:03:47,000 --> 00:03:57,000
לאחר מכן הקלד printf ("argv [% d], כדי לייצג את ערך שלם,

48
00:03:57,000 --> 00:04:06,000
הוא% s, לחוט, ואז תו השורה החדשה.

49
00:04:06,000 --> 00:04:12,000
אז אנחנו מספקים printf i לצורתה הנוכחית של הלולאה

50
00:04:12,000 --> 00:04:18,000
וargv [i] לייצוג המחרוזת של הטיעון הנוכחי של שורת פקודה.

51
00:04:18,000 --> 00:04:25,000
כאשר אנו מפעילים את זה עם שני טיעונים, אנחנו נראה את הטיעונים שמוצגים בטרמינל.

52
00:04:34,000 --> 00:04:38,000
מוקדם יותר אמר שargv התקיים מערך של מצביעי char.

53
00:04:38,000 --> 00:04:45,000
>> לכן, אם זה מקרה, איך אנחנו לאחר מכן לגשת תווים בודדים בכל ויכוח?

54
00:04:45,000 --> 00:04:51,000
לדוגמה, מה אם אני רוצה לחפש תו מסוים בטענה הראשונה?

55
00:04:51,000 --> 00:04:55,000
ובכן, התשובה היא שאנחנו צריכים ליישם לולאה מקוננת

56
00:04:55,000 --> 00:04:59,000
כי אז יהיה לחזר דרך כל אחד מהמרכיבים במחרוזת הוויכוח.

57
00:04:59,000 --> 00:05:02,000
זה איך אתה עושה את זה.

58
00:05:02,000 --> 00:05:10,000
>> ראשית, אנחנו הולכים ליצור עותק של example2.c.

59
00:05:10,000 --> 00:05:13,000
ואז, בתוך הראשון ללולאה,

60
00:05:13,000 --> 00:05:15,000
אנחנו הולכים להוסיף נוספים ללולאה.

61
00:05:15,000 --> 00:05:28,000
אז עבור (int j = 0, n = strlen (argv [i]),

62
00:05:28,000 --> 00:05:32,000
אז מה נותן לנו את אורכו של הוויכוח הנוכחי,

63
00:05:32,000 --> 00:05:39,000
, J <n; j + +)

64
00:05:39,000 --> 00:05:43,000
אנחנו הולכים להדפיס את המיקום של כל תו

65
00:05:43,000 --> 00:05:47,000
בתוך הוויכוח הנוכחי באמצעות printf.

66
00:05:47,000 --> 00:05:57,000
אז, printf ("argv [% d], כדי לייצג את האינדקס של הוויכוח הנוכחי,

67
00:05:57,000 --> 00:06:05,000
אז [% d] שוב, כדי לייצג את האופי הנוכחי של הוויכוח הנוכחי,

68
00:06:05,000 --> 00:06:13,000
הוא: ג%, על דמותה הנוכחית בוויכוח.

69
00:06:13,000 --> 00:06:20,000
לבסוף, אנו מספקים printf עם המדד של הלולאה החיצונית, אני,

70
00:06:20,000 --> 00:06:22,000
אז המדד של הלולאה הפנימית.

71
00:06:22,000 --> 00:06:28,000
>> והטיעון האחרון שלנו לprintf הוא דמות הממשית מהוויכוח ספק

72
00:06:28,000 --> 00:06:31,000
בשורת הפקודה.

73
00:06:31,000 --> 00:06:37,000
עכשיו, בגלל שהשתמשתי בפונקצית מחרוזת strlen לקבל האורך של מחרוזת,

74
00:06:37,000 --> 00:06:43,000
עליי גם להוסיף ספריית string.h לראש כולל שלנו.

75
00:06:43,000 --> 00:06:50,000
לכן, כדי לעשות את זה, תלך, ורק תחת stdio.h, אנחנו הולכים לעשות

76
00:06:50,000 --> 00:06:57,000
# כולל <string.h>.

77
00:06:57,000 --> 00:07:02,000
>> אז, בואו לקמפל ולהריץ ולספק אותו טיעון ממשי.

78
00:07:09,000 --> 00:07:18,000
>> וכמו שאנחנו יכולים לראות, עכשיו יש לנו את המיקום המדויק של כל תו הבודד בויכוח.

79
00:07:18,000 --> 00:07:23,000
אז זהו זה. אני כריסטופר רתולומיאו, זה CS50.

80
00:07:23,000 --> 00:07:26,000
[CS50.TV]