Турбо-Паскаль 7.0

BEGIN будем ставить в начале программы, чтобы компьютеру было видно, откуда она начинается. (Это правило мы очень скоро уточним). BEGIN переводится НАЧАЛО, читается "би'гин".

END с точкой ставится в конце программы, чтобы компьютеру было видно, где она кончается. END переводится КОНЕЦ, читается "энд".

Точкой с запятой необходимо отделять операторы друг от друга. Служебные слова BEGIN и END от операторов точкой с запятой отделять не нужно.

Итак, программа на Паскале, как и на многих языках, состоит из последовательности операторов, выполняемых компьютером в порядке записи. Так, выполняя нашу программу, компьютер сначала выведет на экран слово Начали! , затем число 9, затем число 3. На этом работа программы завершится. На экране мы увидим Начали!93

Программу совсем не обязательно записывать в столбик, можно и в строчку, лишь бы было ясно, в какой последовательности записана информация:

BEGIN Write( 'Начали!') ;

Write( 8 +1 ) ;Write( 5

-2) END.

Эта программа записана правильно и, с точки зрения компьютера, не менее изящно, чем предыдущая.

Неважно также, какими буквами - заглавными или строчными, полужирным шрифтом или обычным - записаны названия служебных слов и операторов.

bEgin WriTe( 'Начали!') ; write( 8+1) ; WRITE( 5-2) enD.

Я для более легкого чтения программ буду выделять полужирным шрифтом некоторые из служебных слов (список всех служебных слов вы найдете в 11.2) и другие общеупотребительные слова Паскаля.

Кроме вышеупомянутых элементов программа на Паскале может содержать комментарии. Это - любые пояснительные тексты, взятые в фигурные скобки. Во время выполнения программы компьютер не обращает на них внимания, они ему не нужны, а нужны программисту для более легкого понимания своей программы. Пример:

BEGIN

Write('Начали!'); {Это приказ напечатать слово «Начали!»}

Write( 8+1) ;

Write( 5-2) {А здесь компьютер из 5 вычтет 2 и напечатает результат}

END. {Не забыть бы точку}

Не забывайте брать комментарии в фигурные скобки, иначе компьютер подумает, что это операторы, не поймет их и сообщит вам, что у вас в программе ошибка. Правда, есть одно исключение, когда компьютер воспринимает заключенную в фигурные скобки информацию, как директиву на выполнение кое-каких действий, но об этом поговорим позже, в 15.2.

2.1.3 Выполняем первую программу на компьютере

Если у вас под рукой есть компьютер, то сейчас вам совершенно необходимо вашу программу на компьютере выполнить и посмотреть на результаты. (Если же до компьютера в ближайшем будущем не добраться, смело переходите к следующему параграфу.) Сейчас я вкратце поясню, в каком порядке и какие кнопки нужно нажимать на компьютере, чтобы это сделать. Пояснение рассчитано на тех, кому не терпится поскорее сесть за компьютер и кто уже имеет небольшой опыт работы на нем, в частности умеет вводить в компьютер две-три строчки текста и запускать, например, нужную игру. Остальным же нужно немедленно приступить к изучению части IV, где вас ждет то же пояснение, но уже основательное и подробное, рассчитанное на тех, кто начинает с нуля.

Торопыжкам все равно придется изучать часть IV, но, возможно, попозже. Основательным же скажу, что пока при последовательном изучении части IV вам достаточно остановиться на «Сообщениях об ошибках». «Пошаговый режим» и прочее оставьте на потом.

Итак, вот последовательность действий для опытных по выполнению первой программы на компьютере:

Запустите Паскаль. (файл turbo.exe). Наверху экрана возникнет меню, а под ним синее (обычно) окно во весь экран с мигающим курсором. Можно вводить программу. Если окно не появилось, то нажмите клавишу F10, а затем в меню слово File и New. (В дальнейшем для краткости я просто напишу File New).

Введите в это окно программу, как обычный текст в обычном текстовом редакторе.

Если получится, сохраните программу на жесткий диск. Для этого File Save, а затем в открывшемся диалоговом окне выберите каталог и введите имя файла, в который сохраните программу.

Выполните программу. Для этого выполните Run Run, а чтобы увидеть результаты, нажмите Alt-F5, что означает: удерживая нажатой клавишу Alt, щелкните по клавише F5. Выполнив программу в первый раз, поэкспериментируйте - измените содержимое операторов Write - и выполните программу еще раз.

Если в вашей программе Паскаль заметил ошибку, он ставит на нее (или недалеко от нее) курсор и сообщает о ней золотыми буквами на красном фоне. Наиболее распространенные для начинающих сообщения об ошибках вы найдете несколькими строками ниже. Более полный список - в части IV. Исправьте ошибку и вернитесь к пункту 3.

Распознаем сообщения компьютера об ошибках

Итак, вы добились того, чтобы ваша программа печатала нужный результат - Начали!93. Теперь давайте поэкспериментируем. Цель эксперимента - научить вас правильно реагировать на сообщения об ошибках, которые выдает Паскаль. Поскольку нужный результат напечатан, то в вашей программе ошибок нет. Придется нам намеренно вводить ошибки и наблюдать за реакцией Паскаля.

Сотрите точку после END. Теперь запустите программу. На экране появится сообщение Unexpected end of file, которое переводится Неожиданный конец файла. Паскаль нашел эту ошибку в программе и сообщает нам о ней, поставив курсор в строку, содержащую ошибку. Уберите сообщение компьютера клавишей Esc.

Исправьте эту ошибку и введите другую - сотрите точку с запятой после Write(`Начали!'). На этот раз сообщение такое - “;” expected, что значит - Ждал точку с запятой. Однако курсор стоит совсем не в том месте, где ошибка, а в начале следующего оператора. Вам придется привыкнуть к тому, что Паскаль не всегда точно определяет место ошибки.

Исправьте эту ошибку и введите другую - напишите само имя оператора с ошибкой - Wite(`Начали!'). Реакция Паскаля - Unknown identifier, что означает - Неизвестное имя. Имеется в виду имя процедуры Write.

Исправьте эту ошибку и введите другую - сотрите правую кавычку в операторе Write(`Начали!'), чтобы получилось Write(`Начали!). Реакция Паскаля - String constant exeeds line. Перевод вы пока не поймете, но в общем это намек на то, что раз кавычку открыли, то надо ее закрывать.

Теперь сотрите левую кавычку. Реакция Паскаля - Syntax error, что значит Синтаксическая ошибка. Паскаль в затруднении - он знает, где ошибка, но в чем она состоит - не знает.

Исправьте ошибки и введите другую - сотрите правую скобку в операторе Write(`Начали!'), чтобы получилось Write (`Начали!' . Реакция Паскаля - “)” expected, что значит - Ждал скобку.

Исправьте ошибку и введите другую - сотрите левую скобку в операторе Write(`Начали!'), чтобы получилось Write `Начали!'). Реакция Паскаля - “;” expected, что значит - Ждал точку с запятой, причем курсор стоит на букве Н. Вот здесь Паскаль неправ (это не значит, что он глупый, просто невозможно учесть все возможные причины ошибки). Вам придется привыкнуть и к тому, что Паскаль иногда неправильно определяет характер ошибки.

2.1.4 Процедура вывода WriteLn. Курсор

Оператор WriteLn - читается "райт 'лайн" , переводится - ПИШИ СТРОКУ. Правила его записи и выполнения те же, что и у Write, с одним исключением - после выполнения оператора Write следующий оператор Write или WriteLn печатает свою информацию в той же строке, а после выполнения оператора WriteLn - с начала следующей. Примеры:

ПРОГРАММА	ЧТО ВИДИМ НА ЭКРАНЕ
BEGIN Write ( 'Ама' ); Write ( 'зонка' ) END.	Амазонка
BEGIN Write ( 'Ама' ); WriteLn( 'зонка' ) END.	Амазонка
BEGIN WriteLn( 'Ама' ); Write ( 'зонка' ) END.	Ама зонка
BEGIN WriteLn( 'Ама' ); WriteLn( 'зонка' ) END.	Ама зонка

Все вышесказанное можно более точно описать с помощью понятия курсора. Если вы когда-нибудь вводили текст в компьютер с клавиатуры, то знаете, что вводимый вами текст для вашего удобства автоматически появляется на экране монитора. Вы также, вероятно, обратили внимание на короткую светлую черточку или прямоугольное пятнышко, которое "бежит" на экране перед вводимым текстом. Так, если вы вводите с клавиатуры слово BEGIN, то:

после нажатия на клавишу B на экране вы увидите B_

после нажатия на клавишу E на экране вы увидите BE_

после нажатия на клавишу G на экране вы увидите BEG_ и т.д.

Курсор предназначен для того, чтобы показывать пользователю, где на экране появится следующий символ, который он введет с клавиатуры. Курсор точно так же бежит по экрану впереди текста и тогда, когда информация появляется на мониторе не при вводе с клавиатуры, а во время исполнения программы в результате выполнения операторов Write или WriteLn,

Так вот. Разница между процедурами Write и WriteLn в том, что после выполнения Write курсор остается в той же строке, а после выполнения WriteLn курсор прыгает в начало следующей строки, а значит и все следующие символы волей-неволей будут выводиться в следующей строке.

Оператор WriteLn можно использовать просто для перевода курсора в начало следующей строки. Для этого достаточно написать одно слово WriteLn без скобок.

Задание 3: Определите без компьютера и изобразите на листке бумаги в клетку (один символ - одна клетка), что напечатает программа:

BEGIN

Write (1992);

WriteLn ( ' Mы начинаем!' );

WriteLn (6*8);

WriteLn;

WriteLn ('Шестью шесть ' , 6*6, '. Арифметика:' , (6+4)*3)

END.

Пояснение: Значок * обозначает умножение. Выполнив задание на бумаге, выполните программу на компьютере и сверьте результаты. Совпадает ли число пробелов между символами? Если не совпадает, еще раз прочтите материал, чтобы понять, почему. Измените число пробелов в разных местах последнего WriteLn. Как изменилась картинка на экране? Почему? Добавте рядом с пустым WriteLn еще один. Что изменилось? Почему?

2.1.5 Переменные величины. Оператор присваивания

Понятие переменной величины вам известно из школьной математики. Пусть несколько лет назад ваш рост равнялся 130 см. Обозначим этот факт так: r=130. Теперь он равен 140 см, то есть r=140. Получается, что величина r изменилась.Поэтому она называется переменной величиной. Числа 130 и 140 называются значениями переменной величины r.

Любой язык программирования умеет обращаться с переменными величинами. Без них он был бы очень слаб и смог бы извлечь из компьютера только возможности карманного калькулятора. Точно так же алгебра без переменной величины превратилась бы в арифметику. Однако, преимущества применения переменных величин нам откроются позже, а пока наша задача - к ним привыкнуть.

Что же мы можем делать с переменными величинами, программируя на Паскале? Прежде всего, мы можем задавать компьютеру значение той или иной переменной величины. Это мы можем сделать при помощи нового оператора, который называется оператором присваивания. Так, если мы хотим сказать, что а имеет значение 6, то должны записать а := 6 . Как видите, вместо значка = употребляется значок := . Он называется знаком присваивания , а сама запись а:=6 называется оператором присваивания. Говорят, что величине а присваивается значение 6. С момента выполнения оператора а:=6 компьютер будет помнить, что а равно шести.

Справа от значка := в операторе присваивания можно писать не только числа, но и переменные величины, и выражения. Выражение пока будем понимать так, как его понимает школьная математика. Например, после выполнения следующего фрагмента программы: . . . . a:=2*3+4; b:=a; y:=a+b+1. . . . компьютер будет знать, что a равно 10, b равно 10, y равно 21. Еще несколько примеров:

ФРАГМЕНТ ПРОГРАММЫ	ЧТО ЗАПОМНИТ КОМПЬЮТЕР
v := -2+10; h := 10*v; s := v+h	v=8 h=80 s=88
t := 0; n := 2*t+40; z := -n	t=0 n=40 z= -40

Необходимо помнить, что компьютер выполняет оператор присваивания "в уме", то есть результат его выполнения не отображается на экране. Если мы хотим видеть результат выполнения оператора присваивания, используем WriteLn. Примеры:

ФРАГМЕНТ ПРОГРАММЫ	ЧТО ВИДИМ НА ЭКРАНЕ
v := -2+10; h := 10*v; s := v+h; WriteLn (s)	88
v := -2+10; h := 10*v; s := v+h; WriteLn ( 's' )	s
v := -2+10; h := 10*v; WriteLn (v+h)	88
v := -2+10; WriteLn (v+10*v)	88
v := -2+10; h := 10*v; s := v+h; WriteLn (v, ' ' ,h, ' ' ,s)	8 80 88
v := -2+10; h := 10*v; s := v+h; WriteLn (v+1000, ' ' ,10*h, ' ' ,s)	1008 800 88

Нужно иметь в виду, что слева от знака := может стоять только переменная величина, но не число и не выражение. Можно писать с:=34, но нельзя писать 34:=с. Можно писать z:=f-v+990 , но нельзя писать f-v+990:=z. Правило это принято потому, что оператор присваивания сначала смотрит или вычисляет, какое значение имеет правая часть, а затем присваивает это значение переменной, стоящей в левой части. Нет смысла присваивать значение числу или выражению.

Обратите внимание на один важный момент. Когда школьник видит выражение (например, d+2d), он не обязательно его вычисляет. Он может его преобразовать или, скажем, упростить (получив 3d). Компьютер же, видя выражение, сначала его, может быть, и упростит, но затем обязательно вычислит. А для этого он должен знать численные значения входящих в него величин (в нашем случае это величина d). Таким образом, вычисляя правую часть оператора присваивания (например, y:=a+b+1), компьютер должен обязательно заранее знать, чему равны переменные, из которых эта правая часть состоит (в нашем случае это a и b). Ответственность за это знание лежит полностью на программисте. Пусть забывчивый программист записал такой фрагмент: . . . а:=10; y:=a+b+1 . . . , нигде в программе не придав b никакого значения. Естественно, при вычислении выражения a+b+1 компьютер не будет знать, чему равно b. В такой ситуации разные языки программирования поступают по-разному. Некоторые просто отказываются вычислять выражения, некоторые подставляют вместо b нуль, Паскаль же иногда может поступить довольно вредно: вместо b он подставит, что бог на душу положит, и получит сногсшибательный результат, например, игрек становится равным -8904 .

Подведем предварительные итоги обсуждения очень важного оператора присваивания:

Оператор присваивания состоит из знака присваивания := , слева от которого пишется переменная, а справа - число, переменная или выражение. При выполнении оператора присваивания компьютер "в уме" (то есть ничего не показывая на мониторе) вычисляет правую часть и присваивает вычисленное значение переменной, стоящей в левой части.

Задание 4: Какое значение будет присвоено переменной t после выполнения фрагмента: k:=1+2; s:=2*k; t:=6-s ?

2.1.6 Описания переменных (VAR)

В 4.5 я писал фрагменты программ, содержащих переменные величины. А теперь пришло время писать такие программы целиком. Но для этого я должен написать кое-что выше begin, чего раньше не делал. Вот пример программы:

VAR a,b : Integer;

BEGIN

a:=100;

b:=20;

WriteLn (a + b)

END.

Очевидно, эта программа напечатает число 120. В программе новостью для нас является только первая строка. Называется она описанием переменных величин а и b. Я пока не буду излагать правила составления описаний переменных. Скажу только, что описание начинается со служебного слова var (читается ВАР, это сокращение от английского variable - переменная). После него записываются имена всех переменных, встречающихся в программе с указанием через двоеточие типа значений, которые каждая переменная имеет право принимать. В нашем случае я записал имена переменных а и b, так как только они встречаются между BEGIN и END. Слово Integer (читается " 'интеджер", переводится ЦЕЛЫЙ) указывает, что а и b имеют право быть целыми числами, а не дробными. Смысл подобного ограничения в том, что Паскаль по-разному работает с целыми и дробными числами, а поскольку он язык строгий, то требует, чтобы программист точно указал, к какому из этих двух типов относятся числа.

Зачем нужно описание? Для понимания этого сначала нужно вспомнить, для чего нужна компьютеру память и как она устроена (см.3.2), а также порядок работы человека на компьютере (см.2.7).

После того, как программист ввел программу в память, он приказывает компьютеру ее исполнить. Но компьютер при этом не сразу принимается выполнять программу, а сначала совершает компиляцию, то есть перевод программы с Паскаля на собственный машинный язык. (Часто вместо термина «компиляция» употребляют более общий термин «трансляция»). Во время компиляции компьютер производит некоторые подготовительные действия, одним из которых является отведение в памяти места под переменные величины, упомянутые в программе. При этом компьютер "рассуждает" так: Раз в программе упомянута переменная величина, значит она в каждый момент времени будет иметь какое-то значение, которое, хочешь не хочешь, надо помнить. Лучше, чтобы не спутаться, заранее отвести в памяти определенное место для запоминания текущего значения каждой переменной величины и только потом уже выполнять программу. Будем называть место, отведенное в памяти под данную переменную, ячейкой.

Теперь нам понятно, зачем в паскалевской программе нужно описание - чтобы перечислить компьютеру переменные, под которые он должен отвести ячейки в памяти. Если мы забудем упомянуть в описании какую-нибудь переменную, то под нее в памяти не будет отведена ячейка и компьютер не сможет ее запомнить, а значит и вообще не сможет с ней работать. Паскаль строг к программисту, он заставляет его самого перечислять в описании все переменные, встречающиеся в программе. Бэйсик более добр - если программист поленился написать описание, Бэйсик сам просматривает программу и выискивает переменные величины, чтобы отвести для них место. Однако, не всегда доброта лучше строгости . . .

Итак, при решении задачи в памяти компьютера находится программа решения задачи, а в другом месте памяти - значения переменных, описанных в программе. Кстати, вы можете узнать, сколько байтов в памяти займет текст программы, если посчитаете, сколько в ней букв и других символов (включая пробелы).

Вы можете сказать: Зачем хранить значения 100 и 20 в каком-то другом месте, если они содержатся прямо в тексте программы, которая и без того хранится в памяти? Получается, что эти числа хранятся в двух разных местах памяти. Ответ на этот вопрос выходит за рамки книги.

2.1.6.1 Integer и LongInt

Итак, в Паскале принято правило, что если человек описал переменную, как Integer, то он разрешает ей принимать значения только целого числа. Число типа Integer занимает в памяти два байта. Значит, под переменные а и b компьютер отводит в памяти ячейки по два байта каждая. Два байта - это маленький объем памяти и уместиться в него может лишь небольшое целое число, а именно - число в диапазоне от -32768 до 32767. Если бы в предыдущем примере вам понадобилось взять а=40000, то Паскаль получил бы неправильную сумму.

Для того, чтобы переменная имела право принимать значения больших целых чисел, она должна быть описана не как Integer, а как LongInt (сокращение от Long Integer - Длинное Целое, читается “лонг'инт”). Под переменную типа LongInt компьютер отводит в памяти 4 байта и она может принимать значения в диапазоне от _2147483648 до 2147483647.

Задание 5: Население Москвы равняется а=9000000 жителей. Население Нью-Васюков равняется b=1000 жителей. Напишите программу, которая определяет разницу в числе жителей между двумя городами. Используйте переменные величины.

Задание 6: Попробуйте ввести ошибку. Опишите переменные величины не как LongInt, а как Integer. Какова реакция Паскаля?

2.1.7 Что делает оператор присваивания с памятью

Рассмотрим пример программы:

VAR a,b,y : Integer;

BEGIN

a:= 10;

b:= 6;

y:= a+b+1;

WriteLn (y+200)

END.

В программе между BEGIN и END встречаются три переменные, поэтому все они перечислены в описании VAR a,b,y : Integer . Компьютер отведет для них в памяти три двухбайтовые ячейки.

В 4.5 я рассказывал о работе оператора присваивания, используя такие выражения, как "компьютер знает", "компьютер помнит". Но нам необходимо более строгое понимание работы этого оператора, понимание "ближе к железу":

Выполняя оператор присваивания (например, y:=a+b+1), компьютер сначала смотрит на его правую часть (a+b+1). Если в ней встречаются переменные (в нашем случае это a и b ), то компьютер перед вычислением ищет их значения в отведенных под них ячейках памяти (и находит там 10 и 6), подставляет эти значения в правую часть и вычисляет ее. Затем вычисленное значение (17) компьютер записывает в ячейку памяти, отведенную под переменную, поставленную в левой части (y).

Таким образом, когда мы говорим "Компьютер запомнил, что а равно 2", мы подразумеваем "Компьютер записал в ячейку памяти, предназначенную для а, число 2".

А теперь рассмотрим, как будут заполняться информацией ячейки a,b,y в процессе выполнения нашей программы. В самом начале выполнения паскалевской программы в них находится неизвестно что. Первым выполняется оператор a:=10. Согласно только что приведенному определению оператора присваивания в ячейку a будет записано число 10. Затем выполняется оператор b:= 6 и в ячейке b появляется шестерка. Затем выполняется оператор y:= a+b+1. Компьютер смотрит, что находится в ячейках a и b, видит там 10 и 6, подставляет их в выражение a+b+1, получает 17 и записывает в ячейку y. Наконец выполняется оператор WriteLn (y+200). Компьютер заглядывает в ячейку y, видит там 17, вычисляет 17+200 и выводит 217 на экран.

Схематически этот процесс можно изобразить так:

ПОРЯДОК ИСПОЛНЕНИЯ ОПЕРАТОРОВ	ЧТО НАХОДИТСЯ В ЯЧЕЙКАХ ПАМЯТИ	ЧТО ВИДИМ НА ЭКРАНЕ
	a	b	y
a:= 10	10	?	?
b:= 6	10	6	?
y:= a+b+1	10	6	17
WriteLn (y+200)	10	6	17	217

Теперь мы можем также уточнить работу оператора WriteLn:

Если в скобках оператора WriteLn встречаются выражения с переменными величинами, то Паскаль находит в памяти значения этих величин, подставляет их в выражения, вычисляет выражения и результат выводит на экран.

Задание 7: Поменяйте местами операторы b:= 6 и y:= a+b+1. Что произойдет?

2.1.7.1 Оператор присваивания меняет значение переменной величины

Пока я не рассматривал программы, в которых переменные меняют свою величину. Теперь настало время такую программу рассмотреть:

VAR k : Integer;

BEGIN

k:=10; WriteLn (k); k:=25; WriteLn (k); k:=4; WriteLn (k)

END.

Запишем схематически процесс изменения информации в ячейке k:

ПОРЯДОК ИСПОЛНЕНИЯ ОПЕРАТОРОВ	ЧТО НАХОДИТСЯ В ЯЧЕЙКЕ ПАМЯТИ k	ЧТО ВИДИМ НА ЭКРАНЕ
k:=10	10
WriteLn (k)	10	10
k:=25	25
WriteLn (k)	25	25
k:=4	4
WriteLn (k)	4	4

Как видите, в процессе работы программы содержимое ячейки k меняется. Так, при выполнении оператора k:=25 там вместо значения 10 появляется 25. А куда же девается десятка? Она стирается, то есть компьютер забывает ее безвозвратно. Здесь действует общий принцип работы всех компьютеров:

Если в какое-нибудь место памяти или диска записывается новая информация, то старая информация, записанная там раньше, автоматически стирается, даже если она кому-то и нужна.

Раз теперь вместо 10 в ячейке k находится 25, то оператор WriteLn (k) печатает уже 25. Следующий оператор k:=4 запишет на место 25 четверку, а WriteLn (k) ее напечатает.

А что напечатает следующая программа?

VAR f : Integer;

BEGIN

f:=30;

f:=f+4;

WriteLn (f)

END.

Оператор f:=30 запишет в ячейку f число 30. А что сделает странный оператор f:=f+4? По определению оператора присваивания он сначала вычислит правую часть f+4 , подставив туда вместо f его значение, взятое из ячейки, и получит 34. Затем число 34 будет записано в ячейку, отведенную под переменную, обозначенную в левой части, то есть опять в ячейку f. При этом старое значение 30 будет стерто.

Таким образом, оператор f:=f+4 просто увеличивает число в ячейке f на четверку или, другими словами, увеличивает f на 4.

Задания 8-10:

Определите без компьютера, что будет напечатано при выполнении следующих фрагментов программ:

a:=100; a:=10*a+1; WriteLn (a)

a:=100; a:=-a; WriteLn (a)

a:=10; b:=25; a:=b-a; b:=a-b; WriteLn (a,' ',b)

2.1.8 Имена переменных

Мы привыкли переменные величины обозначать буквами (a, s, d ... ). Большинство языков программирования, в том числе и Паскаль, позволяет обозначать переменные не только буквами, но и целыми словами. Вот два равносильных фрагмента программы:

a:=3;	Summa:=3;
b:=4-a;	ROBBY:=4-Summa;
WriteLn (a,b+50)	WriteLn (Summa,ROBBY+50)

В том и другом случае будут напечатаны числа 3 и 51. Очевидно, компьютеру все равно, как мы обозначаем переменные величины, в смысл имен он не вдумывается и не удивляется, что переменная Summa никакой суммой не является, а просто числом 3.

Будем называть обозначение переменной именем или идентификатором этой переменной.

Правило:

Именем переменной в Паскале может служить любая последовательность цифр, латинских букв и знака подчеркивания, не начинающаяся с цифры.

Примеры правильной записи имен:

a

x

velichina

zzz

polnaja_summa

tri_plus_dva

s25

k1

_k1

___

a1b88qq

oshibka

Примеры неправильной записи имен:

ж - буква не латинского алфавита
polnaja summa - содержится символ (пробел), не являющийся буквой, цифрой или знаком подчеркивания
2as - начинается с цифры

Domby&Son - содержится символ & , не являющийся буквой, цифрой или знаком подчеркивания

2.1.9 Математика. Запись арифметических выражений

Если вы - школьник не самых старших классов, то не все, что здесь написано, будет вам понятно. Не огорчайтесь, при дальнейшем чтении непонятные вещи вам не понадобятся.

В правой части оператора присваивания и в операторе WriteLn мы записывали выражения, имеющие численное значение (например, a+b-8). Такие выражения называются арифметическими. В будущем мы увидим, что выражения могут быть не только арифметическими. А сейчас рассмотрим математические возможности Паскаля.

Четыре действия арифметики (и еще два) обозначаются в Паскале следующим образом:

ДЕЙСТВИЕ	РЕЗУЛЬТАТ	СМЫСЛ
2 + 3	5	плюс
4 - 1	3	минус
2 * 3	6	умножить
10 / 5	2	разделить
17 div 5	3	целочисленное деление
17 mod 5	2	остаток от целочисленного деления

На уроках математики мы привыкли писать ab+cd , подразумевая: a умножить на b плюс c умножить на d. В Паскале это выражение мы обязаны писать так: a*b+c*d. Иначе компьютер подумает, что нужно к переменной, имеющей имя ab, прибавить переменную, имеющую имя cd. Во избежание двусмысленности знак умножения положено писать всегда. Например, a * (b+c).

Скобки. Ввиду того, что с клавиатуры всю информацию приходится вводить символ за символом в одну строку, ввод двухэтажных выражений, таких как

,

очень затруднен. Поэтому для обозначения деления и выбрана косая черта. Это выражение на Паскале положено записывать так: (a+1)/(b+1). Если бы мы не поставили скобок, то выражение получилось бы таким a+1/b+1, а это неправильно, так как компьютер, как и мы, всегда перед сложением и вычитанием выполняет умножение и деление, поэтому в последнем случае он бы сначала разделил 1 на b , а затем к результату прибавил a и 1.

Вопрос: когда в выражениях можно ставить скобки? Ответ: всегда, когда у вас возникают сомнения в правильной очередности действий. Лишняя пара скобок не помешает. Пример: записать на Паскале выражение:

Его можно было бы записать так: (1 + a / (2+a*b)) / (3+a) * b . Однако, при такой записи мы не знаем, что Паскаль будет делать раньше - делить (1 + a / (2+a*b)) на (3+a) или умножать (3+a) на b. А от этого зависит результат. Добавим для верности пару скобок: ((1 + a / (2+a*b)) / (3+a)) * b . Теперь все в порядке.

К сожалению, в выражениях разрешается писать только круглые скобки. Квадратные и фигурные запрещены. От этого сложные выражения с большим количеством скобок на глаз воспринимаются с трудом, так как трудно для конкретной скобки увидеть ее законную пару. В этом случае я могу посоветовать идти "от малого к большому", то есть сначала заметить самые малые из взятых в скобки фрагменты выражения (у нас это 3+a и 2+a*b). После этого будет уже легче заметить более крупные фрагменты, такие как 1 + a / (2+a*b) , и т.д.

Запись десятичных дробей. Почти во всех языках программирования и уж, конечно, в Паскале, в десятичных дробях принято вместо запятой ставить точку. Пример: 62.8 - шестьдесят две целых восемь десятых.

Математические функции. Кроме четырех действий арифметики Паскаль может выполнять и другие математические действия, например, возведение в квадрат, для чего имеется специальная функция - Sqr. На уроке математики мы обозначаем показатели степени маленькими цифрами и буквами. На компьютере такие цифры и буквы вводить не всегда возможно, поэтому в Паскале принято другое обозначение. Например, пять в квадрате обозначается так - Sqr(5), a+b в квадрате так - Sqr(a+b). Здесь Sqr - сокращение от английского слова square - квадрат. То, что нужно возвести в квадрат, записывается в скобках.

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

ДЕЙСТВИЕ	РЕЗУЛЬТАТ	СМЫСЛ
Sqr (5)	25	возведение в квадрат
Sqrt (25)	5	корень квадратный
Pi	3.1415...	число пи
Frac (23.192)	0.192	дробная часть числа
Int (3.98)	3.0	целая часть числа
Round (5.8)	6	округление
Abs ( -20)	20	абсолютная величина (модуль) числа
Random	0.73088	случайное число из диапазона (0 - 1)
Random (200)	106	случайное целое число из диапазона (0 - 199)

Кроме этого, имеются функции sin, cos, arctan, exp, ln и процедура Randomize. К сожалению, в Паскале нет специальной функции для возведения в произвольную степень.

Примеры:

Выражение Sqr(2+1) при вычислении даст 9

Выражение 10+Sqr(2+1) при вычислении даст 19

Выражение 1+Abs(5-8) при вычислении даст 4

Выражение Sqr(2)+Sqrt(35+1) при вычислении даст 10

Выражение Sqrt(8+Int(41.5)) при вычислении даст 7

Выражение 21 div (Round(Pi+1)) при вычислении даст 5

Задание 11: Определите без компьютера, что напечатает данная программа:

VAR a,b: Integer;

BEGIN

a:=(Sqr(2)+1)*(20- Sqr(2*2))-11;

b:=11 div (a-4);

WriteLn (Sqr(a)+b-1)

END.

2.1.10 Вещественные числа в Паскале

Вот ошибочная программа:

VAR a,b,y : Integer;

BEGIN

a:=10; b:=6;

y:= a / b;

WriteLn (y)

END.

Паскаль откажется выполнять эту программу, так как знает, что при делении целого на целое результат может получиться дробный, а это значит, что в ячейку y придется записывать дробное число. Но описание VAR a,b,y : Integer запрещает это делать. Вот вам еще один пример придирчивости Паскаля. Если бы мы даже вместо b:=6 написали b:=2 , все равно Паскаль отказался бы делить.

Что же делать? Конечно же, Паскаль предлагает простой выход. Программист имеет право любую переменную описать не как целую (Integer), а как вещественную (Real). В этом случае переменная имеет право принимать любые целые и дробные значения. Вот правильная программа:

VAR a,b :Integer;

y :Real;

BEGIN

a:=10; b:=6;

y:=a / b;

WriteLn (y)

END.

По-английски Real читается " 'риэл", переводится "вещественный". Под переменную типа Real Паскаль отводит в памяти ячейку размером в 6 байтов.

Что мы увидим на экране в результате выполния оператора WriteLn (y)? Если вы думаете, что 1.666666 , то ошибаетесь. Переменные, описанные как Real, Паскаль выводит на экран в так называемом экспоненциальном формате (виде), с первого взгляда непонятном. Более подробно об этом и других форматах мы поговорим в 14.5, а пока, чтобы заставить Паскаль выводить вещественные числа в обычном, понятном виде, допишем кое-что в оператор вывода - WriteLn (y :8:3). Это значит, что мы хотим численное значение переменной y типа Real видеть на экране в привычном виде с 3 знаками после десятичной точки, а всё изображение числа не должно занимать больше 8 символов, включая целую часть, дробную часть, знак и десятичную точку. Этот оператор напечатает на экране 1.667. Здесь напечатано действительно 8 символов (три пробела, предшествующие единице, видны вам, как пустое место). Вместо 8 и 3 в операторе программист может писать любые имеющие смысл числа.

Поэкспериментируйте: (y :38:3), (y :20:10), (`Результат равен', y :8:3).

Три совета

Дорогой читатель! Если у вас под рукой есть компьютер, то вот вам три моих совета, по своей силе приближающихся к непререкаемым приказам:

1. Программы, которые вы видите в книге, вводите в компьютер и выполняйте их, даже если они кажутся вам почти понятными. В ряде случаев вы получите неожиданные результаты, из чего сделаете вывод, что программы эти вы поняли не до конца.

2. В каждой из этих программ экспериментируйте, то есть разными способами изменяйте в них то, что я как раз в этот момент объясняю. Например, если я объясняю оператор for i:=1 to 5, пробуйте for i:=1 to 10.

3. Выполняйте и сверяйте с ответом все задания. Это, конечно, главный совет из трех. Учтите, что сверенная с ответом правильно работающая программа - ваша победа, сверенная с ответом неправильно работающая программа - временное поражение, отказ от сверки - разгром.

Если вы пожалеете времени и пренебрежете этими советами, то через несколько страниц можете обнаружить трудности в понимании материала и вскоре не сможете правильно составить большинство программ.

2.1.11 Порядок составления простой программы

Задача:

Известны размеры спичечной коробки: высота - 12.41 см., ширина - 8 см., толщина - 5 см. Вычислить площадь основания коробки и ее объем .

Порядок составления программы:

1. Программист сам должен знать решение задачи. Ведь программа - это инструкция по ее решению. Нельзя давать инструкцию, не зная, как решать.

В нашем случае программист должен знать формулы для вычисления площади основания коробки и ее объема : площадь = ширина х толщина , объем = площадь х высота .

2. Нужно придумать имена переменным. Имя переменной должно говорить о ее смысле. Если смыслом является ширина коробки, то не ленитесь и не называйте ее а, потому что через полгода, разбираясь в своей полузабытой программе, вы будете долго тереть лоб и думать - Что, черт возьми, я обозначил через а? Называйте ее shirina (если вы не знаете английского) или, к примеру, width (если знаете). Так делают все профессиональные программисты (а они, как известно, терпеть не могут трудиться зря, значит, зачем-то это им нужно).

Удовлетворимся такими именами:

shirina - ширина

tol - толщина

visota - высота

pl - площадь

V - объем

3. Нужно определить, какого типа будут переменные. Поскольку ширина и толщина - целые, то и площадь будет целой. Высота и, следовательно, объем - вещественные. Первые две строки программы будут такими:

VAR shirina,tol,pl : Integer;

visota,V : Real;

4. Перед вычислениями нужно задать исходные данные решения задачи. Вот следующие две строки программы:

BEGIN

shirina:=8; tol:=5; visota:=12.41;

5. Теперь нужно задать компьютеру действия, которые нужно проделать с исходными данными, чтобы получить результат.

pl := shirina * tol;

V := pl * visota;

6. После получения результата его нужно напечатать. Действительно, все операторы присваивания компьютер выполняет "в уме". После их выполнения в ячейках памяти pl и V будут находиться числовые результаты решения задачи. Чтобы их узнать, человек в нашем случае может использовать оператор WriteLn, после чего программу можно заканчивать:

WriteLn (pl,' ', V :10:3)

END.

Обратите внимание, что поскольку переменная V имеет тип Real, для ее вывода мы использовали формат (см.4.10).

Вот как будет выглядеть наша программа целиком:

VAR shirina,tol,pl :Integer;

visota,V :Real;

BEGIN

shirina:=8; tol:=5; visota:=12.41;

pl := shirina * tol;

V := pl * visota;

WriteLn (pl,' ', V :10:3)

END.

Программа напечатает два числа: 40 и 496.400 .

Эту задачу можно было бы решить и гораздо более короткой программой:

BEGIN WriteLn (8 * 5, ' ' , 8 * 5 * 12.41 :10:3) END.

А еще быстрее эту задачу решить в уме. Однако, соблюдение приведенного мной порядка составления программы облегчит вам в дальнейшем программирование реальных задач для компьютера.

Задания 12-14:

Написать программы для решения следующих задач:

В углу прямоугольного двора размером 50х30 стоит прямоугольный дом размером 20х10. Подсчитать площадь дома, свободную площадь двора и длину забора. Примечание: в углу, где дом, забора нет.

Радиус окружности равен 800. Вычислить длину окружности и площадь круга. Результаты печатать с 5 знаками после десятичной точки.

Автомобиль 3 часа ехал со скоростью 80 км/час и 2 часа со скоростью 90 км/час. Вычислить среднюю скорость автомобиля (она равна суммарному пути, деленному на суммарное время).

2.1.12 Операторы ввода данных ReadLn и Read.

Задача: Сложить два числа - 20 и 16.

Сравним две программы решения этой задачи:

VAR a,b : Integer; BEGIN a:=20; b:=16; WriteLn (a+b) END.	VAR a,b : Integer; BEGIN ReadLn (a,b); WriteLn (a+b) END.

Программы отличаются только одной строкой. Первая программа не требует пояснений - она печатает число 36. Во второй программе нигде не сказано, чему равны a и b, а вместо этого включен оператор ReadLn. Поговорим о нем.

ReadLn читается "рид'лайн", переводится "читай строку". Он приказывает компьютеру остановиться и ждать, когда человек введет с клавиатуры определенную информацию, после чего продолжить работу. В частности, ReadLn (a,b) будет ждать ввода двух целых чисел.

Таким образом, если первая программа после запуска будет работать без остановки до самого конца и без хлопот выдаст результат, то вторая программа на операторе ReadLn остановится и будет ждать. Во время этого ожидания человек должен на клавиатуре набрать число 20 (так как первым в списке оператора ReadLn стоит a), затем нажать клавишу пробела, затем набрать 16 и нажать клавишу Enter. Паскаль воспринимает нажатие пробела, как сигнал человека о том, что закончен набор на клавиатуре одного числа и сейчас начнется набор другого. После набора на клавиатуре последнего числа необходимо нажать клавишу Enter в знак того, что ввод чисел для данного оператора ReadLn закончен и компьютер может продолжать работу. В соответствии с этим компьютер сразу же после нажатия Enter прекращает ожидание и прежде всего направляет число 20 в память, в ячейку a, число же 16 - в ячейку b. На этом он считает выполнение оператора ReadLn законченным и переходит к следующему оператору - WriteLn. В результате будет напечатано число 36.

Таким образом, обе программы делают одно и то же. Зачем же тогда применять ReadLn вместо оператора присваивания? Ведь первая программа понятней, да и работает без остановки. Одна из причин в том, что программа с ReadLn гораздо универсальнее, "свободнее": если первая программа решает задачу сложения только двух конкретных чисел, то вторая программа складывает два любых числа. Вторая причина в том, что программа с ReadLn позволяет программисту во время написания программы не задумываться над конкретными значениями исходных данных, оставляя эту головную боль на момент выполнения программы. Но самая главная причина в том, что ReadLn позволяет человеку общаться с компьютером, вести с ним диалог во время выполнения программы.

В подтверждение важности первой причины напишем программу для решения следующей задачи: В зоопарке три слона и довольно много кроликов, причем количество кроликов часто меняется. Слону положено съедать в сутки сто морковок, а кролику - две. Каждое утро служитель зоопарка сообщает компьютеру количество кроликов. Компьютер в ответ на это должен сообщить служителю общее количество морковок, которые сегодня нужно скормить кроликам и слонам.

Придумаем имена переменным величинам:

kol_krol - количество кроликов в зоопарке

kol_slon - количество слонов в зоопарке

norma_krol - сколько морковок в день положено кролику

norma_slon - сколько морковок в день положено слону

vsego - сколько всего требуется морковок

А теперь напишем программу:

VAR kol_krol,kol_slon,norma_krol,norma_slon,vsego :Integer;

BEGIN

norma_krol:=2;

norma_slon:=100;

ReadLn (kol_krol);

kol_slon:=3;

vsego := norma_krol * kol_krol + norma_slon * kol_slon;

WriteLn (vsego)

END.

Написав программу, программист вводит ее в компьютер, отлаживает и записывает на диск. На этом его миссия закончена. Утром служитель, пересчитав кроликов и найдя, что их 60 штук, подходит к компьютеру и запускает программу на выполнение.

Компьютер, выполнив автоматически первые два оператора (norma_krol:=2 и norma_slon:=100), останавливается на операторе ReadLn. Служитель вводит число 60, после чего компьютер посылает это число в ячейку kol_krol и переходит к выполнению следующего оператора ( kol_slon:=3 ). В конце концов на мониторе появится ответ: 420.

Вот схематическое изображение процесса выполнения программы:

ПОРЯДОК ИСПОЛНЕНИЯ ОПЕРАТОРОВ	ЧТО НАХОДИТСЯ В ЯЧЕЙКАХ ПАМЯТИ
	kol_krol	kol_slon	norma_krol	norma_slon	vsego
norma_krol:=2	?	?	2	?	?
norma_slon:=100	?	?	2	100	?
ReadLn (kol_krol)	60	?	2	100	?
kol_slon:=3	60	3	2	100	?
vsego:=norma_krol	60	3	2	100	420
WriteLn (vsego)	60	3	2	100	420

На следующее утро, обнаружив, что 5 кроликов продано другому зоопарку, служитель запускает ту же самую программу, вводит число 55 и получает ответ - 410.

На этом несколько фантастичном примере я хотел показать, что применение ReadLn позволяет создавать программы, которые, оставаясь приятно неизменными, позволяют легко решать задачу в любое время для любых значений исходных данных. Можно было бы пойти по другому пути - вместо ReadLn использовать оператор присваивания, например kol_krol:=60. Но в этом случае программист каждое утро должен был бы бежать в зоопарк, чтобы исправлять в программе этот оператор присваивания.

Оператор ReadLn можно писать и без скобок, просто так: ReadLn . Выполняя оператор в такой записи, компьютер остановится и будет ждать, но не ввода какой-то информации, а просто нажатия на клавишу Enter. Таким образом, это просто оператор создания паузы в процессе выполнения программы. О том, зачем нужны паузы, поговорим чуть ниже.

Кроме оператора ReadLn для ввода данных применяется также оператор Read. Для начинающего программиста различия в их применении несущественны. Мы будем пока употреблять только ReadLn. Оператор Read без скобок паузу не создает.

2.1.13 Интерфейс пользователя

Когда служитель запускает программу и она делает паузу на операторе ReadLn(kol_krol), служитель видит перед собой пустой экран монитора, на котором нет никаких намеков на приглашение вводить какую-либо информацию. Посторонний человек ни за что и не догадается, что компьютер чего-то ждет. Это не очень удобно. Было бы гораздо лучше, если бы на экране все-таки можно было в нужный момент видеть подходящее приглашение, чтобы служитель с раннего утра чего-нибудь не перепутал.

Это же касается и выдачи результатов. На пустом экране появляется сухое число 420. Посторонний человек ни за что не поймет, какой оно имеет смысл: то ли это 420 рублей, то ли 420 зоопарков. Говорят, что у нашей программы неудобный интерфейс пользователя, то есть человеку, использующему нашу программу, неудобно с ней общаться. Слово "интерфейс" можно перевести, как "взаимодействие", в данном случае взаимодействие человека с компьютером.

Дополним чуть-чуть нашу программу, чтобы интерфейс стал более удобным:

VAR kol_krol,kol_slon,norma_krol,norma_slon,vsego : Integer;

BEGIN

norma_krol:=2;

norma_slon:=100;

WriteLn ( 'Введите, пожалуйста, количество кроликов' );

ReadLn ( kol_krol);

kol_slon:=3;

vsego := norma_krol * kol_krol + norma_slon * kol_slon;

WriteLn( 'Вам всего понадобится ' ,vsego, ' морковок' );

ReadLn

END.

Эта программа будет работать точно так же, как и предыдущая, с тем отличием, что во время паузы, вызванной оператором ReadLn ( kol_krol), на экране будет гореть удобная надпись -

Введите, пожалуйста, количество кроликов

а результат будет выведен на экран в виде -

Вам всего понадобится 420 морковок

Оператор ReadLn без скобок в конце программы нужен для нейтрализации одной неприятной особенности в работе Паскаля. Дело в том, что выполнив программу, Паскаль торопится погасить экран с результатами решения задачи и делает это так быстро, что человек просто не успевает эти результаты разглядеть. Оператор ReadLn, поставленный после оператора WriteLn, выводящего результаты на экран, задает паузу. Во время этой паузы экран не гаснет, так как программа еще не выполнилась до конца, и человек может спокойно разглядеть результаты. После этого он нажатием клавиши Enter позволит компьютеру продолжить выполнение программы (в нашем случае после ReadLn стоит END с точкой, поэтому программа завершится).

Часто, впрочем, можно обойтись и без ReadLn. Нажав пару клавиш на клавиатуре (Alt-F5), мы можем снова зажечь погасший экран с результатами. В дальнейших примерах я буду для экономии места и "смысла" обходиться без ReadLn.

Задания 15-16:

Написать с использованием интерфейса программы решения задач:

Длина одной стороны треугольника равна 20. Длины двух других сторон будут известны только после запуска программы на выполнение. Вычислить периметр треугольника.

В компьютер вводятся путь, пройденный телом, и скорость тела. Найти время движения тела.

2.1.14 Строковые переменные

Сравним две программы:

VAR a : Integer; BEGIN a:=98; WriteLn (a) END.	VAR a : String; BEGIN a:='Привет всем!'; WriteLn (a) END.

В первой программе описание VAR a : Integer говорит о том, что переменная a обязана иметь числовое значение, а оператор a:=98 записывает в ячейку a число 98.

Во второй программе описание VAR a : String говорит о том, что переменная a обязана иметь строковое (текстовое) значение, то есть ее значением будет не число, а произвольная цепочка символов, например, Привет всем! или рпН2Н(*fD6:u . Оператор a:='Привет всем!' записывает в ячейку a строку Привет всем! . Оператор WriteLn (a), поскольку он обязан всегда выводить на экран содержимое ячейки a, выведет на экран текст Привет всем!

Обратите внимание, что в программе текст должен браться в кавычки, а в памяти он хранится без кавычек и на экран выводится без кавычек.

Слово String читается "стринг", переводится "строка".

Какой смысл переменным иметь текстовое значение, выяснится в следующем параграфе.

Информация в ячейке памяти под строковую переменную может в процессе выполнения программы меняться точно так же, как и в ячейке для числовой переменной. Например, при выполнении фрагмента

a:='Минуточку!'; WriteLn(a); a:='Здравствуйте!'; a:='До свидания!'; WriteLn (a)

в ячейке a будут по очереди появляться строки

Минуточку! Здравствуйте! До свидания!

а на экран будут выведены строки

Минуточку! До свидания!

Строковую переменную можно задавать не только оператором присваивания, но и оператором ReadLn. Пример:

VAR a : String;

BEGIN

WriteLn ('Введите какое-нибудь слово');

ReadLn (a);

WriteLn ('Вы ввели слово ' ,a)

END.

Во время паузы, вызванной оператором ReadLn, вы должны ввести какой-нибудь набор символов, например Изнакурнож , и затем нажать клавишу Enter в знак того, что ввод закончен. В результате на экране будет напечатан текст:

Вы ввели слово Изнакурнож

2.1.15 Диалог с компьютером

Напишем программу, которая осуществляла бы такой диалог человека с компьютером:

КОМПЬЮТЕР ВЫВОДИТ НА ЭКРАН: Здравствуй, я компьютер, а тебя как зовут?

ЧЕЛОВЕК ВВОДИТ С КЛАВИАТУРЫ: Коля

КОМПЬЮТЕР ВЫВОДИТ НА ЭКРАН: Очень приятно, Коля. .Сколько тебе лет?

ЧЕЛОВЕК ВВОДИТ С КЛАВИАТУРЫ: 16

КОМПЬЮТЕР ВЫВОДИТ НА ЭКРАН: Ого!Целых 16 лет!Ты уже совсем взрослый!

Вот программа:

VAR imya :String;

vozrast :Integer;

BEGIN

WriteLn ('Здравствуй, я компьютер, а тебя как зовут?');

ReadLn (imya);

WriteLn ('Очень приятно, ', imya, ' . Сколько тебе лет?');

ReadLn (vozrast);

WriteLn ('Ого! Целых ' ,vozrast, ' лет! Ты уже совсем взрослый!')

END.

Диалог будет отличаться только той информацией, которую вводит человек. Так, в другой раз по этой же программе будет осуществлен следующий диалог:

КОМПЬЮТЕР: Здравствуй, я компьютер, а тебя как зовут?

ЧЕЛОВЕК : Фантомас!

КОМПЬЮТЕР: Очень приятно, Фантомас! . Сколько тебе лет?

ЧЕЛОВЕК: 100

КОМПЬЮТЕР: Ого! Целых 100 лет! Ты уже совсем взрослый!

Не подумайте, что эта программа очень умная. Она совершенно не анализирует, какую информацию человек ввел с клавиатуры. Поэтому с ней возможен и такой диалог:

КОМПЬЮТЕР: Здравствуй, я компьютер, а тебя как зовут?

ЧЕЛОВЕК: Сгинь с моих глаз!

КОМПЬЮТЕР: Очень приятно, Сгинь с моих глаз! . Сколько тебе лет?

ЧЕЛОВЕК: -2

КОМПЬЮТЕР: Ого! Целых -2 лет! Ты уже совсем взрослый!

Задание 17: Напишите программу для следующей задачи: Компьютер спрашивает названия двух планет, радиусы их орбит (в миллионах километров) и скорости движения по орбите (в миллионах километров в сутки). Компьютер вычисляет продолжительность года на планетах и выдает результат в таком виде: Продолжительность года на планете Земля - 365 суток, а на планете Эоэлла - 12 суток.

2.1.16 Константы

Кроме переменных величин в тексте программы мы встречаем константы. Это те значения, которые или присванваются переменным, или встречаются в выражениях, или сравниваются с выражениями. Например:

x:=25 здесь числовая константа - 25

slovo:='Волга' здесь строковая константа - Волга

simvol:='!' здесь символьная константа - !

y:=(x+1) / (200*x - 0.3) здесь числовые константы - 1 и 200 и 0.3

2.2 Разветвляющиеся программы

2.2.1 Условный оператор IF или как компьютер делает выбор

Идею разветвления в программе я изложил в 2.8. Сейчас добавлю только, что вся мыслительная деятельность во всех программах (в том числе и той, что выиграла в шахматы у Каспарова) осуществляется только при помощи ветвления (выбора).

Теперь посмотрим, как писать разветвляющиеся программы на Паскале.

Выучим сначала три английских слова:

if	читается "иф"	переводится "если"
then	читается "зэн"	переводится "то"
else	читается "элз"	переводится "иначе"

Теперь приведем пример нового для вас оператора:

IF a=28 THEN WriteLn (f) ELSE k:=44

Переводится он так:

ЕСЛИ a=28 ТО печатай f ИНАЧЕ присвой переменной k значение 44.

Другими словами, мы предлагаем компьютеру сначала подумать, правда ли, что a=28 , и если правда, то выполнить оператор WriteLn (f), в противном случае выполнить оператор k:=44 . Таким образом, мы с вами впервые написали оператор, при выполнении которого компьютер не просто выполняет, что приказано, а сначала думает и делает выбор (пока одного из двух).

Мы видим, что оператор if включает в себя другие операторы, которые выполняются или не выполняются в зависимости от какого-то условия. Чтобы понять, зачем может пригодиться оператор if, рассмотрим следующую задачу.

Задача 1. Компьютер должен перемножить два числа - 167 и 121. Если их произведение превышает 2000, то компьютер должен напечатать текст ПРОИЗВЕДЕНИЕ БОЛЬШОЕ, иначе текст ПРОИЗВЕДЕНИЕ МАЛЕНЬКОЕ. После этого компьютер в любом случае должен напечатать само произведение.

Программа:

VAR a,b,y :Integer;

BEGIN

a:=167;

b:=121;

y:=a*b;

if y>20000 then WriteLn ('ПРОИЗВЕДЕНИЕ БОЛЬШОЕ')

else WriteLn ('ПРОИЗВЕДЕНИЕ МАЛЕНЬКОЕ');