Ако си спомняте, когато разглеждахме пример за оператор за присвояване, бяхме изправени пред необходимостта да разберем резултата от изпълнението на програмата. Разбрахме как да съхраняваме информация (в променливи), как да я обработваме (използвайки изрази), но два от най-фундаменталните информационни процеси бяха пропуснати от нашето внимание: получаване на информация и предаването й към света, външен за компютъра. Досега нашите програми могат да използват само информация, която е директно в текста на програмата. Разберете какви стойности този моментда има променливи също не беше възможно. Програмирането при такива условия е безсмислено.
Взаимодействието на устройствата за обработка и съхраняване на информация с външната среда (поне с потребителя) е абсолютно необходимо. За такъв интерфейс на езика Pascal отговарят операторите за въвеждане и извеждане на информация. Тези инструкции ви позволяват да въвеждате аргументи, параметри за изчисление по време на изпълнение на програмата (а не на етапа на писане), за да показвате изчислените данни във форма, разбираема за човек.
Изявления за първи вход (формати на изявления):
Прочети(<Список ввода>);
Readln(<Список ввода>);
В този формат тези команди ви позволяват да въвеждате данни в променливи по време на изпълнение на програмата от клавиатурата. Елементите на списъка за въвеждане могат да бъдат имена на променливи, които трябва да бъдат попълнени със стойности, въведени от клавиатурата.
Изпълнението на входните оператори се извършва по следния начин: програмата е спряна, курсорът се показва на екрана, компютърът очаква от потребителя набор от данни за променливите, чиито имена са посочени във входния списък. Потребителят от клавиатурата въвежда необходимите стойности в реда, в който се изискват от списъка за въвеждане, натиска Enter. След това въведените данни попадат в съответните им променливи и изпълнението на програмата продължава.
Забележка: входните данни са разделени с интервали.
Разликата между работата на процедурите Read и Readln (от ред Read) е следната: след изпълнение на Read стойността на следващите данни се чете от същия ред, а след изпълнение на Readln - от нов ред.
За показване на информация в Pascal има и две команди:
Напиши(<Список вывода>);
Writeln(<Список вывода>);
Този формат на използване на Write и Writeln ви позволява да показвате данни от изходния списък на екрана на монитора. Елементите на изходния списък могат да бъдат имена на променливи, изрази, константи. Преди да покаже стойностите на изразите, компютърът първо изчислява. Елементите на списъка, както и във входните оператори, се разделят със запетаи.
Разликата между двата изходни оператора е следната: след изпълнение на оператора Writeln (от реда Write), той преминава към нова линия, а след изпълнението на инструкцията Write преходът към нов ред не се извършва и отпечатването на следващите изходни команди Write или Writeln ще се извършва на същия ред. Когато извикате оператора Writeln без параметри, той просто прескача на нов ред.
Ето пример за използване на входни и изходни оператори:
Програмен интерфейс;
Write("Въведете радиуса на окръжността"); (Отпечатване на екрана с искане за въвеждане)
readln(R); (Въвеждане на стойност в променливата R от клавиатурата)
S:=4*ARCTAN(1)*SQR(R); (Изчислете площта на кръг (pR2))
Writeln("Площта на кръг с радиус ",R," е равна на ",S)
Тази програма подканва потребителя за радиуса на окръжност, предоставя възможност за въвеждане на неговата стойност, изчислява и показва площта на окръжност с такъв радиус. По този начин става възможно, без да правите промени в текста на програмата, да въведете различни стойности на радиуса и да получите съответните стойности на площта на кръга. За да направите това, достатъчно е да стартирате програмата няколко пъти. Тази програма също демонстрира следното правило: изходът на резултатите трябва да бъде коментиран, така че значението на отпечатаните числа да е ясно. Наистина би било възможно да се ограничим до Writeln(S), но значението на числото, изведено от програмата в този случай, би било ясно само за този, който е написал тази програма.
ОПЕРАТОРИ ЗА ВХОД И ИЗХОД
Нека разгледаме организацията на въвеждане и извеждане на данни от крайното устройство. Терминално устройство е устройство, с което работи потребителят, обикновено екран (дисплей) и клавиатура. За въвеждане и извеждане на данни се използват стандартните процедури за въвеждане и извеждане Read и Write, работещи със стандартни последователни 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);
Стойностите на първоначалните данни могат да бъдат разделени една от друга с интервали и чрез натискане на клавишите tab и Enter.
За показване на резултатите от програмата на екрана се използват следните оператори:
Write(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(rA, rB:10:2);
WriteLn(iP, iQ:8);
WriteLn(bR, bS:8);
WriteLn(chT, chV, chU, chW);
Етикети. Оператор за безусловен скок.
Всяка къща на улицата има свой собствен номер, всички хора имат собствени имена, дори клетките на компютърната памет имат свой собствен адрес. Всичко това се приема, за да може еднозначно да се посочи дефинираният обект. По подобен начин етикетите се използват за обозначаване на изрази в програмите.
Етикетът в езиковия стандарт Pascal е неотрицателно цяло число. Всички етикети, използвани в програмата, трябва да бъдат изброени в раздела за описание на етикети, който започва с ключовата дума Label, например:
Само един оператор може да бъде етикетиран с един етикет. Етикетът е отделен от етикетирания израз с двоеточие.
6: Вписване(14/2);
Във всички програми по-горе операторите бяха изпълнени един след друг в реда, в който бяха написани в текста. Такава алгоритмична структура се нарича директно следване. В езика Pascal обаче първоначално съществува оператор, който нарушава директното изпълнение на програмата, прехвърляйки управлението на произволна точка в нея. Такава инструкция се нарича безусловно разклоняване и има следния формат:
гото<метка>;
Изявлението, към което се извършва преходът, трябва да бъде маркирано с този етикет.
Използвайте оператора за безусловно разклоняване с изключително внимание, за да избегнете получаване на грешни резултати или пълно "зацикляне" на програмата. Като цяло използването на тази команда сред програмистите се счита за лоша форма. Както ще видите, винаги има възможност да се мине без него.
ЕЛЕМЕНТИ НА СТРУКТУРНОТО ПРОГРАМИРАНЕ
Структурирана програма (или подпрограма) е програма, съставена от фиксиран набор от основни конструкции. Нека разгледаме основните дефиниции и начините за формиране на тези конструкции в схеми на алгоритми.
Операциите, разклоненията и сливанията формират основните структури: следване, разклоняване, цикъл. Използвайки само тези три конструкции, е възможно да се реализира алгоритъм за решаване на всеки проблем.
Конструкцията, която е последователно изпълнение на две или повече операции, се нарича следното.
Конструкция, състояща се от разклонение, две операции и сливане, се нарича клон. Една от операциите може да липсва.
Структура, която има контролни линии, водещи до предишни операции или разклонения, се нарича цикъл.
Конструкциите за следване, разклоняване и цикъл могат да се разглеждат като операции, тъй като имат един вход и един изход. Произволна последователност от операции може да бъде представена като една операция.
Една операция може да бъде изпълнена от всеки PASCAL оператор (прост или съставен) или от група оператори, с изключение на оператора за преход GOTO.
В езика PASCAL броят на основните структури е увеличен на шест, това са:
Последвам;
разклоняване;
Цикъл с предусловие;
Цикъл с постусловие;
Цикъл с параметър;
Условен оператор
Една от основните алгоритмични структури е разклоняването (алтернативата).
Ако условието е изпълнено, тогава ще бъде изпълнена инструкция "1", ако не, тогава ще бъде изпълнена инструкция "2". Въпреки че има две действия в схемата, само едно ще бъде изпълнено, защото условието е или невярно, или вярно. Трети няма. Такава схема позволява решаването на проблеми, при които в зависимост от обстоятелствата е необходимо едно или друго действие. Няма съмнение, че броят на проблемите от този род е огромен. Освен това е много трудно да се измисли наистина смислена задача, чийто алгоритъм за изпълнение да съдържа просто директно следване на команди. Дори примитивен пример, взет от курс по математика, както ще видите, не може да бъде решен без разклоняване. Така че е необходимо да се изчисли стойността на израза y=1/x. Ти знаеш това дадена функцияне винаги има значение, т.е. не всички стойности на аргументи имат резултатна стойност. Нашата задача е да съставим алгоритъма по такъв начин, че изпълнителят в никакъв случай да не заседне, дори когато получи нула като аргумент. Не е трудно да се формулира това на естествен език:
1. Вземете x стойност.
2. Ако x=0, тогава отчетете, че изразът няма стойност, в противен случай изчислете y като 1/x.
По този начин се използва горната алгоритмична структура. Може да се изрази с прости думи:
Ако<усл.>(Ако условието е изпълнено)
Че<действие 1>(след това изпълнете действие #1)
в противен случай<действие 2>(в противен случай - изпълнете действие #2)
Как да го напиша на Паскал? Да, абсолютно същото, само на английски.
Формат на условен оператор в Pascal:
Ако<условие>
Тогава<оператор 1>
Друго<оператор 2>;
Обърнете внимание, че има само едно изявление в частите Then- и Else-частите. Но какво трябва да се направи, за да се реши проблем, при който при изпълнение или неизпълнение на условие е необходимо да се извършат не едно, а няколко действия? Тук на помощ идва съставният оператор, който вече познавате. Операторните скоби могат да включват произволен брой оператори.
Вариант на условния оператор в този случай:
Ако<условие>
Тогава Започнете<группа операторов 1>край
Else Begin< группа операторов 2>край;
Знакът "точка и запетая" не се поставя преди служебната дума Else, но операторите в групите са естествено разделени един от друг с този знак.
Сега нека поговорим за условията. В програмите на Pascal условията са изрази, чиято стойност е булева стойност. Тя може да бъде или проста променлива от посочения тип, или сложна последователност от изрази, свързани с логически операции.
При прости условия могат да се използват знаци за операции за сравнение: > (по-голямо от),<(меньше), =(равно), <>(не е равно), >= (по-голямо или равно),<=(меньше или равно).
Примери за прости условия: A=5 (Стойността на променлива A е 5)
(C+D3)>=(D1*(45-2)) (Стойността на израза от лявата страна е по-голяма или равна на стойността на израза от дясната страна)
С<>"ABC" (Стойността на променливата S не е равна на низовата константа "ABC")
Нека дадем пример за решаване на друга задача: "От две числа изберете най-голямото."
На пръв поглед решението е очевидно, но не е толкова тривиално, колкото изглежда.
Примерна програма;
VarA,B,C: Реални; (A,B - за съхраняване на аргументи, C - резултат)
Writeln("Въведете две числа");
ReadIn(A,B); (Въведете аргументи от клавиатурата)
Ако A>B Тогава C:=A Друго C:=B; (Ако A>B, тогава резултатът е A, в противен случай резултатът е B)
writeln(C); (Поставете резултата на екрана)
Друг класически пример: "Решете квадратно уравнение, като използвате дадените коефициенти." Тази задача е по-трудна, затова преди да напишем програмата, ще съставим алгоритъм, като го напишем под формата на блок-схема.Първо въвеждаме коефициентите, след това изчисляваме дискриминанта. Сега възникват две възможности: или липсата на реални корени в случай на отрицателен дискриминант, или тези корени все още могат да бъдат изчислени и показани в случай на неотрицателен дискриминант (случаят на дискриминантът да е равен на нула е включен тук , има два корена, само че те са еднакви J).
Когато пишете алгоритъм на език за програмиране, трябва да се има предвид, че в клона "не" няма едно действие, а три, следователно трябва да се използва съставен оператор. Не забравяйте да пишете аритметични изрази в съответствие с правилата на езика Pascal. Иначе тази програма не е по-сложна от предишната.
Var A, B, C, D, X1, X2: реален;
Writeln("Въведете коефициентите на квадратното уравнение");
Ако Д<0 Then Writeln ("Корней нет! ")
X1:=(-B+SQRT(D))/2/A;
X2:=(-B-SQRT(D))/2/A;
Интересното е, че условният оператор може да действа като оператор, който се изпълнява, когато дадено условие е изпълнено или не. В този случай се говори за вложени условни изрази. Когато решавате такива проблеми, силно препоръчвам да съставите блок-схема на алгоритъма в тетрадка. Само тогава, когато компилирате програма, трябва внимателно да запишете първо цялата Then-част и след това да преминете към Else-частта. Обикновено, когато пишете условни изрази в Pascal (особено с множество разклонения), командите се пишат с издатина надясно и надолу. Това увеличава видимостта и, повярвайте ми, намалява времето за отстраняване на грешки.
За да илюстрираме, нека решим друга задача: „решете уравнение от формата A*x^2 + B*x + C = 0“. Моля, не бъркайте с квадратното уравнение, за което знаехме, че коефициентът А не е равен на нула. Тук коефициентите могат да бъдат всякакви числа. Въз основа на елементарни математически разсъждения получаваме следния алгоритъм:
Var A, B, C, D, X, X1, X2: реален;
Writeln("Въведете коефициенти на уравнение (A, B, C)");
If C=0 Then Writeln("X е произволно число")
Else Writeln ("Без корени!")
Else Begin 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), или чрез аварийно спиране на самата програма, в случай на препълване на променлива, деление на нула и т.н.
В Pascal структурата на цикъла 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);
Стойностите на входните данни могат да бъдат разделени една от друга с интервали
и натискане на клавишите tab и enter.
За да изведете резултатите от програмата на екрана, използвайте
оператори:
Write(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: Boolean;chT, chV, chU, chW: Char;
. . . . . . . . . . . .
WriteLn(rA, rB:10:2);
WriteLn(iP, iQ:8);
WriteLn(bR, bS:8);
По-нататъшното разглеждане на операторите на езиците за програмиране на високо ниво ще бъде извършено на примера на езика Pascal. Този избор се дължи на простотата на езика и стриктния синтаксис.
Оператори за присвояване
В Pascal операторът за присвояване се обозначава с два знака ":=", между които няма интервал. Лявата страна на този оператор трябва да съдържа променлива, а дясната страна трябва да съдържа израз, чиято стойност ще бъде присвоена на променливата.
Много често в Pascal можете да видите конструкцията на формата p:=p+1. Този запис не съдържа грешка. Вътре в компютъра този оператор се изпълнява по следния начин: първо се взема началната стойност на променливата, към която се добавя единица. След тези действия резултатът от изчисленията се поставя в променливата p. Така променливата инкремент е реализирана в Pascal.
Много е важно да се гарантира, че всички променливи, които участват в дясната страна на оператора за присвояване, са дефинирани до момента на изпълнението му. Операторите за присвояване използват аритметични изрази, състоящи се от променливи, константи, операторни знаци, скоби и извиквания на функции като дясна страна за изчисляване на числови променливи. В общия случай правилата за конструиране на изрази са подобни на математическата нотация. Двоичните операции, приложими към целочислени данни, са показани в таблица 1.
За пример за изпълнение на операцията за присвояване, разгледайте проблема за изчисляване на хипотенузата на триъгълник от два известни крака. Според теоремата на Питагор хипотенузата се изчислява по формулата:
Таблица 1 - Двоични аритметични операции с целочислен тип
Изходният код на програмата:
Програма Op_prisv;
c:=sqrt(a*a+b*b);
Тази програма използва само оператори за присвояване. В този случай в два случая първоначалната стойност просто се присвоява на променливите - това са краката на триъгълника. И в третия случай се изчислява израз, който определя корена на сумата от квадратите на краката.
В резултат на изпълнението на този код програмата ще изчисли стойността на хипотенузата на триъгълник със страни a, b и ще съхрани тази стойност в променливата c.
I/O отчети
Входът и изходът са необходими на програмата за комуникация с външния свят - по този начин е възможно да се получават входни данни от потребителя и да се показват резултатите на екрана. Очевидно програма без изход няма смисъл. В предишния пример беше разгледано изчисляването на хипотенузата на правоъгълен триъгълник, но без използване на оператора за изход е невъзможно да се намери резултатът, получен по време на изпълнението на програмата.
В Pascal I/O операторите са по-правилно наречени процедури. Те служат за обмен на данни между програмата и външни устройства. Така например можете да въвеждате данни от клавиатурата, от файл, да извеждате данни на екрана или във файл.
В Pascal има два оператора за въвеждане от клавиатурата: Read и Readln. За екранен изход - Write и Writeln. Добавката "ln" идва от английската дума "line" - линия, линия. Операторите, завършващи на "ln", преместват курсора на нов ред в резултат на техните действия. Така, например, по време на операцията на оператора Write, курсорът ще остане на следващата позиция след последния отпечатан знак. А в случай на оператора Read, следващите данни ще бъдат прочетени от същия ред, където е курсорът.
Традиционният запис на операторски данни съдържа параметри, но те може и да не са. В този случай операторът Writeln просто ще имплементира нов ред, а операторът Readln ще изчака въвеждането на произволен ключ.
В допълнение към стандартния изход, Pascal предоставя и форматиран изход, който съществува, за да направи дисплея по-разбираем на екрана. Форматираният изход съдържа броя на позициите, които трябва да бъдат присвоени на стойността на променливата по време на изхода.
Като пример за използване на I/O оператори, ние променяме проблема за определяне на хипотенузата на правоъгълен триъгълник, както следва:
Програма Op_vvod_vyvod;
write("Крак a = ");
write("Katet 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; и т.н.
Празният оператор не съдържа никакви знаци и не извършва никакво действие. Обикновено празен оператор се използва за прескачане в края на локален или глобален блок в случаите, когато е необходимо да се пропуснат няколко оператора, но не и да се напусне блокът. За да направите това, запазената дума end се предхожда от етикет и двоеточие.
Операторът за безусловно прескачане goto означава „отиди на“ и се използва в случаите, когато след изпълнение на някакъв оператор е необходимо да се изпълни не следващият по ред, а някой друг оператор, маркиран с етикет. Пример: gotometka1;
ВХОД/ИЗХОД НА ДАННИ: процедура за четене Четене на въвеждане на числови данни, символи, низове и др. за по-нататъшна обработка от програмата. Формат: четене (x1,x2,x3…); или прочетете (FV,x1,x2,x3…); , където x1, x2, x3.. са променливи, FV е променлива, свързана с файла, откъдето ще се извърши четенето. Процедурата за четене на Readln е подобна на процедурата Read, само се извършва преход към следващия ред. Процедурата за запис Write произвежда извеждане на числови данни, знаци, низове и булеви стойности. Формат: Напиши (x1,x2,x3…); или Write(FV,x1,x2,x3…);
където x са променливи, FV е името на файла, където се произвежда изходът Writeln е прехвърляне на линия.
26. Оператори за въвеждане на данни от клавиатурата.
Read("списък с променливи");
Readln("списък с променливи");
Write("Въведете стойност a="); readln(a);
въведете стойността a= .
readln(a); readln(b); readln(c); или Readln(a, b, c);
Readln(c1, c2, c3, c4); (изчакване за въвеждане на стойностите на символните променливи c1, c2, c3, c4, например: "U", "P", "A", "!" и натискане на Enter )
Writeln(c1, c2, c3, c4); ще покаже надпис: Ура!
27. Оператор по избор.
Случай "параметър" на
"списък с маркирани оператори"
Else "изявление" End;
Пример за оператори за определяне на реда на цяло число N от 0 до 999:
0..9: writeln("един към един");
10..99: writeln("двуцифрен");
100..999: writeln("трицифрен")
else writeln("Числото "N" не е в посочения диапазон") end;
28. Условен оператор.
IF "условие" Then "statement1" Else "statement2";
Например, изчисляването на корен квадратен от числото "a" се извършва при условие a>=0,
IF a >= 0 Then b:= Sqrt(a) Else begin WriteLn("a<0"); Readln; Halt end;
Операторът Halt прекратява изпълнението на програмата.
29. Цикъл оператор.
С параметър
For i:= N1 To N2 Do "statement";
For i:= N1 DownTo N2 Do "statement";
С условие
Докато "условие" DO "изявление";
Повторете "изявления" До "условие";
"условие" е израз от булев тип.
30 .Преминете към оператор на етикет.
goto "етикет";
M1: Write("Въведете x>=0"); readln(x); Ако x<0 Then Goto M1;
Етикетите са описани в раздела за описание, например: Етикет M1;
31.Линейни масиви.
Описание на масивите:
VarA: масив [ 1. .30 ] от байт;
S: масив [ 1. . 30] от низ;
SO:масив[ 1. . 30]низ;
Присвояване на стойности на елементи от масива:
A:= 5; A:= 4; и т.н.
S:= "Иванов"; S:= "Петров"; и т.н.
Присвояване на стойност на елементите от масива "y" по зависимост:
y=sin(x), където x= Pi * i/180, 0<= i <=180 .
За i:= 0 до 180 Направете y[i]:= sin(Pi * i/180);
Присвояване на произволни стойности в диапазона от -30 до +40 сто елемента от масива "R":
рандомизирам; за i:=1 до 100 Do R[i]:= - 30+Random(71);
Лаборатория за цел А трънлива работа: научете как правилно да описвате променливи, като използвате следните стандартни типове данни: integer. реални и логични; изучавайте оператори за въвеждане-извеждане на данни, развивайте практически умения за работа със системата PascalABC, научете как да създавате, влизате в компютър, изпълнявате и коригирате прости програми на езика Pascal в диалогов режим, запознайте се с диагностичните съобщения на компилатора за грешки при изпълнение програми, които изпълняват линейни алгоритми.
Операторът е специален набор от служебни думи, идентификатори и специални знаци, които извършват определени действия. Операторите са разделени един от друг с точка и запетая ";". Примери за говорители.
Оператор за присвояване: (:=). Операторът за присвояване се използва за присвояване на стойности на променливи, например: x:=1; а:=5. 02; b:= 32*a+Sin(x); S:= "Иван Иванович".
Съставен израз: Начало<операторы>край;
Съставен израз се използва за записване на други изрази в тялото му, чиято последователност в този случай се счита за един израз. Този оператор започва и завършва секцията за изпълнение на основната програма, подпрограма, функция. Последният оператор END на основната програма е последван от точка.
Изявления за вход/изход на данни
Четири оператора се използват за извършване на I/O операции:
Четене, ReadLn, Write, WriteLn. Операторът Read предоставя вход за числови данни, знаци, низове и т.н. за по-нататъшна обработка от програмата.
Формат: Четене(X1, X2, .. , Xn), където X1, X2, .. , Xn са променливи с валидни типове данни.
Стойностите X1, X2, .., Xn се въвеждат на поне един интервал от клавиатурата от потребителя и се показват на екрана. Стойностите на променливите трябва да бъдат въведени в строго съответствие със синтаксиса на езика. Ако програмата има няколко оператора Read, данните за тях се въвеждат в поток, т.е. след прочитане на стойностите на променливите за един оператор Read, данните за следващия оператор Read се въвеждат на същия ред, както за предишния един до края на реда, след което се преминава към следващия ред. Операторът ReadLn е подобен на оператора ReadLn, единствената разлика е, че след прочитане на последната стойност в списъка за един оператор ReadLn, данните за следващия оператор ReadLn ще бъдат прочетени от началото на нов ред.
Операторът за запис (Write) генерира изходни данни.
Формат: Write(X1, X2, .. , Xn), където X1, X2, .. , Xn са изрази от тип integer, byte, real, char, Boolean и др.
Пример: Write(125); (израз, представен чрез стойност)Write(A+B-C); (показва се резултатът от израза).
Операторът Write ви позволява да извеждате стойностите на променливите по следните начини.
Извеждане на десетично представяне на стойността I, като се започне от позицията на курсора (I):
Извеждане на десетичното представяне на стойността I в най-десните позиции на полето с ширина p (I:p):
Където ַ е интервал.
3. Извеждане на десетичното представяне на стойността I в крайните десни позиции на полето с ширина p и дробната част на числото с ширина q(I:p:q):
Операторът WriteLn е подобен на оператора Write, но след като се покаже последната стойност в списъка за текущия оператор WriteLn, курсорът се премества в началото на следващия ред. Инструкцията WriteLn, написана без параметри, предизвиква преместване на ред.
Ако няма достатъчно позиции за изход, числото или текстът се показват изцяло и форматът се игнорира, с изключение на изходния формат на дробната част от числото. Ако изходният формат не е зададен, тогава стойностите на целочислените и низовите променливи се показват изцяло, а реалните - с броя на цифрите, съответстващи на типа променлива, например,
a:=5.12345678912345678912345; WriteIn("a=", a); ще покаже надписа.
Зареждане...