การเรียกซ้ำในภาษาปาสคาลอาจารย์ : Tlekhurai Yu.V. สถาบันการศึกษาเทศบาล "สถานศึกษาที่ 8" คุณเห็นอะไรในภาพเขียน? ปรากฏการณ์ทางศิลปะนี้เรียกว่า การเรียกซ้ำ “เพื่อที่จะเข้าใจการเรียกซ้ำ คุณต้องเข้าใจการเรียกซ้ำก่อน” การเรียกซ้ำ - คำจำกัดความบางส่วนของวัตถุผ่านตัวมันเอง คำจำกัดความของวัตถุโดยใช้วัตถุที่กำหนดไว้ก่อนหน้านี้ พูดตามหลักวิทยาศาสตร์: การเรียกซ้ำ - วิธีการกำหนดคลาสของอ็อบเจ็กต์หรือเมธอดโดยการระบุกรณีหรือเมธอดพื้นฐานตั้งแต่หนึ่งกรณีขึ้นไป (โดยปกติจะเป็นแบบง่าย) จากนั้นระบุกฎเกณฑ์สำหรับการสร้างคลาสที่ถูกกำหนดไว้บนพื้นฐาน ปีเตอร์ ดอยช์ ปีเตอร์ ดอยช์

การทำซ้ำของมนุษย์

การเรียกซ้ำมาจากพระเจ้า

การเรียกซ้ำในวิชาฟิสิกส์การเรียกซ้ำในภาษาและวรรณคดี ตัวอย่างคลาสสิกของการเรียกซ้ำแบบไม่สิ้นสุดคือ กระจกสองบานวางตรงข้ามกัน: ทางเดินสองแห่งก่อตัวขึ้นจากแสงสะท้อนของกระจกที่จางหายไป อีกตัวอย่างหนึ่งของการเรียกซ้ำแบบไม่สิ้นสุดก็คือ ผลการกระตุ้นตนเอง (เชิงบวก ข้อเสนอแนะ) ย วงจรอิเล็กทรอนิกส์ได้รับเมื่อสัญญาณจากเอาต์พุตไปถึงอินพุตจะถูกขยายอีกครั้งถึงอินพุตของวงจรและถูกขยายอีกครั้ง แอมพลิฟายเออร์ที่โหมดการทำงานนี้เป็นมาตรฐานเรียกว่าออสซิลเลเตอร์ในตัว ตัวอย่างของรายการพจนานุกรมแบบเรียกซ้ำ: “The Priest has a dog...” - การเรียกซ้ำทั่วไป เรื่องราวหลายเรื่องของ Stanislaw Lem อุทิศให้กับเหตุการณ์ที่มีการเรียกซ้ำอย่างไม่สิ้นสุด: เรื่องราวเกี่ยวกับสุสาน (“The Star Diaries of John the Quiet”) ซึ่งพระเอกย้ายจากบทความเกี่ยวกับสุสานไปยังบทความเกี่ยวกับการแยกศพอย่างต่อเนื่อง จากที่นั่นไปยังบทความเกี่ยวกับสุสานซึ่งมีการอ้างอิงถึงบทความ " sepulcaria" อีกครั้ง เรื่องราวเกี่ยวกับเครื่องจักรอัจฉริยะที่มีความฉลาดและความเกียจคร้านเพียงพอที่จะสร้างเครื่องจักรที่คล้ายกันเพื่อแก้ไขปัญหาที่กำหนดและมอบความไว้วางใจในการแก้ปัญหา (ผลลัพธ์คือการเรียกซ้ำไม่สิ้นสุดเมื่อแต่ละ รถใหม่สร้างแบบเดียวกับตัวเธอเองและมอบงานให้เธอ) การเรียกซ้ำในการเขียนโปรแกรมเป็นวิธีการจัดระเบียบกระบวนการคำนวณซึ่งขั้นตอนหรือฟังก์ชันอ้างอิงถึงตัวเองในระหว่างการดำเนินการของตัวดำเนินการที่เป็นส่วนประกอบ เพื่อให้การเรียกดังกล่าวไม่สิ้นสุด ข้อความของรูทีนย่อยจะต้องมีเงื่อนไขเมื่อไปถึง ซึ่งไม่มีการเรียกใด ๆ เกิดขึ้นอีก ดังนั้นการเรียกซ้ำสามารถรวมไว้ในสาขาใดสาขาหนึ่งของรูทีนย่อยเท่านั้น ตัวอย่าง. การคำนวณแฟกทอเรียลของจำนวนธรรมชาติ สร้างฟังก์ชันแบบเรียกซ้ำที่คำนวณแฟกทอเรียลของจำนวน n ดังนี้ ฟังก์ชัน f (n: จำนวนเต็ม): longint; เริ่มต้นถ้า n = 1 แล้ว f:= 1 อื่น f:= n * f(n -1); (ฟังก์ชัน f เรียกตัวเอง)จบโปรแกรม Pascal โดยใช้การเรียกซ้ำ: Var n: integer; a: ลองจินต์; ฟังก์ชันแฟกทอเรียล (n: จำนวนเต็ม): longint; เริ่มต้นถ้า n = 1 แล้วแฟกทอเรียล:= 1 อย่างอื่นแฟกทอเรียล:= n * แฟกทอเรียล (n -1); จบ; เริ่มเขียน('n='); อ่าน(n); A:= แฟกทอเรียล (n); เขียน('n!=',a); อ่าน; จบ. เลโอนาร์โดแห่งปิซา ฟีโบนัชชี

ตัวเลขฟีโบนัชชีเป็นองค์ประกอบของลำดับตัวเลข

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ... โดยแต่ละหมายเลขที่ตามมาจะเท่ากับผลรวมของสองตัวก่อนหน้า

ภารกิจ: แสดงชุดตัวเลขฟีโบนัชชีที่ประกอบด้วยองค์ประกอบ n ตัว คำอธิบายของตัวแปร: n – จำนวนองค์ประกอบของอนุกรม; a, b – ค่าของสององค์ประกอบสุดท้ายของอนุกรม; c – ตัวแปรบัฟเฟอร์ (“สำรอง”); ฉัน – เคาน์เตอร์ อัลกอริทึมสำหรับการแก้ปัญหา: 1. รับค่าของ n 2. กำหนดค่า 0 และ 1 ให้กับ a และ b ตามลำดับ (นี่คือตัวเลขแรกของชุดฟีโบนัชชี) แสดงไว้บนหน้าจอ 3. เริ่มต้นจากองค์ประกอบที่ 3 ถึง n: a) แสดงผลรวมของ a และ b, b) เก็บค่าของตัวแปร b ใน c, c) เขียนผลรวมของ a และ b ถึง b, d) กำหนดค่าของ ค. โปรแกรม Pascal โดยใช้การวนซ้ำ: โปรแกรมฟีโบนัชชี; var a,b,c,i,n: จำนวนเต็ม; เริ่ม เขียน("n = "); อ่าน(n); ก:= 0; เขียน," "); ข:= 1; เขียน(ข," "); สำหรับ i:=3 ถึง n จะเริ่มต้น เขียน(a+b," "); ค:=ข; ข:= ก + ข; ก:=ค; จบ; อ่าน; จบ. โปรแกรมปาสคาลใช้การเรียกซ้ำ:คำจำกัดความแบบเรียกซ้ำสำหรับการคำนวณตัวเลขฟีโบนัชชีมีดังต่อไปนี้: คำจำกัดความของตัวเลขฟีโบนักชีนี้สามารถแปลงเป็นฟังก์ชันแบบเรียกซ้ำได้อย่างง่ายดาย: function f(n: Integer) : longint; เริ่มต้น ถ้า n<= 1 Then f:= n else f:= f(n– 1) + f(n - 2); end; Program chislaFibonacci; var n,i: integer; a: longint; function fib (n: integer): longint; begin If n <= 1 Then fib:= n else fib:= fib(n– 1) + fib(n - 2); End; begin write(‘n=’); readln(n); for i:=0 to n do begin A:= fib (n); write (‘ ’,a); end; readln; end. Домашнее задание Написать программу нахождения НОД двух натуральных чисел, используя алгоритм Евклида и рекурсию Даны два натуральных числа กและ ข.ถ้า ก= ขจากนั้นโหนด ( ก,ข)=ก.ถ้า ก>ขจากนั้นโหนด ( ก,ข)=โหนด ( ก -ข,ข)ถ้า ก< ขจากนั้นโหนด ( ก,ข)=โหนด ( ก,ข-ก) โปรแกรม noddvyxchisel; var a,b: ยาว; ฟังก์ชั่น nod(a,b:longint): longint; เริ่มต้น ถ้า a = b แล้วก็พยักหน้า:= a else ถ้า a>b แล้วก็พยักหน้า:= nod(a-b,b) else พยักหน้า:= nod(a,b-a) สิ้นสุด; เริ่มเขียน('a='); อ่าน(a); เขียน('b='); อ่าน(b); A:= พยักหน้า(a,b); เขียน('nod=',a); อ่าน; จบ. ปัญหาเกี่ยวกับหอคอยแห่งฮานอย ในกรณีนี้ต้องปฏิบัติตามกฎต่อไปนี้อย่างเคร่งครัด:

• คุณสามารถย้ายดิสก์ได้ครั้งละหนึ่งดิสก์เท่านั้น
• ไม่สามารถวางดิสก์ขนาดใหญ่กว่าได้ ดิสก์ขนาดเล็ก;
• ดิสก์ที่ถูกถอดออกจะต้องใส่หมุดใดๆ ก่อนที่ดิสก์อื่นจะถูกถอดออก
พระภิกษุผู้ขยันหมั่นเพียรจะถือจานจากยอดหนึ่งไปยังอีกยอดหนึ่งทั้งกลางวันและกลางคืน ตำนานเล่าว่าเมื่อพระภิกษุทำงานเสร็จ วันสิ้นโลกก็มาถึง เราสามารถคำนวณได้ว่าการแก้ปัญหาด้วยดิสก์ 64 แผ่นจะต้องมีการเคลื่อนไหว 264–1 ครั้ง ดังนั้น สำหรับการสิ้นสุดของโลก มันจะเกิดขึ้นหลังจากห้าพันล้านศตวรรษ ถ้าเราพิจารณาว่าดิสก์หนึ่งแผ่นเคลื่อนที่ในหนึ่งวินาที อย่างไรก็ตาม ทั้งปัญหาและตำนานของปัญหานี้ถูกประดิษฐ์ขึ้นในปี พ.ศ. 2426 โดยนักคณิตศาสตร์ เอดูอาร์ด ลูคัส จากวิทยาลัยแซงต์-หลุยส์

ยอดแหลมเพชรหนึ่งในสามยอดนั้นมีแผ่นทองคำกลม 64 แผ่น จานเบรกมีรัศมีที่แตกต่างกันและตั้งอยู่บนยอดแหลมโดยเรียงรัศมีจากมากไปหาน้อยจากฐานถึงด้านบน จำเป็นต้องย้ายดิสก์จากสไปร์แรกไปยังสไปร์ที่สอง โดยใช้สไปร์ที่สามหากจำเป็น

งาน. สร้างโปรแกรมแบบเรียกซ้ำที่จะแก้ปัญหาด้านบนเกี่ยวกับหอคอยฮานอยด้วยจำนวนดิสก์เท่ากับ n (n = 1, 2, ...) สารละลาย. มากรอกชื่อยอดแหลมกัน: ก ข ค. อนุญาต ฮานอย(n,a,b,c)- ฟังก์ชั่นที่จำเป็นที่ส่งคืนลำดับการเคลื่อนไหวของดิสก์ด้วย กบน ขโดยใช้ คตามกฎที่อธิบายไว้ข้างต้น เมื่อ n=1 เรารู้วิธีการแก้ปัญหา คุณเพียงแค่ต้องดำเนินการ "ย้าย" กบน ข" สมมติว่าเราสามารถแก้ไขปัญหานี้สำหรับดิสก์ n – 1 ได้ ย้ายดิสก์ n–1 จาก กบน กับ. จากนั้นให้ย้ายดิสก์ที่เหลือหนึ่งแผ่นจาก กบน ขและในที่สุดก็ย้ายดิสก์ n–1 จาก คบน ข. ป้อนข้อมูล: จำนวนแผ่นดิสก์บนหมุด a; เอาท์พุต: ลำดับ; Step0:(กำหนดประเภทตัวแปร); ขั้นตอนที่ 1: (คำอธิบายขั้นตอนฮานอยซึ่งแสดงลำดับการดำเนินการ); ขั้นตอนที่ 1.1:(ย้าย (n-1) ดิสก์จาก peg a ไปยัง peg b); ขั้นตอนที่ 1.2:(ย้ายดิสก์ที่ n จาก a ไปยัง c); ขั้นตอนที่ 1.3:(ย้าย (n-1) ดิสก์จาก b ไปยัง c); (ขั้นตอนที่ 1.2-1.3 ดำเนินการซ้ำ); Step2:(โปรแกรมหลัก); ขั้นตอนที่ 2.1:(ใส่จำนวนดิสก์); ขั้นตอนที่ 2.2: (เรียกขั้นตอนฮานอย) การแก้ปัญหาในโปรแกรม Pascal bahnya; var n: จำนวนเต็ม; ก,ข,ค: ถ่าน; ขั้นตอนฮานอย (n: จำนวนเต็ม; a, b, c: char); เริ่มต้นถ้า n>0 แล้วเริ่มต้น hanoi(n-1,a,c,b); writeln ("ดิสก์ Peremestit ดังนั้น sterzhnya ",a," na sterzhen" ",b); ฮานอย(n-1,c,b,a); ปลาย; ปลาย; เริ่มเขียน ("Vvedite naturalnoe chislo n"); readln ( n); a:="a"; b:="b"; c:="c"; hanoi (n,a,c,b); readln; end. การบ้าน เขียนโปรแกรมคำนวณปริญญาแบบธรรมชาติ เลขชี้กำลังที่กำหนด: ฐานระดับ เอ็กซ์เลขชี้กำลัง ถึง ถ้า k=0 แล้ว องศา(k,x)=1 มิฉะนั้น องศา(k,x)= x· องศา(k-1,x) โปรแกรม stepen; var y: จริง; n:จำนวนเต็ม; ขั้นตอนฟังก์ชัน (k: จำนวนเต็ม, x: จริง): จริง; เริ่มต้น ถ้า k = 0 จากนั้น ขั้นตอน:= 1 ขั้นตอนอื่น:= x * ขั้นตอน(k-1,x) สิ้นสุด; เริ่มเขียน ('vvedite osnovanie stepeni x='); อ่าน(y); write('vvedite pokazatel stepeni k='); อ่าน(n); write('x v stepeni k=',ขั้นตอน(n,y)); อ่าน; จบ. ทำงานอิสระ

• ค้นหาผลรวมของตัวเลข
• พิจารณาว่าจำนวนธรรมชาติที่กำหนดเป็นจำนวนเฉพาะหรือไม่
• ค้นหาหลักแรกของตัวเลข
• แปลงจำนวนธรรมชาติจาก s.s. ทศนิยม ถึงไบนารี
• ค้นหาผลรวมขององค์ประกอบของอาร์เรย์จำนวนเต็มซึ่งประกอบด้วย 20 องค์ประกอบ
• สลับค่าของจำนวนเต็มสองตัว
• จัดลำดับค่าของตัวแปรทั้งสาม ก ข คตามลำดับจากน้อยไปหามาก
• ค้นหาจำนวนหลักใน จำนวนธรรมชาติ n
• ค้นหาตัวเลขที่ใหญ่ที่สุดจากสามจำนวนที่กำหนด
• ค้นหาจำนวนจำนวนบวกระหว่างสี่ A, B, C, D

คำตอบสำหรับงานอิสระหมายเลข 2 โปรแกรมง่ายๆ var n, m, s: จำนวนเต็ม; ฟังก์ชั่น prost (m, n: จำนวนเต็ม): บูลีน; เริ่มต้น ถ้า n = m จากนั้น prost:= true อย่างอื่น prost:= (n mod m<>0) และต่อมลูกหมาก (m+1, n); จบ; เริ่มเขียน('n='); อ่าน(n); ม:=2; ถ้า prost(m,n) ให้เขียน (n,’prostoechislo’) หรือเขียนอย่างอื่น (n,’sostavnoe’); อ่าน; จบ.

การแปลโปรแกรม

ขั้นตอนดีวีดี (n: longint);

ถ้า n >1 ดังนั้น dvd (n div 2);

เขียน (n mod 2);

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

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

ขั้นตอนและฟังก์ชัน มีรูทีนย่อยอยู่ 2 ประเภทใน Pascal: ขั้นตอน (PROCEDURE) และฟังก์ชัน (FUNCTION) ขั้นตอนและฟังก์ชันใน Pascal ได้รับการประกาศไว้ในส่วนการประกาศที่อยู่ด้านหลังส่วนตัวแปร โปรแกรมชื่อโปรแกรม; VAR ... // ส่วนสำหรับอธิบายตัวแปรของโปรแกรมหลัก ขั้นตอน ชื่อขั้นตอน; var ... start ...// ส่วนท้ายของขั้นตอน; start //เนื้อความของโปรแกรมหลักสิ้นสุด

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

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

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

ตัวอย่างที่ 2 สร้างโปรแกรมสำหรับสลับตัวเลขสองตัว c=5 และ d=7 โปรแกรม obmenDan var c,d:จำนวนเต็ม; การแลกเปลี่ยนขั้นตอน (a,b:จำนวนเต็ม); var m:จำนวนเต็ม; เริ่มต้น ม.:=a; ก:=ข; ข:=ม; writeln(ก,ข); จบ; start writeln("ใส่ตัวเลข 2 ตัว: "); อ่าน(c,d); แลกเปลี่ยน(c,d); writeln(c," ",d); จบ. c5 d 7 a 5 b 7 1) เมื่อเรียกโพรซีเดอร์ obmen ด้วยพารามิเตอร์สองตัว 5 และ 7 หมายเลข 5 และ 7 เดียวกันจะถูกวางไว้ในตัวแปร a และ b ตามลำดับ: 2) จากนั้นในขั้นตอนค่าของเซลล์หน่วยความจำ a และ b ถูกจัดเรียงใหม่: c5 d 7 a 7 b 5 3) แต่ในตัวแปร c และ d ข้อมูลไม่เปลี่ยนแปลงเพราะ พวกมันอยู่ในเซลล์หน่วยความจำอื่น

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

ตัวอย่างที่ 3 กำหนดให้อาร์เรย์จำนวนเต็มต่างกัน 3 อาร์เรย์ (ขนาดของแต่ละอาร์เรย์ไม่เกิน 15) ในแต่ละอาร์เรย์ ให้ค้นหาผลรวมขององค์ประกอบและค่าเฉลี่ยเลขคณิต โปรแกรม proc; var i, n, sum: จำนวนเต็ม; sr: จริง; ขั้นตอนการทำงานของ (r:integer; var s:integer; var s1:real); var mas: อาร์เรย์ของจำนวนเต็ม ; เจ:จำนวนเต็ม; เริ่มต้น s:=0; สำหรับ j:=1 ถึง r เริ่มอ่าน (mas[j]); s:=s+mas [เจ]; จบ; s1:=s/r; จบ;

(โปรแกรมหลัก) เริ่มต้นสำหรับ i:=1 ถึง 3 เริ่มเขียน ("Vvedite razmer",i, "masiva: "); อ่าน(n); งาน(n, ผลรวม, sr); (งานขั้นตอนการโทร) writeln ("Summa elementov = ",sum); writeln("Srednearifmeticheskoe = ",sr:4:1); จบ; จบ.

ผลลัพธ์ของโปรแกรม: โปรแกรมเรียกขั้นตอนการทำงานสามครั้ง ซึ่งตัวแปรทางการ r, s, s1 จะถูกแทนที่ด้วยค่า n, sum, sr ที่แท้จริง ขั้นตอนป้อนองค์ประกอบอาร์เรย์ คำนวณผลรวมและค่าเฉลี่ย ตัวแปร s และ s1 จะถูกส่งกลับไปยังโปรแกรมหลัก ดังนั้นคำว่าบริการ var จะถูกวางไว้หน้าคำอธิบาย พารามิเตอร์เฉพาะที่ mas, j ใช้ได้เฉพาะในขั้นตอนเท่านั้น Global - i, n, sum, sr มีให้ตลอดโปรแกรม

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

ตัวอย่างที่ 4 เขียนฟังก์ชันรูทีนย่อยระดับ a x โดยที่ a, x เป็นตัวเลขใดๆ ลองใช้สูตร: a x = e x ln โปรแกรม p2; var f, b, s, t, c, d: จริง; (ตัวแปรโกลบอล) ฟังก์ชั่น stp (a, x: real) : real; var y: จริง; (ตัวแปรท้องถิ่น) เริ่มต้น y:= exp (x * ln (a)) ; stp:= y;(การกำหนดชื่อฟังก์ชันให้กับผลลัพธ์ของการคำนวณรูทีนย่อย) สิ้นสุด; (คำอธิบายฟังก์ชันเสร็จสมบูรณ์) เริ่มต้น d:= stp (2.4, 5); (การคำนวณกำลังของตัวเลขและตัวแปรต่างๆ) writeln (d, stp (5,3.5)); อ่าน(f, b, s, t); c:= stp (f, s)+stp (b, t); เขียน(c); จบ.

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

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

1 ฟังก์ชัน f (n: จำนวนเต็ม): จำนวนเต็ม; เริ่มต้นถ้า n = 1 แล้ว f:= 1 อื่น f:= n * f (n -1); (ฟังก์ชัน f เรียกตัวเองว่า" title="Example 5. สร้างฟังก์ชันแบบเรียกซ้ำที่คำนวณแฟกทอเรียลของจำนวน n ดังนี้: n! = 1 ถ้า n= 1 n!= (n -1)! · n ถ้า n > 1 ฟังก์ชัน f (n: integer): จำนวนเต็ม; เริ่มถ้า n = 1 แล้ว f:= 1 อย่างอื่น f:= n * f (n -1); (ฟังก์ชัน f เรียกตัวเองว่า" class="link_thumb"> 19 !}ตัวอย่างที่ 5 สร้างฟังก์ชันแบบเรียกซ้ำที่คำนวณแฟกทอเรียลของจำนวน n ดังนี้: n! = 1 ถ้า n= 1 n!= (n -1)! · n ถ้า n > 1 ฟังก์ชัน f (n: จำนวนเต็ม): จำนวนเต็ม; เริ่มต้นถ้า n = 1 แล้ว f:= 1 อื่น f:= n * f (n -1); (ฟังก์ชัน f เรียกตัวเอง) สิ้นสุด; 1 ฟังก์ชัน f (n: จำนวนเต็ม): จำนวนเต็ม; เริ่มต้นถ้า n = 1 แล้ว f:= 1 อื่น f:= n * f (n -1); (ฟังก์ชั่น f เรียกตัวเอง"> 1 ฟังก์ชั่น f (n: จำนวนเต็ม): จำนวนเต็ม; เริ่มต้นถ้า n = 1 แล้ว f:= 1 อย่างอื่น f:= n * f (n -1); (ฟังก์ชัน f เรียกตัวเอง) สิ้นสุด; " > 1 ฟังก์ชัน f (n: integer): จำนวนเต็ม; เริ่มต้นถ้า n = 1 แล้ว f:= 1 อย่างอื่น f:= n * f (n -1); (ฟังก์ชัน f เรียกตัวเองว่า" title="Example 5 สร้างฟังก์ชันแบบเรียกซ้ำที่คำนวณแฟกทอเรียลของจำนวน n ดังนี้: n! = 1, ถ้า n= 1 n!= (n -1)! n, ถ้า n > 1 ฟังก์ชัน f (n: จำนวนเต็ม): จำนวนเต็ม; เริ่มต้นถ้า n = 1 แล้ว f:= 1 อย่างอื่น f:= n * f (n -1); (ฟังก์ชัน f เรียกตัวเองว่า"> title="ตัวอย่างที่ 5 สร้างฟังก์ชันแบบเรียกซ้ำที่คำนวณแฟกทอเรียลของจำนวน n ดังนี้: n! = 1 ถ้า n= 1 n!= (n -1)! · n ถ้า n > 1 ฟังก์ชัน f (n: จำนวนเต็ม): จำนวนเต็ม; เริ่มต้นถ้า n = 1 แล้ว f:= 1 อื่น f:= n * f (n -1); (ฟังก์ชัน f เรียกตัวเอง"> !}

สไลด์ 1

สไลด์ 3

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

สไลด์ 4

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

สไลด์ 5

สไลด์ 6

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

สไลด์ 7

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

สไลด์ 8

สไลด์ 9

สไลด์ 10

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

สไลด์ 11

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

สไลด์ 12

สไลด์ 13

สไลด์ 14

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

สไลด์ 15

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

สไลด์ 16

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

สไลด์ 17

สไลด์ 18

กลไกในการส่งพารามิเตอร์ไปยังฟังก์ชันและโพรซีเดอร์ จะพิมพ์อะไรโดยโพรซีเดอร์ และอะไรจะพิมพ์โดยโปรแกรม ตัวแปรร่วม ตัวแปรเฉพาะที่ a b 3 3 -3 ที่อยู่ c a b c 48 ที่อยู่ c A:=b+3 B:=3*a C:=a+b สถานะ C 24 5 8 ตอบกลับ

สไลด์ 19

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

ครูสารสนเทศของ NIS ของ Uralsk ฟิสิกส์และคณิตศาสตร์ Zelenov Boris Aleksandrovich

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

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

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

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

1.รู้ความหมายของ “ขั้นตอน”

2.รู้ความหมายของ “ฟังก์ชัน”

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

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

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

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

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

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

3.ล้างโต๊ะ

4.เช็ดกระจก

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

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

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

รูทีนย่อย:

อิชกี บักดาร์ลามา

รูทีนย่อย

ขั้นตอน

ขั้นตอน

ตัวกำหนดพารามิเตอร์

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

หากต้องการส่งผ่านค่าตัวแปรไปยังโพรซีเดอร์ (ฟังก์ชัน) จะใช้พารามิเตอร์จริง...

ในการอธิบายขั้นตอน คุณควร... จากนั้น...

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

คำนิยาม

รูทีนย่อย- นี่เป็นส่วนที่แยกจากกันของฟังก์ชันการทำงานอิสระของโปรแกรม

รูทีนย่อย

ขั้นตอน

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

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

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

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

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

ปฏิสัมพันธ์ระหว่างโปรแกรมหลักและรูทีนย่อย

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

• บล็อกการเรียกรูทีนย่อย (ขั้นตอนหรือฟังก์ชัน)

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

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

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

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

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

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

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

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

โปรแกรม ...;

// ส่วนคำอธิบาย การใช้งาน, Const, Var, ...

ขั้นตอน ก ;

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

ขั้นตอน บี ;

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

ฟังก์ชั่น C ;

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

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

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

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

ขั้นตอน

ฟังก์ชั่น

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

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

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

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

คำสั่งการเรียกโพรซีเดอร์เป็นคำสั่งแยกต่างหากที่สามารถใช้งานได้อย่างอิสระ

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

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

b จากนั้นสูงสุด:=a อย่างอื่นสูงสุด:=b; จำนวนสูงสุด:= สูงสุด; สิ้นสุด;" width="640"

ขั้นตอนหรือการทำงาน?

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

var สูงสุด: จำนวนเต็ม;

จำนวนสูงสุด:= สูงสุด;

b จากนั้นสูงสุด:=a อย่างอื่นสูงสุด:=b; สิ้นสุด;" width="640"

ขั้นตอนหรือการทำงาน?

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

ถ้า ab แล้วสูงสุด:=a อื่นสูงสุด:=b;

ขั้นตอนหรือการทำงาน?

เปลี่ยนสี(C1, C2: Word);

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

ขั้นตอนหรือการทำงาน?

บวก(X, Y: จำนวนเต็ม): จำนวนเต็ม;

แท้จริง

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

เป็นทางการ

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

กระบวนการนี้ถูกเรียกโดยตัวดำเนินการที่มีรูปแบบดังต่อไปนี้:

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

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

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

การส่งผ่านพารามิเตอร์ พารามิเตอร์ที่เป็นทางการ

ตัวแปร

ค่านิยม

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

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

ตัวแปร

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

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

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

ขั้นตอน

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

โปรแกรมหลัก

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

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

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

ขั้นตอน

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

โปรแกรมหลัก

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

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

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

ขั้นตอน Kvad(R: real; var S: real);

2. พารามิเตอร์อย่างเป็นทางการ ___________

3. พารามิเตอร์อย่างเป็นทางการ - ค่า __________

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

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

งานแบบโต้ตอบ

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

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

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

รูทีนย่อย:

อาร์เซน - เก็บเอกสารออกไป

มิลา - รดน้ำดอกไม้

Vitaly – ล้างโต๊ะ

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

1. ประหารอาร์เซน

2. เรียกใช้มิลา

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

4. วิ่งอินทิรา

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

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

• พารามิเตอร์ถูกส่งผ่านไปยังขั้นตอนอย่างไร?

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

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

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

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

นัดเจอกัน

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

วัตถุประสงค์ของบทเรียน

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

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

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

• ปลูกฝังความถูกต้อง ความสนใจ องค์กร
• วัฒนธรรมทักษะการใช้คอมพิวเตอร์

การพัฒนา

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

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

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

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

ฉันองค์กร ช่วงเวลา

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

แจกงานบนกระดาษ ( ภาคผนวก 1 ). ค้นหาการซ้ำซ้อน

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

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

รูทีนย่อยแบ่งออกเป็นขั้นตอนและฟังก์ชัน

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

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

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

โครงสร้างของขั้นตอนเป็นไปตามโครงสร้างของโปรแกรม มันคือ "โปรแกรมขนาดเล็ก" ซึ่งแสดงด้วยส่วนหัวและเนื้อหาด้วย

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

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

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

//เนื้อหาของโปรแกรมหลัก

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

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

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

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

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

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

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

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

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

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

การคำนวณ

การคำนวณ

การคำนวณ

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

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

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

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

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

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

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

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

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

มาสร้างขั้นตอนการตรวจสอบกัน:

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

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

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

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

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

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

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

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

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

แลกเปลี่ยนโปรแกรมแดน;

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

การแลกเปลี่ยนขั้นตอน (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 ก่อนตัวแปรที่ต้องการ:

การแลกเปลี่ยนขั้นตอน (var a,b:integer);

เปลี่ยนโปรแกรม obmenDan:

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

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

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

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

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

readln(ก,อี);

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

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

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

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

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

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

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

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

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

ตัวอย่างที่ 5 เรามาแก้ไขปัญหาเกี่ยวกับพื้นที่วงกลมกันใหม่.

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

ก:=วงกลม(5); (ต้องได้รับมอบหมาย)

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

เราใช้ฟังก์ชันในการค้นหาแฟกทอเรียล เนื่องจากเราป้อนมันเป็นอินพุตและรับผลลัพธ์

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

สำหรับ i:=1 ที่จะทำ

ในบรรทัด fact:=fact*I;

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

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

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

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

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

สำหรับ i:=1 ที่จะทำ

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

ผลรวม:=ผลรวม+ข้อเท็จจริง(เจ);

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

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

V. การบ้าน

แก้ไขปัญหา (เป็นลายลักษณ์อักษร):

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