Начала программирования

Что такое программирование и язык программирования

Зачем нужно программирование

Часто людям приходится делать что-то, а потом повторять те же действия сразу или позже. Когда человек первый раз сталкивается с задачей, то обдумывает последовательность действий для ее решения, т. е. человек разрабатывает алгоритм решения задачи. Придумав удачный алгоритм, человек его запоминает, и последующее выполнение похожих задач происходит уже «на автомате», не думая. Когда мы действуем согласно какой-либо инструкции, не обдумывая ее смысл, то являемся просто исполнителями.

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

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

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

Определение компьютерной программы

Предположим, что поместить в память компьютера инструкции для решения задач, написанные человеком, не проблема. Но поймет ли их компьютер? Он не «говорит» на естественных для нас языках. Для него нужны инструкции на понятном ему языке. Комплекс инструкций для решения определенной группы задач, записанный на понятном компьютеру языке является ничем иным как компьютерной программой.

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

Так какой же язык понятен компьютеру, в каком виде следует вносить информацию в его память, чтобы он потом делал то, что мы хотим. Компьютер – это электронное вычислительное устройство. Вычислительное! Он работает с числами, складывает, вычитает, сравнивает. Больше ни с чем. Но как же? Ведь мы привыкли обрабатывать на компьютере не только числовую информацию, но также текстовую и графическую. Поэтому нам кажется, что компьютер работает не только с числами. Фокус заключается в том, что любую информацию, в том числе текстовую и графическую можно закодировать числами. А чтобы запрограммировать какие-то действия с нечисловой информацией можно манипулировать именно числами, которыми она кодируется.

Первые программы для ЭВМ программисты писали именно числами. Это сложно для человека. Представьте, что все, что вы хотите сказать, нужно сказать, оперируя исключительно числами. Тут дело усложнялось еще тем, что компьютеры как вычислительные машины проще создавать таким образом, чтобы они считали в двоичной системе счисления. Записи программ получались слишком длинными. Для их сокращения пользовались восьмеричной и шестнадцатеричной системами счисления. Запись программы числами называется машинным языком программирования.

Программировать работу компьютера в машинных кодах трудно, т.к. думать числами неестественно для человека. Мы привыкли думать словами. А что если сопоставить часто используемым группам чисел слова, а затем написать программу перевода слов в числа, понятные компьютеру. Т.е. теперь программист может описать алгоритм в словах, затем передать его специальной программе-переводчику (транслятору), который преобразует словесный алгоритм в машинный код, понятный компьютеру. И человеку хорошо и компьютеру понятно. От человека требовалось только создать этот самый транслятор. Человечество регулярно придумывает различные языки программирования и пишет под них трансляторы. Первыми языками программирования, где использовались слова, были ассемблеры.

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

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

Следует понимать, что конкретный язык программирования может содержать в себе несколько концепций (парадигм) программирования. Например, быть структурным и объектно-ориентированным одновременно. Языков множество, парадигм (принципов программирования) единицы.

История и особенности языка программирования Паскаль (Pascal)

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

Принято считать, что он хорош для обучения программированию. Язык Паскаль был создан в конце 60-х годов Н. Виртом как специальный язык для обучения студентов. Однако вскоре из-за реализации в Паскале прогрессивных идей того времени получил распространение среди программистов. Было время, когда Паскаль широко использовался для написания прикладных программ и даже как язык системного программирования. Программное обеспечение многих мини- и микрокомпьютеров было написано на Pascal.

При разработке языка программирования на свет должны появиться как его описание, так и транслятор с него в машинный код. После 70-го года язык Pascal развивался и совершенствовался, включал в себя новые возможности. Производились новые трансляторы и среды разработки для Pascal.

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

В 80-х годах компьютерная наука начала входить в массы, в школах появился предмет «Информатика». Поскольку в это время Pascal был распространен и зарекомендовал себя как учебный язык, то он нашел широкое распространение в школах и вузах. В итоге было написано огромное количество учебных пособий по этому языку.

Среди других достоинств языка программирование Pascal можно отметить следующее:

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

Чтобы Pascal оставался простым языком, разработчик (Н. Вирт) ввел в него некоторые ограничения. Так, Паскаль хорошо «учит» понимать, как хранятся данные в памяти компьютера, но имеет ряд ограничений при работе с ними (чего лишены большинство «настоящих» языков).

Так как в свое время Паскаль достаточно активно использовался для решения практических задач, на его основе сформировался язык Object Pascal (который сейчас используется в Delphi и Lazarus).

Словарь языка Pascal

Язык программирования Pascal использует следующий набор символов.

Для обращения к ячейкам памяти компьютера используются переменные. Переменная – это имя физического участка памяти, в котором в любой момент времени может храниться только одно значение. Для обозначения участков памяти используют идентификаторы (имена переменных).

Идентификаторы (имена переменных, констант программ, модулей, функций, процедур) записываются с помощью допустимых в Pascal символов и должны удовлетворять следующим правилам:

Слова, употребляемые в большинстве языков программирования, в том числе и Pascal, делятся на три группы: зарезервированные (ключевые) слова самого языка; предопределенные имена и идентификаторы, определяемые программистом.

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

Ключевые слова языка программирования Паскаль:

and end nil set
array file not then
begin for of to
case function or type
const goto packed until
div if procedure var
do in program while
downto label record with
else mod repeat

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

Пользовательские имена определяются программистом и должны быть явно объявлены в программе.

Десятичные числа всегда начинаются с цифры, перед которой может стоять знак числа, + или -.

Действительные числа изображаются в двух форматах. В формате с фиксированной точкой явно указывают положение десятичной точки (например, 4.505, -16.25, +1.0). В формате с плавающей точкой используется десятичный порядок, обозначаемый прописной или строчной буквой E, после которой идет целое число, указывающее значение порядка, например, 8e10, 1.62e-3, 0.8E+3.

В языке Pascal максимально допустимое целое число равняется 2147483647 (оно содержится в предопределенной целой константе MaxLongInt). Чтобы получить это число достаточно выполнить выражение

writeln(maxlongint);

В Паскале возможен диапазон целых чисел от -2147483648 до 2147483647. Предопределенная в Паскале целая константа MaxInt содержит в себе значение 32767

writeln(maxint);

Распространенные компиляторы с языка Pascal позволяют оперировать действительными числами до 38 порядка, а некоторые – до 67 порядка.

Целое число может задаваться не только в десятичной, но и в шестнадцатеричной системе счисления. Шестнадцатеричному числу предшествует знак $.

Текстовым литералом (строкой) в языке Pascal называют последовательность любых допустимых символов, стоящих между апострофами (например, ‘Hello World!’). Если в качестве символа строки необходимо использовать апостроф, то записывают подряд два апострофа

writeln('Don''t do it')

Строку можно задавать также в виде последовательности, образованной из символов # с последующим цифровым кодом требуемого символа (например, запись #72#73#33 эквивалентна строке 'HI!'). В строковых данных прописные и строчные буквы различаются.

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

Компиляция

Программу на Паскале надо предварительно скомпилировать. Компиляция означает перевод исходной программы с языка Pascal в объектную программу – на язык компьютера. При запуске программы, вычисления производятся по программе в объектном коде, а не по исходной программе.

После компиляции имеются две версии программы: одна на Паскале, другая на языке компьютера (или близком к нему). Если посмотреть на объектную программу, то на экране будут непонятные «слова» и закорючки.

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

Сначала исходная программа записывается программистом (редактируется), после чего сохраняется на диске под произвольным именем.

На следующем шаге в память загружаются компилятор и исходный текст программы. Компилятор «читает» ее, превращая в объектный код, который затем также сохраняется на диске.

Последний шаг – выполнение программы. В компьютерную память загружается именно объектный (исполняемый) код. Выполняющаяся программа может предполагать ввод данных (input) с клавиатуры и вывод результатов (output) на экран. Это довольно распространенная схема ввода-вывода данных, стандартная в Паскале, но, разумеется, не единственная. Язык был разработан еще тогда, когда файлы хранились на магнитной ленте, ввод осуществлялся с перфокарт, а вывод – на печатающее устройство.

Структура программы на языке Паскаль

Программа состоит из заголовка и блока.

Заголовок программы

В заголовке указывается имя программы и список параметров. Общий вид:

program n (input, output, x, y,…);

здесь n – имя программы; input – файл ввода; output – файл вывода; x, y – внешние файлы, используемые в программе.

Заголовка может и не быть или он может быть без параметров.

Блок

Блок программы состоит из шести разделов, следующих в строго определенном порядке:

  1. раздел меток (label)
  2. раздел констант (const)
  3. раздел типов (type)
  4. раздел переменных (var)
  5. раздел процедур и функций
  6. раздел действий (операторов).

Раздел действий должен присутствовать всегда, остальные разделы могут отсутствовать.

Каждый из первых четырех разделов начинается с соответствующего ключевого слова (label, const, type, var), которое записывается один раз в начале раздела и отделяется от последующей информации только пробелом, либо концом строки, либо комментарием.

Раздел меток (label)

Любой выполняемый оператор может быть снабжен меткой – целой положительной константой, содержащей не более 4-х цифр. Все метки, встречающиеся в программе, должны быть описаны в разделе label.

Общий вид:

label l1, l2, l3…;

здесь l1, l2, l3 – метки.

Пример. label 5, 10, 100;

Метка отделяется от оператора двоеточием.

Пример. Пусть выражение a := b имеет метку 20. Тогда этот оператор выглядит так:

20: a := b;

Раздел констант (const)

Если в программе используются константы, имеющие достаточно громоздкую запись (например, число пи с 8-ю знаками), либо сменные константы (для задания варианта программы), то такие константы обычно обозначаются какими-либо именами и описываются в разделе const, а в программе используются только имена констант. Это делает программу более наглядной и удобной при отладке и внесении изменений.

Общий вид:

const a1 = c1; a2 = c2; …

здесь a1 – имя константы, c1 – значение константы.

Пример. const pi = 3.14; c = 2.7531;

Раздел типов (type)

Если в программе вводится тип, отличный от стандартного, то этот тип описывается в разделе type:

type t1 = вид_типа;
        t2 = вид_типа;

где t1 и t2 – идентификаторы вводимых типов.

Затем тип используется при объявлении переменных.

Пример использования нестандартных типов:

const
	len=40;
type
	year=1930..2010;
	names=string[len];
var
	empl: names;
	y: year;

Раздел описания типов имеет большое значение в программе на языке Pascal. Если в программе не использовать типы, то можно столкнуться с несовместимостью типов переменных, даже если они описаны одинаково.

Раздел переменных (var)

Пусть в программе встречаются переменные v11, v12,…; все они должны быть описаны следующим образом:

var v11, v12,…: type1;
      v21, v22,…: type2; …

здесь v11, v12,… - имена переменных; type1 – тип переменных v11, v12,…; type2 – тип переменных v21, v22,….

Пример. var k, i, j: integer; a, b: real;

Каждая переменная должна быть описана до ее использования в программе и отнесена к одному и только одному типу. Названия разделов (const, type, var…) указываются только один раз.

Пример.

var a: real;
      b: real;

Таким образом, в разделе var вводится имя каждой переменной и указывается, к какому типу эта переменная принадлежит. Тип переменной можно задать двумя способами: указать имя типа (например, real, color и т.д.), либо описать сам тип, например: array[1..16] of char

Раздел процедур и функций

Здесь присутствуют заголовки и тела пользовательских процедур и функций.

Раздел действий (операторов)

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

Пунктуация в программах на Паскале

Слова begin и end не являются операторами – они служат знаками пунктуации. Слово begin выступает в качестве левой, а end – правой скобки. Так как они сами знаки пунктуации, то точка запятой после begin и перед end не обязательна. В программах на Паскаль слова begin и end используются преимущественно для образования составных операторов. Составной оператор может быть использован в любом месте, где мог бы быть использован простой оператор. Пример составного оператора:

begin
    t := a;
    a := b;
    b := t
end;

Слова в других операторах также действуют как знаки пунктуации.

if ab > bd then
    write(‘yes’)
else
    write(‘no’);

Слова if, then, else выступают внутри оператора в качестве знаков пунктуации.

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

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

Слова program, const, var, begin, end, а также множество других называются зарезервированными словами. Зарезервированные слова нельзя расширять (например, constant будет ошибкой) и сокращать (например, prog также будет ошибкой).

Использовать в программном коде на Pascal можно как прописные, так и строчные буквы, а также их чередовать. Однако в строках (тип данных) разница между прописными и строчными буквами существует.

Операторы Pascal

Под операторами в языке Паскаль подразумевают только описание действий. Операторы отделяются друг от друга только точкой с запятой. Если оператор стоит перед end, until или else, то в этом случае точка с запятой не ставится.

Оператор присваивания

Общий вид:

v := a;

здесь v – переменная, a – выражение, := - операция присваивания. Выражение a может содержать константы, переменные, названия функций, знаки операций и скобки.

Пример. f := 3 * C + 2 * sin(x);

Вид выражения однозначно определяет правила его вычисления: действия выполняются слева направо с соблюдением следующего старшинства (в порядке убывания):

  1. not;
  2. *, /, div, mod, and;
  3. +, -, or;
  4. =, <, >, <>, <=, >=, in.

Любое выражение в скобках вычисляется раньше, чем выполняется операция, предшествующая скобкам.

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

В операции v := a переменная v и выражение a должны иметь один и тот же тип, а для интервального типа – одно и то же подмножество значений.

Примечания. Разрешается присваивать переменной типа real выражение типа integer. Нельзя присваивать переменной типа integer выражение типа real.

Составной оператор

Если при некотором условии надо выполнить определенную последовательность операторов, то их объединяют в один составной оператор.

Составной оператор начинается ключевым словом begin и заканчивается словом end. Между этими словами помещаются составляющие операторы, которые выполняются в порядке их следования. После end ставится точка с запятой, а после begin – только пробелы (либо комментарий).

Пример.

begin
	i := 2;
	k := i / 5
end;

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

Выражения в Pascal

В операторах присваивания можно использовать арифметические выражения. Например:

num := (d + n) / 10;
sq := trunk(num) + 1;

Скобки обеспечивают необходимый порядок вычислений. Если бы в первом примере скобки были опущены:

num := d + n / 10;

то сначала было бы выполнено деление, приоритет которого выше. Приоритет в арифметических выражениях выше у операций умножения (*) и деления (/), ниже у сложения и вычитания.

Во втором из приведенных примеров производится присваивание значения целого числа. Функция trunc дает целый результат, а число 1 записано без десятичной точки; таким образом, оба слагаемых в сумме дают целое значение. Вообще, когда все члены выражения – целые, само выражение принимает целое значение.

У сформулированного выше правила существует важное исключение: деление (с использованием знака /) всегда дает вещественный результат:

6.5 / 2 = 3.25
6 / 2 = 3.0

Деление нацело (нахождение частного и остатка) может быть выполнено при помощи операций div и mod.

Выражение может включать в себя и целые и вещественные члены. Наличие хотя бы одного вещественного члена или знака / приводит к тому, что значение результата будет вещественным. Функции trunc и round могут быть использованы для преобразования вещественного числа в целое.

Функция sqr возводит значение аргумента (записанного внутри скобок) в квадрат. В Паскале нет оператора возведения в произвольную степень. Возведение в степень здесь осуществляется с использованием логарифмов. Вместо математического выражения ax на Pascal можно написать exp(ln(a) * x).

Знаки <, >= и подобные также играют роль операций. Выражения, содержащие подобные операции, принимают логическое значение и называются логическими выражениями. В состав логических выражений могут входить логические операции not (не), and (и), or (или). Такие логические выражения называются сложными.

Ввод-вывод данных в Pascal

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

Следовательно, любой язык программирования должен иметь инструменты как для ввода данных, так и их вывода. В Паскале ввод осуществляется с помощью процедур read() и readln(), а вывод - благодаря write() и writeln(). Процедуры, которые имеют окончание ln, после своего выполнения переводят указатель на новую строку.

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

Куда можно вывести данные? На экран, в файл, на принтер и др.

Стандартным устройством ввода является клавиатура, а вывода — монитор. Стандартные — значит "работающие по-умолчанию"; т.е. если не указано ничего иного, то программа будет считывать данные с клавиатуры, а выводить их на монитор. Вместе клавиатуру и монитор называют консолью. Таким образом консоль представляет собой стандартное устройство ввода-вывода.

Вывод данных на экран. Форматированный вывод

Вывод данных на экран и в файл в языке программирования Pascal осуществляется с помощью процедур write() и writeln(). Здесь будет рассмотрен вывод только на экран.

Допустим, нам требуется отобразить на экране пару фраз. Если мы хотим, чтобы каждая из них начиналась с новой строки, то надо использовать writeln(), если нет – то write().
Write() и writeln()

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

Еще один пример. В памяти компьютера хранятся данные. Из программы мы обращаемся к ним с помощью переменных num, fl и st. Вывести их значения на экран можно по-разному.
Форматированный вывод

Во втором случае мы видим, что процедуры вывода (как write() так writeln()) позволяют конструировать выводимую информацию из различных компонент (строк-констант и переменных).

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

Ввод данных с клавиатуры

Ввод данных в языке программирования Паскаль обеспечивается процедурами read() и readln(). Ввод данных осуществляется либо с клавиатуры, либо из файла. Здесь рассматривается только ввод с клавиатуры.

Когда данные вводятся, то они помещаются в ячейки памяти, доступ к которым обеспечивается с помощью механизма переменных. Поэтому, когда в программе на Pascal используется процедура read() (или readln()), то в качестве фактического параметра (аргумента) ей передается имя переменной, которая будет связана с вводимыми данными. Потом эти данные можно будет использовать в программе или просто вывести на экран.
Read() и readln()

В процедуры ввода можно передавать не один фактический параметр, а множество.
Передача множества аргументов в процедуру readln()

При вводе данных их разделяют пробелом, табуляцией или переходом на новую строку (Enter). Данные символьного типа не разделяются или разделяются переходом на новую строку.

Существуют особенности ввода данных с помощью операторов read() и readln(). Если используются подряд несколько операторов read(), то вводимые данные можно разделять всеми допустимыми способами. При использовании нескольких вызовов readln() каждый последующий срабатывает только после нажатия Enter. Программа ниже иллюстрирует это. Комментарии поясняют последовательность возможных действий при вводе данных.

var
        a,b,c,d: integer;
begin
        read(a); // a -> <space> or <tab> or <enter> -> b
        read(b);
        writeln(a,' ',b);
 
        readln(c); // c ->  only <enter> -> d
        readln(d);
        writeln(c,' ',d);
 
        read(a,b); // a -> <space> or <tab> or <enter> -> b
        writeln(a,' ',b);
 
        readln(c,d); // c -> <space> or <tab> or <enter> -> d
        writeln(c,' ',d);
end.

Переменные и константы

Переменные

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

Переменные описываются в начале программы и как бы сообщают о том, с какими данными будет работать программа и какой объем памяти они займут. Другими словами, резервируется память. Но это не значит, что в эти ячейки памяти помещаются конкретные значения (данные). На момент резервирования памяти в них может быть что угодно.

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

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

В Pascal прописные и строчные буквы в именах переменных не различаются.

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

В примере ниже происходит ввод значений трех переменных разных типов и выполнение допустимых для их типов операций. Если тип переменных integer, то им можно присваивать только целые числа в диапазоне от -32768 до 32767. Под тип integer в языке программирования Паскаль отводится 2 байта, что равно 16 битам, а это значит, что можно хранить 216 (65536) значений (отрицательные и положительные числа, а также ноль). В этих диапазонах переменные int1 и int2 могут принимать какие угодно значения. При попытке записи в переменную значения не ее типа возникнет ошибка.

var
    int1,int2: integer;
    r: real;
    ch: char;
begin
    write('Type integer: ');
    readln(int1);
    write('Type real: ');
    readln(r);
    write('Type char: ');
    readln(ch);
 
    int2:= int1 mod 10;
    int1:= int1 div 10;
    r:= r + 0.5;
    ch:= chr(ord(ch)+1);
    writeln(int1:5,int2:3,r:7:2,ch:3);
end.

Пример работы программы:

Type integer: 32
Type real: 5.34
Type char: A
    3  2   5.84  B

Итак, переменные связаны с участками памяти, содержимое которых может меняется по ходу выполнения программы в определенных приделах.

Длина переменных

Ранние версии компиляторов Паскаля имели ограничение на учитываемую длину имен переменных. В имени учитывались лишь первые восемь символов. Поэтому, например, такие переменные как variable1 и variable2 компилятор воспринимал как одно и тоже, т.к. первые восемь символов совпадали.

В современных версиях компиляторов с языка Pascal таких ограничений нет. Например, в результате работы приведенной ниже программы как в среде Free Pascal, так и Turbo Pascal 7.1 на экран выводятся два разных числа (10 и 20). Это значит, что компиляторы учитывают больше восьми символов в именах переменных (и других идентификаторов: именах констант, процедур и др.).

var
    variable111, variable222: integer;
 
begin
    variable111 := 10;
    variable222 := 20;
 
    writeln(variable111);
    writeln(variable222);
 
readln
end.

Константы

Что делать, если в программе требуется постоянно использовать какое-нибудь одно и тоже число. Вроде бы это не проблема. Можно описать переменную, затем присвоить ей значение и не изменять его в программе. Однако это не всегда удобно (можно нечаянно изменить), поэтому в языках программирования для хранения данных помимо переменных существуют константы.

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

const
	конст1 = значение;
	конст2 = значение;

Значениями констант могут быть данные большинства типов, используемых в языке Паскаль.

Рассмотрим такую программу:

const n=10;
var
    i: byte;
    sum: word;
begin
    sum:= 0;
    for i:=1 to n do
        sum:= sum+i;
 
    writeln('Sum of ',n,' numbers = ', sum);
end.

В ней используется константа n со значением 10. Программа считает сумму десяти чисел в диапазоне от 1 до 10. Если нам захочется посчитать сумму чисел до 20, то достаточно будет изменить значение константы в начале программы. Если бы константа не использовалась, то пришлось бы просмотреть весь код программы и исправить значение 10 на 20. Если программа большая, то легко ошибиться: не найти или исправить не то значение.

Типизированные константы

В языке Паскаль помимо обычных констант используются типизированные константы. Можно сказать, что они занимают промежуточное положение между переменными и константами. Они получают значение при описании (как константы), но могут его менять в теле программы (как переменные).

Описываются типизированные константы в разделе констант:

const
	конст1: тип=значение;
	конст2: тип=значение;

Например:

const
	nums: integer=10;

Типы данных в Паскале

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

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

Переменные описываются до основного кода программы. Здесь указываются имена переменных и тип хранимых в них данных.

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

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

Переменные типа integer могут быть связаны только с целыми значениями обычно в диапазоне от -32768 до 32767. В Pascal есть другие целочисленные типы (byte, longint).

Переменные типа real хранят вещественные (дробные) числа.

Переменная булевского (логического) типа (boolean) может принимать только два значения - true (1, правда) или false (0, ложь).

Символьный тип (char) может принимать значения из определенной упорядоченной последовательности символов.

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

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

Все вышеописанное – это простые типы данных. Но бывают и сложные, структурированные, которые базируются на простых типах.

Массив – это структура, занимающая в памяти единую область и состоящая из фиксированного числа компонентов одного типа.

Строки представляет собой последовательность символов. Причем количество этих символов не может быть больше 255 включительно. Такое ограничение является характерной чертой Pascal.

Запись – это структура, состоящая из фиксированного числа компонент, называемых полями. В разных полях записи данные могут иметь разный тип.

Множества представляют собой совокупность любого числа элементов, но одного и того же перечисляемого типа.

Файлы для Pascal представляют собой последовательности однотипных данных, которые хранятся на устройствах внешней памяти (например, жестком диске).

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

Задачи к данной теме

Целые типы

В языке Паскаль определено пять целых типов.

Таблица. Целые типы Pascal

Тип Диапазон допустимых значений Отводимая память, в байтах
shortint -128…127 1
integer -32 768…32 767 2
longint -2 147 483 648…2 147 483 647 4
byte 0…255 1
word 0…65 535 2

Переменные целого типа могут принимать только целые значения. Такие переменные в программе описываются следующим образом:
a, b, c: integer;

Здесь a, b, c… - имена переменных, integer – тип переменных. Транслятор, встретив такое описание переменных a, b, c, запоминает, что эти переменные могут принимать только целые значения и формирует соответственно этому команды программы.

Таблица. Операции над целыми типами, дающие в результате значение целого типа

Знак операции Операция
+ Сложение
- Вычитание
* Умножение
div Целочисленное деление (остаток отбрасывается). Деление без округления (целая часть частного).
mod Деление по модулю (выделение остатка от деления). Остаток от деления: a mod b = a – ((a div b) * b).

Операции над операндами целого типа выполняются правильно только при условии, что результат и каждый операнд не меньше минимального (крайнего левого) и не больше максимального (крайнего правого) значений диапазона. Например, в Паскале существует константа maxint, в которой содержится максимально допустимое значение для типа integer. Тогда при выполнении операций в программе должны соблюдаться следующие условия:
(a операция b) <= maxint,
a <= maxint, b <= maxint.

Над целыми типами, как и многими другими, допустимы операции отношения (сравнения). Результат таких операций относится к типу boolean и может принимать одно из двух значений – либо true (истина), либо false (ложь).

Таблица. Операции отношения

Знак операции Операция
= Равно
<> Не равно
>= Больше или равно
> Больше
<= Меньше или равно
< Меньше

Целые типы могут приниматься в качестве фактических параметров рядом стандартных функций языка программирования Pascal.

Таблица. Стандартные функции Pascal, применимые к аргументам целых типов

Функция Тип результата Результат выполнения
abs(x) Целый Модуль x (абсолютная величина x)
sqr(x) Целый Квадрат x
succ(x) Целый Следующее значение x (x+1)
pred(x) Целый Предыдущее значение x (x-1)
random(x) Целый Случайное целое число из интервала 0..x-1.
sin(x) Действительный Синус x (угол в радианах)
cos(x) Действительный Косинус x (угол в радианах)
arctan(x) Действительный Арктангенс x (угол в радианах)
ln(x) Действительный Натуральный логарифм x
exp(x) Действительный Экспонента x
sqrt(x) Действительный Квадратный корень из x
odd(x) Логический Значение true, если x – нечетное число; false – если четное.
Функция random возвращает равномерно распределенное случайное целое число, если ей передан целый аргумент. При повторном запуске программы она возвращает те же значения. Во избежание этого следует в начале программы вызвать процедуру без параметров randomize.

Процедуры inc и dec могут иметь по одному или по два параметра целого типа. Если параметров два, то значение первого увеличивается (для inc) или уменьшается (для dec) на величину, равную значению второго параметра. Например, inc(x,2) равнозначно x+2. Если параметр один, то его значение увеличивается (для inc) или уменьшается (для dec) на единицу. Например, dec(x) равнозначно x-1. (ТАКИХ ПРОЦЕДУР ВО FREEPASCAL СКОРЕЕ ВСЕГО НЕТ.)

Следующие функции принимают в качестве аргументов значения вещественного типа, а возвращают значения целого типа:
trunc(x) – отбрасывание десятичных знаков после точки;
round(x) – округление до целого.

Примеры работы некоторых приведенных выше операций и функций:
Пример 1. Пусть a = 17, b = 5. Тогда a div b дает 3, a mod b дает 2 (остаток от деления), sqr(b) дает 25.
Пример 2. Пусть x = 4.7389. Тогда trunc(x) дает 4, round(x) дает 5.
Пример 3. Выражение 4 * 21 дает результат целого типа, а 4 * 21.0 – вещественного, т.к. один из сомножителей вещественный.

Вещественные типы

В языке Паскаль существует несколько типов для представления действительный чисел. Однако чаще всего для их представления используется тип Real.

Таблица. Вещественные типы в Pascal

Тип Диапазон Число цифр Память, байт
Real 2.9e-39 … 1.7e38 11-12 6
Single 1.5e-45 … 3.4e38 7-8 4
Double 5.0e-324 ...1.7e308 15-16 8
Extended 3.4e-4932 … 1.1e493 19-20 10
Comp -9.2e63 … (9.2e63)-1 19-20 8

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

Над действительными числами выполнимы операции сложения (+), вычитания (-), умножения (*) и деления (/). Результатом этих операций является также действительное число. Даже если хотя бы один из операндов вещественный, то результат этих операций также будет вещественным.

Операция деления (/) дает вещественный результат и в случае двух целых операндов. Например, 6 / 2 = 3.0.

Для действительных чисел допустимы такие же операции отношения (сравнения), что и для целых чисел.

Стандартная функция abs(x) – модуль x – от целого аргумента дает целый результат, а от вещественного – вещественный, как и sqr(x) – квадрат x.

Функции

sin(x) – синус x (x в радианах),
cos(x) – косинус x (x в радианах),
ln(x) – натуральный логарифм x,
exp(x) – экспонента x,
sqrt(x) – корень квадратный из x,
arctan(x) – арктангенс x
дают вещественный результат, как для вещественного, так и для целого аргумента.

Функция int возвращает в виде действительного значения целую часть аргумента, frac возвращает дробную часть аргумента.

Функции trunc и round возвращают результат целого типа. Первая отсекает дробную часть от аргумента, а вторая выполняет округление до ближайшего целого.

Функция random без аргументов возвращает равномерно распределенное случайное число от 0 до 1.

Не имеющая аргументов функция pi возвращает число Пифагора.

Нельзя использовать переменные и константы вещественного типа:

Использование константы PI

Задача: 

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

Программа на языке Паскаль: 

var r,l,s: real;
begin
    write('radius: ');
    readln(r);
 
    l:= 2*PI*r;
    s:= PI*r*r;
 
    writeln('PI=',PI);
    writeln('circuit: ',l:7:2);
    writeln('square:  ',s:7:2);
end.

Символьный тип (Char)

Переменная типа char может принимать значения из определенной упорядоченной последовательности символов. Переменная этого типа занимает 1 байт и принимает одно из 256 значений кода ASCII (американский стандартный код для обмена информацией). Символы упорядочены в соответствии с их кодом, поэтому к данным символьного типа применимы операции отношения.

В программе вместо символа можно использовать его код, состоящий из # и номера кодируемого символа (например, #51). Обычно символы, имеющие экранное представление, записывают в явном виде, заключив в апострофы (например, 'A', 'b', '*').
Две стандартные функции позволяют поставить в соответствие данную последовательность символов множеству целых неотрицательных чисел (порядковым номерам символов последовательности).

Эти функции называются функциями преобразования:

ord(ch) – выдает номер символа (нумерация с нуля),
chr(i) – выдает i-ый символ из таблицы символов.

Пример. ord('H') выдает номер символа Н в последовательности всех символов, используемых транслятором. chr(15) выдает 15-ый символ этой последовательности.

Кроме того, для символьных переменных применяются такие функции:

pred(ch) – возвращает предыдущий символ;
succ(ch) – возвращает следующий символ;
upcase(ch) – преобразует строчную букву в заглавную. Обрабатывает буквы только латинского алфавита.

Также можно использовать процедуры inc и dec.

Задачи к данной теме

Тип pchar

В язык программирования Pascal введен тип pchar, который описывает так называемые длинные (или ASCIIZ) строки. В переменных типа string длина строки записывается в нулевом байте, а т.к. в 1 байт нельзя записать значение, превосходящее 255, то и длина переменной типа string не может превосходить 255 символов. Переменная типа pchar – это строка, которая может иметь длину до 65534 символов. Длина таких строк не указывается явно: строка начинается с первого символа и замыкается символом #0. Поскольку тип pchar определяется как указатель на символ, ASCIIZ-строки создаются в динамической памяти. С типом pchar совместим любой символьный массив, левая граница которого равна нулю. ASCIIZ-строки индексируются с отсчетом значений индекса от 0. Строковые константы также могут быть записаны в переменные типа pchar. Для вывода ASCIIZ-строк применимы операторы write и writeln.

Пример использования ASCIIZ-строк:

const
    ch_arr: array[0..20] of char = 'Hello World!';
var
    p_str: pchar;
begin
    p_str := ch_arr;
    writeln(p_str);
    p_str[4] := #0;
    writeln(ch_arr);
readln
end.

В программе символьный массив объявлен в виде типизированной константы. Поскольку под него отведены 21 байт, его содержимое нужно было бы задавать строкой из 21 символа; однако в языке программирования Паскаль строковая константа, длина которой меньше количества элементов символьного массива, также записывается в символьный массив с автоматическим заполнением конца массива символом #0. В приведенной программе осуществляется коррекция переменной p_str, что меняет содержимое массива ch_arr, т.к. переменная p_str после присваивания p_str := ch_arr просто ссылается на этот массив и оперирует областью памяти, которую он занимает. Поэтому выражение p_str[4] := #0 изменяет длину строки ch_arr до четырех символов.

ASCIIZ-строка может быть объявлена типизированной константой, но ее длина в этом случае не может превосходить 255 символов. Например:

const
	pch: pchar = 'My name is ';

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

const
    pch1: pchar = 'hello world';
    pch2: pchar = 'привет мир';
var
    p_str: pchar;
    n: longint;
begin
    p_str := pch1 + 6;
    writeln(p_str); // world
    writeln(pch2 + 7); // мир
 
    p_str := 'This is world';
    writeln(p_str);
 
    n := pch2 - pch1;
    writeln(n);
readln
end.

Значение n показывает взаимное смещение в памяти двух ASCIIZ-строк.
Основные средства по работе с ASCIIZ-строками сосредоточены в модуле Strings.

Явное преобразование типов

В ряде случаев в Pascal происходит автоматический переход от одного типа данных к другому (от целого к действительному, от символьного к строковому и т.д.). Существует также ряд функций, осуществляющих преобразование типов (ord, chr, trunc, round). Наряду с этим в Паскаль возможно явное преобразование типов (ретипизация данных). Для того, чтобы осуществить явное преобразование типа, необходимо использовать имя типа аналогично тому, как используется имя функции. В качестве параметра в этом случае указывается имя преобразуемой переменной.

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

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

Вычислить значение функции sign(x) = 1 при x>0; 0 при x=0; -1 при x<0.

var
    x: real;
    sign: integer;
begin
    readln(x);
    sign:= byte(x>0)-byte(x<0);
    writeln(sign);
end.

В программе при положительном значении x выражение x>0 принимает значение true, а выражение x<0 — false. В результате получается, что byte(x>0) = 1, byte(x<0)=0, а sign=1. При отрицательном значении x byte(x>0)=0, byte(x<0)=1, sign=-1. При нулевом значении x sign=0.

Перечисляемый тип

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

type 
	nm = (word1, word2,, wordN);
var
	w: nm;

здесь nm – идентификатор типа (произвольный), word1, word2… - конкретные значения, которые может принимать переменная w, принадлежащая типу nm. Значения данного типа считаются упорядоченными, т.е. описание типа одновременно вводит упорядочение word1 < word2 < wordN. Порядковые значения отсчитываются с 0.

К переменным типа перечисления можно применять функции ord, pred, succ и процедуры inc и dec.

Ко всем переменным одного и того же скалярного типа применимы операции отношения: =, <>, <=, >=, <, >.

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

Пример 1. type color = (red, yellow, green, blue);
Здесь определено, что red < yellow < green < blue. Переменная типа color может принимать одно из перечисленных значений.

Функция succ(x)

По элементу x определяется та упорядоченная последовательность, которой принадлежит x, и выдается элемент, следующий за x в этой последовательности.

Пример 2. Пусть задана последовательность букв в алфавитном порядке. Тогда succ(A) есть B; succ(L) есть M и т.д.

Для примера 1 succ(red) есть yellow.

Функция pred(x)

По элементу x определяется последовательность, которой принадлежит x, и выдается предыдущий элемент этой последовательности.

Пример 3. pred(F) есть E; pred(Z) есть Y и т.д.

Функция ord(x)

Выдается номер элемента x в последовательности.

Пример 4. ord(red) равен 0, а ord(green) равен 2.

Диапазонный, или интервальный, тип

Для переменной скалярного (перечисляемого) типа можно указать некоторое подмножество значений, которые может принимать данная переменная.

Общий вид:
a: min..max;

здесь a – интервальная переменная, min – левая граница, max – правая граница подмножества (диапазона). Границы диапазона разделяются двумя точками; граница min всегда должна быть меньше max.

Константы min и max должны принадлежать одному и тому же типу. Они определяют базовый тип переменной a. Так, если границы являются целыми числами типа integer, то под переменную a будет выделен такой же объем памяти, что и под тип integer. Однако переменная a сможет принимать только те значения, которые определены границами ее диапазона.

Примеры

Пусть переменная k должна принимать значения из множества -1000..1000. Тогда ее следует объявить как k: -1000..1000. При этом базовым типом переменной k является тип integer, т.к. границами диапазона являются целые константы -1000 и 1000.

Если переменная b может принимать одно из значений red, yellow, green, то эту переменную можно описать так: b: red..green; базовым типом для b является тип color:

type color=(red,yellow,green,blue);
var b:red..green;
begin
    b:=red;
    writeln(b);
    b:=yellow;
    writeln(b);
    b:=green;
    writeln(b);
readln
end.

Пусть i – переменная, принимающая значения года рождения сотрудника какого-либо учреждения. Имеет смысл ограничить диапазон значений i подмножеством, т.е. описать примерно так: i: 19302000.

Булевы типы. Логические выражения и логические операции

Простые логические выражения

Для того, чтобы программа была не линейной (т.е. в зависимости от ситуации выполнялись разные инструкции) в языках программирования используются логические выражения, результат которых может быть либо правдой (true), либо ложью (false). Результат логических выражений обычно используют для определения пути выполнения программы.

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

В Паскале предусмотрены следующие операторы отношений:

Булевы типы

Результатом логического выражения всегда является булево (логическое) значение. Булев тип данных (boolean) может принимать только два значения (true или false). Эти величины упорядочены следующим образом: false < true. Это значит, что данные булевого типа являются не только результатом операций отношения, но и могут выступать в роли операндов операции отношения. Также к ним можно применять функции ord, succ, pred, процедуры inc и dec.

Значение типа boolean занимает в памяти 1 байт.

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

Логические выражения и логические переменные

Кроме типа boolean в Pascal введены еще три булевых типа — bytebool (занимает 1 байт), wordbool (занимает 2 байта) и longbool (занимает 4 байта).
Для всех булевых типов значению false соответствует 0, а значению true — любое ненулевое значение. Логические переменные, принадлежащие разным булевым типам, ведут себя по-разному при выполнении над ними операций. Ниже приводится пример, реализованный на языке FreePascal (в комментариях отображается результат).

var 
b:boolean; 
wb:wordbool; 
begin 
b:= false; 
b:= pred(b); 
writeln(b,' ',ord(b)); // TRUE 255 
writeln(b=true); // TRUE 
 
wb:= false; 
wb:= pred(wb); 
writeln(wb,' ',ord(wb)); // TRUE -1 
 
b:= true; 
b:= succ(b); 
writeln(b,' ',ord(b)); // TRUE 2 
 
wb:= true; 
wb:= succ(wb); 
writeln(wb,' ',ord(wb)); // FALSE 0 
end.

Логические операции

С помощью логических операторов можно формировать сложные логические выражения. Логические операторы часто применяются по отношению к простым логическим выражениям.

В языке программирования Pascal предусмотрены следующие логические операции:

Последовательность выполнения логических операторов: not, and, or.

В языке Паскаль сначала выполняются логические операторы (and, or, xor, not), а уже потом операторы отношений (>, >=, <, <=, <>, =), поэтому не нужно забывать расставлять скобки в сложных логических выражениях.

Расстановка скобок в логических выражениях на языке Pascal

Сложные булевы выражения могут не обрабатываться до конца, если продолжение вычислений не изменит результат. Если булево выражение в обязательном порядке нужно обрабатывать до конца, то это обеспечивается включением директивы компиляции {B+}.

Стандартные булевские функции

В остальных случаях эти функции принимают значение false.

Задачи к данной теме

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

В Pascal над целыми типами (byte, shortint, word, integer, longint и их диапазоны) допустимы побитовые операции.

Логические операции над битами

Над битами двух целых операндов можно выполнять ранее рассмотренные логические операции: not, and, or, xor. Отличие между побитовыми и логическими операциями состоит в том, что побитовые (поразрядные) операции выполняются над отдельными битами операндов, а не над их значением в десятичном (обычно) представлении.

Например, число 5 в двоичном представлении (в одном байте) имеет значение 00000101. Операция not инвертирует биты и мы получим 11111010, т.е число 250. Если побитовую операцию or использовать к числам 5 (00000101) и 3 (00000011), то получится число 7 (00000111).

Операции циклического сдвига

В Паскаль определены еще две операции над данными целого типа, имеющие тот же уровень приоритета, что и операции and, *, /, div и mod. Это операции shl и shr, которые сдвигают последовательность битов на заданное число позиций влево или вправо соответственно. При этом биты, которые выходят за разрядную сетку, теряются. При выполнении операции shl освободившиеся справа биты заполняются нулями. При выполнении операции shr освободившиеся слева биты заполняются единицами при сдвиге вправо отрицательных значений и нулями в случае положительных значений.

С помощью операции shl возможна замена операции умножения целых чисел на степени двойки. Следующие пары выражений приводят к одинаковому результату: (a shl 1) = a * 2, (a shl 2) = a * 4, (a shl3) = a * 8.

Пример побитовых операций и циклического сдвига

var
     A, B: byte;
begin
     A := 11;                                       {00001011}
     B := 6;                                         {00000110}
     writeln('A=', A);
     writeln('B=', B);
     writeln('not A = ', not A);           {11110100 = 244}
     writeln('A and B = ', A and B);   {00000010 = 2}
     writeln('A or B = ', A or B);        {00001111 = 15}
     writeln('A xor B = ', A xor B);    {00001101 = 13}
     writeln('A shl 1 = ', A shl 1);      {00010110 = 22}
     writeln('B shr 2 = ', B shr 2);      {00000001 = 1}
end.

Практическое значение побитовых операций

Операция and практически всегда используется только для достижения одной из двух целей: проверить наличие установленных в единицу битов или осуществить обнуление некоторых битов.

Подобная проверка нужна, если число представляет набор признаков с двумя возможными значениями (набор флагов). Так, многие системные ячейки памяти содержат сведения о конфигурации компьютера или его состоянии. При этом установка бита с конкретным номером в 1 трактуется как включение какого-либо режима, а в 0 — выключение этого режима.

Пусть переменная a имеет тип byte и является байтом с восемью флагами. Необходимо проверить состояние бита с номером 5 (биты нумеруются справа налево от 0 до 7). Единица в бите 5 — это пятая степень числа 2, т.е. 32 (00100000). Поэтому, если в пятом бите переменной a стоит единица, то выполняется условие (a and 32) = 32, которое можно проверить в операторе ветвления if. Если необходимо проверить состояние нескольких одновременно установленных в единицу битов, то нужно вычислить соответствующее число как сумму степеней числа 2, где показатели степени равны номерам битов, установленных в 1. Например, для битов 5, 2 и 0 имеем 32+4+1=37. Если a имеет среди прочих единицы в битах 5, 2, 0, то выполнится условие (a and 37) = 37.

Пусть нужно обнулить какой-либо бит в переменной a типа byte (например, бит 3). Определим сначала число, содержащее единицы во всех битах, кроме третьего. Максимальное число, которое можно записать в тип byte, равняется 255. Чтобы в нем обнулить третий бит, вычтем из этого числа третью степень числа 2 (255-8=247). Если это число логически умножить на a, то его единицы никак не скажутся на состоянии переменной a, а нуль в третьем бите независимо от значения третьего бита переменной a даст в результате 0. Итак, имеем a:= a and (255-8). Аналогично можно обнулить несколько битов.

Операция or применяется при установке в единицу отдельных битов двоичного представления целых чисел. Так, чтобы установить бит 4 переменной a в единицу без изменения остальных битов, следует записать a:= a or 16, где 16 — четвертая степень числа 2. Аналогично устанавливаются в единицу несколько битов.

Операция xor применяется для смены значения бита (или нескольких битов) на противоположное (1 на 0 или 0 на 1). Так, чтобы переключить в противоположное состояние 3-й бит переменной a, следует записать a:= a xor 8, где 8 — третья степень числа 2.

Порядок выполнения операций

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

  1. Одноместные (унарные) операции: +, -, not.
  2. Мультипликационные операции: *, /, div, mod, and.
  3. Аддитивные операции: +, -, or, xor.
  4. Операции отношения: <, <=, >, >=, =, <>.

Условные операторы

Условные операторы в программировании

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

Чаще всего в качестве условного оператора в языках программирования используется конструкция if-else или ее сокращенный вариант if. Также существует оператор выбора case, который имеет более специфичное применение.

Оператор if-else

Когда выполнение основной ветки программы доходит до условного оператора if-else, то в зависимости от результата логического выражения в его заголовке выполняются разные блоки кода. Если логическое выражение вернуло true, то выполняется один блок (в Паскале начинается со слова then), если false – то другой (начинается со слова else). После выполнения одного из вложенных блоков кода, ход программы возвращается в основную ветку. Другой вложенный блок не выполняется.

Например, программа должна определять, ввел пользователь четное или нечетное число, и выводить на экран сообщение. Тогда программный код на языке Pascal может быть таким:

var n: integer;
begin
    write ('Введите целое число: ');
    readln (n);
 
    if n mod 2 = 0 then
        write ('Оно четное.')
    else
        write ('Оно нечетное.');
 
readln
end.

Бывают неполные формы условных операторов. В таком случае вложенный в if блок кода выполняется только в случая true логическом выражении заголовка. В случае false выполнение программы сразу передается в основной блок. Понятно, что ветка else в таком случае отсутствует.

В примере ниже, если переменная имеет значение меньше нуля, то ее значение изменяется (находится модуль числа). Если же значение переменной изначально больше нуля, то блок кода при операторе if вообще не выполняется, т.к. не соблюдено условие (n<0).

var n: integer;
begin
    write ('Введите целое число: ');
    readln (n);
 
    if n < 0 then
        n := abs (n);
 
    write (n);
 
readln
end.

В качестве условия может стоять любое выражение, результатом вычисления которого является одно из булевых значений — true или false.

Непосредственно после then может стоять только один оператор. При необходимости выполнения нескольких операторов они должны быть заключены в операторные скобки begin-end. Пример программы, которая меняет значения переменных местами, только если эти значения различны. Блок if содержит четыре выражения, поэтому заключен в begin-end.

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 (или if-else) в другой. При этом следует соблюдать осторожность, т.е. бывает трудно определить какому if (внешнему или внутреннему) принадлежит ветка else. Рекомендуют использовать вложенную конструкцию if, только в ветке else. К тому же в языке Паскаль действует следующее правило: каждому then соответствует ближайшее else, не задействованное при установлении соответствия с другим then. Глубина вложенности операторов if может быть сколь угодно большой, но разобраться в таком коде будет очень сложно.

Оператор case (оператор выбора)

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

case селектор of 
	значение1: оператор1;
	значение2: оператор2;
	значение3: оператор3;
	...
	else операторN
end;

В заголовке оператора case вместо логического выражения фигурирует переменная, которую называют селектором. До этого в программе ей присваивается какое-либо значение. Эта переменная может иметь только перечисляемый тип (например, она не может быть вещественного типа). По ходу выполнения оператора case, значение переменной-селектора сравнивается с различными, описанными в нем альтернативами (метками-значениями). Как только совпадение будет найдено, то выполняется блок кода при данной метке и происходит выход в основную ветку программы. Значения-метки являются константами, которые может принимать селектор. Их тип и тип селектора должны быть совместимы по присваиванию.

Если совпадений не будет, то выполняется блок else. Если блок 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 ('Error')
    end;
 
readln
end.

На использование оператора выбора накладываются следующие ограничения:

Задачи к данной теме

Вложенные конструкции if-else

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

Сравните две программы ниже. Они делают одно и то же. Однако предпочтительной является первая.

else-if

var
    a: integer;
 
begin
    write('Введите целое число: ');
    readln(a);
 
    if a = 0 then
        writeln('zero')
    else
        if a = 1 then
            writeln('one')
        else
            if a = 2 then
                writeln('two')
            else
                writeln('unknown');
 
readln
end.

then-if
var
    a: integer;
 
begin
    write('Введите целое число: ');
    readln(a);
 
    if a <> 0 then
        if a <> 1 then
            if a <> 2 then
                writeln('unknown')
            else
                writeln('two')
        else
            writeln('one')
    else
        writeln('zero');
 
readln
end.

При использовании второго варианта надо помнить следующее общее правило: каждый else относится к ближайшему предшествующему if, еще не имеющему парного else.

При вложении в ветвь else (первый вариант) конструкция получается логически более понятной.

Задачи к данной теме

Циклы в Паскале

Циклы языка программирования Pascal

При решении задач может возникнуть необходимость повторить одни и те же действия несколько или множество раз. В программировании блоки кода, которые требуется повторять не единожды, оборачиваются в специальные конструкции – циклы. У циклов выделяют заголовок и тело. Заголовок определяет, до каких пор или сколько раз тело цикла будет выполняться. Тело содержит выражения, которые выполняются, если в заголовке цикла выражение вернуло логическую истину (True, не ноль). После того как достигнута последняя инструкция тела, поток выполнения снова возвращается к заголовку цикла. Снова проверяется условие выполнения цикла. В зависимости от результата тело цикла либо повторяется, либо поток выполнения переходит к следующему выражению после всего цикла.

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

Цикл for

Часто цикл for называют циклом со счетчиком. Этот цикл используется, когда число повторений не связано с тем, что происходит в теле цикла. Т.е. количество повторений может быть вычислено заранее (хотя оно не вычисляется).

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

Цикл for существует в двух формах:

for счетчик:=значение to конечное_значение do 
     тело_цикла;

for счетчик:=значение downto конечное_значение do 
     тело_цикла;

Счетчик – это переменная любого из перечисляемых типов (целого, булевого, символьного, диапазонного, перечисления). Начальные и конечные значения могут быть представлены не только значениями, но и выражениями, возвращающими совместимые с типом счетчика типы данных. Если между начальным и конечным выражением указано служебное слово to, то на каждом шаге цикла значение параметра будет увеличиваться на единицу. Если же указано downto, то значение параметра будет уменьшаться на единицу.

Количество итераций цикла for известно именно до его выполнения, но не до выполнения всей программы. Так в примере ниже, количество выполнений цикла определяется пользователем. Значение присваивается переменной, а затем используется в заголовке цикла. Но когда оно используется, циклу уже точно известно, сколько раз надо выполниться.

var
    i, n: integer;
 
begin
    write ('Количество знаков: ');
    readln (n);
 
    for i := 1 to n do
        write ('(*) ');
 
readln
end.

Цикл while

Цикл while является циклом с предусловием. В заголовке цикла находится логическое выражение. Если оно возвращает true, то тело цикла выполняется, если false – то нет.

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

var
    i, n: integer;
 
begin
    write ('Количество знаков: ');
    readln (n);
 
    i := 1;
    while i <= n do begin
        write ('(*) ');
        i := i + 1
    end;
 
readln
end.

Цикл repeat

Цикл while может не выполниться ни разу, если логическое выражение в заголовке сразу вернуло false. Однако такая ситуация не всегда может быть приемлемой. Бывает, что тело цикла должно выполниться хотя бы один раз, не зависимо оттого, что вернет логическое выражение. В таком случае используется цикл repeat – цикл с постусловием.

В цикле repeat логическое выражение стоит после тела цикла. Причем, в отличие от цикла while, здесь всё наоборот: в случае true происходит выход из цикла, в случае false – его повторение.

var
    i, n: integer;
 
begin
    write ('Количество знаков: ');
    readln (n);
 
    i := 1;
    repeat
        write ('(*) ');
        i := i + 1
    until i > n;
 
readln
end.

В примере, даже если n будет равно 0, одна звездочка все равно будет напечатана.

Задачи к данной теме

Операторы goto, break, continue и прекращения программы

Оператор безусловного перехода goto

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

Позже большинство программистов отказались от регулярного использования оператора 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:5:2);
 
readln
end.

Операторы break и continue

Бывает, что цель выполнения цикла достигается раньше, чем он будет прекращен по условию выхода. Так, например, в программе для определения простоты числа цикл будет выполняться n div 2-1 раз, хотя то, что число не является простым, может быть обнаружено на первых шагах цикла. Чтобы уменьшить количество шагов цикла, можно воспользоваться оператором goto, либо сформировать сложное условие выполнения (прекращения) цикла.

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

Операторы break и continue выполняются в любом из видов циклов (repeat, while, for) и действительны только для внутреннего цикла. Например, если нужно обеспечить принудительный выход из двойного цикла, оператор break должен быть расположен как во внутреннем, так и во внешнем цикле. Операторы break и continue по сути являются видоизмененными операторами goto с известной точкой, в которую осуществляется переход.

В примере у пользователя пять раз запрашивается число только в том случае, если он не вводит ноль.

var
    num: real;
    i: integer;
 
begin
    for i := 1 to 5 do begin
        write ('Введите число: ');
        readln (num);
        if num = 0 then
            break;
        writeln (num)
    end;
 
readln
end.

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

var
    num, sum: real;
    i: integer;
 
begin
    sum := 0;
 
    for i := 1 to 5 do begin
        write ('Введите число: ');
        readln (num);
        if num < 0 then
            continue;
        sum := sum + num
    end;
 
    write (sum:10:2);
 
readln
end.

Принудительное прекращение программы

Обычно программа завершает свою работу по достижении последнего оператора (т.е. при выходе на оператор end с точкой). Если возникает необходимость прекратить выполнение программы где-либо внутри нее, то можно воспользоваться процедурой halt, которая вызывается как отдельный оператор. Эту процедуру можно вызвать, задав в круглых скобках параметр в виде целого неотрицательного числа от 0 до 255. Это значение возвращается в операционную систему в виде кода ошибки (ERRORLEVEL) и может быть проанализирована DOS в случае запуска данной программы из командного файла. Отсутствие параметра в процедуре halt соответствует значению параметра 0 (нормальное завершение программы).

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

Генератор псевдослучайных чисел

Бывают ситуации, когда требуется, чтобы результат работы программы был случайным в определенных пределах. Для реализации такой возможности во многих языках программирования присутствуют встроенные функции, код которых выдает случайные числа. На самом деле числа не совсем случайные, а псевдослучайные. Дело в том, что искусственно реализовать случайность невозможно. Обычно берется некоторый коэффициент, и с его помощью вычисляется каждое последующее «случайное» число.

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

Функция random генерирует случайное число в диапазоне от 0 (включительно) до единицы. Если в скобках указан аргумент, то от 0 до значения указанного в скобках (не включая само значение). Так выражение random (10), говорит о том, что будет получено любое число в диапазоне [0, 10). Если требуется получать значения в каком-либо другом диапазоне (не от нуля), то прибегают к математической хитрости. Например, чтобы получить случайное число от -100 до 100 достаточно записать такое выражение: random (200) – 100. В результате, сначала будет получено число из диапазона [0, 199], а затем из него будет вычтена сотня. И если случайное число было меньше 100, то результат выражения будет отрицательным.

В примере программы сначала с помощью процедуры randomize инициализируется датчик случайных чисел. Далее переменной n присваивается случайное значение в диапазоне [5, 12). Значение переменной n используется для определения количества итераций цикла for. В цикле for генерируются случайные числа в диапазоне [0, 50) и выводятся на экран.

var n, i, x: integer;
 
begin
    randomize;
 
    n := random (7) + 5;
 
    for i := 1 to n do begin
        x := random (100) - 50;
        write (x:5)
    end;
 
readln
end.

Задачи к данной теме

Эквивалентность и совместимость типов

Эквивалентность типов

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

type
 	T1=integer;
 	T3=T1;
 	T2=T3;

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

type
	tp1 = array[1..10] of real;
	tp2 = array[1..10] of real;

Если переменные описаны совместно, то они обладают эквивалентными типами. Например:

var
	v1, v2: tp1;

Совместимость типов

Одним из требований в языке программирования Pascal является следующее: в выражениях (в том числе при сравнении) должны использоваться операнды с совместимыми типами. Типы совместимы, если выполняется хотя бы одно из условий.

type
	tp1 = integer;
 	tp2 = -1..1000;

type
	tp1 ='a'..'z';
	tp2 = 'a'..'f';

type
	tp1 = set of byte;
	tp2 = set of 1..100;

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

Кроме понятий эквивалентности и совместимости типов в Pascal введено понятие совместимости по присваиванию.

Функция sizeof

Для определения объема памяти, отводимого под элемент данных (переменную), используется функция sizeof, которая имеет один параметр. Этот параметр может быть именем типа, переменной, константой или выражением. Например:

writeln(sizeof(real));
writeln(sizeof(n));