สวัสดีและยินดีต้อนรับกลับ
บรรยายนี้อยากไป ผ่านการสาธิตการแก้ปัญหาของความท้าทายครั้งก่อนของเราซึ่ง
คือการสร้างฟังก์ชันบางอย่าง ส่วนใหญ่เป็นฟังก์ชัน
GCD และ a ฟังก์ชันคู่ ฟังก์ชันค่าสัมบูรณ์ และฟังก์ชันรากที่สอง
ฉันจะสร้างโครงการและ ฉันอาจจะแค่ตั้งชื่อฟังก์ชั่นของโปรเจ็กต์
ฉันจะไป เพื่อปิดโครงการที่มีอยู่ของฉันที่นี่
กำลังจะเป็นอีกคน แอปพลิเคชันคอนโซล
เราไม่ได้จริงๆ ลงในไลบรารี่หรือการเขียนโปรแกรมกราฟิกชนิดใดก็ได้
มันก็จะประมาณนี้ เกี่ยวกับฟังก์ชันบางอย่างเท่านั้น
โดยปกติคุณต้องการมี มีชื่อที่ดี แต่นี่เป็นเพียงเพื่อการเรียนรู้
เราก็เลยเฉยๆ ให้ฟังก์ชันทั่วไป
ถ้าเป็นโปรแกรม GCD ฉันจะ เขียนตัวหารร่วมมาก.
แต่สิ่งแรกที่เราจะทำ คือเราจะนำโปรแกรมตัวหารร่วมมากสุดของเราไปใช้
นี่จะเป็นฟังก์ชันที่ หาตัวหารร่วมมากระหว่างจำนวนเต็มที่ไม่เป็นลบสองตัว
ค่าแล้วส่งกลับผลลัพธ์
เราควรจัดให้มีฟังก์ชั่น ต้นแบบอีกด้วยเพื่อให้เราสามารถเรียกมันและเราสามารถวาง
ได้ทุกที่ในฟังก์ชัน
มาทำกัน
สำหรับฟังก์ชันแรก นี่ เป็นการประกาศฟังก์ชัน
ทำไมเราถึงสร้างฟังก์ชั่น ประกาศเพื่อให้เราสามารถเรียกใช้ได้ทุกที่ในโปรแกรม
เราไม่จำเป็นต้องจริงๆ ใช้ฟังก์ชันนี้เหนือฟังก์ชันหลักเมื่อเราเรียกใช้
และเป็นเพียงแนวปฏิบัติที่ดีคือ ง่ายมากที่จะเห็นสิ่งที่เกิดขึ้นในโปรแกรมที่มีทั้งหมด
ประกาศฟังก์ชันที่ด้านบน
นี่จะคืนค่า int
ดังนั้น จำไว้ว่า ส่วนหัวของฟังก์ชันเป็นอันดับแรก สิ่งที่คุณทำคือคุณระบุประเภทของข้อมูลที่จะส่งคืน
GCD กำลังจะส่งคืน int
มันจะขึ้นชื่อว่า ฟังก์ชันที่เป็น GCD
แล้วในวงเล็บคือ ข้อมูลที่ถูกส่งไปยัง GCD
และนี่กำลังจะไป จะยังเป็น int.
เราจะส่งข้อมูลสองรายการ
ดังนั้นเราจึงคั่นด้วยเครื่องหมายจุลภาค
เราระบุประเภทข้อมูลสำหรับ แต่ละตัวและชื่อตัวแปร
ผมแค่จะบอกว่าเป็น u กับ v
แล้วผมมีอัฒภาคถึง สิ้นสุดคำจำกัดความของฟังก์ชัน
ตอนนี้ฉันสามารถกำหนดฟังก์ชันของฉันได้ด้านล่าง ตัวหลักและฉันยังสามารถเรียกใช้ได้และไม่มีปัญหาใด
ๆ
ดังนั้นเมื่อคุณต้องการจริงๆ กำหนดฟังก์ชัน
ใช้งาน คุณทำหน้าที่เดียวกัน ส่วนหัว int ค่าส่งคืน GCD
มันต้องคู่กับ ประกาศในแง่ของประเภท
เรียกอย่างอื่นก็ได้ เช่น int x สำหรับชื่อ แต่เราจะสอดคล้องกัน
เราจะบอกว่า int v
เรารู้ว่ามันคือหน้าที่ ความหมายเพราะมีวงเล็บที่กำหนดเนื้อความ
นี่คือรหัสการใช้งาน
อัลกอริทึมที่แท้จริงสำหรับ GCD ค่อนข้างง่าย
สิ่งที่คุณต้องทำคือเขียนลูป และผ่านลูปและดูค่า
temp ตามเศษที่เหลือ
ดังนั้นฉันจะสร้างท้องถิ่น ตัวแปรภายในฟังก์ชัน GCD ของฉัน
เราจะรู้ได้อย่างไรว่าเป็นท้องถิ่นเพราะ อยู่ในวงเล็บสำหรับ 12 ถึง 14
ตัวแปรนี้ไม่สามารถเข้าถึงได้ ภายในฟังก์ชั่นหลัก
เฉพาะในบล็อกนี้เท่านั้น
นี่ฉันกำลังจะไป โทร temp เนื่องจากเป็นแบบท้องถิ่น
ตอนนี้ฉันกำลังจะสร้างลูปของฉันด้วย
ฉันจะใช้ลูป while
และวง while ของฉันกำลังจะไป จนถึง v, ซึ่งจะเป็นตัวหารร่วมมากสุดของเรา
จำไว้ สามัญที่สุด ตัวหารใช้สองพารามิเตอร์
มันจะใช้พารามิเตอร์
และจากพารามิเตอร์ทั้งสองนั้น มันมีอัลกอริธึมที่จะสร้างเพื่อหาตัวหารร่วมมาก
ดังนั้นหากเรากำลังพยายามค้นหา ตัวหาร
เราต้องแน่ใจว่า v ไม่เท่ากับ ศูนย์ พารามิเตอร์ที่สองของเรา
นี่แค่มาตรฐาน ส่วนของอัลกอริทึม
ในขณะที่ v ไม่เท่ากัน ถึงศูนย์ เราจะใส่วงเล็บสำหรับลูป
สิ่งที่เราจะทำคือเรา อันดับแรกจะกำหนดค่า
temp ให้กับค่าโมดูลของ u mod v
จากนั้นเราจะตั้งค่า u เท่ากับ v และเราจะตั้ง
v เท่ากับ temp
แล้วเราก็อยากกลับ ข้อมูลจากฟังก์ชันนี้
แล้วเราจะคืนค่าข้อมูลจาก . ได้อย่างไร ฟังก์ชั่น? เราใช้คีย์เวิร์ด return
และเราก็แค่ส่งคืน ข้อมูลที่เราต้องการส่งคืน
ในกรณีนี้ เราต้องการส่งคืนคุณ
ตอนนี้จำไว้ว่าถ้าฟังก์ชั่นนี้ ไม่ส่งคืนข้อมูลใด ๆ เราจะต้องเปลี่ยนประเภทเป็นโมฆะ
แล้วเราก็ทำได้เพียง มีผลตอบแทนที่ไม่มีข้อมูล
แต่นี่คือการส่งคืนข้อมูล
เลยต้องคู่กัน
และนี่คือเราจะ บอกว่ากลับมาอีกครั้ง u
ถ้าเราไม่ส่งข้อมูล ฟังก์ชันนี้ เราสามารถใส่ค่าเป็นโมฆะเป็นพารามิเตอร์
หรือเราทำได้ เว้นว่างไว้และนั่นก็บอกว่าฟังก์ชันไม่รับข้อมูล
แต่เรากำลังส่งผ่านสองตัวแปร
และตัวแปรเหล่านี้ u และ v คือ ตัวแปรท้องถิ่นของฟังก์ชัน GCD
เราสามารถใช้พวกมันในฟังก์ชันได้
และนั่นคือสิ่งที่เราทำ
ทั้งหมดนี้เป็นลักษณะเฉพาะของฟังก์ชัน
ค่าที่ส่งคืน ข้อมูลที่ คุณกำลังส่งผ่านโดยใช้ตัวแปรในเครื่องแล้วส่งคืนข้อมูล
สิ่งเหล่านั้นทั้งหมดให้ความสนใจใน ไวยากรณ์ที่มีวงเล็บแล้วตามด้วยการประกาศที่ด้านบน
ตอนนี้เราต้องการที่จะพยายามที่จะ ทดสอบฟังก์ชันนี้
เราจึงอยากทดสอบมันทั้งหมด สิ่งต่าง ๆ
ไปข้างหน้าและจำไว้ว่าสิ่งนี้ ฟังก์ชั่นส่งคืนข้อมูลดังนั้นเราอาจต้องการสร้างตัวแปรท้องถิ่นใน
หลักของเรา เราจะเรียกมันว่าผลลัพธ์
เราสามารถเริ่มต้นให้เป็นศูนย์ได้
แล้วเราก็อยากจะ โดยทั่วไปเรียกใช้ฟังก์ชัน
เราจะเรียกใช้ฟังก์ชันได้อย่างไร
เราเพียงแค่ระบุฟังก์ชั่น ชื่อตามด้วยข้อมูลที่ส่งไป
เนื่องจากฟังก์ชันนี้ส่งคืน data ฉันจะบอกว่าผลลัพธ์เท่ากับแล้วชื่อฟังก์ชัน
ชื่อฟังก์ชันคือ GCD
และฉันจะผ่านมันไปให้ได้ 150 สำหรับการทดสอบครั้งแรกของฉันและ 35
ฉันจะทำแบบทดสอบอีกสองแบบ แค่ส่งเลขต่างกันแต่ที่อยากทำคือ
เพื่อพิมพ์ข้อมูลที่ส่งคืนผลลัพธ์
ดังนั้นฉันจะพูดว่า printf และฉัน จะบอกว่า GCD ของ 150 และ 35 เป็นเปอร์เซ็นต์การป้อนบรรทัดแล้วผลลัพธ์
ถูกต้อง. ดังนั้นบรรทัดที่ 10 จึงมีความสำคัญ
เราได้รับข้อมูลคืนจาก GCD ดังนั้น เรากำลังกำหนดให้กับตัวแปร
และเราสามารถเรียกฟังก์ชันว่าผ่าน ในค่าคงที่สองค่าตรงนี้ 150 และ 35
เรายังสามารถส่งผ่านตัวแปรได้อีกด้วย
วิธีที่เราเรียกใช้ฟังก์ชัน โดยข้อมูลที่ส่งไปอยู่ในวงเล็บเราใส่ค่า
คั่นด้วยเครื่องหมายจุลภาค แล้วเครื่องหมายอัฒภาคอยู่ที่ส่วนท้าย
ฉันต้องการทำแบบทดสอบหลายแบบ
ผมจะคัดลอกบรรทัดที่ 10 และ 11 แล้วใส่ข้อมูลอื่นๆ ลงไป
ฉันจะใส่ 1026 และ 405 แล้วก็ 83 ด้วย
และสิ่งที่เราทำได้คือ แทนที่จะคืนค่าตัวแปร เราสามารถใส่มันแทนค่า
เรียกใช้ฟังก์ชันภายใน printf แล้วพิมพ์ออกมาตรงนั้น
เราไม่ต้องบันทึกด้วยซ้ำ
เราก็บอกว่า GCD 83, 240 ได้
เราจะต้องเปลี่ยนอะไร
เรากำลังพิมพ์ออกมาในแง่ของค่าฮาร์ดโค้ดที่นี่, พูด 1026, 405 แล้วก็ 240 และ 83 ด้วย
มาลองเรียบเรียงกันเลยดีกว่า
มาทำให้แน่ใจว่าเราได้รับ ไม่มีข้อผิดพลาดหรือคำเตือน
เราไม่มีข้อผิดพลาดและคำเตือน
มาเริ่มกันเลย
เมื่อเราเรียกใช้เราควรเห็น ตัวหารร่วมมากสุดสามครั้งสำหรับจำนวนหนึ่ง
ดังนั้นเราจึงเห็น GCD ของ 150 และ 35 คือ 5
GCD ของ 1026 และ 405 คือ 27
และ GCD ของ 83 และ 240 คือ 1
ตัวหารร่วมที่ยิ่งใหญ่ที่สุดหมายถึง ตัวประกอบที่หารเลขสองตัวนั้น
ตัวประกอบสูงสุดคืออะไร
5 ไปหาร 35, และ 5 ไปหาร 150.
และนั่นคือสิ่งที่สูงที่สุด
27 ไปหาร 405 กับ 1026 ด้วย นั่นคือ สูงสุดระหว่างทั้งสอง
ดูเหมือนว่าจะใช้งานได้
และเราครอบคลุมพื้นฐานของ ส่งข้อมูลและส่งคืนข้อมูล
ตอนนี้เราอยากฝึกคู่ อย่างอื่นในแง่ของอัลกอริธึมและการแก้ปัญหา
มาสร้างฟังก์ชันอื่นกันเถอะ เรียกว่าค่าสัมบูรณ์
ฟังก์ชันค่าสัมบูรณ์กำลังดำเนินอยู่ เพื่อคืนทุ่นและลอย
มันจะเป็นเ ฟังก์ชั่นที่ง่ายมาก
ดังนั้นเราจะประกาศ ฟังก์ชั่นขึ้นในบรรทัดที่ห้า
เราจะว่าลอยแน่นอน ค่า นั่นคือชื่อตามด้วยพารามิเตอร์ และเราก็แค่
จะบอกว่า float x แล้วเราจะจบอัฒภาค
สังเกตฟังก์ชั่นอีกครั้ง ประกาศ, ค่าส่งคืน, พารามิเตอร์ที่ระบุด้วยประเภทข้อมูล
แล้วชื่อของฟังก์ชัน
จากนั้นเราสามารถไปข้างหน้าและกำหนด ฟังก์ชันนี้อยู่ใต้ฟังก์ชัน
GCD และมันจะง่ายมาก
เรากำหนดฟังก์ชันด้วย type ที่จะถูกส่งกลับ ชื่อแล้วพารามิเตอร์
เช่นเดียวกับ ประกาศยกเว้นว่าตอนนี้เรามีวงเล็บเพื่อเริ่มบล็อกของรหัส
มันง่ายเพราะทั้งหมดที่เราต้องทำ คือตรวจสอบพารามิเตอร์ที่ผ่านและตรวจสอบว่ามีค่าน้อยกว่าศูนย์หรือไม่
ถ้ามันน้อยกว่าศูนย์ งั้น เราจะกำหนดอินเวอร์สให้มันเป็นลบ
x
ดังนั้นหากเป็นค่าลบ มันจะคูณด้วยลบกลับเป็นบวก
และเราต้องการส่งคืนข้อมูลนั้น
เราจะบอกว่า return x
ตอนนี้สิ่งหนึ่งที่ฉันพูดถึงใน บรรยายที่ไม่ได้ยกตัวอย่างมาคืออะไร
หากคุณส่งคืนข้อมูลทั้งหมดโดยตลอด
เพราะเราอาจจะมีพวงของ คำสั่ง if และเราสามารถส่งคืนคำสั่ง if แต่ละรายการได้
และเพื่อให้ฟังก์ชันของคุณสามารถใน ทฤษฎี มีคำสั่งส่งคืนจำนวนมากหากอยู่ภายใน
ifs หรือ loops
แล้วคุณก็ทำได้ มีหนึ่งที่ด้านล่าง
ประเด็นคือ มันยากมากที่จะปฏิบัติตาม
หากคุณต้องการคืนที่แตกต่างกัน บางส่วนของรหัสของคุณ โดยพื้นฐานแล้ว เพียงแค่เก็บข้อมูลในตัวแปร
และส่งคืนที่ด้านล่าง
แต่นี่เป็นฟังก์ชันง่ายๆ
เราก็แค่คืนค่ากลับมา
ไปลองใช้กันดูนะคะ ฟังก์ชันนี้และมันดีจริงๆ ที่มันลอยได้เราจึงทำได้
ใช้กับจำนวนเต็มและทศนิยม
ดังนั้นฉันจะสร้าง ตัวแปรสองสามตัวที่นี่ที่เราจะผ่าน
และฉันก็จะไป เพื่อสร้างจำนวนเต็ม
ฉันจะทำอย่างนั้น ที่ด้านบนสุดของฉัน
ฉันกำลังจะสร้าง ลูกลอยสำหรับ F1 F2 F3
และผมจะสร้างจำนวนเต็ม I1
และฉันกำลังจะสร้างอีก ตัวแปรที่เก็บผลลัพธ์ไว้แต่ต้องเป็นค่าทศนิยม
ดังนั้นฉันจะต้องสร้าง
ตัวแปรอื่น และนี่เป็นเพียงการบอกผลลัพธ์ของค่าสัมบูรณ์
และผมจะเริ่มต้นให้เป็น 0
0.
ตอนนี้ฉันจะเรียกใช้ ฟังก์ชั่นและพิมพ์ผลลัพธ์
ดังนั้นฉันจะคัดลอกและ วางรหัสบางส่วนที่นี่
เรียกใช้ฟังก์ชันและจัดเก็บได้ ข้อมูลที่ส่งคืนหรือฉันสามารถส่งต่อไปยังฟังก์ชัน
printf ได้
ฉันอาจต้องการแสดงความคิดเห็นที่นี่เพื่อทดสอบฟังก์ชันค่าสัมบูรณ์
และเมื่อคุณใช้เครื่องหมายดอกจันบนตัวเดียว ไลน์มันเน้นๆหน่อย
ดังนั้นที่นี่ฉันจึงวางการโทรไปยังค่าสัมบูรณ์เท่านั้น ฟังก์ชันค่าแล้วแสดงผลบางอย่าง
ดังนั้นใน 24 นี้ฉันโทร ค่าสัมบูรณ์ด้วย f1
จำไว้ว่า F1 คือการลอยตัว
เท่ากับลบ 15 5.
ฉันจะจัดรูปแบบ ผลลัพธ์และพิมพ์ออกมา
แล้วฉันก็ กำลังจะพิมพ์ f1
เราจะมาดูกันว่า ผลลัพธ์การเปลี่ยนแปลงโดยการเรียกใช้ฟังก์ชันมากกว่าเดิม
เลยจะปริ้นออกมา ผลลัพธ์ของการเรียกใช้ฟังก์ชันแล้วค่าเดิม
สิ่งนี้จะบอกเราว่า มันเปลี่ยนไปเลย
ถ้าเดิมติดลบ และเปลี่ยนเป็นบวก
ทำสิ่งนั้นในหลาย ๆ ตัว บรรทัดสำหรับการทดสอบหลายรายการ
แล้วในบรรทัดที่ 37 เท่านั้น ความแตกต่างที่นี่คือแทนที่จะเก็บค่าไว้ในตัวแปร
เดี๋ยวจะพิมพ์ให้ครับ
เลยต้องเปลี่ยนผลลัพธ์ ที่นี่ไปยังตัวแปรที่ถูกต้อง
มาทำกันและ.
ข้างล่างนี้ฉันอยากจะทำอย่างนั้น
เมื่อตอนแรกฉันเขียน โปรแกรมฉันเขียนแยกกัน
หวังว่าฉันจะไม่ทำผิดพลาดที่นี่
และเปลี่ยนทุกอย่างที่ฉันต้องการ ที่จะเปลี่ยนและที่ควรจะทำ
อันอื่นไม่ใช่ พิมพ์ผลลัพธ์ของตัวแปรทั้งหมด
เฉพาะในบรรทัดที่ 26
ไม่อย่างนั้นเราก็แค่ แสดงผล
อันแรกแสดงว่า มันเปลี่ยนไปเพราะ
f1 เป็นค่าลบ
เรามาสร้างสิ่งนี้กันเถอะ
เราไม่มีข้อผิดพลาดหรือไม่มีการเตือน
ผลลัพธ์ที่เราต้องการ ให้ความสนใจเป็นเพียงผลลัพธ์ของค่าสัมบูรณ์
ดังนั้นมันอาจจะดีกว่าที่จะ จริง ๆ แล้วเพิ่มฟีดบางบรรทัด
หลังจากที่เราแสดงอันสุดท้ายของเรา มาเพิ่มฟีดบรรทัดคู่กัน
ง่ายต่อการอ่านและเรียกใช้สิ่งนี้
ตอนนี้เราเห็นผลคือ 15 5.
มันเลยเปลี่ยนไปจริงๆ จากค่าลบเป็นบวกเพราะว่า
f1 เดิมคือ 15 5.
และผลลัพธ์อื่นๆ ทั้งหมด เป็นค่าบวกด้วย
คำสั่งพิมพ์ล่าสุดไม่ได้พิมพ์ ผลลัพธ์ก็แค่พิมพ์ค่าที่ส่งคืนจากฟังก์ชัน
ดูเหมือนว่าจะทำงาน
ฟังก์ชั่นสุดท้ายที่ฉันต้องการ define เป็นฟังก์ชันสแควร์รูท
ซึ่งจะเป็นฟังก์ชันที่ คำนวณรากที่สองของตัวเลข
และถ้าอาร์กิวเมนต์เชิงลบคือ ผ่านไปแล้ว ข้อความจะแสดงขึ้นและจะส่งกลับค่าลบ
1
มากำหนดการประกาศของ .กัน ฟังก์ชันนี้เป็นทศนิยมทศกัณฐ์และจะใช้ทุ่นชื่อใดก็ได้
และสแควร์รูทกำลังจะไปจริงๆ เพื่อใช้ฟังก์ชันค่าสัมบูรณ์
ดังนั้นเราจึงสามารถกำหนดได้ด้านบน และยังคงใช้อยู่เพราะการประกาศฟังก์ชัน
ลองนิยามมัน และมันต้องลอย
ดังนั้นเราจึงค่อนข้างสะดวกที่ กำหนดฟังก์ชันเหล่านี้ ชนิดข้อมูลสำหรับพารามิเตอร์ส่งคืน
วงเล็บ
เรากำลังจะสร้างคู่รัก ตัวแปรท้องถิ่นที่นี่
เหล่านี้ได้เท่านั้น เข้ามาภายในบล๊อก
แค่นี้ก็ช่วยได้แล้วค่ะ ด้วยอัลกอริธึมรากที่สองของเรา
คุณจะสังเกตเห็นที่นี่ในบรรทัด 59 ฉันสร้างตัวแปรคงที่
เราไม่ได้พูดถึงเรื่องนั้น แต่นั่นเป็นเพียงวิธีสร้างค่าคงที่แทนที่จะใช้การกำหนด
เราสร้างตัวแปร float ชื่อ เอปซิลอน มันคือ. 001 จะช่วยให้เราคำนวณรากที่สองของเราได้
แน่ใจว่าอยู่ในช่วงที่กำหนด
เราเดาได้ว่าอันไหนคือ 1 1 และ การประกาศค่าสัมบูรณ์ที่นี่
เราไม่จำเป็นต้องจัดหาให้ การประกาศเพราะเรากำหนดไว้ด้านบน
ดังนั้นผมจึงสามารถกำจัดมันได้
ตอนนี้จำไว้ว่าเราต้อง ตรวจสอบพารามิเตอร์ เราต้องการทำการตรวจสอบพารามิเตอร์
หากพารามิเตอร์น้อยกว่าศูนย์
เราต้องการพิมพ์ความคิดเห็นและส่งกลับค่าลบ
ดังนั้นถ้า x น้อยกว่าศูนย์ ให้พิมพ์ ลบอาร์กิวเมนต์เชิงลบไปที่สแควร์รูทแล้วคืนค่าเป็นค่าลบ
ที่นี้เราจะมี คืนค่าหลายค่าและฉันจะแสดงให้คุณเห็นว่าคุณสามารถส่งคืนได้อย่างไร
และวางไว้ที่ด้านล่าง
มิฉะนั้นเรามี .ของเรา อัลกอริทึมสำหรับรากที่สอง
ฉันจะไม่อธิบาย อัลกอริธึมเพราะไม่เกี่ยวข้องกับสิ่งที่เรากำลังเรียนรู้
แต่โดยพื้นฐานแล้ว การหาสี่เหลี่ยมจัตุรัส รากของตัวเลข เราได้ค่าสัมบูรณ์ของมันโดยการคูณ
มันแล้วลบใน x
ดังนั้นการเดาคือเราจะเดา
ตอนแรกเราจะเดาและ จากนั้นตรวจสอบว่านี่คืออัลกอริธึม
ตรวจสอบว่าอยู่ในช่วงที่กำหนดหรือไม่
แล้วถ้างั้นเราไปกันเถอะ เพื่อคาดเดาบางอย่างและหารด้วยสองและก็ไป
เพื่อเป็นการเดาว่าเรากลับมา
ที่ด้านล่างสุด เรา จะบอกว่ากลับเดา
ดังนั้นเราจึงใช้ ฟังก์ชันค่าสัมบูรณ์
มันถูกกำหนดไว้ด้านล่างเรา แต่ เรามีประกาศของเราที่ด้านบน
ดังนั้นที่ดี
สิ่งหนึ่งที่เรามีคือ คำสั่งส่งคืนหลายรายการ
สิ่งนี้ถูกกฎหมายอย่างสมบูรณ์ แต่ควร หลีกเลี่ยงเพราะมันยากที่จะเข้าใจสิ่งที่เกิดขึ้น
ดังนั้นสิ่งที่ฉันจะทำที่นี่ก็คือฉันจะ อาจเก็บค่าลบนี้ไว้ในตัวแปรอื่นที่ไม่ใช่การเดา
แต่ มาดูกันว่าเราจะทำสิ่งนี้ได้อย่างไร
ดังนั้นสิ่งที่ฉันจะทำคือเดา เริ่มต้นเป็น 1 0 และเรากำลังคืนค่าเป็นลบ
ฉันอาจจะแค่สร้างอย่างอื่น ตัวแปรที่เรียกว่า float return value
เราสามารถตั้งค่านี้เป็น 0 0.
แล้วก่อนกลับที่นี่ เพราะนี่คือการกระโดดออกจากฟังก์ชันคณิตศาสตร์
ฉันทำได้แค่ บอกว่าค่าส่งคืนเท่ากับลบ 1
0 แทนที่จะได้ผลตอบแทน
เช็คแล้วบอกได้เลย ถ้าผลตอบแทนไม่เท่ากับลบ
1 0 เพราะฉันไม่ ต้องการดำเนินการนี้หากฉันมีหมายเลขที่ไม่ถูกต้องอยู่แล้ว
หมายเลขที่ไม่ถูกต้อง และฉันสามารถใส่สิ่งนี้ในคำสั่ง if
และภายในคำสั่ง while ฉันสามารถพูดได้ว่าผลตอบแทนเท่ากับการเดา
ด้วยวิธีนี้ฉันส่งคืนที่ถูกต้อง สิ่งที่ถ้ามันเป็นรายการที่ถูกต้อง
แล้วแทนที่จะกลับมา เดาว่าสิ่งที่ฉันทำคือฉันคืนค่าส่งคืน
และรหัสนี้ค่อนข้างสะอาดกว่า เพราะมันกลับมาที่ด้านล่างเพียงครั้งเดียวและง่ายต่อการติดตาม
ดังนั้นค่าที่ส่งกลับเป็นค่าลบ หนึ่งถ้ามันเป็นอาร์กิวเมนต์ที่ไม่ถูกต้องหรือมันจะเป็นกำลังสองจริง
root ถ้าไม่ใช่อาร์กิวเมนต์ที่ไม่ถูกต้อง
และเราก็ทำได้เช่นกัน ง่าย ๆ แค่นี้จริง ๆ แล้วไม่แม้แต่ตรวจสอบค่าที่ส่งกลับ
นี่อาจจะง่ายกว่าถ้าจะพูดอย่างอื่นและทำ
ส่วนอื่นของต้นฉบับถ้า
ดังนั้นถ้าเป็นจำนวนบวกที่ จะทำให้สะอาดขึ้นด้วยวิธีการที่คุณไม่มีคำสั่ง
if
ตอนนี้เราต้องทดสอบ
ไปข้างหน้าและทดสอบสิ่งนี้
เราจะเรียก ทำหน้าที่หลายครั้ง
เราจะบอกว่าการทดสอบสแควร์รูท
ฉันจะไม่ทำอะไรทั้งนั้น แฟนซีพิมพ์ที่นี่
ฉันจะทำให้แน่ใจว่าฉัน สามารถเพิ่มบรรทัดฟีดเพื่อให้อ่านง่ายขึ้น
กดปุ่มแทรกที่นั่น
ไม่เป็นไร. ตอนนี้ฉันจะทำหลายอย่าง printfs ที่ฉันจะส่งข้อมูลที่ดีและ
val และข้อมูล inval บางส่วน และฉันจะจัดรูปแบบด้วยวิธีเดียวกัน
เอาเป็นว่าโทรครั้งแรก จะเป็นสแควร์รูทของสแควร์รูทที่ถูกต้อง
ก่อนอื่นเราจะตรวจสอบ ด้วยจำนวนลบ
เราก็บอกว่าลบ 3 ที่ควรพิมพ์ออกมาผิดพลาด
มิฉะนั้นเราจะทดสอบมัน ด้วยตัวเลขที่ถูกต้อง
เราจะบอกว่าสแควร์รูทของ 16 และเราจะส่งผ่าน int พวกเขาจะถูกแปลง ฉันอาจได้รับคำเตือนบางอย่าง
ก็ฉันไม่อยากได้อะไรทั้งนั้น คำเตือน และเราจะทำ 165
ทีนี้มาลองรันและทดสอบกัน
หวังว่ามันจะรวบรวม
ฉันสะกดผิดด้วย float
ตอนนี้เมื่อฉันเรียกใช้ หวังว่า เราจะได้เอาต์พุตสแควร์รูทที่ดี
ตรงนี้เรามีค่าลบ
และเราก็พิมพ์ออกมาเป็นลบ คะแนนอาร์กิวเมนต์ดังนั้นที่ดี
แล้วก็อีกอันคือ ฉัน เชื่อว่ารากที่สองที่ถูกต้อง
ดังนั้นดูเหมือนว่า ฟังก์ชั่นใช้งานได้ดีทีเดียว
เราหารากที่สองของ 16 ซึ่งก็คือ 4, 25 ซึ่งก็คือ 5, 9 ซึ่งก็คือ
3, 165 คือ 12 85.
ดังนั้นฉันจึงคำนวณผิดพลาดที่นั่น
ฉันพยายามนึกถึง 15 คูณ 15 ซึ่งก็คือ 225.
ถ้าฉันใส่ 225 ลงไป มันจะ กลับมาเป็น 15 เป็นรากที่สอง
ฉันจะให้ซอร์สโค้ดนี้ เพื่อให้คุณวิเคราะห์ได้
แต่เข้าใจการประกาศฟังก์ชัน เข้าใจวิธีกำหนดฟังก์ชันด้วยประเภทการส่งคืนและ
พารามิเตอร์ส่งผ่านข้อมูล เข้าใจตัวแปรท้องถิ่น เข้าใจวิธีการ
เพื่อกลับมาที่ด้านล่างเพียงครั้งเดียว
อัลกอริทึมเอง ไม่สำคัญขนาดนั้น
ฉันหวังว่านี่จะช่วยได้ ขอขอบคุณ.