>> [เสียงเพลง]
>> เดวิดเจลัน: สิทธิทั้งหมด
นี่คือ CS50 และนี่ เป็นจุดเริ่มต้นของสัปดาห์ที่ 2
และคุณจะจำได้ว่าในช่วง คู่ที่ผ่านมาของสัปดาห์ที่ผ่านมา
เราได้รับการแนะนำคอมพิวเตอร์ วิทยาศาสตร์และในทางกลับกันการเขียนโปรแกรม
>> และเราเริ่มต้นเรื่องราวโดยวิธีการ รอยขีดข่วนว่าภาษากราฟิก
จากเอ็มไอทีมีเดียแล็บ
และจากนั้นเมื่อเร็ว ๆ นี้ สัปดาห์ที่แล้วเราได้
แนะนำ higher-- ภาษาในระดับต่ำกว่าที่รู้จักกัน
C, บางสิ่งบางอย่างที่เกี่ยวกับใจอย่างหมดจด
และแน่นอนครั้งสุดท้ายที่เรา การสำรวจในบริบทที่
จำนวนของแนวคิด
>> นี้เรียกเป็นอย่างมาก โปรแกรมแรกที่เรามองไปที่
และโปรแกรมนี้ค่อนข้างง่าย พิมพ์ออก "Hello, world."
แต่มีมาก มายากลดูเหมือนเกิดขึ้น
มี #include นี้เป็น ด้วยวงเล็บมุมเหล่านี้
มี int เป็น
มี (void)
มีวงเล็บวงเล็บปีกกาของ กึ่งทวิภาคและอื่น ๆ อีกมากมาย
>> และเพื่อให้จำได้ว่า เราได้นำรอยขีดข่วน
เพื่อให้เราสามารถนึกคิดเห็นอดีต ไวยากรณ์ว่าสิ่งที่เป็นจริงไม่
ทุกสิ่งที่สติปัญญา แต่ที่น่าสนใจในช่วงต้น
คืออย่างบิตหากิน มัดใจรอบ
และแน่นอนหนึ่งที่พบมากที่สุด สิ่งที่ในช่วงต้นของการเรียนการเขียนโปรแกรม
โดยเฉพาะอย่างยิ่งสำหรับผู้น้อย ความสะดวกสบายที่จะได้รับความผิดหวังจากการ
และดีดกลับขึ้นมาจากบางประโยค ข้อผิดพลาดที่ไม่พูดถึงข้อผิดพลาดเชิงตรรกะ
และในหมู่เป้าหมายของเรา วันนี้จริงจะ
จะจัดให้คุณกับบางส่วน เทคนิคการแก้ปัญหาสำหรับวิธีการ
ที่ดีกว่าการแก้ปัญหาตัวเอง ในรูปแบบของการแก้จุดบกพร่อง
และคุณจะจำได้เหมือนกันว่า สภาพแวดล้อมที่เราแนะนำ
ครั้งสุดท้ายที่ถูกเรียกว่า CS50 IDE
นี้เป็นซอฟต์แวร์บนเว็บที่ ช่วยให้คุณสามารถเขียนโปรแกรมในเมฆ
เพื่อที่จะพูดในขณะที่เก็บทั้งหมดของคุณ ไฟล์เข้าด้วยกันในขณะที่เราในวันนี้อีกครั้งจะ
และจำได้ว่าเรา หัวข้อเหล่านี้มาเยือนที่นี่
ในหมู่พวกเขาฟังก์ชั่นและลูปและ ตัวแปรและการแสดงออกบูลีน
และเงื่อนไข
และจริงอีกไม่กี่ที่เรา แปลมาจากโลกของรอยขีดข่วน
สู่โลกของซี
>> แต่อาคารพื้นฐาน บล็อกเพื่อที่จะพูด
จริงๆยังคงเป็นสัปดาห์ที่ผ่านมาเช่นเดียวกัน
ในความเป็นจริงเราจริงๆเพียงแค่มี ชิ้นส่วนจิ๊กซอว์ที่แตกต่างกันถ้าคุณจะ
แทนที่จะเป็นสีม่วงว่า บันทึกบล็อกเราแทน
ได้ printf ซึ่งเป็น ฟังก์ชั่นนี้ใน C ที่
ช่วยให้คุณพิมพ์บางสิ่งบางอย่าง และจัดรูปแบบบนหน้าจอ
เราแนะนำ CS50 ห้องสมุดที่คุณ
มีตอนนี้ที่ get_char การกำจัดของคุณ และ get_int และ get_string,
และฟังก์ชั่นอื่น ๆ ไม่กี่เป็น ดีผ่านทางที่คุณจะได้รับการป้อนข้อมูล
จากแป้นพิมพ์ของผู้ใช้
และเรายังได้ดูสิ่งที่ เช่นบูล these- และถ่าน
และดับเบิลลอย int สตริง long_long
และมีแม้กระทั่งชนิดข้อมูลอื่น ๆ ใน C.
>> ในคำอื่น ๆ เมื่อคุณประกาศ ตัวแปรเพื่อเก็บค่าบางอย่าง
หรือเมื่อคุณใช้ฟังก์ชั่น ที่ส่งกลับค่าบางอย่าง
คุณสามารถระบุสิ่งที่ ประเภทของค่าที่
มันเป็นสตริงเช่น ลำดับของตัวอักษร?
มันเป็นตัวเลขเช่นจำนวนเต็ม?
มันเป็นจุดลอย คุ้มค่าหรือชอบ?
ดังนั้นใน C ซึ่งแตกต่างจากรอยขีดข่วนเราจริง เริ่มที่จะระบุชนิดของข้อมูล
เรากำลังจะกลับหรือใช้
>> แต่แน่นอนเรายังวิ่งเข้าไป บางข้อ จำกัด ของการใช้คอมพิวเตอร์พื้นฐาน
และโดยเฉพาะอย่างยิ่ง นี้ภาษา C การเรียกคืน
ที่เราเอามาดูที่ ล้นจำนวนเต็มในความเป็นจริง
ว่าถ้าคุณมีเพียง จำนวน จำกัด ของหน่วยความจำ
หรือเฉพาะจำนวน จำกัด ของบิตคุณสามารถนับสูงมาก
และเพื่อให้เรามองไปที่ตัวอย่างนี้ที่นี่ โดยเคาน์เตอร์ในเครื่องบิน,
ที่จริงถ้าทำงานนานพอที่จะ ล้นและผลในซอฟต์แวร์
ข้อผิดพลาดที่เกิดขึ้นจริงที่มีศักยภาพทางกายภาพ
>> นอกจากนี้เรายังมองไปที่ลอย จุดไม่แน่ชัดในความเป็นจริง
ที่มีเพียงจำนวน จำกัด ของบิตไม่ว่าจะเป็น 32 หรือ 64
คุณสามารถระบุตัวเลขจำนวนมากดังนั้น หลังจากจุดทศนิยมหลังจากที่คุณ
เริ่มต้นที่จะได้รับไม่แน่ชัด
ดังนั้นสำหรับตัวอย่างเช่นหนึ่งในสามใน โลกที่นี่ในโลกมนุษย์ของเรา
เรารู้ว่าเป็นเพียงจำนวนอนันต์ ของ 3s หลังจุดทศนิยม
แต่คอมพิวเตอร์ไม่สามารถจำเป็น แทนจำนวนอนันต์ของตัวเลข
ถ้าคุณจะให้มันบาง จำนวน จำกัด ของข้อมูล
>> ดังนั้นไม่เพียง แต่เราจัดให้คุณ ที่มีอำนาจมากขึ้นในแง่
วิธีการที่คุณอาจจะแสดงตัวเองที่ แป้นพิมพ์ในแง่ของการเขียนโปรแกรม
นอกจากนี้เรายัง จำกัด สิ่งที่ คุณสามารถทำได้จริง
และแน่นอนข้อบกพร่องและความผิดพลาดสามารถ เกิดขึ้นจากชนิดของปัญหา
และแน่นอนในหัวข้อวันนี้ กำลังจะเป็นหัวข้อต่างๆเช่นการแก้จุดบกพร่อง
และที่จริงมองใต้กระโปรงหน้ารถ ในสัปดาห์ที่ผ่านมาว่าสิ่งที่ถูกนำมาใช้
จะดำเนินการจริง เพื่อให้คุณดีขึ้น
เข้าใจความสามารถของทั้งสองและ ข้อ จำกัด ของภาษาเช่นซีที่
>> และในความเป็นจริงเราจะปอกเปลือกกลับชั้น ของที่ง่ายที่สุดของโครงสร้างข้อมูล
สิ่งที่เรียกว่าอาร์เรย์ซึ่ง รอยขีดข่วนที่เกิดขึ้นเรียกว่า "รายการ".
มันนิด ๆ หน่อย ๆ ที่แตกต่างกันในบริบทที่
แล้วเรายังจะแนะนำหนึ่งใน แรกของปัญหาเฉพาะโดเมนของเรา
ใน CS50 โลกของ วิทยาการศิลปะของ scrambling
หรือใน ciphering ข้อมูลเพื่อ ที่คุณสามารถส่งข้อความลับ
และถอดรหัสข้อความลับ ระหว่างคนสองคน, A และ B
>> ดังนั้นก่อนที่เราจะเปลี่ยนแปลง เพื่อโลกใหม่ที่
ลองจัดให้คุณกับบางส่วน เทคนิคที่คุณสามารถกำจัด
หรือลดอย่างน้อยบางส่วน ของความผิดหวัง
ที่คุณอาจจะได้พบ ในช่วงสัปดาห์ที่ผ่านมาเพียงอย่างเดียว
ในความเป็นจริงข้างหน้าของคุณจะ such-- บางส่วนของ ปัญหาที่เกิดขึ้นครั้งแรกของคุณใน C. และราคาเป็น
ถ้าคุณชอบฉันเป็นครั้งแรก คุณพยายามที่จะพิมพ์ออกโปรแกรม
แม้ว่าคุณจะคิดว่ามีเหตุผล โปรแกรมคือสวยเรียบง่าย
คุณเป็นอย่างดีอาจจะชนกำแพงและ คอมไพเลอร์จะไม่ให้ความร่วมมือ
ทำให้เสียงดังกราวหรือไม่ได้ไป ที่จริงทำตามคำสั่งของคุณ
>> และเหตุผลที่ว่าอาจจะมี?
ดีขอดูที่, บางทีอาจจะเป็นโปรแกรมที่ง่าย
ฉันจะไปข้างหน้าและบันทึกนี้ ไฟล์จงใจเรียก buggy0.c,
เพราะผมรู้ว่ามันจะ เป็นข้อบกพร่องล่วงหน้า
แต่ผมอาจจะไม่ทราบว่าถ้านี้ เป็นโปรแกรมแรกหรือครั้งที่สองหรือสาม
ว่าฉันจริงทำให้ตัวเอง
ดังนั้นฉันจะไปข้างหน้าและ พิมพ์ออก int main (void)
และจากนั้นภายในวงเล็บปีกกาของฉัน ที่คุ้นเคยมาก ( "สวัสดี world--
ทับขวา, N ") - และ semi-colon
>> ผมเคยบันทึกไฟล์
ตอนนี้ฉันจะไปลง เพื่อหน้าต่าง terminal ของฉัน
และประเภทแต่งหน้า buggy0 เพราะอีกครั้ง ชื่อของไฟล์ในวันนี้คือ buggy0.c
ดังนั้นผมจึงทำให้พิมพ์ buggy0 ใส่
>> และโอ้เอ้ยจำจากครั้งสุดท้าย ว่าข้อความที่ไม่มีข้อผิดพลาดเป็นสิ่งที่ดี
ดังนั้นผลลัพธ์ออกมาเป็นสิ่งที่ดี
แต่ที่นี่ผมมีอย่างชัดเจน จำนวนผิดพลาดบางอย่าง
>> ดังนั้นบรรทัดแรกของการส่งออก หลังจากพิมพ์ให้ buggy0 จำ
เป็นผล verbose ค่อนข้างเสียงดังกราวของ
ภายใต้ประทุน IDE CS50 มีการกำหนดค่า
จะใช้ทั้งกลุ่ม ตัวเลือกที่มีคอมไพเลอร์นี้
เพื่อให้คุณไม่ได้ ที่จะคิดเกี่ยวกับพวกเขา
และนั่นคือทั้งหมดที่บรรทัดแรก วิธีการที่เริ่มต้นด้วยเสียงดังกราว
>> แต่หลังจากนั้นปัญหาที่เกิดขึ้น เริ่มต้นที่จะทำให้ลักษณะของพวกเขา
Buggy0.c ในบรรทัดที่ 3 ตัวอักษร 5 มีขนาดใหญ่สีแดงข้อผิดพลาด
นั่นคืออะไร?
โดยปริยายประกาศฟังก์ชั่นห้องสมุด printf กับชนิด int (const char *,
... ) [-Werror]
ฉันหมายความว่ามันได้อย่างรวดเร็ว ได้รับความลับมาก
และแน่นอนว่าในตอนแรก ได้อย่างรวดเร็วเราจะไม่
คาดหวังว่าคุณจะเข้าใจ ความสมบูรณ์ของข้อความนั้น
และเพื่อให้เป็นหนึ่งในบทเรียน สำหรับวันนี้เป็นไป
ที่จะพยายามที่จะแจ้งให้ทราบ รูปแบบหรือสิ่งที่คล้ายกัน
ข้อผิดพลาดที่คุณอาจมี พบในอดีตที่ผ่านมา
ดังนั้นขอแซวออกจากกันเท่านั้น คำพูดเหล่านั้นที่ดูคุ้นเคย
ขนาดใหญ่สีแดงข้อผิดพลาดอย่างชัดเจน สัญลักษณ์ของบางสิ่งบางอย่างผิด
>> โดยปริยายประกาศ ห้องสมุด printf ฟังก์ชั่น
ดังนั้นแม้ว่าผมจะไม่เข้าใจสิ่งที่ โดยปริยายประกาศฟังก์ชั่นห้องสมุด
หมายถึงปัญหาที่เกิดขึ้นอย่างแน่นอน เกี่ยวข้องกับ printf อย่างใด
และแหล่งที่มาของปัญหาว่า จะทำอย่างไรกับประกาศว่า
>> ประกาศฟังก์ชั่น กล่าวถึงมันเป็นครั้งแรก
และเราใช้คำศัพท์สัปดาห์ที่ผ่านมา ประกาศของต้นแบบฟังก์ชั่นของการ
ทั้งที่มีหนึ่งบรรทัดที่ด้านบนของคุณ ไฟล์ของตัวเองหรือในไฟล์ส่วนหัวที่เรียกว่า
และในสิ่งที่ทำไฟล์ที่เราพูด สัปดาห์ที่แล้วว่าเป็น printf อ้าง
ได้นำมาอ้างประกาศ?
ในสิ่งที่ไฟล์ต้นแบบของตนหรือไม่
>> ดังนั้นถ้าคุณจำสิ่งแรกที่ผม พิมพ์เกือบทุกโปรแกรม time-- สุดท้าย
และตั้งใจสักครู่ที่ผ่านมาเริ่มต้น พิมพ์ myself-- เป็นหนึ่ง here--
hash-- #include <stio-- สำหรับ อินพุต / output-- จุด H และแน่นอน
ถ้าตอนนี้ผมบันทึกไฟล์นี้ฉันจะ ไปข้างหน้าและล้างหน้าจอของฉัน
ซึ่งคุณสามารถทำโดยการพิมพ์ ชัดเจนหรือคุณสามารถกด Control L,
เพียงเพื่อล้างหน้าต่าง terminal ของคุณ เพียงเพื่อขจัดความยุ่งเหยิงบาง
>> ฉันจะไปข้างหน้าและ Re ชนิดทำให้ buggy0 ใส่
และ voila ฉันยังคงเห็นว่า คำสั่งที่ยาวจากเสียงดังกราว,
แต่มีข้อผิดพลาดจะไม่มีเวลานี้
และแน่นอนถ้าผมทำ ./buggy0, เช่นเดียวกับครั้งสุดท้าย
ที่จุดนี้หมายถึง ไดเรกทอรี Slash เพียงหมายความว่า
นี่มาชื่อของโปรแกรมและ ชื่อของโปรแกรมที่เป็น buggy0,
ใส่ "Hello, world."
>> ตอนนี้วิธีที่คุณอาจมี รวบรวมการแก้ปัญหานี้
โดยไม่จำเป็นต้อง ตระหนักถึงคำให้มากที่สุด
เป็นผมอย่างแน่นอนมี ทำแบบนี้มาหลายปี?
ดีตระหนักต่อปัญหาที่เกิดขึ้นเป็นครั้งแรก ชุดเราแนะนำให้คุณคำสั่ง
ที่พนักงานของตัวเองของ CS50 เขียนเรียกว่า help50
และแน่นอน, C ไม่ข้อกำหนดสำหรับ ปัญหาที่กำหนดเป็นวิธีการที่จะใช้นี้
>> แต่ help50 เป็นหลัก โปรแกรมที่พนักงานของ CS50
เขียนที่ช่วยให้คุณสามารถเรียกใช้ คำสั่งหรือเรียกใช้โปรแกรม
และถ้าคุณไม่เข้าใจมัน การส่งออกที่จะผ่านการส่งออกไปยัง help50,
จุดที่ซอฟแวร์ ที่พนักงานของหลักสูตรเขียน
จะมีลักษณะที่การส่งออกของโปรแกรม ทีละบรรทัดตัวอักษรตัวอักษร
และถ้าเราพนักงานที่รับรู้ ข้อผิดพลาดที่คุณพบ
เราจะพยายามที่จะกระตุ้นให้คุณมีบางส่วน คำถามเชิงโวหารมีคำแนะนำบางอย่าง
เหมือน TF หรือ CA หรือตัวเอง จะทำอย่างไรคนที่อยู่ในเวลาราชการ
>> ดังนั้นมองไป help50 ถ้าคุณทำไม่ได้ จำเป็นต้องรับรู้ปัญหา
แต่ไม่ต้องพึ่งพามัน มากเกินไปเป็นไม้ยันรักแร้
แน่นอนพยายามที่จะเข้าใจมัน การส่งออกแล้วเรียนรู้จากมัน
เพื่อให้มีเพียงครั้งหรือสองครั้งที่คุณทำ เคยทำงาน help50 สำหรับข้อผิดพลาดโดยเฉพาะอย่างยิ่ง
ข่าวสาร
หลังจากนั้นคุณควรจะเป็น การติดตั้งตัวเองดีกว่า
จะคิดออกว่ามันเป็นจริง
>> ให้ทำอย่างใดอย่างหนึ่งอื่น ๆ ที่นี่
ให้ฉันไปข้างหน้าและในอีก ไฟล์เราจะเรียก buggy1.c นี้
และในแฟ้มนี้ฉัน จะ deliberately--
แต่แกล้งทำเป็นว่าฉันทำไม่ได้ เข้าใจในสิ่งที่ผิดพลาดที่ผมได้ทำ
>> ฉันจะไปข้างหน้าและทำ this-- #include ตั้งแต่ฉันได้
ได้เรียนรู้บทเรียนของฉันจากช่วงเวลาที่ผ่านมา
int main (void) เป็นมาก่อน
และจากนั้นในที่นี่ฉันจะ จะทำสตริง - get_string
และจำได้จากครั้งสุดท้ายที่ วิธีนี้ Hey, คอมพิวเตอร์,
ให้ฉันตัวแปรเรียกมันและ ทำให้ประเภทของตัวแปรที่สตริง
ดังนั้นผมจึงสามารถเก็บหนึ่งหรือมากกว่าคำพูดในนั้น
>> และจากนั้นในขวามือ ด้านข้างของเครื่องหมายเท่ากับ
เป็น get_string ซึ่งเป็น ฟังก์ชั่นในห้องสมุด CS50
ที่ไม่ตรงกับที่
จะได้รับฟังก์ชั่นแล้ว มือมันจากขวาไปซ้าย
ดังนั้นเครื่องหมายเท่ากับนี้ไม่ได้หมายความว่า "เท่ากับ" ในขณะที่เราอาจจะคิดว่าในวิชาคณิตศาสตร์
มันหมายถึงการโอนจากขวาไปซ้าย
ดังนั้นหมายความใช้สตริงจาก ผู้ใช้และเก็บไว้ภายในของ s
>> ตอนนี้ขอใช้มัน
ผมขอไปข้างหน้าในขณะนี้และเป็นครั้งที่สอง บรรทัดให้ฉันไปข้างหน้าและพูดว่า "สวัสดี" -
ไม่ได้เป็น "โลก" แต่ "สวัสดี% s-- ซึ่งเป็นตัวยึดของเราจุลภาค S,
ซึ่งเป็นตัวแปรของเรา แล้ว semi-colon
ดังนั้นถ้าผมไม่ได้กรูขึ้นมากเกินไป นี่นี้ดูเหมือนว่ารหัสที่ถูกต้อง
>> และสัญชาตญาณของฉันตอนนี้คือการรวบรวมมัน
ไฟล์จะถูกเรียกว่า buggy1.c
ดังนั้นฉันจะทำอะไรให้ buggy1 ใส่
และสาปมันถ้ามีไม่ได้ แม้จะมีข้อผิดพลาดมากขึ้นกว่าก่อน
ผมหมายถึงมีมากขึ้น ข้อความผิดพลาดมันจะ
ดูเหมือนกว่าเส้นที่เกิดขึ้นจริงในโปรแกรมนี้
>> แต่ Takeaway ที่นี่คือ แม้ว่าคุณจะจม
มีสองหรือสามหรือ สี่ข้อผิดพลาดมากขึ้น
มุ่งเน้นเสมอในมาก แรกของข้อความเหล่านั้น
มองไปที่ด้านบนสุดหนึ่ง เลื่อนกลับขึ้นไปเป็นจำเป็นต้องเป็น
ดังนั้นที่นี่ฉันพิมพ์ทำให้ buggy1
นี่คือเสียงดังกราวว่าการส่งออกตามที่คาดไว้
>> และนี่คือความผิดพลาดครั้งแรกสีแดง
การใช้งานของตัวระบุที่ไม่ได้ประกาศ สตริงไม่ผมหมายถึงมาตรฐานมีอะไรบ้าง?
ดังนั้นในมาตรฐานคือ บางสิ่งบางอย่างอื่นจริง
มันหมายถึงการใช้งานของ แป้นพิมพ์เป็นหลัก
>> แต่นั่นไม่ใช่สิ่งที่ผมหมายถึง
ฉันหมายถึงสตริงและฉันหมาย get_string
ดังนั้นมันจึงเป็นสิ่งที่ฉัน ลืมที่จะทำครั้งนี้หรือไม่
สิ่งที่หายไปครั้งนี้หรือไม่
ฉันมี #include ของฉัน ดังนั้นผมจึงมีการเข้าถึง printf
>> แต่สิ่งที่ฉันไม่ได้ การเข้าถึงยังเพียง?
ดีเช่นเดียวกับครั้งสุดท้าย ผมจำเป็นต้องบอกคอมไพเลอร์
เสียงดังกราวสิ่งเหล่านี้มีฟังก์ชั่น
Get_string ไม่ได้มา กับซีและโดยเฉพาะอย่างยิ่งมัน
ไม่ได้มาใน ไฟล์ส่วนหัว
มันแทนมาใน สิ่งที่พนักงานเขียน
ซึ่งเป็นไฟล์ที่แตกต่างกัน ชื่อ แต่ชื่อ aptly
>> ดังนั้นเพียงโดยการเพิ่มว่าหนึ่งบรรทัด ของการเรียกคืน code-- จากครั้งสุดท้าย
ว่าเมื่อเสียงดังกราวทำงานก็จะ จะมองไปที่ด้านบนรหัสของฉันลงล่าง
จากซ้ายไปขวา.
ก็จะแจ้งให้ทราบล่วงหน้า โอ้คุณต้องการ
ผมขอไปและพบว่า ทุกที่ที่มันอยู่บนเซิร์ฟเวอร์
คัดลอกและวางเป็นหลัก ลงไปบนของไฟล์ของคุณเอง
เพื่อให้ที่จุดนี้ในเรื่อง บรรทัดที่ 1 ส่วนที่เหลือของโปรแกรม
สามารถจริงใช้ใด ๆ ของฟังก์ชั่น ในนั้นในหมู่พวกเขา get_string
ดังนั้นผมจะไม่สนใจ ส่วนที่เหลือของข้อผิดพลาดเหล่านั้น
เพราะผมแน่นอนเพียง แต่สงสัยว่า คนแรกที่สำคัญจริง
และฉันจะไปข้างหน้าและวิ่ง, หลังจากบันทึกไฟล์ของฉันทำ buggy1
และ voila มันไม่ทำงาน
และถ้าผมทำ ./buggy1 และพิมพ์สำหรับ เช่น Zamyla ตอนนี้ผมจะได้รับสวัสดี
Zamyla แทน Hello, world
>> ก็ดี
ดังนั้นประเด็นที่นี่จึงจะเป็นไป หนึ่งพยายามที่จะรวบรวมให้มากที่สุดเท่าที่คุณสามารถ
จากข้อความผิดพลาดเพียงอย่างเดียวมอง ที่บางส่วนของคำพูดที่เป็นที่รู้จัก
แบริ่งที่ใช้ help50 ต่อ ปัญหาการตั้งค่าสเปค
แต่ยกเว้นที่มากเกินไปมองเสมอ ที่ข้อผิดพลาดด้านบนเพียงอย่างน้อย
ในขั้นต้นเพื่อดูว่าข้อมูล มันอาจจะให้ผลจริง
แต่มันจะเปิดออกมีของ การทำงานมากยิ่งขึ้นสร้างขึ้น
เข้าไปในห้องสมุด CS50 ที่จะช่วยให้ คุณในช่วงต้นของภาคการศึกษา
และในช่วงต้นในการเขียนโปรแกรม คิดออกสิ่งที่เกิดผิด
เพื่อขอทำอีกตัวอย่างหนึ่งที่นี่
ฉันจะโทร buggy2 นี้ซึ่ง อีกครั้งเป็นไปได้ไม่สมบูรณ์ออก
จากประตูจากการออกแบบ
>> และฉันจะไปข้างหน้า และทำ #include
แล้วฉันจะทำ int main (void)
แล้วฉันจะทำสำหรับห่วง
สำหรับ (int i _ 0
ฉันมีค่าน้อยกว่าหรือเท่ากับ 10
i ++ และจากนั้นในวงเล็บปีกกาฉันจะ จะพิมพ์ออกมาเป็นเพียงแค่สัญลักษณ์แฮชแท็กที่นี่
และตัวอักษรบรรทัดใหม่
>> ดังนั้นความตั้งใจของฉันกับเรื่องนี้ โปรแกรมค่อนข้างเป็นเพียง
เพื่อย้ำ 10 ครั้ง และในแต่ละซ้ำ
ของวงว่าทุกครั้งที่ ผ่านวงจร
พิมพ์ออกมาแฮชแท็ก แฮชแท็ก, แฮชแท็ก
บรรทัดต่อหนึ่งเพราะผม มีการขึ้นบรรทัดใหม่มี
และจำได้ว่าสำหรับ ห่วงต่อ week-- สุดท้าย
และคุณจะได้รับเพิ่มเติม คุ้นเคยกับไวยากรณ์
โดยใช้มันกับการปฏิบัติ ก่อนที่จะ long-- นี้ให้ฉัน
ตัวแปรที่เรียกว่า I และชุดมันเป็น 0
>> นี้เพิ่มฉันใน ซ้ำโดยทุก 1
ดังนั้นฉันไปเป็น 1 เพื่อ 2-3
แล้วสภาพนี้ใน ตรงกลางระหว่างจุดคู่กึ่ง
ได้รับการตรวจสอบในทุกย้ำที่จะทำให้ แน่ใจว่าเรายังคงอยู่ในช่วง
ดังนั้นผมจึงอยากจะย้ำ 10 ครั้งดังนั้นฉัน มีการจัดเรียงมากสังหรณ์ใจเพียง
ใส่ 10 ขอบเขตบนของฉันมี
>> และยังเมื่อฉันทำงานนี้หลังจาก รวบรวมกับ Make buggy2--
และมันไม่รวบรวมตกลง
ดังนั้นผมจึงไม่ได้มีการ ไวยากรณ์ผิดพลาดในครั้งนี้
ผมขอไปข้างหน้าในขณะนี้ และเรียกใช้ buggy2 ใส่
และตอนนี้เลื่อนขึ้น
และแจ้งให้เราเพิ่มขึ้น ขนาดของหน้าต่าง
>> ฉันดูเหมือนจะมี 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
ดังนั้นจึงมี 11 hashtags แม้ว่า ฉันชัดเจนใส่ภายใน 10 ของวงนี้
ตอนนี้บางท่านอาจจะเห็นได้ทันที สิ่งที่ผิดพลาดเป็นเพราะจริงนี้
ไม่ได้เป็นข้อผิดพลาดที่ยากมากที่จะทำให้
แต่มันเป็นบ่อยมาก ทำมากในช่วงต้น
>> สิ่งที่ผมอยากจะชี้ให้เห็น แต่ คือวิธีที่ผมอาจจะคิดออกนี้?
ดีก็ปรากฎว่า ห้องสมุด CS50 มา
ไม่เพียง get_string และ get_int และ get_float และฟังก์ชั่นอื่น ๆ
นอกจากนี้ยังมาพร้อมกับฟังก์ชั่นพิเศษ เรียกว่า eprintf หรือ printf ข้อผิดพลาด
และมันมีอยู่ แต่เพียงผู้เดียวที่จะทำให้ มันเล็กน้อยง่ายสำหรับคุณ
เมื่อการแก้จุดบกพร่องรหัสของคุณเพียงแค่ พิมพ์ข้อความผิดพลาดบนหน้าจอ
และรู้ว่ามันมาจากไหน
>> ดังนั้นสำหรับตัวอย่างเช่นสิ่งหนึ่งที่ผมอาจจะ ทำที่นี่ด้วยฟังก์ชั่นนี้เป็น this--
eprintf แล้วฉันจะไปข้างหน้า และกล่าวว่าตอนนี้ฉันคือ% i, ทับขวา, N
และฉันจะเสียบค่าของฉัน
และขึ้นด้านบนเพราะนี้ อยู่ในห้องสมุด CS50,
ฉันจะไปข้างหน้า และรวมถึง
ดังนั้นผมจึงมีการเข้าถึงฟังก์ชั่นนี้
แต่ขอพิจารณาสิ่งที่บรรทัด 9 ควรจะทำ
ฉันจะลบนี้ในที่สุด
นี้มีอะไรจะทำอย่างไร กับเป้าหมายที่ครอบคลุมของฉัน
แต่ eprintf, printf ข้อผิดพลาดที่มีความหมายเพียงแค่ จะให้ฉันข้อมูลการวินิจฉัยบาง
เมื่อฉันเรียกใช้โปรแกรมของฉันฉันต้องการที่จะ เห็นนี้บนหน้าจอชั่วคราว
จะดีแค่ที่จะเข้าใจ เกิดอะไรขึ้น.
>> และแน่นอนในแต่ละ ย้ำที่นี่ของสาย 9
ผมอยากจะเห็นสิ่งที่เป็นคุณค่าของฉันหรือไม่
ค่าของฉันคืออะไร?
และหวังว่าฉันควร เห็นข้อความที่ยัง 10 ครั้ง
>> เพื่อให้ฉันไปข้างหน้าและ คอมไพล์โปรแกรมของฉัน
ขณะที่ผมต้องทำตลอดเวลา ฉันจะทำให้การเปลี่ยนแปลง ./buggy2
และ now-- ตกลง
มีจำนวนมากขึ้นไปบน
เพื่อให้ฉันเลื่อนขึ้นใน หน้าต่างที่ยิ่งใหญ่
>> และคุณจะเห็นว่าแต่ละ แฮชแท็กยังคงพิมพ์
แต่ในระหว่างแต่ละของพวกเขาอยู่ในขณะนี้ เอาท์พุทวินิจฉัยรูปแบบดังนี้
ชื่อของโปรแกรมของฉันที่นี่คือ buggy2
ชื่อของไฟล์ที่เป็น buggy2.c
หมายเลขบรรทัดจากการที่ นี้ถูกตีพิมพ์เป็นสาย 9
และจากนั้นไปทางขวาของที่เป็น ข้อผิดพลาดที่ฉันคาดหวัง
>> และสิ่งที่ดีเกี่ยวกับเรื่องนี้ก็คือว่า ตอนนี้ฉันไม่จำเป็นต้องนับ
ในหัวของฉันสิ่งที่โปรแกรมของฉันจะทำ
ฉันจะเห็นว่าบน ย้ำแรกที่ผมเป็น 0
แล้ว 1 แล้ว 2 แล้ว 3 แล้ว 4 แล้ว 5 แล้ว 6 จากนั้น 7 แล้ว 8 แล้ว 9 แล้ว
10
ดังนั้นรอสักครู่
เกิดอะไรขึ้นที่นี่?
ฉันยังคงดูเหมือนจะนับ ตามที่ตั้งใจไว้ได้ถึง 10
>> แต่ผมไม่เริ่มต้นอย่างไร
0, 1, 2, 3, 4, 5, 6, 7, 8, 9 10
ดังนั้น 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10-- 11 นิ้ว
บ่งบอกถึงปัญหาที่เกิดขึ้น
ฉันดูเหมือนจะได้นับ ไม่ถูกต้องในวงของฉัน
แทนที่จะไป 10 การทำซ้ำ ฉันเริ่มที่ 0,
ฉันสิ้นสุดที่ 10 และผ่านการ
แต่เป็นเพราะเช่นเครื่องคอมพิวเตอร์ ฉันเริ่มนับที่ 0,
ฉันควรจะนับ แต่ไม่ผ่าน 10
>> และเพื่อให้การแก้ไขในที่สุดผม ตระหนักถึงที่นี่เป็นหนึ่งในสองสิ่ง
ฉันมากเพียงอาจจะบอกว่า นับถึงน้อยกว่า 10
ดังนั้น 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ซึ่งเป็นจริงที่ถูกต้อง
แม้ว่ามันจะฟังดูผิดเล็ก ๆ น้อย ๆ
หรือฉันจะทำน้อยกว่าหรือเท่ากับ 9 ตราบใดที่ผมเริ่มต้นที่ 0
หรือถ้าคุณไม่ชอบที่คุณ สามารถนับขึ้นถึง 10 แต่เริ่มต้นที่ 1
แต่อีกครั้งนี้ก็ไม่ได้เป็นที่พบบ่อย
ใน programming-- แม้ว่า ไม่มากใน Scratch--
แต่ในการเขียนโปรแกรมใน ภาษา C และอื่น ๆ
เช่น JavaScript และ งูหลามและคนอื่น ๆ ก็
เพียงแค่เรื่องธรรมดามากสำหรับ การอภิปรายของไบนารีของเรา
เพียงแค่เริ่มนับที่ จำนวนมากที่สุดที่คุณสามารถซึ่งเป็น 0
ก็ดี
ดังนั้นที่ eprintf
และอีกครั้งตอนนี้ที่ผมเคยคิดออกของฉัน ปัญหาและฉันจะกลับไปที่ 0
ผ่านน้อยกว่า 10 ฉันจะ ไปในการลบ eprintf
>> มันไม่ควรจะมีเมื่อฉัน จัดส่งรหัสของฉันหรือส่งรหัสของฉัน
หรือแสดงให้คนอื่น
มันจริงๆเพียงแค่ความหมาย ที่จะนำมาใช้ชั่วคราว
แต่ตอนนี้ฉันได้รับการแก้ไขนี้ ปัญหาเฉพาะเช่นกัน
>> ดีขอทำตัวอย่างหนึ่งที่เพิ่มเติมที่นี่ ว่าฉันจะชักขึ้นดังต่อไปนี้
ฉันจะไปข้างหน้าและ #include $ 50
และฉันจะไปข้างหน้า และ #include
>> และฉันจะประหยัด แฟ้มนี้เป็น buggy3.c
และฉันจะไปข้างหน้า และประกาศ int main (void)
และจากนั้นภายในมี ฉันจะทำ int i _ -
ฉันต้องการที่จะใช้โปรแกรม กับ get_negative_int
นี้ไม่ได้เป็นฟังก์ชั่นที่มีอยู่ยัง
ดังนั้นเรากำลังจะดำเนินการ ได้ในเพียงสักครู่
แต่เรากำลังจะไปดูว่าทำไม มันเป็นรถที่ผ่านครั้งแรก
และเมื่อผมเคย เป็น int จากผู้ใช้
ฉันแค่จะพิมพ์ฉัน% เป็นเชิงลบ จำนวนเต็มทับขวา, N, จุลภาคฉัน
ในคำอื่น ๆ ทั้งหมดที่ฉัน ต้องการโปรแกรมนี้จะทำอย่างไร
คือการได้รับ int เชิงลบจาก ผู้ใช้แล้วพิมพ์ออกมา
ที่ดังกล่าวและเช่นเป็น int เชิงลบ
>> ตอนนี้ผมต้องใช้ฟังก์ชั่นนี้
ดังนั้นต่อมาในแฟ้มของฉันฉันจะไป ไปข้างหน้าและประกาศฟังก์ชั่นที่เรียกว่า
get_negative_int (void) - และเราจะ กลับมากับสิ่งที่หมายถึงสายอีกครั้ง
ใน moment-- int n; do-- ทำ following-- printf n คือ :.
แล้วฉันจะทำ n - get_int, และทำในขณะนี้ n มากกว่า 0
แล้วกลับ n ;.
>> ดังนั้นมีจำนวนมากที่เกิดขึ้นใน แต่ไม่มีใครที่เราไม่ได้
มองไปที่สัปดาห์ที่ผ่านมาอย่างน้อยในเวลาสั้น ๆ
ดังนั้นในบรรทัด 10 นี่ผมได้ประกาศให้เป็น ฟังก์ชั่นที่เรียกว่า get_negative_int,
และฉันได้ใส่ (void) ใน วงเล็บเหตุผลที่มีนี้
ไม่ใช้การป้อนข้อมูล
ฉันไม่ได้ผ่านอะไร ฟังก์ชั่นนี้
ฉันแค่สิ่งที่ได้รับกลับมาจากมัน
>> และสิ่งที่ฉันหวังที่จะ ได้รับกลับเป็นจำนวนเต็ม
ไม่มีชนิดข้อมูลคือ C เรียกว่า negative_int
มันเป็นเพียงแค่ int เพื่อให้มันเป็นไป ที่จะอยู่กับเราเพื่อให้แน่ใจว่า
ว่าค่าที่เป็นจริง กลับไม่ได้เป็นเพียง int
แต่ก็ยังเป็นเชิงลบ
>> On line ที่ 12 ผมประกาศตัวแปร เรียกว่า n และทำให้มันเป็นชนิด int
และจากนั้นในบรรทัดที่ 13 ถึง 18 ฉัน ทำอะไรบางอย่างในขณะที่สิ่งที่เป็นความจริง
ฉันจะไปข้างหน้าและการพิมพ์ n คือลำไส้ใหญ่แล้วช่องว่าง
เช่นพรอมต์สำหรับผู้ใช้
>> ฉันแล้วโทร get_int และ การจัดเก็บค่าตอบแทนของสิ่งที่เรียกว่า
ในตัวแปรที่ n
แต่ฉันจะให้ทำ ขณะนี้ n มากกว่า 0
ในคำอื่น ๆ หากผู้ใช้ให้ฉัน int และจำนวนที่มากกว่า 0
Ergo บวกฉันจะ เพียงแค่ให้ reprompting ผู้ใช้
ให้ reprompting โดยบังคับให้พวกเขา ความร่วมมือและให้ฉัน int เชิงลบ
>> และเมื่อ n คือ negative-- จริง สมมติว่าผู้ใช้ที่สุดประเภท -50,
แล้วห่วงขณะนี้ไม่เป็นความจริง เพราะ -50 ไม่มากกว่า 0
ดังนั้นเราจึงแยกออกจากที่ ห่วงเหตุผลและกลับ n
>> แต่มีคนอื่น ๆ สิ่งที่ฉันต้องทำ
และฉันก็สามารถทำเช่นนี้ โดยการคัดลอกและวาง
หนึ่งบรรทัดของรหัสที่ด้านบนของไฟล์
ฉันต้องการที่จะสอนให้เสียงดังกราว, หรือสัญญาว่าจะเสียงดังกราว,
อย่างชัดเจนว่าผมจะ แน่นอนไปและดำเนินการ
get_negative_int ฟังก์ชั่นนี้
มันก็อาจจะลดลงในแฟ้ม
อีกครั้งจำได้ว่าเสียงดังกราว อ่านสิ่งบนลงล่าง
จากซ้ายไปขวาคุณจึงไม่สามารถ เรียกใช้ฟังก์ชันถ้าเสียงดังกราว
ไม่ทราบว่ามันจะมีอยู่
>> ตอนนี้น่าเสียดายที่โปรแกรมนี้ ขณะที่บางท่านอาจจะได้สังเกตเห็น
เป็นรถแล้ว
ให้ฉันไปข้างหน้าและทำให้ buggy3
มันรวบรวมดังนั้นปัญหาของฉันตอนนี้ไม่ได้ ไวยากรณ์ผิดพลาดเช่นข้อผิดพลาดเกี่ยวกับใจ,
จริงมันจะเป็นตรรกะ ข้อผิดพลาดที่ผมเคยจงใจ
ทำให้เป็นโอกาสต่อไปยัง ก้าวผ่านสิ่งที่เกิดขึ้น
>> ฉันจะไปข้างหน้า ในขณะนี้และวิ่ง buggy3
และฉันจะไป ข้างหน้าและไม่ให้ความร่วมมือ
ฉันจะให้หมายเลข 1
มันไม่ชอบมันดังนั้น มันกระตุ้นให้ฉันอีกครั้ง
>> วิธีการเกี่ยวกับ 2 หรือไม่?
3 หรือไม่?
50?
ไม่มีของเหล่านี้จะทำงาน
วิธีการเกี่ยวกับ -50?
และโปรแกรมที่ดูเหมือนว่าจะทำงาน
>> ผมขอลองอีกครั้ง
ผมขอลอง -1 ดูเหมือนว่าจะทำงาน
ผมขอลอง -2, ดูเหมือนว่าจะทำงาน
ผมขอลอง 0
อืมมมที่ไม่ถูกต้อง
ตอนนี้เรากำลังถูกอวดความรู้เล็ก ๆ น้อย ๆ ที่นี่
แต่มันเป็นความจริงกรณีที่ 0 เป็นค่าบวกหรือเชิงลบ
และเพื่อให้ความจริงที่ว่าโปรแกรมของฉันคือ บอกว่า 0 เป็นจำนวนเต็มลบ
ที่ไม่ถูกต้องในทางเทคนิค
>> ตอนนี้ทำไมมันทำเช่นนี้?
ดีก็อาจจะเห็นได้ชัด
และแน่นอนโปรแกรมคือ หมายถึงการเป็นที่ค่อนข้างง่าย
เพื่อให้เรามีบางสิ่งบางอย่างที่จะสำรวจ
>> แต่ขอแนะนำการแก้จุดบกพร่องที่สาม เทคนิคที่นี่เรียกว่า debug50
ดังนั้นนี่คือโปรแกรม ที่เราได้สร้างขึ้น
ปีนี้เรียกว่า debug50 ที่จะทำให้คุณ
ที่จะใช้สิ่งที่เรียกว่าในตัว กราฟิกดีบักใน CS50 IDE
และดีบักเป็นเพียงโปรแกรมที่ โดยทั่วไปจะช่วยให้คุณสามารถเรียกใช้โปรแกรมของคุณ
แต่ทีละขั้นตอนโดยขั้นตอนสาย โดยทีละบรรทัดหยุดโผล่
รอบกำลังมองหาที่ตัวแปรเพื่อให้ โปรแกรมไม่เพียงพัดผ่านมาคุณ
ได้อย่างรวดเร็วและพิมพ์บางสิ่งบางอย่าง หรือไม่สามารถพิมพ์บางสิ่งบางอย่าง
มันทำให้คุณมีโอกาสที่ ความเร็วของมนุษย์ในการโต้ตอบกับมัน
>> และการทำเช่นนี้คุณ เพียงแค่ทำต่อไปนี้
หลังจากรวบรวมรหัสของคุณ ซึ่งฉันไม่อยู่แล้ว buggy3,
คุณไปข้างหน้าและเรียก ./buggy debug50
ดังนั้นเหมือน help50 มีคุณเรียก help50 แล้วคำสั่ง
debug50 มีคุณเรียก debug50 และ แล้วชื่อของคำสั่ง
>> ตอนนี้ดูสิ่งที่เกิดขึ้นบนหน้าจอของฉัน อยู่ทางด้านขวามือโดยเฉพาะอย่างยิ่ง
เมื่อกดเรียกใช้ทั้งหมดของ ฉับพลันแผงนี้ทางด้านขวามือ
เปิดขึ้นบนหน้าจอ
และมีจำนวนมากที่เกิด บนได้อย่างรวดเร็วก่อน
แต่มีไม่มากเกินไป มากที่จะต้องกังวลเกี่ยวกับเลย
>> นี้จะแสดงให้ฉันทุกอย่าง ที่เกิดขึ้นภายในของโปรแกรมของฉัน
ตอนนี้และผ่านทางเหล่านี้ ปุ่มขึ้นด้านบนแล้ว
ช่วยให้ผมก้าวผ่านรห​​ัสของฉัน ในที่สุดทีละขั้นตอนโดยขั้นตอน
แต่ไม่เพียง แต่
ขอให้สังเกตสิ่งที่เกิดขึ้น
ที่หน้าต่าง terminal ของฉัน ฉันถูกพร้อมท์สำหรับ n
และฉันจะไปข้างหน้าและ ความร่วมมือในครั้งนี้และพิมพ์ -1
และแม้จะเล็ก ๆ น้อย ๆ ความลับ, -1 เป็นจำนวนเต็มลบตามที่คาดไว้
>> แล้วเดินออกมาจากเด็กที่มี สถานะ 0 GDBserver ออก
GDB, GNU ดีบักเป็นชื่อ ซอฟต์แวร์พื้นฐาน
ที่ดำเนินการดีบักนี้
แต่ทั้งหมดนี้จริงๆหมายถึงดีบัก เดินออกไปเพราะโปรแกรมของฉันเลิก
และทั้งหมดได้ดี
ถ้าผมต้องการแก้ปัญหาอย่างแท้จริงโปรแกรมของฉัน ฉันต้องบอก preemptively debug50,
ที่ฉันต้องการที่จะเริ่มต้น ก้าวผ่านรห​​ัสของฉัน?
>> และอาจจะเป็นวิธีที่ง่ายที่สุด จะทำอย่างไรที่จะเป็นดังนี้
ถ้าผมเลื่อนเมาส์ไปที่ รางน้ำของการแก้ไขของฉันที่นี่
ดังนั้นจริงๆเพียงแค่ในแถบด้านข้างที่นี่ ด้านซ้ายของจำนวนบรรทัด
ขอให้สังเกตว่าถ้าฉันเพียงแค่คลิก ครั้งหนึ่งผมใส่จุดสีแดงเล็ก ๆ น้อย ๆ
และที่จุดสีแดงเล็ก ๆ น้อย ๆ เช่นป้ายหมายความว่าเดี๋ยวก่อน
debug50 การดำเนินการหยุดการทำงานชั่วคราวของรหัสของฉัน ที่นั่นเมื่อฉันเรียกใช้โปรแกรมนี้
>> ดังนั้นขอให้ทำอย่างนั้น
ให้ฉันไปข้างหน้าและเรียกใช้โปรแกรมของฉัน อีกครั้งกับ debug50 ./buggy3 ใส่
และตอนนี้แจ้งให้ทราบล่วงหน้าบางสิ่งบางอย่าง ที่แตกต่างกันได้เกิดขึ้น
ฉันไม่ได้ถาม ยังอยู่ในหน้าต่าง terminal ของฉัน
สำหรับอะไรเพราะฉันไม่ได้ อากาศยังมีในโปรแกรมของฉัน
ขอให้สังเกตว่าในบรรทัดที่ 8 ซึ่งเป็นไฮไลต์ในขณะนี้
และมีลูกศรเล็ก ๆ ที่ คำกล่าวที่ว่าซ้ายคุณจะหยุดชั่วคราวที่นี่
บรรทัดของรหัสบรรทัดนี้ 8 ยังไม่ได้ดำเนินการ
>> และสิ่งที่อยากรู้อยากเห็นถ้าฉันมอง มากกว่าที่นี่อยู่ทางด้านขวามือ
สังเกตเห็นว่าฉันเป็นท้องถิ่น ตัวแปรท้องถิ่นในความรู้สึก
ว่ามันเป็นฟังก์ชั่นภายในปัจจุบัน
และความคุ้มค่าของมันเห็นได้ชัดโดยค่าเริ่มต้น และการเรียงลำดับของความสะดวกคือ 0
แต่ผมไม่ได้พิมพ์ 0
ที่เพิ่งเกิดขึ้นเป็นของตน ค่าเริ่มต้นในขณะนี้
>> เพื่อให้ฉันไปข้างหน้าและทำเช่นนี้ในขณะนี้
ให้ฉันไปข้างหน้าและใน ด้านบนขวาที่นี่ผม
จะไปข้างหน้าและ คลิกที่ไอคอนนี้เป็นครั้งแรกที่
หมายถึงขั้นตอนมากกว่าซึ่งหมายความว่าไม่ข้าม แต่ก้าวข้ามบรรทัดของรหัสนี้
รันมันไปพร้อมกัน
>> และตอนนี้สังเกตเห็นของฉัน พรอมต์มีการเปลี่ยนแปลงเพียง
ทำไมเป็นเช่นนั้น?
ฉันบอก debug50, เรียกใช้บรรทัดของรหัสนี้
สิ่งที่ไม่บรรทัดของรหัสนี้ทำอย่างไร
แจ้งให้ฉันสำหรับ int
ตกลง.
ผมขอความร่วมมือ
ผมขอไปข้างหน้าในขณะนี้และพิมพ์ -1 ใส่
และตอนนี้สังเกตเห็นสิ่งที่มีการเปลี่ยนแปลง
อยู่ทางด้านขวามือ ตัวแปรท้องถิ่นของฉัน
ถูกระบุว่าเป็น -1 ในขณะนี้
และก็ยังคงชนิด int
>> และแจ้งให้ทราบเกินไปฉันเรียกว่า โทรสแต็คที่ฉันไม่หยุด?
เราจะพูดคุยเกี่ยวกับ นี้ในอนาคต
แต่เรียกกองเพียงหมายถึงสิ่งที่ ฟังก์ชั่นที่มีอยู่ในปัจจุบันในการเคลื่อนไหว
ตอนนี้มันเป็นเพียงแค่หลัก
และตอนนี้ในประเทศอื่น ตัวแปรคือฉันมีค่าเป็น 1
>> และเมื่อในที่สุดผมก็ก้าวข้ามบรรทัดนี้ ที่นี่กับไอคอนที่เดียวกันที่ด้านขวาบน
-1 เป็นจำนวนเต็มเชิงลบ
ตอนนี้ก็หยุดมากกว่าที่วงเล็บปีกกา
ลองปล่อยให้มันทำสิ่งที่ตน
ผมก้าวข้ามเส้นนั้นและ voila
>> ดังนั้นไม่ได้ทั้งหมดที่ชะมัด enlightening ยัง
แต่มันไม่ให้ผมหยุด และคิดว่าผ่านเหตุผล
สิ่งที่โปรแกรมนี้จะทำ
แต่นั่นก็ไม่ได้เป็นกรณีที่ผิดพลาด
ลองทำเช่นนี้อีกครั้งดังต่อไปนี้
>> ฉันจะออกจากจุดพักที่ ในบรรทัดที่ 8 มีจุดสีแดง
ฉันจะเรียก debug50
มันหยุดชั่วคราวโดยอัตโนมัติที่นี่
แต่ครั้งนี้แทน ก้าวข้ามเส้นนี้
ให้ฉันจริงไปภายในของ get_negative_int และคิดออก
มันเป็นเหตุผลที่ยอมรับ 0 เป็นคำตอบที่ถูกต้อง?
>> ดังนั้นแทนที่จะคลิกขั้นตอนจบ
ฉันจะไปข้างหน้า และคลิกขั้นตอนไป
และแจ้งให้ทราบว่าเส้นที่ 8 ตอนนี้ไฮไลต์ในขณะนี้อย่างกระทันหัน
กลายเป็นสาย 17
>> ตอนนี้ก็ไม่ได้ว่าการดีบัก ได้ข้ามเส้น 14 และ 15 และ 16
มันเป็นเพียงแค่ไม่มีอะไร จะแสดงให้คุณมี
เหล่านี้เป็นเพียงการประกาศตัวแปร แล้วมีคำว่าทำ
แล้วเปิดวงเล็บปีกกา
บรรทัดเดียวที่ทำงาน ฉ่ำจริงๆเป็นหนึ่งในที่นี่ 17
และนั่นคือสิ่งที่เราได้ หยุดชั่วคราวโดยอัตโนมัติ
>> ดังนั้น printf ( "n.is:") เพื่อให้ ;, ที่ยังไม่เกิดขึ้น
ดังนั้นขอให้ไปข้างหน้าและก้าวข้ามคลิก
ตอนนี้พรอมต์ของฉันแน่นอน เปลี่ยนไป ( "n คือ:")
ตอนนี้ get_int ผมไม่ได้ไป เพื่อก้าวเข้าสู่รำคาญ,
เพราะฟังก์ชั่นที่ได้รับ ทำโดย CS50 ในห้องสมุด
มันเป็นเรื่องที่ถูกต้องสันนิษฐานว่า
>> ดังนั้นฉันจะไปข้างหน้าและ การเรียงลำดับของความร่วมมือโดยให้มัน
เป็น int แต่ไม่ int เชิงลบ
เพื่อให้ฉันไปข้างหน้าและกด 0
และตอนนี้สิ่งที่เกิดขึ้นที่นี่ เมื่อฉันได้รับลงไปที่บรรทัดที่ 21?
ฉันไม่ได้ซ้ำอีกครั้ง
ฉันไม่ได้ดูเหมือนจะติดอยู่ในวงที่
ในคำอื่น ๆ , สีเหลืองนี้ แถบไม่ได้เก็บไปรอบ ๆ
และบริเวณใกล้เคียงและรอบ ๆ
>> ตอนนี้ทำไมเป็นเช่นนั้น?
ดี N, n สิ่งที่ตอนนี้?
ฉันสามารถมองไปที่ท้องถิ่น ตัวแปรในการดีบัก
n คือ 0
สิทธิทั้งหมดสิ่งที่เป็นไปตามเงื่อนไขของฉันได้อย่างไร
>> 20-- เส้น 20 คือดี 0 มากกว่า 0
ว่าไม่เป็นความจริง
0 ไม่มากกว่า 0
และดังนั้นผมจึงโพล่งออกมานี้
>> และเพื่อที่ว่าทำไมในบรรทัด 21 ถ้าจริงผมดำเนินการต่อ
ฉันจะกลับ 0 แม้ แม้ว่าฉันควรจะได้ปฏิเสธ 0
ที่จะไม่เป็นจริงในเชิงลบ
ดังนั้นตอนนี้ฉันทำไม่ได้จริงๆแม้กระทั่ง ดูแลเกี่ยวกับการดีบัก
Got มันฉันไม่จำเป็นต้อง รู้ว่าสิ่งที่มากขึ้นเป็นสิ่งที่เกิดขึ้น
>> ดังนั้นฉันจะไปข้างหน้าและ เพียงแค่คลิกที่ปุ่ม Play,
และปล่อยให้เรื่องนี้จบลง
ตอนนี้ผมได้ตระหนักว่าฉัน ข้อผิดพลาดที่เห็นได้ชัดคือในบรรทัด 20
นั่นเป็นข้อผิดพลาดทางตรรกะของฉัน
>> และเพื่อทำในสิ่งที่ฉันต้องการ ที่จะทำอะไรเพื่อเปลี่ยนแปลงนี้หรือไม่?
ถ้าปัญหาคือว่าฉันไม่ได้ จับ 0 มันเป็นเพียงความผิดพลาดเชิงตรรกะ
และผมสามารถพูดในขณะที่ n คือ มากกว่าหรือเท่ากับ 0
ให้แจ้งให้ผู้ใช้อีกครั้งและอีกครั้ง
>> ดังนั้นอีกครั้งผิดพลาดง่ายบางที ที่เห็นได้ชัดแม้เมื่อคุณเห็นฉัน
เขียนเพียงไม่กี่นาทีที่ผ่านมา
แต่ Takeaway ที่นี่ เป็นที่ที่มีการแก้ปัญหา 50,
และมีการแก้จุดบกพร่อง ซอฟแวร์มากกว่าปกติ
คุณต้องพบพลังงานใหม่เพื่อ เดินผ่านรห​​ัสของคุณเองดู
ผ่านแผงมือด้านขวาที่สิ่งที่ ค่าตัวแปรของคุณ
ดังนั้นคุณจึงไม่จำเป็นต้อง มีบางสิ่งบางอย่างที่จะใช้
เช่นเดียวกับคุณ eprintf พิมพ์ค่าเหล่านั้น
จริงๆคุณสามารถเห็นพวกเขา สายตาบนหน้าจอ
>> ตอนนี้นอกเหนือจากนี้มันเป็นมูลค่า noting ว่ามีเทคนิคที่อื่น
จริงสุดที่พบบ่อย
และคุณอาจจะสงสัยว่าทำไมนี้เล็ก ๆ น้อย ๆ ผู้ชายคนที่นี่ได้รับการนั่งอยู่บนเวที
ดังนั้นจึงมีเทคนิคนี้โดยทั่วไป ที่รู้จักกันเป็นเป็ดยางแก้จุดบกพร่อง
ซึ่งจริงๆเป็นเพียง ข้อพิสูจน์ถึงความเป็นจริง
ที่มักจะเมื่อโปรแกรมเมอร์ มีการเขียนโค้ด
พวกเขาไม่จำเป็นต้อง การทำงานร่วมกันกับคนอื่น ๆ
หรือการทำงานในสภาพแวดล้อมที่ใช้ร่วมกัน
>> พวกเขากำลังจัดเรียงของที่บ้าน
บางทีมันอาจจะเป็นในช่วงดึก
พวกเขากำลังพยายามที่จะคิด จากข้อผิดพลาดบางอย่างในรหัสของพวกเขา
และพวกเขากำลังก็ไม่เห็นมัน
>> และไม่มีเพื่อนร่วมห้อง
ไม่มี TF คือ
มี CA ไม่มีรอบ
ทั้งหมดที่พวกเขามีในการเก็บรักษาของพวกเขา นี้เป็นยางที่รักเล็ก ๆ น้อย ๆ
>> และเพื่อให้การแก้จุดบกพร่องเป็ดยาง เป็นเพียงคำเชิญนี้
ที่จะคิดว่าสิ่งที่เป็นความโง่ เช่นนี้เป็นสิ่งมีชีวิตจริง
และที่จริงเดินผ่านรห​​ัสของคุณ ด้วยวาจาไปยังวัตถุที่ไม่มีชีวิตนี้
ดังนั้นสำหรับตัวอย่างเช่นถ้า นี่คือตัวอย่างของฉัน here--
และจำได้ว่าก่อนหน้านี้ ปัญหาที่เกิดขึ้นนี้
ถ้าฉันลบบรรทัดแรกนี้ของรหัส และฉันไปข้างหน้าและทำให้รถ 0 อีกครั้ง
จำได้ว่าผมมีเหล่านี้ ข้อความผิดพลาดที่นี่
ดังนั้นความคิดที่นี่ไร้สาระ แต่ฉัน รู้สึกว่าในขณะที่การทำเช่นนี้ต่อสาธารณชน
เป็นข้อผิดพลาดที่
>> ตกลงดังนั้นปัญหาของฉันที่ฉันได้ โดยปริยายประกาศให้เป็นฟังก์ชั่นห้องสมุด
และฟังก์ชั่นที่เป็นห้องสมุด printf
Declare-- ตกลงประกาศ ทำให้ผมนึกถึงต้นแบบ
>> นั่นหมายความว่าฉันต้องการจริง บอกคอมไพเลอร์ล่วงหน้าว่า
ฟังก์ชั่นที่มีลักษณะดังนี้
เดี๋ยวก่อน.
ฉันไม่ได้มี io.h. มาตรฐาน
ขอบคุณมาก.
>> ดังนั้นเพียงแค่ขั้นตอนนี้ of-- คุณ ไม่จำเป็นต้องจริงมีเป็ด
แต่ความคิดของการเดินนี้ ตัวเองผ่านรห​​ัสของคุณเอง
เพื่อให้คุณได้ยิน ตัวเองเพื่อให้คุณ
ตระหนักถึงการละเว้นในของคุณเอง พูดโดยทั่วไปคือความคิด
>> และบางทีอาจจะมากกว่าเหตุผลไม่ได้ดังนั้น มากกับที่หนึ่ง แต่ที่เกี่ยวข้องมากขึ้น
ตัวอย่างเช่นเราก็ทำใน 3.c รถ, คุณอาจจะเดินผ่านมันด้วยตัวคุณเอง
ดังต่อไปนี้
ดังนั้นสิทธิทั้งหมดยาง Ducky, DDB ถ้าคุณจะ
ที่นี่เรามีฟังก์ชั่นหลักของฉัน ฉันโทรได้รับ int เชิงลบ
>> และฉันได้รับค่าตอบแทน
ฉันเก็บไว้ทางด้านซ้ายมือ ในบรรทัดที่ 8 ในตัวแปรที่เรียกว่าฉัน
OK แต่รอไง ที่ได้รับค่าที่?
ให้ฉันมองไปที่การทำงานในสาย 12
>> ในบรรทัดที่ 12 เรามีได้รับ int เชิงลบ
ไม่ได้ใช้ปัจจัยการผลิตใด ๆ ไม่กลับมาเป็น int, OK
ผมประกาศบนเส้น 14 A N ตัวแปร
มันเป็นไปได้ในการจัดเก็บเป็นจำนวนเต็ม
นั่นคือสิ่งที่ฉันต้องการ.
>> ดังนั้นต่อไปนี้ขณะ n is-- ให้ ฉันเลิกทำสิ่งที่แก้ไขที่เราทำอยู่แล้ว
ดังนั้นในขณะที่ n มากกว่า 0, พิมพ์ N มีตกลง
แล้วเรียกได้เก็บไว้ใน int n
แล้วตรวจสอบถ้า n เป็น 0 n คือ not-- มีเป็น
ดังนั้นอีกครั้งคุณทำไม่ได้ ต้องเป็ดที่เกิดขึ้นจริง
แต่เพียงแค่เดินผ่านด้วยตัวคุณเอง รหัสของคุณเป็นการออกกำลังกายทางปัญญา
มักจะช่วยให้คุณ ตระหนักถึงสิ่งที่เกิดขึ้น
เมื่อเทียบกับเพียงแค่การทำบางสิ่งบางอย่าง เช่นนี้จ้องมองที่หน้าจอ
และไม่ได้พูดถึงตัวเองผ่าน มันซึ่งตรงไปตรงมาไม่ได้
เกือบเป็นเทคนิคที่มีประสิทธิภาพ
จึงมีคุณมีมันเป็น จำนวนเทคนิคที่แตกต่าง
สำหรับการแก้จุดบกพร่องจริงรหัสของคุณ และค้นหาความผิดซึ่งทั้งหมดนี้
ควรจะเป็นเครื่องมือในชุดเครื่องมือของคุณ เพื่อให้คุณไม่ได้อยู่ในช่วงดึก
โดยเฉพาะอย่างยิ่งคุณอยู่ในอาหาร ห้องโถงหรืออย่างเวลาทำการ
ทุบหัวของคุณกับ ผนังพยายามที่จะแก้ปัญหาบางอย่าง
ทราบว่ามีเครื่องมือซอฟต์แวร์
มีเครื่องมือเป็ดยาง
และมีพนักงานทั้งหมดของ สนับสนุนการรอคอยที่จะยืมมือ
>> ดังนั้นตอนนี้คำในการแก้ปัญหา ชุดและในสิ่งที่เราหวังว่าคุณ
ได้รับจากพวกเขาและวิธี เราไปเกี่ยวกับการประเมิน
ต่อรายวิชาที่ CS50 ของชุดปัญหา
จะมีการประเมินสี่แกนหลักเพื่อ เพื่อ speak-- ขอบเขตความถูกต้อง, การออกแบบ
และรูปแบบ
และขอบเขตเพียงหมายถึงเท่าไหร่ ของชิ้นคุณกัดปิด?
คุณมีวิธีการมากของปัญหาพยายาม?
สิ่งที่ระดับของความพยายาม คุณประจักษ์?
>> ความถูกต้องคือไม่ทำงานโปรแกรมเป็น มันควรจะตามข้อกำหนด CS50
เมื่อคุณให้ปัจจัยการผลิตบางอย่าง หรือผลบางอย่างกลับมา?
การออกแบบเป็นอัตนัยที่สุดของพวกเขา
และมันก็เป็นหนึ่งที่จะ ใช้เวลานานที่สุดที่จะเรียนรู้
และยาวที่สุดในการสอนใน เท่าที่มันเดือดลงไป,
วิธีที่ดีที่เขียนเป็นรหัสของคุณหรือไม่
>> มันเป็นสิ่งหนึ่งที่จะเพียงแค่พิมพ์ที่ถูกต้อง เอาท์พุทหรือค่าตอบแทนที่เหมาะสม
แต่คุณกำลังทำมันเป็น มีประสิทธิภาพเป็นไปได้หรือไม่
คุณกำลังทำมันแบ่ง และพิชิตหรือไบนารี
ค้นหาในขณะที่เราเร็ว ๆ นี้จะเห็นว่าเราไม่ได้ทำ สองสัปดาห์ที่ผ่านมากับสมุดโทรศัพท์?
จะมีวิธีการที่ดีในการแก้ปัญหา ปัญหาที่เกิดขึ้นกว่าที่คุณในขณะนี้มีที่นี่?
นั่นเป็นโอกาสสำหรับการออกแบบที่ดีกว่า
>> แล้ว style-- วิธี สวยเป็นรหัสของคุณหรือไม่
คุณจะสังเกตเห็นว่าฉันสวย โดยเฉพาะเกี่ยวกับการเยื้องรหัสของฉัน
และทำให้แน่ใจว่าตัวแปรของฉัน มีชื่อพอสมควร n,
ในขณะที่ระยะสั้นเป็นชื่อที่ดีสำหรับ จำนวนฉันสำหรับจำนวนเต็มนับ
สำหรับสตริง
และเราจะได้มีอีกต่อไป สไตล์ชื่อตัวแปร
สไตล์เป็นเพียงวิธีการที่ดี ไม่รหัสของคุณมอง?
และวิธีการที่สามารถอ่านได้มันคืออะไร?
>> และเมื่อเวลาผ่านไปสิ่งที่ครูของคุณ และ TFS จะทำในหลักสูตร
จะให้คุณกับที่ ชนิดของข้อมูลเชิงคุณภาพ
เพื่อที่คุณจะได้รับดีกว่า ในแง่มุมต่าง ๆ เหล่านั้น
และในแง่ของวิธีการที่เรา ประเมินแต่ละของแกนเหล่านี้
ก็มักจะมีน้อยมาก บุ้งกี๋เพื่อให้คุณโดยทั่วไป
ได้รับความรู้สึกของวิธีการที่ดีที่คุณทำ
และแน่นอนถ้าคุณได้รับคะแนนใน ใด ๆ ของผู้ axes-- ความถูกต้อง, การออกแบบ
และสไตล์ especially-- ตัวเลขที่ โดยทั่วไปจะอยู่ระหว่าง 1 และ 5
และตัวอักษรหากคุณได้รับ 3 ในช่วงเริ่มต้นของภาคการศึกษาที่
นี้เป็นสิ่งที่ดีมาก
มันหมายความว่ายังคงมี ห้องพักสำหรับการปรับปรุง
ที่คุณจะหวังใน การเรียนเป็นครั้งแรก
มีหวังว่าบิตของเพดานบางส่วน ที่คุณกำลังต้องการที่จะถึง
และเพื่อให้ได้รับ 3 บน ชิ้นที่เก่าแก่ที่สุด
ถ้าไม่ได้บางส่วน 2 และ 4 ของ เป็นจริงเป็นสิ่งที่ดี
มันเป็นอย่างดีในช่วง อย่างดีในความคาดหวัง
>> และถ้าใจของคุณจะแข่งรอ นาทีสามในห้า
นั่นคือจริงๆ 6 จาก 10
นั่นคือ 60%
พระเจ้าของฉันที่เป็นเอฟ
>> มันไม่ใช่.
มันไม่ได้ในความเป็นจริงว่า
แต่ก็มีโอกาสที่จะปรับปรุง ผ่านหลักสูตรของภาคการศึกษา
และถ้าคุณได้รับบาง Poors เหล่านี้เป็นโอกาส
เพื่อใช้ประโยชน์จากเวลาทำการ แน่นอนส่วนและทรัพยากรอื่น ๆ
>> ที่ดีที่สุดคือโอกาสจริงๆ จะเป็นความภาคภูมิใจของได้ไกลแค่ไหนคุณได้
มามากกว่าหลักสูตรของภาคการศึกษา
จึงตระหนักถึงถ้าไม่มีอะไร อื่นสามเป็นสิ่งที่ดี
และมันช่วยให้ห้องพักสำหรับการเจริญเติบโตในช่วงเวลา
>> เป็นวิธีการที่แกนเหล่านี้จะ ถ่วงน้ำหนักแนบเนียนคุณ
จะใช้เวลาส่วนใหญ่ของคุณได้รับ สิ่งที่จะทำงานให้อยู่คนเดียวได้อย่างถูกต้อง
และเพื่อความถูกต้องมีแนวโน้มที่จะ ให้น้ำหนักมากที่สุดเช่นเดียวกับ
ปัจจัยคูณสาม
การออกแบบยังเป็นสิ่งสำคัญ แต่ บางสิ่งบางอย่างที่คุณไม่จำเป็นต้อง
ใช้จ่ายทั้งหมดของผู้ที่อยู่ในชั่วโมง พยายามที่จะได้รับสิ่งที่เป็นเพียงแค่การทำงาน
>> และดังนั้นจึงถ่วงน้ำหนัก เล็ก ๆ น้อย ๆ เบา ๆ
และจากนั้นรูปแบบจะมีน้ำหนักน้อย
แม้ว่ามันจะไม่น้อย สิ่งสำคัญพื้นฐาน
มันเป็นเพียงแค่บางที สิ่งที่ง่ายที่สุดที่จะทำขวา
ลอกเลียนแบบตัวอย่างที่เรา ทำในการบรรยายและส่วน
กับสิ่งอย่าง เยื้องและแสดงความคิดเห็น
และอื่น ๆ เป็นหนึ่งในที่ง่ายที่สุด สิ่งที่ต้องทำและได้รับสิทธิ
ดังนั้นเป็นเช่นนี้ตระหนักถึง ว่าผู้ที่เป็นจุด
ที่ค่อนข้างง่ายต่อการเข้าใจ
>> และตอนนี้คำใน ซื่อสัตย์ในการศึกษา this--
ดังนั้นต่อหลักสูตร หลักสูตรคุณจะเห็น
ว่าหลักสูตรมีค่อนข้าง บิตของภาษารอบนี้
และแน่นอนที่จะเกิดปัญหาของ ซื่อสัตย์ในการศึกษาค่อนข้างจริงจัง
>> เรามีความแตกต่าง ดีขึ้นหรือแย่ลง
ของที่ได้ส่งในแต่ละปีมากขึ้น นักเรียนสำหรับการดำเนินการทางวินัย
มากที่สุดกว่าคนอื่น ๆ แน่นอนว่าฉันรู้
นี้ไม่จำเป็นต้อง บ่งบอกถึงความเป็นจริง
ว่านักเรียน CS หรือนักเรียน CS50 เป็น น้อย ๆ เที่ยงตรงกว่าเพื่อนร่วมชั้นของคุณ
แต่ความเป็นจริงที่ว่าในนี้ โลกอิเล็กทรอนิกส์เราเพียงแค่
มีเทคโนโลยี หมายถึงการตรวจสอบนี้
>> มันเป็นสิ่งสำคัญเพื่อให้เรา ความเป็นธรรมทั่วชั้นเรียน
ที่เราทำตรวจสอบนี้และยกระดับ ปัญหาเมื่อเราเห็นสิ่งที่
และเพียงแค่การวาดภาพและจริงๆ ที่จะช่วยให้สิ่งที่ชอบอ่างนี้ใน
เหล่านี้เป็นตัวเลขของ นักเรียนที่ผ่านมา 10 ปี
ที่ได้มีส่วนร่วมในบาง ปัญหาดังกล่าวของความซื่อสัตย์ทางวิชาการ
มีนักเรียนบางคน 32 จากฤดูใบไม้ร่วงปี 2015 ซึ่ง
คือจะบอกว่าเราไม่ใช้ เรื่องนี้เป็นอย่างมาก
และในที่สุดตัวเลขเหล่านี้เขียน เมื่อเร็ว ๆ นี้ประมาณ 3%, 4% หรือมากกว่านั้น
ของชั้นเรียน
>> ดังนั้นสำหรับส่วนสุดของนักเรียน ดูเหมือนว่าเส้นที่มีความชัดเจน
แต่ไม่เก็บไว้ใน ใจโดยเฉพาะอย่างยิ่งในช่วงปลาย
ในเวลากลางคืนเมื่อดิ้นรนกับ วิธีการแก้ปัญหาบางอย่างที่จะเป็นชุดที่มีปัญหา
ว่ามีกลไก สำหรับการเดินทางด้วยตัวเองดีกว่า
สนับสนุนกว่าที่คุณอาจ คิดว่าแม้ในเวลานั้น
ตระหนักดีว่าเมื่อเราได้รับ ส่งนักเรียนเราข้าม
เปรียบเทียบการส่งทุกปีนี้ กับการส่งทุกปีที่ผ่านมา
กับการส่งจาก 2007 ทุก และตั้งแต่มองเป็นอย่างดี
รหัสที่เก็บออนไลน์ กระดานสนทนาเว็บไซต์งาน
และเราพูดถึงนี้ จริงๆทั้งหมดเพราะ
ของการเปิดเผยข้อมูลเต็มรูปแบบว่าถ้า คนอื่นสามารถค้นหาได้ออนไลน์
แน่นอนดังนั้นเราสามารถเรียนการสอน
แต่จริงๆจิตวิญญาณ ของหลักสูตรเดือดลง
ข้อนี้ในหลักสูตร
จริงๆมันเป็นเพียงแค่จะเหมาะสม
>> และถ้าเรามีการทำอย่างละเอียดในที่ มีเพียงภาษามากขึ้นอีกนิด
ตระหนักดีว่าสาระสำคัญของทั้งหมด งานที่คุณส่งไปยังหลักสูตรนี้
จะต้องเป็นของคุณเอง
แต่ภายในนั้นมีแน่นอน โอกาสและให้กำลังใจ
และความคุ้มค่าในการสอนเปลี่ยนไป others-- ตัวของเราเอง TFS, คาสิโน,
ครูและคนอื่น ๆ ในชั้นเรียน ที่ให้การสนับสนุนให้เพื่อนคนเดียว
และเพื่อนร่วมห้องที่มีการศึกษา บริการลูกค้าและการเขียนโปรแกรมก่อน
และเพื่อให้มีการตั้งค่าเผื่อการว่า
และกฎทั่วไปของหัวแม่มือ เป็น this-- เมื่อขอความช่วยเหลือ
คุณอาจแสดงรหัสของคุณกับคนอื่น ๆ แต่คุณอาจไม่ดูพวกเขา
ดังนั้นแม้ว่าคุณจะอยู่ที่เวลาทำการ หรือในห้องโถง D, หรือที่อื่น
การทำงานในชุดชิ้นบาง ทำงานร่วมกับเพื่อนที่
ดีทั้งหมดที่ ตอนท้ายของวันทำงานของคุณ
ในท้ายที่สุดควรจะเป็นของแต่ละคน ของคุณตามลำดับและไม่ได้
เป็นความพยายามร่วมกัน ยกเว้นโครงการสุดท้ายที่
ได้รับอนุญาตและเป็นกำลังใจให้
>> ตระหนักดีว่าถ้าคุณเป็น ดิ้นรนกับบางสิ่งบางอย่าง
และเพื่อนของคุณเพิ่งเกิดขึ้น จะดีกว่าที่นี้แล้วคุณ,
หรือดีกว่าปัญหามากกว่าที่คุณว่า หรือน้อยไกลไปข้างหน้ากว่าคุณ
ก็สมควรที่จะเปิดทั้งหมด กับเพื่อนของคุณและพูดว่าเดี๋ยวก่อน
ไม่ใจคุณกำลังมองหาที่รหัสของฉันที่นี่ ช่วยฉันมองเห็นสิ่งที่เป็นปัญหาของฉันเป็นอย่างไร
และหวังว่าใน ความสนใจของมูลค่าการสอน
เพื่อนที่ไม่ได้เป็นเพียงแค่ กล่าวว่าโอ้ทำเช่นนี้ แต่
สิ่งที่คุณจะหายไปในบรรทัด 6 หรือสิ่งที่ต้องการนั้น
แต่การแก้ปัญหาไม่ได้ สำหรับเพื่อน ๆ ที่อยู่ติดกับคุณ
ที่จะบอกว่าโอ้ดีนี่ให้ฉันดึง นี้ขึ้นและแสดงวิธีการแก้ปัญหาของฉันกับคุณ
เพื่อให้เป็นเส้น
คุณสามารถแสดงรหัสของคุณ คนอื่น ๆ แต่คุณอาจไม่ได้
ดูพวกเขาอยู่ภายใต้การอื่น ๆ ข้อ จำกัด ในหลักสูตรการเรียนการสอนของ
>> ดังนั้นอย่าเก็บไว้ในใจนี้ ที่เรียกว่าข้อเสียใจ
ในหลักสูตรการเรียนการสอนที่เป็นอย่างดี ว่าถ้าคุณกระทำการบางอย่างที่
ไม่สมเหตุสมผล แต่นำมาให้ ความสนใจของหัวหลักสูตรฯ
ภายใน 72 ชั่วโมงการเรียนการสอน อาจกำหนดบทลงโทษในท้องถิ่นที่
อาจรวมถึงเป็นที่น่าพอใจหรือ ความล้มเหลวในชั้นประถมศึกษาปีสำหรับการทำงานที่ส่ง
แต่การเรียนการสอนจะไม่อ้าง สำคัญสำหรับการดำเนินการทางวินัยต่อไป
ยกเว้นในกรณีของการกระทำซ้ำแล้วซ้ำอีก
ในคำอื่น ๆ ถ้าคุณทำทำให้บาง โง่ดึกโดยเฉพาะอย่างยิ่งการตัดสินใจ
เช้าวันถัดไปหรือสองวัน ต่อมาคุณตื่นขึ้นและตระหนักถึง
สิ่งที่ผมคิด?
ที่คุณทำใน CS50 มีทางออก สำหรับการแก้ไขปัญหาที่
และเป็นเจ้าของขึ้นไปเพื่อให้เรา จะได้พบคุณครึ่งหนึ่งและจัดการ
กับมันในเรื่องที่เป็นทั้ง การศึกษาและมีคุณค่าสำหรับคุณ
แต่ยังคงลงโทษในทางใดทางหนึ่ง
และตอนนี้จะใช้ขอบปิดนี้
>> [เล่นวีดีโอ]
>> [เสียงเพลง]
>> [จบ PLAYBACK]
เดวิดเจลัน: สิทธิทั้งหมดที่เราจะกลับมา
และตอนนี้เรามองไปที่หนึ่งใน ครั้งแรกของโดเมนโลกแห่งความจริงของเรา
ใน CS50 ศิลปะของการเข้ารหัสที่ ศิลปะของการส่งและรับ
ข้อความลับ, การเข้ารหัส ข้อความถ้าคุณจะ
ที่สามารถถอดรหัสถ้าคุณมี บางส่วนผสมที่สำคัญที่ผู้ส่งมี
ได้เป็นอย่างดี
ดังนั้นเพื่อกระตุ้นนี้เราจะพา ดูที่สิ่งนี้ที่นี่
ซึ่งเป็นตัวอย่างของหนึ่ง แหวนถอดรหัสลับที่
สามารถนำมาใช้ในการสั่งซื้อที่จะคิดออก สิ่งที่ข้อความลับจริง
ในความเป็นจริงกลับมาอยู่ใน วันในระดับโรงเรียน
ถ้าคุณเคยส่งข้อความลับไป เพื่อนบางส่วนหรือปิ๊บางส่วนในชั้นเรียน
คุณอาจจะคิดว่า คุณเป็นคนฉลาด
โดยชิ้นส่วนของการเปลี่ยนกระดาษ เช่น A ไป B และ B ไป C, และ C กับ D,
เป็นต้น
แต่คุณเป็นจริงการเข้ารหัส ข้อมูลของคุณแม้
ถ้ามันเป็นที่น่ารำคาญเล็ก ๆ น้อย ๆ ไม่ได้ ที่ยากสำหรับครูที่จะตระหนักถึง
ดีถ้าคุณเพียงแค่เปลี่ยน B ไป A และ C กับ B,
คุณคิดจริงออก สิ่งที่ข้อความเป็น
แต่คุณอยู่ใน ciphering ข้อมูล
>> คุณเป็นเพียงแค่การทำมัน ก็เหมือนฟี่ที่นี่
ในภาพยนตร์ที่มีชื่อเสียงที่เล่น nauseum โฆษณาสวยมากในแต่ละฤดูหนาว
[เล่นวีดีโอ]
-Be มันรู้ไปทุกที่ ราล์ฟปาร์กเกอร์เป็นขอ
ได้รับการแต่งตั้งเป็นสมาชิกของเล็ก ๆ น้อย ๆ เด็กกำพร้าแอนนี่วงกลมลับ
และมีสิทธิที่จะได้รับเกียรตินิยมทั้งหมด และผลประโยชน์ที่เกิดขึ้นดังกล่าว
>> -Signed, กำพร้าแอนนี่ เคาน์เตอร์ลงนามปิแอร์อังเดรในหมึก
เกียรติประวัติและผลประโยชน์ แล้วที่อายุสิบเก้า
>> [ตะโกน]
-Come บน
ให้ของได้รับกับมัน
ฉันไม่จำเป็นต้องทั้งหมดที่แจ๊ส เกี่ยวกับการลักลอบและโจรสลัด
>> คืนวันพรุ่งนี้ -Listen สำหรับ สรุปการผจญภัย
ของเรือโจรสลัดสีดำ
ตอนนี้ก็ถึงเวลาสำหรับ ข้อความลับของแอนนี่
สำหรับสมาชิกของคุณวงกลมลับ
โปรดจำไว้ว่าเด็กเฉพาะสมาชิกเท่านั้น ของแอนนี่วงกลมลับ
สามารถถอดรหัสข้อความลับของแอนนี่
>> โปรดจำไว้ว่าแอนนี่ขึ้นอยู่กับคุณ
ตั้งหมุดของคุณเพื่อ B2
นี่คือข้อความ
12 11--
>> -I am ในการประชุมลับครั้งแรกของฉัน
>> -14, 11, 18, 16
>> -Pierre อยู่ในคืนนี้เสียงที่ดี
ผมบอกได้เลยว่าคืนนี้ ข้อความเป็นสิ่งสำคัญจริงๆ
>> -3, 25, ที่ข้อความ จากแอนนี่ตัวเอง
โปรดจำไว้ว่าอย่าบอกใคร
>> -90 วินาทีต่อมาผมอยู่ในเท่านั้น ห้องพักในบ้านที่เป็นเด็กเก้า
จะนั่งอยู่ในความเป็นส่วนตัวและถอดรหัส
อ้า B!
ผมไปต่อไปอี
>> คำแรกคือเป็น
S มันก็ง่ายขึ้นมาตอนนี้ U, 25--
>> โอ้มาในฟี่ I gotta ไป!
>> ผมจะไปมีสิทธิลง Ma!
หวือ Gee!
>> -T, O, ให้แน่ใจว่า to-- ให้แน่ใจว่าได้อะไร?
สิ่งที่เป็นเด็กกำพร้าเล็ก ๆ น้อย ๆ แอนนี่พยายามที่จะพูด?
ให้แน่ใจว่าได้อะไร?
>> -Ralphie แอนดี้ได้มีการ ไปคุณจะกรุณ​​าออกมา?
>> สิทธิพักแม่!
ฉันจะออกไปทางขวา!
>> -I ได้รับใกล้ชิดในขณะนี้
ความตึงเครียดที่น่ากลัว
มันคืออะไร?
ชะตากรรมของโลก อาจแขวนอยู่ในสมดุล
>> -Ralphie!
แอนดี้ต้องไป!
>> ผมจะไปมีสิทธิออกร้องไห้ออกมาดัง ๆ !
>> -Almost มีมือของฉันบินใจของฉัน เป็นกับดักเหล็กทุกขุมขนสั่นสะเทือน
มันก็เกือบจะชัดเจนใช่ใช่ใช่
>> -Be แน่ใจว่าได้ดื่มโอวัลติคุณ
โอวัลติ?
พาณิชย์ crummy?
ไอ้บ้า
[จบ PLAYBACK]
เดวิดเจลัน: ตกลงดังนั้น ว่าเป็นวิธีที่มีความยาวมาก
ของการแนะนำวิทยาการ และโอวัลติ
ในความเป็นจริงจากการโฆษณาเก่า นี่คือเหตุผลที่โอวัลติดีเพื่ออะไร?
มันเป็นสกัดเข้มข้นของสุก ข้าวบาร์เลย์มอลต์นมวัวครีมบริสุทธิ์ของ
และเตรียมเป็นพิเศษโกโก้เข้าด้วยกัน กับ phosphatides ธรรมชาติและวิตามิน
มันเป็นเสริมอีกด้วย วิตามินเพิ่มเติม B และ D ยำ
และคุณยังจะได้รับมันเห็นได้ชัดว่า ใน Amazon เหมือนเราได้ที่นี่
>> แต่แรงจูงใจของที่นี่คือการ แนะนำการเข้ารหัสเฉพาะ
ประเภทของการเข้ารหัสที่รู้จักกัน เป็นคีย์การเข้ารหัสลับ
และเป็นชื่อที่แนะนำทั้งหมด การรักษาความปลอดภัยของระบบการเข้ารหัสลับที่สำคัญเป็นความลับ
ถ้าคุณจะวิธีการ เพียง scrambling
ข้อมูลระหว่างคนสองคนก็คือว่า เฉพาะผู้ส่งและผู้รับเท่านั้น
รู้ key-- ลับค่าบางอย่างบาง วลีลับบางจำนวนลับว่า
ช่วยให้พวกเขาทั้งเข้ารหัส และถอดรหัสข้อมูล
และการเข้ารหัสจริงๆ เป็นเพียงแค่นี้จากสัปดาห์ 0
>> มันเป็นปัญหาที่มีปัจจัยการผลิต, เช่นข้อความที่เกิดขึ้นจริงในภาษาอังกฤษ
หรืออะไรก็ตามที่คุณภาษา ต้องการที่จะส่งไปยังคนในชั้นเรียน
หรือผ่านทางอินเทอร์เน็ต
มีการส่งออกบางอย่างที่เป็นไปได้คือ จะเป็นข้อความที่มีสัญญาณรบกวนที่คุณ
ต้องการผู้รับที่จะได้รับ
และแม้กระทั่งถ้ามีคนใน ตรงกลางจะได้รับมันมากเกินไป
คุณไม่ต้องการให้พวกเขา จำเป็นต้องสามารถถอดรหัสมัน
เพราะภายในนี้ กล่องดำหรืออัลกอริทึม
เป็นกลไกบางขั้นตอนโดยขั้นตอนบางอย่าง คำแนะนำสำหรับการป้อนข้อมูลที่
และการแปลงลงใน การส่งออกในหวังว่าวิธีการที่ปลอดภัย
>> และในความเป็นจริงมีบางส่วน คำศัพท์ในโลกนี้ดังต่อไปนี้
ข้อความล้วนเป็นคำว่า นักวิทยาศาสตร์คอมพิวเตอร์จะ
ใช้เพื่ออธิบายการป้อนข้อมูล ข้อความเช่นภาษาอังกฤษ
หรือสิ่งที่ภาษาที่คุณจริง ต้องการที่จะส่งไปบางส่วนอื่น ๆ ของมนุษย์
แล้ว ciphertext คือการแย่งชิง การเข้ารหัสหรือการเข้ารหัส
รุ่นดังกล่าว
>> แต่มีส่วนผสมอื่น ๆ ที่นี่
มีอยู่คนหนึ่งป้อนข้อมูลอื่น ๆ ที่จะเป็น คีย์การเข้ารหัสลับ
และนั่นคือกุญแจสำคัญในตัวของมันเอง ซึ่งเป็นปกติ
ในขณะที่เราจะเห็นตัวเลขหรือ ตัวอักษรหรือคำใด ๆ ก็ตาม
อัลกอริทึมจะมีการคาดการณ์ว่าจริง
>> และวิธีการที่คุณจะถอดรหัสข้อมูล?
คุณจะทำอย่างไรถอดรหัสมันได้หรือไม่
ดีที่คุณเพิ่งกลับ เอาท์พุทและปัจจัยการผลิต
>> ในคำอื่น ๆ เมื่อมีคน ได้รับข้อความที่เข้ารหัสของคุณ
เขาหรือเธอก็มี ที่จะรู้ว่าคีย์เดียวกันว่า
พวกเขาได้รับข้อความที่เข้ารหัส
และด้วยการเสียบทั้งสอง ปัจจัยการผลิตเข้ามาในระบบการเข้ารหัสลับที่
อัลกอริทึม, ก​​ล่องดำนี้จาก ควรมา plaintext เดิม
และเพื่อให้เป็นระดับที่สูงมาก มุมมองของสิ่งที่เข้ารหัสเป็นจริง
ทั้งหมดเกี่ยวกับ.
>> จึงขอได้มี
ตอนนี้ขอดูใต้ เครื่องดูดควันของบางสิ่งบางอย่าง
เราได้รับการให้ได้รับสำหรับ สัปดาห์ที่ผ่านมาและสำหรับการประชุมครั้งนี้
here-- สตริง
สตริงในตอนท้ายของวัน เป็นเพียงลำดับของตัวอักษร
>> มันอาจจะเป็นโลกสวัสดีหรือ สวัสดี Zamyla หรืออะไรก็ตาม
แต่สิ่งที่หมายความว่าจะ เป็นลำดับของตัวอักษรหรือไม่?
ในความเป็นจริงจะช่วยให้ห้องสมุด CS50 เราชนิดข้อมูลที่เรียกว่าสตริง
>> แต่มีจริงไม่มี สิ่งดังกล่าวเป็นสตริงในซี
จริงๆมันเป็นเพียงลำดับของ ตัวละครตัวละครตัวละคร
ตัวอักษรกลับไปกลับไป กลับไปด้านหลังจะกลับเข้าไปข้างใน
ของหน่วยความจำของคอมพิวเตอร์ของคุณหรือแรม
และเราจะมองลึกลงไปว่าใน ในอนาคตเมื่อเรามองไปที่หน่วยความจำตัวเอง
และการใช้ประโยชน์และ ภัยคุกคามที่มีส่วนร่วม
>> แต่ขอพิจารณาสตริง Zamyla
ดังนั้นเพียงแค่ชื่อของ มนุษย์นี่ Zamyla,
ที่เป็นลำดับของ ตัวอักษร Z-A-M-Y-L-A
และตอนนี้สมมติว่าชื่อของ Zamyla จะถูกเก็บไว้ในคอมพิวเตอร์
โครงการ
>> ดีก็หมายถึงเหตุผลที่เราควรจะ สามารถที่จะมองไปที่ตัวอักษรเหล่านั้น
เป็นรายบุคคล
ดังนั้นฉันแค่จะไปวาดเล็ก ๆ น้อย ๆ กล่องรอบ Zamyla ชื่อของที่นี่
และมันก็เป็นกรณีใน C ที่ว่าเมื่อคุณ มีสตริงเช่น Zamyla-- และอาจ
สตริงที่ได้กลับมาจาก ฟังก์ชั่นเช่นสตริงได้รับ
คุณจริงสามารถจัดการ ตัวละครมันด้วยตัวอักษร
>> ตอนนี้เป็นชิดสำหรับ การสนทนาที่มือเพราะ
ในการเข้ารหัสถ้าคุณต้องการที่จะเปลี่ยน A ไป B และ B ไป C, และ C กับ D,
และอื่น ๆ ที่คุณจะต้องสามารถ จะมองไปที่ตัวละครแต่ละคน
ในสตริง
คุณจะต้องสามารถที่จะเปลี่ยน Z เพื่ออย่างอื่นต่อ A
อย่างอื่นที่ M เพื่อ อย่างอื่นและอื่น ๆ
และเพื่อให้เราต้องมีวิธีการ โปรแกรมเพื่อ
ที่จะพูดใน C เพื่อให้สามารถที่จะเปลี่ยน และมองไปที่ตัวอักษรของแต่ละบุคคล
และเราสามารถทำเช่นนี้ดังต่อไปนี้
>> ให้ฉันไปมุ่งหน้ากลับใน CS50 IDE
และแจ้งให้เราไปข้างหน้า และสร้างไฟล์ใหม่
ว่าฉันจะเรียก string0 เวลานี้ เป็นตัวอย่างเช่นครั้งแรกของเราจุด C
และฉันจะไปข้างหน้า และชักขึ้นดังต่อไปนี้
>> ดังนั้นรวม CS50.h และ แล้วรวม io.h มาตรฐาน
ซึ่งฉันเกือบเสมอไป จะใช้ในโปรแกรมของฉันอย่างน้อย
ในขั้นต้น
int เป็นโมฆะหลักและจากนั้นในที่นี่ผม จะทำสายได้รับได้รับสตริง
แล้วฉันจะไป ไปข้างหน้าและทำเช่นนี้
ฉันต้องการที่จะไปข้างหน้า และในขณะที่การตรวจสอบสติ
เพียงแค่พูดว่าสวัสดีร้อยละ S, ลำไส้ใหญ่กึ่งทำให้สตริง 0
อ๊ะทำอะไรที่นี่?
โอ้ผมไม่ได้เสียบ
ดังนั้นบทเรียนที่ได้เรียนรู้ว่า ไม่ได้เจตนา
>> ข้อผิดพลาดดังนั้นร้อยละ แปลงกว่าข้อโต้แย้งข้อมูล
และนี่คือที่ใน สาย 7-- ตกลงดังนั้นฉันมี
อ้างนำมาอ้างว่าเป็น สตริงของฉันไป printf
ฉันมีเครื่องหมายเปอร์เซ็นต์
แต่ฉันหายไปอาร์กิวเมนต์ที่สอง
>> ฉันหายไป s จุลภาคซึ่ง ฉันไม่ได้ในตัวอย่างก่อนหน้านี้
ดังนั้นเป็นโอกาสที่ดีในการแก้ไขปัญหา อีกหนึ่งความผิดพลาดโดยไม่ได้ตั้งใจ
และตอนนี้ให้ฉันทำงาน string0 พิมพ์ใน Zamyla
ตกลงสวัสดี Zamyla
>> ดังนั้นเราจึงได้เรียกใช้ชนิดของโปรแกรมนี้ ครั้งที่แตกต่างกันไม่กี่ตอน
แต่ขอทำบางสิ่งบางอย่าง เล็ก ๆ น้อย ๆ ที่แตกต่างกันในครั้งนี้
แทนที่จะเป็นเพียงการพิมพ์ Zamyla ของ ชื่อทั้งหมดออกมาพร้อมกับพริทฟ์
ขอทำทีละอักขระ
>> ฉันจะใช้สำหรับวง
และฉันจะให้ตัวเอง ตัวแปรนับเรียกฉัน
และฉันจะเก็บ iterating ดังนั้น ตราบเท่าที่ฉันมีค่าน้อยกว่าความยาวของนั้น
>> มันจะเปิดออกเราไม่ได้ ทำครั้งสุดท้ายนี้
ที่ C มาพร้อมกับ ฟังก์ชั่นที่เรียกว่าสเตอร์ลิง
ย้อนกลับไปในวันและทั่วไป ยังคงเมื่อใช้ฟังก์ชั่น
มนุษย์มักจะเลือกมาก ชื่อรวบรัดชนิดของเสียงที่
เหมือนสิ่งที่คุณต้องการแม้ว่าจะเป็น หายไปไม่กี่สระหรือตัวอักษร
ดังนั้นสเตอร์ลิงเป็น ชื่อของฟังก์ชั่นที่
ใช้เวลาโต้เถียงระหว่าง วงเล็บที่ควรจะเป็นสตริง
และมันก็ส่งกลับจำนวนเต็ม ความยาวของสตริงว่า
>> ดังนั้นนี้สำหรับวงในบรรทัดที่ 7 เป็นไป ที่จะเริ่มต้นนับที่ฉันมีค่าเท่ากับ 0
มันจะเพิ่มขึ้น ผมในแต่ละซ้ำ
โดยที่ 1 ในขณะที่เราได้รับการทำไม่กี่ครั้ง
แต่มันเป็นไปได้เพียง แต่ทำ ขึ้นนี้จนกว่าจุด
เมื่อฉันเป็นความยาว ของสตริงตัวเอง
>> ดังนั้นนี่คือวิธีการในที่สุด iterating มากกว่าตัวละคร
ในสตริงที่เป็นอยู่ต่อไปนี้
ฉันจะพิมพ์ออกมาไม่ได้เป็น สตริงทั้ง แต่ร้อยละ C,
ตัวเดียว ตามมาด้วยการขึ้นบรรทัดใหม่
แล้วฉันจะไป ไปข้างหน้าและฉันต้องการ
จะบอกว่าผมต้องการพิมพ์ ตัวละครที่ i ของ s
>> ดังนั้นถ้าฉันเป็นตัวแปรที่บ่งชี้ ดัชนีของสตริงที่
คุณกำลังอยู่ในนั้นผมจะต้องสามารถที่จะ พูดให้ฉันตัวละครที่ i ของ s
และ C มีวิธีการทำ นี้กับวงเล็บ
คุณเพียงแค่พูดชื่อของ สตริงซึ่งในกรณีนี้คือ s
แล้วคุณใช้วงเล็บซึ่งเป็น มักจะอยู่เหนือหรือใส่กลับของคุณ
บนแป้นพิมพ์
แล้วคุณใส่ดัชนีของ ตัวอักษรที่คุณต้องการพิมพ์
ดังนั้นดัชนีจะไปได้ number-- 0 หรือ 1 หรือ 2 หรือ 3 หรือจุด
จุดจุดบางหมายเลขอื่น
>> และเรามั่นใจว่ามันจะ เป็นจำนวนที่เหมาะสมเพราะฉัน
เริ่มนับที่ 0
และโดยค่าเริ่มต้นตัวอักษรตัวแรก ในสตริงเป็น 0 โดยการประชุม
และตัวอักษรที่สองคือวงเล็บ 1
และตัวละครที่สามคือขายึด 2
และคุณไม่ต้องการที่จะไปมากเกินไป ห่างไกล แต่เราจะไม่เพราะเรา
จะเพิ่มขึ้นเพียงฉันจนกว่าจะ เท่ากับความยาวของสตริง
และที่จุด สำหรับวงนี้จะหยุด
>> เพื่อให้ฉันไปข้างหน้าและบันทึกนี้ โปรแกรมและเรียกสตริง 0
แต่ผมเมาขึ้น
โดยปริยายประกาศฟังก์ชั่นห้องสมุด Stirling มีประเภทดังกล่าวและ such-- ตอนนี้
นี้เสียงที่คุ้นเคย
แต่ก็ไม่ได้ printf
และมันก็ไม่ได้รับสตริง
>> ผมไม่ได้กรูขึ้นใน เช่นเดียวกับครั้งนี้
แต่สังเกตเห็นลงที่นี่น้อยลง เพิ่มเติม ได้แก่ สตริงส่วนหัว
อย่างชัดเจนให้ ประกาศสำหรับสเตอร์ลิง
ดังนั้นมีจริงในการมีเงื่อนงำ
>> และแน่นอนมันจะเปิดออก มีไฟล์ส่วนหัวอีก
ที่เราไม่ได้ใช้ ในชั้นเรียน แต่มันเป็น
ในหมู่ผู้ใช้ได้ ให้คุณเรียกว่าสตริง
และในการที่ไฟล์สตริง สเตอร์ลิงจะประกาศ
เพื่อให้ฉันไปข้างหน้าและ บันทึกนี้ให้สตริง
0-- ดีไม่มีข้อผิดพลาดในครั้งนี้
>> ./string0 Zamyla และ ฉันจะกด Enter,
จุดที่เป็นไป GetString เพื่อกลับสตริงใส่ไว้ใน s
แล้วที่สำหรับวงเป็นไปย้ำ มากกว่าตัวอักษร S หนึ่งที่เวลา
และพิมพ์ต่อหนึ่งบรรทัดเพราะ ฉันมีที่ทับขวา n ที่สิ้นสุด
ดังนั้นฉันสามารถละเว้นทับขวาว่า n และจากนั้นเพียงแค่พิมพ์ Zamyla ทั้งหมด
ในบรรทัดเดียวกัน ได้อย่างมีประสิทธิภาพ reimplementing
printf ซึ่งไม่ได้ทั้งหมดที่มีประโยชน์ที่
แต่ในกรณีนี้ผมไม่ได้ทำอย่างนั้น
ผมเคยพิมพ์จริงหนึ่ง ตัวอักษรในเวลาหนึ่งต่อบรรทัด
เพื่อให้เราได้จริงเห็นผล
>> แต่ฉันควรทราบสิ่งหนึ่งที่นี่
และเราจะกลับมา ในสัปดาห์อนาคต
แต่กลับกลายเป็นว่านี้ รหัสอาจเป็นรถ
>> แต่กลับกลายเป็นว่าสตริง และบางฟังก์ชั่นอื่น ๆ ในชีวิต
ไม่จำเป็นต้องเสมอ กลับสิ่งที่คุณคาดหวัง
เรารู้จากชั้นเรียนสุดท้าย ในเวลานี้ที่จะได้รับ
สตริงควรจะกลับสตริง
แต่ถ้าผู้ใช้ชนิดดังกล่าวออก คำยาวหรือวรรคหรือเรียงความ
ว่ามีเพียงไม่เพียงพอ หน่วยความจำในเครื่องคอมพิวเตอร์เพื่อให้พอดีกับมัน
>> เช่นเดียวกับสิ่งที่ถ้าบางสิ่งบางอย่างไป ที่ไม่ถูกต้องอยู่ภายใต้ฝากระโปรง?
มันอาจจะไม่เกิดขึ้นบ่อยครั้ง แต่มันอาจจะเกิดขึ้นเพียงครั้งเดียว
ในขณะที่ไม่บ่อยมาก
และดังนั้นจึงเปิดออกสตริงได้รับที่ และฟังก์ชั่นเหมือนมันไม่จำเป็นต้อง
เสมอกลับสตริง
พวกเขาอาจจะกลับค่าความผิดพลาดบางอย่าง บางค่าแมวมองเพื่อที่จะพูด
ที่บ่งชี้ว่า บางสิ่งบางอย่างที่ได้ไปผิด
และคุณจะได้รู้ว่าจากนี้ มีการเรียนรู้ในชั้นเรียนตอนนี้
หรือมีการอ่านเอกสารเพิ่มเติมบางส่วน
แต่กลับกลายเป็นว่าสตริง สามารถกลับไปเรียกค่า null
Null เป็นค่าพิเศษที่เราจะ กลับไปมาในสัปดาห์อนาคต
แต่ตอนนี้เพิ่งรู้ว่าถ้าผมต้องการ จะเป็นที่เหมาะสมจริงๆในการก้าวไปข้างหน้า
ใช้สตริงผม จะไม่เพียง แต่เรียกว่า
และสุ่มสี่สุ่มห้าใช้ค่าตอบแทนสูง ไว้วางใจว่ามันเป็นสตริง
>> ครั้งแรกที่ผมควรจะพูดว่า เดี๋ยวก่อนรอสักครู่เท่านั้น
ดำเนินการต่อไปถ้า s ไม่เท่ากับ null, null ที่อีกครั้ง
เป็นเพียงบางค่าพิเศษ
และมันก็เป็นเพียงค่าพิเศษคุณ จำเป็นต้องกังวลเกี่ยวกับสตริง
รับสตริงอย่างใดอย่างหนึ่งไป ที่จะกลับมาเป็นสตริงหรือ null
>> และเครื่องหมายอัศเจรีย์นี้เท่ากับ คุณอาจรู้จากชั้นเรียนคณิตศาสตร์อาจจะ
ที่คุณอาจวาดด้วยเครื่องหมายเท่ากับ เส้นผ่านมันจะบ่งบอกถึงไม่เท่ากัน
นั่นคือไม่ได้โดยทั่วไปตัวละคร คุณสามารถพิมพ์บนแป้นพิมพ์
และอื่น ๆ มากที่สุดในการเขียนโปรแกรมภาษา เมื่อคุณต้องการที่จะบอกว่าไม่เท่ากัน
คุณใช้เครื่องหมายอัศเจรีย์ หรือที่เรียกว่าปัง
ดังนั้นคุณจะพูดว่าปังเท่ากับซึ​​่ง หมายความว่าไม่เท่ากับเหตุผล
มันเหมือนกับมีไม่มากขึ้น กว่าหรือเท่ากับหรือน้อยกว่า
หรือเท่ากับบนแป้นพิมพ์ ที่ไม่ได้ทั้งหมดในหนึ่งสัญลักษณ์
เพื่อที่ว่าทำไมในตัวอย่างที่ผ่านมา คุณไม่วงเล็บเปิดแล้ว
เครื่องหมายเท่ากับเพื่อที่จะทำ มากกว่าหรือพูดน้อยกว่า
>> ดังนั้นสิ่งที่ Takeaway ที่นี่?
นี้เป็นเพียงวิธีการที่ตอนนี้ แนะนำไวยากรณ์นี้คุณลักษณะนี้
iterating มากกว่าบุคคล ตัวอักษรในสตริง
และเช่นเดียวกับตารางเหล่านั้น วงเล็บช่วยให้คุณสามารถที่จะได้รับพวกเขา
พิจารณาวงเล็บเหล่านั้นเป็น ชนิดของเค้านี้พื้นฐาน
ออกแบบโดยทุก ตัวละครภายในของสตริง
ถูกบรรจุอยู่ในกล่องชนิดของในที่ไหนสักแห่งที่อยู่ภายใต้ เครื่องดูดควันในหน่วยความจำของคอมพิวเตอร์ของคุณ
>> แต่ขอให้แตกต่างจากนี้
แต่กลับกลายเป็นว่านี้ โปรแกรมที่ถูกต้อง
ดังนั้นต่อแกน CS50 สำหรับการประเมิน รหัสนี้ถูกต้องในขณะนี้
โดยเฉพาะตอนที่ผมตรวจสอบ null โปรแกรมนี้ไม่ควรผิดพลาด
และฉันก็รู้ว่าจากประสบการณ์
แต่มีอะไรอย่างอื่นที่ เราจริงๆสามารถไปอย่างผิดปกติท​​ี่นี่
แต่มันไม่ได้เป็นอย่างการออกแบบที่ดี เพราะปล่อยให้กลับไปสู่​​พื้นฐาน
>> แรก principles-- สิ่งที่ไม่ห่วงทำอย่างไร
สำหรับห่วงไม่สามสิ่ง
มันเริ่มต้นบางอย่าง คุ้มค่าถ้าคุณถามมัน
มันจะตรวจสอบสภาพ
และแล้วหลังจากที่แต่ละ ซ้ำหลังจากแต่ละรอบ
มันเพิ่มขึ้นบางส่วน คุ้มค่าหรือค่าที่นี่
>> ดังนั้นสิ่งที่หมายความว่า?
เราเริ่มต้นฉันถึง 0
เราตรวจสอบและให้แน่ใจว่าฉันมีค่าน้อยกว่า ความยาวของ s ซึ่งเป็น Z-A-M-Y-L-A
ดังนั้นซึ่งน้อยกว่า 6
และแน่นอน 0 เป็นน้อยกว่า 6
>> เราพิมพ์ Z จากชื่อของ Zamyla
จากนั้นเราก็เพิ่มฉัน 0-1
จากนั้นเราจะตรวจสอบเป็น 1 น้อย กว่าความยาวของ s หรือไม่?
ความยาวของ s คือ 6
ใช่แล้ว.
>> ดังนั้นเราพิมพ์ในชื่อ Zamyla ของ ZA
เราเพิ่ม I จาก 0, 1, 2
จากนั้นเราจะตรวจสอบเป็น 2 น้อยกว่า ความยาวของชื่อ Zamyla ของ
6- ดังนั้น 2 เป็นน้อยกว่า 6
ใช่ลองพิมพ์ออกมาตอนนี้เอ็ม ชื่อ Zamyla ของตัวละครที่สาม
>> ที่สำคัญนี่คือว่าในแต่ละ ย้ำเรื่องที่ผมตรวจสอบ
คือผมน้อยกว่าความยาวของ Zamyla หรือไม่
แต่จับได้ว่า สเตอร์ลิงไม่ได้เป็นสถานที่ให้บริการ
บรรดาผู้ที่มีโปรแกรม ก่อน Java หรือภาษาอื่น ๆ
อาจจะรู้ว่าความยาวของสตริง สถานที่ให้บริการเพียงบางส่วนเท่านั้นที่อ่านค่า
>> ใน C ในกรณีนี้ถ้าเป็น ฟังก์ชั่นที่เป็นอักษร
การนับจำนวนของ ตัวละครใน Zamyla ทุกครั้ง
ที่เราเรียกว่าฟังก์ชั่น
ทุกครั้งที่คุณถามคอมพิวเตอร์ให้ใช้ สเตอร์ลิงก็การดูที่ Zamyla,
และพูดว่า Z-A-M-Y-L-A, 6
และมันจะกลับ 6
ครั้งต่อไปที่คุณเรียก ภายในที่ห่วง
ก็จะไปดูที่ Zamyla อีกครั้งบอกว่า Z-A-M-Y-L-A, 6
และมันจะกลับ 6
ดังนั้นสิ่งที่โง่เกี่ยวกับการออกแบบนี้หรือไม่?
>> ทำไมไม่เป็นรหัส 5 จาก 5 ของฉัน สำหรับการออกแบบในขณะนี้เพื่อที่จะพูด?
ดีฉันถาม คำถามที่ไม่จำเป็น
ฉันทำทำงานมากขึ้นกว่าที่ฉันต้อง
>> ดังนั้นแม้ว่า คำตอบที่ถูกต้องผม
ขอให้คอมพิวเตอร์คืออะไร ความยาวของ Zamyla อีกครั้ง
และอีกครั้งและอีกครั้งและอีกครั้ง?
และคำตอบที่เป็น ไม่เคยไปเปลี่ยน
มันมักจะเป็น 6
>> ดังนั้นทางออกที่ดีกว่านี้ จะเป็นรุ่นต่อไปนี้
ให้ฉันไปข้างหน้าและใส่ไว้ใน ไฟล์แยกต่างหากที่เรียกว่า string1.c,
เพียงเพื่อให้มันแยกจากกัน
และปรากฎในสำหรับ ห่วงคุณจริงสามารถ
ประกาศตัวแปรหลายครั้ง
>> ดังนั้นฉันจะให้ฉันและตั้งค่าให้ 0
แต่ฉันยังจะ เพิ่มเครื่องหมายจุลภาคและกล่าวว่า
ให้ฉันตัวแปรที่เรียกว่า n ซึ่ง ค่าเท่ากับความยาวของสตริง s
และตอนนี้โปรดตรวจสภาพของฉัน ตราบใดที่ฉันมีค่าน้อยกว่า n
>> ดังนั้นในทางตรรกะคือ เหมือนกันในตอนท้ายของวัน
แต่ผมจำ มูลค่า 6 ในกรณีนี้
ความยาวของชื่อ Zamyla คืออะไร?
และฉันวางไว้ที่ n
>> และฉันยังคงตรวจสอบ สภาพทุกครั้ง
คือ 0 น้อยกว่า 6?
1 น้อยกว่า 6?
คือ 2 น้อยกว่า 6 และอื่น ๆ ?
>> แต่ฉันไม่ได้ขอคอมพิวเตอร์ อีกครั้งและอีกครั้งว่ามีอะไร
ความยาวของชื่อ Zamyla ได้หรือไม่
อะไรยาวของชื่อ Zamyla ฯ คืออะไร?
สิ่งที่ความยาวของชื่อ Zamyla นี้คืออะไร?
ฉันจำได้ว่าตัวอักษรแรกและ เพียงตอบในเรื่องนี้ n ตัวแปรที่สอง
ดังนั้นในตอนนี้จะไม่เพียง ที่ถูกต้อง แต่ยังออกแบบมาอย่างดี
>> ตอนนี้สิ่งที่เกี่ยวกับรูปแบบ?
ฉันได้รับการตั้งชื่อตัวแปรของฉัน สวยดีผมจะบอกว่า
พวกเขากำลังซุปเปอร์รวบรัดในขณะนี้
และที่ดีทั้งหมด
>> หากคุณมีเพียงหนึ่ง สตริงในโปรแกรม
คุณเช่นกันอาจจะเรียกมันสตริง
หากคุณมีเพียงตัวแปรเดียว สำหรับการนับในโปรแกรม
คุณเช่นกันอาจจะเรียกมันฉัน
ถ้าคุณมีความยาว, N เป็นซุปเปอร์ร่วมกันได้เป็นอย่างดี
แต่ฉันไม่ได้แสดงความคิดเห็นใด ๆ ของรหัสของฉัน
>> ฉันไม่ได้แจ้ง reader-- ไม่ว่าจะเป็น TF ฉันหรือ TA,
หรือเพียงแค่ colleague-- สิ่งที่ควร ที่จะเกิดขึ้นในโปรแกรมนี้
และเพื่อที่จะได้รับรูปแบบที่ดี สิ่งที่ฉันต้องการจะทำ
เป็นสิ่งที่ this-- เช่นขอให้ผู้ใช้สำหรับการป้อนข้อมูล
และฉันจะเขียน นี้จำนวนวิธีใดวิธีหนึ่ง
>> ตรวจสอบให้แน่ใจ s-- ให้แน่ใจว่าได้รับ สตริงกลับสตริง
และจากนั้นใน here-- และนี่อาจจะเป็น ที่สำคัญที่สุดสำทับ comment--
มากกว่าตัวอักษรในหนึ่งในช่วงเวลา
และฉันจะใช้ใด ๆ ทางเลือกของการใช้ภาษาอังกฤษ
ที่นี่เพื่ออธิบายแต่ละ ชิ้นนี้ของรหัส
>> ขอให้สังเกตว่าผมยังไม่ได้ใส่ แสดงความคิดเห็นในบรรทัดของรหัสทุกครั้ง
จริงๆเพียงแค่บนที่น่าสนใจ คนคนที่
มีความหมายบางอย่างที่ฉันอาจ ต้องการที่จะทำให้สุดความชัดเจนให้กับใครบางคน
การอ่านรห​​ัสของฉัน
และทำไมคุณโทรมาได้รับ สตริงขอให้ผู้ใช้สำหรับการป้อนข้อมูล?
แม้ที่หนึ่งไม่จำเป็นต้องเป็น ทุกสิ่งที่สื่อความหมาย
แต่มันก็ช่วยบอกเล่าเรื่องราวเพราะ บรรทัดที่สองในเรื่องที่จะให้แน่ใจว่า
ได้รับกลับสตริงสตริง
>> และบรรทัดที่สามในเรื่องคือ ย้ำกว่าตัวละครใน s หนึ่ง
ขณะนั้น.
และขณะนี้เป็นเพียงการวัดที่ดี, ฉันจะไปข้างหน้าและเพิ่ม
หนึ่งความคิดเห็นเพิ่มเติมว่าเพียงแค่ บอกว่าตัวอักษรพิมพ์ I-TH ใน s
ตอนนี้สิ่งที่ฉันได้ทำ ในตอนท้ายของวัน?
>> ฉันได้เพิ่มภาษาอังกฤษบางส่วน คำในรูปแบบของการแสดงความคิดเห็น
สัญลักษณ์เฉือนเฉือนหมายความว่าเดี๋ยวก่อน คอมพิวเตอร์เครื่องนี้สำหรับมนุษย์
ไม่ได้สำหรับคุณคอมพิวเตอร์
เพื่อให้พวกเขาไม่สนใจเหตุผล
พวกเขากำลังเพียงมี
>> และแน่นอน CS50 IDE แสดงให้เห็นว่าพวกเขาเป็น สีเทาเป็นประโยชน์ แต่ไม่สำคัญ
ในการเขียนโปรแกรม
ขอให้สังเกตสิ่งที่ตอนนี้คุณสามารถทำได้
ไม่ว่าคุณจะรู้ว่า C การเขียนโปรแกรมหรือไม่คุณ
ก็สามารถกลับมายืนอยู่ที่นี้ โปรแกรมและหางการแสดงความคิดเห็น
ขอให้ผู้ใช้สำหรับการป้อนข้อมูลให้แน่ใจว่า ได้รับกลับสตริงสตริง
ย้ำกว่าตัวละครใน s หนึ่งที่เวลาพิมพ์ตัวอักษร
ตัวอักษร I-TH ใน s-- คุณทำไม่ได้ แม้ต้องมองไปที่รหัส
ที่จะเข้าใจสิ่งที่โปรแกรมนี้ไม่
และยังดีกว่าถ้าคุณตัวเองดู ในโปรแกรมนี้ในหนึ่งหรือสองสัปดาห์
หรือเดือนหรือปี คุณก็ไม่ได้มี
จ้องที่รหัส พยายามที่จะจำ
สิ่งที่ผมพยายามจะทำอย่างไรกับรหัสนี้หรือไม่?
>> คุณเคยบอกตัวเอง
คุณได้เล่าว่าสำหรับตัวคุณเอง หรือเพื่อนร่วมงานหรือ TA หรือ TF
ดังนั้นในตอนนี้จะเป็น ที่ถูกต้องและการออกแบบที่ดี
และในที่สุดรูปแบบที่ดีเช่นกัน
เพื่อทำให้ทราบว่า
>> ดังนั้นจึงมีคนอื่น ๆ สิ่งที่ฉันจะทำที่นี่
ที่ตอนนี้สามารถที่จะเปิดเผยว่าสิ่งที่ ที่เกิดขึ้นภายใต้ฝากระโปรง
เพื่อให้มีคุณลักษณะนี้ ใน C และภาษาอื่น ๆ
เรียกว่า Typecasting อย่างใดอย่างหนึ่งโดยปริยาย
หรืออย่างชัดเจนช่วยให้คุณแปลง จากชนิดข้อมูลหนึ่งไปยังอีก
เราได้รับการติดต่อเพื่อให้ ห่างไกลในวันนี้ด้วยสตริง
>> และสตริงตัวอักษร
แต่จำจากสัปดาห์ 0 สิ่งที่เป็นตัวอักษร?
ตัวอักษรเป็นเพียงนามธรรม ด้านบนของตัวเลขทศนิยมเบอร์,
และตัวเลขทศนิยมจริงๆเพียง นามธรรมด้านบนของเลขฐานสอง,
ในขณะที่เรากำหนดมัน
>> ดังนั้นตัวอักษรเป็นตัวเลข
และตัวเลขตัวอักษร เพียงขึ้นอยู่กับบริบท
และปรากฎว่าภายใน ของโปรแกรมคอมพิวเตอร์
คุณสามารถระบุวิธีการที่คุณต้องการที่จะดู ที่บิตภายในของโปรแกรมที่?
>> การเรียกคืนจากสัปดาห์ที่ 0 ที่เรามี ASCII ซึ่งเป็นเพียงรหัสนี้
ตัวอักษรทำแผนที่ไปยังหมายเลข
และเรากล่าวว่าทุนคือ 65
ทุน B คือ 66, และอื่น ๆ
>> และแจ้งให้ทราบเราเป็นหลักมีตัวอักษรบน แถวบนสุดที่นี่เป็น C จะเรียกพวกเขา
ตัวละครแล้ว ints ในแถวที่สอง
และปรากฎคุณสามารถแปลง ได้อย่างลงตัวระหว่างทั้งสองโดยทั่วไป
และถ้าเราต้องการที่จะทำ นี้จงใจเรา
อาจต้องการที่จะแก้ไขปัญหา บางอย่างเช่นนี้
>> เราอาจจะต้องการแปลง กรณีบนเพื่อลด
กรณีหรือกรณีที่ต่ำกว่าเพื่อกรณีบน
และมันจะเปิดออกมีของ จริงรูปแบบที่นี่
เราสามารถโอบกอดในเวลาเพียงสักครู่
แต่ขอดูครั้งแรกที่ ตัวอย่างของการทำเช่นนี้อย่างชัดเจน
>> ฉันจะกลับไป CS50 IDE
ฉันจะสร้าง ไฟล์ที่เรียกว่า Ascii 0.c.
และฉันจะไปข้างหน้าและเพิ่มของฉัน io.h มาตรฐานที่ด้านบน int เป็นโมฆะหลัก
ที่ด้านบนของฟังก์ชั่นของฉัน
แล้วฉันแค่ไปที่จะทำ following-- สำหรับห่วงจาก i เท่ากับ
สมมติว่า 65
>> แล้วฉันก็เป็นไปได้น้อยกว่า 65 บวก 26 ตัวอักษรในตัวอักษร
ดังนั้นฉันจะให้คอมพิวเตอร์ ทำคณิตศาสตร์สำหรับฉันมี
และจากนั้นภายในวงนี้ สิ่งที่ฉันจะพิมพ์เพื่อ?
>> % c คือ% ฉันทับขวา n
และตอนนี้ฉันต้องการที่จะเชื่อมต่อสองค่า
ฉันได้ใส่คำถามชั่วคราว เครื่องหมายที่นั่นเพื่อเชิญคำถาม
>> ผมอยากจะย้ำตั้งแต่ 65 เป็นต้นไป สำหรับ 26 ตัวอักษรของตัวอักษร,
พิมพ์ออกในแต่ละย้ำว่า ตัวละครเทียบเท่าหนึ่ง
ในคำอื่น ๆ ที่ฉันต้องการ ย้ำพิมพ์กว่า 26 หมายเลข
สิ่งที่อักขระ ASCII เป็นตัวอักษร และสิ่งที่เกี่ยวข้องจำนวน is--
จริงๆเพียงแค่การสร้าง แผนภูมิจากสไลด์ว่า
ดังนั้นสิ่งที่เครื่องหมายคำถามเหล่านี้ควรจะเป็นอย่างไร
>> ดีก็ปรากฎว่าสอง หนึ่งก็ควรจะเป็นตัวแปรฉัน
ฉันต้องการที่จะเห็นว่าเป็นตัวเลข
และอาร์กิวเมนต์กลาง ที่นี่ผมสามารถบอกได้ว่าเครื่องคอมพิวเตอร์
ในการรักษาจำนวนเต็มที่ ฉันเป็นตัวอักษรเพื่อให้เป็น
เพื่อทดแทนได้ที่นี่ร้อยละซี
>> ในคำอื่น ๆ ถ้าผมที่ โปรแกรมเมอร์มนุษย์รู้
เหล่านี้เป็นเพียงตัวเลข ในตอนท้ายของวัน.
และฉันรู้ว่า 65 ควร map กับตัวละครบาง
พร้อมกับโยนอย่างชัดเจนนี้ ด้วยวงเล็บ,
ชื่อของชนิดข้อมูลที่คุณต้องการไป แปลงและวงเล็บปิด
คุณสามารถบอก คอมพิวเตอร์, Hey, คอมพิวเตอร์,
แปลงจำนวนเต็มนี้เพื่อถ่าน
>> ดังนั้นเมื่อผมทำงานนี้ โปรแกรมหลังจากที่รวบรวม
เรามาดูสิ่งที่ฉัน get-- ทำให้ Ascii 0
ยี้มันสิ่งที่ฉันได้ทำผิดที่นี่?
การใช้งานของตัวระบุไม่ได้ประกาศ สิทธิทั้งหมดไม่ได้เจตนา
แต่ขอดูว่าเราไม่สามารถ เหตุผลผ่านทางนี้
>> ดังนั้นสาย five-- ดังนั้นผมจึงไม่ได้รับ ไกลมากก่อนที่จะกวดขันขึ้น
ไม่เป็นไร.
ดังนั้นสาย 5 เพราะเราเท่ากับ 65-- ฉันเห็น
ดังนั้นจำไว้ว่าใน C ซึ่งแตกต่างจากบางส่วน ภาษาถ้าคุณมีการเขียนโปรแกรมก่อน
ประสบการณ์ที่คุณมี ที่จะบอกคอมพิวเตอร์
ซึ่งแตกต่างจากรอยขีดข่วนสิ่งที่ ชนิดของตัวแปรมันเป็น
>> และฉันลืมวลีที่สำคัญที่นี่
ในบรรทัดที่ห้าผมได้เริ่มต้นใช้ฉัน
แต่ผมยังไม่ได้บอก C ข้อมูลที่พิมพ์เป็น
ดังนั้นฉันจะไปในที่นี่ พูด ah, ทำให้มันเป็นจำนวนเต็ม
>> ตอนนี้ฉันจะไปข้างหน้าและคอมไพล์
ที่คงที่
./ascii0 ใส่ว่าเป็นชนิดของเย็น
ไม่เพียง แต่มันเป็นซุปเปอร์รวดเร็ว ถามคอมพิวเตอร์คำถามนี้
มากกว่ามองขึ้นบนภาพนิ่ง มันพิมพ์ออกมาอย่างใดอย่างหนึ่งต่อบรรทัดคือ 65,
B เป็น 66 ทุกทาง down-- ตั้งแต่ผม ทำอย่างนี้ 26 times-- กับตัวอักษร Z,
ซึ่งเป็น 90
และในความเป็นจริงเล็กน้อย ฉลาดมากขึ้นจะ
ได้รับสำหรับฉันที่จะไม่พึ่งพา บนคอมพิวเตอร์เพื่อเพิ่ม 26
ฉันจะได้ทำเพียงแค่ 90 เช่นกันนานมาก
ที่ผมไม่ทำผิดพลาดเหมือนครั้งที่สอง
ฉันต้องการที่จะไปขึ้นผ่าน Z ไม่เพียงผ่าน Y
>> เพื่อให้เป็นนักแสดงอย่างชัดเจน
แต่กลับกลายเป็นว่านี้ ไม่จำเป็นต้องได้
ให้ฉันไปข้างหน้าและวิ่งนี้ คอมไพเลอร์และวิ่ง Ascii 0
แต่กลับกลายเป็นว่าซีเป็นสมาร์ทสวย
>> และ printf โดยเฉพาะอย่างยิ่ง เป็นสมาร์ทสวย
หากคุณเพียงแค่ผ่านฉันสองครั้ง สำหรับทั้งตัวยึด printf
จะรู้ว่าโอ้ดีฉันรู้ว่าคุณ ให้ผม integer-- จำนวนบาง
เช่น 65 หรือ 90 หรืออะไรก็ตาม
แต่ผมเห็นว่าคุณต้องการให้ฉันไป จัดรูปแบบตัวเลขที่เหมือนตัวละคร
และเพื่อให้ printf สามารถลงโดยปริยาย int เพื่อถ่านสำหรับคุณเช่นกัน
ดังนั้นที่ไม่ได้เป็นปัญหาที่ทุกคน
>> แต่สังเกตเห็นเพราะความเท่าเทียมนี้ เราจริงสามารถทำเช่นนี้ได้เป็นอย่างดี
ให้ฉันไปข้างหน้าและทำให้ใครคนหนึ่ง รุ่นอื่น ๆ ของ this-- 1.c. Ascii
และแทนที่จะทำซ้ำมากกว่า จำนวนเต็มจริงๆสามารถพัดใจของคุณ
โดยการทำซ้ำตัวละคร
ถ้าถ่านได้รับทุนผม ต้องการที่จะไปข้างหน้าและทำเช่นนี้
ตราบใดที่ C คือน้อยกว่าหรือเท่ากับ ถึง Z ทุนและในแต่ละซ้ำ
ฉันต้องการที่จะเพิ่ม C, ฉันสามารถ ขณะนี้อยู่ในบรรทัด printf ของฉันที่นี่
พูดร้อยละซี ร้อยละฉันอีกครั้งจุลภาคซี
>> และตอนนี้ฉันสามารถไปทิศทางอื่น ๆ หล่อตัวอักษรอย่างชัดเจน
เป็นจำนวนเต็ม
ดังนั้นอีกครั้งว่าทำไมคุณจะทำเช่นนี้?
มันเป็นเพียงเล็กน้อยแปลกที่จะเรียงลำดับของ นับในแง่ของตัวละคร
>> แต่ถ้าคุณเข้าใจสิ่งที่ ที่เกิดขึ้นภายใต้ประทุน
มีจริงๆไม่มีเวทมนตร์
คุณเพียงแค่บอกว่าเดี๋ยวก่อนคอมพิวเตอร์ให้ ฉันตัวแปรเรียกว่า C ประเภทถ่าน
มันเริ่มต้นไปยังเมืองหลวงและ A. แจ้งให้ทราบว่าราคาเดียว
>> สำหรับตัวละครใน C, จำจาก สัปดาห์ที่ผ่านมาคุณใช้ราคาเดียว
สำหรับสตริงสำหรับคำ วลีที่คุณใช้คำพูดสอง
ตกลงคอมพิวเตอร์ให้ทำเช่นนี้เพื่อให้ ตราบใดที่ตัวละครจะน้อยกว่า
หรือเท่ากับ Z
และฉันรู้จากตาราง Ascii ของฉันที่ทั้งหมด ของรหัส Ascii เหล่านี้มีความต่อเนื่องกัน
>> ไม่มีช่องว่างเป็น
ดังนั้นมันจึงเป็นเพียงถึง Z แยกจากกันโดยแต่ละหมายเลขหนึ่ง
แล้วฉันจะเพิ่มขึ้น ถ่านถ้าผมต้องการ
ในตอนท้ายของวัน, มันเป็นเพียงตัวเลข
ฉันรู้ว่านี้.
ดังนั้นผมก็สามารถเข้าใจเพื่อเพิ่ม 1 ถึงมัน
>> แล้วเวลานี้ผมพิมพ์ C, แล้วเทียบเท่าหนึ่ง
และฉันไม่จำเป็นต้องหล่ออย่างชัดเจน
ฉันสามารถให้ printf และ รูปคอมพิวเตอร์สิ่งที่ออก
เพื่อที่ว่าตอนนี้ถ้าผมทำงาน ทำให้ Ascii1./ascii1,
ฉันจะได้รับสิ่งเดียวที่แน่นอนเช่นกัน
>> โปรแกรมไร้ประโยชน์ though-- ไม่มีใคร เป็นไปได้จริงเขียนซอฟต์แวร์
เพื่อที่จะคิดออกสิ่งที่เป็น ตัวเลขที่แผนที่ไปยังหรือ B หรือ Z?
คุณเพียงแค่ไปที่ Google มันหรือ มองมันได้ออนไลน์หรือดูมันขึ้น
บนสไลด์หรือชอบ
เพื่อที่จะได้รับจริงนี้มีประโยชน์หรือไม่
>> ดีพูดว่า สไลด์สังเกตเห็นมี
รูปแบบที่เกิดขึ้นจริงที่นี่ระหว่างตัวพิมพ์ใหญ่ และตัวพิมพ์เล็กที่ไม่ได้ตั้งใจ
ขอให้สังเกตว่าทุนคือ 65
ตัวพิมพ์เล็กเป็น 97
และวิธีการที่ห่างไกลออกไปเป็นกรณีที่ต่ำกว่าหรือไม่?
>> ดังนั้น 65 ขั้นตอนวิธีการที่หลายคนให้พ้นจาก 97?
ดังนั้น 97 ลบ 65 เป็น 32
ดังนั้นเงินทุนคือ 65
ถ้าคุณเพิ่ม 32 ถึงว่า คุณจะได้รับตัวพิมพ์เล็ก
และเท่ากันถ้าคุณลบ 32, คุณได้รับกลับไปยังเมืองหลวง A-- เดียวกันกับ B
น้อย B, C ขนาดใหญ่เพื่อคเล็ก ๆ น้อย ๆ
>> ทั้งหมดเหล่านี้เป็นช่องว่างห่างกัน 32
ตอนนี้ก็ดูเหมือนจะช่วยให้เราสามารถ ทำอะไรเช่น Microsoft Word,
หรือ Google Docs มีที่คุณ สามารถเลือกทุกอย่างแล้วพูดว่า
เปลี่ยนทุกตัวพิมพ์เล็กหรือ เปลี่ยนทุกกรณีบน
หรือเปลี่ยนแปลงเพียงคำแรก ของประโยคกรณี​​ส่วนบน
เราสามารถทำได้จริงบางสิ่งบางอย่าง เช่นเดียวกับที่ตัวเอง
>> ให้ฉันไปข้างหน้าและบันทึกแฟ้ม นี่เรียกว่าประโยชน์ 0.c.
และให้ไปข้างหน้าและชักขึ้นโปรแกรม ที่ไม่ตรงกับที่ดังต่อไปนี้
ดังนั้น ได้แก่ ห้องสมุด CS50
และรวมถึงมาตรฐานของ I / O
>> และฉันรู้ว่านี้จะมาเร็ว ๆ นี้
ดังนั้นฉันจะใส่ไว้ใน มีอยู่แล้วสตริง,
ดังนั้นผมจึงมีการเข้าถึง สิ่งที่ต้องการสเตอร์ลิง
แล้ว int เป็นโมฆะหลักตามปกติ
แล้วฉันจะไปข้างหน้า และจะได้รับได้รับสตริงสตริง
เพียงเพื่อให้ได้สตริงจากผู้ใช้
แล้วฉันจะไป จะตรวจสอบสุขภาพจิตของฉัน
ถ้าสตริงไม่ null เท่ากัน แล้วมันปลอดภัยที่จะดำเนินการต่อไป
และทำในสิ่งที่ฉันต้องการจะทำอย่างไร?
ฉันจะย้ำจาก i เท่ากับ 0, n และขึ้นอยู่กับความยาวของสตริง s
>> และฉันจะทำเช่นนี้ตราบใดที่ ฉันมีค่าน้อยกว่า n และฉันบวกบวก
เพื่อให้ห่างไกลฉันจริงๆเพียงแค่ ยืมความคิดจากก่อน
และตอนนี้ฉันจะแนะนำสาขา
>> ดังนั้นคิดว่ากลับไปเกาที่ เรามีส้อมผู้ที่อยู่ในท้องถนน
และสัปดาห์ที่ผ่านมาใน C. ฉันจะ พูดแบบนี้ถ้าตัวอักษร I-TH ใน s
มากกว่าหรือ เท่ากับลดกรณี
and-- ในรอยขีดข่วนที่คุณต้องการอย่างแท้จริง พูดและ แต่ใน C คุณพูดเครื่องหมาย,
ampersand-- และตัวอักษร I-TH ใน s น้อยกว่าหรือเท่ากับกรณีที่ต่ำกว่า Z,
ขอทำสิ่งที่น่าสนใจ
Let 's จริงพิมพ์ ตัวละครที่ไม่มีการขึ้นบรรทัดใหม่
ว่าเป็นตัวละครในสตริง ตัวอักษร I-TH ในสตริง
>> แต่ขอไปข้างหน้าและ ลบ 32 จากมัน
อื่นถ้าตัวละครในนั้น สตริงที่เรากำลังมองหา
ไม่ได้เล็ก ๆ น้อย ๆ ระหว่าง และลิตเติ้ล Z ไปข้างหน้า
และเพียงแค่พิมพ์มันออกมาไม่เปลี่ยนแปลง
ดังนั้นเราจึงได้แนะนำให้รู้จัก นี้สัญกรณ์วงเล็บ
สำหรับสตริงของเราที่จะได้รับที่ ตัวอักษร I-TH ในสตริง
>> ฉันได้เพิ่มบางตรรกะเงื่อนไขเช่น รอยขีดข่วนในหนึ่งสัปดาห์เมื่อสัปดาห์ที่แล้วที่
ฉันเพียงแค่ใช้พื้นฐานของฉัน เข้าใจในสิ่งที่เป็น
ที่เกิดขึ้นภายใต้ฝากระโปรง
เป็นตัวละครที่ i ของ s มากกว่าหรือเท่ากับหรือไม่?
เหมือนมันเป็น 97 หรือ 98 หรือ 99 และอื่น ๆ ?
>> แต่ก็ยังน้อยกว่าหรือเท่ากับ มูลค่าของตัวพิมพ์เล็ก Z หรือไม่?
และถ้าเป็นเช่นนั้นสิ่งที่ไม่บรรทัดนี้หมายความว่าอย่างไร
14 นี้จะเรียงลำดับของ จมูกของความคิดทั้งหมด
อักษรตัวโดย เพียงแค่ลบ 32 จากมัน
ในกรณีนี้เพราะฉันรู้ว่าต่อว่า แผนภูมิวิธีหมายเลขของฉันจะเป็นตัวแทนของ
ดังนั้นขอให้ไปข้างหน้าและทำงานนี้ หลังจากรวบรวมประโยชน์ 0.c,
และเรียกใช้ประโยชน์ 0
>> ลองพิมพ์ในสิ่งที่ต้องการ Zamyla ตัวพิมพ์เล็กทั้งหมด Enter
และตอนนี้เรามี Zamyla ตัวพิมพ์ใหญ่ทั้งหมด
ลองพิมพ์ในร็อบในพิมพ์เล็กทั้งหมด
ลองเจสันในพิมพ์เล็กทั้งหมด
และเราได้รับ บังคับตัวพิมพ์ใหญ่
มีข้อผิดพลาดเล็ก ๆ น้อย ๆ ที่ฉันเป็น ชนิดของการไม่ได้คาดหวัง
ขอให้สังเกตพรอมต์ใหม่ของฉันกำลังจะสิ้นสุดลงขึ้น ในบรรทัดเดียวกับชื่อของพวกเขา
ที่รู้สึกยุ่งเล็ก ๆ น้อย ๆ
>> ดังนั้นฉันจะไปที่นี่และ จริงในตอนท้ายของโปรแกรมนี้
พิมพ์ออกมาเป็นตัวอักษรขึ้นบรรทัดใหม่
นั่นคือทั้งหมดที่
ด้วย printf คุณไม่จำเป็นต้อง ผ่านในตัวแปรหรือรหัสรูปแบบ
คุณสามารถแท้จริงเพียงแค่พิมพ์ สิ่งที่ต้องการขึ้นบรรทัดใหม่
>> ดังนั้นขอให้ไปข้างหน้าและทำให้ ประโยชน์ 0 อีกครั้งเรียกว่า Zamyla
และตอนนี้ก็เป็นความน่ารักเล็ก ๆ น้อย ๆ
ตอนนี้พรอมต์ของฉันอยู่บนบรรทัดใหม่ของตัวเอง
ดังนั้นนั่นคือทั้งหมดที่ดีและดี
เพื่อให้เป็นตัวอย่างที่ดี
แต่ผมไม่ได้จำเป็นต้อง ต้องยากรหัส 32
คุณรู้ไหมว่า?
ฉันสามารถ say-- ฉันไม่เคย จำสิ่งที่แตกต่างกันคือ
>> แต่ฉันรู้ว่าถ้าผม มีตัวอักษรกรณีที่ต่ำกว่า
ผมต้องการที่จะเป็นหลักลบออก สิ่งที่ระยะห่างระหว่างเล็ก ๆ น้อย ๆ
และขนาดใหญ่เพราะถ้าฉันคิดว่า ทั้งหมดของตัวอักษรอื่น ๆ เหมือนกัน
ที่ควรจะได้งานทำ
แต่แทนที่จะทำเช่นนั้นคุณรู้อะไรไหม
ยังคงมีวิธีอื่น
>> หากเป็นประโยชน์ 1.c-- ถ้าฉันเป็น ที่จะนำที่เป็นไฟล์แยกต่างหาก
ขอทำประโยชน์ 2.c ดังต่อไปนี้
ฉันจะไปจริงๆทำความสะอาดนี้ขึ้นที่นี่
และแทนที่จะต้องมีการ รู้หรือสนใจเกี่ยวกับระดับต่ำเหล่านั้น
รายละเอียดการดำเนินฉันแทน เพียงแค่จะพิมพ์ตัวอักษร
อ้างนำมาอ้างร้อยละ C, และ แล้วเรียกฟังก์ชั่นอื่นที่
อยู่ที่จะโต้แย้ง ซึ่งเป็นตัวละครเช่นนี้
>> มันจะเปิดออกใน C มี การเรียกใช้ฟังก์ชันอื่น
ไปบนซึ่งเป็นชื่อของมัน แสดงให้เห็นตัวละครที่ใช้เวลา
และทำให้มันกับกรณีบนของ เทียบเท่าแล้วส่งกลับไป
ดังนั้น printf ที่สามารถเสียบเข้าที่นั่น
และเพื่อที่จะทำเช่นนี้แม้ว่าฉัน ต้องแนะนำหนึ่งไฟล์อื่น ๆ
มันจะเปิดออกมีไฟล์อื่น ว่าคุณจะได้รู้จากชั้นเรียน
หรือตำราหรือออนไลน์ การอ้างอิงที่เรียกว่า type.h. C
>> ดังนั้นถ้าฉันจะเพิ่มขึ้นในหมู่หัวของฉัน ไฟล์และตอนนี้รวบรวมอีกครั้งโปรแกรมนี้
capitalize2, ./capitalize2 ใส่
ลองพิมพ์ใน Zamyla ในทุก ตัวพิมพ์เล็กยังคงทำงานเดียวกัน
แต่คุณรู้อะไรไหม
แต่กลับกลายเป็นว่าไปด้านบน มีบางส่วนการทำงานอื่น ๆ
>> และแจ้งให้เราแนะนำนี้ คำสั่งที่นี่จัดเรียงของเชื่องช้า
ชื่อ แต่คนสำหรับคู่มือ
แต่กลับกลายเป็นว่าคอมพิวเตอร์ที่ใช้ Linux ที่สุด ในขณะที่เรากำลังใช้ here-- ปฏิบัติการ
system-- มีคำสั่ง เรียกว่าคนที่ว่า
Hey, คอมพิวเตอร์, ให้ฉัน คู่มือของเครื่องคอมพิวเตอร์
คุณต้องการอะไร ขึ้นไปดูในคู่มือที่?
>> ฉันต้องการที่จะมองขึ้นฟังก์ชั่น เรียกตัวไปบนใส่
และมันก็เป็นความลับเล็ก ๆ น้อย ๆ บางครั้งการอ่าน
แต่สังเกตเห็นเราอยู่ใน คู่มือลินุกซ์โปรแกรมเมอร์
และมันก็เป็นทุกข้อความ
และแจ้งให้ทราบว่ามีเป็น ชื่อของฟังก์ชันที่ขึ้นที่นี่
มันจะเปิดออกก็มีญาติที่เรียกว่า เพื่อลดซึ่งจะตรงข้าม
และแจ้งให้ทราบภายใต้การสรุปที่จะใช้นี้ ทำงานหน้าคน, เพื่อที่จะพูด
จะบอกฉันว่าฉัน ต้องรวม C type.h.
และผมรู้ว่าจากการปฏิบัติ
>> นี่ก็แสดงให้ฉันสอง ต้นแบบสำหรับฟังก์ชั่น
เพื่อที่ว่าถ้าฉันเคยต้องการที่จะใช้นี้ ฉันรู้ว่าสิ่งที่พวกเขาใช้เป็น input
และสิ่งที่พวกเขากลับมาเป็นเอาท์พุท
แล้วถ้าผมอ่าน คำอธิบายที่ฉันเห็น
ในรายละเอียดมากขึ้นสิ่งที่ทำงานไม่
แต่ที่สำคัญกว่าถ้า ผมมองภายใต้ค่าตอบแทน
มันบอกว่าค่าที่ส่งกลับคือ ของตัวอักษรที่แปลง
หรือ C, การป้อนข้อมูลเดิมถ้า แปลงเป็นไปไม่ได้
>> ในคำอื่น ๆ ไปยังมุมบนจะพยายาม การแปลงจดหมายถึงกรณีที่ส่วนบน
และถ้าเป็นเช่นนั้นก็จะกลับมา
แต่ถ้ามันไม่สามารถสำหรับบาง reason-- บางทีมันอาจจะเป็นกรณีบนแล้ว
บางทีมันอาจจะเป็นเครื่องหมายอัศเจรีย์ หรือบาง punctuation-- อื่น ๆ
มันเป็นเพียงแค่ไป กลับ C เดิม
ซึ่งหมายความว่าฉันสามารถทำให้รหัสของฉัน การออกแบบที่ดีขึ้นดังต่อไปนี้
>> ฉันไม่จำเป็นต้องทั้งหมดของ เหล่านี้สายยี้รหัส
ทุกสายที่ผมได้ เพียงแค่ไฮไลต์สามารถ
จะทรุดลงเพียงหนึ่งง่าย บรรทัดซึ่งเป็น this-- ร้อยละ printf
C ถึง S วงเล็บบนผม
และนี่จะเป็น ตัวอย่างของการออกแบบที่ดีกว่า
>> ดำเนินการใน 7 หรือ 8 สายทำไม ของรหัสสิ่งที่มันเป็นฉันเพียงแค่
ลบเมื่อคุณแทนสามารถยุบ ทั้งหมดที่ตรรกะและการตัดสินใจ
เป็นสายเดียว 13 ตอนนี้ที่ อาศัยอยู่กับห้องสมุด function--
ฟังก์ชั่นที่มาพร้อมกับ C แต่ที่ ไม่ตรงกับสิ่งที่คุณต้องการจะทำ
และตรงไปตรงมาแม้ว่า มันไม่ได้มาพร้อมกับ C,
คุณสามารถใช้มันด้วยตัวคุณเองเป็น เราได้เห็นกับได้รับ int เชิงลบ
และได้รับในเชิงบวกในสัปดาห์ที่ผ่าน int เช่นกัน
>> รหัสนี้ในขณะนี้คืออ่านได้มากขึ้น
และแน่นอนถ้าเราเลื่อนขึ้น ดูวิธีการที่มีขนาดกะทัดรัดมากขึ้น
รุ่นของโปรแกรมของฉันนี้
มันเป็นหนักบนเล็ก ๆ น้อย ๆ ในขณะนี้ ทั้งหมดเหล่านี้รวมถึง
แต่ที่ตกลงเพราะตอนนี้ฉันยืนอยู่ บนไหล่ของโปรแกรมเมอร์
ก่อนฉัน.
และใครก็ตามที่มันเป็นใคร ดำเนินการเพื่อให้บนจริงๆ
ทำฉันหน่อยได้ไหมเหมือนใครก็ตาม การดำเนินการของสเตอร์ลิงจริงๆ
ไม่ฉันชอบเวลาที่ผ่านมา
ดังนั้นตอนนี้เรามี โปรแกรมออกแบบที่ดีกว่า
ที่ใช้ตรรกะเดียวกันแน่นอน
>> การพูดของสเตอร์ลิงให้ ฉันไปข้างหน้าและทำเช่นนี้
ให้ฉันไปข้างหน้าและบันทึก แฟ้มนี้เป็น stirling.c
และมันจะเปิดออกเราสามารถลอกกลับ ชั้นหนึ่งอื่นสวยเพียงแค่ตอนนี้
ฉันจะไปข้างหน้าและแส้ ขึ้นอีกโปรแกรมหนึ่งในหลัก
ที่นี่เป็นที่เรียบง่ายการดำเนินการอีกครั้ง ความยาวสายดังต่อไปนี้
ดังนั้นนี่คือบรรทัดของรหัสที่ ได้รับฉันสตริงจากผู้ใช้
เราให้ใช้นี้อีกครั้งและอีกครั้ง
ผมขอให้ตัวเองที่เรียกว่าตัวแปร n ชนิด int ที่เก็บตัวเลข
>> และแจ้งให้เราไปข้างหน้าและ ทำตรรกะต่อไปนี้
ในขณะที่ตัวอักษร N-TH ใน s ไม่ ไม่เท่ากับ 0 ทับขวาไปข้างหน้า
และเพิ่มขึ้น n
แล้วพิมพ์ออกร้อยละ printf ฉัน n
ฉันเรียกร้องว่าโปรแกรมนี้ที่นี่ โดยไม่มีการเรียกความยาวสตริง
ตัวเลขออกมาตามความยาวของสตริง
>> และความมหัศจรรย์เป็นอย่างสิ้นเชิง ห่อหุ้มในบรรทัดที่ 8
ที่นี่มีสิ่งที่ดูเหมือนว่าไวยากรณ์ใหม่ ทับขวานี้ 0 ในราคาเดียว
แต่ทำไมเป็นเช่นนั้น?
ดีพิจารณาสิ่งที่ได้รับ ที่เกิดขึ้นทั้งหมดในขณะนี้
>> และเช่นกันก่อนที่ผมจะลืมตระหนัก เกินไปว่านอกเหนือไปจากหน้าคน
ที่มาพร้อมกับโดยทั่วไป ระบบ Linux เช่น CS50 IDE,
ตระหนักดีว่าเราที่ พนักงานของหลักสูตรมียัง
ทำรุ่นที่เว็บไซต์ ของความคิดเดียวกันนี้เรียกว่า
reference.cs50.net ซึ่งมี ทุกคนหน้าคนเดียวกัน
ทุกเดียวกันกับที่ เอกสารเช่นเดียวกับ
กล่องเล็ก ๆ ที่ด้านบนที่ช่วยให้ คุณสามารถแปลงทุกอย่างเป็นธรรม
ภาษา Arcane เข้าน้อยสบาย โหมดที่เราพนักงานการเรียนการสอน
ได้ผ่านและพยายามที่จะลดความซับซ้อน บางส่วนของภาษาเพื่อให้สิ่งที่
มุ่งเน้นไปที่ความคิดและไม่ได้ บางส่วนของศัพท์
ดังนั้นเก็บไว้ในใจ reference.cs50.net เป็นทรัพยากรอื่นได้เป็นอย่างดี
>> แต่ทำไมไม่ทำงานสตริง วิธีการที่ผมนำเสนอช่วงเวลาที่ผ่านมา?
นี่คือชื่อ Zamyla อีกครั้ง
และนี่คือชื่อของ Zamyla บรรจุกล่องในขณะที่ผมให้ทำ
การวาดภาพของมันถูก, จริงๆเพียงลำดับของตัวอักษร
แต่ Zamyla ไม่อยู่ ในการแยกในโปรแกรม
>> เมื่อคุณเขียนและเรียกใช้โปรแกรม คุณกำลังใช้ Mac หรือ PC ของคุณ
เป็นหน่วยความจำหรือแรมเพื่อที่จะพูด
และคุณอาจจะคิดว่า คอมพิวเตอร์ของคุณมี
จำนวนมากกิกะไบต์หน่วยความจำวันนี้
และกิ๊กหมายถึงพันล้าน ดังนั้นพันล้านไบต์
>> แต่ขอย้อนกลับในเวลาที่
และสมมติว่าเรากำลังใช้ คอมพิวเตอร์เก่าจริงๆว่า
มีเพียง 32 ไบต์ของหน่วยความจำ
ที่ฉันสามารถทำได้บนหน้าจอคอมพิวเตอร์ของฉัน เพียงแค่วาดนี้ออกมาดังต่อไปนี้
>> ฉันก็อาจกล่าวได้ว่าฉัน คอมพิวเตอร์มีทั้งหมดของหน่วยความจำนี้
และนี่ก็เหมือนติดของหน่วยความจำถ้า คุณจำภาพของเราจากครั้งที่แล้ว
และถ้าฉันเพียงแค่แบ่ง นี้ในช่วงเวลาที่เพียงพอ
ฉันเรียกร้องว่าฉันมี 32 ไบต์ ของหน่วยความจำบนหน้าจอ
>> ตอนนี้ในความเป็นจริงที่ฉันสามารถทำได้เพียง วาดเพื่อให้ห่างไกลบนหน้าจอนี้ได้ที่นี่
ดังนั้นฉันจะไปข้างหน้า และเพียงแค่การประชุม
วาดหน่วยความจำของคอมพิวเตอร์ของฉันเป็น ตารางที่ไม่เพียง แต่เป็นหนึ่งในแนวเส้นตรง
โดยเฉพาะฉันเรียกร้องในขณะนี้ว่า ตารางนี้นี้ 8 4 ตาราง
เพียงแสดงทั้งหมด 32 ไบต์ ของหน่วยความจำที่มีอยู่ในเครื่อง Mac ของฉัน
หรือที่มีอยู่ในเครื่องคอมพิวเตอร์ของฉัน
และพวกเขากำลังห่อ ไปสองบรรทัดเพียง
เพราะมันพอดีมากขึ้นบนหน้าจอ
แต่นี้เป็นไบต์แรก
นี้เป็นครั้งที่สองไบต์
นี้เป็นไบต์ที่สาม
>> และนี่คือ 32 ไบต์
หรือถ้าเราคิดว่าเหมือนคอมพิวเตอร์ นักวิทยาศาสตร์นี้เป็นไบต์ 0, 1, 2, 3, 31
เพื่อให้คุณมี 0-31 ถ้า คุณเริ่มนับที่ 0
>> ดังนั้นหากเราใช้โปรแกรม ที่ได้รับการโทรสตริง
และเราได้รับสตริงจากมนุษย์ เหมือนผมเรียกว่า Zamyla, Z-A-M-Y-L-A
ว่าในโลกไม่ ติดตาม Computer เก็บของซึ่งไบต์
ซึ่งก้อนของหน่วยความจำ เป็นของสตริง?
ในคำอื่น ๆ ถ้าเราดำเนินการต่อไป พิมพ์ชื่ออื่นเข้ามาในเครื่องคอมพิวเตอร์
เช่นนี้แล้วล่ะเรียก ได้รับสตริงเป็นครั้งที่สอง
A-N-D-I มีที่จะจบลงใน หน่วยความจำของเครื่องคอมพิวเตอร์ได้เป็นอย่างดี
แต่อย่างไร
>> ดีก็ปรากฎว่าอยู่ภายใต้ เครื่องดูดควัน, C สิ่งที่ไม่เมื่อการจัดเก็บสตริง
ว่าประเภทของมนุษย์หรือว่า มาจากแหล่งอื่น ๆ บางอย่างก็คือ
ให้สัตยาบันในตอนท้ายของพวกเขาด้วย เครื่องหมาย character-- พิเศษ
0 ซึ่งเป็นเพียงวิธีพิเศษ บอก 80 บิตในแถว
>> ดังนั้น A-- นี้คือการเรียกคืนจำนวน 97
ดังนั้นรูปแบบของ 8 บิตบาง หมายถึงจำนวนทศนิยม 97
ทับขวา 0 เป็นอักษรจำนวน 0, NUL หรือที่เรียกว่า N-U-L ซึ่งแตกต่างจากก่อนหน้านี้
N-U-L-L ซึ่งเราพูดคุยเกี่ยวกับ
แต่สำหรับตอนนี้เพียงแค่รู้ว่านี้ ทับขวา 0 เป็นเพียง 80 บิตในแถว
>> และเป็นเพียงบรรทัดนี้ใน เม็ดทรายที่ว่าอะไรไปทางซ้าย
เป็นหนึ่งสายหรือชนิดข้อมูลหนึ่ง
และสิ่งที่ไปทางขวา เป็นอย่างอื่น
Andi ชื่อในขณะเดียวกัน ซึ่งเพียงแค่สายตา
ที่เกิดขึ้นในการตัดไปสายอื่น ๆ , แต่นั่นเป็นเพียงรายละเอียดความงาม
ในทำนองเดียวกันคือ NUL สิ้นสุด
>> มันเป็นสตริงของตัวอักษร A-N-D-ฉัน, บวกกับตัวละครลับที่ห้า
ทั้งหมด 0 บิตที่เพิ่ง demarcates ท้ายชื่อของ Andi ได้เป็นอย่างดี
และถ้าเราได้รับโทรสตริงเป็นครั้งที่สาม ในเครื่องคอมพิวเตอร์ที่จะได้รับเช่นสตริง
มาเรีย, M-A-R-I-A, ในทำนองเดียวกันคือมาเรีย ชื่อ NUL สิ้นสุดลงด้วยเครื่องหมายทับขวา 0
>> นี่คือพื้นฐานที่แตกต่างกัน จากวิธีการที่คอมพิวเตอร์จะมักจะ
เก็บจำนวนเต็มหรือลอยหรืออื่น ๆ ชนิดข้อมูลยังคงเพราะการเรียกคืน
จำนวนเต็มมักจะเป็น 32 บิตหรือ 4 ไบต์หรือแม้กระทั่ง 64 บิต
หรือแปดไบต์
แต่หลายคนในวิทยาการคอมพิวเตอร์ ในการเขียนโปรแกรมภาษา
มีจำนวนคงที่ของ ไบต์ใต้ hood--
บางทีที่ 1, 2 บางทีอาจจะ 4 อาจจะ 8
>> แต่สายโดยการออกแบบมี จำนวนแบบไดนามิกของตัวละคร
คุณไม่ทราบล่วงหน้าจนกว่า ประเภทของมนุษย์ใน Z-A-M-Y-L-A
หรือ M-A-R-I-A หรือ A-N-D-I คุณไม่ทราบว่า กี่ครั้งที่ผู้ใช้จะได้ไปตี
คีย์บอร์ด.
ดังนั้นคุณไม่ทราบวิธีการ ตัวอักษรหลายล่วงหน้า
คุณกำลังจะต้อง
>> และเพื่อให้ C เพียงแค่ชนิดของใบเช่น แสดงเส้นทางลับใต้ฝากระโปรง
ในตอนท้ายของสตริง
หลังจากได้จัดเก็บ Z-A-M-Y-L-A ในหน่วยความจำ มันก็เป็นเพียงแค่ทำให้เทียบเท่า
งวด
ในตอนท้ายของประโยค มันทำให้ 80 บิตเพื่อให้เป็น
จำที่ Zamyla เริ่มต้นและสิ้นสุด
>> ดังนั้นสิ่งที่เชื่อมต่อ แล้วโปรแกรมนี้?
โปรแกรมนี้ที่นี่สเตอร์ลิง เป็นเพียงกลไก
สำหรับการรับสตริง จากผู้ใช้ LINE 6
สาย 7 ผมประกาศตัวแปร เรียกว่า n และตั้งค่าเท่ากับ 0
>> และจากนั้นในบรรทัดที่ 8 ผมก็ถาม คำถามในขณะที่ตัวอักษร N-TH ไม่
ไม่เท่ากันทั้งหมด 0 bits-- ในคำอื่น ๆ ไม่ได้
เท่ากับพิเศษนี้ ตัวอักษรทับขวา 0 ซึ่ง
เป็นเพียงที่ character-- NUL พิเศษ ไปข้างหน้าและเพิ่มขึ้นเพียง n
>> และให้ทำมันและให้ ทำมันและให้ทำมัน
และดังนั้นแม้ว่าใน ที่ผ่านมาเราได้ใช้ผม
ก็ปรับได้อย่างสมบูรณ์แบบ ความหมายที่จะใช้ N,
ถ้าคุณเพียงแค่พยายามที่จะ นับเวลานี้จงใจ
และเพียงแค่ต้องการที่จะเรียกว่า n
ดังนั้นนี่เป็นเพียงแค่ช่วยถามคำถาม เป็นตัวละครที่ N-TH ของ s 0s ทั้งหมดหรือไม่
ถ้าไม่ได้มองไปดูต่อไป มองไปข้างหน้ามองไปข้างหน้า
มองไปข้างหน้า
>> แต่ทันทีที่คุณเห็นทับขวา 0, ทางรถไฟสายนี้ loop-- 9 ถึงหยุด 11--
คุณทำลายออกจากวงในขณะที่ ออกจากด้านในของตัวแปรที่ n
จำนวนรวมทั้งหมดของ ตัวอักษรในสตริงที่คุณเห็น
จึงพิมพ์มันออกมา
ดังนั้นขอลองนี้
>> ให้ฉันไปข้างหน้าและโดยไม่ต้อง โดยใช้ฟังก์ชั่นสเตอร์ลิง
แต่เพียงแค่ใช้รุ่นพื้นบ้านของตัวเอง เรียกว่าสเตอร์ลิงที่นี่ให้ฉันไปข้างหน้า
และเรียกใช้สเตอร์ลิงชนิดในบางสิ่งบางอย่าง เช่น Zamyla ซึ่งผมทราบล่วงหน้า
เป็นหกตัวอักษร
ลองมาดูกันว่าการทำงาน
อันที่จริงมันเป็นหก
ลองกับร็อบสามตัวอักษร ตัวละครทั้งสามเป็นอย่างดีและอื่น ๆ
ดังนั้นนั่นคือทั้งหมดที่เกิดขึ้น ขึ้นภายใต้ฝากระโปรง
และแจ้งให้ทราบการเชื่อมต่อ, แล้วกับสัปดาห์แรก
ของชั้นเรียนที่เราพูดคุยเกี่ยวกับ สิ่งที่ต้องการนามธรรม
ซึ่งเป็นเพียงชั้นของความคิดนี้หรือ ความซับซ้อนด้านบนของหลักการพื้นฐาน
นี่เรากำลังมองหาการเรียงลำดับของ ใต้ฝากระโปรงของสเตอร์ลิง
เพื่อที่จะพูดจะคิดออก วิธีการที่จะดำเนินการ?
>> และเราจะดำเนินการอีกครั้งมันเอง
แต่เราไม่เคยอีกครั้งไป ใช้อีกครั้งสเตอร์ลิง
เรากำลังจะไป สเตอร์ลิงใช้ในการสั่งซื้อ
ที่จะได้รับจริงบางสายยาว
>> แต่มีเวทมนตร์ไม่มี ใต้ฝากระโปรง
ถ้าคุณรู้ว่าภายใต้ เครื่องดูดควัน, สตริง
เป็นเพียงลำดับของตัวอักษร
และลำดับของตัวอักษรที่ ทุกคนสามารถได้รับการแก้ไขตัวเลข
ด้วยวงเล็บ 0 วงเล็บ 1 วงเล็บ 2 และคุณ
รู้ว่าในตอนท้ายของสตริงเป็น ตัวอักษรพิเศษที่คุณสามารถคิดออก
วิธีการทำอะไรมากที่สุดใน โปรแกรมเพราะมันเดือดลงไป
คือการอ่านและการเขียนหน่วยความจำ
นั่นคือการเปลี่ยนแปลงและการมอง ที่หน่วยความจำหรือการเคลื่อนย้ายสิ่ง
รอบ ๆ หน่วยความจำในสิ่งที่พิมพ์ บนหน้าจอและอื่น ๆ
>> ดังนั้นตอนนี้ขอใช้ที่เพิ่งค้นนี้ เข้าใจในสิ่งที่สตริงจริง
อยู่ใต้ฝากระโปรงและ ปอกเปลือกกลับชั้นหนึ่งอื่น ๆ
ว่าจนถึงตอนนี้เราได้ ถูกละเลยโดยสิ้นเชิง
โดยเฉพาะอย่างยิ่งเวลาใดก็ได้ เราได้ดำเนินการโปรแกรม
ที่เราเคยมีบรรทัดของรหัสนี้ ใกล้หลักประกาศด้านบน
และเราได้ระบุไว้ int เป็นโมฆะหลัก
>> และนั่นถือเป็นโมฆะภายในวงเล็บ มีรับการพูดตลอดเวลาว่าหลัก
ตัวเองไม่ได้ใช้ข้อโต้แย้งใด ๆ
ป้อนข้อมูลใด ๆ ที่สำคัญคือ จะได้รับจากผู้ใช้
มีการมาจากบางส่วนอื่น ๆ กลไกเช่นได้รับ int,
หรือได้รับลอยหรือได้รับสตริง หรือบางฟังก์ชั่นอื่น ๆ
แต่มันกลับกลายเป็นว่า เมื่อคุณเขียนโปรแกรม
คุณจริงสามารถระบุ ว่าโปรแกรมนี้จะ
ใช้ปัจจัยการผลิตจากมนุษย์ ที่บรรทัดคำสั่งของตัวเอง
>> ในคำอื่น ๆ แม้ว่าเราป่านนี้ มีการทำงานเพียง ./hello สวัสดี
หรือโปรแกรมที่คล้ายกันทั้งหมดของ โปรแกรมอื่น ๆ ที่เราได้รับใช้
ที่เราเองไม่ได้เขียน ได้รับการดูเหมือนว่า
arguments-- บรรทัดคำสั่ง สิ่งที่ต้องการให้
คุณบอกว่าสิ่งที่ชอบแต่งหน้า, แล้วสองคำ
หรือเสียงดังกราวคุณพูดเสียงดังกราวแล้ว คำที่สองชื่อของไฟล์
>> หรือแม้กระทั่ง RM หรือซีพีที่คุณอาจ ได้เห็นหรือใช้แล้ว
จะลบหรือคัดลอกไฟล์
ทั้งหมดของผู้ใช้ที่เรียกว่า arguments-- บรรทัดคำสั่ง
คำเพิ่มเติมที่พร้อมท์ขั้ว
แต่จนถึงขณะนี้เรา ตัวเองไม่ได้
ความหรูหราของการป้อนข้อมูลจากนี้ ผู้ใช้เมื่อเขาหรือเธอจริงทำงาน
โปรแกรมเองที่บรรทัดคำสั่ง
>> แต่เราสามารถทำเช่นนั้นโดยการประกาศ หลักก้าวไปข้างหน้าไม่ได้ว่ามี
ช่องว่างในวงเล็บ แต่ทั้งสองมีปากเสียง
instead-- แรกจำนวนเต็ม และบางสิ่งบางอย่างที่สอง
ใหม่สิ่งที่เรากำลังจะไปเรียก อาร์เรย์สิ่งที่คล้ายกันในจิตวิญญาณ
กับสิ่งที่เราเห็นในรอยขีดข่วนเป็นรายการ แต่ อาร์เรย์ของสตริงที่เราจะเห็นทันที
แต่ขอดูนี้โดย วิธีการเช่นก่อนที่เราจะ
แยกแยะว่าสิ่งที่หมายถึง
>> ดังนั้นถ้าฉันไปเป็น IDE CS50 ที่นี่ผมได้ไปข้างหน้า
และประกาศในไฟล์ที่เรียกว่า argv0.c แม่แบบดังต่อไปนี้
และแจ้งให้ทราบเพียงสิ่งเดียว ที่แตกต่างกันเพื่อให้ห่างไกล
คือการที่ฉันได้เปลี่ยนไปเป็นโมฆะ int สตริง argc argv วงเล็บเปิดปิด
วงเล็บ
และแจ้งให้ทราบตอนนี้มี ไม่มีอะไรที่อยู่ภายในวงเล็บเหล่านั้น
>> มีจำนวนไม่ได้
และไม่มีผมหรือ N, หรือตัวอักษรอื่น ๆ
ฉันแค่ใช้ วงเล็บสำหรับตอนนี้
สำหรับเหตุผลที่เราจะมา กลับไปในเวลาเพียงสักครู่
>> และตอนนี้สิ่งที่ผมจะทำคือการนี​​้
ถ้า argc เท่ากับเท่ากับ 2-- และจำได้ว่าเท่ากับเท่ากับ
เป็นผู้ดำเนินการเปรียบเทียบความเสมอภาค ด้านซ้ายและขวาเพื่อความเท่าเทียมกัน
มันไม่ได้เป็นที่ได้รับมอบหมาย ผู้ประกอบการซึ่งเป็น
เครื่องหมายเท่ากับเดียวซึ่งหมายถึงการคัดลอก จากขวาไปซ้ายค่าบางอย่าง
>> ถ้า argc เท่ากับเท่ากับ 2 ผมต้องการที่จะ พูด printf สวัสดีร้อยละบรรทัดใหม่
แล้วเสียบ in-- และนี่คือใหม่ trick-- argv วงเล็บ 1 สำหรับเหตุผล
ว่าเราจะกลับมาในช่วงเวลาที่
อื่นถ้า argc ไม่ เท่ากับ 2 คุณรู้อะไรไหม
ขอเพียงไปข้างหน้าและตามปกติการพิมพ์ ออก Hello World โดยไม่มีการเปลี่ยนตัว
>> ดังนั้นก็จะดูเหมือนว่าถ้า argc ซึ่ง ยืนสำหรับการนับอาร์กิวเมนต์เท่ากับ 2
ฉันจะพิมพ์ออกมา สวัสดีหรือสิ่งอื่น ๆ
มิฉะนั้นโดยค่าเริ่มต้นผม จะพิมพ์ Hello World
ดังนั้นสิ่งนี้หมายความว่าอย่างไร
>> ดีให้ฉันไปข้างหน้าและบันทึก ไฟล์นี้แล้วจะทำให้ argv0,
แล้ว ./argv0 ใส่
และกล่าวว่า Hello World
ตอนนี้ทำไมเป็นเช่นนั้น?
>> ดีก็จะเปิดออกตลอดเวลาที่คุณ เรียกใช้โปรแกรมที่บรรทัดคำสั่ง
คุณกำลังกรอกข้อมูลในสิ่งที่เราจะ โดยทั่วไปเรียกเวกเตอร์อาร์กิวเมนต์
ในคำอื่น ๆ โดยอัตโนมัติ คอมพิวเตอร์ระบบปฏิบัติการ
เป็นไปมือเพื่อโปรแกรมของคุณ ตัวเองรายการทั้งหมดของคำว่า
ว่ามนุษย์ที่พิมพ์ พรอมต์ในกรณีที่คุณ
โปรแกรมเมอร์ต้องการที่จะทำ บางสิ่งบางอย่างที่มีข้อมูลว่า
และในกรณีนี้คำเดียว ผมเคยพิมพ์ที่พรอมต์เป็น ./argv0
>> และดังนั้นจำนวนของการขัดแย้งที่มีอยู่ ถูกส่งผ่านไปยังโปรแกรมของฉันเป็นเพียงหนึ่ง
ในคำอื่น ๆ การโต้แย้ง นับหรือที่เรียกว่า argc
ที่นี่เป็นจำนวนเต็มเป็นเพียงหนึ่ง
หนึ่งของหลักสูตรไม่เท่ากับสอง
ดังนั้นนี่คือสิ่งที่พิมพ์สวัสดีโลก
>> แต่ให้ฉันใช้เวลานี้อยู่ที่ไหนสักแห่ง
ให้ฉันบอกว่า argv0
แล้ววิธีการเกี่ยวกับมาเรีย?
แล้วกด Enter
>> และสังเกตเห็นสิ่งที่น่าอัศจรรย์ที่เกิดขึ้นที่นี่
ตอนนี้แทนที่จะโลกสวัสดีฉันมี การเปลี่ยนแปลงพฤติกรรมของโปรแกรมนี้
โดยการป้อนข้อมูลที่ไม่ได้มาจากการได้รับ สตริงหรือบางฟังก์ชั่นอื่น ๆ
แต่จากเห็นได้ชัดว่าคำสั่งของฉัน ตัวเองในสิ่งที่ฉันเดิมที่พิมพ์ลงใน
และผมสามารถเล่นเกมนี้อีกครั้งโดย เปลี่ยนไป Stelios ตัวอย่างเช่น
>> และตอนนี้ผมเห็นชื่ออื่นยังคง
และที่นี่ผมอาจจะพูดล่ะ
และผมอาจจะบอกว่า Zamyla
และเราสามารถเล่นเกมนี้ได้นานตลอดวัน เพียงแค่เสียบค่าที่แตกต่างกัน
ตราบใดที่ผมให้ตรง คำสองคำที่พรอมต์
เช่นที่ argc นับอาร์กิวเมนต์ของฉันคือ 2
>> ฉันเห็นว่าชื่อเสียบเข้า printf ต่อสภาพนี้ที่นี่?
ดังนั้นเราจึงดูเหมือนจะมีในขณะนี้ ความสามารถในการแสดงออก
ของการใช้ข้อมูลจากกลไกอื่น จากบรรทัดคำสั่งที่เรียกว่า
แทนที่จะต้องรอ จนกว่าผู้ใช้รันโปรแกรม
แล้วแจ้งให้เขาหรือเธอ ใช้สิ่งที่ต้องการสตริง
>> ดังนั้นสิ่งนี้คืออะไร?
argc อีกครั้งเป็นเพียงจำนวนเต็ม จำนวน words-- arguments--
ที่ผู้ใช้บริการที่มีให้ที่ พรอมต์ที่หน้าต่าง terminal,
รวมทั้งชื่อของโปรแกรม
ดังนั้น ./argv0 ของเราคือการมีประสิทธิภาพ ชื่อของโปรแกรม
หรือวิธีการที่ฉันเรียกใช้โปรแกรม
>> ที่นับว่าเป็นคำ
ดังนั้น argc จะเป็น 1
แต่เมื่อผมเขียน Stelios หรือ Andi หรือ Zamyla หรือมาเรีย
นั่นหมายความว่านับอาร์กิวเมนต์เป็นสอง
และอื่น ๆ ตอนนี้มีสองคำผ่าน
>> และแจ้งให้ทราบเราสามารถดำเนินการต่อตรรกะนี้
ถ้าผมพูดจริง สิ่งที่ต้องการ Zamyla จัน
ชื่อเต็มจึงผ่าน สามข้อโต้แย้งในทั้งหมด
ตอนนี้ก็บอกว่าเริ่มต้นอีกครั้ง เพราะของหลักสูตร 3 ไม่เท่ากับ 2
>> และอื่น ๆ ในลักษณะนี้ทำฉันมี การเข้าถึงผ่านทาง argv โต้เถียงครั้งใหม่นี้
ที่เราจะได้ในทางเทคนิค เรียกสิ่งที่เราต้องการ
แต่โดยการประชุมก็ และ argv argc ตามลำดับ
argv อาร์กิวเมนต์เวกเตอร์เป็นชนิด ของคำพ้องสำหรับการเขียนโปรแกรมเป็น
คุณลักษณะใน C เรียกว่าอาร์เรย์
>> อาร์เรย์คือรายการของค่าที่คล้ายกัน กลับไปกลับไปกลับไปด้านหลัง
ในคำอื่น ๆ หากมีที่นี่ใน RAM, หนึ่งต่อไปอยู่ติดกับมัน
และขวาถัดไป
พวกเขาไม่ได้ทั่วทุกสถานที่
และสถานการณ์หลังสิ่งที่ มีทั่วทุกสถานที่ในหน่วยความจำ
จริงอาจจะเป็นคุณลักษณะที่มีประสิทธิภาพ
แต่เราจะกลับมาที่ว่าเมื่อเรา พูดคุยเกี่ยวกับโครงสร้างข้อมูลนักเล่น
สำหรับตอนนี้อาร์เรย์เป็นเพียง หน่วยความจำอันต่อเนื่องกัน
แต่ละซึ่งเป็นธาตุ กลับไปกลับไปกลับไปกลับ
และโดยทั่วไปประเภทเดียวกัน
>> ดังนั้นหากคุณคิดเกี่ยวกับการจาก ช่วงเวลาที่ผ่านมาสิ่งที่เป็นสตริง?
ดีสตริงเช่น Zamyla, Z-A-M-Y-L-เป็นเทคนิค
เพียงอาร์เรย์
มันเป็นอาร์เรย์ของตัวอักษร
>> ดังนั้นถ้าเราวาดนี้ที่ผม ก่อนหน้านี้ไม่เป็นก้อนของหน่วยความจำ
มันกลับกลายเป็นว่าแต่ละเหล่านี้ ตัวละครจะขึ้นไบต์
แล้วมีที่พิเศษ ตัวละคร Sentinel, เครื่องหมาย 0,
หรือทั้งหมดแปด 0 บิตที่ demarcates ปลายสายว่า
ดังนั้นสตริงก็จะเปิด ออกมาพูดนำมาอ้างสตริง,
เป็นเพียงอาร์เรย์ของ chara-- ถ่านเป็นชนิดข้อมูลที่เกิดขึ้นจริง
>> และตอนนี้ argv, meanwhile-- ขอกลับไปที่โปรแกรม
argv แม้ว่าเราจะเห็นคำว่า สตริงที่นี่ไม่เป็นสตริงตัวเอง
argv อาร์กิวเมนต์เวกเตอร์ เป็นอาร์เรย์ของสตริง
>> ดังนั้นเพียงแค่เท่าที่คุณสามารถมีอาร์เรย์ของ ตัวอักษรที่คุณสามารถมีระดับที่สูงขึ้น
อาร์เรย์ของ strings-- เพื่อตัวอย่างเช่น เมื่อฉันพิมพ์สักครู่ที่ผ่านมา ./argv0
argv0 พื้นที่ Z-A-M-Y-L-ผมอ้างว่า argv มีสองสายใน ./argv0 it--,
และ Z-A-M-Y-L-A ใน คำอื่น ๆ argc 2
ทำไมเป็นเช่นนั้น?
>> ดีอย่างมีประสิทธิภาพสิ่งที่เกิดขึ้น ก็คือว่าแต่ละสายเหล่านี้
เป็นของหลักสูตรอาร์เรย์ของตัวอักษร เมื่อก่อนแต่ละที่มีตัวอักษร
ใช้เวลาถึงหนึ่งไบต์
และไม่สร้างความสับสนให้เกิดขึ้นจริง 0 ในชื่อของโปรแกรมที่มี 0,
ซึ่งหมายความว่าทุก 80 บิต
และ Zamyla ขณะที่ยังคง ยังมีอาร์เรย์ของตัวอักษร
>> ดังนั้นในตอนท้ายของวันนั้นจริงๆ ลักษณะเช่นนี้อยู่ภายใต้ฝากระโปรง
แต่ argv โดยธรรมชาติของวิธีการหลัก งานช่วยให้ฉันไปห่อทั้งหมดนี้
ขึ้นไปถ้าคุณจะเป็นอาร์เรย์ที่ใหญ่กว่า ว่าถ้าเราลดความซับซ้อนน้อยกว่า
สิ่งที่ภาพดูชอบและไม่ วาดมันค่อนข้างที่จะไต่ขึ้นมี
อาร์เรย์นี้เป็นเพียงขนาด 2 เป็นครั้งแรก องค์ประกอบของการที่มีสตริง
องค์ประกอบที่สองของ ซึ่งมีสตริง
และในทางกลับกันถ้าคุณ ชนิดของการซูมในแต่ละ
ของสตริงเหล่านั้นสิ่งที่คุณ ดูใต้ฝากระโปรง
คือการที่แต่ละสายเป็นเพียง อาร์เรย์ของตัวละคร
>> ตอนนี้เช่นเดียวกับสตริง เราสามารถที่จะได้รับการเข้าถึง
ไปที่ตัวอักษร I-TH ในสตริง โดยใช้สัญกรณ์วงเล็บเหลี่ยม
ในทำนองเดียวกันกับอาร์เรย์ โดยทั่วไปเราสามารถ
ใช้สัญกรณ์วงเล็บเหลี่ยมที่จะได้รับ ที่บ้านเลขที่ใด ๆ ของสตริงในอาร์เรย์?
ยกตัวอย่างให้ฉัน ไปข้างหน้าและทำเช่นนี้
>> ให้ฉันไปข้างหน้าและสร้าง argv1.c, ซึ่งเป็นที่แตกต่างกันเล็ก ๆ น้อย ๆ ในเวลานี้
แทนการตรวจสอบสำหรับ argc2, ฉันจะทำเช่นนี้แทน
สำหรับ int ฉันได้รับ 0 ผมน้อย กว่า argc ผมบวกบวก
แล้วพิมพ์ออกมาภายในนี้ ร้อยละ S, บรรทัดใหม่แล้ว
argv วงเล็บฉัน
>> ดังนั้นในคำอื่น ๆ ผมไม่ได้ติดต่อกับ อักขระแต่ละตัวในขณะนี้
argv เป็นนัยเหล่านี้ตารางที่ว่างเปล่า วงเล็บด้านขวาของชื่อ argv ที่
หมายความ argv เป็นอาร์เรย์ของสตริง
และ argc เป็นเพียง int
>> บรรทัดนี้ที่นี่ 6, มี บอกว่าผมตั้งค่าเท่ากับ 0
นับตลอดทางขึ้นไป, แต่ไม่รวม argc
และจากนั้นในแต่ละซ้ำ, พิมพ์สตริง
อะไรสตริง?
>> สตริง I-TH ใน argv
ดังนั้นในขณะที่ก่อนผมเป็น โดยใช้วงเล็บเหลี่ยม
สัญกรณ์ที่จะได้รับที่ i ตัวละครในสตริงในขณะนี้
ฉันใช้สัญกรณ์วงเล็บสี่เหลี่ยม ที่จะได้รับสตริงที่ i ในอาร์เรย์
ดังนั้นมันจึงเป็นชนิดของชั้นหนึ่ง ข้างต้นแนวคิด
>> และเพื่อให้สิ่งที่เรียบร้อยเกี่ยวกับเรื่องนี้ โปรแกรมตอนนี้ถ้าผมรวบรวม argv1,
แล้วทำ ./argv1 และจากนั้นพิมพ์ ในสิ่งที่ต้องการ foo บาร์ Baz,
ซึ่งเป็นคำสามคำเริ่มต้นว่า นักวิทยาศาสตร์คอมพิวเตอร์ถึงเวลาใด ๆ
เขาหรือเธอต้องการคำยึดบางส่วน และกด Enter แต่ละคำพูดเหล่านั้น
รวมทั้งชื่อของโปรแกรมซึ่ง อยู่ใน argv ที่สถานที่แรก
จบลงด้วยการถูกพิมพ์ในช่วงเวลาหนึ่ง
และถ้าผมเปลี่ยนนี้และผมบอกว่า สิ่งที่ต้องการ argv1 Zamyla จัน
เราได้รับทั้งสามของคนเหล่านั้น คำซึ่งเป็น argv0,
argv1, argv2 เพราะในนี้ กรณี argc นับเป็น 3
>> แต่สิ่งที่เรียบร้อยคือถ้าคุณเข้าใจ argv ที่เป็นเพียงอาร์เรย์ของสตริง,
และคุณเข้าใจว่าสตริง เป็นอาร์เรย์ของตัวอักษร,
เราสามารถจริงชนิดของการใช้นี้ สัญกรณ์วงเล็บเหลี่ยมหลายครั้ง
ให้เลือกสตริงและจากนั้นเลือก ตัวละครภายในสตริง,
ดำน้ำลึกดังต่อไปนี้
ในตัวอย่างนี้ให้ฉันไป ไปข้างหน้าและเรียก argv2.c นี้
และในตัวอย่างนี้ให้ฉันไปข้างหน้า และทำ following-- สำหรับ int ฉันได้รับ 0,
ฉันมีค่าน้อยกว่า argc ผมบวก บวกเหมือนเมื่อก่อน
ดังนั้นใน words-- อื่น ๆ และตอนนี้ จะได้รับความซับซ้อนพอ
แล้วฉันจะบอกว่า ย้ำกว่าสตริงใน argv,
เป็นความคิดเห็นกับตัวเอง
แล้วฉันจะมี สำหรับวงซ้อนกันซึ่งคุณอาจ
ได้กระทำหรือการพิจารณา ทำในรอยขีดข่วนที่
ฉันจะบอกว่าฉัน int-- ไม่ได้ไปใช้ผมอีกครั้ง
เพราะผมไม่ต้องการที่จะเงาหรือ การเรียงลำดับของการเขียนทับที่ผมมีอยู่
>> ฉันจะแทนที่จะพูด J เพราะ ที่ไปของฉันให้กับตัวแปรหลังจากที่ฉัน,
เมื่อฉันแค่พยายามที่จะ นับตัวเลขที่เรียบง่าย
เจได้รับ 0-- และยัง N, เป็นไปได้ ได้รับความยาวท้าย argv วงเล็บผม
ตราบใดที่ J น้อยกว่าเมตร J บวกบวกทำต่อไปนี้
และนี่คือส่วนที่น่าสนใจ
>> พิมพ์ออกมาเป็นตัวอักษรและสายใหม่ เสียบในว​​งเล็บ argv I, J วงเล็บ
ตกลงเพื่อให้ฉันเพิ่มความคิดเห็นบางอย่างที่นี่
ย้ำผ่านตัวอักษร ในสตริงปัจจุบัน
ตัวอักษรพิมพ์ที่ j ในสตริง I-TH
ดังนั้นตอนนี้ขอพิจารณา สิ่งเหล่านี้หมายถึงการแสดงความคิดเห็น
>> ย้ำกว่าสตริง ใน argv-- หลายวิธี
สตริงอยู่ใน argv ซึ่งเป็นอาร์เรย์?
argc จำนวนมากดังนั้นฉันทำซ้ำ จาก i เท่ากับ 0 ถึง argc
ในขณะที่จำนวนตัวอักษร อยู่ในสตริง I-TH ใน argv?
>> ดีจะได้คำตอบว่า ฉันเพียงแค่เรียกความยาวสาย
ในการดูแลผมในปัจจุบันสตริง เกี่ยวกับซึ​​่งเป็นวงเล็บ argv ฉัน
และฉันจะเก็บชั่วคราวที่ ค่าใน N, เพียงเพื่อแคช
จะจำมันได้อย่างมีประสิทธิภาพ
แล้วฉันจะเริ่มต้น J 0 ให้ไปตราบ J น้อยกว่า N,
และในแต่ละซ้ำเพิ่ม J
>> และจากนั้นในที่นี่ต่อ ความคิดเห็นของฉันในบรรทัดที่ 12
พิมพ์ตัวอักษร ตามมาด้วยการขึ้นบรรทัดใหม่,
วงเล็บ argv เฉพาะ ฉันให้ฉันสตริง I-TH
ใน argv-- ดังนั้นคำแรกที่ คำสองคำที่สามสิ่ง
แล้วดำน้ำใน J ลึกและได้รับ ฉันเป็นตัวละครที่ j ของคำว่า
และเพื่อให้มีผลบังคับใช้คุณสามารถรักษา argv เป็นหลายมิติ
เป็นสองมิติอาร์เรย์ โดยทุกชนิดทุกคำของรูปลักษณ์
เช่นนี้ในใจของคุณ ตาและตัวละครทุกตัว
ประกอบด้วยชนิดของใน คอลัมน์ว่าจะช่วย
>> ในความเป็นจริงเมื่อเราหยอกล้อ นี้ออกจากกันในสัปดาห์ที่ผ่านมาในอนาคต
มันจะเป็นเพียงเล็กน้อย ที่มีความซับซ้อนมากขึ้นกว่าที่
แต่คุณสามารถจริงๆ คิดว่าตอนนี้
เป็นเพียงแค่นี้สองมิติ อาร์เรย์โดยหนึ่งระดับของมัน
คือทั้งหมดของสตริง
แล้วถ้าคุณดำน้ำในลึกคุณ จะได้รับตัวละครแต่ละคน
นั้นโดยใช้สัญกรณ์นี้ได้ที่นี่
>> ดังนั้นสิ่งที่เป็นผลกระทบสุทธิ?
ให้ฉันไปข้างหน้าและ ทำให้ยี้ argv2-- มัน
ฉันทำผิดพลาดที่นี่
ประกาศโดยปริยาย ห้องสมุดสเตอร์ลิงฟังก์ชั่น
ดังนั้นเวลานี้มันเป็น บางทีอาจจะเหมาะสม
ที่เรากำลังจัดเรียงของการตกแต่ง ตรงที่เราเริ่มต้น
>> ฉันเมาขึ้นโดยปริยายประกาศ ห้องสมุดสเตอร์ลิงฟังก์ชั่น
ตกลงรอสักครู่
ผมจำได้ว่าโดยเฉพาะอย่างยิ่ง เพราะมันเป็นสิทธิที่นี่
ฉันต้องการที่จะรวมในสตริง รุ่นของโปรแกรมนี้
>> ให้ฉันไปข้างหน้าและรวมถึง สตริงบันทึกที่ไปข้างหน้า
และคอมไพล์ argv2
และตอนนี้ที่นี่เราไปให้ argv2 ใส่
และแม้ว่ามันจะเป็นเพียงเล็กน้อย คลุมเครืออย่างรวดเร็วก่อน
แจ้งให้ทราบว่าแน่นอนสิ่งที่ จะมีการพิมพ์เป็นจุด argv2
>> แต่ถ้าผมพิมพ์คำบางคำหลัง พรอมต์เช่น argv2 Zamyla จัน
ใส่ยังเล็ก ๆ น้อย ๆ คลุมเครืออย่างรวดเร็วก่อน
แต่ถ้าเราเลื่อนกลับขึ้น ./argv2 Z-A-M-Y-L-C-H-A-N
ดังนั้นเราจึงได้ซ้ำมากกว่าทุกคำ
และในทางกลับกันเราได้ซ้ำมากกว่า ตัวละครทุกตัวที่อยู่ในคำ
>> ตอนนี้หลังจากที่ทั้งหมดนี้ ตระหนักดีว่ามี
หนึ่งในรายละเอียดอื่น ๆ ที่เราได้รับชนิด ไม่สนใจตลอดเวลานี้
เราเพียงแค่แกล้งนอกเหนือสิ่งที่ ปัจจัยการผลิตหลักสามารถ?
สิ่งที่เกี่ยวกับการส่งออกหลักของ?
>> ทั้งหมดเวลานี้เราได้รับ เพียงคัดลอกและวาง
int ตัวคำในด้านหน้าของหลัก แม้ว่าคุณอาจจะเห็นออนไลน์
บางครั้งไม่ถูกต้องในรุ่นเก่า ตัว C และตัวคอมไพเลอร์ที่พวกเขากล่าวว่าเป็นโมฆะ
หรืออะไรเลย
แต่ที่จริงแล้วสำหรับรุ่น ของซีที่เรากำลังใช้อยู่
C 11 หรือ 2011 ตระหนักถึง ที่มันควรจะเป็น int
และมันทั้งที่ควรจะเป็น เป็นโมฆะหรือ argc และ argv ที่นี่
>> แต่ทำไม int main?
มันคืออะไรจริงกลับมา?
ดีก็จะเปิดออกทั้งหมดของเวลานี้ เวลาที่คุณได้เขียนโปรแกรมหลัก
อยู่เสมอบางสิ่งบางอย่างกลับมา
แต่จะได้รับการทำเช่นนั้นแอบ
>> สิ่งที่เป็น int เป็นสาย 5 แสดงให้เห็น
แต่สิ่งที่ int?
ดีมีนี้ การประชุมในการเขียนโปรแกรม
ด้วยเหตุนี้ถ้าไม่มีอะไรมี ผิดไปและทั้งหมดเป็นอย่างดี
โปรแกรมและฟังก์ชั่นทั่วไป return-- ค่อนข้าง counterintuitively--
0
0 โดยทั่วไปหมายถึงทั้งหมดเป็นอย่างดี
ดังนั้นแม้ว่าคุณคิดว่าการ ว่ามันเป็นเท็จในบริบทที่หลาย ๆ
มันจริงโดยทั่วไปหมายถึงเป็นสิ่งที่ดี
>> ในขณะเดียวกันถ้าโปรแกรมผลตอบแทนที่ 1 หรือติดลบ 1 หรือ 5 หรือเชิงลบ 42,
หรือใด ๆ ที่ไม่ใช่ 0 ค่า ซึ่งโดยทั่วไปหมายถึง
สิ่งที่ได้ไปผิด
ในความเป็นจริงบน Mac ของคุณเองหรือพีซี คุณอาจได้เห็นจริง
ข้อผิดพลาดโดยมัน พูดอะไรบางอย่างหรืออื่น ๆ ที่มีข้อผิดพลาด
รหัสเชิงลบ 42 หรือรหัสข้อผิดพลาด 23 หรือสิ่งที่ต้องการ
ตัวเลขที่โดยทั่วไปเพียงคำใบ้ โปรแกรมเมอร์หรือ บริษัท
ที่ทำให้ซอฟแวร์ สิ่งที่ผิดพลาดและทำไม
เพื่อให้พวกเขาสามารถมองผ่าน เอกสารหรือรหัสของพวกเขา
และคิดออกว่า ข้อผิดพลาดจริงหมายถึง
จึงมักไม่ ประโยชน์กับเราผู้ใช้ปลายทาง
>> แต่เมื่อผลตอบแทนหลัก 0 ทั้งหมดเป็นอย่างดี
และถ้าคุณไม่ได้ระบุ สิ่งหลักควรกลับ
มันจะเป็นเพียงแค่โดยอัตโนมัติ กลับ 0 สำหรับคุณ
แต่บางสิ่งบางอย่างกลับมา อื่นจะเป็นประโยชน์จริง
>> ในโปรแกรมสุดท้ายนี้ให้ฉัน ไปข้างหน้าและเรียก exit.c นี้
และแนะนำสุดท้ายของวันนี้ หัวข้อที่รู้จักกันเป็นรหัสข้อผิดพลาด
ให้ฉันไปข้างหน้าและรวมของเรา ไฟล์ที่คุ้นเคยขึ้นด้านบนทำ int main
และในครั้งนี้เราจะมาทำ argc int, สตริง argv และมีวงเล็บของฉัน
ที่จะบ่งบอกว่ามันเป็นในอาร์เรย์
แล้วให้ฉันเพียงแค่จะตรวจสอบสุขภาพจิตดี
เวลานี้ถ้า argc ไม่ เท่ากับ 2 แล้วคุณรู้อะไรไหม
ลืมมันไปเถอะ
ผมกำลังจะบอกว่าเดี๋ยวก่อนผู้ใช้ คุณจะหายไปอาร์กิวเมนต์บรรทัดคำสั่ง
ทับขวา n
>> แล้วที่มัน
ฉันต้องการที่จะออกจาก
ฉันจะไป preemptively, และก่อนเวลาอันควรจริงๆกลับมา
สิ่งอื่นที่ไม่ใช่หมายเลข 1
ไปที่คุ้มค่าสำหรับครั้งแรก ข้อผิดพลาดที่อาจเกิดขึ้นได้คือ 1
ถ้าคุณมีบางอย่างผิดพลาดอื่น ๆ สถานการณ์ที่อาจเกิดขึ้น
คุณอาจจะบอกว่าผลตอบแทนที่ 2 หรือ 3 กลับมาหรือ แม้กระทั่งในเชิงลบหรือเชิงลบ 1 2
>> เหล่านี้เป็นเพียงรหัสออก ที่มีทั่วไป
เพียง แต่มีประโยชน์ในการเขียนโปรแกรมหรือ บริษัท ที่จัดส่งซอฟแวร์
แต่ความจริงที่ว่ามันเป็น ไม่ 0 เป็นสิ่งที่สำคัญ
ดังนั้นหากในโปรแกรมนี้ผมต้องการที่จะ รับประกันได้ว่าโปรแกรมนี้เท่านั้น
ทำงานหากผู้ใช้ให้ฉัน ด้วยการนับโต้แย้งของทั้งสอง
ชื่อของโปรแกรมและอื่น ๆ คำว่าฉันสามารถบังคับใช้มากที่สุดเท่าที่ดังต่อไปนี้
เสียงโห่ร้องที่ผู้ใช้ที่มีคำกล่าวที่ว่า printf, อาร์กิวเมนต์บรรทัดคำสั่งที่ขาดหายไป
กลับ 1
ที่จะเป็นเพียงแค่การได้ทันที ออกจากโปรแกรม
>> เฉพาะในกรณีที่ argc เท่ากับ 2 เราจะได้รับการลง ที่นี่จุดที่ผมจะพูดว่า
สวัสดีร้อยละ S, ทับขวา N, argv1
ในคำอื่น ๆ ฉัน ไม่ได้ไปหลังจาก argv 0,
ซึ่งเป็นเพียงแค่ชื่อของโปรแกรม
ฉันต้องการที่จะพิมพ์ออกมาสวัสดีจุลภาค คำที่สองที่มนุษย์พิมพ์
และในกรณีนี้ บรรทัดที่ 13 ทั้งหมดเป็นอย่างดี
>> ฉันรู้ว่า argc คือ 2 เหตุผลจากโปรแกรมนี้
ฉันจะไปข้างหน้าและย้อนกลับ 0
เช่นกันเก็บไว้ในใจว่า นี้เป็นจริงในรอยขีดข่วนได้เป็นอย่างดี
>> เหตุผลที่ฉันจะทำเช่นนี้ และห่อหุ้มเส้นเหล่านี้
ของรหัสในข้ออื่น ๆ ได้ที่นี่
แต่นั่นคือการเรียงลำดับของ โดยไม่จำเป็นเยื้องรหัสของฉัน
และฉันต้องการที่จะทำให้สุด เห็นได้ชัดว่าไม่ว่าอะไรจะเกิดขึ้น
โดยค่าเริ่มต้นทักทาย สิ่งที่จะได้รับการพิมพ์,
ตราบใดที่ผู้ใช้ให้ความร่วมมือ
>> ดังนั้นจึงเป็นเรื่องธรรมดามากที่จะใช้ เงื่อนไขเพียงถ้า
ที่จะจับความผิดพลาดบางอย่าง สถานการณ์แล้วออกจาก
แล้วตราบทั้งหมด ดีไม่ได้มีอะไร
แต่เพียงแค่มีรหัส นอกว่าถ้าเพราะมัน
เทียบเท่าในครั้งนี้ โดยเฉพาะอย่างยิ่งกรณีที่มีเหตุผล
ดังนั้นฉันกลับ 0, เพียงเพื่อ มีความหมายอย่างชัดเจนทั้งหมดเป็นอย่างดี
>> ถ้าผมละเว้นผลตอบแทน 0, มันจะ สันนิษฐานได้โดยอัตโนมัติสำหรับฉัน
แต่ตอนนี้ที่ฉันกลับมา หนึ่งในอย่างน้อยกรณีนี้
ฉันจะไป, การวัดที่ดีและ ความชัดเจนผลตอบแทน 0 ในกรณีนี้
ดังนั้นตอนนี้ให้ฉันไปข้างหน้าและให้ออก ซึ่งเป็นที่สมบูรณ์แบบเพื่อทำต่อเพียงแค่ปล่อยให้
>> แต่ให้ออกและปล่อยให้ฉันไป ข้างหน้าและทำ ./exit ใส่
และโปรแกรมที่ตะโกนใส่ฉัน อาร์กิวเมนต์บรรทัดคำสั่งที่ขาดหายไป
ตกลงให้ฉันให้ความร่วมมือ
>> ขอให้ฉันแทนทำ ./exit เดวิดใส่
และตอนนี้ก็พูดว่าสวัสดีเดวิด
และคุณจะไม่ปกติเห็นนี้
>> แต่ปรากฎว่ามี วิธีพิเศษในลินุกซ์ที่จะเห็นจริง
กับสิ่งที่รหัสออกจากโปรแกรมออก
บางครั้งในแบบกราฟิก โลกเช่น Mac OS หรือ Windows,
คุณจะเห็นตัวเลขเหล่านี้เมื่อมีการ ข้อผิดพลาดปรากฏขึ้นบนหน้าจอ
และโปรแกรมเมอร์ แสดงให้คุณเห็นตัวเลขที่
แต่ถ้าเราต้องการที่จะเห็นสิ่งที่เกิดข้อผิดพลาด ข้อความคือเราสามารถทำมันได้ here--
./exit ดังนั้นใส่พิมพ์ อาร์กิวเมนต์บรรทัดคำสั่งที่ขาดหายไป
>> ถ้าตอนนี้ฉันทำ echo $ ?, ซึ่งเป็น ขัน​​มองคลุมเครือ
แต่ $?
เป็นคาถาที่มีมนต์ขลัง ที่บอกว่าเดี๋ยวก่อนคอมพิวเตอร์
บอกฉันว่าก่อนหน้านี้ รหัสออกจากโปรแกรมเป็น
และฉันกด Enter
ฉันเห็น 1 เพราะนั่นคือสิ่งที่ฉัน บอกว่าฟังก์ชั่นหลักของฉันจะกลับมา
>> ในขณะเดียวกันถ้าฉันทำ ./exit ดาวิด และกด Enter ผมเห็นสวัสดีเดวิด
และถ้าตอนนี้ผมทำ $ Echo ?, ฉันเห็นสวัสดี 0
และอื่น ๆ นี้จะจริง จะเป็นข้อมูลที่มีคุณค่า
ในบริบทของการดีบักที่ไม่ได้ดังนั้น มากที่คุณมนุษย์ที่จะดูแล
แต่การดีบักเกอร์และอื่น ๆ โปรแกรมเราจะใช้ภาคการศึกษานี้
มักจะดูที่จำนวนที่ แม้ว่ามันจะซ่อนการจัดเรียงของออกไป
เว้นแต่คุณจะมองหามันเพื่อ กำหนดหรือไม่โปรแกรมของ
การดำเนินการถูกต้องหรือไม่ถูกต้อง
>> และเพื่อที่จะนำเราไป นี้ในตอนท้ายของวัน
เราเริ่มต้นในวันนี้โดยมองไปที่ แก้จุดบกพร่องและในทางกลับที่แน่นอน
ตัวเองแล้วน่าสนใจมากขึ้น ในทางเทคนิคที่อยู่ใต้ฝากระโปรง
สิ่งที่สตริงซึ่งมีอายุ สัปดาห์เราก็เอาให้ได้รับ,
และแน่นอนเอาพวกเขา สำหรับการรับในรอยขีดข่วน
>> จากนั้นเราจะมองไปที่วิธีการที่เราสามารถเข้าถึง ตัวละครแต่ละตัวในสตริง
และจากนั้นอีกครั้งเอาระดับที่สูงขึ้น ดูสิ่งที่มองหาวิธี well--
ถ้าเราต้องการที่จะได้รับของแต่ละบุคคล องค์ประกอบในรายการเช่นโครงสร้าง
เราไม่สามารถทำเช่นนั้นกับสตริงหลาย
และเราสามารถมีข้อโต้แย้งบรรทัดคำสั่ง
แต่ภาพนี้ที่นี่เพียงกล่อง เป็นชี้ของความคิดทั่วไปนี้
ของอาร์เรย์หรือรายการหรือเวกเตอร์
และขึ้นอยู่กับ บริบททั้งหมดของคำเหล่านี้
หมายถึงสิ่งที่แตกต่างกันเล็กน้อย
ดังนั้นใน C เราเพียงจะ พูดคุยเกี่ยวกับอาร์เรย์
และอาร์เรย์เป็นก้อน ของหน่วยความจำแต่ละคนเป็น
องค์ประกอบที่ต่อเนื่องกันกลับ ไปกลับไปกลับไปด้านหลัง
>> และองค์ประกอบเหล่านั้นโดยทั่วไป ประเภทข้อมูลเดียวกันตัวละคร
ตัวละครตัวละครตัวละครหรือ สตริงสตริงสตริงสตริงหรือ int,
int, int สิ่งที่เป็น เรากำลังพยายามที่จะเก็บ
แต่ในตอนท้ายของวันนี้เป็น สิ่งที่ดูเหมือนว่าแนวคิด
คุณกำลังการของคุณ หน่วยความจำของคอมพิวเตอร์หรือ RAM
และคุณแกะสลักมันออกไป กล่องขนาดเหมือนกันซึ่งทั้งหมดนี้
จะกลับไปกลับไป กลับไปด้านหลังในลักษณะนี้
>> และสิ่งที่ดีเกี่ยวกับ ความคิดนี้และความจริงที่
ที่เราสามารถแสดงค่าในลักษณะนี้ กับครั้งแรกของโครงสร้างข้อมูลของเรา
ในชั้นเรียน, หมายความว่าเราสามารถเริ่มต้น ในการแก้ปัญหาด้วยรหัส
ที่มาเพื่อให้สังหรณ์ใจในสัปดาห์ 0
คุณจะจำโทรศัพท์ ตัวอย่างหนังสือที่
ที่เราใช้ในการแบ่งและพิชิต หรือการค้นหาแบบทวิภาค,
ที่จะลอดผ่านทั้งหมด พวงของชื่อและหมายเลข
แต่เราสันนิษฐานว่าจำว่า สมุดโทรศัพท์ถูกเรียงไว้แล้ว
ว่าคนอื่นได้แล้ว คิดได้รับ out-- รายชื่อ
และเบอร์วิธีการเรียงตามลำดับอักษร
และตอนนี้ที่ใน C เรา ก็มีความสามารถในการ
ที่จะวางสิ่งที่ออกไม่ได้ ร่างกายอยู่ในสมุดโทรศัพท์
แต่ความจริงในคอมพิวเตอร์ หน่วยความจำที่เราจะสามารถที่สัปดาห์ถัดไป
ที่จะแนะนำอีกครั้ง this-- แรก ของโครงสร้างข้อมูลของเราใน array--
แต่ที่สำคัญกว่าคอมพิวเตอร์ที่เกิดขึ้นจริง ขั้นตอนวิธีการดำเนินการทางวิทยาศาสตร์
ในรหัสที่เราสามารถจัดเก็บ ข้อมูลในโครงสร้างเช่นนี้
และจากนั้นเริ่มที่จะจัดการกับมันและ ที่จริงการแก้ปัญหากับมัน
และเพื่อสร้างด้านบนของที่ ในที่สุดโปรแกรมใน C,
ในหลามใน JavaScript, สอบถามฐานข้อมูลกับ SQL?
>> และเราจะเห็นว่าสิ่งเหล่านี้ ความคิดที่แตกต่างกันลูกโซ่
แต่ตอนนี้จำได้ว่า โดเมนที่เราได้นำเสนอในวันนี้
เป็นสิ่งนี้ที่นี่และ โลกของการเข้ารหัส
และในหมู่ปัญหาต่อไปที่คุณด้วยตัวคุณเอง จะแก้เป็นศิลปะของการเข้ารหัส,
scrambling และ de-หนี ข้อมูลและการเข้ารหัส
และถอดรหัสข้อความ และสมมติว่าในท้ายที่สุด
ว่าตอนนี้คุณรู้ว่าสิ่งที่ อยู่ภายใต้ฝากระโปรง
เพื่อที่ว่าเมื่อคุณเห็นหรือรับ ข้อความเช่นนี้คุณ
ตัวเองสามารถถอดรหัสมัน
ทั้งหมดนี้และครั้งต่อไปมากขึ้น
>> [เล่นวีดีโอ]
>> -Mover เพิ่งมาถึง
ฉันจะไปเยี่ยมชม อาจารย์ที่วิทยาลัยของเขา
อ๋อ
สวัสดี
เป็นคุณนั้นเอง.
รอ!
เดวิด
ฉันแค่พยายามที่จะคิด สิ่งที่เกิดขึ้นกับคุณ
โปรดอะไรจะช่วยให้
คุณอยู่ที่วิทยาลัยของเขา เพื่อนร่วมห้องก็ไม่ได้คุณ?
คุณอยู่ที่นั่นกับเขาเมื่อ เขาเสร็จสิ้นโครงการ CS50 หรือไม่
>> [เสียงเพลง]
>> ใช่หรือไม่เพราะเป็น CS50
>> ฉันรักที่นี่.
>> -Eat ขึ้น
เรากำลังจะออกจากธุรกิจ
>> [จบ PLAYBACK]