>> [เล่นเพลง]
>> DOUG LLOYD: สิทธิทั้งหมดเพื่อให้ พูดคุยเกี่ยวกับอาร์กิวเมนต์บรรทัดคำสั่ง
ดังนั้นเพื่อให้ห่างไกลในหลักสูตรสวย มากทุกโปรแกรมของคุณ
อาจจะได้เริ่มต้น เช่น this-- int เป็นโมฆะหลัก
เราได้รับการจัดเก็บภาษี ท่านผู้ใช้ถ้าเราจำเป็นต้องใช้มัน
ในโปรแกรมของเราเช่น โปรแกรมมาริโอยกตัวอย่างเช่น
โดยแจ้งในโปรแกรม
เรายังไม่จำเป็นที่จะปรับเปลี่ยน ประกาศหลัก
เพราะแทนที่จะภายในของเราหลัก เพียงแค่พูดว่าคุณอาจเรียกมันว่าจะได้รับ int
วิธีที่มีขนาดใหญ่ที่คุณต้องการพีระมิดจะเป็น?
หรือคุณอาจเรียกมันว่าจะได้รับ float-- เท่าใดการเปลี่ยนแปลง
ฉันควรส่งออกไปยังผู้ใช้หรือไม่
>> มีวิธีอื่น แต่ และถ้าเราต้องการให้ผู้ใช้ของเรา
เพื่อให้สามารถที่จะให้ ข้อมูลในการเขียนโปรแกรมของเรา
ที่รันไทม์แทนในขณะที่ โปรแกรมจะทำงาน
ความแตกต่างที่บอบบาง แต่ บางครั้งหนึ่งที่มีประโยชน์มาก
เราจำเป็นต้องมีรูปแบบใหม่ของการประกาศหลัก
เราไม่สามารถใช้เป็นโมฆะหลัก int ถ้าเราต้องการ การเก็บรวบรวมข้อมูลอื่น ๆ ที่บรรทัดคำสั่ง
เมื่อผู้ใช้เรียกใช้โปรแกรม จึงอาร์กิวเมนต์บรรทัดคำสั่ง
>> ในการเก็บรวบรวมบรรทัดคำสั่งเหล่านี้ ข้อโต้แย้งจากผู้ใช้
เปลี่ยนการประกาศของคุณ หลักจะมีลักษณะเหมือน int this--
หลักวงเล็บเปิด int argc, เครื่องหมายจุลภาค argv สตริงตารางวงเล็บ
แล้วเปิดวงเล็บปีกกา
ดังนั้นสิ่งที่หมายความว่าอยู่แล้ว?
ดีที่เราจะผ่านในสองพารามิเตอร์ หรือข้อโต้แย้งหรือปัจจัยการผลิตหลัก
หนึ่งจำนวนเต็มเรียกว่า argc, และอื่น ๆ คืออะไร?
มันเป็นอาเรย์ของสายใช่มั้ย?
เราเห็นสัญกรณ์วงเล็บเหลี่ยมที่
มันเป็นอาเรย์ของสาย
มันไม่ได้เป็นสตริงแต่ละ มันเป็นอาเรย์ของสาย
และทั้งสองมีปากเสียง argc และ argv, ช่วยให้คุณสามารถที่จะรู้ว่าข้อมูลของผู้ใช้
ได้จัดให้มีที่บรรทัดคำสั่ง และวิธีการหลายสิ่งที่พวกเขา
ที่มีให้ ณ บรรทัดคำสั่ง
สิ่งที่มีประโยชน์สวยที่จะทำงานกับ
>> argc ย่อมานับอาร์กิวเมนต์ และคุณควรจะรู้ว่าโดยวิธีการที่
ที่คุณสามารถเรียก argc สิ่งที่คุณต้องการ
คุณสามารถเรียก argv สิ่งที่คุณต้องการ
เหล่านี้เป็นเพียงชื่อเดิม ที่เราใช้สำหรับการนับอาร์กิวเมนต์ them--,
และในขณะที่เราจะได้เห็นในครั้งที่สอง เวกเตอร์อาร์กิวเมนต์ argv
แต่คุณจะได้ไม่ต้องเรียกพวกเขา argc และ argv ถ้าคุณไม่ต้องการ
แต่อัตภาพว่าเป็นสิ่งที่เราทำ
>> ดังนั้นต่อไป argc นับอาร์กิวเมนต์
มันเป็นตัวแปรจำนวนเต็มชนิดและเพื่อให้เป็น คุณอาจคาดหวังถ้าเรามีสองสิ่ง
ที่เรากำลังจะหา สิ่งเหล่านี้จะถูกพิมพ์
และวิธีการมากสิ่งที่ ผู้ใช้พิมพ์ argc คือ
จะบอกเราเท่าใด สิ่งที่ผู้ใช้พิมพ์
ดังนั้นจึงช่วยให้คุณมีจำนวนของ ผู้ใช้อาร์กิวเมนต์บรรทัดคำสั่ง
พิมพ์เมื่อโปรแกรมถูกประหารชีวิต
ดังนั้นถ้าโปรแกรมของคุณ เรียกจุดเฉือนโลภ
และภายในของโลภของคุณ โปรแกรมฟังก์ชั่นหลักของคุณ
มีการประกาศ int argc int หลักที่ สตริง argv วงเล็บแล้ว
argc ในกรณีที่เป็นหนึ่ง
ตอนนี้สังเกตเห็นเราทำไม่ได้ นับหลายสิ่งหลายอย่าง
ผู้ใช้พิมพ์หลังจากที่ชื่อโปรแกรม
ชื่อโปรแกรมที่ตัวเองนับ เป็นอาร์กิวเมนต์บรรทัดคำสั่ง
>> ดังนั้นจุดเฉือนโลภใน กรณีที่ argc เป็นหนึ่ง
หากผู้ใช้พิมพ์เฉือนโลภ 1024 CS50 ที่บรรทัดคำสั่งที่ argc ในกรณีที่
จะสาม
และเรารู้ว่านี้เพราะทาง ที่แบ่งระหว่างสตริง
มีการตรวจพบว่า มีพื้นที่ว่างหรือแท็บ
หรือสิ่งที่ต้องการระหว่างพวกเขา
ดังนั้นจำนวนเงินใด ๆ ของพื้นที่สีขาวที่เรียกว่า ระหว่างค่าพิมพ์บรรทัดคำสั่ง
แสดงให้เห็นว่ามีหลาย
ดังนั้นจุดเฉือนพื้นที่โลภ 1024 พื้นที่ CS50, argc ในกรณีที่สาม
>> argv เป็นเวกเตอร์โต้แย้ง
เวกเตอร์โดยวิธีการที่เป็นเพียง คำสำหรับอาร์เรย์
และนี่คืออาร์เรย์ สตริงที่ร้านค้า
หนึ่งสายต่อองค์ประกอบซึ่งเป็น สายที่ผู้ใช้จริง
พิมพ์ที่บรรทัดคำสั่ง เมื่อโปรแกรมถูกประหารชีวิต
ตอนนี้เป็นกรณีที่ กับอาร์เรย์ใด ๆ หากคุณ
จำได้จากการสนทนาของเรา อาร์เรย์องค์ประกอบแรกของ argv
เสมอไปที่จะพบ ที่ยึด argv ตารางศูนย์
นั่นเป็นครั้งแรกที่ดัชนี ของอาร์เรย์ argv
เพื่อให้ will-- และในความเป็นจริงที่จะ มักจะเป็นชื่อของโปรแกรม
มักจะตั้งอยู่ที่ argv วงเล็บเหลี่ยมศูนย์
>> องค์ประกอบสุดท้ายของ argv พบเสมอ ที่ argv วงเล็บ argc ลบหนึ่ง
คุณเห็นว่าทำไม?
โปรดจำไว้ว่าหลายองค์ประกอบ อยู่ในอาร์เรย์นี้
ดีที่เรารู้ว่ามันเป็น that-- argc จำนวนขององค์ประกอบ
หากผู้ใช้พิมพ์สามสิ่งที่ บรรทัดคำสั่งที่ argc สาม
แต่เนื่องจากในคเมื่อเรากำลังทำงาน กับอาร์เรย์แต่ละองค์ประกอบของอาร์เรย์
หรือมากกว่าดัชนีของ อาร์เรย์เริ่มต้นที่ศูนย์
ถ้าเรามีสามองค์ประกอบของเรา อาร์เรย์เรามีองค์ประกอบที่ argv ศูนย์การ
องค์ประกอบที่ argv หนึ่ง, และองค์ประกอบที่สอง argv
มีองค์ประกอบที่เป็น argv สามและอาเรย์ที่มีขนาดสาม
เพื่อที่ว่าทำไมที่ผ่านมา องค์ประกอบของ argv สามารถเสมอ
พบได้ที่ตาราง argv วงเล็บ argc ลบหนึ่ง
>> ดังนั้นสมมติว่าผู้ใช้รัน โปรแกรมโลภเป็น follows--
ถ้าพวกเขาพิมพ์ในจุดบรรทัดคำสั่ง เฉือนพื้นที่โลภ 1024 พื้นที่ CS50,
และด้วยเหตุผลอะไรก็ตามที่เราได้ เตรียมไว้แล้วโปรแกรมโลภของเรา
ที่จะรู้และทำงานร่วมกับเหล่านี้ อาร์กิวเมนต์บรรทัดคำสั่ง
เราไม่ได้ก่อนหน้านี้เมื่อเราทำงาน ที่มันสำหรับปัญหาโลภ
แต่ขอบอกว่าเราได้มีการปรับเปลี่ยนในขณะนี้ เพื่อที่เราทำกระบวนการ
อาร์กิวเมนต์บรรทัดคำสั่งในทางใดทางหนึ่ง
ในกรณีนี้ argv ศูนย์ คือเฉือนจุดโลภ
สิ่งหนึ่ง argv?
ดีก็ 1024 ใช่มั้ย?
มันเป็น 1024 แต่ที่นี่เป็น distinction-- ที่สำคัญจริงๆ
คุณจำชนิดข้อมูลของ argv หรือไม่
>> มันเก็บสายใช่มั้ย?
แต่ดูเหมือนว่า 1024 เป็นค่าจำนวนเต็ม
นี่คือสิ่งที่สำคัญจริงๆ ความแตกต่างและเป็นจริง
จะกลายเป็นสิ่งที่คุณ อาจพบในปัญหาในภายหลัง
ทุกอย่างใน argv เป็น เก็บไว้เป็นสตริง
ดังนั้นเนื้อหาของคน argv เป็น สตริงหนึ่งศูนย์สองสี่
ซึ่งประกอบด้วยผู้ที่สี่ตัวอักษร
มันเหมือนกับว่าผู้ใช้พิมพ์ หนึ่งศูนย์สองสี่
เป็นตัวอักษรของแต่ละบุคคลหรือตัวอักษร
มันไม่ได้เป็นจำนวนเต็ม 1024, และเพื่อให้คุณไม่สามารถโดยตรง
ทำงานกับมันด้วยการพูดว่า int 1000 หรือ ค่อนข้าง int x เท่ากับ argv หนึ่งลบ 24
>> สังหรณ์ใจที่คุณอาจคิดว่า เป็นตกลงกันมันเป็น 1,024 ลบ 24
ดังนั้น x เท่ากับ 1,000
แต่ในความเป็นจริงที่ไม่ได้กรณีที่ เพราะ argv เป็นสตริง
สตริง 1024
ขณะนี้มีฟังก์ชั่นที่สามารถ ใช้ในการแปลงสตริงเพื่อจำนวนเต็ม
ฉันจะไม่เสียมันสำหรับคุณ ตอนนี้ แต่ผมมั่นใจว่า Zamyla
จะมีความสุขที่จะบอกคุณเกี่ยวกับมันใน คำแนะนำสำหรับปัญหาที่เกิดขึ้นในอนาคต
แต่คุณยังสามารถหา ปัญหาข้อแก้ตัว like--
ผมฟังก์ชั่นที่จะ ทำเช่นนี้ใน 50 อ้างอิง
ถ้าคุณไปที่คู่มืออ้างอิง คุณสามารถหาฟังก์ชั่นที่
จะทำให้การแปลงนี้สำหรับคุณ
แต่อีกครั้งในคำแนะนำแบบ สำหรับปัญหาในอนาคต
Zamyla ยินดีที่จะ บอกคุณว่าฟังก์ชั่น
มันคือการที่จะแปลง สตริงจำนวนเต็ม 1024 ถึง 1024
>> ทั้งหมดขวาเพื่อย้าย
เราได้ครอบคลุมศูนย์ argv ของเรา เราได้ครอบคลุม argv หนึ่ง
สิ่งที่อยู่ใน argv สอง?
CS50
หนึ่งที่อาจ สวยด้วยตนเองอธิบาย
สิ่งที่อยู่ใน argv สาม?
ดีอีกครั้งที่เราไม่ทราบจริงๆใช่มั้ย?
เรามีอาร์เรย์ของขนาดสามที่ ว่าเป็นวิธีที่หลาย ๆ องค์ประกอบที่ผู้ใช้
พิมพ์ที่บรรทัดคำสั่ง, ดังนั้นถ้าเราไป argv สาม
ตอนนี้เรา overstepping ขอบเขตของอาร์เรย์ของเรา
คอมไพเลอร์จะช่วยให้เราทำเช่นนี้ ไม่มีปัญหาที่ใช้งานง่ายกับมัน
แต่ในแง่ของจริงสิ่งที่เกิดขึ้น ที่จะเกิดขึ้นเราไม่ทราบจริงๆ
มันขึ้นอยู่กับสิ่งที่เป็น ตั้งอยู่ที่หน่วยความจำที่
argv สามจะได้รับการคาดว่าจะเป็น
และเพื่อให้เราจะจบลง รับไปฟรีลอยนวล
มีโอกาสมากขึ้นกว่าไม่ได้โดยเฉพาะอย่างยิ่งเมื่อ คุณกำลังทำงานกับ argv ตรงข้าม
ไปยังอาร์เรย์อื่น ๆ ที่อยู่ในโปรแกรมของเรา
เราอาจจะต้องทนทุกข์ทรมาน ความผิดพลาดในการแบ่งส่วน ดังนั้นอีกครั้ง
จะแน่ใจว่าจะไม่ล้ำเส้นขอบเขต ของอาร์เรย์ของคุณโดยเฉพาะ argv,
รับระดับสูงของ ความสำคัญในโปรแกรมของคุณ
>> ฉันลอยด์ดั๊ก
นี่คือ CS50