O instrucțiune goală nu conține niciun caracter și nu efectuează nicio acțiune. Este folosit pentru a organiza trecerea la sfârșitul blocului în cazurile în care este necesar să săriți mai multe instrucțiuni, dar nu să ieșiți din bloc. Pentru a face acest lucru, sfârșitul cuvântului rezervat este precedat de o etichetă și două puncte, de exemplu:

Capitolul 2 Operatori Pascal Operatori structurali

Operatorii structurali sunt constructe construite din alți operatori conform unor reguli stricte. Ele pot fi împărțite în trei grupe: compuse, condiționate și repetitive. Utilizarea instrucțiunilor structurate în programul dvs. este adesea indispensabilă, deoarece acestea permit programatorului să facă programul său dependent de condiții precum cele introduse de utilizator. În plus, prin utilizarea operatorilor repetați, aveți posibilitatea de a procesa cantități mari de date într-o perioadă relativ scurtă de timp (acest lucru, desigur, depinde de procesor :)

Capitolul 2 Operatori Pascal

Această declarație este o colecție de un număr arbitrar de instrucțiuni, separate între ele printr-un punct și virgulă și delimitate de paranteze operator start și sfârșit. Este perceput ca o singură entitate și poate fi localizat oriunde în program unde este posibil un operator.

Capitolul 2 Operatori Pascal Operatori condiționali

Declarații condiționale sunt concepute pentru a selecta una dintre acțiunile posibile pentru execuție, în funcție de o anumită condiție (în acest caz, una dintre acțiuni poate fi absentă). Există operatori speciali pentru programarea algoritmilor de ramificare în Turbo Pascal. Una dintre ele este declarația if. Acesta este unul dintre cele mai populare mijloace de schimbare a ordinii de execuție a instrucțiunilor programului.

Poate lua una dintre formele:

Dacă<условие>apoi<оператор1>

altfel<оператор2>;

Dacă<условие>apoi<оператор>;

Operatorul se execută după cum urmează. În primul rând, se evaluează expresia scrisă în condiție. Ca rezultat al calculului său, se obține o valoare de tip logic (boolean). Dacă această valoare este „adevărată”, atunci instrucțiunea1 specificată după cuvântul apoi este executată. Dacă rezultatul este fals, atunci instrucțiunea 2 este executată. Dacă în loc de operator1 sau operator2 există o serie de operatori, atunci această serie de operatori trebuie inclusă între paranteze operatorbegin...end.

Rețineți că nu există punct și virgulă înaintea cuvântului else.

Exemplu 1. Scrieți un program care solicită vârsta copilului și apoi emite o decizie privind admiterea copilului la școală (vârsta ³ 7 ani).

Dacă v>=7, atunci scrieți('Acceptăm școala')

Exercițiu. Modificați acest program pentru a limita limita superioară de înscriere la școală la 16 ani.

Write('Introduceți vârsta copilului');

Dacă (v>=7) și (v<=16) then writeln(‘Принимаем в школу’)

else writeln('Nu este acceptat la școală');

Exemplu 2. Sunt date două numere. Cu cât mai mic dintre aceste numere este înlocuit cu suma acestor numere, cu atât mai mare - cu produsul.

Var x, y, s, p: întreg;

Scrie('Introduceți 2 numere');

apoi începe y:=s; x:=p; Sfârşit

altfel începe x:=s; y:=p; Sfârşit;

writeln('x=', x);

writeln('y=', y);

Dacă instrucțiunea If oferă o alegere între două alternative, atunci există un operator care vă permite să alegeți dintr-un număr arbitrar de opțiuni. Aceasta este declarația de selecție a cazului. Acesta organizează o tranziție către una dintre mai multe opțiuni în funcție de valoarea unei expresii, numită selector.

Vedere generală: Cazul k de

: <оператор1>;

: <оператор2>;

: <операторN>

altfel<операторN+1>

Aici k este o expresie de selecție care poate avea doar un tip ordinal simplu (întreg, caracter, boolean). , …sunt constante de același tip ca și selectorul.

Declarația Case funcționează după cum urmează. Mai întâi se evaluează valoarea expresiei selectorului, apoi se oferă implementarea operatorului a cărui constantă de selecție este egală cu valoarea curentă a selectorului. Dacă niciuna dintre constante nu este egală cu valoarea selectorului, atunci instrucțiunea care urmează cuvântului „altfel” este executată. Dacă acest cuvânt este absent, atunci este activat operatorul situat în afara limitei cazului, adică. după sfârşitul cuvântului.

Când utilizați declarația Case, trebuie respectate următoarele reguli:

1. O expresie selector poate avea doar un tip ordinal simplu (întreg, caracter, boolean).

2. Toate constantele care preced instrucțiunile alternative trebuie să fie de același tip ca și selectorul.

3. Toate constantele din alternative trebuie să fie unice în cadrul instrucțiunii de selecție.

Formulare de înregistrare a operatorului:

Selector tip interval:

1..10: writeln('un număr în intervalul 1-10');

11.. 20: writeln('un număr în intervalul 11-20');

elsewriteln('număr în afara intervalelor')

Selector de tip întreg:

Exemplu 1. Scrieți un program care să afișeze numele zilei săptămânii având în vedere numărul zilei săptămânii.

Write('Introduceți numărul zilei săptămânii');

1: writeln('luni');

2: writeln('Marți');

3: writeln('Miercuri');

4: writeln('Joi');

5: writeln('vineri');

6: writeln('sâmbătă');

7: scrieți(„duminică”)

elsewriteln('Nu există o astfel de zi');

Exemplu 2. Scrieți un program care să afișeze numele sezonului având în vedere numărul lunii.

Write('Introduceți numărul lunii');

1, 2, 12: writeln('Iarna');

3, 4, 5: writeln('Primăvara');

6, 7, 8: writeln('Vara');

9, 10, 11: scrieți(„Toamna”)

elsewriteln('Nu există o astfel de lună');

Ne-am întâlnit deja cu unul dintre cei mai des utilizați operatori în limbajul Turbo Pascal - operatorul de atribuire. Restul operatorilor de limbă sunt discutați mai jos.

Declarație compusă este o secvență de instrucțiuni de program arbitrare incluse între paranteze operator - cuvinte rezervate începe... sfârșit. Instrucțiunile compuse sunt un instrument important în Turbo Pascal, care face posibilă scrierea de programe folosind tehnologia modernă de programare structurată (fără instrucțiuni de salt). MERGI LA).

Limbajul Turbo Pascal nu impune nicio restricție asupra naturii operatorilor incluși într-un operator compus. Printre aceștia pot fi și alți operatori compuși - Turbo Pascal permite adâncimea arbitrară a cuibării lor:

Start……. ÎNCEPE……. începe …… …… sfârșit; ……Sfârşit; ……Sfârşit;

De fapt, întreaga secțiune a operatorului, încadrată de cuvinte începe... sfârșit, este un singur operator compus. De la cuvântul rezervat Sfârşit este o paranteză a operatorului de închidere, indică, de asemenea, sfârșitul operatorului anterior, așa că precedați-l cu un „;” opțional, iar în toate exemplele de mai jos nu vom face acest lucru.

Prezența punctului și virgulă înainte Sfârşitîn exemplele anterioare însemna că între ultima instrucţiune şi paranteza instrucţiunii Sfârşit este o afirmație goală. O instrucțiune goală nu conține nicio acțiune, doar un punct și virgulă suplimentar este adăugat la program. Practic, o instrucțiune goală este folosită pentru a transfera controlul la sfârșitul unei instrucțiuni compuse.

Operatori de limbaj Pascal

1. Operatori compusi si gol

Declarație compusă este o secvență de instrucțiuni de program arbitrare incluse între paranteze de instrucțiuni.

Turbo Pascal permite adâncimea de cuibărire arbitrară:
ÎNCEPE
...
ÎNCEPE
...
ÎNCEPE
...
Sfârşit;
Sfârşit;
Sfârşit;
Disponibilitate; before End este o instrucțiune goală.

2. Operatori de sucursale

DACĂ<условие>APOI<оператор1>

Condiție– valoare de tip BOOLEAN sau operație logică. Dacă condiția este adevărată, instrucțiunea sau blocul de instrucțiuni care urmează THEN este executat; în caz contrar, blocul de instrucțiuni după ELSE, dacă există, este executat.

Condițiile pot fi imbricate, caz în care orice parte ELSE care apare se potrivește cu partea THEN cea mai apropiată de ea „de sus”.

Exemplu:
Var
A, B, C, D: întreg;
ÎNCEPE
A:=1;
B:=2;
C:=3;
D:=4;
Dacă A > B Atunci
Daca C< D Then
Daca C< 0 Then
C:=0
(rețineți că înainte de Else)
(operatorul gol „;” nu este setat)
Altfel
A:=B;
Sfârşit.
dar ar putea fi și așa:
Dacă A > B Atunci
Daca C< D Then
Daca C< 0 Then
C:=0
Altfel
Altfel
Altfel A:=B

Luați în considerare un program care introduce un număr întreg arbitrar de la 0 la 15 și îl trimite la sistem hexazecimal:

Program Hex;
Var
Ch: Char;
N: întreg;
ÎNCEPE
Scrie ("n=");
ReadIn(N);
Dacă (N >= 0) și (N<= 15) Then
ÎNCEPE
Daca N< 10 Then
Ch:= Chr(Ord("0")+N)
Altfel
Ch:=Chr(Ord("A")+N-10);
Sfârşit
Altfel
WriteIn("Eroare");
Sfârşit.

3. Operatori de repetiție

Pentru<переменная цикла>:=<начальное значение>Spre (Jos)<конечное значение>Do<блок операторов>

Variabila trebuie să fie de tip întreg sau enumerat. Când bucla este executată, variabila buclă se schimbă de la valoarea inițială la valoarea finală în trepte de 1. Dacă este la, atunci variabila este incrementată dacă jos la- scade.

Condițiile de execuție a buclei sunt verificate înainte ca blocul de instrucțiuni să fie executat. Dacă condiția nu este îndeplinită, bucla For nu este executată. Următorul program calculează suma numerelor de la 1 la intrare:

Suma programului;
Var
I, N, S: întreg;
ÎNCEPE
Scrie ("n = ");
ReadIn(N);
S:=0;
Pentru I:=1 To N Do
S:=S + I;
Scrieți("Suma = ", S)
Sfârşit.

In timp ce<условие>Do<блок операторов>

Blocul de instrucțiuni va fi executat atâta timp cât condiția se evaluează la adevărat. Este necesar ca valoarea condiției să se poată modifica în timpul execuției blocului de instrucțiuni, altfel executarea buclei nu se va încheia niciodată (în DOS acest lucru va duce la înghețarea computerului). Dacă precondiția este falsă, blocul de instrucțiuni nu va fi niciodată executat.

Să găsim mașina „epsilon” pentru o variabilă de tip Real:
Programul Epsilondetect;
Var
Epsilon: Real;
ÎNCEPE
Epsilon:=1;
În timp ce Epsilon + 1 > 1 Do
Epsilon:= Epsilon/2;
Writeln("Epsilon = ", Epsilon);
Sfârşit.

Repeta<тело цикла>Pana cand<условие>

Blocul de instrucțiuni, indiferent de valoarea condiției, va fi executat cel puțin o dată. Bucla se termină dacă după următoarea execuție a blocului de instrucțiuni condiția se evaluează ca adevărată.

Exemplu: programul solicită un singur caracter și scoate codul său ASCII până când este introdus un caracter gol:

Cod program;
Const
Cr=13;
Var
Ch:Char;
ÎNCEPE
Repeta
Readln(Ch);
Writeln(Ch,"=",Ord(Ch));
Până la Ord(Ch) = Cr
Sfârşit.

caz<ключ выбора>De<список выбора>Altfel<оператор>Sfârşit;

<ключ выбора> - o expresie de orice tip enumerat,
<список выбора> - una sau mai multe structuri ale formei<значение ключа>:<блок операторов>.

Să scriem un program care simulează un calculator. Programul introduce două linii: primul conține două numere separate prin spațiu sau virgulă, al doilea este un simbol aritmetic.

2 2
*
Un semn al sfârșitului lucrării este introducerea oricărui caracter, altul decât +, -, /, *.

Program:
Program Calc;
Var
Operare: Char; (Insigna de operare)
X, Y, Z: Real;
Stop: boolean;
ÎNCEPE
Stop:= Fals;
repeta
Writeln; (Șir gol - Separator)
Scrie ("X, Y=");
ReadIn(X,Y);
Scrie ("Operațiune: ");
Readln(Operațiune);
Cazul de funcționare a
„+”: Z: = X+Y;
"-":Z:=X-Y;
„*”: Z: = X*Y;
"/":Z:=X/Y;
Altfel
Stop:= Adevărat;
Sfârşit;
Dacă nu te oprești, atunci
WriteIn("Z = ",Z);
Până la Stop;
Sfârşit.

Oricare dintre blocurile de instrucțiuni din listă poate fi precedat de mai multe valori de selecție, separate prin virgulă.

mergi la<метка>

Eticheta trebuie descrisă în secțiunea descrieri. Eticheta descrisă în procedură (funcție) este localizată în ea, astfel încât transferul controlului din exteriorul procedurii (funcției) către eticheta din interiorul acesteia este imposibil.

Capitolul 5. OPERATORI LINGVISTICI
Turbo Pascal-7 Operatorii limbajului descriu câteva acțiuni algoritmice care trebuie efectuate pentru a rezolva problema. Corpul programului poate fi reprezentat ca o secvență de astfel de declarații. Instrucțiunile de program consecutive sunt separate prin punct și virgulă. Toți operatorii limbajului Pascal pot fi împărțiți în două grupe: simpli și structurați. 5.1. Operatori simpli Operatorii simpli sunt cei care nu conțin alți operatori. Acestea includ: - operator de atribuire; - referire la procedura; - operator de salt neconditionat GOTO; este un operator gol. Referirea la procedură va fi luată în considerare în paragraful 10.1, restul - în această secțiune. 5.1.1. Operatorul de atribuire Acest operator atribuie valoarea unei expresii unei variabile sau unei funcții. Pentru aceasta se folosește semnul de atribuire: = , în stânga căruia se află numele variabilei sau funcției căreia îi este atribuită valoarea, iar în dreapta este expresia, a cărei valoare este evaluată înainte de atribuire. Puteți atribui valori variabilelor și funcțiilor de orice tip, cu excepția tipului de fișier. Tipul unei expresii și tipul unei variabile (sau funcție) trebuie să fie compatibile pentru atribuire (vezi 9.3). Exemplu. X:=Y; Z:= A + B; Res:= (I>0) și (I<100); I:= Sqr(J) + I*К; 5.1.2. Оператор безусловного перехода GOTO. Использование меток Оператор GOTO позволяет изменить стандартный последовательный порядок выполнения операторов и перейти к выполнению заданного оператора. Оператор, на который происходит переход, должен быть помечен меткой. Эта же метка должна быть указана и в операторе GOTO. Метки, используемые в Turbo Pascal, могут быть двух типов: - целым числом в пределах от 0 до 9999; - обычным идентификатором. Все используемые метки должны быть перечислены в разделе объявления меток, начинающемся зарезервированным словом label, например: label 1, 2, Metka; Одной меткой можно пометить только один оператор. Метка от помеченного оператора отделяется двоеточием. Использовать оператор GOTO следует крайне осторожно. Широкое его применение без особых на то оснований ухудшает понимание логики работы программы. Безусловный переход можно осуществлять далеко не из каждого места программы и не в любое место программы. Так, нельзя с помощью этого оператора перейти из основной программы в подпрограмму или выйти из подпрограммы, не рекомендуется осуществлять переход внутрь структурированного оператора, т. к. он может дать неправильный результат, и т. д. Более подробно о таких ограничениях см. [ 1 ]. Пример. Найти частное от деления целых чисел. program EXAMPLE4; label Out; {описание метки} var X, Y, Res: Integer; {описание переменных} begin Write("Введите делимое:"); {вывод сообщения на экран} ReadLn(X); {чтение числа} Write("Введите делитель:"); {вывод сообщения на экран} ReadLn(Y); {чтение числа} if Y = 0 then begin {это - Составной оператор, см. п. 5.2.1} WriteLn("Деление на ноль недопустимо! Выхожу..."); goto Out; {выход при нулевом делителе} end; Res:=X div Y; WriteLn("Частное равно: ",Res); Out: {метка "пустого" оператора} end. 5.1.3. Пустой оператор Пустой оператор не выполняет никакого действия и никак не отображается в программе (за исключением, быть может, метки или точек с запятыми, отделяющих пустой оператор от предыдущих или последующих операторов). Он может потребоваться для осуществления на него безусловного перехода (см. пример в п. 5.1.2). 5.2. Структурированные операторы Структурированными являются такие операторы, которые включают в себя другие операторы. К структурированным операторам относятся: - составной оператор; - условный оператор IF; - условный оператор CASE; - оператор цикла REPEAT; - оператор bucla WHILE; - operator bucla FOR; - operator peste înregistrări CU. Operatorul WITH va fi discutat în secțiunea 6.4, celelalte în această secțiune. 5.2.1. Instrucțiune compusă O instrucțiune compusă este un set de instrucțiuni executate consecutiv, cuprinse între paranteze operator begin și end: begin<оператор 1>; <оператор 2>; . . . <оператор N>Sfârşit; Poate fi necesar în cazurile în care, în conformitate cu regulile de construire a constructelor de limbaj, puteți utiliza UN operator, dar trebuie să efectuați mai multe acțiuni. O astfel de instrucțiune compusă include o serie de instrucțiuni care efectuează acțiunile necesare. În cele ce urmează, oriunde se va indica faptul că poate fi utilizat un singur operator, acesta poate fi și un operator compus. Declarațiile separate dintr-o instrucțiune compusă sunt separate unele de altele printr-un punct și virgulă (vezi exemplul din 5.1.2, unde corpul buclei reprezintă o instrucțiune compusă). Deoarece cuvântul end care se termină cu instrucțiunea compusă nu este o clauză separată, nu puteți pune punct și virgulă înaintea acestuia, altfel compilatorul va presupune că există o instrucțiune goală înainte de cuvântul end. Putem presupune că corpul programului însuși, deoarece este inclus în parantezele operatorului început și sfârșit, este, de asemenea, un operator compus. 5.2.2. Operatorul IF condiționat Operatorul IF implementează construcția algoritmică FORKING și modifică ordinea de execuție a operatorilor în funcție de adevărul sau falsitatea unei anumite condiții. Există două versiuni ale enunţului: dacă S atunci A else B; (furca completa) si daca S atunci A; (furca scurta) La acesti operatori: S - unii expresie booleană, al cărui adevăr este verificat; A este o instrucțiune care este executată dacă expresia S este adevărată; B este o instrucțiune care se execută dacă expresia S este falsă. Deoarece instrucțiunea IF condiționată este o singură clauză, nici atunci, nici altfel nu poate fi precedată de punct și virgulă. Exemple de utilizare a operatorului: dacă X< 0 then X:= -Y; if X < 1.5 then Z:= X + Y else Z:= 1.5; Пример. Ввести целое число и вывести символ, соответствующий этому числу в кодировке ASCII, если такой символ есть, или сообщение, что такого символа нет (управляющие символы не учитываются). program EXAMPLE5; var X: Integer; begin Write("Введите целое число: "); ReadLn(X); if (X >31) și (X< 256) then WriteLn("Соответствующий символ - ", Chr(X)) else WriteLn("Такого символа НЕТ") end. 5.2.3. Условный оператор CASE С помощью этого оператора можно выбрать вариант из любого количества вариантов. Структура этого оператора в Turbo Pascal: case S of Cl:<оператор1>; C2:<оператор2>; . . . CN:<операторN>; altfel<оператор>Sfârşit; În această structură: S este o expresie de tip ordinal a cărei valoare este evaluată; Cl, C2, ..., CN - constante cu care se compară valoarea expresiei S;<оператор1>, <оператор2>, ..., <операторN>- instrucţiuni din care se execută cea a cărei valoare constantă a expresiei S coincide;<оператор>- un operator care se execută dacă valoarea expresiei S nu se potrivește cu niciuna dintre constantele С1, ..., CN. Ramura else a declarației este opțională. Dacă este absentă și valoarea expresiei S nu se potrivește cu niciuna dintre constantele enumerate, întreaga instrucțiune este tratată ca fiind goală. Spre deosebire de instrucțiunea IF, puteți pune punct și virgulă înaintea cuvântului else. Dacă mai multe constante trebuie să execute aceeași instrucțiune, acestea pot fi separate prin virgulă (sau chiar variate, dacă este posibil), urmate de o singură instrucțiune. Exemplu. cazul I de 0,2,4,6,8: WriteLn("cifra pară"); 1,3,5,7,9: WriteLn("Odd Digit"); 10..100: WriteLn("Număr de la 10 la 100"); else WriteLnC"Număr negativ sau mai mare de 100") end; Un exemplu de utilizare a instrucțiunii CASE este de asemenea dat în 16.3.21. 5.2.4. Operatorul de buclă REPEAT Operatorul de buclă REPEAT organizează execuția unei bucle formată din orice număr de operatori, cu un număr de repetări necunoscut anterior. Corpul buclei este executat cel puțin o dată. Bucla se iese atunci când o expresie logică este adevărată. Structura acestei afirmații este: repetă<Оператор1>; <Оператор2>; . . . <ОператорN>; până la S; În această structură:<Оператор1>; <Оператор2>; <ОператорN>- instrucțiunile executabile care alcătuiesc corpul buclei; S este o expresie logică, al cărei adevăr este verificat la sfârșitul fiecărei iterații. Deoarece cuvintele se repetă și până sunt un fel de paranteze operator, nu este necesar să se pună punct și virgulă înaintea cuvântului până. Exemplu. Un program îmbunătățit care calculează suma a două numere (vezi exemplul de la pasul 2). programul EXEMPLUL 6; var X, Y, Suma: Real; Ch: Char; începe repetarea (începutul buclei) Scrie ("Introduceți numerele X și Y"); ReadLn(X, Y); Suma:= X + Y; WriteLn("Suma numerelor X și Y este ",Suma); Write("Încheierea programului?"); ReadLn(Ch); până când (UpCase(Ch) = "Y") sau (Ch = "y") sau (Ch = "Y") (funcția UpCase - returnează litera majusculă corespunzătoare.) final. 5.2.5. Instrucțiunea WHILE Loop Instrucțiunea WHILE execută o singură instrucțiune de un număr necunoscut de ori. Bucla se iese dacă o expresie logică este falsă. Deoarece adevărul expresiei logice este verificat la începutul fiecărei iterații (adică înainte ca corpul să fie executat), corpul buclei poate să nu fie executat nici măcar o dată. Structura operatorului buclă este: while S do<Оператор>; În această structură: S este o expresie logică, al cărei adevăr este verificat la începutul fiecărei iterații;<Оператор>- instrucțiunea buclă care urmează să fie executată. Exemplu. Găsiți toți divizorii unui număr întreg pozitiv (cu excepția 1 și a numărului însuși). programul EXEMPLUL 7; varX:Integer; Jumătate: întreg; Divizor: Integer; i: întreg; begin repeat Write("Introduceți un număr mai mare decât zero: "); ReadLn(X) ; daca X<= 0 then WriteLn("Неправильный ввод") until X >0; Jumătate:= X div 2; Divizor:= 2; i:= 0; în timp ce Divider<= Half do begin if X mod Divider = 0 then begin Inc(i); {увеличение счетчика на единицу} WriteLn(i, " -и делитель равен; ", Divider) end ; Inc(Divider) {увеличение делителя на единицу} end; if i = 0 then WriteLn("Делителей нет"); WriteLn("Конец решения") end . 5.2.6. Оператор цикла FOR Оператор цикла FOR организует выполнение одного оператора заранее известное число раз. Существует два варианта оператора: for <переменная цикла>:=<начальное значение>la<конечное значение>do<оператор>; pentru<переменная цикла>:=<начальное значение>jos la<конечное значение>do<оператор>; În acești operatori:<переменая цикла>- variabila de tip ordinal;<начальное значение>- o expresie (de tip ordinal) care definește valoarea inițială a variabilei buclei;<конечное значение>- o expresie (de tip ordinal) care definește valoarea finală a variabilei ciclului (cu această valoare, corpul ciclului (i.e.<оператор>) este executat ultima dată);<оператор>- operator de executat.<начальное значение>și<конечное значение>trebuie să fie compatibil pentru alocare cu o variabilă de buclă (vezi 9.3). Bucla funcționează astfel: - În primul rând, valorile de început și de sfârșit sunt calculate și stocate. - În continuare, variabilei ciclului i se atribuie o valoare inițială. - Valoarea variabilei buclei este apoi comparată cu valoarea finală. Mai mult, în timp ce parametrul buclei este mai mic sau egal cu valoarea finală (în prima versiune a operatorului) sau mai mare sau egal cu valoarea finală (în cea de-a doua versiune), se efectuează următoarea iterație; în caz contrar, bucla iese. Execuția următoarei iterații include mai întâi execuția<оператора>, iar apoi atribuirea valorii următoare mai mare (în prima versiune a instrucțiunii) sau următoarei valori inferioare (în a doua versiune) variabilei buclei. Desigur, dacă în prima variantă<начальное значение>mai mult decât<конечное значение>sau în a doua versiune mai puțin decât<конечное значение>, instrucțiunea nu este niciodată executată. După părăsirea buclei<переменая цикла>devine nedefinită cu excepția cazului în care bucla a fost ieșită cu o instrucțiune GOTO sau procedura standard Break. Exemplu. Afișați literele de la Z la A, programul EXEMPLUL8; var i: Char; începe pentru i:= „Z” în jos la „A” do Write(i); WriteLn final. Exemplu. Calculați 101 valori sin x cu pasul dat și scoateți prima valoare sinus negativă. programul EXEMPLUL9; eticheta 1; var Si: matrice de Real; (matrice de numere reale) Pas: Real; X: Real; i: întreg; begin Write("Introduceți pasul de calcul: "); ReadLn(Pas); X:=0; (argument inițial) pentru i:= 0 la 100 nu începe Si[i]:=Sin(X); X:= X + Sfârșitul pasului; pentru i:= 0 până la 100 face dacă Si[I]< 0 then begin WriteLn("Первое отрицательное значение синуса: ", Si[i], " Номер элемента: ", i); goto 1; end; WriteLn("Нет отрицательного значения"); 1: end. 5.2.7. Использование стандартных процедур Break и Continue в операторах циклов REPEAT, WHILE и FOR В версии 7.0 в циклах REPEAT, WHILE и FOR можно использовать две стандартные процедуры - Break и Continue. Процедура Break позволяет досрочно выйти из цикла, не дожидаясь выполнения условия выхода. Процедура Continue позволяет начать новую итерацию цикла, даже если предыдущая не завершена. Пример. В массиве целых числел (см. п. 6.1) найти первое отрицательное число и вывести его на экран дисплея. program EXAMPLE10; const N = 10; var Mas: array of Integer; {массив чисел} i: Byte; Yes: Boolean; begin WriteLn ("введите элементы массива"); {ввод чисел} for i:= 1 to N do begin Write ("Mas[", i, " ]= "); ReadLn(Mas[i]) end; Yes:= False; {предположим - число не найдено} for i:= 1 to N do {поиск отрицательного числа} begin if Mas[i] >= 0 apoi Continuare; (nu negativ => următorul număr) WriteLn("Primul număr negativ = ",Mas[i], " Number = ", i); (număr găsit) Da:= adevărat; pauză; (bucla de ieșire) capăt; dacă nu Da, atunci WriteLn("Nu există numere negative"); ReadLn final.

Instrucțiunile sunt executate secvenţial în ordinea în care sunt scrise în program. Operatorii sunt separați prin punct și virgulă. Toți operatorii Pascal sunt împărțiți în trei grupe: simpli (atribuire, salt necondiționat, apel de procedură, gol), input-output, structural (compozit, condiționat, repetiție).

Operatori simpli nu conțin alți operatori. Acestea includ:

1) Operator de atribuire(:=) instruiește să execute expresia pe partea dreaptă și să atribuie rezultatul variabilei al cărei identificator este situat în partea stângă:

identificator:=expresie;

Variabila și expresia trebuie să fie de același tip.

2) Operator de sărituri necondiționat(GOTO) înseamnă „mergi la” și are formatul:

MERGI LA_ eticheta;

Eticheta la care este transferat controlul trebuie descrisă în secțiunea etichetă, domeniul de aplicare al etichetei este blocul în care este descrisă.

3) Operator de apel de procedură (subrutină) servește la activarea unui utilizator predefinit sau a unei proceduri standard:

numele procedurii[(lista de parametri)];

Parametrii din listă sunt listați separați prin virgule. Procedurile sunt detaliate mai jos.

4) Declarație goală nu conține niciun simbol și nu îndeplinește nicio funcție. Poate fi localizat oriunde în program unde este permisă o declarație.

Declarații structurale sunt structuri construite din alți operatori după reguli strict definite. Acestea includ:

1) Enunț compus este un grup de un număr arbitrar de operatori, separați unul de celălalt prin punct și virgulă și delimitați prin paranteze de operator:

[Operatorul 1;

OperatorN]

O instrucțiune compusă este tratată ca o singură unitate și poate fi localizată oriunde în program unde sintaxa limbajului permite prezența unui operator.

2) Propoziții condiționale asigura executarea sau neexecutarea unei instrucțiuni, grup de instrucțiuni sau bloc, în funcție de condițiile date.

Operator de condiție poate lua una dintre următoarele forme:

1.IF_ condiție _APOI_ operator1 _ELSE_ operator2;

2.IF_ condiție _APOI_ operator;

Condiție– o expresie de tip boolean, la scrierea acesteia se pot folosi toate operațiile posibile ale relației. Dacă valoarea expresiei este adevărată, atunci operator1 dacă este fals - operator2. În a doua variantă, dacă expresia este falsă, atunci se execută instrucțiunea care urmează programului imediat după instrucțiunea IF. O instrucțiune IF poate fi conținută într-o altă instrucțiune IF, adică acest operator poate fi imbricat. În imbricarea instrucțiunilor, fiecare ELSE se potrivește cu THEN care îl precede imediat.

Exemplul 7 1) Programul de determinare a apartenenței unui punct cu Coordonatele X,Y un cerc cu raza R centrat la origine.

VAR X,Y,R,L: REAL;

WRITELN('Intra valorile X,Yşi R');

L:=SQRT(SQR(X)+SQR(Y));

IF-L

ELSE WRITELN('punctul este în afara cercului');

2) căutați în matrice elemente egale cu o valoare dată, determinând numărul acestora, formând un tablou din indicii acestor elemente și imprimându-l.

CITEȘTE(J); (setarea valorii)

FOR I:=1 TO N DOIF A[I]=J THEN START

(tipărește rezultatele căutării)

IF S=0 THEN WRITELN("nu sunt egali cu elementul specificat în matrice")

ELSE BEGIN WRITELN("în matrice ",s:3," elemente egale cu',J);

WRITELN(' numere de elemente egale cu date: ',)

(tipărirea unei matrice de numere de elemente)

FOR K:=1 TO S DO WRITE(' ',C[K]);

3) Selectați declarația vă permite să alegeți dintr-un număr arbitrar de opțiuni disponibile și are formatul:

CAZ_ expresie selector _DE

lista1: operator1;

lista2: operator2;

listaN: operatorN;

altfel[ operator]

În primul rând, se calculează valoarea expresii selectoare, atunci este furnizată implementarea acelui operator a cărui constantă de selecție este egală cu valoarea curentă a selectorului. Dacă niciuna dintre constante nu este egală cu valoarea curentă a selectorului, atunci instrucțiunea de după ELSE este executată.

Exemplul 8 Specifică intervalul în care se află numărul introdus de la tastatură.

1..10: WRITELN('numărul I=',I:3,'variază de la 1 la 10');

11..20: WRITELN('numărul I=',I:3,'este în intervalul de la 11 la 20');

21..30: WRITELN('numărul I=',I:3,'este în intervalul de la 21 la 30');

ELSE WRITELN('numărul I=',I:3,'în afara intervalului 1 - 30');

4) Operatori de repetare sunt folosite în organizarea ciclurilor.

PENTRU operator de repetiție constă dintr-un antet și un corp de buclă și poate avea două formate:

1. PENTRU_ parametru de buclă:=S1_TO_S2_DO_ operator;

2. PENTRU_ parametru de buclă:=S1_DOWNTO_S2_DO_ operator;

S1 și S2 sunt expresii care definesc valorile inițiale și finale ale parametrului ciclului. FOR...DO – antet ciclu, operator este corpul buclei. Corpul buclei poate fi o instrucțiune simplă sau compusă. Instrucțiunea FOR asigură că corpul buclei este executat cu o creștere a parametrului buclei (TO) sau cu o scădere a parametrului buclei (DOWNTO) cu unul.

În operatorul de repetare FOR, Pascal nu permite modificarea parametrului buclei cu o altă valoare decât una. Ca parte din operator instrucțiunile care modifică valoarea parametrului buclei sunt interzise.

Exemplul 9 1) Calculul variabilelor A și B, ale căror valori depind de variabila ciclului și tipărirea acestora.

ÎNCEPE A:=2*I; B:=4+I

WRITELN(A:3,B:4)

2) Transformarea unghiului în grade în radiani.

WRITELN('unghi în grade unghi în radiani');

PENTRU I:=0 LA 18 ÎNCEPEȚI

RAD:=GRAD*PI/180;

WRITELN(' ',GRAD:12:2,' ',RAD:12:4);

operator repetat are formatul:

corp de ciclu;

PANA CAND cuvânt;

Condiție– o expresie de tip boolean, la scrierea acesteia sunt permise operații booleene și operațiuni relaționale. Corpul buclei este un operator simplu sau compus. Corpul buclei este executat mai întâi, apoi condiția de ieșire a buclei este verificată. Dacă condiția nu este îndeplinită, atunci instrucțiunile corpului buclei sunt executate din nou, dacă este, bucla iese.

Instrucțiunea REPEAT are următoarele caracteristici: este executată cel puțin o dată, corpul buclei este executat în timp ce condiția este FALS, un număr arbitrar de instrucțiuni poate fi în corpul buclei fără suporturi operator, cel puțin una dintre instrucțiunile din corpul buclei trebuie să afecteze valoarea condiției, altfel bucla va rula pe termen nelimitat.

Exemplul 10 Calculul y=x 2 pentru x=8, 6, 4, 2.

WRITELN(X:3,Y:4);

WHILE repeta operator similar cu instrucțiunea REPEAT, dar condiția de executare a corpului buclei este verificată la începutul buclei. Operatorul are formatul:

IN TIMP CE_ condiție _DO_ corpul buclei;

Condiție- expresie booleană, corpul buclei este un operator simplu sau compus. Înainte de fiecare execuție a corpului buclei, condiția este evaluată; dacă condiția este îndeplinită, atunci corpul buclei este executat și valoarea condiției este evaluată din nou. Dacă condiția nu este îndeplinită, atunci bucla se iese și trece la prima instrucțiune după WHILE. În această declarație, programatorul însuși trebuie să aibă grijă de schimbarea variabilelor care determină ieșirea din buclă.

Toate declarațiile repetate pot fi imbricate.

Exemplul 11. 1) Creșteți variabila I cu 2 atâta timp cât este mai mică de 30.

IN TIMP CE EU<30 DO I:=I+2;

2) Calculul variabilelor A și N conform formulelor date până când 2*A devine mai mic sau egal cu 3*N+1.

CAT 2*A<=3*N+1 DO

ÎNCEPE A:=A*2; N:=N+1; ND;

3) Conversia unghiului în radiani în grade.

WRITELN('unghi în radiani unghi în grade');

ÎN CAZUL RAD<6,28 DO BEGIN

GRAD:=RAD*180/PI; WRITELN(' ',RAD:12:4,' ',GRAD:12:2);