ขั้นตอนการนำเสนอแบบปาสกาล ขั้นตอนและหน้าที่ในภาษาปาสกาล การเรียกซ้ำ รูทีนย่อย บ่อยครั้งที่งานต้องการให้คุณทำซ้ำคำสั่งเฉพาะในส่วนต่างๆ ของโปรแกรม ผ่านพารามิเตอร์ พารามิเตอร์ทางการ

หากต้องการใช้ตัวอย่างการนำเสนอ ให้สร้างบัญชี Google (บัญชี) ของคุณเองแล้วลงชื่อเข้าใช้: https://accounts.google.com

คำบรรยายสไลด์:

ขั้นตอนและหน้าที่ในภาษาปาสกาล การเรียกซ้ำดำเนินการโดยครูด้านสารสนเทศ GBOU โรงเรียน 1362 Sanina Marina Sergeevna

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

ฟังก์ชันขั้นตอนงานประจำ PROCEDURE FUNCTION

ขั้นตอนและฟังก์ชันในภาษา Pascal ถูกประกาศไว้ในส่วนการประกาศหลังส่วนตัวแปร

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

นอกจากนี้ รูทีนย่อยยังมีตัวแปรอีกด้วย ซึ่งเธอทำงานต่อไป แบ่งออกเป็นสองประเภทอีกครั้ง: 1) ตัวแปรโกลบอล นั่นคือ ตัวแปรที่ทำหน้าที่ในโปรแกรมทั้งหมด 2) โลคัล - ตัวแปรที่ทำหน้าที่เฉพาะในโพรซีเดอร์หรือฟังก์ชัน

ขั้นตอน ใช้ในกรณีที่จำเป็นต้องมีผลลัพธ์หลายรายการในรูทีนย่อย ขั้นตอนมีสองประเภท: ด้วยพารามิเตอร์; ไม่มีพารามิเตอร์

โครงสร้างของขั้นตอนคล้ายกับโปรแกรมและประกอบด้วยส่วนหัวและบล็อก (เนื้อหาขั้นตอน) ขั้นตอน ชื่อขั้นตอน; var… เริ่ม… // ขั้นตอนเนื้อหาสิ้นสุด; เริ่มต้น // ตัวโปรแกรมหลักสิ้นสุด

ขั้นตอนที่ไม่มีพารามิเตอร์ ขั้นตอน pr; var i: จำนวนเต็ม; เริ่มต้นสำหรับ i: = 1 ถึง 60 เขียน ('* "); writeln; end. start pr; end โปรแกรมนี้พิมพ์สตริงที่มีดาว 60 ดวง

ขั้นตอนพารามิเตอร์ สร้างโปรแกรมสำหรับแลกเปลี่ยนตัวเลขสองตัวด้วยโปรแกรม = 5 และ d = 7 obmenDan; var c, d: จำนวนเต็ม; ขั้นตอน obmen (a, b: จำนวนเต็ม); var m: จำนวนเต็ม; เริ่มต้น m: = a; ก: = ข; ข: = ม; writeln (a, b); จบ; เริ่ม writeln ("ป้อน 2 หมายเลข:"); readln (c, d); obmen (c, d); writeln (c, "", d); จบ.

การวิเคราะห์ปัญหา 1) เมื่อเรียกใช้ขั้นตอน obmen ด้วยสองพารามิเตอร์ 5 และ 7 ตัวเลข 5 และ 7 จะถูกวางไว้ในตัวแปร a และ b ตามลำดับ: c 5 d 7 a 5 b 7

เพื่อให้ตัวแปร c และ d, a และ b อ้างถึงเซลล์หน่วยความจำเดียวกัน (หากค่าของ a และ b เปลี่ยนแปลง ค่าของ c และ d ก็เปลี่ยนไปด้วย) เมื่ออธิบายพารามิเตอร์ที่เป็นทางการ ให้เพิ่ม คำว่า VAR นำหน้าตัวแปรที่ต้องการ: ขั้นตอน obmen (var a, b: integer); s 5 d 7 a b

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

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

คำอธิบายฟังก์ชัน: ฟังก์ชั่น (): ประเภท; (ส่วนที่อธิบายชื่อท้องถิ่น) Begin (ส่วนของคำสั่งปฏิบัติการ): =; (พารามิเตอร์ที่จำเป็น) สิ้นสุด;

เรียกใช้ฟังก์ชัน:: = (); 1 . ที่ด้านขวาของตัวดำเนินการมอบหมาย 2. ในนิพจน์ในเงื่อนไขของตัวดำเนินการแตกแขนง 3. ในขั้นตอนการส่งออกอันเป็นผลมาจากฟังก์ชัน

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

เขียนฟังก์ชันแบบเรียกซ้ำที่คำนวณแฟกทอเรียลของจำนวน n ดังนี้: n! = 1 ถ้า n = 1 n! = (N -1)! N ถ้า n> 1

ฟังก์ชัน f (n: จำนวนเต็ม): จำนวนเต็ม; เริ่มต้นถ้า n = 1 แล้ว f: = 1 อื่น f: = n * f (n -1); (ฟังก์ชัน f เรียกตัวเอง) สิ้นสุด;

งาน เปลี่ยนค่าของตัวแปร a, b, c เพื่อให้เรียงตามลำดับที่ไม่ลดลง (a ≤ b ≤ c) คุณจะได้รับ n จำนวนเต็ม ค้นหาในหมู่พวกเขาจำนวนที่มีผลรวมของหลักมีค่าสูงสุด

รูทีนย่อย วี เทอร์โบปาสกาล

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

เหตุผลในการใช้รูทีนย่อย

• ลดความซับซ้อนในการพัฒนาโปรแกรมขนาดใหญ่โดยแยกย่อย (แบ่ง) งานออกเป็นงานย่อยหลายงาน
• ทัศนวิสัยที่มากขึ้นของโปรแกรม
• บันทึกหน่วยความจำ

ประเภทของรูทีนย่อย

ขั้นตอน

ฟังก์ชั่น

• ขั้นตอนเป็นส่วนที่มีชื่ออิสระของโปรแกรมที่ออกแบบมาเพื่อดำเนินการเฉพาะ

ขั้นตอนไร้พารามิเตอร์

• รูปแบบการบันทึก :

ขั้นตอน ;

จบ ;

• ตัวแปรทั้งหมดที่ใช้ในโพรซีเดอร์ที่ไม่มีพารามิเตอร์มีอธิบายไว้ในโปรแกรมหลัก (ในโมดูล Var)

ตัวอย่าง . ทำโปรแกรมหาปริมาตรของทรงกระบอก

กระบอกโปรแกรม;

Var R, H, V: จริง;

อินพุตขั้นตอน; (ขั้นตอนการป้อนข้อมูล)

Writeln ('ป้อนค่ารัศมี');

writeln ('ป้อนค่าความสูง');

สูตรขั้นตอน { ขั้นตอน การคำนวณ ปริมาณ }

V: = PI * sqr (R) * H;

ผลลัพธ์ของขั้นตอน; (ขั้นตอนแสดงผล)

writeln ('V =', V);

ขั้นตอน ค พารามิเตอร์

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

ขั้นตอน ค พารามิเตอร์

• ตัวแปรทั่วโลก

ตัวอย่าง .

โปรแกรม zadacha;

Var a, b: จำนวนเต็ม;

ขั้นตอนท้องถิ่น;

Var a, x: ถ่าน; สำหรับ ขั้นตอน ท้องถิ่น:

เริ่ม ตัวแปร NS - ตัวแปรท้องถิ่น

เป็น: = ’! '; (โปรแกรมไม่สามารถเปลี่ยนค่าได้)

ข: = ข +1; ตัวแปร NS - ตัวแปรทั่วโลก

จบ; (การเปลี่ยนแปลงทั้งหมดในค่าของตัวแปรนี้ในขั้นตอน

BEGIN จะถูกบันทึกหลังจากออกจากขั้นตอน)

ข: = 100; ตัวแปร NS ในโปรแกรมหลัก – ทั้งประเภท,

ท้องถิ่น; และในขั้นตอนนั้นเป็นประเภทอักขระ ตัวแปร a

writeln ('a =', ก); ไม่มีประเภทจำนวนเต็มในโพรซีเดอร์ท้องถิ่น

writeln ('b =', b);

ผลลัพธ์ของการทำงานของโปรแกรม: a = 0; ข = 101.

); เริ่ม; จบ; "ความกว้าง =" 640 "

ส่งพารามิเตอร์ไปที่ เทอร์โบ ปาสกาล

• 1. ผ่านพารามิเตอร์ตามค่า

• ค่าพารามิเตอร์ – ตัวแปรที่อธิบายหลังชื่อโพรซีเดอร์ในวงเล็บ ไม่มีคำบริการ Var ก่อนหน้าพวกเขา
• รูปแบบการบันทึก :

ขั้นตอน (:

ตัวแปร);

จบ ;

• พารามิเตอร์ที่เป็นทางการ .
• พารามิเตอร์จริง .

ตัวอย่าง .

พารามิเตอร์โปรแกรม

Var m, n: จำนวนเต็ม;

ผลรวมของกระบวนงาน (a, b: จำนวนเต็ม);

writeln ('S =', S);

ผลรวม (m, n); หรือผลรวม (100,10);

ตัวแปร NS และ NS เป็นพารามิเตอร์ที่เป็นทางการ และตัวแปร NS และ NS - แท้จริง. ค่าของพารามิเตอร์จริง NS = 100 และ NS = 10 ถูกส่งไปยังพารามิเตอร์ที่เป็นทางการ NS และ NS .

การเปลี่ยนแปลงพารามิเตอร์จริงจะเกิดขึ้นภายในโพรซีเดอร์เท่านั้น และไม่มีผลกับพารามิเตอร์ภายนอกโพรซีเดอร์นี้

; ตัวแปร Var :); เริ่ม; จบ; "ความกว้าง =" 640 "

ส่งพารามิเตอร์ไปที่ เทอร์โบ ปาสกาล

• 2. ส่งพารามิเตอร์ตามชื่อ

• พารามิเตอร์ตัวแปร – ตัวแปรที่อธิบายหลังชื่อโพรซีเดอร์ในวงเล็บและนำหน้าด้วยคำบริการ Var
• รูปแบบการบันทึก :

ขั้นตอน (:

ตัวแปร; วาร์

ตัวแปร :);

จบ ;

b แล้ว min: = b; ถ้า min c แล้ว min: = c; จบ; BEGIN writeln ('ป้อนสามตัวเลข'); readln (a1, b1, c1); writeln ('ป้อนสามตัวเลข'); readln (a2, b2, c2); ขั้นต่ำ (a1, b1, c1, min1); ขั้นต่ำ (a2, b2, c2, min2); S: = นาที1 + นาที 2; writeln ('S =', S); จบ. ตัวอย่าง. ให้เลขสามตัวสองจำนวน: a 1, b 1, c 1 และ a 2, b 2, c 2 ค้นหาค่าของผลรวม: S = นาที (a1, b1, c1) + นาที (a2, b2, c2) "ความกว้าง =" 640 "

Var a1, b1, c1, a2, b2, c2, min1, min2, S: จริง;

ขั้นตอนขั้นต่ำ (a, b, c: จริง; Var min: จริง);

ถ้า min b แล้ว min: = b;

ถ้า min c แล้ว min: = c;

writeln ('ป้อนสามตัวเลข');

readln (a1, b1, c1);

writeln ('ป้อนสามตัวเลข');

readln (a2, b2, c2);

ขั้นต่ำ (a1, b1, c1, min1);

ขั้นต่ำ (a2, b2, c2, min2);

S: = นาที1 + นาที 2;

writeln ('S =', S);

ตัวอย่าง... ให้เลขสามตัวสองจำนวน: a 1, b 1, c 1 และ a 2, b 2, c 2 ค้นหาค่าของผลรวม: S = นาที (a1, b1, c1) + นาที (a2, b2, c2)

การทำงานเป็นรูทีนย่อยซึ่งผลลัพธ์ที่ได้คือค่าบางอย่าง

• รูปแบบการบันทึก :

การทำงาน (:

จบ ;

• ในเนื้อความของฟังก์ชัน ชื่อของฟังก์ชันจะต้องกำหนดผลลัพธ์ของการดำเนินการ
• เมื่อเรียกใช้ฟังก์ชัน ชื่อของฟังก์ชันพร้อมรายการพารามิเตอร์จริงต้องรวมอยู่ในนิพจน์เป็นตัวถูกดำเนินการ

โปรแกรม vyrazenie;

โมดูลฟังก์ชัน (a: จริง): จริง;

writeln ('ป้อนค่าของตัวแปร');

y: = โมดูล (x-3) + โมดูล (x + 6);

writeln ('y =', y);

ตัวอย่าง . คำนวณค่าของนิพจน์: y = | x -3 | + | x +6 |

ชั้นประถมศึกษาปีที่ 8 การเขียนโปรแกรม ABC Pascal

ครูสารสนเทศ NIS Uralsk FMN Zelenov Boris Aleksandrovich

• นักเรียนใช้ขั้นตอนและฟังก์ชันในการแก้ปัญหา
• นักเรียนเรียนรู้ที่จะแก้ปัญหาใหญ่โดยแบ่งเป็นปัญหาย่อยๆ

• สร้างแนวคิดของขั้นตอนและฟังก์ชันในภาษาโปรแกรม

• นักเรียนรู้แนวคิดของ "ขั้นตอน" และ "หน้าที่" กำหนดพารามิเตอร์ที่เป็นทางการและเป็นจริง

ผลลัพธ์ที่คาดหวัง - คำอธิบาย:

1.รู้จักนิยามของ “ขั้นตอน”

2.รู้จักนิยามของ “หน้าที่”

3.กำหนดพารามิเตอร์จริงและเป็นทางการ

4.แยกแยะระหว่างค่าและพารามิเตอร์ตัวแปร

5. ค้นหาการเรียกโพรซีเดอร์หรือฟังก์ชันในรหัสโปรแกรม

แผนมาตรฐานของเอลวิรา

1. นำกระดาษออก

2. รดน้ำดอกไม้

3. ล้างโต๊ะ

4.เช็ดกระจก

จุดสิ้นสุดของอัลกอริทึม

เราจะปรับปรุงองค์กรของกระบวนการนี้ได้อย่างไร?

หัวข้อบทเรียน

รูทีนย่อย:

Ішкі baғdarlama

รูทีนย่อย

ขั้นตอน

ขั้นตอน

พารามิเตอร์

วลีที่เป็นประโยชน์:

ในการถ่ายโอนค่าของตัวแปรไปยังขั้นตอน (ฟังก์ชัน) จะใช้พารามิเตอร์จริง ...

เพื่ออธิบายขั้นตอน ก่อนอื่นควร ...., แล้วก็ ...

แนวคิดของรูทีนย่อย

คำนิยาม

รูทีนย่อยเป็นส่วนแยกการทำงานอิสระของโปรแกรม

รูทีนย่อย

ขั้นตอน

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

• วาดรั้วด้วยภาษาโปรแกรม

ในงานนี้ คุณสามารถสร้างขั้นตอนที่จะดำเนินการอัลกอริธึมสำหรับการวาดเศษส่วน (รั้วไม้) จากนั้นอ้างอิงขั้นตอนนี้อย่างต่อเนื่องโดยเปลี่ยนตำแหน่งเริ่มต้นของปากกา

• อธิบายวิธีดำเนินการวาดภาพต้นคริสต์มาสอย่างมีเหตุผลในสภาพแวดล้อมการเขียนโปรแกรม

• เป็นชิ้นส่วนของโปรแกรมที่เป็นอิสระ ออกแบบในลักษณะพิเศษและมีชื่อเป็นของตัวเอง

การโต้ตอบระหว่างโปรแกรมหลักและรูทีนย่อย

บล็อกไดอะแกรม

• Subroutine call block (ขั้นตอนหรือฟังก์ชัน)

ชื่อรูทีนย่อย (ขั้นตอนหรือฟังก์ชัน)

บล็อกไดอะแกรม

คำอธิบายของขั้นตอนมีดังนี้:

ขั้นตอนชื่อ (รายการพารามิเตอร์ที่เป็นทางการ); ส่วนคำอธิบาย เริ่มตัวดำเนินการ จบ ;

คำอธิบายฟังก์ชันมีลักษณะดังนี้:

การทำงานชื่อ (รายการพารามิเตอร์ที่เป็นทางการ): ประเภทการส่งคืน;

ส่วนคำอธิบาย เริ่มตัวดำเนินการ จบ ;

ตำแหน่งในโปรแกรม

โปรแกรม ...;

// คำอธิบายส่วน Uses, Const, Var, ...

ขั้นตอน NS ;

เริ่ม ....... จบ ;

ขั้นตอน NS ;

เริ่ม ........ จบ ;

ฟังก์ชัน C ;

เริ่ม ........ จบ ;

// โปรแกรมหลัก

เริ่ม ........ จบ .

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

ขั้นตอน

ฟังก์ชั่น

อาจมีผลลัพธ์หลายอย่างหรือดำเนินการบางอย่าง

มีผลลัพธ์เพียงรายการเดียว ซึ่งระบุประเภทแยกต่างหากเมื่อมีการประกาศฟังก์ชัน

ผลลัพธ์สามารถเป็นค่าประเภทใดก็ได้ อาร์เรย์ สตริง ตัวเลข ฯลฯ

ผลลัพธ์ต้องเป็นค่าประเภทจำนวนจริง จำนวนเต็ม หรืออักขระเท่านั้น

คำสั่งการเรียกขั้นตอนเป็นคำสั่งแยกต่างหากที่ใช้อย่างอิสระ

การเรียกใช้ฟังก์ชันสามารถใช้เป็นส่วนประกอบของนิพจน์ประเภทที่เหมาะสมเท่านั้น

เนื้อหาของฟังก์ชันต้องมีตัวดำเนินการกำหนดอย่างน้อยหนึ่งตัวที่มีชื่อของฟังก์ชันอยู่ทางด้านซ้าย

b แล้ว max: = อื่น max: = b; MaxNumber: = สูงสุด; ปลาย; "ความกว้าง =" 640 "

ขั้นตอนหรือหน้าที่?

MaxNumber (a, b: จำนวนเต็ม): จำนวนเต็ม;

var max: จำนวนเต็ม;

MaxNumber: = สูงสุด;

b แล้ว max: = อื่น max: = b; ปลาย; "ความกว้าง =" 640 "

ขั้นตอนหรือหน้าที่?

MaxNumber (a, b: จำนวนเต็ม; var max: จำนวนเต็ม);

ถ้า ab แล้ว max: = อย่างอื่น max: = b;

ขั้นตอนหรือหน้าที่?

ChangeColor (C1, C2: Word);

ข้อความพื้นหลัง (C2)

ขั้นตอนหรือหน้าที่?

เพิ่ม (X, Y: จำนวนเต็ม): จำนวนเต็ม;

ที่เกิดขึ้นจริง

• ระบุไว้ในส่วนของโปรแกรมหลัก

เป็นทางการ

• ระบุไว้ในรูทีนย่อย
• ระบุไว้ในรูทีนย่อย

โพรซีเดอร์ถูกเรียกโดยโอเปอเรเตอร์ด้วยรูปแบบต่อไปนี้:

ชื่อขั้นตอน (รายการพารามิเตอร์จริง);

• รายการพารามิเตอร์จริง- นี่คือรายการของพวกเขาคั่นด้วยเครื่องหมายจุลภาค

• ในมาตรฐานภาษาปาสกาล พารามิเตอร์สามารถส่งผ่านได้สองวิธี - โดยค่าและโดยการอ้างอิง พารามิเตอร์ที่ส่งผ่านเรียกว่าค่า ค่าพารามิเตอร์ผ่านลิงค์ - พารามิเตอร์ตัวแปร... สิ่งหลังต่างกันตรงที่คำว่าฟังก์ชัน var อยู่ข้างหน้าพวกเขาในส่วนหัวของขั้นตอน (ฟังก์ชัน)

ผ่านพารามิเตอร์ พารามิเตอร์ทางการ

ตัวแปร

ค่า

พารามิเตอร์ตามค่า

พารามิเตอร์ทางการ

ตัวแปร

พารามิเตอร์ทางการ

พารามิเตอร์ตามค่า

• ในวิธีแรก (ผ่านค่า) ค่าของพารามิเตอร์จริงจะถูกคัดลอกไปยังพารามิเตอร์ที่เป็นทางการที่สอดคล้องกัน

ขั้นตอน

ชื่อขั้นตอน (a, b: จำนวนเต็ม);

โปรแกรมหลัก

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

Var c, d: จำนวนเต็ม;

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

ขั้นตอน

ชื่อกระบวนงาน (a, b: จำนวนเต็ม, Var c: จริง);

โปรแกรมหลัก

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

ที่คุณเขียน:

1. พารามิเตอร์จริง ___________

ขั้นตอน Kvad (R: จริง var S: จริง);

2. พารามิเตอร์ทางการ ___________

3.ค่าพารามิเตอร์ทางการ __________

5.ชื่อขั้นตอน ___________

6.อ้างอิงขั้นตอนจากโปรแกรม _____________________

งานโต้ตอบ

http://www.bzfar.net/load/podprogrammy_procedury_i_funkcii_parametry/23-1-0-498

เอลวิราเป็นผู้นำชั้นเรียน เธอจะต้องจัดทำแผนสำหรับทำความสะอาดทั่วไปในชั้นเรียน: นำกระดาษออก รดน้ำดอกไม้ ล้างโต๊ะ เช็ดกระจก เธอจะจัดระเบียบงานของเธอให้ดีที่สุดได้อย่างไร? ช่วยเอลวิร่า

แผนขั้นสูงของเอลวิรา

รูทีนย่อย:

Arsen - เอาเอกสารออก

Mila - รดน้ำดอกไม้

Vitaly - ล้างโต๊ะ

อินทิรา - เช็ดกระจก

1. ดำเนินการ Arsen

2. เรียกใช้ Mila

3. ดำเนินการ Vitaly

4. ประหารอินทิรา

จุดสิ้นสุดของอัลกอริทึม

• โครงสร้างใหม่ของภาษาโปรแกรมที่เราพบในวันนี้คืออะไร?
• ตั้งชื่อพารามิเตอร์ที่เรียนรู้

• พารามิเตอร์ถูกส่งผ่านไปยังโพรซีเดอร์อย่างไร?

• สรุปบทเรียน

• ค้นหาคำจำกัดความ: "ตัวแปรท้องถิ่น" และ "ตัวแปรส่วนกลาง"

• สร้างงานสองงานซึ่งคุณสามารถใช้โพรซีเดอร์หรือฟังก์ชันได้

• คุณจะกำหนดหัวข้อของบทเรียนอย่างไร (มากับชื่อของคุณ)
• คุณคิดว่าคุณควรเรียนรู้อะไรในบทเรียนต่อไป

พบคุณ

ในบทเรียนต่อไป!

สไลด์ 1

สไลด์ 3

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

สไลด์ 4

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

สไลด์ 5

สไลด์ 6

คำอธิบายของขั้นตอนโปรแกรม P1; Const ... ประเภท ... Var ... ขั้นตอน (); ส่วนบรรยาย เริ่มต้น ขั้นตอน เนื้อหา สิ้นสุด; เริ่ม ... (); ... จบ. เมื่อเรียกโพรซีเดอร์ พารามิเตอร์ที่เป็นทางการจะถูกแทนที่ด้วยพารามิเตอร์จริง

สไลด์ 7

ขั้นตอนการคำนวณผลรวมของโปรแกรมตัวเลขสองตัว pr1; ใช้ crt; Var a, b, s: จริง; ผลรวมกระบวนงาน (x, y: จริง; var z: จริง); เริ่ม z: = x + y; จบ; เริ่ม clrscr; writeln ("ป้อน a, b"); readln (a, b); ผลรวม (a, b, s); writeln ("ผลรวมของตัวเลข", a: 3: 1, "และ", b: 3: 1, "=", s: 3: 1); อ่าน; จบ. x, y, z - พารามิเตอร์ที่เป็นทางการ, ตัวแปรท้องถิ่น a, b, s - ตัวแปรส่วนกลาง a, b, s - พารามิเตอร์จริง х y z a b s พารามิเตอร์ค่า พารามิเตอร์ตัวแปร

สไลด์ 8

สไลด์ 9

สไลด์ 10

ประเมินค่าของนิพจน์ a: = (3n! + 2m!) / (M + n)! ในการหาแฟกทอเรียล ควรใช้ตัวแปรประเภทใด โปรแกรม pr2; ใช้ crt; Var m, n, x, y, z: จำนวนเต็ม; เป็น: จริง; ข้อเท็จจริงของขั้นตอน (d: จำนวนเต็ม; var q: จำนวนเต็ม); var i: จำนวนเต็ม; เริ่ม q: = 1; สำหรับ i: = 1 ถึง d ทำ q: = q * i; จบ; เริ่ม clrscr; writeln ("ป้อนค่า n, m"); readln (n, m); ข้อเท็จจริง (n, x); ข้อเท็จจริง (ม, y); ข้อเท็จจริง (m + n, z); a: = (3 * x + 2 * y) / z; writeln ("ค่าของนิพจน์ที่ m =", m: 4, "and n =", n: 4, "equals", a: 8: 3); อ่าน; จบ. N! = 1 · 2 · 3 ·… · N

สไลด์ 11

อินพุตเอาต์พุตขององค์ประกอบของอาร์เรย์หนึ่งมิติ ฟังก์ชัน Random (X) จะสร้างตัวเลขสุ่มตั้งแต่ 0 ถึง X ของจำนวนเต็มหรือประเภทจริง หากไม่ได้ระบุพารามิเตอร์ X ผลลัพธ์จะเป็นประเภท Real ตั้งแต่ 0.0 ถึง 1.0 ในการรับอาร์เรย์ของจำนวนเต็มสุ่มจากช่วงสุ่ม (BA + 1) + A งาน: ดำเนินการอินพุตขององค์ประกอบของอาร์เรย์หนึ่งมิติโดยใช้ตัวสร้างตัวเลขสุ่ม (ช่วงของค่าตั้งแต่ -10 ถึง 20) และ ส่งออกองค์ประกอบเป็นขั้นตอน สำหรับ A = -10 B = 20 สุ่ม (20 - (- 10) +1) + (- 10)

สไลด์ 12

สไลด์ 13

สไลด์ 14

คำอธิบายของฟังก์ชัน ฟังก์ชันได้รับการออกแบบมาเพื่อคำนวณค่าเดียวเท่านั้น 1. ดังนั้นความแตกต่างประการแรกคือขั้นตอนสามารถมีค่าใหม่สำหรับพารามิเตอร์หลายตัว และฟังก์ชันสามารถมีได้เพียงค่าเดียว (นี่จะเป็นผลลัพธ์) 2. ข้อแตกต่างประการที่สองอยู่ในชื่อของฟังก์ชัน ประกอบด้วยคำว่า FUNCTION ตามด้วยชื่อของฟังก์ชัน จากนั้นในวงเล็บจะมีรายการพารามิเตอร์ที่เป็นทางการ หลังจากนั้น ประเภทของผลลัพธ์ของฟังก์ชันจะถูกเขียนโดยคั่นด้วยเครื่องหมายทวิภาค 3. เนื้อหาของฟังก์ชันต้องมีตัวดำเนินการกำหนดอย่างน้อยหนึ่งตัว โดยที่ชื่อของฟังก์ชันอยู่ทางซ้ายและค่าของฟังก์ชันอยู่ทางขวา ฟังก์ชัน (): ส่วนที่เป็นคำอธิบาย Begin Function body: =; จบ;

สไลด์ 15

ประเมินค่าของนิพจน์ a: = (3n! + 2m!) / (M + n)! โปรแกรม fn2; ใช้ crt; Var m, n: จำนวนเต็ม; เป็น: จริง; ฟังก์ชั่นข้อเท็จจริง (d: จำนวนเต็ม): longint; var i: จำนวนเต็ม; q: ลองจินต์; เริ่ม q: = 1; สำหรับ i: = 1 ถึง d ทำ q: = q * i; ข้อเท็จจริง: = q; จบ; เริ่ม clrscr; writeln ("ป้อนค่า n, m"); readln (n, m); a: = (3 * ข้อเท็จจริง (n) + 2 * ข้อเท็จจริง (ม.)) / ข้อเท็จจริง (ม + n) ;; writeln ("ค่าของนิพจน์ที่ m =", m: 4, "and n =", n: 4, "equals", a: 8: 3); อ่าน; จบ.

สไลด์ 16

สร้างโปรแกรมที่จะหา ab นั่นคือกำลัง b-th ของตัวเลข A โดยที่ A และ B เป็นจำนวนเต็มและ B> 0 ที่ป้อนจากแป้นพิมพ์ สร้างโปรแกรมโดยแทนที่ฟังก์ชันด้วยโพรซีเดอร์โปรแกรม pr2 ใช้ crt; Var a, b: จำนวนเต็ม; c: ลองจินต์; ฟังก์ชัน stepen (x, y: จำนวนเต็ม): longint; var i: จำนวนเต็ม; s: ลองจินต์; เริ่ม s: = 1; สำหรับ i: = 1 ถึง y ทำ s: = s * x; สตีเฟน: = s; จบ; เริ่ม clrscr; writeln ("ป้อนค่า a, b"); readln (a, b); C: = สตีเฟน (a, b); writeln ("s =", s); อ่าน; จบ.

สไลด์ 17

สไลด์ 18

กลไกการส่งค่าพารามิเตอร์ไปยังฟังก์ชันและขั้นตอน ขั้นตอนจะพิมพ์อะไรและโปรแกรมจะพิมพ์อะไร ตัวแปรโกลบอล ตัวแปรโลคัล a b 3 3 -3 Address c a b c 48 Address c A: = b + 3 B: = 3 * a C: = a + b State C 24 5 8 ตอบกลับ

สไลด์ 19

จุดประสงค์ของบทเรียน

เกี่ยวกับการศึกษา

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

เกี่ยวกับการศึกษา

• นำมาซึ่งความถูกต้อง, ความสนใจ, องค์กร;
• วัฒนธรรมของทักษะการใช้คอมพิวเตอร์

กำลังพัฒนา

• พัฒนาความคิดเชิงตรรกะ วัฒนธรรมอัลกอริธึมของนักเรียน
• พัฒนาความรู้และทักษะในการเขียนและแก้จุดบกพร่องของรูทีนย่อยในภาษาปาสกาล

นักเรียนจะต้อง:

• รู้กฎสำหรับการเขียนขั้นตอนโดยไม่มีพารามิเตอร์และพารามิเตอร์
• รู้กฎเกณฑ์ในการเขียนฟังก์ชัน
• สามารถใช้ขั้นตอนและฟังก์ชันในการแก้ปัญหาง่ายๆ ได้

ระหว่างเรียน

I. องค์กร ช่วงเวลา

ครั้งที่สอง บทนำ. ความเกี่ยวข้อง

ออกงานบนแผ่นกระดาษ ( ภาคผนวก 1 ). ค้นหารีเพลย์

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

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

รูทีนย่อยแบ่งออกเป็นโพรซีเดอร์และฟังก์ชัน

ขั้นตอนและฟังก์ชั่นในตัว (มาตรฐาน) คือ ส่วนหนึ่งภาษาและสามารถเรียกชื่อได้ โดยไม่มีคำอธิบายก่อนตัวอย่างเช่น , abs, sqrt, ln, sin ... - ฟังก์ชั่น (ส่งคืนผลลัพธ์), readln, เขียน ... - ขั้นตอน (ไม่ส่งคืนผลลัพธ์) การปรากฏตัวของพวกเขาอำนวยความสะดวกอย่างมากในการพัฒนาโปรแกรมแอปพลิเคชัน อย่างไรก็ตาม ในกรณีส่วนใหญ่ เฉพาะเจาะจงการดำเนินการสำหรับโปรแกรมนี้ไม่พบแอนะล็อกโดยตรงในไลบรารี Turbo Pascal จากนั้นโปรแกรมเมอร์ต้องพัฒนาตัวเอง ไม่ได้มาตรฐานขั้นตอนและหน้าที่

สาม. คำอธิบายของวัสดุใหม่

มีการเขียนขั้นตอนผู้ใช้ ด้วยตัวเองโปรแกรมเมอร์ตามไวยากรณ์ของภาษาใน ส่วนคำอธิบายรูทีนย่อย

โครงสร้างของขั้นตอนจะทำซ้ำโครงสร้างของโปรแกรม มันคือ "โปรแกรมย่อส่วน" - มันถูกแสดงโดยส่วนหัวและเนื้อหาด้วย

ส่วนหัวประกอบด้วยคำสงวนขั้นตอน, ตัวระบุ (ชื่อ)ขั้นตอน

VAR ... // ส่วนอธิบายตัวแปรของโปรแกรมหลัก

ขั้นตอน ชื่อขั้นตอน;

// ตัวโปรแกรมหลัก

มีการบันทึกการเรียกขั้นตอนสำหรับการดำเนินการในภายหลัง ในเนื้อหาของโปรแกรมหลัก

ตัวอย่างที่ 1 โปรแกรมคำนวณพื้นที่และปริมณฑล

ข้อดีของรูทีนย่อย:

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

ตัวอย่างที่ 2 ผู้ใช้ป้อนทั้งสองด้านของสี่เหลี่ยมทั้งสาม แสดงพื้นที่ของพวกเขา

คุณสามารถแก้ปัญหาได้ดังนี้:

สำหรับ i: = 1 ถึง 3 do

writeln ('ป้อน a และ b:');

writeln ('พื้นที่ =', a * b);

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

การคำนวณ

การคำนวณ

การคำนวณ

ขั้นตอนข้อความมีอยู่แล้ว (ดูตัวอย่างที่ 1) มาสร้างขั้นตอนที่สองที่คำนวณพื้นที่กัน แต่ในการคำนวณ S คุณต้องรู้ 2 ด้าน ดังนั้นขั้นตอนต้องแสดงว่าด้านไหนควรคูณ

ขั้นตอน pl (c, d: จำนวนเต็ม);

writeln ('พื้นที่ของสี่เหลี่ยมผืนผ้าที่มีด้าน', c, '', d, '=', S);

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

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

พารามิเตอร์จริงต้องเหมือนกันในประเภทและปริมาณกับพารามิเตอร์ที่เป็นทางการ

ดังนั้นโปรแกรมหลัก:

สำหรับ i: = 1 ถึง 3 do

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

มาเขียนขั้นตอนการตรวจสอบกัน:

ข้อผิดพลาดของขั้นตอน (f, g: จำนวนเต็ม);

ถ้า (f<0) or (g<0) then begin

writeln ('ด้านของสี่เหลี่ยมผืนผ้าไม่สามารถเป็นค่าลบได้');

หยุด; // การหยุดชะงักของโปรแกรม

โปรแกรมสุดท้าย - ภาคผนวก 4

ดังนั้นรูปแบบของขั้นตอน:

ขั้นตอน<имя>(พารามิเตอร์ทางการ);

<операторы>;

ตัวอย่างที่ 3 ทำโปรแกรมแลกเปลี่ยนตำแหน่งสองตัวเลขด้วย = 5 และ d = 7

โปรแกรม obmenDan;

var c, d: จำนวนเต็ม;

ขั้นตอน obmen (a, b: จำนวนเต็ม);

ม: = ก; ก: = ข; ข: = ม;

writeln ("ป้อน 2 หมายเลข:");

writeln (c, "", d);

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

1) เมื่อเรียกโพรซีเดอร์ obmen ด้วยสองพารามิเตอร์ 5 และ 7 ตัวเลข 5 และ 7 จะถูกวางไว้ในตัวแปร a และ b ตามลำดับ:

3) แต่ในตัวแปร c และ d ข้อมูลไม่เปลี่ยนแปลง ตั้งแต่ พวกเขาอยู่ในตำแหน่งหน่วยความจำอื่น

สำหรับตัวแปร c และ d, a และ b อ้างถึงตำแหน่งหน่วยความจำเดียวกัน (หากค่าของ a และ b เปลี่ยนไป ค่าของทั้งสอง c, d จะเปลี่ยนไป) เมื่ออธิบายพารามิเตอร์ที่เป็นทางการ ให้เพิ่มคำว่า VAR ก่อนตัวแปรที่ต้องการ:

ขั้นตอน obmen (var a, b: จำนวนเต็ม);

แก้ไขโปรแกรม obmenDan:

เกิดข้อผิดพลาดเนื่องจาก var ตัวเลขเป็นค่าคงที่ที่ไม่สามารถเปลี่ยนแปลงได้ในโพรซีเดอร์

ตัวอย่างที่ 4 ค้นหาพื้นที่ของวงกลมโดยใช้ขั้นตอนที่คำนวณแต่ไม่แสดงผลบนหน้าจอ

วงกลมขั้นตอน (r: จริง);

ขั้นตอนควรส่งคืนผลลัพธ์:

วงกลมขั้นตอน (r: จริง; var S: จริง);

readln (a, e);

ความคิดเห็น:ตัวแปรในโพรซีเดอร์ S ใช้เพื่อส่งคืนผลลัพธ์ของโพรซีเดอร์ไปยังโปรแกรมหลัก เมื่อมีการเปลี่ยนแปลง พารามิเตอร์จริงในโปรแกรมการเรียกก็จะเปลี่ยนไปเช่นกัน กล่าวคือ ตัวแปร จ.

บ่อยครั้ง สำหรับสิ่งนี้ในภาษา Pascal แทนที่จะใช้โพรซีเดอร์ ฟังก์ชันถูกใช้ (รูทีนย่อยที่ส่งคืนบางสิ่ง)

ฟังก์ชันเหมือนกับขั้นตอน แต่มีความแตกต่างสองประการ

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

ตัวอย่างเช่น sqr (x) - จะยกกำลังสองค่าของ x และส่งกลับค่าที่คำนวณได้ของกำลังสองของตัวเลข x ไปยังจุดเรียก: y: = sqr (x);

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

การทำงาน<имя>(พารามิเตอร์ทางการ):<тип результата>;

<операторы>;

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

ตัวอย่างที่ 5 มาทำโจทย์เกี่ยวกับพื้นที่วงกลมอีกครั้ง.

วงกลมฟังก์ชัน (r: จริง): จริง;

a: = วงกลม (5); (มอบหมายบังคับ)

ตัวอย่างที่ 6 หา 1! +2! +… + N!

เราใช้ฟังก์ชันในการหาแฟกทอเรียล เพราะเราให้มันกับอินพุตและได้ผลลัพธ์

ฟังก์ชันข้อเท็จจริง (a: integer): integer;

สำหรับฉัน: = 1 ถึง do

ในบรรทัดข้อเท็จจริง: = ข้อเท็จจริง * I;

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

โปรแกรมแฟคทอเรียล

var sum, n, j: จำนวนเต็ม;

ฟังก์ชันข้อเท็จจริง (a: integer): integer;

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

สำหรับฉัน: = 1 ถึง do

สำหรับ j: = 1 ถึง n do

ผลรวม: = ผลรวม + ความจริง (j);

IV. สรุปบทเรียน

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

V. การบ้าน

แก้งาน (เป็นลายลักษณ์อักษร):

1. เขียนขั้นตอนที่แทนที่ตัวอักษรทั้งหมด a ด้วย * ในสตริงที่ป้อน
2. สองประโยคจะได้รับ ค้นหาจำนวนตัวอักษร "n" ทั้งหมด (กำหนดฟังก์ชันเพื่อคำนวณจำนวนตัวอักษร "n" ในประโยค)