ฟังก์ชั่นและความเป็นไปได้ในการเขียนโปรแกรม หน้าที่ของโปรแกรมและลักษณะของโปรแกรม ฟังก์ชันที่มีอาร์กิวเมนต์ตั้งแต่สองตัวขึ้นไป

ตัวดำเนินการลูปเป็นตัวดำเนินการที่สำคัญที่สุดและพบได้ในภาษาการเขียนโปรแกรมที่ทันสมัยที่สุด และแนวคิดของลูปมีมาตั้งแต่ศตวรรษที่ 19 วัฏจักรช่วยให้คุณดำเนินการตามลำดับการกระทำซ้ำ ๆ ซึ่งกำหนดโดยผู้ดำเนินการที่ประกอบเป็นเนื้อหาของรอบ

มาเริ่มกันที่ตัวดำเนินการ วนรอบด้วยเงื่อนไขเบื้องต้น. โอเปอเรเตอร์นี้ดูเหมือนว่า:

ในขณะที่<условие>ทำ<оператор>.

เมื่อดำเนินการคำสั่งนี้ ค่าของนิพจน์เชิงตรรกะจะถูกประเมินก่อน หากค่านี้เป็นจริง คำสั่งจะถูกดำเนินการ จากนั้น ค่าของนิพจน์จะถูกตรวจสอบอีกครั้ง และทุกอย่างจะถูกทำซ้ำจนกว่านิพจน์จะประเมินเป็นเท็จ การดำเนินการวนซ้ำแต่ละครั้งบางครั้งเรียกว่าการวนซ้ำ หากนิพจน์ประเมินเป็นเท็จในการทดสอบครั้งแรก คำสั่งจะไม่ถูกดำเนินการเลย

ในลูปที่มีเงื่อนไขเบื้องต้น เงื่อนไขเบื้องต้นจะกำหนดว่าจะดำเนินการเนื้อหาของลูปก่อนการวนซ้ำครั้งแรกหรือไม่ หากสิ่งนี้สอดคล้องกับตรรกะของอัลกอริธึม ก็สามารถใช้ลูปที่มีเงื่อนไขภายหลังได้

วนซ้ำกับเงื่อนไขภายหลังดูเหมือน:

ทำซ้ำ...<выражние_1>จนกระทั่ง...<выражение_2>

ในที่นี้ คำสั่งคำสั่ง (คำสั่ง) จะถูกดำเนินการก่อน จากนั้นจึงประเมินค่าของนิพจน์เชิงตรรกะเท่านั้น นั่นคือเหตุผลที่วงจรดังกล่าวเรียกว่าวัฏจักรที่มีเงื่อนไขภายหลัง กระบวนการนี้จะทำซ้ำตราบใดที่นิพจน์ประเมินว่าเป็นเท็จ ทันทีที่ค่าของมันกลายเป็นจริง การวนรอบจะสิ้นสุดลง ตัวดำเนินการสามารถเป็นอะไรก็ได้ รวมถึงตัวดำเนินการแบบผสม:

โอเปอเรเตอร์_1;

โอเปอเรเตอร์_2;

…………….

โอเปอเรเตอร์_N;

จนกระทั่ง<условие>

ในการทำซ้ำ...จนถึงการวนซ้ำ การตรวจสอบจะดำเนินการครั้งสุดท้าย และเนื้อหาของการวนซ้ำจะดำเนินการอย่างน้อยหนึ่งครั้งเสมอ

คำสั่งวนรอบด้วยตัวนับ: for...to...do and for...downto ...do

ตัวแปรที่สามของคำสั่งวนรอบคือ วนซ้ำกับพารามิเตอร์. ถือได้ว่าวัฏจักรที่มีตัวนับคล้ายกันมากมีสองแบบ ตัวดำเนินการแรกเหล่านี้คือ:

สำหรับพารามิเตอร์ลูป:= ค่าเริ่มต้นถึงค่าสิ้นสุด do<оператор>;

คำสั่ง ซึ่งเป็นเนื้อความของลูป อาจเป็นแบบง่ายหรือแบบผสมก็ได้ พารามิเตอร์ลูป เช่นเดียวกับช่วงของการเปลี่ยนแปลง สามารถเป็นประเภทจำนวนเต็มหรือแบบแจงนับเท่านั้น มีการอธิบายพารามิเตอร์ร่วมกับตัวแปรอื่นๆ

หลังจากรัน for loop ค่าของตัวแปรควบคุมจะไม่ถูกกำหนด

ตัวแปร for...downto...do... ของ for loop จะคล้ายกับ for..to...do loop เว้นแต่ว่าตัวแปรควบคุมในตัวแปรนั้นจะไม่เพิ่มขึ้นในแต่ละขั้นตอนการดำเนินการ แต่จะลดลงหนึ่งรายการ:

สำหรับเจ:-<выражение_1>ลงไป<выражение_2>ทำ<оператор>.

โดยสรุป คำแนะนำต่อไปนี้สามารถกำหนดขึ้นสำหรับการใช้วัฏจักร:

ใช้ a for loop เมื่อคุณทราบจำนวนครั้งที่ body ของ loop ควรถูกดำเนินการ มิฉะนั้น ให้ใช้การวนซ้ำหรือ while ลูป

· ใช้ while หากคุณต้องการให้การทดสอบเสร็จสิ้นก่อนที่เนื้อความของลูปจะทำงาน

· บางครั้งก็สะดวกที่จะตรวจสอบหาทางออกที่เป็นไปได้จากลูปที่อยู่ตรงกลาง ไม่ใช่จุดเริ่มต้นหรือจุดสิ้นสุด

การออกจากลูปนี้มีให้โดยโพรซีเดอร์ Break ซึ่งจะหยุดการทำงานของลูปที่ซ้อนกันในสุด ไม่ว่าจะเป็นสำหรับ ในขณะที่ หรือทำซ้ำ โมดูลที่ระบุจะเชื่อมต่อกับโปรแกรมโดยอัตโนมัติ หากจำเป็น

ในขณะที่ความจริงเริ่มต้น

<Выражение_1>

ถ้า<оператор>แล้วแบ่ง

<Выражение_2>; จบ

เราควรพูดถึงโพรซีเดอร์ Continue ซึ่งขัดขวางการทำงานของส่วนในสุดของ innermost สำหรับ ในขณะที่ หรือ วนซ้ำ และถ่ายโอนการควบคุมไปยังส่วนหัวของมัน เพื่อที่การดำเนินการของการวนซ้ำรอบถัดไปของลูปเริ่มต้นขึ้น

ขั้นตอนของ for ลูปจะคงที่เสมอและเท่ากับช่วงเวลาระหว่างสองค่าที่ใกล้ที่สุดของประเภทของพารามิเตอร์ลูป

Var (คำอธิบายของพารามิเตอร์ลูป)

ผม: จำนวนเต็ม (ประเภทจำนวนเต็ม);

c: ถ่าน (ประเภทอักขระ);

1. Begin (พิมพ์จำนวนเต็มตั้งแต่ 1 ถึง 10)

สำหรับ i:=1 ถึง 10 ทำ writeln (i);(ขั้นตอนลูปคือ 1)

2. (พิมพ์ตัวเลขตั้งแต่ 10 ถึง -10)

สำหรับ 10 ลงไป -10 (ขั้นตอนลูปคือ -1)

3. (พิมพ์อักษรละตินจาก A ถึง R)

(พารามิเตอร์ลูปเปลี่ยนจาก A เป็น R ตามลำดับตัวอักษร)

สำหรับ c:='A' ถึง 'R' ทำ writeln(c);

การดำเนินการวนรอบเริ่มต้นด้วยการกำหนดค่าเริ่มต้นให้กับพารามิเตอร์ ตามด้วยการตรวจสอบเพื่อดูว่าพารามิเตอร์มากกว่าค่าสุดท้ายหรือไม่ หากผลการตรวจสอบเป็นการยืนยัน ถือว่าการวนซ้ำเสร็จสมบูรณ์และการควบคุมจะถูกส่งไปยังผู้ดำเนินการตามเนื้อหาของลูป มิฉะนั้น เนื้อหาของลูปจะถูกดำเนินการและพารามิเตอร์จะเปลี่ยนค่าเป็นค่าถัดไปตามชื่อของลูป ถัดไป ค่าของพารามิเตอร์ไซเคิลจะถูกตรวจสอบอีกครั้ง และอัลกอริธึมจะถูกทำซ้ำ

ตัวอย่าง: การคำนวณผลรวมตั้งแต่ 1 ถึง n

var s,n,i: จำนวนเต็ม;

writeln('ป้อน n');

สำหรับ i:=1 ถึง n do s:=s+i;

ฟังก์ชันในการเขียนโปรแกรมเป็นส่วนแยกของโค้ดที่สามารถเรียกได้โดยอ้างอิงจากชื่อที่ใช้เรียกฟังก์ชันนั้น เมื่อถูกเรียก คำสั่งของตัวฟังก์ชันจะถูกดำเนินการ

ฟังก์ชันต่างๆ สามารถเปรียบเทียบได้กับโปรแกรมขนาดเล็กที่ไม่ได้ดำเนินการด้วยตนเอง กล่าวคือ ทำงานโดยอัตโนมัติ แต่มีอยู่ในโปรแกรมปกติ บ่อยครั้งที่พวกเขาถูกเรียกว่า - รูทีนย่อย ไม่มีความแตกต่างที่สำคัญอื่น ๆ ระหว่างฟังก์ชันและโปรแกรม ฟังก์ชันยังสามารถรับและส่งคืนข้อมูลได้ตามต้องการ โดยปกติแล้ว พวกเขาจะไม่ได้มาจากอินพุต (คีย์บอร์ด ไฟล์ ฯลฯ) แต่มาจากโปรแกรมการโทร ที่นี่พวกเขาส่งคืนผลงานของพวกเขา

มีฟังก์ชันมากมายที่สร้างขึ้นในภาษาโปรแกรม เราได้พบสิ่งเหล่านี้ใน Python แล้ว คือ print(), input(), int(), float(), str(), type() เรามองไม่เห็นรหัสของร่างกายมันอยู่ที่ไหนสักแห่ง "ซ่อนอยู่ภายในภาษา" เรามีให้เฉพาะอินเทอร์เฟซ - ชื่อของฟังก์ชัน

ในทางกลับกัน โปรแกรมเมอร์สามารถกำหนดหน้าที่ของตัวเองได้เสมอ พวกเขาเรียกว่าประเพณี ในกรณีนี้ "ผู้ใช้" หมายถึงโปรแกรมเมอร์ ไม่ใช่ผู้ที่ใช้โปรแกรม มาดูกันว่าทำไมเราถึงต้องการฟังก์ชันเหล่านี้ และวิธีสร้างฟังก์ชันเหล่านี้

สมมติว่าคุณต้องถามหาคู่ตัวเลขสามครั้งติดต่อกันแล้วบวกกัน เพื่อจุดประสงค์นี้ คุณสามารถใช้ลูป:

ผม = 0 ในขณะที่ผม< 3 : a = int (input () ) b = int (input () ) print (a+b) i += 1

อย่างไรก็ตาม จะเกิดอะไรขึ้นถ้าก่อนที่จะขอหมายเลขแต่ละครั้ง จำเป็นต้องแสดงคำจารึก เหตุใดจึงต้องมี และทุกครั้งที่คำจารึกนี้แตกต่างกัน เราไม่สามารถทำลายวงจรแล้วกลับไปที่วัฏจักรเดิมได้ คุณต้องละทิ้งมัน จากนั้นคุณจะได้โค้ดยาวที่มีส่วนเดียวกันในที่ต่างๆ:

พิมพ์ () a = int (อินพุต () ) b = int (อินพุต () ) พิมพ์ ("รวม" , a+b, "ชิ้น" ) พิมพ์ () a = int (อินพุต () ) b = int (อินพุต ( ) ) พิมพ์ ("รวม", a+b, "ชิ้น")

ตัวอย่างการทำงานของโปรแกรม:

กล้วยและสับปะรดสำหรับลิงมีกี่ผล? 15 5 รวม 20 ชิ้น มีด้วงและหนอนกี่ตัวสำหรับเม่น? 50 12 รวม 62 ชิ้น มีปลาและหอยสำหรับนากกี่ตัว? 16 8 รวม 24 ชิ้น

การแนะนำฟังก์ชันช่วยให้คุณสามารถแก้ปัญหาการทำซ้ำโค้ดในตำแหน่งต่างๆ ของโปรแกรมได้ ขอบคุณพวกเขา คุณสามารถรันโค้ดชิ้นเดียวกันได้ไม่ใช่ในทันที แต่เฉพาะเมื่อคุณต้องการเท่านั้น

คำจำกัดความของฟังก์ชัน def คำสั่ง

ในภาษาโปรแกรม Python ฟังก์ชันถูกกำหนดโดยใช้คำสั่ง def พิจารณารหัส:

def countFood() : a = int (input () ) b = int (input () ) พิมพ์ ("Total" , a+b, "pcs" )

นี่คือตัวอย่างการกำหนดฟังก์ชัน เช่นเดียวกับคำสั่งที่ซับซ้อนอื่นๆ เช่น ตัวดำเนินการตามเงื่อนไขและวนซ้ำฟังก์ชันประกอบด้วยส่วนหัวและเนื้อหา ชื่อเรื่องลงท้ายด้วยโคลอนและขึ้นบรรทัดใหม่ ร่างกายถูกเยื้อง

คีย์เวิร์ด def จะบอกล่ามว่าเป็นนิยามของฟังก์ชัน def ตามด้วยชื่อของฟังก์ชัน มันสามารถเป็นอะไรก็ได้ เช่นเดียวกับตัวระบุใดๆ เช่น ตัวแปร ในการเขียนโปรแกรม เป็นสิ่งที่พึงปรารถนาอย่างยิ่งที่จะตั้งชื่อที่มีความหมายให้กับทุกสิ่ง ดังนั้นในกรณีนี้ ฟังก์ชันนี้จึงเรียกว่า "คำนวณอาหาร" ในการแปลเป็นภาษารัสเซีย

วงเล็บจะวางไว้หลังชื่อฟังก์ชัน ในตัวอย่างข้างต้น จะว่างเปล่า ซึ่งหมายความว่าฟังก์ชันไม่ยอมรับข้อมูลใด ๆ จากโปรแกรมที่เรียกใช้ อย่างไรก็ตาม เธอสามารถยอมรับได้ จากนั้นพารามิเตอร์ที่เรียกว่าจะระบุไว้ในวงเล็บ

ลำไส้ใหญ่ตามด้วยร่างกายซึ่งมีคำสั่งที่จะดำเนินการเมื่อมีการเรียกใช้ฟังก์ชัน ต้องแยกความแตกต่างระหว่างการกำหนดฟังก์ชันและการเรียกฟังก์ชัน ใน รหัสโปรแกรมพวกเขาไม่ได้อยู่ใกล้กันและไม่ได้อยู่ด้วยกัน คุณสามารถกำหนดฟังก์ชันได้ แต่อย่าเรียกมันว่า คุณไม่สามารถเรียกใช้ฟังก์ชันที่ยังไม่ได้กำหนดได้ หากคุณกำหนดฟังก์ชันแต่ไม่เคยเรียกใช้ คุณจะไม่เรียกใช้เนื้อความของฟังก์ชันนั้น

เรียกใช้ฟังก์ชัน

พิจารณา เวอร์ชันเต็มโปรแกรมที่มีฟังก์ชั่น:

def countFood() : a = int (input () ) b = int (input () ) print ("Total" , a+b, "pcs" ) พิมพ์ ( "กล้วยกับสับปะรดให้ลิงกี่ลูก") countFood() พิมพ์ ( "มีด้วงและหนอนกี่ตัวสำหรับเม่น") countFood() พิมพ์ ( "มีปลาและหอยสำหรับนากกี่ตัว") นับอาหาร()

หลังจากที่แต่ละข้อความแสดงข้อมูลปรากฏบนหน้าจอ จะทำการเรียกใช้ฟังก์ชัน ซึ่งดูเหมือนกับการกล่าวถึงชื่อด้วยวงเล็บ เนื่องจากเราไม่ได้ส่งผ่านสิ่งใดไปยังฟังก์ชัน วงเล็บจึงว่างเปล่าอีกครั้ง ในโค้ดด้านบนนี้ ฟังก์ชันถูกเรียกสามครั้ง

เมื่อเรียกใช้ฟังก์ชัน เธรดการดำเนินการของโปรแกรมจะข้ามไปยังคำจำกัดความและเริ่มดำเนินการเนื้อหา หลังจากที่เนื้อความของฟังก์ชันถูกเรียกใช้งาน โฟลว์ของการดำเนินการจะส่งกลับไปยังโค้ดหลัก ณ ตำแหน่งที่เรียกใช้ฟังก์ชัน ถัดไป นิพจน์หลังการโทรจะถูกดำเนินการ

ใน Python การกำหนดฟังก์ชันต้องมาก่อนการเรียก เนื่องจากล่ามอ่านโค้ดทีละบรรทัดและยังไม่รู้ว่าดาวน์สตรีมคืออะไร ดังนั้น หากการเรียกใช้ฟังก์ชันอยู่ก่อนคำจำกัดความ จะเกิดข้อผิดพลาด (มีข้อยกเว้น NameError):

พิมพ์ ( "กล้วยกับสับปะรดให้ลิงกี่ลูก") countFood() พิมพ์ ( "มีด้วงและหนอนกี่ตัวสำหรับเม่น") countFood() พิมพ์ ( "มีปลาและหอยสำหรับนากกี่ตัว") countFood() def countFood() : a = int (อินพุต () ) b = int (อินพุต () ) พิมพ์ ("Total" , a+b, "pcs" )

ผลลัพธ์:

กล้วยและสับปะรดสำหรับลิงมีกี่ผล? Traceback (การโทรล่าสุดครั้งสุดท้าย ) : ไฟล์ "test.py" , บรรทัดที่ 2 , in< module>countFood() NameError: ไม่ได้กำหนดชื่อ "countFood"

สำหรับภาษาที่คอมไพล์หลายๆ ภาษา นี่ไม่ใช่ข้อกำหนด คุณสามารถกำหนดและเรียกใช้ฟังก์ชันในตำแหน่งใดก็ได้ในโปรแกรม อย่างไรก็ตาม เพื่อความชัดเจนในการอ่านโค้ด โปรแกรมเมอร์ในกรณีนี้ยังต้องการปฏิบัติตามกฎเกณฑ์บางประการ

ฟังก์ชันกำหนดโครงสร้างให้กับโปรแกรม

ประโยชน์ของฟังก์ชันไม่ได้เป็นเพียงความสามารถในการเรียกรหัสเดียวกันซ้ำๆ จากที่ต่างๆ ในโปรแกรมเท่านั้น ที่สำคัญเท่าเทียมกันคือ ทำให้โปรแกรมมีโครงสร้างที่แท้จริง ฟังก์ชั่นตามที่เป็นอยู่แบ่งออกเป็นส่วนต่าง ๆ ซึ่งแต่ละส่วนทำหน้าที่เฉพาะของตัวเอง

สมมติว่าคุณจำเป็นต้องเขียนโปรแกรมที่คำนวณพื้นที่ของตัวเลขต่างๆ ผู้ใช้ระบุพื้นที่ที่ต้องการคำนวณ หลังจากนั้นป้อนข้อมูลเริ่มต้น เช่น ความยาวและความกว้างในกรณีของสี่เหลี่ยมผืนผ้า ในการแบ่งโฟลว์ของการดำเนินการออกเป็นหลายสาขา ให้ใช้คำสั่ง if-elif-else:

รูป = อินพุต () ถ้ารูป == "1" : a = float (อินพุต ("ความกว้าง: " ) ) b = float (อินพุต ("ความสูง: " ) ) พิมพ์ ("พื้นที่: %.2f" % (a* b) ) elif figure == "2" : a = float (อินพุต ("Base: " ) ) h = float (อินพุต ("ความสูง: " ) ) พิมพ์ ("Area: %.2f" % (0.5 * a * h) ) elif figure == "3" : r = float (input ("Radius: " ) ) print ("Area: %.2f" % (3.14 * r**2 ) ) else : print ("ข้อผิดพลาดในการป้อนข้อมูล" )

ไม่มีฟังก์ชั่นที่นี่ และทุกอย่างเรียบร้อยดี แต่มาเขียนเวอร์ชันที่มีฟังก์ชันกัน:

def รูปสี่เหลี่ยมผืนผ้า () : a = float (อินพุต ("ความกว้าง: " ) ) b = float (อินพุต ("ความสูง: " ) ) พิมพ์ ("พื้นที่: %.2f" % (a*b) ) def triangle() : a = float (input ("Base: " ) ) h = float (input ("Height: " ) ) print ("Area: %.2f" % (0.5 * a * h) ) def circle() : r = float (อินพุต ("รัศมี: " ) ) พิมพ์ ("พื้นที่: %.2f" % (3.14 * r**2 ) ) รูป = อินพุต ( "1-สี่เหลี่ยมผืนผ้า, 2-สามเหลี่ยม, 3 วงกลม: ") ถ้ารูป == "1" : รูปสี่เหลี่ยมผืนผ้า () รูป elif == "2" : รูปสามเหลี่ยม () รูป elif == "3" : วงกลม () อื่น ๆ : พิมพ์ ("ข้อผิดพลาดในการป้อนข้อมูล")

ดูเหมือนซับซ้อนมากขึ้นและฟังก์ชันทั้งสามนี้ถูกเรียกเพียงครั้งเดียว อย่างไรก็ตาม จากตรรกะทั่วไปของโปรแกรม คำแนะนำในการค้นหาพื้นที่จะเรียงลำดับและแยกออก ตอนนี้โปรแกรมประกอบด้วย "อิฐเลโก้" แยกต่างหาก ที่สาขาหลักก็รวมเอาตามใจชอบ มันทำหน้าที่เป็นกลไกควบคุม

หากเราต้องการคำนวณพื้นที่ของสามเหลี่ยมโดยใช้สูตรของ Heron แทนการใช้ความสูง เราก็ไม่ต้องมองหาโค้ดในโปรแกรมทั้งหมด (ลองนึกภาพว่าประกอบด้วยโค้ดหลายพันบรรทัดเหมือนโปรแกรมจริง) . เราจะไปยังสถานที่ที่มีการกำหนดฟังก์ชั่นและเปลี่ยนเนื้อหาของหนึ่งในนั้น

หากเราต้องการใช้ฟังก์ชันเหล่านี้ในโปรแกรมอื่น เราสามารถนำเข้าฟังก์ชันเหล่านี้ได้โดยใช้การอ้างอิงถึง ให้ไฟล์ด้วยรหัส (วิธีการทำใน Python จะกล่าวถึงในภายหลัง)

ฝึกงาน

ในการเขียนโปรแกรม คุณสามารถเรียกใช้ฟังก์ชันอื่นจากฟังก์ชันหนึ่งได้ เพื่อแสดงให้เห็นความเป็นไปได้นี้ ให้เขียนโปรแกรมตามที่อธิบายไว้ด้านล่าง

สาขาหลักของโปรแกรมไม่นับส่วนหัวของฟังก์ชันประกอบด้วยโค้ดหนึ่งบรรทัด นี่คือการเรียกใช้ฟังก์ชัน test() มันขอเลขจำนวนเต็ม หากเป็นค่าบวก ฟังก์ชัน positive() จะถูกเรียก เนื้อหามีคำสั่งให้แสดงคำว่า "บวก" บนหน้าจอ ถ้าตัวเลขเป็นค่าลบ ฟังก์ชัน negative() จะถูกเรียก เนื้อความของตัวเลขจะมีนิพจน์สำหรับแสดงคำว่า "Negative" บนหน้าจอ

ตัวแปรท้องถิ่นและระดับโลก

พื้นฐานของใดๆ โปรแกรมคอมพิวเตอร์- อัลกอริทึมที่แสดงเป็นคำสั่ง มนุษย์, การเขียนโค้ดหมายความ ว่า เอาไป ทำอย่างนั้น เช่นนั้น แล้วแสดงผลที่นั่น และไปพัก. ดังนั้น เพื่อให้คำสั่งในโปรแกรมไม่รวมกันเป็นหนึ่งระเบียบและสามารถโต้ตอบกันได้ คำสั่งเหล่านี้จะถูกจัดกลุ่มเป็นฟังก์ชันและขั้นตอนที่เรียกว่า มาทำความรู้จักกับแนวคิดเหล่านี้กัน

ฟังก์ชั่นคืออะไร

ใช้ชื่อฟังก์ชัน: 1) เพื่อสร้างเอกสาร; 2) สำหรับ API กล่าวคือ อินเทอร์เฟซสำหรับเชื่อมต่อกับโปรแกรมหรือระบบปฏิบัติการทั้งหมดของแอปพลิเคชันใดๆ ดังนั้นจึงควรเตือนอีกครั้งว่าชื่อเหล่านี้ควรสามารถเข้าใจได้ และหากเป็นไปได้ ให้สอดคล้องกับการกระทำที่ทำ

สรุป

ดังนั้น ฟังก์ชันจึงเป็นคอนเทนเนอร์ประเภทหนึ่งสำหรับจัดกลุ่มอัลกอริธึม พวกเขาเป็น:

รับผิดชอบงานเฉพาะ
โต้ตอบกับวัตถุอื่น ๆ
เป็นพื้นฐานทางความคิด การเขียนโปรแกรมสมัยใหม่ไม่ว่ามันจะฟังดูน่าสมเพชแค่ไหน

ในความเป็นจริงขั้นตอนการทำงานเหมือนกัน แม้ว่าจะ "เป็นโมฆะ" ที่ไม่ส่งคืนสิ่งใด (นี่คือความแตกต่างหลัก) เครื่องมือเสริมที่ออกแบบมาเพื่อใช้งาน กิจกรรมประจำและยังช่วยประหยัดพื้นที่ แรงและเวลา

สิ่งพิมพ์ก่อนหน้า:

ตามคำจำกัดความมันเป็นหน่วยอิสระของโปรแกรมที่ออกแบบมาสำหรับการใช้งานเฉพาะ ในแง่ที่ง่ายกว่า ฟังก์ชันคือกลุ่มของตัวดำเนินการหลายตัวที่แยกออกเป็นบล็อกที่แยกจากกัน ฟังก์ชันนี้อยู่ภายใต้กฎและมาตรฐานทั้งหมดของภาษาซี

จุดบวก:

สามารถเรียกใช้ฟังก์ชันได้ตลอดเวลาและทุกที่ในโปรแกรมเพื่อเรียกใช้งานและมากกว่าหนึ่งครั้ง

ฟังก์ชั่นช่วยโปรแกรมเมอร์จากการโคลนนิ่งของคำสั่งซ้ำ ๆ จำนวนมาก

สามารถแทรกฟังก์ชันเดียวกันลงในโปรแกรมที่แตกต่างกันโดยสิ้นเชิง ซึ่งจะช่วยลดเวลาในการพัฒนาและการดีบัก

การใช้ฟังก์ชันเพิ่มโมดูลาร์ของโปรแกรม โครงสร้าง ซึ่งทำให้อ่านรายการได้ง่ายขึ้น เร่งการแนะนำการเปลี่ยนแปลง

คุณจำเป็นต้องรู้อะไรบ้างเกี่ยวกับฟังก์ชัน? ประการแรก วิธีการเรียกอย่างถูกต้องจากโปรแกรม ประการที่สอง วิธีการจัดเรียงในไลบรารีแยกต่างหาก และประการที่สาม วิธีการสร้างความสัมพันธ์กับฟังก์ชันอื่น ๆ

ฟังก์ชั่นในภาษาซีสามารถแบ่งออกเป็นสามประเภท: ระบบภายในและภายนอก

ฟังก์ชั่นของระบบแนบมากับคอมไพเลอร์ ใน WinAVR สามารถพบได้ในการอ้างอิงไลบรารีที่ C:\WinAVR-2010010\doc\avr-libc\avr-libc-user-manual.pdf (ต่อไปนี้จะเรียกว่า "คู่มือห้องสมุด")

แต่ละฟังก์ชันของระบบจะรวมอยู่ในไลบรารีของตัวเองอย่างเคร่งครัด ชื่อของไลบรารีและฟังก์ชันต่างกันในคอมไพเลอร์ที่แตกต่างกัน การประกาศของไลบรารีที่ใช้ทำใน "ส่วนหัว" ของโปรแกรมโดยคำสั่งตัวประมวลผลล่วงหน้า "#inC1ude<имя заголовочного файла-хеддера>».

สัญลักษณ์ "#" เขียนพร้อมกับคำว่า "inC1ude" และต้องขึ้นต้นในคอลัมน์แรกของรายการ "Hedder" เป็นไฟล์ที่มีนามสกุล ".h" ซึ่งอธิบายพารามิเตอร์ของฟังก์ชัน ฟังก์ชันของระบบยังรวมถึงฟังก์ชันหลัก "หลัก" โดยที่ไม่มีโปรแกรมในภาษา C ที่สามารถทำได้

กล่าวโดยเคร่งครัด การใช้ฟังก์ชันของระบบทำให้ยากต่อการย้ายโปรแกรมจากแพลตฟอร์ม MK หนึ่งไปยังอีกแพลตฟอร์มหนึ่ง คอมไพเลอร์ที่แตกต่างกันมีปรัชญาการเขียนโปรแกรมที่แตกต่างกัน ตัวอย่างเช่น นักพัฒนาบางคนพยายามที่จะรวมเฉพาะไลบรารีและฟังก์ชันที่ได้มาตรฐานระดับสากลในคอมไพเลอร์ ในขณะที่คนอื่น ๆ กลับสร้างฟังก์ชันเฉพาะทางขั้นสูงจำนวนมากซึ่งสะดวกสำหรับโปรแกรมเมอร์ แต่ห่างไกลจากมาตรฐานโดยสิ้นเชิง

คอมไพเลอร์ AVR-GCC ที่ใช้ในแพ็คเกจ WinAVR ใช้พื้นที่ตรงกลางเมื่อเทียบกับคอมไพเลอร์อื่นๆ ประกอบด้วยฟังก์ชันโดยประมาณเท่าๆ กันของมาตรฐาน ANSI, C99 ที่ยอมรับโดยทั่วไป รวมถึงไลบรารีไมโครคอนโทรลเลอร์ของตัวเอง

เมื่อศึกษาฟังก์ชันของระบบของคอมไพเลอร์หนึ่งตัวอย่างละเอียดแล้ว โปรแกรมเมอร์จะ "ยึด" กับคอมไพเลอร์และไม่ต้องการเรียนรู้คอมไพเลอร์ใหม่ นี่คือจุดที่ต้องมีการคำนวณหมากรุกอย่างแท้จริงเพื่อเลือกคอมไพเลอร์ที่แข็งแกร่ง ทรงพลัง และได้รับการอัปเดตอย่างต่อเนื่อง (และดังนั้นจึง "ถ่ายทอดสด"!) เป็นครั้งแรก อย่างไรก็ตาม AVR-GCC ยังคงแสดงให้เห็นถึงความคาดหวังทั้งหมดของผู้ใช้

นอกจากฟังก์ชันแล้ว ไลบรารีของคอมไพเลอร์มาตรฐานยังรวมถึงนิยามมาโครของระบบด้วย เช่น "_BV" เฉพาะแพ็คเกจ WinAVR "bit_is_set" "bit_is_C1ear" รายละเอียดการใช้งานอยู่ในคู่มือห้องสมุด

โปรแกรมเมอร์สร้างฟังก์ชันภายในเอง จำนวนของพวกเขาในโปรแกรมถูก จำกัด ด้วยจินตนาการของนักพัฒนาเท่านั้น ตามกฎแล้วฟังก์ชันภายในจะถูกเพิ่มไว้ที่ส่วนท้ายหรือตอนต้นของรายการทั่วไปและสามารถเรียกได้ทั้งจากโปรแกรมหลักและจากฟังก์ชันอื่น ๆ ตำแหน่งพิเศษถูกครอบครองโดยตัวจัดการการขัดจังหวะ ซึ่งหมายถึงการทำงานภายในเชิงความหมายด้วย แม้ว่าจะมีระบบคำอธิบายพิเศษก็ตาม

ควรเรียกฟังก์ชันภายในกี่ครั้ง? ควรใช้อย่างน้อยสองครั้ง มิฉะนั้น ประโยชน์ของการใช้จะหายไป การใช้ฟังก์ชันภายในจะได้ผลเมื่อคุณต้องดำเนินการซ้ำๆ กันหลายๆ ครั้ง ยิ่งเรียกใช้ฟังก์ชันบ่อยเท่าใด ระดับการบีบอัดของรหัสโปรแกรมก็จะยิ่งสูงขึ้น

ฟังก์ชันภายนอกตามคำจำกัดความอยู่นอกรายการหลัก กล่าวคือ ในไฟล์แยกต่างหาก มีโครงสร้างคล้ายกับหน้าที่ภายใน แต่ทำไมพวกเขาจึงถูกแยกออกในกลุ่มที่แยกจากกัน? มีหลายสาเหตุ

1. คอมไพเลอร์มีข้อ จำกัด ทางกายภาพเกี่ยวกับความยาวของไฟล์ที่ประมวลผล ตัวอย่างเช่น หากเมื่อรวบรวมรายชื่อขนาดใหญ่ ข้อความแสดงข้อผิดพลาด "Eggr" จะปรากฏขึ้น คุณสามารถแยกฟังก์ชันภายในบางส่วนออกเป็นไฟล์แยกต่างหาก (ทำให้เป็นไฟล์ภายนอก) และทุกอย่างจะเรียบร้อย

2. โปรแกรมที่มีจำนวนบรรทัดมากจะวิเคราะห์ แก้ไข และแก้ปัญหาได้ยากกว่า เพื่อให้สอดคล้องกับหลักการของโมดูลาร์ ขอแนะนำให้แบ่งโปรแกรมออกเป็นส่วนเล็กๆ ที่แยกจากกันตามหลักเหตุผล ซึ่งแก้ไข จัดเรียงใหม่ แทนที่ได้ง่าย

3. หากคุณทำให้ฟังก์ชันภายนอกทำงานอัตโนมัติให้มากที่สุดเท่าที่จะเป็นไปได้ ในอนาคตจะสามารถใช้ร่วมกับโปรแกรมอื่นๆ ได้ โปรแกรมเมอร์ที่มองการณ์ไกลพยายามสร้างไลบรารี "ดั้งเดิม" ของตนเอง ซึ่งประกอบด้วยฟังก์ชันพิเศษ ตัวอย่างเช่น ชุดฟังก์ชันภายนอกสำเร็จรูปที่ดีสำหรับตัวควบคุม AVR มีอยู่ในไลบรารีฟรีของ Pascal Stang

ตามประเพณีที่กำหนดไว้ ชื่อฟังก์ชันทั้งหมด รวมทั้งชื่อตัวแปรจะเขียนด้วยตัวอักษรละตินตัวเล็ก อนุญาตให้ใช้ตัวเลขในทุกตำแหน่งของชื่อ ยกเว้นตำแหน่งแรกจากด้านซ้าย ชื่อของฟังก์ชันระบบไม่สามารถเปลี่ยนแปลงได้ ถูกกำหนดโดยมาตรฐาน ตรงกันข้ามกับฟังก์ชันภายในและภายนอก ซึ่งทุกคนเป็นผู้คิดค้นชื่อตามที่ต้องการ ข้อจำกัดเพียงอย่างเดียวคือชื่อใหม่แตกต่างจากชื่อของฟังก์ชันของระบบ มิฉะนั้น คอมไพเลอร์จะแสดงข้อความแสดงข้อผิดพลาด: "Error Previous definition"

ชื่อของฟังก์ชันต้องตามด้วยวงเล็บ ซึ่งหากจำเป็น ให้ระบุพารามิเตอร์ที่จะส่งผ่าน/รับ ในตาราง 6.9 แสดงการประกาศที่ถูกต้องและรูปแบบการเรียกใช้ฟังก์ชันทั้งหมดใน AVR-GCC

ตารางที่ 6.9. การประกาศฟังก์ชันและรูปแบบการโทรใน AVR-GCC

รูปแบบการประกาศฟังก์ชัน __ "ตัวอย่าง ()"

ระบบแยก (ระบบย่อย, โปรแกรมย่อย) ซึ่งรับอินพุตควบคุมในรูปแบบของค่าอาร์กิวเมนต์ ที่เอาต์พุต ฟังก์ชันจะส่งกลับผลลัพธ์ ซึ่งสามารถเป็นค่าสเกลาร์หรือค่าเวกเตอร์ (โครงสร้าง อาร์เรย์ดัชนี เป็นต้น) ในระหว่างการเรียกใช้ฟังก์ชัน การเปลี่ยนแปลงบางอย่างสามารถทำได้ในระบบที่ถูกจัดการ ทั้งแบบย้อนกลับและแบบย้อนกลับไม่ได้

ผลข้างเคียง

หน้าที่และขั้นตอน

ในภาษาโปรแกรมบางภาษา (เช่น ใน Pascal) ฟังก์ชันและโพรซีเดอร์ (รูทีนย่อยที่ไม่คืนค่า) จะแยกความแตกต่างอย่างชัดเจนตามไวยากรณ์ของภาษา ในภาษาอื่นๆ ตัวอย่างเช่น ในภาษา C โพรซีเดอร์เป็นกรณีพิเศษ (เซ็ตย่อย) ของฟังก์ชันที่คืนค่าประเภท (pseudotype) เป็นโมฆะ ซึ่งเป็นค่าว่าง

อาร์กิวเมนต์และตัวเลือก

เมื่อมีการเรียกใช้ฟังก์ชัน อาร์กิวเมนต์จะถูกส่งต่อไปยังฟังก์ชันนั้น หากอาร์กิวเมนต์เป็นการอ้างอิงไปยังพื้นที่หน่วยความจำ (ตัวแปร ตัวชี้ หรือการอ้างอิง) ฟังก์ชันก็สามารถใช้ค่าของฟังก์ชันนั้นได้ (เช่น สร้างตัวแปร คัดลอกค่าของอาร์กิวเมนต์ที่นั่น) ) หรืออาร์กิวเมนต์เอง (สร้างการอ้างอิงไปยังพื้นที่ที่หน่วยความจำอ้างอิงโดยอาร์กิวเมนต์)

ฟังก์ชันที่ไม่มีอาร์กิวเมนต์

ฟังก์ชันดังกล่าวไม่ต้องการอาร์กิวเมนต์ใดๆ

ดูสิ่งนี้ด้วย

ลิงค์

ฟังก์ชัน PHP ไวยากรณ์และตัวอย่างการใช้ฟังก์ชัน PHP

มูลนิธิวิกิมีเดีย 2010 .

ดูว่า "ฟังก์ชัน (การเขียนโปรแกรม)" ในพจนานุกรมอื่นๆ คืออะไร:

วิกิพจนานุกรมมีบทความ "ฟังก์ชัน" ฟังก์ชันเป็นศัพท์หลายความหมายที่หมายถึงความสัมพันธ์ระหว่างองค์ประกอบที่การเปลี่ยนแปลงในองค์ประกอบหนึ่งทำให้เกิดการเปลี่ยนแปลง ... Wikipedia

ฟังก์ชัน stub ในการเขียนโปรแกรมคือฟังก์ชันที่ไม่ดำเนินการใดๆ ที่มีความหมาย ส่งกลับผลลัพธ์ที่ว่างเปล่าหรือข้อมูลอินพุตที่ไม่เปลี่ยนแปลง คำภาษาอังกฤษที่เทียบเท่าคือต้นขั้ว ใช้: เพื่อความชัดเจนเมื่อ ... ... Wikipedia

ฟังก์ชั่นพลังจิตที่สูงขึ้น: การกู้คืน- (การฟื้นฟูสมรรถภาพทางจิตที่สูงขึ้น) ส่วนหนึ่งของ neuropsychology ที่อุทิศให้กับการศึกษากลไกและวิธีการในการฟื้นฟูการทำงานของหน้าที่ทางจิตที่สูงขึ้นซึ่งบกพร่องเนื่องจากรอยโรคของสมองในท้องถิ่นของสมอง ตามแนวคิดเกี่ยวกับ... สารานุกรมจิตวิทยาที่ยิ่งใหญ่

การเขียนโปรแกรมทางคณิตศาสตร์เป็นวินัยทางคณิตศาสตร์ที่ศึกษาทฤษฎีและวิธีการในการแก้ปัญหาของการค้นหา extrema ของฟังก์ชันในชุดของพื้นที่เวกเตอร์ที่มีขอบเขตจำกัด ซึ่งกำหนดโดยข้อ จำกัด เชิงเส้นและไม่เชิงเส้น ... ... Wikipedia

ในสาขาคอมพิวเตอร์แนวคิดของการเขียนโปรแกรมงานเครือข่ายหรือที่เรียกว่าการเขียนโปรแกรมเครือข่ายค่อนข้างคล้ายกับแนวคิดของการเขียนโปรแกรมซ็อกเก็ตและการเขียนโปรแกรมไคลเอนต์ - เซิร์ฟเวอร์ ... ... Wikipedia

ฟังก์ชันลำดับที่สูงกว่าคือฟังก์ชันที่รับฟังก์ชันอื่นเป็นอาร์กิวเมนต์หรือส่งกลับฟังก์ชันอื่นเป็นผลลัพธ์ แนวคิดพื้นฐานคือฟังก์ชันมีสถานะเหมือนกับออบเจ็กต์ข้อมูลอื่นๆ ... ... Wikipedia

การเขียนโปรแกรมคณิตศาสตร์- ทางคณิตศาสตร์ที่ซับซ้อน แบบจำลองและวิธีการแก้ปัญหาการหาค่าสุดโต่ง (สูงสุดหรือต่ำสุด) ของฟังก์ชันของตัวแปรหลายตัวภายใต้ข้อจำกัดในรูปแบบของความไม่เท่าเทียมกัน หมายความว่าตัวแปรกำหนดลักษณะบางแง่มุมของกลไก ... ... สารานุกรมสังคมวิทยารัสเซีย

สาขาวิชาคณิตศาสตร์ที่เรียนคณิตศาสตร์ นามธรรมของโปรแกรม ถือเป็นวัตถุที่แสดงในภาษาที่เป็นทางการ โดยมีข้อมูลและตรรกะบางอย่าง โครงสร้างและการดำเนินการโดยอัตโนมัติ อุปกรณ์ ป. ต. ... ... สารานุกรมคณิตศาสตร์

ฟังก์ชั่นในการเขียนโปรแกรมเป็นประเภทของรูทีนย่อย คุณลักษณะที่แยกความแตกต่างจากรูทีนย่อยของโพรซีเดอร์ประเภทอื่นคือ ฟังก์ชันส่งคืนค่า และสามารถใช้การเรียกในโปรแกรมเป็นนิพจน์ได้ จากมุมมอง ... ... Wikipedia

การเขียนโปรแกรม คณิตศาสตร์- สาขาวิชาคณิตศาสตร์ประยุกต์ที่ใช้เป็นวิธีการวิจัยทางเศรษฐศาสตร์ พัฒนาทฤษฎีและวิธีการในการแก้ปัญหาเงื่อนไขสุดโต่งซึ่งเป็นส่วนหลักของเครื่องมือที่เป็นทางการสำหรับการวิเคราะห์ปัญหาการควบคุมต่างๆ ... พจนานุกรมเศรษฐกิจขนาดใหญ่