Презентация "Основные элементы языка Паскаль"


Подписи к слайдам:
Структурное программирование на языке Паскаль

Основные элементы языка Паскаль

  • © С.В.Кухта, 2009
  • <number>
  • Тема 2.

  • © С.В.Кухта, 2009
  • <number>
  • Общая характеристика языка Паскаль
  • Алфавит языка Паскаль
  • Структура программы
  • Основные объекты программы
  • Типы данных и операции, производимые с ними
  • Стандартные процедуры и функции
  • Арифметические выражения
  • Оператор присваивания
  • Процедуры ввода-вывода данных
  • Метки и оператор безусловного перехода
  • Содержание

  • © С.В.Кухта, 2009
  • <number>
  • 1. Общая характеристика языка Паскаль

  • © С.В.Кухта, 2009
  • <number>
  • Языки программирования
  • Язык Паскаль был разработан Никласом Виртом первоначально для целей обучения программированию.
  • В настоящее время он получил широкое распространение по ряду объективных причин.
    • По своей идеологии Паскаль наиболее близок к современной методике и технологии программирования. В частности, он достаточно полно отражает идеи структурного программирования, что довольно хорошо видно даже из основных управляющих структур языка.
    • Паскаль хорошо приспособлен для применения технологии разработки программ сверху-вниз (пошаговой детализации).
    • Паскаль содержит большое разнообразие различных структур данных, что обеспечивает простоту алгоритмов, а следовательно снижение трудоемкости при разработке программ.

  • © С.В.Кухта, 2009
  • <number>
  • Отличия алгоритмических языков от машинных
  • алгоритмический язык обладает гораздо большими выразительными возможностями, т.е. его алфавит значительно шире алфавита машинного языка, что существенно повышает наглядность текста программы;
  • набор операций, допустимых для использования, не зависит от набора машинных операций, а выбирается из соображений удобства формулирования алгоритмов решения задач определенного класса;
  • формат предложений достаточно гибок и удобен для использования, что позволяет с помощью одного предложения задать достаточно содержательный этап обработки данных;

  • © С.В.Кухта, 2009
  • <number>
  • Отличия алгоритмических языков от машинных
  • требуемые операции задаются в удобном для человека виде, например, с помощью общепринятых математических обозначений;
  • для задания операндов операций, используемым в алгоритме данным присваиваются уникальные имена, выбираемые программистом, и ссылка на операнды производится, в основном, по именам;
  • в языке может быть предусмотрен значительно более широкий набор типов данных по сравнению с набором машинных типов данных.

  • © С.В.Кухта, 2009
  • <number>
  • Языки программирования
  • Из вышеперечисленного следует, что алгоритмический язык в значительной мере является машинно-независимым.

  • © С.В.Кухта, 2009
  • <number>
  • 2. Основные понятия языка Паскаль

  • © С.В.Кухта, 2009
  • <number>
  • Алфавит языка Паскаль
  • Алфавит включает в себя буквы, цифры и специальные символы.
  • 1. Прописные и строчные буквы латинского алфавита:
  • A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
  • a b c d e f g h i j k l m n o p q r s t u v w x y z
  • _ знак подчеркивания (используется в именах вместо пробела)
  • 2. Десятичные цифры: 0 1 2 3 4 5 6 7 8 9

  • © С.В.Кухта, 2009
  • <number>
  • Алфавит языка Паскаль
  • 3. Прописные и строчные буквы русского алфавита
  • (для комментариев, для вывода сообщений на экран):
  • А Б В Г Д Е Ё Ж З И Й К Л М Н О П Р С Т У Ф Х Ц Ч Ш
  • Щ Ъ Ы Ь Э Ю Я
  • а б в г д е ё ж з и й к л м н о п р с т у ф х ц ч ш
  • щ ъ ы ь э ю я

  • © С.В.Кухта, 2009
  • <number>
  • Алфавит языка Паскаль
  • 4. Специальные символы:
    • + плюс – минус
    • * звездочка / дробная черта (слэш)
    • > больше < меньше = равно
    • : двоеточие ; точка с запятой
    • пробел
    • ' апостроф , запятая . точка
    • ^ крышка @ коммерческое а (эт)
    • $ знак доллара # номер
    • [ ] квадратные скобки
    • { } фигурные скобки
    • ( ) круглые скобки

  • © С.В.Кухта, 2009
  • <number>
  • Алфавит языка Паскаль
  • 5. Составные символы, которые нельзя разделять пробелами
    • <> не равно
    • <= меньше или равно
    • >= больше или равно
    • := присваивание
    • .. промежуток значений
    • (* *) (. .) начало и конец комментариев
    • (замена фигурных скобок)

  • © С.В.Кухта, 2009
  • <number>
  • Зарезервированные слова
  • ABSOLUTE
  • AND
  • ARRAY
  • ASM
  • ASSEMBLER
  • BEGIN
  • CASE
  • CONST
  • CONSTRUCTOR
  • DESTRUCTOR
  • DIV
  • DO
  • DOWNTO
  • ELSE
  • END
  • EXTERNAL
  • FAR
  • FILE
  • FOR
  • FORWARD
  • FUNCTION
  • GOTO
  • IF
  • IMPLEMENTATION
  • IN
  • INHERITED
  • INLINE
  • INTERFACE
  • INTERRUPT
  • LABEL
  • MOD
  • NEAR
  • NIL
  • NOT
  • OBJECT
  • OF
  • OR
  • PACKED
  • PRIVATE
  • PROCEDURE
  • PROGRAM
  • PUBLIC
  • RECORD
  • REPEAT
  • SET
  • SHL
  • SHR
  • STRING
  • THEN
  • TO
  • TYPE
  • UNIT
  • UNTIL
  • USES
  • VAR
  • VIRTUAL
  • WHILE
  • WITH
  • XOR

  • © С.В.Кухта, 2009
  • <number>
  • Структура программы
  • Для того чтобы компилятор правильно понял, какие именно действия от него ожидаются, ваша программа должна быть оформлена в полном соответствии с синтаксисом (правилами построения программ) языка Паскаль.

  • © С.В.Кухта, 2009
  • <number>
  • Структура программы
  • program <имя программы>;
  • Uses …; { подключаемые модули и библиотеки }
  • Label …; { раздел объявления меток }
  • Const …; { раздел объявления констант }
  • Type …; { раздел объявления типов }
  • Var …; { раздел объявления переменных }
  • begin { начало основного блока программы }
  • { операторы основного блока программы }
  • end. { конец основного блока программы }
  • Procedure …; { раздел описания процедур }
  • Function …; { раздел описания функций }
  • комментарии в фигурных скобках не обрабатываются

  • © С.В.Кухта, 2009
  • <number>
  • Структура программы
  • Любой из перечисленных необязательных разделов может встречаться в тексте программы более одного раза, их общая последовательность также может меняться, но при этом всегда должно выполняться главное правило языка Паскаль:
  • прежде чем объект будет использован, он должен быть объявлен и описан.
  • !

  • © С.В.Кухта, 2009
  • <number>
  • Оформление текста программы
  • Шапка – комментарий в начале процедур и функций.
  • {----------------------------------------
  • Max – максимальное из двух чисел
  • Вход: a, b – исходные числа
  • Выход: максимальное из a и b
  • ----------------------------------------}
  • function Max(a, b: integer): integer;
  • begin
  • ...
  • end;

  • © С.В.Кухта, 2009
  • <number>
  • Оформление текста программы
  • Отступы – тело цикла, условного оператора, оператора выбора и т.п. сдвигается вправо на 2-3 символа.
  • for i:=1 to n do begin j := 0; while j < i
  • do begin j := j + 1; k := k mod N; end; k
  • := k + 1; end;
  • лесенка
  • for i:=1 to n do begin
  • j := 0;
  • while j < i do begin
  • j := j + 1;
  • k := k mod N;
  • end;
  • k := k + 1;
  • end;
  • легче читать текст программы
  • видны блоки begin-end (где начинаются и заканчиваются)
  • Скорость работы программы не меняется!
  • !

  • © С.В.Кухта, 2009
  • <number>
  • Оформление текста программы
  • «говорящие» имена функций, процедур, переменных: Sum, ShowMenu, count, speed.
  • пробелы в операторах
  • выделение пустыми строками и комментариями важных блоков
  • if(a<b)then b:=c+d;
  • if ( a < b ) then
  • b := c + d;
  • { ввод данных }
  • writeln( 'Введите число' );
  • read ( n );
  • { вычисления }
  • n2 := n*n;
  • { вывод результата }
  • writeln ( 'Его квадрат ', n2);

  • © С.В.Кухта, 2009
  • <number>
  • Порядок разработки программы
  • 1. Программист должен знать алгоритм решения задачи
  • 2. Нужно придумать имена константам, переменным
  • 3. Нужно определить какого типа будут переменные
  • 4. Перед вычислениями нужно задать или ввести исходные данные для решения задачи
  • 5. Задать действия необходимые для получения результата
  • 6. Полученный результат нужно вывести
  • 7. Проверить работоспособность программы на нескольких исходных данных

  • © С.В.Кухта, 2009
  • <number>
  • Из чего состоит программа?
  • Константа – постоянная величина, имеющая имя.
  • Переменная – изменяющаяся величина, имеющая имя (ячейка памяти).
  • Выражение состоит из констант, переменных, указателей функций, знаков операций и скобок и служит для задания правила вычисления некоторого значения.
  • Комментарий – строка (или несколько строк) из произвольных символов, заключенная в фигурные скобки.
  • Оператор – неделимый элемент программы, который позволяет выполнять определенные алгоритмические действия.

  • © С.В.Кухта, 2009
  • <number>
  • Из чего состоит программа?
  • Процедура – вспомогательный алгоритм, описывающий некоторые действия (рисование окружности).
  • Функция – вспомогательный алгоритм для выполнения вычислений (вычисление квадратного корня, sin).

  • © С.В.Кухта, 2009
  • <number>
  • Идентификаторы
  • Имена, даваемые программным объектам (константам, типам, переменным, функциям и процедурам, да и всей программе целиком) называются идентификаторами.
  • Каждый объект программы должен иметь уникальный идентификатор.
  • Идентификаторы могут иметь любую длину, но если у двух имен первые 63 символа совпадают, то такие имена считаются идентичными. Максимальная длина - 127 символов.
  • Вы можете давать программным объектам любые имена, но необходимо, чтобы они отличались от зарезервированных слов языка Паскаль, потому что компилятор все равно не примет переменные с "чужими" именами.

  • © С.В.Кухта, 2009
  • <number>
  • Идентификаторы
  • Имена могут включать
    • латинские буквы (A-Z)
    • цифры
    • знак подчеркивания _
  • заглавные и строчные буквы не различаются
  • Имена НЕ могут включать
    • русские буквы
    • пробелы
    • скобки, знаки +, =, !, ? и др.
  • имя не может начинаться с цифры

  • © С.В.Кухта, 2009
  • <number>
  • Идентификаторы
  • Какие имена правильные?
    • AXby R&B
    • 4Wheel Вася
    • “PesBarbos” TU154
    • [QuQu] _ABBA
    • A+B Koren uravneniya
    • X1_X2 Koren

  • © С.В.Кухта, 2009
  • <number>
  • Константа - это объект, значение которого известно еще до начала работы программы.
    • необходимы для оформления наглядных программ,
    • незаменимы при использовании в тексте программы многократно повторяемых значений,
    • удобны в случае необходимости изменения этих значений сразу во всей программе.
  • Константы

  • © С.В.Кухта, 2009
  • <number>
  • Константы
  • const
  • i2 = 45; { целое число }
  • pi = 3.14; { вещественное число }
  • qq = 'Вася'; { строка символов }
  • L = True; { логическая величина }
  • целая и дробная часть отделяются точкой
  • можно использовать русские буквы!
  • может принимать два значения:
    • True (истина, «да»)
    • False (ложь, «нет»)

  • © С.В.Кухта, 2009
  • <number>
  • Константы
  • В языке Паскаль существует три вида констант:
    • неименованные константы (цифры и числа, символы и строки, множества);
    • именованные нетипизированные константы;
    • именованные типизированные константы.

  • © С.В.Кухта, 2009
  • <number>
  • Неименованные константы
  • Неименованные константы не имеют имен, и потому их не нужно описывать.
  • Тип неименованной константы определяется автоматически, по умолчанию:
    • любая последовательность цифр (возможно, предваряемая знаком "-" или "+" или разбиваемая одной точкой) воспринимается компилятором как число (целое или вещественное);
    • любая последовательность символов, заключенная в апострофы, воспринимается как строка (см. сл. тему);
    • любая последовательность целых чисел либо символов через запятую, обрамленная квадратными скобками, воспринимается как множество (см. сл. тему).
  • Кроме того, существуют две специальные константы true и false, относящиеся к логическому типу данных.

  • © С.В.Кухта, 2009
  • <number>
  • Неименованные константы
  • int1 := -10;
  • real2 := 12.075 + х;
  • char3 := 'z';
  • string4 := 'abc' + string44;
  • set5 := [1,3,5] * set55;
  • boolean6 := true;
  • Примерами использования неименованных констант могут послужить следующие операторы:

  • © С.В.Кухта, 2009
  • <number>
  • Нетипизированные константы
  • Именованные константы, как следует из их названия, должны иметь имя. Стало быть, эти имена необходимо сообщить компилятору, то есть описать в специальном разделе const.
  • Если не указывать тип константы, то по ее внешнему виду компилятор сам определит, к какому (базовому) типу ее отнести.
  • Любую уже описанную константу можно использовать при объявлении других констант, переменных и типов данных.

  • © С.В.Кухта, 2009
  • <number>
  • const n = -10;
  • m = 1000000000;
  • mmm = n*100;
  • x = 2.5;
  • c = 'z';
  • s = 'компьютер';
  • b = true;
  • Примеры описания нетипизированных констант:
  • Нетипизированные константы

  • © С.В.Кухта, 2009
  • <number>
  • Типизированные константы
  • Любую уже описанную константу можно использовать при объявлении других констант, переменных и типов данных.
  • Типизированные именованные константы представляют собой переменные(!) с начальным значением, которое к моменту старта программы уже известно.
  • Следовательно,
    • во-первых, типизированные константы нельзя использовать для определения других констант, типов данных и переменных,
    • во-вторых, их значения можно изменять в процессе работы программы.

  • © С.В.Кухта, 2009
  • <number>
  • Типизированные константы
  • Описание типизированных констант производится по следующему шаблону:
  • const
  • < имя константы > : < тип константы > =
  • <начальное значение>;

  • © С.В.Кухта, 2009
  • <number>
  • const n: integer = -10;
  • x: real = 2.5;
  • c: char = 'z';
  • b: boolean = true;
  • Примеры описания типизированных констант:
  • Типизированные константы
  • Примеры типизированных констант других типов будем приводить по мере изучения соответствующих типов данных.

  • © С.В.Кухта, 2009
  • <number>
  • Переменные
  • Переменная – это величина, имеющая имя, тип данных и значение. Значение переменной можно изменять во время работы программы.
  • Тип данных - это характеристика диапазона значений, которые может принимать переменная, относящиеся к этому типу данных.
  • Наиболее часто применяемые типы переменных:
    • integer { целая }
    • real { вещественная }
    • char { один символ }
    • string { символьная строка }
    • boolean { логическая }

  • © С.В.Кухта, 2009
  • <number>
  • Переменные
  • Все используемые в программе переменные должны быть описаны в специальном разделе var по следующему шаблону:
  • Пример объявления переменных (выделение памяти):
  • var a, b: integer;
    • Q: real;
    • s1, s2: string;
    • var <имя переменной 1> [, <имя переменной 2,
    • ...>] : <имя типа 1>;
    • <имя переменной 3> [, <имя переменной 4,
    • ...>] : <имя типа 2>;

  • © С.В.Кухта, 2009
  • <number>
  • Комментарии
  • Используют для пояснений, необходимых для лучшего понимания программы.
  • Комментарий представляет собой пояснительный текст, который можно записывать в любом месте программы, где разрешен пробел.
  • Текст комментария ограничен символами { и } или (* и *). Может содержать любые комбинации латинских и русских букв, цифр и других символов алфавита языка Паскаль.
  • Примеры:
  • { Комментарий к программе Regress }
  • { Блок вычисления
  • корней уравнения }
  • (* Переменная для вычисления суммы ряда *)

  • © С.В.Кухта, 2009
  • <number>
  • Комментарии
  • По месту положения в программе комментарии подразделяются на четыре класса:
    • объясняющие назначение программы;
    • поясняющие смысл идентификаторов констант и переменных;
    • поясняющие смысл идентификаторов констант и переменных;
    • объясняющие труднопонимаемые элементы алгоритма.

  • © С.В.Кухта, 2009
  • <number>
  • Комментарии
  • Внутри самого комментария символы } или *) встречаться не должны.
  • Во время компилирования программы комментарии игнорируются. Следовательно, их можно добавлять в любом месте программы.
  • Можно даже разорвать оператор вставкой комментария.
  • Кроме того, все, что находится после ключевого слова end., завершающего текст программы, компилятор тоже воспринимает как комментарий.

  • © С.В.Кухта, 2009
  • <number>
  • 3. Типы данных и операции

  • © С.В.Кухта, 2009
  • <number>
  • Компиляторы языка Паскаль требуют, чтобы сведения об объеме памяти, необходимой для работы программы, были предоставлены до начала ее работы.
  • Для этого в разделе описания переменных (var) нужно перечислить все переменные, используемые в программе. Кроме того, необходимо также сообщить компилятору, сколько памяти каждая из этих переменных будет занимать. А еще было бы неплохо заранее условиться о различных операциях, применимых к тем или иным переменным.
  • Все это можно сообщить программе, просто указав тип будущей переменной. Имея информацию о типе переменной, компилятор "понимает", сколько байт необходимо отвести под нее, какие действия с ней можно производить и в каких конструкциях она может участвовать.

  • © С.В.Кухта, 2009
  • <number>
  • Тип данных определяет:
    • возможные значения переменных, констант, функций, выражений, принадлежащих к данному типу;
    • внутреннюю форму представления данных в ЭВМ;
    • операции и функции, которые могут выполняться над величинами, принадлежащими к данному типу.

  • © С.В.Кухта, 2009
  • <number>
  • Классификация типов данных
  • Для удобства программистов существует множество стандартных типов данных и плюс к тому возможность создавать новые типы.
  • Конструируя новые типы данных на основе уже имеющихся (стандартных или опять-таки определенных самим программистом), нужно помнить, что любое здание должно строиться на хорошем фундаменте. Поэтому сейчас мы и поговорим об этом "фундаменте".
  • На основании базовых типов данных строятся все остальные типы языка Паскаль, которые так и называются: конструируемые.

  • © С.В.Кухта, 2009
  • <number>
  • Классификация типов данных
  • Типы данных
  • Скалярные
  • Структурированные
  • Стандартные
  • Типы, определяемые пользователем
  • Вещественный
  • Целый
  • Символьный
  • Логический
  • Адресный
  • Перечисляемый
  • Интервальный
  • Множества
  • Массивы
  • Записи
  • Файлы
  • базовые типы
  • конструируемые типы

  • © С.В.Кухта, 2009
  • <number>
  • Формат описания типа
  • Type <Имя типа> = <описание типа>;
  • Типы данных, конструируемые программистом, описываются в разделе type по следующему шаблону:
  • type lat_bukvy = 'a'..'z','A'..'Z';
  • Например:

  • © С.В.Кухта, 2009
  • <number>
  • Базовые типы данных являются стандартными, поэтому нет нужды описывать их в разделе type. Однако при желании это тоже можно сделать, например, дав длинным определениям короткие имена.
  • Скажем, введя новый тип данных
  • можно немного сократить текст программы.
  • Стандартные конструируемые типы также можно не описывать в разделе type.
  • Однако в некоторых случаях это все равно приходится делать из-за требований синтаксиса. Например, в списке параметров процедур или функций конструкторы типов использовать нельзя (см. лекции далее).
  • type int = integer;

  • © С.В.Кухта, 2009
  • <number>
  • Целочисленные типы определяют константы, переменные и функции, значения которых реализуются множеством целых чисел.
  • Целочисленные типы данных
  • Целочисленный тип данных BYTE
  • Целочисленный тип данных WORD
  • Допустимые значения: от 0 до 255
  • Пример: 5 58
  • Формат хранения в оперативной памяти: 1 байт без знака
  • Допустимые значения: от 0 до 65535
  • Пример: 5 58 43467
  • Формат хранения в оперативной памяти: 2 байта без знака

  • © С.В.Кухта, 2009
  • Целые беззнаковые числа
  • Беззнаковые данные – не могут быть отрицательными.
  • Байт (символ)
  • память: 1 байт = 8 бит
  • диапазон значений 0…255, 0…FF16 = 28 - 1
  • Паскаль: byte
  • 0
  • 1
  • 0
  • 0
  • 1
  • 1
  • 1
  • 0
  • 7
  • 6
  • 5
  • 4
  • 3
  • 2
  • 1
  • 0
  • биты
  • младший
  • старший
  • старший полубайт
  • старшая цифра
  • младший полубайт
  • младшая цифра
  • 416
  • E16
  • 10011102 = 4E16

  • © С.В.Кухта, 2009
  • Целые беззнаковые числа
  • Целое без знака
  • память: 2 байта = 16 бит диапазон значений 0…65535, 0…FFFF16 = 216-1
  • Паскаль: word
  • 0
  • 1
  • 0
  • 0
  • 1
  • 1
  • 0
  • 1
  • 0
  • 1
  • 1
  • 1
  • 1
  • 0
  • 1
  • 0
  • 15
  • 14
  • 13
  • 12
  • 11
  • 10
  • 9
  • 8
  • 7
  • 6
  • 5
  • 4
  • 3
  • 2
  • 1
  • 0
  • биты
  • старший байт
  • младший байт
  • 4D16
  • 7A16
  • 1001101011110102 = 4D7A16

  • © С.В.Кухта, 2009
  • <number>
  • Целочисленные типы данных
  • Целочисленный тип данных SHORTINT
  • Целочисленный тип данных INTEGER
  • Допустимые значения: от –128 до 127
  • Пример: -5 0 58
  • Формат хранения в оперативной памяти: 1 байт со знаком
  • Допустимые значения: от –32768 до 32767
  • Пример: 5 –58 0 10000 –32768
  • Формат хранения в оперативной памяти: 2 байта со знаком

  • © С.В.Кухта, 2009
  • <number>
  • Целочисленные типы данных
  • Целочисленный тип данных LONGINT
  • Допустимые значения: от –2147483648 до 2147473647
  • Пример: 5 –3345550 3345550 0
  • Формат хранения в оперативной памяти: 4 байта со знаком

  • © С.В.Кухта, 2009
  • «-1» – это такое число, которое при сложении с 1 даст 0.
  • 1 байт: FF16 + 1 = 1 0 0 16
  • 2 байта: FFFF16 + 1 = 1 0 0 0 0 16
  • 4 байта: FFFFFFFF16 + 1 = 1 0 0 0 0 0 0 0 0 16
  • Целые числа со знаком
  • Сколько места требуется для хранения знака?
  • ?
  • Старший (знаковый) бит числа определяет его знак. Если он равен 0, число положительное, если 1, то отрицательное.
  • не помещается в 1 байт!

  • © С.В.Кухта, 2009
  • Двоичный дополнительный код
  • Задача: представить отрицательное число (–a) в двоичном дополнительном коде.
  • Решение:
    • Перевести число a–1 в двоичную систему.
    • Записать результат в разрядную сетку с нужным числом разрядов.
    • Заменить все «0» на «1» и наоборот (инверсия).
  • Пример: (– a) = – 78, сетка 8 бит
    • a – 1 = 77 = 10011012
  • 0
  • 1
  • 0
  • 0
  • 1
  • 1
  • 0
  • 1
  • 1
  • 0
  • 1
  • 1
  • 0
  • 0
  • 1
  • 0
  • = – 78
  • знаковый бит

  • © С.В.Кухта, 2009
  • Целые числа со знаком
  • Байт (символ) со знаком
  • память: 1 байт = 8 бит диапазон значений:
  • max
  • min
  • – 128 = – 27 … 127 = 28 – 1
  • Паскаль: shortint
  • 0
  • 1
  • 1
  • 1
  • 1
  • 1
  • 1
  • 1
  • 1
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • можно работать с отрицательными числами
  • уменьшился диапазон положительных чисел
  • 127
  • – 128

  • © С.В.Кухта, 2009
  • Целые числа со знаком
  • Слово со знаком
  • память: 2 байта = 16 бит
  • диапазон значений
  • – 32768 … 32767
  • Паскаль: integer
  • Двойное слово со знаком
  • память – 4 байта диапазон значений
  • – 231 … 231-1
  • Паскаль: longint
  • 15
  • 14
  • 13
  • 12
  • 11
  • 10
  • 9
  • 8
  • 7
  • 6
  • 5
  • 4
  • 3
  • 2
  • 1
  • 0

  • © С.В.Кухта, 2009
  • Ошибки
  • Переполнение разрядной сетки: в результате сложения больших положительных чисел получается отрицательное (перенос в знаковый бит).
  • 0
  • 1
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 1
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • +
  • 64
  • 64
  • 7
  • 6
  • 5
  • 4
  • 3
  • 2
  • 1
  • 0
  • 1
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • – 128

  • © С.В.Кухта, 2009
  • Ошибки
  • Перенос: при сложении больших (по модулю) отрицательных чисел получается положительное (перенос за границы разрядной сетки).
  • 1
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 1
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • +
  • – 128
  • 7
  • 6
  • 5
  • 4
  • 3
  • 2
  • 1
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • – 128
  • 1
  • в специальный бит переноса

  • © С.В.Кухта, 2009
  • <number>
  • Над целочисленными операндами выполняются арифметические операции, операции отношения.
  • Целочисленные типы данных
  • Арифметические операции
  • + сложение,
  • вычитание,
  • * умножение,
  • MOD и DIV целочисленное деление:
    • MOD – остаток от деления операндов
    • DIV – целая часть частного.
  • Результат выполнения операции является величиной целого типа.
  • 21 Div 4 = 5 21 MOD 5 = 1
  • 4 DIV 8 = 0 4 mod 8 = 4
  • (-2 mod 5)= -2

  • © С.В.Кухта, 2009
  • <number>
  • Целочисленные типы данных
  • Операции отношения (сравнения)
  • = равенство, <> неравенство,
  • < меньше, > больше,
  • <= меньше или равно, >= больше или равно
  • Результат выполнения операции является величиной логического типа (True или False).

  • © С.В.Кухта, 2009
  • <number>
  • Вещественные типы определяют константы, переменные и функции, значения которых реализуются множеством действительных (вещественных) чисел.
  • Вещественные типы данных
  • Вещественный тип данных REAL
  • Вещественный тип данных SINGLE
  • Допустимые значения: от 2.9e–39 до 1.7e+38
  • Пример: 5.567 58e–3 1.76e+8 1.0
  • Формат хранения в оперативной памяти: 6 байт, в том числе 11 цифр для мантиссы
  • Допустимые значения: от 1.5e–45 до 3.4e+38
  • Формат хранения в оперативной памяти: 4 байта, в том числе 7 цифр для мантиссы

  • © С.В.Кухта, 2009
  • <number>
  • Вещественные типы данных
  • Вещественный тип данных DOUBLE
  • Вещественный тип данных EXTENDED
  • Допустимые значения: от 5.0e–324 до 1.7e+308
  • Формат хранения в оперативной памяти: 8 байт, в том числе 15 цифр для мантиссы
  • Допустимые значения: от 3.4e–4932 до 1.1e+4932
  • Формат хранения в оперативной памяти: 10 байт, в том числе 19 цифр для мантиссы
  • Вещественный тип данных COMP
  • Допустимые значения: от –9.2e+18 до 9.2e+18
  • Формат хранения в оперативной памяти: 8 байт, в том числе 19 цифр для мантиссы

  • © С.В.Кухта, 2009
  • Нормализация двоичных чисел
  • X = s  M  2e
  • s знак (1 или -1)
  • M мантисса,
  • e порядок
  • M = 0 или 1 M < 2
  • 15,625 =
  • 1111,1012 =
  • 11,1111012 23
  • знак
  • порядок
  • мантисса
  • Пример:

  • © С.В.Кухта, 2009
  • Нормализованные числа в памяти
  • IEEE Standard for Binary Floating-Point Arithmetic (IEEE 754)
  • 15,625 = 11,1111012 23
  • s = 1 e = 3 M = 1,1111012
  • p
  • m
  • Знаковый бит:
  • 0, если s = 1
  • 1, если s = – 1
  • Порядок со сдвигом:
  • p = e + E (сдвиг)
  • Дробная часть мантиссы:
  • m = M – 1
  • Целая часть M всегда 1, поэтому не хранится в памяти!
  • ?

  • © С.В.Кухта, 2009
  • Вещественные числа в памяти
  • 15,625 = 1,1111012 23
  • 4 байта = 32 бита
  • 0
  • 1
  • 0
  • 0
  • 0
  • 0
  • 0
  • 1
  • 0
  • 1
  • 1
  • 1
  • 1
  • 0
  • 1
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
  • 31
  • 0
  • 22
  • 30
  • 23
  • p = e+127 = 130
  • =100000102
  • m = M – 1 = 0,1111012

  • © С.В.Кухта, 2009
  • <number>
  • Над вещественными операндами выполняются арифметические операции, операции отношения.
  • Вещественные типы данных
  • Арифметические операции
  • + сложение,
  • вычитание,
  • * умножение,
  • / деление.
  • Результат выполнения операции является величиной вещественного типа.
  • 3.0+7.51 6.2–10/33
  • 5.23*(–10.1E2) 21.2/(11.21E–2)

  • © С.В.Кухта, 2009
  • <number>
  • Операции отношения (сравнения)
  • = равенство, <> неравенство,
  • < меньше, > больше,
  • <= меньше или равно, >= больше или равно
  • Результат выполнения операции является величиной логического типа (True или False).
  • Вещественные типы данных

  • © С.В.Кухта, 2009
  • <number>
  • Данные, которые могут принимать логические значения True и False.
  • Логический тип данных BOOLEAN
  • Логические операции
    • Not – логическое отрицание
    • And – логическое И (конъюнкция)
    • Or – логическое ИЛИ (дизъюнкция)
    • Xor – логическое исключающее ИЛИ
  • Таблицы истинности для операций:
  • А
  • В
  • Not А
  • А And В
  • А Or В
  • А Xor В
  • False
  • False
  • True
  • False
  • False
  • False
  • False
  • True
  • False
  • True
  • True
  • True
  • False
  • False
  • False
  • True
  • True
  • True
  • True
  • True
  • True
  • False

  • © С.В.Кухта, 2009
  • <number>
  • Операции отношения (сравнения)
  • Логический тип определен таким образом, что
  • True < False.
  • Это позволяет применять к булевским операндам все операции сравнения:
  • = равенство, <> неравенство,
  • < меньше, > больше,
  • <= меньше или равно, >= больше или равно
  • Логический тип данных BOOLEAN

  • © С.В.Кухта, 2009
  • <number>
  • Типы данных: символы
  • Символьный тип данных CHAR
  • Допустимые значения: один символ из кодовой таблицы (256 символов кода ASCII)
  • Пример: Y f 4 я Д *
  • Формат хранения в оперативной памяти: 1 байт
  • Применимы все операции отношения, функции преобразования типов Ord() и Chr(), функции, которые определяют предыдущий и последующий символы Pred() и Succ().

  • © С.В.Кухта, 2009
  • <number>
  • Типы данных: символы
  • Строковый тип данных STRING
  • Строка типа String – это цепочка символов типа Char.
  • String используется для хранения текстовых сообщений.
  • Допустимые значения: любой текст длинной не более 255 символов
  • Пример: Всё, что вы хотите написать!
  • Формат хранения в оперативной памяти: 1 байт на каждый символ строки + 1 байт под длину строки

  • © С.В.Кухта, 2009
  • <number>
  • Кодирование символов
  • Текстовый файл
  • на экране (символы)
  • в памяти – двоичные коды
  • 10000012
  • 10000102
  • 10000112
  • 10001002
  • В файле хранятся не изображения символов, а их числовые коды в двоичной системе!
  • !
  • 65
  • 66
  • 67
  • 68

  • © С.В.Кухта, 2009
  • <number>
  • Кодирование символов
  • Сколько символов надо использовать одновременно? или 65536 (UNICODE)
  • Сколько места надо выделить на символ:
  • Выбрать 256 любых символов (или 65536) - алфавит.
  • Каждому символу – уникальный код 0..255 (или 0..65535). Таблица символов:
  • Коды – в двоичную систему.
  • 256
  • 256 = 28 8 бит на символ
  • 65
  • 66
  • 67
  • 68
  • A
  • B
  • C
  • D
  • коды

  • © С.В.Кухта, 2009
  • <number>
  • Кодировка 1 байт на символ
  • 0
  • 1
  • 254
  • 255
  • 127
  • 128
  • таблица ASCII
  • (международная)
  • кодовая страница
  • ASCII = American Standard Code for Information Interchange
    • 0-31 управляющие символы: 7 – звонок, 10 – новая строка, 13 – возврат каретки, 27 – Esc.
    • 32 пробел
    • знаки препинания: . , : ; ! ?
    • специальные знаки: + - * / () {} []
    • 48-57 цифры 0..9
    • 65-90 заглавные латинские буквы A-Z
    • 97-122 строчные латинские буквы a-z
  • Кодовая страница (расширенная таблица ASCII) для русского языка:
  • CP-866 для системы MS DOS
  • CP-1251 для системы Windows (Интернет)
  • КОИ8-R для системы UNIX (Интернет)

  • © С.В.Кухта, 2009
  • <number>
  • Типы данных, определяемые программистом
  • Интервальный тип данных
  • Позволяет задавать две константы, определяющие границы диапазона значений для данной переменной.
  • Обе константы должны принадлежать одному из стандартных типов (тип real здесь недопустим).
  • Значение первой константы должно быть обязательно меньше второй.
  • Type <Имя типа> =
  • <константа 1> .. <константа 2> ;
  • Формат описания типа:
  • Type Dni = 1 ..31;
  • Например:

  • © С.В.Кухта, 2009
  • <number>
  • Типы данных, определяемые программистом
  • Перечисляемый тип данных
  • Определение перечисляемого типа задает упорядоченное множество значений путем перечисления имен, обозначающих эти значения.
  • Type <Имя типа> = (<имя данного 1>,
  • <имя данного 2>, …, <имя данного k>);
  • Формат описания типа:
  • Type Weekday = (Monday, Tuesday, Wednesday,
  • Thursday, Friday, Saturday, Sunday);
      • Colour = (Red, Orange, Yellow, Green, Blue,
      • Black);
      • Operation = (Plus, Minus, Times, Divide);
  • Например:

  • © С.В.Кухта, 2009
  • <number>
  • Среди базовых типов данных особо выделяются порядковые типы. Такое название можно обосновать двояко:
    • Каждому элементу порядкового типа может быть сопоставлен уникальный (порядковый) номер. Нумерация значений начинается с нуля. Исключение - типы данных shortint, integer и longint. Их нумерация совпадает со значениями элементов.
    • Кроме того, на элементах любого порядкового типа определен порядок (в математическом смысле этого слова), который напрямую зависит от нумерации. Таким образом, для любых двух элементов порядкового типа можно точно сказать, который из них меньше, а который - больше.
  • Порядковые типы данных

  • © С.В.Кухта, 2009
  • <number>
  • Только для величин порядковых типов определены следующие стандартные функции и процедуры:
    • Функция ord(x) возвращает порядковый номер значения переменной x (относительно того типа, к которому принадлежит переменная х).
    • Функция pred(x) возвращает значение, предшествующее х (к первому элементу типа неприменима).
    • Функция succ(x) возвращает значение, следующее за х (к последнему элементу типа неприменима).
    • Процедура inc(x) возвращает значение, следующее за х (для арифметических типов данных это эквивалентно оператору x:=x+1).
  • Порядковые типы данных

  • © С.В.Кухта, 2009
  • <number>
    • Процедура inc(x, k) возвращает k-е значение, следующее за х (для арифметических типов данных это эквивалентно оператору x:=x+k).
    • Процедура dec(x) возвращает значение, предшествующее х (для арифметических типов данных это эквивалентно оператору x:=x-1).
    • Процедура dec(x, k) возвращает k-e значение, предшествующее х (для арифметических типов данных это эквивалентно оператору x:=x-k).
  • Порядковые типы данных

  • © С.В.Кухта, 2009
  • <number>
  • На первый взгляд кажется, будто результат применения процедуры inc(x) полностью совпадает с результатом применения функции succ(x). Однако разница между ними проявляется на границах допустимого диапазона.
  • Функция succ(x) неприменима к максимальному элементу типа, а вот процедура inc(x) не выдаст никакой ошибки, но, действуя по правилам машинного сложения, прибавит очередную единицу к номеру элемента.
  • Номер, конечно же, выйдет за пределы диапазона и за счет усечения превратится в номер минимального значения диапазона.
  • Получается, что процедуры inc() и dec() воспринимают любой порядковый тип словно бы "замкнутым в кольцо": сразу после последнего вновь идет первое значение.
  • Порядковые типы данных

  • © С.В.Кухта, 2009
  • <number>
  • Поясним все сказанное на примере. Для типа данных
  • type sixteen = 0..15;
  • попытка прибавить 1 к числу 15 приведет к следующему результату:
  • Начальная единица будет отсечена, и потому получится, что inc(15)=0.
  • Аналогичная ситуация на нижней границе допустимого диапазона произвольного порядкового типа данных наблюдается для процедуры dec(x) и функции pred(x):
  • dec(min_element)= max_element
  • Порядковые типы данных
  • 1111
  • 1
  • 10000

  • © С.В.Кухта, 2009
  • <number>
  • Опишем теперь порядковые типы данных более подробно.
  • Логический тип boolean имеет два значения: false и true, и для них выполняются следующие равенства:
    • ord(false)=0, ord(true)=1,
    • false<true,
    • pred(true)=false, succ(false)=true,
    • inc(true)=false, inc(false)=true,
    • dec(true)=false, dec(false)=true.
  • В символьный тип char входит 256 символов расширенной таблицы ASCII (например, 'a', 'b', 'я', '7', '#'). Номер символа, возвращаемый функцией ord(), совпадает с номером этого символа в таблице ASCII.
  • Целочисленные типы данных.
  • Типы данных, относящиеся к порядковым

  • © С.В.Кухта, 2009
  • <number>
  • Перечисляемые типы данных задаются в разделе type явным перечислением их элементов.
    • Например:
    • type week =(sun,mon,tue,wed,thu,fri,sat)
    • 0 1 2 3 4 5 6
    • Для этого типа данных:
      • inc(sat) = sun, dec(sun) = sat.
  • Интервальные типы данных задаются только границами своего диапазона.
    • Например:
    • type month = 1..12;
    • budni = mon..fri;
  • Типы данных, относящиеся к порядковым

  • © С.В.Кухта, 2009
  • <number>
  • Программист может создавать и собственные типы данных, являющиеся комбинацией нескольких стандартных типов.
    • Например:
    • type valid_for_identifiers= 'a'..'z','A'..'Z','_','0'..'9';
    • Этот тип состоит из объединения нескольких интервалов, причем в данном случае изменен порядок латинских букв: если в стандартном типе char 'A' < 'a', то здесь наоборот - 'a' < 'A'.
    • Для величин этого типа выполняются следующие равенства:
    • inc('z')='A'; dec('0')='_',
    • pred('9')='8'; ord('b')= 2.
  • Типы данных, относящиеся к порядковым

  • © С.В.Кухта, 2009
  • <number>
  • 4. Стандартные функции

  • © С.В.Кухта, 2009
  • <number>
  • Арифметические функции
  • Функция
  • Назначение
  • Тип аргумента
  • Тип результата
  • ABS(X)
  • Абсолютное значение (модуль) аргумента
  • целый
  • вещественный
  • целый
  • вещественный
  • ARCTAN(X)
  • Арктангенс аргумента
  • целый
  • вещественный
  • вещественный
  • COS(X)
  • Косинус аргумента
  • целый
  • вещественный
  • вещественный
  • EXP(X)
  • Экспонента аргумента
  • целый
  • вещественный
  • вещественный
  • FRAC(X)
  • Дробная часть числа
  • вещественный
  • вещественный
  • INT(X)
  • Целая часть числа
  • вещественный
  • вещественный
  • LN(X)
  • Натуральный логарифм
  • целый
  • вещественный
  • вещественный
  • PI
  • Значение величины =3.1415926535
  • вещественный
  • SIN(X)
  • Синус аргумента
  • целый
  • вещественный
  • вещественный
  • SQR(X)
  • Квадрат аргумента
  • вещественный
  • вещественный
  • SQRT(X)
  • Квадратный корень аргумента
  • целый
  • вещественный
  • вещественный

  • © С.В.Кухта, 2009
  • <number>
  • Эти функции предназначены для преобразования типов величин, например, символа в целое число, вещественного числа в целое и т.д.
  • Chr(X) – преобразование ASCII-кода в символ. Аргумент функции – целого типа от 0 до 255. Результатом – символ, соответствующий данному коду.
  • High(X) – получение максимального значения величины. Аргумент функции – параметр или идентификатор порядкового типа, типа-массива, типа-строки. Результат функции для величины порядкового типа – максимальное значение этой величины, типа-массива – максимальное значение индекса, типа-строки – объявленный размер строки.
  • Low(X) – получение минимального значения величины. Аргумент функции и результат функции аналогичны High(X).
  • Функции преобразования типов

  • © С.В.Кухта, 2009
  • <number>
  • Ord(X) – преобразование любого порядкового типа в целый тип. Аргумент функции – логический, символьный, перечисляемый тип. Результат – величина типа Longint.
  • Round(X) – округление вещественного числа до ближайшего целого. Результат – округленная до ближайшего целого величина типа Longint.
  • Trunc(X) – получение целой части вещественного числа. Результат – целая часть этого числа типа Longint.
  • Функции преобразования типов

  • © С.В.Кухта, 2009
  • <number>
  • Примеры арифметических функций
  • sin(x)
  • cos(x)
  • arctan(x)
  • Аргумент x для тригонометрических функций указывается в радианах.
  • !
  • a:=Pi/180*30;
  • s:=sin(a); c:=cos(a);
  • t:=s/c; ct:=c/s;
  • синус, косинус, тангенс и котангенс угла 30

  • © С.В.Кухта, 2009
  • <number>
  • Примеры арифметических функций
  • exp(x)
  • ln(x)
  • Exp(b*Ln(a))
  • Вычислять ab таким образом можно только для положительных значений a. Алгоритм вычисления ab для любых значений a будет разобран позднее.
  • !
  • ex (экспонента числа, e2.7183)
  • ln x (натуральный
  • логарифм)
  • ab
  • exp(7*ln(x-3))
  • (x-3)7
  • exp(x*ln(2))
  • 2 x

  • © С.В.Кухта, 2009
  • <number>
  • Примеры арифметических функций
  • Round(x)
  • Trunc(x)
  • Перевод дробного числа в целое
  • с округлением
  • Перевод дробного числа в целое с отбрасыванием дробной части
  • a1:=Round(2.34);
  • a1 = 2
  • a2:=Trunc(2.34);
  • a2 = 2
  • b1:=Round(8.51);
  • b1 = 9
  • b2:=Trunc(8.51);
  • b2 = 8
  • c1:=Round(-3.7);
  • c1 = -4

  • © С.В.Кухта, 2009
  • <number>
  • Примеры арифметических функций
  • Вычисляемая функция
  • Математическая запись
  • Запись на языке Паскаль
  • Exp(y*ln(x))
  • Exp(1/y*ln(x))
  • arctan(x/sqrt(1-x*x))
  • arctan(sqrt(1-x*x)/x)
  • Ln(x)/Ln(y)
  • Sin(x)/Cos(x)

  • © С.В.Кухта, 2009
  • <number>
  • Randomize – стандартная процедура установки датчика случайных чисел в исходное состояние.
  • Random – стандартная функция формирования случайного дробного числа из диапазона от 0 до 1.
  • Random(N) – стандартная функция формирования случайного целого числа из диапазона от 0 до N-1.
  • Генераторы случайных чисел

  • © С.В.Кухта, 2009
  • <number>
  • Примеры получения случайных числе
  • a:=Random;
  • 0<a<1
  • x:=Random+10;
  • 10<x<11
  • y:=5*Random;
  • 0<y<5
  • c:=10*Random-5;
  • -5<c<5
  • a:=Random(3);
  • 0,1,2
  • y:=Random(5)+3;
  • 3,4,5,…,7
  • c:=Random(8)-5;
  • -5,-4,…,2

  • © С.В.Кухта, 2009
  • <number>
  • 5. Арифметические выражения

  • © С.В.Кухта, 2009
  • <number>
  • Все арифметические операции можно сочетать друг с другом - с учетом допустимых для их операндов типов данных.
  • В роли операндов любой операции могут выступать переменные, константы, вызовы функций или выражения, построенные на основе других операций. Все вместе и называется выражением.

  • © С.В.Кухта, 2009
  • <number>
  • Примеры арифметических выражений
  • (x<0) and (y>0)
  • z shl abs(k)
  • выражение, результат которого принадлежит к типу boolean
  • вторым операндом является вызов стандартной функции
  • (x mod k) + min(a,b) + trunc(z)
  • сочетание арифметических операций и вызовов функций
  • odd(round(x/abs(x)))
  • "многоэтажное" выражение
  • sin(-x*x-1/(1+x))*(koef[1]*koef[1]-4*koef[2]);
  • "многоэтажное" выражение с использованием массива

  • © С.В.Кухта, 2009
  • <number>
  • Порядок вычислений
  • Если в выражении расставлены скобки, то чем меньше глубина вложенности скобок, тем позже вычисляется заключенная в них операция.
  • Если же скобок нет, то сначала вычисляются значения операций с более высоким приоритетом, затем – с менее высоким.
  • Несколько подряд идущих операций одного приоритета вычисляются в последовательности "слева направо".
  • Вызов любой функции имеет более высокий приоритет, чем все внешние относительно этого вызова операции. Выражения, являющиеся аргументами вызываемой функции, вычисляются в момент вызова.
  • !

  • © С.В.Кухта, 2009
  • <number>
  • Приоритеты всех операций языка Паскаль
  • Операции
  • Приоритет
  • Унарные операции
  • +, -, not, @, ^, #
  • Первый (высший)
  • Операции, эквивалентные умножению
  • *, /, div, mod, and, shl, shr
  • Второй
  • Операции, эквивалентные сложению
  • +, -, or, xor
  • Третий
  • Операции сравнения
  • =, <>, >, <, <=, >=, in
  • Четвертый

  • © С.В.Кухта, 2009
  • <number>
  • Примеры выражений для целых чисел с указанием последовательности вычислений
  • a + b * c / d
  • a * not b or c * d = 0
  • результат принадлежит к вещественному типу данных
  • результат принадлежит к логическому типу данных
  • 3 1 2
  • 2 1 4 3 5
  • -min(a + b, 0) * (a + 1)
  • результат принадлежит к целочисленному типу данных
  • 3 2 1 5 4

  • © С.В.Кухта, 2009
  • <number>
  • В общем случае при выполнении арифметических (и любых других) операций компилятору требуется, чтобы типы операндов совпадали:
    • нельзя, например, сложить массив и множество,
    • нельзя передать вещественное число функции, ожидающей целый аргумент, и т.п.
  • В то же время, любая процедура или функция, написанная в расчете на вещественные значения, сможет работать и с целыми числами.
  • Правила, по которым различные типы данных считаются взаимозаменяемыми, приведены ниже.
  • Совместимость типов данных

  • © С.В.Кухта, 2009
  • <number>
  • Эквивалентность - это наиболее высокий уровень соответствия типов. Она требуется при действиях с указателями (см. Тему далее), а также при вызовах подпрограмм.
  • "А как же тогда быть с оговоркой, сделанной двумя абзацами выше?" - спросите вы.
  • Мы не станем сейчас описывать механизм передачи аргументов процедурам и функциям, поясним лишь, что эквивалентность типов требуется только для параметров-переменных (см. Тему далее).
  • Эквивалентность

  • © С.В.Кухта, 2009
  • <number>
  • Итак, два типа - Т1 и Т2 - будут эквивалентными, если верен хотя бы один вариант из перечисленных ниже:
    • Т1 и Т2 совпадают;
    • Т1 и Т2 определены в одном объявлении типа;
    • Т1 эквивалентен некоторому типу Т3, который эквивалентен типу Т2.
  • Эквивалентность

  • © С.В.Кухта, 2009
  • <number>
  • Пример.
  • Эквивалентность
  • Здесь эквивалентными будут
    • Т1 и Т2;
    • Т1 и Т3;
    • Т1 и Т4;
    • Т1 и Т5;
    • Т4 и Т5.
  • А вот Т2 и Т3 - не эквивалентны!
  • type T2 = T1;
  • T3 = T1;
  • T4, T5 = T2;

  • © С.В.Кухта, 2009
  • <number>
  • Итак, два типа - Т1 и Т2 - будут эквивалентными, если верен хотя бы один вариант из перечисленных ниже:
    • Т1 и Т2 совпадают;
    • Т1 и Т2 определены в одном объявлении типа;
    • Т1 эквивалентен некоторому типу Т3, который эквивалентен типу Т2.

  • © С.В.Кухта, 2009
  • <number>
  • Совместимость типов требуется при конструировании выражений, а также при вызовах подпрограмм (для параметров-значений).
  • Совместимость означает, что для переменных этих типов возможна операция присваивания - хотя во время этой операции присваиваемое значение может измениться:
    • произойдет неявное приведение типов данных (см. п. "Приведение типов данных" ниже).
  • Совместимость

  • © С.В.Кухта, 2009
  • <number>
  • Два типа Т1 и Т2 будут совместимыми, если верен хотя бы один вариант из перечисленных ниже:
    • Т1 и Т2 эквивалентны (в том числе совпадают);
    • Т1 и Т2 - оба целочисленные или оба вещественные;
    • Т1 и Т2 являются подмножествами одного типа;
    • Т1 является некоторым подмножеством Т2;
    • Т1 - строка, а Т2 - символ (см. Тему далее);
    • Т1 - это тип pointer, а Т2 - типизированный указатель (см. Тему далее);
    • Т1 и Т2 - оба процедурные, с одинаковым количеством попарно эквивалентных параметров, а для функций - с эквивалентными типами результатов (см. Тему далее).
  • Совместимость

  • © С.В.Кухта, 2009
  • <number>
  • В отличие от простой совместимости, совместимость по присваиванию гарантирует, что в тех случаях, когда производится какое-либо присваивание (используется запись вида a:=b; или происходит передача значений в подпрограмму или из нее и т.п.), не произойдет никаких изменений присваиваемого значения.
  • Два типа данных Т1 и Т2 называются совместимыми по присваиванию, если выполняется хотя бы один вариант из перечисленных ниже:
    • Т1 и Т2 эквивалентны, но не файлы;
    • Т1 и Т2 совместимы, причем Т2 – некоторое подмножество в Т1;
    • Т1 – вещественный тип, а Т2 – целый.
  • Совместимость по присваиванию

  • © С.В.Кухта, 2009
  • <number>
  • Как мы упомянули в п. "Арифметические операции" выше, тип результата арифметических операций (а следовательно, и выражений) может отличаться от типов исходных операндов.
  • Например, при "дробном" делении ( / ) одного целого числа на другое целое в ответе все равно получается вещественное.
  • Такое изменение типа данных называется неявным приведением типов.
  • Если в некоторой операции присваивания участвуют два типа данных совместимых, но не совместимых по присваиванию, то тип присваиваемого выражения автоматически заменяется на подходящий. Это тоже неявное приведение. Причем в этих случаях могут возникать изменения значений.
  • Неявное приведение типов данных

  • © С.В.Кухта, 2009
  • <number>
  • Т.е., если выполнить такую последовательность операторов
  • Неявное приведение типов данных
  • a:= 10; {a: byte}
  • a:= -a;
  • writeln(a);
  • то на экране мы увидим не -10, а 246 (246 = 256 - 10).
  • Неявным образом осуществляется и приведение при несоответствии типов переменной-счетчика и границ в циклах for (см. след. Тему).

  • © С.В.Кухта, 2009
  • <number>
  • Неявное приведение типов данных можно отключить, если указать директиву компилятора {$R+}, которая принуждает компилятор всегда проверять границы и диапазоны.
  • Если эта директива включена, то во всех ситуациях, в которых по умолчанию достаточно совместимости типов данных, будет необходима их эквивалентность.
  • По умолчанию такая проверка отключена, поэтому во всем дальнейшем изложении (если, конечно, явно не оговорено противное) будем считать, что эта директива находится в выключенном состоянии {$R-}.
  • Неявное приведение типов данных

  • © С.В.Кухта, 2009
  • <number>
  • Тип значения можно изменить и явным способом: просто указав новый тип выражения, например:
  • a:= byte(b).
  • В этом случае переменной а будет присвоено значение, полученное новой интерпретацией значения переменной b.
  • Т.е., если b имеет тип shortint и значение -23, то в a запишется 233 (= 256 - 23).
  • Явное приведение типов данных

  • © С.В.Кухта, 2009
  • <number>
  • Приводить явным образом можно и типы, различающиеся по длине. Тогда значение может измениться в соответствии с новым типом.
  • Т.е., если преобразовать тип longint в тип integer, то возможны потери из-за отсечения первых двух байтов исходного числа.
  • Например, результатом попытки преобразовать число 100 000 к типу integer станет число 31 072, а к типу word - число 34 464.
  • Явное приведение типов данных

  • © С.В.Кухта, 2009
  • <number>
  • В заключение приведем список стандартных функций, аргумент и результат которых принадлежат к совершенно различным типам данных:
      • trunc: real  integer;
      • round: real  integer;
      • val: string  byte / integer / real;
      • chr: byte  char;
      • ord: <порядковый_тип>  longint;
  • Функции, изменяющие тип данных

  • © С.В.Кухта, 2009
  • <number>
  • Пример. Присвоить целой переменной d первую цифру из дробной части положительного вещественного числа x. Например, если x=32,597, то d=5.
  • Функции, изменяющие тип данных
  • d:= trunc(x*10) mod 10;
  • Решение. 1-й способ. Решение этой задачи можно получить, если умножить заданное число на 10. В этом случае задача сведется к выделению последней цифры полученного произведения.
  • Нужно еще учесть, что операция mod применима к целому числу, поэтому произведение нужно преобразовать к целому виду, например, отбросив дробную часть.
  • Получаем оператор, решающий задачу:

  • © С.В.Кухта, 2009
  • <number>
  • Функции, изменяющие тип данных
    • var x: real; { заданное число }
      • d, cod: integer; { первая цифра дробной части
      • заданного числа }
    • s: string; { число, представленное
    • в виде строки символов }
    • begin
      • str(x, s); { преобразовали число в строку
      • 32.597  '32.597' }
    • Val(copy(s, pos('.', s) + 1, 1), d, cod)
    • { выделили нужную цифру }
    • end.
  • 2-й способ. Возможно решение с помощью преобразования числа в строку символов (будет рассмотрено в Теме 5). В этом случае в строке нужно найти позицию точки и выделить следующую за ней цифру.
  • Получаем такой фрагмент:

  • © С.В.Кухта, 2009
  • <number>
  • 6. Простейшие операторы

  • © С.В.Кухта, 2009
  • <number>
  • Оператор языка Паскаль – это неделимый элемент программы, который позволяет выполнять определенные алгоритмические действия.
  • Если говорить строго, то оператором называется (минимальная) структурно законченная единица программы.
  • Все операторы должны заканчиваться знаком ";" (точка с запятой), и ни один оператор не может разрываться этим знаком.
  • Единственная возможность не ставить после оператора ";" появляется в том случае, когда сразу за этим оператором следует ключевое слово end.
  • !

  • © С.В.Кухта, 2009
  • <number>
  • Простейшие операторы языка
  • a:= b; - присваивание переменной а значения переменной b. В правой части присваивания может находиться переменная, константа, арифметическое выражение или вызов функции.
  • ; - пустой оператор, который можно вставлять куда угодно, а также вычеркивать откуда угодно, поскольку на целостность программы это никак не влияет.
  • Операторные скобки, превращающие несколько операторов в один:
        • begin
          • <несколько операторов>
        • end;

  • © С.В.Кухта, 2009
  • <number>
  • Простейшие операторы языка
  • Оператор безусловного перехода (GoTo).
  • Операторы вызова подпрограммы (например, Abs, Write, ReadLn).

  • © С.В.Кухта, 2009
  • <number>
  • Составные операторы языка
  • Составной оператор – это последовательность операторов, заключенных в операторные скобки Begin и End.
  • Условные операторы (If, Case).
  • Операторы цикла (Repeat, While, For).
  • Оператор присоединения (With).

  • © С.В.Кухта, 2009
  • <number>
  • Как изменить значение переменной?
  • Оператор присваивания служит для изменения значения переменной.
  • program qq;
  • var a, b: integer;
  • begin
  • a := 5;
  • b := a + 2;
  • a := (a + 2)*(b – 3);
  • end.
  • a
  • ?
  • 5
  • 5
  • b
  • ?
  • 5+2
  • 7
  • a
  • 5
  • 7*4
  • 28
  • Пример:

  • © С.В.Кухта, 2009
  • <number>
  • Оператор присваивания
  • Арифметическое выражение может включать
    • константы
    • имена переменных
    • знаки арифметических операций:
    • + - * / div mod
    • вызовы функций
    • круглые скобки ( )
  • умножение
  • деление
  • деление нацело
  • остаток от деления
  • <имя переменной> := <выражение>;

  • © С.В.Кухта, 2009
  • <number>
  • Имя слева от символа присваивания := является именем переменной, которой присваивается значение выражения, стоящего справа.
  • С помощью этого оператора осуществляется преобразование информации.
  • Он предназначен для вычисления нового значения некоторой переменной, а также для определения значения, возвращаемого функцией.
  • Оператор присваивания
  • Тип выражения в правой части оператора присваивания должен совпадать или быть совместимым с типом переменной из левой части. Компилятор на этапе синтаксического анализа программы осуществляет эту проверку - так называемый контроль типов.
  • !

  • © С.В.Кухта, 2009
  • <number>
  • Примеры операторов присваивания
  • Root1 := Pi*(x - y);
  • Discriminant := Sqrt(b*b-4*a*c)/2/A;
  • Index := Index + 1;
  • Letter := Succ(Succ(Letter));
  • F:= sin(-x*x-1/(1+x));
  • R:=(r1 + r2)/(r1*r2);
  • D:=((a = b) AND (c = d)) OR (a > d);

  • © С.В.Кухта, 2009
  • <number>
  • program qq;
  • var a, b: integer;
  • x, y: real;
  • begin
  • a := 5;
  • 10 := x;
  • y := 7,8;
  • b := 2.5;
  • x := 2*(a + y);
  • a := b + x;
  • end.
  • Какие операторы неправильные?
  • имя переменной должно быть слева от знака :=
  • целая и дробная часть отделяются точкой
  • нельзя записывать вещественное значение в целую переменную

  • © С.В.Кухта, 2009
  • <number>
  • Ручная прокрутка программы
  • program qq;
  • var a, b: integer;
  • begin
  • a := 5;
  • b := a + 2;
  • a := (a + 2)*(b – 3);
  • b := a div 5;
  • a := a mod b;
  • a := a + 1;
  • b := (a + 14) mod 7;
  • end.
  • a
  • b
  • ?
  • ?
  • 5
  • 7
  • 28
  • 5
  • 3
  • 4
  • 4

  • © С.В.Кухта, 2009
  • <number>
  • Порядок выполнения операций
    • вычисление выражений в скобках
    • умножение, деление, div, mod слева направо
    • сложение и вычитание слева направо
    • z := (5*a*c+3*(c-d))/a*(b-c)/ b;
    • x:=(a*a+5*c*c-d*(a+b))/((c+d)*(d-2*a));
    • 2 3 5 4 1 7 8 6 9
    • 2 6 3 4 7 5 1 12 8 11 10 9

  • © С.В.Кухта, 2009
  • <number>
  • 7. Ввод и вывод данных

  • © С.В.Кухта, 2009
  • <number>
  • Как мы уже говорили, любой алгоритм должен быть результативным. В общем случае это означает, что он должен сообщать результат своей работы потребителю: пользователю-человеку или другой программе (например, программе управления принтером).
  • Мы не будем описывать здесь внутренние автоматические процессы, использующие сигналы непрерывно функционирующих программ, а сосредоточим внимание на взаимодействии программы и человека, т.е. на процессах ввода информации с клавиатуры и вывода ее на экран.
  • В программировании существует специальное понятие консоль, которое обозначает клавиатуру при вводе и монитор при выводе.
  • Ввод и вывод: консоль

  • © С.В.Кухта, 2009
  • <number>
  • Для того чтобы получить данные, вводимые пользователем вручную (т.е. с консоли), применяются команды
  • Ввод с консоли
  • read ( <список_ввода> )
  • readln ( <список_ввода> )
  • Первая из этих команд считывает все предложенные ей данные, оставляя курсор в конце последней строки ввода, а вторая - сразу после окончания ввода переводит курсор на начало следующей строки. В остальном же их действия полностью совпадают.

  • © С.В.Кухта, 2009
  • <number>
  • Например, при помощи команды
  • Ввод с консоли
  • Список ввода - это последовательность имен переменных, разделенных запятыми.
  • программа может получить с клавиатуры данные сразу для четырех переменных, относящихся к различным типам данных.
  • readln(k, x, c, s);
  • {k:byte; x:real; c:char; s:string}

  • © С.В.Кухта, 2009
  • <number>
  • Вводимые значения необходимо разделять пробелами, а завершать ввод - нажатием клавиши Enter.
  • Ввод данных заканчивается в тот момент, когда последняя переменная из списка ввода получила свое значение.
  • Следовательно, вводя данные при помощи приведенной на слайде выше команды, вы можете нажать Enter четыре раза - после каждой из вводимых переменных, - либо же только один раз, предварительно введя все четыре переменные в одну строчку (обязательно нужно разделить их пробелами).
  • Ввод с консоли

  • © С.В.Кухта, 2009
  • <number>
  • При вводе исходных данных происходит преобразование из внешней формы представления во внутреннюю, определяемую типом переменных.
  • Типы вводимых значений должны совпадать с типами указанных переменных, иначе возникает ошибка. Поэтому нужно внимательно следить за правильностью вводимых данных.
  • Вообще, вводить с клавиатуры можно только данные базовых типов: целого, вещественного, символьного (за исключением логического).
  • Ввод с консоли

  • © С.В.Кухта, 2009
  • <number>
  • Если же программе все-таки необходимо получить с консоли значение для boolean-величины, придется действовать более хитро:
    • вводить оговоренный символ, а уже на его основе присваивать логической переменной соответствующее значение.
  • Например:
  • Ввод с консоли
  • repeat
  • writeln('Согласны ли Вы с этим утверждением?');
  • writeln('y - да, n - нет');
  • readln(c); {c:char}
  • case c of
  • 'y': b:= true;
  • 'n': b:= false;
  • else: writeln('Ошибка!');
  • end;
  • until (c='n') or (c='y');

  • © С.В.Кухта, 2009
  • <number>
  • Второе исключение: строки, хотя они и не являются базовым типом, вводить тоже разрешается.
  • Признаком окончания ввода строки является нажатие клавиши Enter, поэтому все следующие за нею переменные необходимо вводить с новой строчки.
  • Ввод с консоли

  • © С.В.Кухта, 2009
  • <number>
  • Сделаем одно важное замечание: ожидая от человека ввода с клавиатуры, не нужно полагать, что он окажется ясновидящим и просто по мерцанию курсора на черном экране догадается, какого типа переменная нужна ожидающей программе.
  • Вывод на консоль
  • Старайтесь всегда придерживаться правила: "лысый" ввод недопустим! Перед тем как считывать что-либо с консоли, необходимо сообщить пользователю, что именно он должен ввести: смысл вводимой информации, тип данных, максимальное и минимальное допустимые значения и т.п.
  • !

  • © С.В.Кухта, 2009
  • <number>
  • Примером неплохого приглашения служит, скажем, такая строчка:
  • Введите два вещественных числа (0.1<x,y<1000000) - длины катетов.
  • Впрочем, и ее можно улучшить, сообщив пользователю не только допустимый диапазон ввода, но и ожидаемую точность (количество знаков после запятой).
  • Вывод на консоль

  • © С.В.Кухта, 2009
  • <number>
  • Для того чтобы вывести на экран какое-либо сообщение, воспользуйтесь процедурами
  • write( <список_вывода> )
  • Первая из них, напечатав на экране все, о чем ее просили, оставит курсор в конце выведенной строки, а вторая переведет его в начало следующей строчки.
  • Вывод на консоль
  • writeln( <список_вывода> )

  • © С.В.Кухта, 2009
  • <number>
  • Список вывода может состоять из нескольких переменных или констант, записанных через запятую; все эти переменные должны иметь тип либо базовый, либо строчный.
  • Например:
  • writeln(a, b, c);
  • Вывод на консоль
  • Переменные, составляющие список вывода, могут относиться к целому, вещественному, символьному или булевскому типам.
  • В качестве элемента списка вывода кроме имен переменных могут использоваться выражения и строки.
  • Оператор Writеln без параметров реализует пропуск строки и переход к началу следующей строки.

  • © С.В.Кухта, 2009
  • <number>
  • Если для вывода информации воспользоваться командой, приведенной в конце предыдущего слайда, то выводимые символы окажутся "слепленными".
  • Чтобы этого не случилось, нужно либо позаботиться о пробелах между выводимыми переменными:
  • Форматированный вывод
  • writeln(a, ' ', b, ' ', c);
  • Но предпочтительнее задать для всех (или хотя бы для некоторых) переменных формат вывода:
  • writeln(a:5, b, c:20:5);
  • количество позиций, выделяемых под дробную часть числа
  • количество позиций, выделяемых под всю переменную

  • © С.В.Кухта, 2009
  • <number>
  • Если число длиннее, чем отведенное под него пространство, количество позиций будет автоматически увеличено.
  • Если же выводимое число короче заданного формата, то спереди к нему припишутся несколько пробелов.
  • Таким образом можно производить вывод красивыми ровными столбиками, а также следить за тем, чтобы переменные не сливались.
  • Форматированный вывод

  • © С.В.Кухта, 2009
  • <number>
  • Например, если a = 25, b = 'x', а c = 10.5, то после выполнения команды
  • _ _ _25_x_ _10.50000
  • Форматированный вывод
  • writeln(a:5, ' ', b, c:20:5);
  • на экране или в файле будет записано следующее:
  • Особенно важен формат при выводе вещественных переменных.
  • К примеру, если не указать формат, то число 10.5 будет выведено как
  • 1.0500000000Е+0001.
  • Такой формат называется записью с плавающей точкой.

  • © С.В.Кухта, 2009
  • <number>
  • Если же задать только общую длину вещественного числа, не указывая длину дробной части, то оно будет занимать на экране заданное количество символов (в случае надобности, спереди будет добавлено соответствующее количество пробелов), но при этом останется в формате плавающей точки.
  • Минимальной длиной для вывода вещественных чисел является 10 (при формате _x.xE+yyyy). Первая позиция зарезервирована под знак "-".
  • Форматированный вывод

  • © С.В.Кухта, 2009
  • <number>
  • Примеры форматированного вывода
  • Вывод десятичного представления величины J, начиная с позиции расположения курсора.
  • Для целочисленного выражения
  • Оператор вывода
  • Значение переменной
  • Результат
  • Write(J);
  • 236
  • 236
  • Write(J, J+1, J+2);
  • 236
  • 236237238
  • Вывод десятичного представления величины J в крайние правые позиции поля заданной шириной.
  • Оператор вывода
  • Значение переменной
  • Результат
  • Write(J:6);
  • 236
  • ___236
  • Write(J:10);
  • 1
  • _________1
  • Write(J+J:7);
  • 236
  • ____472

  • © С.В.Кухта, 2009
  • <number>
  • Примеры форматированного вывода
  • Вывод в поле шириной 18 символов (по умолчанию) десятичного представления величины R в формате с плавающей точкой.
  • Для вещественного выражения
  • Оператор вывода
  • Значение переменной
  • Результат
  • Write (R);
  • 715.432
  • __7.1543200000E+02
  • Write (R);
  • -1.919E+01
  • _-1.9190000000E+01
  • Write (R/2);
  • 567.986
  • __2.8399300000E+02

  • © С.В.Кухта, 2009
  • <number>
  • Примеры форматированного вывода
  • Вывод десятичного представления величины R в формате с плавающей точкой в крайние правые позиции поля заданной шириной.
  • Для вещественного выражения
  • Оператор вывода
  • Значение переменной
  • Результат
  • Write(R:15);
  • 511.04
  • 5.110400000E+02
  • Write(R:15);
  • -511.04
  • -5.11040000E+02
  • Write(-R:12);
  • 46.78
  • -4.67800E+01

  • © С.В.Кухта, 2009
  • <number>
  • Примеры форматированного вывода
  • Вывод десятичного представления величины R в формате с фиксированной точкой в крайние правые позиции поля заданной шириной.
  • Причем, после десятичной точки выводится заданное количество цифр (не более 24-х), представляющих дробную часть числа; если их количество равно 0, ни дробная часть, ни десятичная точка не выводятся.
  • Для вещественного выражения
  • Оператор вывода
  • Значение переменной
  • Результат
  • Write(R:8:4);
  • 511.04
  • 511.0400
  • Write(R:7:2);
  • -46.78
  • _-46.78
  • Write(R:9:4);
  • -46.78
  • _-46.7800

  • © С.В.Кухта, 2009
  • <number>
  • Примеры форматированного вывода
  • Вывод символа Ch, начиная с позиции расположения курсора.
  • Для выражения символьного типа
  • Вывод символа Ch в крайнюю правую позицию поля заданной ширины.
  • Оператор вывода
  • Значение переменной
  • Результат
  • Write(Ch);
  • ‘X‘
  • X
  • Write(Ch, Ch, Ch);
  • ‘!‘
  • !!!
  • Оператор вывода
  • Значение переменной
  • Результат
  • Write(Ch:5);
  • ‘X‘
  • ____X
  • Write(Ch:2, Ch:4);
  • ‘!‘
  • _!___!

  • © С.В.Кухта, 2009
  • <number>
  • Примеры форматированного вывода
  • Вывод строки S, начиная с позиции расположения курсора.
  • Для выражения строкового типа
  • Вывод символа S в крайние правые позиции поля заданной ширины.
  • Оператор вывода
  • Значение переменной
  • Результат
  • Write(S);
  • ‘Иванов‘
  • Иванов
  • Write(S);
  • ‘Ведомость № 2‘
  • Ведомость № 2
  • Write(S, S);
  • ‘ZZXXX‘
  • ZZXXXZZXXX
  • Оператор вывода
  • Значение переменной
  • Результат
  • Write(S:10);
  • ‘Иванов‘
  • ____Иванов
  • Write(S:14);
  • ‘Ведомость № 2‘
  • _Ведомость № 2
  • Write(S:6, S:6);
  • ‘ZZXXX‘
  • _ZZXXX_ZZXXX

  • © С.В.Кухта, 2009
  • <number>
  • Примеры форматированного вывода
  • Вывод результата выражения B (True или False), начиная с позиции расположения курсора.
  • Для выражения логического типа
  • Вывод результата выражения B (True или False) в крайние правые позицию поля заданной ширины.
  • Оператор вывода
  • Значение переменной
  • Результат
  • Write(B);
  • True
  • True
  • Write(B);
  • False
  • False
  • Write(B, not B);
  • True
  • TrueFalse
  • Оператор вывода
  • Значение переменной
  • Результат
  • Write(B:6);
  • True
  • __True
  • Write(B:10);
  • False
  • _____False
  • Write(B:5, not B:8);
  • True
  • _True___False

  • © С.В.Кухта, 2009
  • <number>
  • Например (подчеркивание служит для визуализации пробела):
  • Форматированный вывод
  • В случае недостаточной длины вывода число будет автоматически округлено.
  • !
  • Оператор форматного вывода
  • Результат вывода на экран
  • write (125.2367:10);
  • _1.3E+0002
  • write (125.2367:11);
  • _1.25E+0002
  • write (125.2367:12);
  • _1.252E+0002
  • write (125.2367:13);
  • _1.2524E+0002
  • write (125.2367:14);
  • _1.25237E+0002
  • write (125.2367:15);
  • _1.252367E+0002
  • write (125.2367:16);
  • _1.2523670E+0002

  • © С.В.Кухта, 2009
  • <number>
  • Пример 1. Сложение двух чисел
  • Задача. Ввести два целых числа и вывести на экран их сумму.
  • Простейшее решение:
  • program qq;
  • var a, b, c: integer;
  • begin
  • read ( a, b );
  • c := a + b;
  • writeln ( c );
  • end.

  • © С.В.Кухта, 2009
  • <number>
  • Блок-схема линейного алгоритма
  • начало
  • конец
  • c := a + b;
  • ввод a, b
  • вывод c
  • блок «начало»
  • блок «ввод»
  • блок «процесс»
  • блок «вывод»
  • блок «конец»

  • © С.В.Кухта, 2009
  • <number>
  • Оператор ввода
  • read ( a ); { ввод значения переменной a}
  • read ( a, b ); { ввод значений переменных a и b}
  • Как вводить два числа?
  • через пробел:
  • 25 30
  • через Enter:
  • 25
  • 30
  • a
  • 25
  • b
  • 30
  • a
  • 25
  • b
  • 30

  • © С.В.Кухта, 2009
  • <number>
  • Оператор вывода
  • write ( a ); { вывод значения переменной a}
  • writeln ( a ); { вывод значения переменной a и переход на новую строчку}
  • writeln ( 'Привет!' ); { вывод текста}
  • writeln ( 'Ответ: ', c ); { вывод текста и значения переменной c}
  • writeln ( a, '+', b, '=', c );

  • © С.В.Кухта, 2009
  • <number>
  • Форматы вывода
  • program qq;
  • var i: integer;
  • x: real;
  • begin
  • i := 15;
  • writeln ( '>', i, '<' );
  • writeln ( '>', i:5, '<' );
  • x := 12.345678;
  • writeln ( '>', x, '<' );
  • writeln ( '>', x:10, '<' );
  • writeln ( '>', x:7:2, '<' );
  • end.
  • >15<
  • > 15<
  • >1.234568E+001<
  • > 1.23E+001<
  • > 12.35<
  • всего символов
  • всего символов
  • в дробной части

  • © С.В.Кухта, 2009
  • <number>
  • Полное решение
  • program qq;
  • var a, b, c: integer;
  • begin
  • writeln('Введите два целых числа');
  • read ( a, b );
  • c := a + b;
  • writeln ( a, '+', b, '=', c );
  • end.
  • Протокол:
  • Введите два целых числа
  • 25 30
  • 25+30=55
  • компьютер
  • пользователь

  • © С.В.Кухта, 2009
  • <number>
  • Пример 2.
  • Задача. Программа вычисления площади круга, вписанного в треугольник и площади круга, описанного около треугольника.
  • Program Triangle;
  • Const Pi = 3.1415926;
  • Line =’___________’;
  • Var a, b, c : Real;
  • Sint, Sout : Real;
  • S, p : Real;
  • Begin
  • { ввод данных }
  • Write (’введите стороны
      • треугольника a b c ’);
  • Readln (a, b, c);
  • { вычисления }
  • p:=(a+b+c)/2;
  • S:=Sqrt(p*p–a)*(p–b)*(p–c));
  • Sout:=Pi*sqrt(a*b*c/4/S);
  • Sint:=Pi*sqrt(2*S/p);
  • { печать ответа }
  • Writeln;
  • Writeln (Line);
  • Writeln(’Sвпис = ’, Sout);
  • Writeln(Line);
  • Writeln(’Sопис = ’, Sint);
  • Writeln(Line)
  • End.

  • © С.В.Кухта, 2009
  • <number>
  • Пример 3.
  • Задача. Программа возведения положительного числа “x” в степень”n”, т.е. y=xn. Расчет производится по формуле: y=en*ln(x).
  • Program N_2;
  • {возведение положительного числа в степень}
  • Var n, x, y: real;
  • BEGIN
    • Writeln ('Введите значение аргумента х>0');
    • Readln (x);
    • Writeln ('Введите значение показателя степени n=');
    • Readln (n);
    • y:= exp( n * ln(x));
    • Writeln (' Результат y=', y:10:6);
    • Writeln (' Нажмите Enter');
    • readln; {задержка экрана до нажатия Enter}
  • END.

  • © С.В.Кухта, 2009
  • <number>
  • 8. Метки и безусловный переход

  • © С.В.Кухта, 2009
  • <number>
  • Метки
  • Метка помечает какое-либо место в тексте программы. Метками могут быть числа от 0 до 9999 или идентификаторы, которые в этом случае уже нельзя использовать для каких-либо иных нужд.
  • Все метки должны быть описаны в специальном разделе label:
  • label <список_всех_меток_через_запятую>;
  • Меткой может быть помечен любой оператор программы:
  • <метка>: <оператор>;
  • Любая метка может встретиться в тексте программы только один раз.

  • © С.В.Кухта, 2009
  • <number>
  • Оператор безусловного перехода
  • Используются метки только операторами безусловного перехода goto:
  • Это означает, что сразу после оператора goto будет выполнен не следующий за ним оператор (как это происходит в обычном случае), а тот оператор, который помечен соответствующей меткой.
  • В принципе, передавать управление можно вперед и назад по тексту программы, внутрь составных операторов и наружу и т.п.
  • Исключением являются только процедуры и функции (см. соответствующую Тему):
    • внутрь них и наружу безусловные переходы невозможны.
  • goto <метка>;

  • © С.В.Кухта, 2009
  • <number>
  • Оператор безусловного перехода
  • Оператор Goto следует применять как можно реже, так как его частое употребление резко усложняет понимание логики программы. В крайнем случае он может использоваться для преждевременного выхода из операторов повтора.
  • Вообще же использование безусловных переходов в структурном и надежном программировании считается "дурным тоном". Поэтому настоятельно советуем:
  • Воздерживаться от употребления операторов goto.
  • Язык Паскаль обладает достаточным количеством структурных конструкций и возможностей, позволяющих достичь хороших результатов надежными средствами.
  • !

  • © С.В.Кухта, 2009
  • <number>
  • Пример
  • . . .
  • Label Metka1, Metka2;
  • . . .
  • Goto Metka1;
  • . . .
  • Metka1: Writeln (Summa);
  • Goto Metka2;
  • . . .
  • Metka2:
  • End.