>> [השמעת מוסיקה]
>> דאג LLOYD: בסדר, אז בוא לדבר על נימוקי שורת הפקודה.
אז, עד כה בקורס די הרבה כל התוכניות שלך
כנראה התחיל כמו זה-- חלל המרכזי int.
אנחנו כבר איסוף קלט משתמש אם אנחנו צריכים את זה
בתוכניות שלנו, כגון תכנית מריו, למשל,
על ידי הנחיות ב- תכנית.
יש לנו לא צריך לשנות ההכרזה העיקרית,
כי במקום בתוכנו עיקרי רק אומרים, אתה יכול לקרוא את זה כדי לקבל int.
כמה גדול אתה רוצה להיות הפירמידה?
או שאתה יכול לקרוא את זה כדי לקבל float-- כמה שינוי
אני צריך פלט למשתמש?
>> יש דרך אחרת אם כי, ואם אנחנו רוצים שהמשתמשים שלנו
כדי להיות מסוגל לספק נתונים לתכנית שלנו
בזמן הריצה במקום בזמן התכנית פועלת,
אבל הבחנה עדינה לפעמים אחד שימושי מאוד,
אנחנו צריכים צורה חדשה של הכרזה העיקרית.
אנחנו לא יכולים להשתמש בחלל מרכזי int אם אנחנו רוצים לאסוף נתונים אחרים בשורת הפקודה
כאשר המשתמש מפעיל את התכנית, מכאן שורת הפקודה טיעונים.
>> לאסוף שורת הפקודה הבאות טיעונים מהמשתמש,
לשנות ההצהרה שלך עיקרי להיראות כמו זה-- int
סוגריים עיקריים, פתוחים, argc int, פסיק, argv מחרוזת, סוגריים מרובעים,
ולאחר מכן פתח סד מתולתל.
אז מה זה אומר כבר?
ובכן, אנחנו עוברים בשני פרמטרים, או טענות, או תשומות לעיקריות.
אחד, מספר שלם נקרא argc, והשני הוא מה?
זה מערך של מחרוזות, נכון?
אנו רואים כי סימון הסוגר מרובע.
זה מערך של מחרוזות.
זה לא מחרוזת בודדת, זה מערך של מחרוזות.
ושני טיעונים, argc וargv אלה, תאפשר לכם לדעת מה נתוני המשתמש
סיפק בשורת הפקודה וכמה דברים שהם
סיפק בשורת הפקודה.
דברים די שימושיים לעבודה עם.
>> Argc עומד לספירת טיעון, ואתה צריך לדעת, דרך אגב,
שאתה יכול לקרוא לargc כל מה שאתה רוצה את זה.
אתה יכול לקרוא argv מה שאתה רוצה.
אלה הם שמות רק קונבנציונליים שאנו משתמשים לthem-- ספירת טיעון,
וכפי שנראה בשני, וקטור טיעון, argv.
אבל אתה לא צריך לקרוא להם argc וargv אם אתה לא רוצה,
אבל כמקובל, זה מה שאנחנו עושים.
>> אז בכל מקרה, argc, ספירת הטיעון.
זה משתנה שלם-סוג וכך, כ שאפשר לצפות, אם יש לנו שני דברים
שאנחנו הולכים להיות מציאת מה אלה שהוקלדו
וכמה דברים משתמש הקליד, argc הוא
הולך לספר לנו עד כמה דברי משתמש הקליד.
אז זה נותן לך מספר משתמשים טיעוני שורת הפקודה
הקליד כאשר התכנית בוצעה.
אז אם התכנית שלך היא לרוץ נקודה לקצץ חמדנים,
ובתוך חמדני שלך לתכנת הפונקציה העיקרית שלך
יש argc int הראשי int ההצהרה, מחרוזת argv סוגריים מרובעים, אז
argc במקרה שהוא אחד.
עכשיו שמנו לב שאנחנו עושים לא לספור כמה דברים
משתמש הקליד לאחר את שם התכנית.
שם התכנית עצמה סופרת כטיעון שורת הפקודה.
>> אז נקודה לקצץ חמדנים, ב מקרה זה, argc הוא אחד.
אם משתמש הקליד נטוי חמדנים 1,024 CS50 בשורת הפקודה, argc במקרה ש
יהיו שלושה.
ואנחנו יודעים את זה כי הדרך כי החלוקה בין המחרוזות
הוא זוהה הוא האם יש חלל, או כרטיסייה,
או משהו כזה ביניהם.
אז כל כמות של שטח לבן, מה שנקרא, בין הערכים שהוכנס שורת הפקודה
מציין כמה יש.
אז נקודה לקצץ חלל חמדנים 1,024 חלל CS50, argc, במקרה זה, הוא שלוש.
>> Argv הוא וקטור הטיעון.
וקטור, דרך אגב, הוא רק מילה אחרת למערך,
וזה הוא מערך המאחסן מחרוזות.
מחרוזת אחת לכל אלמנט, שהוא המחרוזות שהמשתמש למעשה
הקליד בשורת הפקודה כאשר התכנית בוצעה.
עכשיו, כמו במקרה של עם כל מערך, אם אתה
זוכר מהדיון שלנו מערכים, האלמנט הראשון של argv
הוא תמיד הולך למצוא בסוגר המרובע argv אפס.
זה המדד הראשון של מערך argv.
כך שwill-- ולמעשה, כי רצון תמיד יהיה שם התכנית,
תמיד יהיה ממוקם ב argv הסוגר מרובע אפס.
>> האלמנט האחרון של argv תמיד נמצא בargc argv כיכר סוגריים פחות אחד.
האם אתה רואה למה?
זכרו אלמנטים כמה קיימים במערך זה.
ובכן, אנחנו יודעים לראות-- זה מספר argc של אלמנטים.
אם משתמש הקליד שלושה דברים ב שורת הפקודה, argc הוא שלוש.
אבל בגלל בג, כאשר אנחנו עובדים עם מערכים, כל אלמנט של המערך,
או לייתר דיוק המדדים המערך, להתחיל באפס.
אם יש לנו שלושה אלמנטים בנו מערך, יש לנו אלמנט בargv אפס,
אלמנט בargv אחד, ואלמנט בargv שני.
אין אלמנט בargv שלוש, ומערך של גודל שלוש.
אז זאת הסיבה שעברה תמיד אלמנט של argv יכול
ניתן למצוא בכיכר argv argc סוגריים פחות אחד.
>> אז בואו נניח עוסק בביצוע המשתמשים תכנית החמדנים כמו follows--
אם הם מקלידים בנקודת שורת הפקודה לקצץ CS50 חלל החמדנים חלל 1024,
וכל סיבה שיש לנו כבר הכין התכנית החמדנית שלנו
לדעת ולעבוד עם אלה שורת הפקודה טיעונים.
אנחנו לא עשינו בעבר כאשר עבדנו על זה לבעית החמדנים,
אבל נניח שעכשיו אנחנו כבר שונה זה כל כך שאנחנו עושים תהליך
שורת הפקודה הטיעונים בדרך כלשהי.
במקרה זה, argv אפס הוא קו נטוי נקודת חמדנים.
מה argv אחד?
ובכן, זה 1024, נכון?
זה הוא 1024, אבל הנה distinction-- החשוב באמת
אתה זוכר את סוג הנתונים של argv?
>> הוא מאחסן מחרוזות, נכון?
אבל זה נראה כמו 1,024 הוא מספר שלם.
זה באמת חשוב הבחנה, והוא למעשה
הולך להיות משהו שאתה עלול להיתקל בבעיות בהמשך.
הכל בargv הוא מאוחסן כמחרוזת.
אז תוכן argv של אחד הוא אחד מחרוזת, אפס, שתיים, ארבע,
מורכב מארבע הדמויות האלה.
זה כאילו משתמש הקליד אחד, אפס, שתיים, ארבע
כאותיות או תווים בודדים.
זה לא המספר השלם 1024, ואז אתה לא יכול ישירות
לעבוד עם זה באומרו 1,000 int, או ולא int x שווה argv אחד מינוס 24.
>> באופן אינטואיטיבי, אתה עלול לחשוב על זה כ, אישור, גם זה 1,024 מינוס 24,
כך x שווה ל1,000.
אבל למעשה, זה לא המקרה, כי argv אחד היא מחרוזת.
מחרוזת 1024.
עכשיו יש פונקציה שיכולה להיות משמש להמרת מחרוזות למספרים שלמים.
אני לא אקלקל את זה בשבילך עכשיו, אבל אני בטוח שZamyla
ישמח לספר לכם על זה ב ההדרכה לבעיה בעתיד.
אבל אתה גם יכול למצוא תירוץ like-- בעיות
שלי, פונקציות שהייתן לעשות את זה בהתייחסות 50,
אם אתה הולך למדריך העזר אתה יכול למצוא פונקציה ש
אעשה גיור זה בשבילך.
אבל שוב, בהדרכה לבעיה בעתיד,
Zamyla ישמח אגיד לך מה פונקציה
זה יהיה להמיר מחרוזת 1024 המספר השלם 1024.
>> בסדר, אז ממשיך הלאה.
אנחנו כבר כיסינו אפס argv, אנחנו כבר כיסינו argv אחד.
מה בargv שתיים?
CS50.
אחד שכנראה די מובן מאליו.
מה בargv שלוש?
ובכן שוב, אנחנו לא באמת יודעים, נכון?
יש לנו מערך של שלושה גודל, זה כמה אלמנטי המשתמש
הקליד בשורת הפקודה, כך שאם אנחנו הולכים לargv שלוש,
עכשיו אנחנו חריגה גבולות המערך שלנו.
מהדר יאפשר לנו לעשות את זה, אין שום בעיה עם זה אינטואיטיבי,
אבל במונחים של ממש מה קורה לקרות, אנחנו לא באמת יודעים.
זה תלוי מה הוא ממוקם בזיכרון שבו
argv שלוש יהיו צפויים להיות.
וכדי שנוכל בסופו של מקבל משם סקוטי חופשי.
יותר סביר מאשר לא, במיוחד כאשר אתה עובד עם argv בניגוד
לכל מערך אחר זה בתכנית שלנו,
אנחנו כנראה הולכים לסבול אשמת פילוח. אז שוב,
להיות בטוח שלא לחרוג מהגבולות המערכים שלך, במיוחד argv,
ניתנו הרמה הגבוהה של חשיבות בתוכניות שלך.
>> אני דאג לויד.
זה CS50.