หากคุณจำได้ว่าเมื่อพิจารณาตัวอย่างตัวดำเนินการมอบหมาย เราจำเป็นต้องค้นหาผลลัพธ์ของการดำเนินการโปรแกรม เราทราบวิธีจัดเก็บข้อมูล (ในตัวแปร) วิธีประมวลผล (โดยใช้นิพจน์) แต่กระบวนการข้อมูลพื้นฐานที่สุดสองกระบวนการไม่ได้อยู่ในความสนใจของเรา: การรับข้อมูลและส่งข้อมูลไปยังโลกภายนอกคอมพิวเตอร์ จนถึงตอนนี้ โปรแกรมของเราสามารถใช้ข้อมูลที่อยู่ในข้อความของโปรแกรมโดยตรงเท่านั้น หาค่าอะไร ช่วงเวลานี้มีตัวแปรก็เป็นไปไม่ได้เช่นกัน การเขียนโปรแกรมภายใต้เงื่อนไขดังกล่าวไม่มีความหมาย
การทำงานร่วมกันของอุปกรณ์สำหรับการประมวลผลและจัดเก็บข้อมูลกับสภาพแวดล้อมภายนอก (อย่างน้อยกับผู้ใช้) เป็นสิ่งที่จำเป็นอย่างยิ่ง สำหรับอินเทอร์เฟซดังกล่าวในภาษา Pascal ตัวดำเนินการอินพุตและเอาต์พุตข้อมูลมีหน้าที่รับผิดชอบ คำแนะนำเหล่านี้ช่วยให้คุณสามารถป้อนอาร์กิวเมนต์ พารามิเตอร์การคำนวณ ระหว่างการดำเนินการของโปรแกรม (ไม่ใช่ในขั้นตอนของการเขียน) เพื่อแสดงข้อมูลที่คำนวณได้ในรูปแบบที่บุคคลเข้าใจได้
คำสั่งอินพุตแรก (รูปแบบคำสั่ง):
อ่าน(<Список ввода>);
อ่านลน์(<Список ввода>);
ในรูปแบบนี้ คำสั่งเหล่านี้อนุญาตให้คุณป้อนข้อมูลลงในตัวแปรระหว่างการทำงานของโปรแกรมจากแป้นพิมพ์ องค์ประกอบของรายการอินพุตสามารถเป็นชื่อตัวแปรซึ่งต้องเติมด้วยค่าที่ป้อนจากแป้นพิมพ์
การดำเนินการของคำสั่งอินพุตเกิดขึ้นดังนี้: โปรแกรมถูกระงับ, เคอร์เซอร์ปรากฏบนหน้าจอ, คอมพิวเตอร์คาดหวังจากผู้ใช้ชุดข้อมูลสำหรับตัวแปรที่มีชื่อระบุไว้ในรายการอินพุต ผู้ใช้จากแป้นพิมพ์ป้อนค่าที่จำเป็นตามลำดับที่จำเป็นสำหรับรายการอินพุต กด Enter หลังจากนั้นข้อมูลที่พิมพ์จะเข้าสู่ตัวแปรที่เกี่ยวข้องและการดำเนินการของโปรแกรมจะดำเนินต่อไป
หมายเหตุ: ข้อมูลที่ป้อนจะถูกคั่นด้วยช่องว่าง
ความแตกต่างระหว่างการทำงานของโพรซีเดอร์ Read และ Readln (จากบรรทัด Read) มีดังต่อไปนี้: หลังจากดำเนินการ Read แล้ว ค่าของข้อมูลถัดไปจะถูกอ่านจากบรรทัดเดียวกัน และหลังจากดำเนินการ Readln จากบรรทัดใหม่
ในการแสดงข้อมูลในภาษาปาสคาลยังมีสองคำสั่ง:
เขียน(<Список вывода>);
ไรท์ลน์(<Список вывода>);
รูปแบบการใช้ Write และ Writeln นี้ช่วยให้คุณสามารถแสดงข้อมูลจากรายการผลลัพธ์บนหน้าจอมอนิเตอร์ องค์ประกอบรายการผลลัพธ์สามารถเป็นชื่อตัวแปร นิพจน์ ค่าคงที่ ก่อนแสดงค่านิพจน์คอมพิวเตอร์จะคำนวณก่อน องค์ประกอบของรายการ เช่นเดียวกับในคำสั่งอินพุต จะถูกคั่นด้วยเครื่องหมายจุลภาค
ความแตกต่างระหว่างคำสั่งเอาต์พุตทั้งสองคือ: หลังจากดำเนินการคำสั่ง Writeln (จากบรรทัด Write) มันจะกระโดดไปที่ บรรทัดใหม่และหลังจากการดำเนินการตามคำสั่ง Write การเปลี่ยนไปยังบรรทัดใหม่จะไม่เกิดขึ้น และการพิมพ์คำสั่งเอาต์พุต Write หรือ Writeln ที่ตามมาจะเกิดขึ้นในบรรทัดเดียวกัน เมื่อคุณเรียกใช้คำสั่ง Writeln โดยไม่มีพารามิเตอร์ คำสั่งนั้นจะข้ามไปที่บรรทัดใหม่
นี่คือตัวอย่างการใช้ตัวดำเนินการอินพุตและเอาต์พุต:
อินเทอร์เฟซโปรแกรม;
เขียน ("ป้อนรัศมีของวงกลม"); (การพิมพ์บนหน้าจอขอให้ป้อนข้อมูล)
อ่าน (R); (ป้อนค่าลงในตัวแปร R จากแป้นพิมพ์)
S:=4*ARCTAN(1)*SQR(R); (คำนวณพื้นที่วงกลม (pR2))
Writeln("พื้นที่วงกลมที่มีรัศมี ",R," เท่ากับ ",S)
โปรแกรมนี้แจ้งให้ผู้ใช้ทราบรัศมีของวงกลม ให้โอกาสในการป้อนค่า คำนวณและแสดงพื้นที่ของวงกลมที่มีรัศมีดังกล่าว ดังนั้นจึงเป็นไปได้โดยไม่ต้องเปลี่ยนแปลงข้อความของโปรแกรมเพื่อป้อนค่าต่าง ๆ ของรัศมีและรับค่าที่สอดคล้องกันของพื้นที่วงกลม ในการทำเช่นนี้ก็เพียงพอที่จะเรียกใช้โปรแกรมหลาย ๆ ครั้ง โปรแกรมนี้ยังสาธิตกฎต่อไปนี้: ผลลัพธ์ของผลลัพธ์จะต้องได้รับการแสดงความคิดเห็นเพื่อให้ความหมายของตัวเลขที่พิมพ์ออกมานั้นชัดเจน อันที่จริง มันเป็นไปได้ที่จะจำกัดตัวเองไว้ที่ Writeln(S) แต่ความหมายของตัวเลขที่ส่งออกโดยโปรแกรมในกรณีนี้จะชัดเจนเฉพาะกับผู้เขียนโปรแกรมนี้เท่านั้น
ตัวดำเนินการอินพุตและเอาต์พุต
ลองพิจารณาการจัดระเบียบข้อมูลเข้าและออกจากอุปกรณ์ปลายทาง อุปกรณ์ปลายทางคืออุปกรณ์ที่ผู้ใช้ใช้งาน โดยปกติจะเป็นหน้าจอ (จอแสดงผล) และแป้นพิมพ์ สำหรับอินพุตและเอาต์พุตข้อมูล จะใช้โพรซีเดอร์อินพุตและเอาต์พุตมาตรฐาน อ่านและเขียน ซึ่งทำงานกับไฟล์ INPUT และ OUTPUT ตามลำดับมาตรฐาน
ไฟล์เหล่านี้แบ่งออกเป็นบรรทัดที่มีความยาวผันแปรได้ แยกออกจากกันด้วยตัวสิ้นสุดบรรทัด จุดสิ้นสุดของบรรทัดถูกกำหนดโดยการกดปุ่ม ENTER
สำหรับการป้อนข้อมูลเริ่มต้น จะใช้ตัวดำเนินการของขั้นตอนการป้อนข้อมูล:
อ่าน (A1,A2,...AK);
ReadLn(A1,A2,...AK);
คนแรกใช้การอ่านค่า K ของข้อมูลเริ่มต้นและกำหนดค่าเหล่านี้ให้กับตัวแปร A1, A2, ..., AK ตัวดำเนินการที่สองดำเนินการอ่านค่า K ของข้อมูลเริ่มต้น ข้ามค่าที่เหลือจนถึงจุดเริ่มต้นของบรรทัดถัดไป กำหนดค่าการอ่านให้กับตัวแปร A1, A2, ..., AK ตัวดำเนินการที่สามดำเนินการข้ามบรรทัดข้อมูลอินพุต
เมื่อป้อนข้อมูลเริ่มต้นการแปลงจาก รูปแบบภายนอกเป็นตัวแทนภายในที่กำหนดโดยประเภทของตัวแปร ตัวแปรที่ประกอบเป็นรายการอินพุตสามารถเป็นประเภทจำนวนเต็ม จำนวนจริง หรืออักขระก็ได้ ไม่อนุญาตให้อ่านข้อมูลดิบประเภทบูลีนในภาษา PASCAL
คำสั่งอินพุตเมื่ออ่านค่าของตัวแปรประเภทจำนวนเต็มและจำนวนจริงให้ข้ามช่องว่างหน้าตัวเลข ในขณะเดียวกัน ตัวดำเนินการเหล่านี้จะไม่ข้ามช่องว่างที่นำหน้าค่าของตัวแปรอักขระ เนื่องจากช่องว่างเป็นอักขระที่เท่ากันในสตริง ตัวอย่างการเขียนคำสั่งอินพุต:
var rV, rs: จริง;
iW, iJ: จำนวนเต็ม;
................
อ่าน (rV, rS, iW, iJ);
ค่าของข้อมูลเริ่มต้นสามารถแยกออกจากกันได้โดยการเว้นวรรคและโดยการกดแท็บและปุ่ม Enter
ในการแสดงผลลัพธ์ของโปรแกรมบนหน้าจอจะใช้ข้อความต่อไปนี้:
เขียน(A1,A2,...AK);
WriteLn(A1,A2,...AK);
ตัวดำเนินการตัวแรกใช้เอาต์พุตของค่าของตัวแปร A1, A2,...,AK ไปยังบรรทัดหน้าจอ ตัวดำเนินการที่สองใช้เอาต์พุตของค่าของตัวแปร A1, A2, ..., AK และการเปลี่ยนไปยังจุดเริ่มต้นของบรรทัดถัดไป ตัวดำเนินการที่สามใช้การข้ามบรรทัดและการเปลี่ยนไปยังจุดเริ่มต้นของบรรทัดถัดไป
ตัวแปรที่ประกอบกันเป็นรายการผลลัพธ์สามารถเป็นประเภทจำนวนเต็ม จำนวนจริง อักขระ หรือบูลีน ในฐานะองค์ประกอบของรายการเอาต์พุต นอกจากชื่อตัวแปรแล้ว ยังสามารถใช้นิพจน์และสตริงได้อีกด้วย
เอาต์พุตของแต่ละค่าในบรรทัดของหน้าจอเกิดขึ้นตามความกว้างของฟิลด์เอาต์พุต ซึ่งกำหนดโดยการใช้งานเฉพาะของภาษา
รูปแบบการแสดงค่าในช่องเอาต์พุตสอดคล้องกับประเภทของตัวแปรและนิพจน์: ค่าประเภทจำนวนเต็มจะถูกส่งออกเป็นตัวเลขทศนิยมจำนวนเต็ม ประเภทจริง - เป็นตัวเลขทศนิยมจริงพร้อมลำดับทศนิยม ประเภทอักขระและสตริง - เป็น สัญลักษณ์ประเภทบูลีน - เป็นค่าคงที่ตรรกะ TRUE และ FALSE
คำสั่งเอาต์พุตให้คุณตั้งค่าความกว้างของฟิลด์เอาต์พุตสำหรับแต่ละองค์ประกอบของรายการเอาต์พุต ในกรณีนี้ อิลิเมนต์รายการเอาต์พุตมีรูปแบบ A:K โดยที่ A เป็นนิพจน์หรือสตริง K เป็นนิพจน์หรือค่าคงที่ของประเภทจำนวนเต็ม หากค่าเอาต์พุตตรงตำแหน่งในช่องเอาต์พุตน้อยกว่า K จะมีการเว้นวรรคก่อนค่านี้ หากค่าที่แสดงไม่พอดีกับความกว้างของฟิลด์ K จำนวนตำแหน่งที่ต้องการจะถูกจัดสรรสำหรับค่านี้ สำหรับค่าประเภทจริง องค์ประกอบรายการเอาต์พุตสามารถอยู่ในรูปแบบ A:K:M โดยที่ A คือตัวแปรหรือนิพจน์ของประเภทจริง K คือความกว้างของฟิลด์เอาต์พุต และ M คือตัวเลข ของหลักที่เป็นเศษส่วนของค่าเอาต์พุต K และ M เป็นนิพจน์หรือค่าคงที่ประเภทจำนวนเต็ม ในกรณีนี้ ค่าจริงจะถูกส่งออกเป็นเลขทศนิยมคงที่ ตัวอย่างการเขียนคำสั่งเอาต์พุต:
. . . . . . . . . . . .
var ra, rB: จริง; iP,iQ:จำนวนเต็ม;
bR, bS: บูลีน; chT, chV, chU, chW: ถ่าน;
. . . . . . . . . . . .
WriteLn(อาร์เอ, rB:10:2);
WriteLn(ไอพี, ไอคิว:8);
WriteLn(bR, bS:8);
WriteLn (chT, chV, chU, chW);
แท็ก ตัวดำเนินการกระโดดแบบไม่มีเงื่อนไข.
บ้านแต่ละหลังบนถนนมีเลขที่ของตัวเอง ทุกคนมีชื่อของตัวเอง แม้แต่เซลล์หน่วยความจำของคอมพิวเตอร์แต่ละหลังก็มีที่อยู่ของตัวเอง ทั้งหมดนี้เป็นที่ยอมรับเพื่อให้สามารถระบุวัตถุที่ถูกกำหนดอย่างชัดเจน ในทำนองเดียวกัน ป้ายกำกับจะใช้เพื่ออ้างถึงคำสั่งในโปรแกรม
ป้ายกำกับในภาษาปาสคาลมาตรฐานเป็นจำนวนเต็มที่ไม่เป็นลบ ป้ายกำกับทั้งหมดที่ใช้ในโปรแกรมจะต้องแสดงอยู่ในส่วนคำอธิบายป้ายกำกับ ซึ่งขึ้นต้นด้วยคีย์เวิร์ดป้ายกำกับ เช่น
สามารถติดป้ายกำกับตัวดำเนินการได้เพียงหนึ่งตัวเท่านั้น ป้ายกำกับแยกออกจากคำสั่งที่มีป้ายกำกับด้วยเครื่องหมายทวิภาค
6: เขียนใน (14/2);
ในโปรแกรมทั้งหมดข้างต้น ข้อความจะถูกดำเนินการตามลำดับที่เขียนในข้อความ โครงสร้างอัลกอริทึมดังกล่าวเรียกว่าการติดตามโดยตรง อย่างไรก็ตาม ในภาษาปาสคาล เริ่มแรกมีโอเปอเรเตอร์ที่ละเมิดการดำเนินการอย่างตรงไปตรงมาของโปรแกรม ถ่ายโอนการควบคุมไปยังจุดโดยพลการในนั้น คำสั่งดังกล่าวเรียกว่ากิ่งที่ไม่มีเงื่อนไขและมีรูปแบบดังต่อไปนี้:
ไปที่<метка>;
คำสั่งที่เกิดการเปลี่ยนแปลงจะต้องทำเครื่องหมายด้วยป้ายกำกับนี้
ใช้ตัวดำเนินการสาขาแบบไม่มีเงื่อนไขด้วยความระมัดระวังเป็นพิเศษเพื่อหลีกเลี่ยงการได้ผลลัพธ์ที่ผิดพลาดหรือการ "วนซ้ำ" โปรแกรมโดยสิ้นเชิง โดยทั่วไปแล้วการใช้คำสั่งนี้ในหมู่โปรแกรมเมอร์ถือเป็นรูปแบบที่ไม่ดี อย่างที่คุณเห็นมีความเป็นไปได้เสมอที่จะทำโดยไม่มีมัน
องค์ประกอบของการเขียนโปรแกรมเชิงโครงสร้าง
โปรแกรมที่มีโครงสร้าง (หรือรูทีนย่อย) เป็นโปรแกรมที่ประกอบด้วยชุดโครงสร้างพื้นฐานที่ตายตัว ให้เราพิจารณาคำจำกัดความหลักและวิธีการสร้างโครงสร้างเหล่านี้ในรูปแบบอัลกอริทึม
การดำเนินการ ส้อม และการควบรวมเป็นโครงสร้างพื้นฐาน: ต่อไปนี้ การแยกย่อย วัฏจักร การใช้โครงสร้างทั้งสามนี้เท่านั้นจึงเป็นไปได้ที่จะใช้อัลกอริทึมเพื่อแก้ปัญหาใด ๆ
การก่อสร้างซึ่งเป็นการดำเนินการตามลำดับของการดำเนินการตั้งแต่สองรายการขึ้นไปเรียกว่าดังต่อไปนี้
โครงสร้างที่ประกอบด้วยส้อม สองการดำเนินการ และการผสานเรียกว่าสาขา การดำเนินการอย่างใดอย่างหนึ่งอาจขาดหายไป
โครงสร้างที่มีสายควบคุมที่นำไปสู่การดำเนินการก่อนหน้านี้หรือทางแยกเรียกว่าวงจร
โครงสร้างการติดตาม สาขา และลูปสามารถถูกมองว่าเป็นการดำเนินการ เนื่องจากมีอินพุตเดียวและเอาต์พุตเดียว ลำดับการดำเนินการโดยพลการสามารถแสดงเป็นการดำเนินการเดียว
การดำเนินการสามารถดำเนินการโดยคำสั่ง PASCAL (แบบง่ายหรือแบบผสม) หรือโดยกลุ่มของคำสั่ง ยกเว้นคำสั่งการเปลี่ยน GOTO
ในภาษาปาสคาล จำนวนของโครงสร้างพื้นฐานได้เพิ่มขึ้นเป็นหก ได้แก่:
ติดตาม;
การแตกแขนง;
วนซ้ำด้วยเงื่อนไขเบื้องต้น;
วนซ้ำด้วย postcondition;
วนซ้ำด้วยพารามิเตอร์
ตัวดำเนินการแบบมีเงื่อนไข
โครงสร้างอัลกอริทึมหลักอย่างหนึ่งคือการแตกแขนง (ทางเลือก)
หากตรงตามเงื่อนไข คำสั่ง "1" จะถูกดำเนินการ หากไม่ คำสั่ง "2" จะถูกดำเนินการ แม้ว่าจะมีการดำเนินการสองอย่างในสคีมา แต่จะมีการดำเนินการเพียงรายการเดียวเนื่องจากเงื่อนไขเป็นเท็จหรือจริง ไม่มีที่สาม รูปแบบดังกล่าวช่วยให้สามารถแก้ปัญหาได้ซึ่งขึ้นอยู่กับสถานการณ์ซึ่งจำเป็นต้องมีการดำเนินการอย่างใดอย่างหนึ่ง ไม่ต้องสงสัยเลยว่าปัญหาประเภทนี้มีมากมายมหาศาล ยิ่งไปกว่านั้น เป็นเรื่องยากมากที่จะได้งานที่มีความหมายจริงๆ อัลกอริธึมการดำเนินการซึ่งจะมีคำสั่งง่ายๆ ดังต่อไปนี้ แม้แต่ตัวอย่างดั้งเดิมที่นำมาจากหลักสูตรคณิตศาสตร์อย่างที่คุณเห็น ก็ไม่สามารถแก้ไขได้หากไม่มีการแตกแขนง ดังนั้นจึงจำเป็นต้องคำนวณค่าของนิพจน์ y=1/x คุณก็รู้ ฟังก์ชันที่กำหนดไม่สำคัญเสมอไป เช่น ไม่ใช่ค่าอาร์กิวเมนต์ทั้งหมดที่มีค่าผลลัพธ์ หน้าที่ของเราคือเขียนอัลกอริทึมในลักษณะที่นักแสดงจะไม่ติดขัดแม้ในกรณีที่ได้รับค่าศูนย์เป็นอาร์กิวเมนต์ การกำหนดสิ่งนี้ในภาษาธรรมชาติไม่ใช่เรื่องยาก:
1. รับค่า x
2. ถ้า x=0 ให้รายงานว่านิพจน์ไม่มีค่า มิฉะนั้น ให้คำนวณ y เป็น 1/x
ดังนั้นจึงใช้โครงสร้างอัลกอริทึมข้างต้น สามารถแสดงออกได้ ด้วยคำพูดง่ายๆ:
ถ้า<усл.>(หากตรงตามเงื่อนไข)
ที่<действие 1>(จากนั้นดำเนินการ #1)
มิฉะนั้น<действие 2>(มิฉะนั้น - ดำเนินการ #2)
จะเขียนเป็นภาษาปาสคาลได้อย่างไร? ใช่เหมือนกันทุกประการเป็นภาษาอังกฤษเท่านั้น
รูปแบบตัวดำเนินการตามเงื่อนไขใน Pascal:
ถ้า<условие>
แล้ว<оператор 1>
อื่น<оператор 2>;
โปรดทราบว่ามีเพียงคำสั่งเดียวในส่วน That- และ Else- แต่จะทำอย่างไรเพื่อแก้ปัญหาที่เมื่อปฏิบัติตามหรือไม่ปฏิบัติตามเงื่อนไขจำเป็นต้องดำเนินการไม่ใช่อย่างใดอย่างหนึ่ง แต่ต้องทำหลายอย่าง นี่คือที่ที่ผู้ดำเนินการผสมที่คุณรู้จักมาช่วย วงเล็บตัวดำเนินการสามารถล้อมรอบตัวดำเนินการจำนวนเท่าใดก็ได้
ตัวแปรของตัวดำเนินการเงื่อนไขในกรณีนี้:
ถ้า<условие>
จากนั้นเริ่มต้น<группа операторов 1>จบ
อื่น ๆ เริ่มต้น< группа операторов 2>จบ;
เครื่องหมาย "อัฒภาค" ไม่ได้วางไว้หน้าคำบริการ Else แต่ตัวดำเนินการในกลุ่มจะถูกแยกออกจากกันด้วยเครื่องหมายนี้
ตอนนี้เรามาพูดถึงเงื่อนไข ในโปรแกรม Pascal เงื่อนไขคือนิพจน์ที่มีค่าเป็นค่าบูลีน โดยสามารถเป็นได้ทั้งตัวแปรอย่างง่ายของประเภทที่ระบุ หรือลำดับที่ซับซ้อนของคำสั่งที่เชื่อมต่อกันด้วยการดำเนินการเชิงตรรกะ
ในเงื่อนไขง่ายๆ สัญญาณของการดำเนินการเปรียบเทียบสามารถใช้ได้: > (มากกว่า),<(меньше), =(равно), <>(ไม่เท่ากัน), >= (มากกว่าหรือเท่ากับ),<=(меньше или равно).
ตัวอย่างเงื่อนไขอย่างง่าย: A=5 (ค่าของตัวแปร A คือ 5)
(C+D3)>=(D1*(45-2)) (ค่าของนิพจน์ทางด้านซ้ายมากกว่าหรือเท่ากับค่าของนิพจน์ทางด้านขวา)
ส<>"ABC" (ค่าของตัวแปร S ไม่เท่ากับค่าคงที่ของสตริง "ABC")
ลองยกตัวอย่างการแก้ปัญหาอื่น: "จากตัวเลขสองตัว เลือกตัวเลขที่ใหญ่ที่สุด"
เมื่อมองแวบแรก วิธีแก้ปัญหานั้นชัดเจน แต่ก็ไม่สำคัญอย่างที่คิด
ตัวอย่างโปรแกรม
วาร์อา,บี,ซี: เรอัล; (A,B - เพื่อเก็บอาร์กิวเมนต์, C - ผลลัพธ์)
Writeln("ป้อนตัวเลขสองตัว");
อ่านใน (A, B); (ป้อนข้อโต้แย้งจากแป้นพิมพ์)
ถ้า A>B แล้ว C:=A อื่น C:=B; (ถ้า A>B ผลลัพธ์คือ A มิฉะนั้น ผลลัพธ์คือ B)
เขียน (C); (แสดงผลบนหน้าจอ)
อีกตัวอย่างคลาสสิก: "แก้สมการกำลังสองโดยใช้ค่าสัมประสิทธิ์ที่กำหนด" งานนี้ยากกว่าดังนั้นก่อนที่จะเขียนโปรแกรมเราจะเขียนอัลกอริทึมโดยเขียนในรูปแบบของผังงาน ขั้นแรกให้ป้อนค่าสัมประสิทธิ์จากนั้นจึงคำนวณการจำแนก ตอนนี้มีความเป็นไปได้สองประการ: การไม่มีรากที่แท้จริงในกรณีของการเลือกปฏิบัติเชิงลบ หรือรากเหล่านี้ยังคงสามารถคำนวณและแสดงได้ในกรณีของการเลือกปฏิบัติที่ไม่ใช่เชิงลบ (กรณีของการเลือกปฏิบัติที่มีค่าเท่ากับศูนย์รวมอยู่ที่นี่ มีสองรากเท่านั้นที่เป็น J เดียวกัน)
เมื่อเขียนอัลกอริทึมในภาษาโปรแกรมควรคำนึงถึงว่าในสาขา "ไม่" ไม่มีการกระทำเดียว แต่สามอย่าง ดังนั้นควรใช้ตัวดำเนินการผสม อย่าลืมเขียนนิพจน์เลขคณิตตามกฎของภาษาปาสคาล มิฉะนั้นโปรแกรมนี้จะไม่ซับซ้อนกว่าโปรแกรมก่อนหน้า
Var A, B, C, D, X1, X2: จริง;
Writeln("ป้อนค่าสัมประสิทธิ์ของสมการกำลังสอง");
ถ้า ง<0 Then Writeln ("Корней нет! ")
X1:=(-B+SQRT(D))/2/A;
X2:=(-B-SQRT(D))/2/A;
ที่น่าสนใจคือตัวดำเนินการตามเงื่อนไขสามารถทำหน้าที่เป็นตัวดำเนินการที่ดำเนินการเมื่อตรงตามเงื่อนไขหรือไม่ก็ได้ ในกรณีนี้ เราพูดถึงการซ้อนคำสั่งแบบมีเงื่อนไข เมื่อแก้ปัญหาดังกล่าว ฉันขอแนะนำให้คุณวาดแผนผังลำดับงานของอัลกอริทึมในสมุดบันทึก เมื่อทำการคอมไพล์โปรแกรม คุณเพียงแค่ต้องเขียนส่วน Then ทั้งหมดอย่างระมัดระวังก่อน แล้วจึงไปยังส่วนอื่น โดยปกติแล้ว เมื่อเขียนคำสั่งแบบมีเงื่อนไขในภาษาปาสคาล (โดยเฉพาะกับหลาย ๆ แบรนช์) คำสั่งจะถูกเขียนโดยมีหิ้งไปทางขวาและล่าง สิ่งนี้จะเพิ่มการมองเห็น และเชื่อฉันสิ ลดเวลาการดีบั๊ก
เพื่ออธิบาย ลองแก้ปัญหาอื่น: "แก้สมการของรูปแบบ A*x^2 + B*x + C = 0" โปรดอย่าสับสนกับสมการกำลังสอง ซึ่งเรารู้ว่าสัมประสิทธิ์ A ไม่เท่ากับศูนย์ ในที่นี้ ค่าสัมประสิทธิ์สามารถเป็นตัวเลขใดๆ ก็ได้ ตามเหตุผลทางคณิตศาสตร์เบื้องต้น เราได้รับอัลกอริทึมต่อไปนี้:
Var A, B, C, D, X, X1, X2: จริง;
Writeln("ป้อนค่าสัมประสิทธิ์ของสมการ (A, B, C)");
ถ้า C=0 แล้ว Writeln("X คือตัวเลขใดๆ")
อื่น Writeln ("ไม่มีราก!")
อื่น เริ่มต้น X:=-C/B; Writeln("X=",X:8:3) สิ้นสุด
ถ้า ง<0 Then Writeln ("Корней нет! ")
X1:=(-B+SQRT(D))/2/A;
X2:=(-B-SQRT(D))/2/A;
WriteIn("X1=", X1:8:3, "X2=",X2:8:3)
วัฏจักร ประเภทของไซเคิล
วัฏจักรคือการกระทำประเภทเดียวกันซ้ำๆ ร่างกายของวงจรจะเรียกว่าการกระทำที่ต้องทำซ้ำหลายครั้ง
ตามที่คุณเข้าใจ คุณสามารถทำสิ่งเดิมซ้ำได้โดยใช้ตัวดำเนินการกระโดดแบบไม่มีเงื่อนไข หากคุณเขียนการกระทำเหล่านี้ในโปรแกรมทีละรายการ และในตอนท้ายให้ใส่คำสั่งข้ามไปที่จุดเริ่มต้นของบล็อกนี้ อย่างไรก็ตาม ด้วยวิธีนี้คุณจะได้รับเฉพาะโปรแกรมที่ทำงานตลอดไป (ลูป) สิ่งนี้สามารถหลีกเลี่ยงได้โดยใช้คำสั่งเงื่อนไขร่วมกับคำสั่งการเปลี่ยนแปลง ทำให้การดำเนินการของการเปลี่ยนแปลงขึ้นอยู่กับการปฏิบัติตามเงื่อนไขที่กำหนด ดังนั้นเราจะได้โครงสร้างของการเปลี่ยนแปลงตามเงื่อนไขและความเป็นไปได้ในการจัดระเบียบรอบสุดท้าย โดยทั่วไป ด้วยวิธีนี้ เราสามารถแก้ปัญหาได้เกือบทุกปัญหาที่ต้องใช้อัลกอริทึมแบบวงจร แน่นอน แค่ขวานเล่มเดียวก็สร้างบ้านได้ เรามาถามคำถามกันก่อน: "บ้านหลังนี้จะสวยงามหรือไม่? สามารถประหยัดเวลาและความพยายามได้มากแค่ไหนโดยใช้เครื่องมือพิเศษทุกชนิด" เพื่ออะไร? - เพื่อความสะดวก สั้น ง่ายในการอ่านโปรแกรม และคำนี้ ผมไม่กลัวความสวยงาม ดังนั้นจึงมีลูปสามประเภทที่มีตัวดำเนินการ Pascal สำหรับเขียน ประเภทเหล่านี้มีชื่อเงื่อนไขของตัวเอง: "ในขณะที่", "ก่อน", "ด้วยพารามิเตอร์" พวกมันค่อนข้างแตกต่างกันและใช้สำหรับงานประเภทต่างๆ
วงจร "บาย"
กลุ่มของคำสั่งที่เรียกว่า "ตัวลูป" ตามรูปแบบนี้ จะถูกดำเนินการในขณะที่เงื่อนไขของลูปเป็นจริง การวนซ้ำจะสิ้นสุดเมื่อเงื่อนไขไม่เป็นจริงอีกต่อไป
หากเงื่อนไขเป็นเท็จแต่แรก เนื้อความของลูปจะไม่ถูกดำเนินการ หากเงื่อนไขเริ่มต้นเป็นจริงและไม่มีการดำเนินการใดในเนื้อความของลูปที่ส่งผลต่อความจริงของเงื่อนไขนี้ เนื้อความของลูปจะถูกดำเนินการเป็นจำนวนครั้งไม่สิ้นสุด สถานการณ์นี้เรียกว่า "การวนซ้ำ" โปรแกรมที่วนซ้ำสามารถถูกขัดจังหวะโดยตัวดำเนินการ (โดยกด Ctrl + C) หรือการหยุดโปรแกรมเองในกรณีฉุกเฉิน ในกรณีที่ตัวแปรล้น การหารด้วยศูนย์ ฯลฯ สิ้นสุด
ในภาษาปาสคาล โครงสร้างลูป while เขียนได้ดังนี้
ในขณะที่<условие>ทำ<оператор>;
รวบรัดจริงหรือ? ในภาษารัสเซียสามารถอ่านได้ดังนี้: "ตราบใดที่เงื่อนไขเป็นจริง ให้ดำเนินการตามคำสั่ง" เช่นเดียวกับในรูปแบบคำสั่งเงื่อนไข มีเพียงคำสั่งเดียวเท่านั้นที่จะดำเนินการ หากต้องการดำเนินการมากกว่าหนึ่งรายการ สามารถใช้คำสั่งผสมได้ รูปแบบของตัวดำเนินการจะอยู่ในรูปแบบต่อไปนี้:
ในขณะที่<условие>ทำ
<оператор #1>;
<оператор #2>;
<оператор #3>;
วงจร "ถึง"
การวนซ้ำประเภทนี้แตกต่างจากครั้งก่อนโดยส่วนใหญ่อยู่ที่การทดสอบเงื่อนไขสำหรับการทำซ้ำเนื้อความของลูปไม่ได้อยู่ข้างหน้า แต่หลังจากนั้น ดังนั้นลูป "Before" จึงเรียกว่าลูป "postcondition" และลูป "While" เรียกว่าลูป "precondition"
โปรดทราบว่าการวนซ้ำใหม่ (การดำเนินการซ้ำของเนื้อหาลูป) ไม่ได้เกิดขึ้นเมื่อเงื่อนไขเป็นจริง แต่เกิดขึ้นเมื่อเงื่อนไขเป็นเท็จ ดังนั้นลูปจึงมีชื่อ (ดำเนินการเนื้อหาของลูปจนกว่าจะตรงตามเงื่อนไขที่สอดคล้องกัน)
10. ตัวดำเนินการอินพุตและเอาต์พุต
พิจารณาการจัดระเบียบอินพุตและเอาต์พุตของข้อมูลจากเทอร์มินัล
การจับกลุ่ม อุปกรณ์ปลายทางคืออุปกรณ์ที่
ผู้ใช้ โดยปกติจะเป็นหน้าจอ (จอแสดงผล) และแป้นพิมพ์
ขั้นตอนอินพุตมาตรฐานใช้สำหรับอินพุตและเอาต์พุตข้อมูล
และเอาต์พุตอ่านและเขียนบนไฟล์ลำดับมาตรฐาน
อินพุตและเอาต์พุต
ไฟล์เหล่านี้แบ่งออกเป็นบรรทัดความยาวผันแปรโดยคั่นด้วย
ออกจากกันโดยมีเครื่องหมายปลายบรรทัดกำหนดปลายบรรทัดโดยกดที่
สำหรับการป้อนข้อมูลเริ่มต้น จะใช้ตัวดำเนินการของขั้นตอนการป้อนข้อมูล:
อ่าน (A1,A2,...AK);
ReadLn(A1,A2,...AK);
คนแรกดำเนินการอ่านค่า K ของข้อมูลเริ่มต้นและกำหนด -
ปรับขนาดค่าเหล่านี้เป็นตัวแปร A1, A2,...,AK ตัวดำเนินการที่สอง
ใช้การอ่านค่า K ของข้อมูลเริ่มต้น ข้ามค่าที่เหลือ
จนถึงจุดเริ่มต้นของบรรทัดถัดไป กำหนดค่าการอ่านให้กับ
ตัวแปร A1, A2, ..., AK ตัวดำเนินการที่สามใช้การข้ามบรรทัดโดยใช้
ข้อมูลอินพุต
เมื่อป้อนข้อมูลเริ่มต้น การแปลงจากภายนอก
รูปแบบการแสดงเป็นรูปแบบภายในที่กำหนดโดยประเภทของตัวแปร วิชาพลศึกษา-
ตัวแปรที่สร้างรายการอินพุตสามารถเป็นของจำนวนเต็มได้
ทั้งตัวจริงหรือตัวละคร แหล่งอ่าน
ไม่อนุญาตให้ใช้ข้อมูลบูลีนใน PASCAL
ตัวดำเนินการอินพุตเมื่ออ่านค่าจำนวนเต็มและค่าตัวแปร
ประเภทจริงจะข้ามช่องว่างที่นำหน้าตัวเลข
ในขณะเดียวกัน ตัวดำเนินการเหล่านี้จะไม่เว้นวรรคหน้าค่า
ตัวแปรอักขระเนื่องจากช่องว่างเท่ากัน
อักขระสตริง ตัวอย่างการเขียนคำสั่งอินพุต:
var rV, rs: จริง;
iW, iJ: จำนวนเต็ม;
................
อ่าน (rV, rS, iW, iJ);
ค่าข้อมูลที่ป้อนสามารถแยกออกจากกันด้วยช่องว่าง
และการกดแท็บและแป้น Enter
ในการแสดงผลลัพธ์ของโปรแกรมบนหน้าจอ ให้ใช้
ผู้ประกอบการ:
เขียน(A1,A2,...AK);
WriteLn(A1,A2,...AK);
ตัวดำเนินการตัวแรกใช้เอาต์พุตของค่าของตัวแปร A1
A2,...,AK ในบรรทัดหน้าจอ คำสั่งที่สอง ใช้เอาต์พุต
ค่าของตัวแปร A1,A2,...,AK และการเปลี่ยนไปยังจุดเริ่มต้นของถัดไป
เส้น ตัวดำเนินการที่สามใช้การข้ามบรรทัดและข้ามไปที่จุดเริ่มต้น
บรรทัดถัดไป
ตัวแปรที่ประกอบเป็นรายการผลลัพธ์สามารถอ้างถึงจำนวนเต็ม
ประเภทจริง อักขระ หรือบูลีน เป็นองค์ประกอบ
ในรายการเอาต์พุต นอกจากชื่อตัวแปรแล้ว ยังสามารถใช้นิพจน์ได้
และเส้น
ผลลัพธ์ของแต่ละค่าในบรรทัดของหน้าจอเกิดขึ้นตาม
ด้วยความกว้างฟิลด์เอาต์พุตเฉพาะการใช้งาน
รูปแบบการแสดงค่าในช่องเอาต์พุตสอดคล้องกับประเภท
เข็มขัดและนิพจน์: ค่าของประเภทจำนวนเต็มจะแสดงเป็นจำนวนเต็มสิบ
จำนวนจริง ชนิดจริง เช่น ทศนิยมจริง
ตัวเลขที่มีลำดับทศนิยม ประเภทอักขระ และสตริง - ในรูปแบบของอักขระ
วัว ประเภทตรรกะ - ในรูปแบบของค่าคงที่ตรรกะ TRUE และ FALSE
ตัวดำเนินการเอาต์พุตให้คุณกำหนดความกว้างของฟิลด์เอาต์พุตสำหรับแต่ละรายการ
รายการผลลัพธ์ ในกรณีนี้
องค์ประกอบรายการผลลัพธ์มีรูปแบบ A:K โดยที่
A คือนิพจน์หรือสตริง K คือนิพจน์หรือค่าคงที่ของประเภทจำนวนเต็ม
หากค่าเอาต์พุตตรงตำแหน่งในช่องเอาต์พุตน้อยกว่า K
แล้วมีช่องว่างก่อนค่านี้ ถ้าค่าออกคือ
ไม่พอดีกับความกว้างของฟิลด์ K ดังนั้นคำตอบจะเป็นค่านี้
จำนวนตำแหน่งที่ต้องการ สำหรับค่าประเภทจริง
รายการเอาต์พุตสามารถอยู่ในรูปแบบ A: K: M โดยที่ A เป็นตัวแปรหรือนิพจน์
ประเภทจริง, K - ความกว้างของฟิลด์เอาต์พุต, M - จำนวนหลัก
ส่วนที่เป็นเศษส่วนของค่าที่แสดง K และ M - นิพจน์หรือค่าคงที่
ประเภทจำนวนเต็ม ในกรณีนี้ ค่าจริงจะถูกส่งออกในรูปแบบ
เลขทศนิยมที่มีจุดคงที่
ตัวอย่างการเขียนคำสั่งเอาต์พุต:
. . . . . . . . . . . .
var ra, rB: จริง;iP,iQ:จำนวนเต็ม;
bR, bS: บูลีน;chT, chV, chU, chW: Char;
. . . . . . . . . . . .
WriteLn(อาร์เอ, rB:10:2);
WriteLn(ไอพี, ไอคิว:8);
WriteLn(bR, bS:8);
การพิจารณาเพิ่มเติมเกี่ยวกับตัวดำเนินการของภาษาโปรแกรมระดับสูงจะดำเนินการโดยใช้ตัวอย่างของภาษาปาสคาล ตัวเลือกนี้เกิดจากความเรียบง่ายของภาษาและไวยากรณ์ที่เข้มงวด
ตัวดำเนินการมอบหมาย
ในภาษาปาสคาล ตัวดำเนินการกำหนดจะแสดงด้วยอักขระสองตัว ":=" ซึ่งระหว่างนั้นไม่มีช่องว่าง ด้านซ้ายของคำสั่งนี้ควรมีตัวแปร และด้านขวาควรมีนิพจน์ที่จะกำหนดค่าให้กับตัวแปร
บ่อยครั้งในภาษาปาสคาล คุณจะเห็นการสร้างแบบฟอร์ม p:=p+1 รายการนี้ไม่มีข้อผิดพลาด ภายในคอมพิวเตอร์ คำสั่งนี้ดำเนินการดังนี้: อันดับแรก ค่าเริ่มต้นของตัวแปรจะถูกนำมาใช้ ซึ่งจะถูกเพิ่มเข้าไป หลังจากดำเนินการเหล่านี้ ผลลัพธ์ของการคำนวณจะอยู่ในตัวแปร p ดังนั้น การเพิ่มตัวแปรจึงถูกนำมาใช้ในภาษาปาสคาล
สิ่งสำคัญคือต้องตรวจสอบให้แน่ใจว่าตัวแปรทั้งหมดที่เข้าร่วมในด้านขวาของคำสั่งการกำหนดได้รับการกำหนดไว้ตามเวลาที่ดำเนินการ ตัวดำเนินการกำหนดใช้นิพจน์ทางคณิตศาสตร์ซึ่งประกอบด้วยตัวแปร ค่าคงที่ เครื่องหมายตัวดำเนินการ วงเล็บ และการเรียกใช้ฟังก์ชันเป็นด้านขวาเพื่อคำนวณตัวแปรที่เป็นตัวเลข ในกรณีทั่วไป กฎสำหรับการสร้างนิพจน์จะคล้ายกับสัญกรณ์ทางคณิตศาสตร์ การดำเนินการไบนารีที่ใช้กับข้อมูลจำนวนเต็มแสดงในตารางที่ 1
สำหรับตัวอย่างการดำเนินการมอบหมาย ให้พิจารณาปัญหาในการคำนวณด้านตรงข้ามมุมฉากของสามเหลี่ยมจากสองขาที่รู้จัก ตามทฤษฎีบทพีทาโกรัส ด้านตรงข้ามมุมฉากจะถูกคำนวณโดยใช้สูตร:
ตารางที่ 1 - การคำนวณเลขฐานสองในประเภทจำนวนเต็ม
รหัสแหล่งที่มาของโปรแกรม:
โปรแกรม Op_prisv;
c:=sqrt(a*a+b*b);
โปรแกรมนี้ใช้ตัวดำเนินการกำหนดเท่านั้น ในกรณีนี้ในสองกรณีค่าเริ่มต้นจะถูกกำหนดให้กับตัวแปร - นี่คือขาของสามเหลี่ยม และในกรณีที่สาม จะมีการคำนวณนิพจน์ที่กำหนดรากของผลรวมของกำลังสองของขา
จากการใช้โค้ดนี้ โปรแกรมจะคำนวณค่าของด้านตรงข้ามมุมฉากของสามเหลี่ยมที่มีด้าน a, b และเก็บค่านี้ไว้ในตัวแปร c
คำสั่ง I/O
อินพุตและเอาต์พุตจำเป็นสำหรับโปรแกรมในการสื่อสารกับโลกภายนอก ดังนั้นจึงเป็นไปได้ที่จะรับข้อมูลอินพุตจากผู้ใช้และแสดงผลบนหน้าจอ เห็นได้ชัดว่าโปรแกรมที่ไม่มีเอาต์พุตนั้นไม่สมเหตุสมผล ในตัวอย่างก่อนหน้านี้ มีการพิจารณาการคำนวณด้านตรงข้ามมุมฉากของสามเหลี่ยมมุมฉาก อย่างไรก็ตาม หากไม่ใช้ตัวดำเนินการเอาต์พุต จะไม่สามารถค้นหาผลลัพธ์ที่ได้รับระหว่างการดำเนินการของโปรแกรมได้
ในภาษาปาสคาล คำสั่ง I/O จะเรียกว่าโพรซีเดอร์อย่างถูกต้องมากกว่า ทำหน้าที่แลกเปลี่ยนข้อมูลระหว่างโปรแกรมกับอุปกรณ์ภายนอก ตัวอย่างเช่น คุณสามารถป้อนข้อมูลจากแป้นพิมพ์ จากไฟล์ ข้อมูลออกไปยังหน้าจอหรือไปยังไฟล์
มีตัวดำเนินการสองตัวสำหรับการป้อนข้อมูลด้วยแป้นพิมพ์ในภาษาปาสคาล: Read และ Readln สำหรับเอาต์พุตหน้าจอ - เขียนและเขียน การเพิ่ม "ln" มาจากคำภาษาอังกฤษ "line" - line, line ตัวดำเนินการที่ลงท้ายด้วย "ln" จะเลื่อนเคอร์เซอร์ไปที่บรรทัดใหม่ตามผลการกระทำของพวกเขา ตัวอย่างเช่น ระหว่างการทำงานของคำสั่ง Write เคอร์เซอร์จะยังคงอยู่ที่ตำแหน่งถัดไปหลังจากพิมพ์อักขระตัวสุดท้าย และในกรณีของคำสั่ง Read ข้อมูลถัดไปจะถูกอ่านจากบรรทัดเดียวกับที่เคอร์เซอร์อยู่
บันทึกข้อมูลผู้ปฏิบัติงานแบบดั้งเดิมประกอบด้วยพารามิเตอร์ อย่างไรก็ตาม อาจไม่เป็นเช่นนั้น ในกรณีนี้ คำสั่ง Writeln จะทำการขึ้นบรรทัดใหม่ และคำสั่ง Readln จะรอให้ป้อนคีย์ใด ๆ
นอกจากเอาต์พุตมาตรฐานแล้ว Pascal ยังมีเอาต์พุตที่จัดรูปแบบซึ่งมีอยู่เพื่อให้เข้าใจการแสดงผลบนหน้าจอได้มากขึ้น เอาต์พุตที่จัดรูปแบบมีจำนวนตำแหน่งที่ต้องกำหนดให้กับค่าของตัวแปรระหว่างเอาต์พุต
ตัวอย่างของการใช้ตัวดำเนินการ I/O เราแก้ไขปัญหาการกำหนดด้านตรงข้ามมุมฉากของสามเหลี่ยมมุมฉากดังนี้:
โปรแกรม Op_vvod_vyvod;
เขียน ("ขา = ");
เขียน ("เคท b = ");
c:=sqrt(a*a+b*b);
writeln("ด้านตรงข้ามมุมฉาก = ",c:3:2);
writeln("กดปุ่มใดก็ได้เพื่อจบ...");
โปรแกรมนี้ใช้ตัวดำเนินการป้อนข้อมูลอินพุต - ขาของสามเหลี่ยมมุมฉาก ในการแสดงผลบนหน้าจอ จะใช้เอาต์พุตที่จัดรูปแบบ ผลลัพธ์ของโปรแกรมแสดงในรูปที่ 9
รูปที่ 9 - ตัวอย่างการทำงานกับคำสั่ง I/O
นอกจากนี้ โปรแกรมยังใช้คำสั่ง Readln โดยไม่มีพารามิเตอร์ ซึ่งยืนยันการสิ้นสุดของโปรแกรม ดังนั้นหลังจากกดปุ่มใด ๆ โปรแกรมจะแสดงข้อความว่างานเสร็จสิ้นแล้ว (ดูรูปที่ 10)
รูปที่ 10 - ตัวอย่างของตัวดำเนินการอินพุตที่ไม่มีพารามิเตอร์
ตัวดำเนินการจะอยู่ในส่วนตัวดำเนินการระหว่างคำหลักและคั่นด้วยเครื่องหมายอัฒภาค ตัวดำเนินการที่ไม่มีตัวดำเนินการอื่นเรียกว่าแบบง่าย:
ตัวดำเนินการกำหนดเป็นตัวดำเนินการพื้นฐานที่สุด มีการแสดงออกทางด้านขวาและ indet ผลลัพธ์จะถูกคั่นด้วยเครื่องหมายมอบหมาย:=
ตัวอย่างเช่น: y:=x + 5 div 2
คำสั่งเรียกโพรซีเดอร์ใช้เพื่อเปิดใช้งานโพรซีเดอร์ที่ผู้ใช้กำหนดหรือมาตรฐาน ตัวอย่างเช่น: clrscr; เป็นต้น
คำสั่งว่างไม่มีอักขระใด ๆ และไม่ดำเนินการใด ๆ โดยทั่วไป คำสั่งว่างจะใช้เพื่อข้ามไปยังจุดสิ้นสุดของบล็อกในเครื่องหรือส่วนกลางในกรณีที่จำเป็นต้องข้ามหลายคำสั่ง แต่ไม่ต้องออกจากบล็อก ในการดำเนินการนี้ คำสงวนส่วนท้ายจะนำหน้าด้วยป้ายกำกับและเครื่องหมายทวิภาค
ตัวดำเนินการกระโดดแบบไม่มีเงื่อนไข goto หมายถึง "ไปที่" และใช้ในกรณีที่หลังจากเรียกใช้ตัวดำเนินการบางตัวแล้ว จำเป็นต้องดำเนินการไม่ใช่ตัวดำเนินการถัดไปตามลำดับ แต่ตัวดำเนินการอื่นบางตัวที่มีป้ายกำกับกำกับไว้ ตัวอย่าง: gotometka1;
DATA INPUT/OUTPUT: อ่านขั้นตอน อ่านอินพุตของข้อมูลตัวเลข อักขระ สตริง ฯลฯ เพื่อให้โปรแกรมประมวลผลต่อไป รูปแบบ: อ่าน (x1,x2,x3…); หรืออ่าน(FV,x1,x2,x3…); โดยที่ x1, x2, x3.. เป็นตัวแปร FV เป็นตัวแปรที่เกี่ยวข้องกับไฟล์ จากตำแหน่งที่จะทำการอ่าน ขั้นตอนการอ่าน Readln คล้ายกับขั้นตอนการอ่าน เฉพาะการเปลี่ยนไปยังบรรทัดถัดไปเท่านั้นที่จะดำเนินการ ขั้นตอนการเขียน Write สร้างเอาต์พุตของข้อมูลตัวเลข อักขระ สตริง และค่าบูลีน รูปแบบ: เขียน (x1,x2,x3…); หรือ เขียน(FV,x1,x2,x3…);
โดยที่ x คือตัวแปร FV คือชื่อของไฟล์ที่สร้างเอาต์พุต Writeln คือการถ่ายโอนบรรทัด
26. ตัวดำเนินการป้อนข้อมูลจากแป้นพิมพ์
อ่าน ("รายการตัวแปร");
Readln("รายชื่อตัวแปร");
เขียน ("ป้อนค่า a="); อ่าน (a);
ใส่ค่า a= .
อ่าน (a); อ่าน (b); อ่าน (c); หรือ Readln(a, b, c);
อ่าน (c1, c2, c3, c4); (รอป้อนค่าของตัวแปรสัญลักษณ์ c1, c2, c3, c4 เช่น "U", "P", "A", "!" แล้วกด Enter )
เขียน (c1, c2, c3, c4); จะแสดงคำจารึก: Hurray!
27. ผู้ประกอบการที่เลือก
กรณี "พารามิเตอร์" ของ
"รายชื่อผู้ประกอบการที่ทำเครื่องหมายไว้"
อื่น ๆ "คำสั่ง" End;
ตัวอย่างของตัวดำเนินการสำหรับกำหนดลำดับของจำนวนเต็ม N ตั้งแต่ 0 ถึง 999:
0..9: writeln("ตัวต่อตัว");
10..99: writeln("สองหลัก");
100..999: writeln("สามหลัก")
อื่น writeln("ตัวเลข "N" ไม่อยู่ในช่วงที่กำหนด") end;
28. ตัวดำเนินการตามเงื่อนไข
ถ้า "เงื่อนไข" แล้วก็ "statement1" Else "statement2";
ตัวอย่างเช่น การคำนวณรากที่สองของตัวเลข "a" ดำเนินการภายใต้เงื่อนไข a>=0
IF a >= 0 จากนั้น b:= Sqrt(a) อย่างอื่นให้เริ่ม WriteLn("a<0"); Readln; Halt end;
คำสั่งหยุดยุติการทำงานของโปรแกรม
29. ตัวดำเนินการวงจร
ด้วยพารามิเตอร์
สำหรับ i:= N1 ถึง N2 ทำ "คำสั่ง";
สำหรับ i:= N1 ลงไปที่ N2 ทำ "คำสั่ง";
โดยมีเงื่อนไข
ในขณะที่ "เงื่อนไข" DO "คำสั่ง";
ทำซ้ำ "คำสั่ง" จนกระทั่ง "เงื่อนไข";
"เงื่อนไข" เป็นนิพจน์ประเภทบูลีน
30 .Jump ไปที่ตัวดำเนินการฉลาก
ไปที่ "ฉลาก";
M1: เขียน ("ป้อน x>=0"); อ่าน (x); ถ้า x<0 Then Goto M1;
ป้ายกำกับจะอธิบายไว้ในส่วนคำอธิบาย เช่น: ป้ายกำกับ M1;
31. อาร์เรย์เชิงเส้น
คำอธิบายของอาร์เรย์:
VarA:array[ 1. .30 ] ของไบต์;
S: อาร์เรย์[ 1. . 30] ของสตริง;
SO:อาร์เรย์[ 1. . 30 ]เชือก;
การกำหนดค่าให้กับองค์ประกอบอาร์เรย์:
ตอบ:= 5; ตอบ:= 4; เป็นต้น
S:= "อีวานอฟ"; S:= "เปตรอฟ"; เป็นต้น
การกำหนดค่าให้กับองค์ประกอบของอาร์เรย์ "y" โดยการพึ่งพา:
y=บาป(x) โดยที่ x= Pi * i/180, 0<= i <=180 .
สำหรับ i:= 0 ถึง 180 Do y[i]:= sin(Pi * i/180);
การกำหนดค่าสุ่มในช่วงตั้งแต่ -30 ถึง +40 ร้อยองค์ประกอบของอาร์เรย์ "R":
สุ่ม; สำหรับ i:=1 ถึง 100 ทำ R[i]:= - 30+Random(71);
วัตถุประสงค์แล็บ ก งานหนาม: เรียนรู้วิธีอธิบายตัวแปรอย่างถูกต้องโดยใช้ประเภทข้อมูลมาตรฐานต่อไปนี้: จำนวนเต็ม จริงและมีเหตุผล ศึกษาตัวดำเนินการอินพุต-เอาท์พุตของข้อมูล พัฒนาทักษะเชิงปฏิบัติในการทำงานกับระบบ PascalABC เรียนรู้วิธีสร้าง ป้อนเข้าสู่คอมพิวเตอร์ ดำเนินการและแก้ไขโปรแกรมอย่างง่ายในภาษาปาสคาลในโหมดโต้ตอบ ทำความคุ้นเคยกับข้อความวินิจฉัยคอมไพเลอร์เกี่ยวกับข้อผิดพลาดเมื่อดำเนินการ โปรแกรมที่ใช้อัลกอริทึมเชิงเส้น
ตัวดำเนินการคือชุดคำบริการ ตัวระบุ และอักขระพิเศษชุดพิเศษที่ดำเนินการบางอย่าง ตัวดำเนินการคั่นด้วยเครื่องหมายอัฒภาค ";" ตัวอย่างลำโพง
โอเปอเรเตอร์การกำหนด: (:=) ตัวดำเนินการกำหนดใช้เพื่อกำหนดค่าให้กับตัวแปร ตัวอย่างเช่น x:=1; ก:=5. 02; b:= 32*a+บาป(x); S:= "อีวาน อิวาโนวิช".
คำสั่งผสม: เริ่มต้น<операторы>จบ;
คำสั่งผสมใช้เพื่อบันทึกข้อความอื่น ๆ ในเนื้อหา ลำดับของคำสั่งนี้ถือเป็นคำสั่งเดียว คำสั่งนี้เริ่มต้นและสิ้นสุดส่วนการดำเนินการของโปรแกรมหลัก รูทีนย่อย ฟังก์ชัน คำสั่ง END สุดท้ายของโปรแกรมหลักตามด้วยจุด
คำสั่งอินพุต / เอาท์พุตข้อมูล
ตัวดำเนินการสี่ตัวถูกใช้เพื่อดำเนินการ I/O:
อ่าน อ่านLn เขียน เขียนLn คำสั่ง Read จัดเตรียมอินพุตสำหรับข้อมูลตัวเลข อักขระ สตริง และอื่นๆ เพื่อให้โปรแกรมประมวลผลต่อไป
รูปแบบ: อ่าน(X1, X2, .. , Xn) โดยที่ X1, X2, .. , Xn เป็นตัวแปรประเภทข้อมูลที่ถูกต้อง
ค่า X1, X2, .., Xn จะถูกพิมพ์อย่างน้อยหนึ่งช่องว่างบนแป้นพิมพ์โดยผู้ใช้และแสดงบนหน้าจอ ต้องป้อนค่าตัวแปรตามไวยากรณ์ของภาษาอย่างเคร่งครัด หากโปรแกรมมีคำสั่ง Read หลายรายการ ข้อมูลจะถูกป้อนในสตรีม เช่น หลังจากอ่านค่าของตัวแปรสำหรับคำสั่ง Read หนึ่งรายการ ข้อมูลสำหรับคำสั่ง Read ถัดไปจะถูกพิมพ์ในบรรทัดเดียวกับคำสั่งก่อนหน้า หนึ่งจนจบบรรทัด แล้วจึงเปลี่ยนไปยังบรรทัดถัดไป ตัวดำเนินการ ReadLn คล้ายกับตัวดำเนินการ ReadLn ข้อแตกต่างเพียงอย่างเดียวคือหลังจากอ่านค่าสุดท้ายในรายการสำหรับตัวดำเนินการ ReadLn หนึ่งตัว ข้อมูลสำหรับตัวดำเนินการ ReadLn ถัดไปจะถูกอ่านจากจุดเริ่มต้นของบรรทัดใหม่
คำสั่งเขียน (เขียน) สร้างเอาต์พุตข้อมูล
รูปแบบ: Write(X1, X2, .. , Xn) โดยที่ X1, X2, .. , Xn เป็นนิพจน์ประเภทจำนวนเต็ม, ไบต์, จำนวนจริง, ถ่าน, บูลีน ฯลฯ
ตัวอย่าง: เขียน (125); (นิพจน์แทนค่า) เขียน (A+B-C); (ผลลัพธ์ของนิพจน์จะปรากฏขึ้น)
คำสั่ง Write ช่วยให้คุณสามารถส่งออกค่าของตัวแปรได้ด้วยวิธีต่อไปนี้
ผลลัพธ์ของการแสดงทศนิยมของค่า I โดยเริ่มจากตำแหน่งของเคอร์เซอร์ (I):
แสดงผลการแสดงทศนิยมของค่า I ไปยังตำแหน่งขวาสุดของฟิลด์ความกว้าง p (I:p):
โดยที่ ַ คือช่องว่าง
3. การแสดงผลทศนิยมของค่า I ไปยังตำแหน่งขวาสุดของฟิลด์ที่มีความกว้าง p และส่วนที่เป็นเศษส่วนของตัวเลขที่มีความกว้าง q(I:p:q):
ตัวดำเนินการ WriteLn คล้ายกับตัวดำเนินการ Write แต่หลังจากค่าสุดท้ายในรายการสำหรับตัวดำเนินการ WriteLn ปัจจุบันแสดงขึ้น เคอร์เซอร์จะเลื่อนไปที่จุดเริ่มต้นของบรรทัดถัดไป คำสั่ง WriteLn เขียนโดยไม่มีพารามิเตอร์ ทำให้เกิดการป้อนบรรทัด
หากมีตำแหน่งไม่เพียงพอสำหรับเอาต์พุต ตัวเลขหรือข้อความจะแสดงแบบเต็ม และรูปแบบจะถูกละเว้น ยกเว้นรูปแบบเอาต์พุตของส่วนที่เป็นเศษส่วนของตัวเลข หากไม่ได้ตั้งค่ารูปแบบเอาต์พุต ค่าของตัวแปรจำนวนเต็มและสตริงจะแสดงเป็นค่าเต็มและค่าจริง - ด้วยจำนวนหลักที่สอดคล้องกับประเภทตัวแปร เช่น
ก:=5.12345678912345678912345; WriteIn("a=", ก); จะแสดงคำบรรยาย
กำลังโหลด...