2. основни операции операции

2.5.1.Въвеждане на данни oт клавиатурата

където Read (прочети), Readln (прочети и премини на следващ ред) са запазени думи, а Входен списък представлява списък от променливи, разделени със запетаи. Променливите могат да бъдат от целочислен, реален и символен тип и от тип символен низ.

Например операторите

Read(Xn,Yn) и Readln(Xk,Yk)

са предназначени за въвеждане на стойностите на Xn, Yn, Xk и Yk.

За да се изпълнят тези два оператора трябва от клавиатурата да прибавим към входния поток от данни стойностите на Xn, Yn, Xk и Yk. Четирите стойности могат да бъдат разположени на един ред или на няколко реда. След стойността на Yk редът трябва да завършва, защото операторът Readln след прочитане на тази стойност ще приключи с четенето от този ред, следващ оператор вече ще чете от нов ред.

Редовете от входния поток се въвеждат един по един. Не е необходимо стойностите на всички променливи от даден входен списък да са включени в един и същи ред. С натискането на клавиша Enter в реда се извежда знака за край на ред, който е невидим, редът завършва и компютърът веднага прочита съдържащите се в него стойности и ги присвоява на съответните променливи от входния списък. Ако те са недостатъчни за всички променливи от списъка, компютърът очаква нови стойности в нови редове.

Редовете могат да съдържат до 127 символа. Във всеки ред може да има цели числа, реални числа, символи и символни низове. Те трябва да са подредени в същата последователност, в която са подредени съответстващите им променливи във входния списък. Между променливите от входния списък и стойностите им във входния поток трябва да има и съответствие по тип. Допуска се само едно изключение - на променлива от реален тип във входния списък да съответства целочислена стойност във входния поток.

Броят на символите на стойност от тип символен низ трябва да е равен на декларираната дължина на съответната променлива. Ако е по-малък, стойността трябва да се допълни със съответен брой празни позиции.

След стойност на числова променлива в реда трябва да има поне една празна позиция за отделянето й от стойността на следващата променлива от същия входен списък. Символите и символните низове не трябва да се разделят с празни позиции. Когато пред символ има празна позиция, тя се приема за стойност на променливата от символен тип от входния списък, а самият символ ще бъде прочетен като стойност на следващата променлива от входния списък и от тук нататък се нарушава съответствието между променливите във входния списък и стойностите в реда и всичко се обърква. Същото става и когато в реда се очаква символ, а се появи знак за край на ред. Ето защо трябва да се избягва във входен списък нечислова променлива да следва числова. Ако обаче това не може да се избегне, трябва във входния списък да включим след числовата променлива някаква измислена променлива от символен тип, която да прочете като своя стойност празната позиция между числовата и нечисловата стойности и по този начин да се запази съответствието между променливи и стойности.

Операторите Read(Xn,Yn) и Readln(Xk,Yk) се изпълняват по различен начин. Първият оператор прочита като стойности на Xn и Yn поредните две числа от реда със стойности и запазва възможността следващият оператор да прочете следващи числа от същия ред. Вторият оператор прочита следващите две числа от реда със стойности като стойности на Xk и Yk и приключва с четенето от този ред. Ако след стойностите на Xk и Yk има други стойности, те ще останат непрочетени. Следващ оператор за четене може да чете само от началото на нов ред.

1. Нека в оператора

Readln(XCoor,YCoor,R,N);

XCoor , YCoor и R са реални променливи, а N е целочислена променлива. Във входния поток първите три числа могат да бъдат реални или целочислени, докато четвъртото число задължително трябва да е целочислено. Не e съществено на колко реда ще бъдат разположени тези четири числа, но е важно реалните числа да са преди цялото, тъй като в списъка на оператора Read най-напред са записани имената на реалните променливи, а след това - на цялата. Един възможен начин за оформяне на входния поток в този случай е следният:

-25.3 50.7 20 3

Изпълнението на оператора за въвеждане започва с търсене във входния поток на стойност за първата променлива от списъка. Търсенето започва от мястото във входния поток, където е приключил предният оператор за въвеждане (четене). Четенето чрез оператора Read може да приключи по средата на реда и тогава следващият оператор (Read или Readln) ще чете от продължението на същия ред.

2. Нека N, XP1, XP2, YP1 и YP2 са числови променливи, които се въвеждат чрез операторите:

Readln(N); Read(XP1, YP1, XP2, YP2);

Ако входният поток е 5 25.7 32 30.4 -29, то първият оператор ще въведе числото 5 като стойност на N и ще подготви четенето със следващия оператор да започне от следващ ред, т.е. ще прескочи остатъка от реда и за XP1, YP1, XP2 и YP2 няма да се прочетат числата 25.7, 32, 30.4 и -29.

Очевидно числото 5 трябва да е на отделен ред, т.е. входният поток може да бъде оформен коректно например по следния начин:

5

25.7 32 30.4 -29.

125.32 42 QZ-35

за реалните променливи Vreal1 и Vreal2 съответно стойностите 125.32 и 42.0, за символните променливи Vchar1 и Vchar2 съответно стойностите Q и Z и за цялата променлива Vint - стойността -35.

Особеното на този входен поток е, че между числото 42 и символа Q има празна позиция. Входният оператор трябва да има вида:

Readln(Vreal1, Vreal2, C, Vchar1, Vchar2, Vint);

където C е символна променлива и служи само за прочитане на празната позиция след числото 42 или

Readln(Vreal1, Vreal2, Vchar1, Vchar1, Vchar2, Vint);

При такава ситуация често стойностите се групират в отделни редове, в случая например така:

125.32 42

QZ-35

Readln(Vreal1, Vreal2);

Readln(Vchar1, Vchar2, Vint);

2.5.2.Извеждане на данни на екрана

Изпълнението на оператора се заключава в изчисляване стойностите на изразите от списъка и извеждане на изчислените стойности на екрана, подредени в редове. Максималната дължина на един екранен ред е 80 символа. Чрез оператора Writeln може да се извеждат и по къси редове. С изпълнението на такъв оператор завършва формираният до този момент ред и следващият оператор за извеждане започва да извежда на нов ред. Оператор Writeln без изходен списък не извежда нищо на екрана, а само прекратява извеждания изходен ред. Следващ оператор за извеждане извежда стойностите на изразите от изходния си списък на нов ред. Ако този следващ оператор е отново без списък, той прекратява реда празен и минава на следващ, т.е. извежда на екрана един празен ред.

За всеки израз от изходния списък се отделя поле, чиято ширина зависи от неговия тип. Ширината на полето (в Турбо Паскал) за стойности на изрази от целочислен, символен и логически тип и тип символен низ е такава, каквато е необходима за самата стойност. Стойностите на изразите от реален тип се извеждат във формат с плаваща точка, т.е. във вида

x.xxxxххххххxExx,

като броят на цифрите в мантисата съответства на конкретния подтип.

Няколко примера:

1. Write(A,B);

Извежда стойностите на A и B една след друга без никакъв разделител между тях.

2. Write('A*B е равно на ',A*B);

Извежда текстовата константа такава каквато е (разбира се без апострофите в двата края) и плътно след нея извежда стойността на израза A*B в съответствие с неговия тип.

3. Write(M=N);

Изразът е от логически тип. Ще се намери стойността му (true или false в зависимост от това дали М е равно на N или не) и ще се изведе.

4. Writeln('Стойности на X и Y:'); Write('X=',X,', Y=',Y);

Първият оператор ще изведе константата от тип символен низ 'Стойности на X и Y:' и ще прекрати реда. т.е. на екрана ще се появи следният текст:

Стойности на X и Y:

Ако X и Y са целочислени със стойности съответно 25 и -100, вторият оператор ще изведе следния следващ ред:

X=25, Y=-100

Съществува възможност програмистът да форматира изхода, като предоставя за стойностите на изразите в изходния списък полета, различни, обикновено по- големи, от необходимите за самите стойности. Така може да се изведе колона от различно големи числа подравнени по последната цифра. Размер на полето за стойността на израз се задава както следва:

Израз : брой позиции на полето,

където броят позиции се указва с израз от цял тип.

Например

Writeln(A:8, B:15, C*D:12);

Когато полето е по-голямо от необходимото, стойностите на изразите се разполагат в дясната част на същото, а когато е по-малко, то автоматично се увеличава до необходимото за целите, логическите символните и символните низове, а при реалните се съкращава броят на цифрите в мантисата. Обикновено се задават полета, по-големи от необходимите, за да остават празни позиции пред извежданите стойности, които служат като разделители.

Реалните числа, изведени във формат с плаваща точка, са непрегледни. Затова е предвидена възможност за заявяване извеждането им и с фиксирана точка. Това става по следния начин:

където броят позиции се указва с израз от цял тип.

1. Writeln(A:8:3,B:5);

Ако променливата A е реална, а B - цяла и техните стойности са 22,5 и 34, ще се изведе ред със следното съдържание:

22.500 34,

т.е. редът ще съдържа: две празни позиции (Защо?), числото 22.500, три празни позиции (Защо?), числото 34.

2. Writeln('A*B е равно на ',A*B:10:3);

Ако променливите и техните стойности са същите както в предния пример, ще се изведе следният ред:

A*B е равно на 765.000

3. Write('Въведете стойностите на A,B и C: '); Readln(A,B,C);

Първият оператор ще изведе константата от тип символният низ, курсорът ще остане в края на изведения текст и от тук нататък може да започне редът със стойности от входния поток. След задаване на стойностите, както е показано по-долу, и натискане на клавиша Enter ще се прочетат стойностите и курсорът ще премине на нов ред. Следващ оператор за въвеждане или извеждане започва от нов ред.

На екрана това изглежда така:

Въведете стойностите на A, B и C: 50 25.55 -3.75

В този случай входният и изходният поток се смесват и Readln и Writeln предизвикват преминаване на нов ред, без да се държи сметка дали следващото действие е въвеждане или извеждане.

2.6.Програма с линейна структура

С променливите R и Н са означени радиусът и височината на цилиндъра, с S1 и S2 - съответно лицата на околната и пълната повърхнина на цилиндъра и с V - обема му. Всички променливи са от реален тип, тъй като съответните им величини могат да бъдат произволни реални числа. Стойността на  е известна в Турбо Паскал като стандартна константа от реален тип с име Pi.

1 Program PovObCyl;

2 Var R, H, V, S1, S2,B : real;

3 Begin

4 Write(’Задайте радиуса: ’); Readln(R);

5 Write(’Задайте височината: ’); Readln(H);

6 S1 := 2 * Pi * R * H;

7 B := Pi*sqr(R);

8 S2 := S1 + 2*B;

9 V := B * H;

10 Writeln; Writeln;

11 Writeln(’ ’:10,’ВХОДНИ ДАННИ:’);

12 Writeln(’ ’:12,’- радиус......’,R:7:2);

13 Writeln(’ ’:12,’- височина....’,H:7:2);

14 Writeln;

15 Writeln(’ ’:10,’РЕЗУЛТАТИ:’);

16 Writeln(’ ’:12,’- околна повърхнина...’,S1:8:2);

17 Writeln(’ ’:12,’- пълна повърхнина.....’,S2:8:2);

18 Writeln(’ ’:12,’- обем...........................’,R:8:2);

19 Readln

20 End.

В програмите на Паскал не е допустимо номериране на редовете. Тук то е направено за удобство при коментара на програмата, който следва.

Ред 1 е заглавието на програмата. То съдържа името PovObCyl. По-нататък ще пропускаме заглавието, тъй като за ТУРБО ПАСКАЛ то не е задължително.

Ред 2 представя описателната част на програмата и дефинира използваните в програмата променливи - те са две входни (R и H), три изходни ( S1, S2 и V) и една помощна (В).

Редовете с номера 3 ..19 представляват изпълнимата част на програмата.

Редове 4 и 5 съдържат по два оператора - първият извежда подсказващ текст, който съобщава на потребителя какво да направи, за да се изпълни вторият оператор, т.е. за да се въведе съответната стойност. Първият оператор е write, a не writeln, за да остане курсорът в края на подсказващото съобщение и въведената стойност да се появи непосредствено след него.

Редове 6 .. 9 съдържат операторите, които извършват необходимите пресмятания.

Редове 10 .. 18 извеждат данните и резултатите в прегледен вид.

Ред 19 съдържа оператора Readln. Той ще принуди компютъра да чака да се въведе завършен ред, т.е. да се натисне клавиша Enter. Това ще даде възможност да се видят резултатите преди да е приключила програмата и те да са изчезнали от екрана.

При изпълнение на програмата с R=15 и H=10, върху екрана на монитора ще се изведе следната информация:

Задайте радиуса: 15

Задайте височината: 10

ВХОДНИ ДАННИ:

- радиус...... 15.00

- височина....10.00

РЕЗУЛТАТИ:

- околна повърхнина... 942.48

- пълна повърхнина..... 2356.19

- обем........................... 7068.58

Xp, Yp, Xc, Yc, R : real;

Write(’Задайте координатите на точката:’); Readln(Xp,Yp);

Write(’Задайте координатите на центъра на окръжността:’);

Readln(Xc,Yc);

Write(’Задайте радиуса на окръжността:’); Readln(R);

Writeln;

Writeln(sqrt(sqr(Xp-Xc)+sqr(Yp-Yc)) <= R);

Readln

В тази програма е по-особен предпоследният оператор. Той е оператор за извеждане на данни с изходен списък от тип израз. Списъкът се състои само от един единствен израз, при това от логически тип. Тук най-напред се пресмята стойността на израза, която може да бъде True или False, и след това тя се извежда. Друг вариант на тази програма може да съдържа една променлива от логически тип, на която предварително се присвоява стойността на логическия израз и след това тя се извежда. При изпълнение на тази програма върху екрана на монитора ще се появи следното:

Задайте координатите на точката: 20 30

Задайте координатите на центъра на окръжността: 10 10

Задайте радиуса на окръжността: 20

FALSE

Стойност на покупката: xxx.xx

Сума, дадена от купувача: xxx.xx

Ресто xxx.xx

Използвани са две променливи от реален тип - Sum1 и Sum2 за означаване на входните данни.

Var

Sum1, Sum2 : real;

Write(‘Стойност на покупката’); Readln(Sum1);

Write(‘Сума, дадена от купувача’); Readln(Sum2);

Writeln('Стойност на покупката’,Sum1:6:2);

Writeln('Сума, дадена от купувача’,Sum2:6:2);

Writeln(’Ресто ’,Sum2-Sum1:6:2);