Добавлен: 31.03.2023
Просмотров: 323
Скачиваний: 1
Пример работы этих операций:
var
x, y :byte;
begin
x := 6; {00000110}
y := 11; {00001011}
writeln(x shr 2); {00000001}
writeln(y shl 1); {00010110}
end.
2.7 Конструкции if-else.
Бывает такое, что в ходе выполнения программы, нужно что-то проверить и получить одобрения на выполнение определенных действий, или же если одобрения не было, то выполнить другую последовательность программы, дабы избежать ошибки. В языках программирования этого можно достигнуть с помощью условных операторов, которые проверяют условие к выполнению определенных действий. Чаще всего используется условный оператор if else, но так же есть и оператор case, который отличается оператора if else, и по моему даже удобнее, но не везде подойдет.
Рассмотрим каждый оператор в действии:
1) if else
var n: integer;
begin
write ('Введите целое число: ');
readln (n);
if n mod 2 = 0 then
write ('Число ', n, ' четное')
else
write ('Число ', n, ' нечетное');
readln
end.
Данная программа проверяет, четное или нечетное число мы ввели. Первым действием мы введем число и после этого оператор if с условием, если введенное число n без остатка делиться на два, и если это правда, то выполняется блок действием под if, но если это не правда, то выполниться блок, который находиться под else и потом программа продолжается дальше.
Так же можно использовать этот оператор без else, но для этого ; должна стоять в последней команде блока под if.
var n: integer;
var
a,b,c: integer;
begin
write('a=');
readln(a);
write('b=');
readln(b);
if a <> b then begin
c := a;
a := b;
b := c;
writeln('a=',a,'; b=',b);
end
else
writeln('Введены одинаковые числа');
readln;
end.
В данной программе мы меняем местами значения у двух введенных нами переменных, с условием, что они не равны. И правда, зачем менять местами два одинаковых значения и в таком случае команда выведет на экран сообщение о том, что элементы равны. Как вы могли заметить, то что блок под условием if заключен в операторные скобки begin-end, так нужно, так как в блоке if больше одной команды.
2)case
Данный условный оператор удобен в том случае, если у нас большое количество ответов. Его формат выглядит так:
case селектор of
значение1: оператор1;
значение2: оператор2;
значение3: оператор3;
...
else операторN
end;
В селектор вкладываем какое-нибудь значение, и оператор просматривает весь список, находящийся под case и если селектор будет совпадать, например, со значением «значение 2», то выполниться оператор2, в случае, когда такого значения не будет, то будет выполнен оператор else. Приведем пример работы с case:
var n: integer;
begin
write ('Введите класс школы: ');
readln (n);
case n of
1..4: writeln ('Младшие классы.');
5..8: writeln ('Средняя школа.');
9,11: writeln ('Старшие классы. Выпускной.');
10: writeln ('Старшие классы.');
else writeln ('Извини, но ты издеваешься…')
end;
readln
end.
Данная программа определяет к какому типу классов относиться введенное число. Вначале мы вводим число n и оператор case проверит все ответы, которые у него есть. Допустим мы введи число 14 и мы понимаем, что классы ограничены до 11, но это надо дать понять компьютеру, и когда он просмотрит весь список ответов, он убедится, ни одно значение оператора case не равно числу 14 и он выведет сообщение, которое подготовлено нами в else, но если мы введем число 3, он найдет в первой строчке, что тройка принадлежит интервалу от 1 до 4 и выведется сообщение 'Младшие классы.'.
2.8 Циклы.
Большое роль в программировании играют циклы. Циклы нужны для того, что выполнить одно и то же действие несколько раз. К примеру, нам нужно вывести цифры от 1, до 100 и если бы не было циклов, то нам бы пришлось 100 раз написать команду вывода и в каждой команде менять число. Согласитесь, что это глупо и очень долго. И поэтому мы с помощью циклов и нескольких строк смогли бы это реализовать.
На языке Pascal существуют 3 вида циклических конструкций, это циклы while, for и repeat. Каждый подробнее рассмотрим:
1) Цикл for
Цикл for еще зачастую называет счетчиком, так как он будет выполнен столько раз, сколько вы ему зададите. В заголовок этого цикла переменной присваивается значение, от которого начинается отсчет, и конечное значение, до которого счетчик будет заходить в тело цикла.
Он бывает двух типов:
for счетчик:=значение to конечное_значение do
тело_цикла;
for счетчик:=значение downto конечное_значение do
тело_цикла;
В первом случае отсчет пойдет от меньшего значения до большего, другими словами, если мы ему скажем выполни что-то, начиная с нуля и до 100, то он постепенно будет выполнять действия, и к начальному значению прибавлять один, и постоянно сравнивать с конечным значением, чтобы прекратить цикл, после того, как он выполнится 100 раз.
Во втором случае все подобно, только тут мы идем от большего к меньшему. Допустим, мы начинаем со 100 и до 0. В этом случае от первого значения будет вычитываться один, до момента, пока не станет нулем.
Пример работы цикла for:
var
i, n: integer;
begin
for i := 1 to 100 do
if i < 100 then
write (i, ' ')
else
write (i);
end.
Результат выполнения программы:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
2) Цикл while:
Этот цикл содержит предусловие, которое ограничивает его выполнение. Это значит, что цикл будет выполнятся, пока в условие в заголовке цикла будет возвращать значение true. Важно, чтобы в теле цикла были изменения с переменной, с которой происходит сравнение в заголовке функции, в противном случае может начаться зацикливание и цикл будет бесконечным, до момента, пока человек сам не остановит программу.
Рассмотрим пример с работой цикла while:
var
i, n: integer;
begin
i := 1;
while i <= 100 do begin
if i < 100 then
write (i, ' ')
else
write (i);
i := i + 1
end;
end.
Здесь переменная i меняется не автоматически в заголовке цикла, как это было в цикле for, а мы сами прописали действие, которое после каждого захода в тело цикла будет увеличиваться на один до того момента пока значение не будет <= 100.
Результатом выполнения работы будет то же самое, что и в предыдущем примере.
3) цикл repeat
Этот цикл очень подобный циклу while, но отличается тем, что цикл while может быть выполнен 0 раз, если первая проверка условия вернуло значение false. Иногда это не всегда подходит. Цикл repeat так же имеет условия, но только в конце тела, то есть команды, которые находятся в теле цикла обязательно выполнятся хотя бы один раз.
Рассмотрим пример работы с циклом repeat:
var
i, n: integer;
begin
i := 1;
n := 100;
repeat
if i < 100 then
write (i, ' ')
else
write (i);
i := i + 1
until i > n;
end.
Странно, но в логической проверке until п изначально видно, что вернется значение false, так как i изначально равно 1 и она не больше ста. Это отличие проверки условия у цикла repeat. Цикл будет выполнен до тех пор, пока в условии не вернет значение true. Результатом будет то же, что и в предыдущих двух примерах, но, если даже переменной n было присвоено значение 0, вывелось бы 1.
2.9 Операторы goto, break, continue, прекращение программы.
Сейчас мы поговорим об операторе goto, который позволяет перейти на указанное место в коде. Он помогает обойти линейный ход программы. Программы выполняются последовательно с верху вниз и это может поменять оператор безусловного перехода goto. Вообще не желательно его использовать, и многие программисты стараются этого избежать, так как он затрудняет чтение и понимание кода. Всегда можно обойтись без этого оператора.
Оператор goto обеспечивает переход от одного места кода в другое, которое помечено меткой, чтобы использовать эту метку, необходимо ее описать в разделе меток и описательно части программы, который начинается со слова label.
Рассмотрим пример работы оператора перехода goto:
label goback;
var num: real;
begin
goback:
write ('Введите число: ');
readln (num);
if num < 0 then
goto goback;
num := sqrt (num);
write ('Квадратный корень: ', num);
end.
Разберем по подробнее, что происходит в этой программе. Эта программа выполняет нахождение квадратного корня из под числа, которое мы ввели, но мы знаем, что найти корень из под отрицательного числа нельзя и это приведет к ошибке, по этому мы создали условие, что если введенное число num меньше 0 , то мы вернемся в начало кода и нам снова будет выведено сообщение о 'Введите число: ' , и программа будет ожидать следующего ввода, до тех пор пока не будет введено положительно число, в теле условного оператора if находиться команда, которая вернет нас в то место, где мы поставили метку goback.
Операторы break и continue.
Бывает такое, что нужно прервать какой-нибудь из выше упомянутых циклов, например, в связи с тем, что его дальнейшее прохождение уже не имеет смысла, и чтобы за зря не увеличивать время работы программы мы можем выйти из этого цикла с помощью операторов break и continue.
Чем отличаются эти два оператора? Оператор break производит полный выход из цикла и больше к нему программа не возвращается, а оператор continue позволяет пропустить все шаги, которые находятся ниже его, в теле цикла.
Рассмотрим пример работы оператора break.
var
i,n: integer;
begin
n := 100;
for i := 1 to n do begin
if i = 39 then begin
write ('Найдено число 39!');
break
end;
end;
end.
Данная программа перебирает все числа от 1 до 100 и ищет число 39, и как только она будет найдено, выпишется положительное сообщение и цикл прекратится.
Без оператора break мы бы заставили наш цикл for проделать еще лишних 61 шаг, что бы могло значительно сделать программу медленнее, если бы значение n было куда больше ста.
Рассмотрим пример работы оператора continue:
var
i, sum: integer;
begin
sum := 0;
for i := 1 to 5 do begin
if i mod 2 = 0 then begin
writeln('Найдено четное число: ', i);
continue
end;
sum := sum + i
end;
write (sum);
end.
Суть этой программы в том, что мы хотим посчитать сумму всех нечетных чисел от 0 до 5 (1, 3, 5) и вывести ее, помимо этого наша программа будет нам выводить сообщение о найденных четных числах, которые не будут входить в сумму. Оператором continue мы этого избежим, потому что как только условный оператор определит четное число, он пропустит все те операции, которые находятся ниже его.
Небольшой вывод по пройденной главе.
Все, что было пройдено ранее является основами основ, без которых создание более сложных программ не увенчалось бы успехом. Я рассказал, что такое переменные и какие основные типы они имеют, каким образом производится ввод и вывод данных, что такое условный оператор и для чего он предназначен, какие виды циклов существуют и как с ними работать. Все эти моменты очень часто используются в программировании и отталкиваясь от этих знаний можно будет уже делать более сложные и объемные программы.
3. Более интереснее.
В этой главе я расскажу о том, как создавать функции, как работать с массивами и файлами, короче все то, что тоже является не мало важным в написании сложных программ.
3.1 Функции.
Функции в языках программирования называют подпрограммами, и они являются главной особенностью структурного программирования. Функция представляет из себя составной оператор, объединяющий ряд простых операторов. В функциях бывают свои локальные переменные, которые никак не связаны с переменными глобальными или же которые находятся в основной части программы, даже если они имеют одинаковое имя.
Функции удобно использовать, когда нужно выполнить одну и ту же операцию несколько раз. Ее можно описать перед основной частью программы единожды и после пользоваться многократно.