8-900-374-94-44
При описании переменной необходимо указать ее тип. Тип переменной описывает набор значений, которые она может принимать, и действия, которые могут быть над ней выполнены. Описание типа определяет идентификатор, который обозначает тип.
Простые типы делятся на стандартные (порядковые) и перечисляемые (ограниченные).
Турбо-Паскаль имеет четыре встроенных стандартных типа: integer (целое), real (вещественное), boolean (логический) и char (символьный).
В Турбо-Паскале имеется пять встроенных целочисленных типов: shortint (короткое целое), integer (целое), longint (длинное целое), byte (длиной в байт) и word (длиной в слово). Каждый тип обозначает определенное подмножество целых чисел, как это показано в следующей Таблице.
Встроенные целочисленные типы.
|
Тип |
Диапазон |
Формат |
|
shortint |
-128 ..+127 |
8 битов со знаком |
|
integer |
-32768 .. 32767 |
16 битов со знаком |
|
longint |
-2147483648 +2147483647 |
32 бита со знаком |
|
byte |
0 .. 255 |
8 битов без знака |
|
word |
0 .. 65535 |
16 битов без знака |
Арифметические действия над операндами целочисленного типа осуществляются в соответствии со следующими правилами:
Операции совершаемые над целыми числами:
“+” — сложение
“-“ — вычитание
“*” — умножение
SQR — возведение в квадрат
DIV — после деления отбрасывает дробную часть
MOD — получение целого остатка после деления
ABS — модуль числа
RANDOM(X)-получение случайного числа от 0 до Х
Пример:
а:=100; b:=60; a DIV b результат - 1 а MOD b результат - 40
Описываются переменные целого типа следующим образом:
var список переменных: тип;
Например: var а,р,n:integer;
К вещественному типу относится подмножество вещественных чисел, которые могут быть представлены в формате с плавающей запятой с фиксированным числом цифр. Запись значения в формате с плавающей запятой обычно включает три значения — m, b и e — таким образом, что m*b е, где b всегда равен 10, а m и e являются целочисленными значениями в диапазоне вещественного типа. Эти значения m и e далее определяют диапазон и точность вещественного типа.
Имеется пять видов вещественных типов: real, singlе, duble, exnende, comp. Вещественные типы различаются диапазоном и точностью связанных с ними значений
Диапазон и десятичные цифры для вещественных типов
|
Тип |
Диапазон |
Цифры |
|
Single Duble Extende comp |
2.9×10Е-39 до 1.7×10Е 38 1.5×10Е-45 до 3.4×10Е 38 5.0×10Е-324 до 1.7×10Е 308 3.4×10Е-493 до 1.1×10Е 403 -2Е 63 до 2Е 63 |
от 11 до 12 от 7 до 8 от 15 до 16 от 19 до 20 от 19 до 20 |
Операции совершаемые над вещественными числами:
Описываются переменные вещественного типа следующим образом:
var список переменных: тип;
Например:
var d,g,k:real;
K типу char относится любой символ заключенный в апострофы. Для представления апострофа как символьную переменную, надо заключить его в апостроф:’’’’.
Каждый символ имеет свой код и номер. Порядковые номера цифр 0,1..9 упорядочены по возрастанию. Порядковые номера букв также упорядочены по возрастанию, но не обязательно следуют друг за другом.
К символьным данным применимы знаки сравнения:
> , < , >=, <=, <> .
Например: ‘A’ < ‘W’
Функции, которые применимы к символьным переменным:
Пример:
ord(‘a’)=97;
Пример:
chr(97)=’a’;
Пример:
pred(‘B’)=’A’;
Пример:
succ(‘A’)=’B’;
Перечислимый тип данных назван так потому, что задается в виде перечисления констант в строго определенном порядке и в строго определенном количестве. Перечислимый тип состоит из списка констант. Переменные этого типа могут принимать значение любой из этих констант. Описание перечислимого типа имеет вид:
Type <имя типа>=(список констант); Var <имя переменной>:<имя типа>;
где <список констант> — это особый вид констант, задаваемых через запятую и имеющих свой порядковый номер, начиная с 0.
Например:
type направление=(север, юг, запад, восток); месяц=(июнь,июль,август,январь); емкость=(ведро,бочка,канистра,бак); var поворот:направление; отъезд:месяц; объем:емкость;
или так:
var поворот:(свер, юг, запад, восток); отъезд:(июнь, июль, август, январь); объем:(ведро, бочка, канистра, бак);
Можно выполнить такие операторы присваивания:
поворот:=юг; отъезд:=август; объем:=бак;
но нельзя выполнять смешанные присваивания:
отъезд:=юг; объем:=август;
К переменным перечислимого типа применимы следующие функции:
1. ORD — порядковый номер
2. PRED — предшествующий элемент
3. SUCC — последующий элемент.
Пример:
PRED(бочка)=ведро; SUCC(юг)=запад; ORD(июль)=1;
Переменные перечислимого типа можно сравнить, так как они упорядочены и пронумерованы. Так выражения: север < юг, июнь < январь имеют значения TRUE, а юг>запад и бак<бочка значение FАLSE.
Если переменная принимает не все значения своего типа, а только в некотором диапазоне, то ее можно рассматривать как переменную ограниченного типа. Каждый ограниченный тип задается путем накладывания ограничения на базовые типы.
Описывается так:
TYPE <имя типа>=константа1..константа2
При этом должны выполняться следующие правила:
Пример:
type index=0..63; letter=’a’..’z’; var char1,char2:letter; a,g:index;
Можно описывать сразу в разделе описания переменных:
var a,g:0..63; char1,char2:’a’..’z’.
В языке Паскаль определено пять целых типов.
Таблица. Целые типы 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, запоминает, что эти переменные могут принимать только целые значения и формирует соответственно этому команды программы.
Таблица. Операции над целыми типами, дающие в результате значение целого типа
| Знак операции | Операция |
|---|---|
| + | Сложение |
| — | Вычитание |
| * | Умножение |
| 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 – вещественного, т.к. один из сомножителей вещественный.
В языке программирования Pascal существует понятие множества, имеющее смысл некоторого собрания элементов, одно и того же базового типа. Базовый тип определяет перечень всех элементов, которые вообще могут содержаться в данном множестве. В качестве базового типа может выступать любой простой порядковый тип. Но вещественные числа (real не порядковый тип) и строки (не простой и не порядковый тип) не могут быть элементами множества.
Размер множества в Turbo Pascal всегда ограничен некоторым предельно допустимым количеством элементов. Во множествах допускаются только такие элементы, порядковые значения которых не выходят за границы 0..255. Для целочисленных множеств это означает, что в них могут присутствовать только числа от 0 до 255. Отрицательные элементы множеств в Turbo Pascal не допускаются. Поэтому базовыми типами не могут быть типы shortint, integer, longint. Если же необходимо множество целочисленных объектов, то базовый тип должен объявлен как диапазон типа byte. Для множеств, содержащих символы, подобных затруднений нет, поскольку базовым типом для них является char (а в нем 256 значений с порядковыми номерами от 0 до 255).
В математике для обозначения множества используют фигурные скобки (например, {4, 7, 12}), в Паскаль — квадратные (например, [1, 3, 5]). Порядок элементов во множестве не имеет значения. Так, записав [3, 6, 9] или [9, 3, 6], мы будем иметь дело с одним и тем же множеством. Более того, многократное повторение одного и того же элемента не меняет множество. Например, [4, 7, 3] и [3, 7, 4, 4] – это одно и то же множество.
По форме записи объявление переменной типа множество сходно с объявлением одномерного массива:
var имя: set of тип;
Например, объявление переменной ch, рассматриваемой как множество с базовым типом char, имеет вид:
В отличие от элементов массива, элементы множества не упорядочены и не имеют индексов.
Можно сначала объявить тип множества, а потом использовать его для объявления переменных:
type t_ch = set of char; var ch2, ch3: t_ch;
Довольно часто в качестве базового типа множества используется тип перечисления или некоторый его диапазон:
type week_days = (Mon, Tue, Wed, Thu, Fri); var work_days: set of week_days; lett: set of 'A'..'Z';
Объявление переменной-множества не дает ей определенного значения.
Чтобы во множестве появились элементы, необходимо выполнить оператор присваивания, в левой части которого стоит имя переменной-множества, а в правой — конструктор множества или некоторое выражение над множествами.
Конструктор множества — это заключенный в квадратные скобки перечень элементов, разделенных запятыми. В качестве элементов могут использоваться диапазоны значений:
type week_days = (Mon, Tue, Wed, Thu, Fri); var work_days: set of week_days; lett: set of 'A'..'Z'; begin work_days := [Mon, Wed, Thu]; lett := ['C', 'E'..'M', 'Z'] end.
Следует помнить, что при задании множества порядок его элементов безразличен, но при задании диапазона такой порядок важен.
Множество, в котором нет элементов, называется пустым (или нуль-множеством). В языке программирования Паскаль обозначается квадратными скобками, между которыми нет элементов:
Множество может быть объявлено типизированной константой, для чего в описании после знака равенства следует указать конструктор множества. Например:
const lett: set of ['а'..'я'] = ['а', 'е', 'и', 'о', 'у', 'ы', 'э', 'ю', 'я'];
В данном случае оператор описывает множество, элементами которого могут быть буквы русского алфавита, с записью в него начального значения, которое представляет собой множество гласных букв.
Конструируя множества, можно использовать и переменные при условии, что их текущие значения попадают в диапазон базового типа множества. Так, если ch2 и ch3 имеют тип char, то допустима следующая последовательность операторов:
ch2 := 'A'; ch3 := 'K'; chs := [ch2, ch3, 'M'];
В результате получится множество [‘A’, ‘K’, ‘M’].
Элементы множества нельзя вводить и выводить. Для организации ввода-вывода элементов множества следует использовать вспомогательные переменные. В то же время можно использовать множества как элементы типизированных файлов.
Над множествами выполнимы объединение (+), пересечение (*) и разность (-).
Объединение двух множеств A и B (A + B) – это новое множество, состоящее из элементов, принадлежащих множеству A или B, либо тому и другому одновременно.
var chs1, chs2, chs3: set of char; begin chs1 := ['a', 'b', 'd']; chs2 := ['m', 'd', 'e']; chs3 := chs1 + chs2 + ['k', 'n']; end.
Результат: chs3 = ['a', 'b', 'd', 'm', 'e', 'k', 'n'].
Пересечение двух множеств A и B (A * B) – это множество, состоящее из элементов, одновременно принадлежащих множествам A и B.
Результат: chs3 = [‘d’].
Разность двух множеств A и B (A – B) – это новое множество, состоящее из элементов множества A, не вошедших в множество B.
chs1 := ['a', 'e', 't'];
chs2 := chs1 – ['e'] { ['a', 't'] }
chs3 := ['m', 'n', 't'] – chs2 { ['m', 'n'] }Манипулируя операциями над множествами, можно добавлять элементы к множествам или удалять их.
Для вставки и удаления элементов при работе с множествами в Pascal введены две процедуры:
include (имя_множества, элемент) exclude (имя_множества, элемент)
Первая из них позволяет выполнить добавление одного элемента в указанное множество, а вторая удалить. Например:
include (chs1, 'g'); { аналогично chs1 + ['g'] }
exclude (chs2, 'a'); { аналогично chs2 - ['a'] }Над множествами можно выполнять четыре операции сравнения: =, <>, >=, <=.
Два множества A и B равны (A = B), если каждый элемент множества A является элементом множества B и наоборот.
Два множества A и B не равны (A <> B), если они отличаются хотя бы одним элементом.
Множество A является подмножеством множества B (A <= B, или B >= A), если каждый элемент из A присутствует в B.
Имеется также возможность выяснить, принадлежит ли данный элемент некоторому множеству. Для этого служит операция in. Пусть A – множество элементов некоторого базового типа, а x – переменная (константа, выражение) этого типа. Тогда выражение x in A истинно, если значение x является элементом множества A.
Все операции сравнения множеств, а также операция in возвращают логическое значение true или 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.
Pascal – язык со строгой типизацией переменных. Это значит, что мы обязательно должны указывать тип каждой переменной, и не можем присвоить переменной одного типа значение другого типа (если только они не эквивалентны).
В качестве примера возьмем часть программы, которая вычисляет площадь круга по заданному радиусу:
S := r*r*3.14;
Если мы укажем, что у переменной S целочисленный тип, программа будет работать не верно, так как результатом выражения r*r*3.14 будет дробь, и присвоить целочисленной переменной дробное значение мы не можем.
Еще один пример. Программа складывает значение двух переменных:
a := 5;
b := 4;
c := a+b;
Если мы укажем, что a, b и c являются числами, то вполне логично предположить, что после выполнения программы значение c станет равно 9-ти. Но что будет, если a и b являются не числами, а простыми символами, а c – строкой?
a := ‘5’;
b := ‘4’;
c := a+b;
В этом случае мы не можем сложить математически два значения (ну правда, мы же не можем математически сложить две буквы), и символы просто подставятся друг к другу, то есть значение c будет равно ‘54’.
Кроме этого, после запуска программы для каждой переменной в оперативной памяти выделяется некоторое количество байт, которое зависит от типа этой переменной. И значения, которые может принять переменная, ограничены этим количеством байт. К примеру, переменной с типом данных byte выделяется 1 байт памяти, и она может принимать значения от 0 до 255, всего 256, что является количеством вариантов, которые можно закодировать одним байтом. Если же мы укажем для переменной тип byte, но присвоим ей значение, к примеру, 1000, программа работать не будет.
Переменная целочисленного типа может принимать любое целое значение из диапазона значений этого типа. Также является порядковым типом.
| Тип | Длина (байт) | Диапазон |
| byte | 1 | 0..255 |
| shortint | 1 | -128..127 |
| integer | 2 | -32768..32767 |
| word | 2 | 0..65536 |
| longint | 4 | -2147483648..2147483647 |
В заданиях ЕГЭ, как правило, достаточно использовать тип данных integer.
К вещественному типу относят дробные числа и числа с плавающей запятой. Тем не менее, мы можем присвоить вещественному типу целое значение.
| Тип | Длина (байт) | Диапазон |
| single | 4 | 1.5*10-45 — 3.4*1038 |
| real | 6 | 2.9*10-39 — 1.7*1038 |
| double | 8 | 5*10-324 — 1.7*10308 |
| extended | 10 | 3.4*10-4932 — 1.1*104932 |
В заданиях ЕГЭ, как правило, достаточно использовать тип данных real.
Любой одиночный символ.
| Тип | Длина (байт) | Диапазон |
| char | 1 | Любой символ кодировки ASCII |
Переменной типа char можно присвоить любую букву, цифру, или любой другой символ стандартной кодировки. Также является порядковым типом.
Если char — это только один символ, то строка — это набор символов. Строкой может быть, к примеру, слово, состоящее из нескольких букв. Также строки относят к структурным типам.
| Тип | Длина (байт) | Диапазон |
| string | 256 | 255 символов кодировки ASCII |
Переменная логического типа может принимать только два значения: true или false (истина или ложь). Является порядковым типом.
| Тип | Длина (байт) | Диапазон |
| boolean | 1 | true, false |
Интервальный тип указывает, что переменная может принимать значения от одного значения, до другого. К примеру, мы знаем, что переменная может принимать значения только от 5 до 25. Мы можем объявить её тип так:
var
a: 5..25;
Любая программа, написанная на любом языке программирования, по большому счету предназначена для обработки данных. В качестве данных могут выступать числа, тексты, графика, звук и др. Одни данные являются исходными, другие – результатом, который получается путем обработки исходных данных программой.
Данные хранятся в памяти компьютера. Программа обращается к ним с помощью имен переменных, связанных с участками памяти, где хранятся данные.
Переменные описываются до основного кода программы. Здесь указываются имена переменных и тип хранимых в них данных.
В языке программирования Паскаль достаточно много типов данных. Кроме того, сам пользователь может определять свои типы.
Тип переменной определяет, какие данные можно хранить в связанной с ней ячейке памяти.
Переменные типа integer могут быть связаны только с целыми значениями обычно в диапазоне от -32768 до 32767. В Pascal есть другие целочисленные типы (byte, longint).
Переменные типа real хранят вещественные (дробные) числа.
Переменная булевского (логического) типа (boolean) может принимать только два значения — true (1, правда) или false (0, ложь).
Символьный тип (char) может принимать значения из определенной упорядоченной последовательности символов.
Интервальный тип определяется пользователем и формируется только из порядковых типов. Представляет собой подмножество значений в конкретном диапазоне.
Можно создать собственный тип данных простым перечислением значений, которые может принимать переменная данного типа. Это так называемый перечисляемый тип данных.
Все вышеописанное – это простые типы данных. Но бывают и сложные, структурированные, которые базируются на простых типах.
Массив – это структура, занимающая в памяти единую область и состоящая из фиксированного числа компонентов одного типа.
Строки представляет собой последовательность символов. Причем количество этих символов не может быть больше 255 включительно. Такое ограничение является характерной чертой Pascal.
Запись – это структура, состоящая из фиксированного числа компонент, называемых полями. В разных полях записи данные могут иметь разный тип.
Множества представляют собой совокупность любого числа элементов, но одного и того же перечисляемого типа.
Файлы для Pascal представляют собой последовательности однотипных данных, которые хранятся на устройствах внешней памяти (например, жестком диске).
Понятие такого типа данных как указатель связано с динамическим хранением данных в памяти компьютера. Часто использование динамических типов данных является более эффективным в программировании, чем статических.
Под множеством в Паскале понимается совокупность взаимосвязанных элементов одного типа. Его элементы должны быть порядкового типа данных и описываться перечислением и/или интервалом. Служебные слова Set Of говорят, что объявлен множественный тип:
Type <имя типа> = Set Of <базовый тип>;
Размер множества может меняться, но количество элементов в нем, как правило, не должно превышать 256. Поэтому если нужно определить множество, состоящее из чисел, то следует указывать значения входящие в тип byte (от 0 до 255).
В Паскале для обозначения элементов множества используют квадратные скобки, в которых последние, как уже было сказано ранее, записываются интервалом и/или перечислением, например:
[‘A’, ‘B’, ‘C’] [0, 1, 2, 5, 9] [1..9] [1, 2, 3, 10..20]Элементы множества в отличие от массивов не имеют индексов (номеров), и поэтому порядок не важен. Возьмем, к примеру, два множества: [2, 3, 5] и [3, 5, 2], не смотря на расположение элементов, они тождественны.
С помощью конструктора множеств можно присвоить множественной переменной, какие-либо значения:
I:=[1, 2, 3, 5, 8];
C:=[‘b’, ‘d’, ‘f’];
B: = [True, False];
В ЯП Pascal над множествами предусмотрены следующие операции.
Объединением множеств A и B является множество C, которое содержит общие или хотя бы одного из них элементы.
Пример:
[1, 2, 3, 4] + [3, 4, 5] = [1, 2, 3, 4, 5] [‘A’, ‘B’, ‘C’, ‘D’] + [‘B’, ‘E’, ‘G’] = [‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘G’]Пересечением множеств A и B является множество C, которое содержит элементы обоих множеств.
Пример:
[1, 2, 3, 4] * [3, 4, 5] = [3, 4] [‘A’, ‘B’, ‘C’, ‘D’] * [‘B’, ‘E’, ‘G’] = [‘B’]Разностью множеств A и B является множество C, которое содержит элементы множества A, не вошедшие в множество B.
Пример:
[1, 2, 3, 4] — [3, 4, 5] = [1, 2] [‘A’, ‘B’, ‘C’, ‘D’] — [‘B’, ‘E’, ‘G’] = [‘A’, ‘C’, ‘D’]Два множества считаются равными, если они состоят из одних и тех же элементов.
Пример:[1, 2, 3, 4] = [2, 1, 4, 3] => True
[‘A’, ‘B’, ‘C’, ‘D’] = [‘B’, ‘E’, ‘G’] => False
Два множества считаются неравными, если они состоят из разных элементов.
Пример:
[1, 2, 3, 4] [2, 1, 4, 3] => FalseВыражение возвращает истину, если второе множество является подмножеством первого множества.
Пример:
[1, 2, 3, 4] >= [2, 1] => TrueВыражение возвращает истину, если первое множество является подмножеством второго множества.
Пример:
[1, 2, 3, 4] >= [2, 1] => FalseПроверяет наличие определенного элемента в заданном множестве:
Пример:
1 In [1, 2, 3, 4] => True
B In [‘A’, ‘G’] => False
Для добавления множеству нового элемента в Паскаль есть операция Include:
Include(<множество>, <элемент>)
Для удаления из множества какого-либо элемента можно воспользоваться операцией Exclude:
Exclude(<множество>, <элемент>)
Необходимо помнить, что добавляемый/удаляемый элемент должен быть тождественного множеству типа.
Похожие записи:90000 90001. . 90002 90003 90004 90005 () 90006 90005 90006 90004 90010 90011 90012 90013 90014 90006 90010 90003 90005 90019 integer 90020 90006 90005 2 90006 90005 -32768..32767 90006 90005 +, -, /, *, Div, Mod, 90027> =, <=, =, <>, <,> 90006 90010 90011 90005 90019 byte 90020 90006 90005 1 90006 90005 0..255 90006 90005 +, -, /, *, Div, Mod, 90027> =, <=, =, <>, <,> 90006 90010 90011 90005 90019 word 90020 90006 90005 2 90006 90005 0..65535 90006 90005 +, -, /, *, Div, Mod, 90027> =, <=, =, <>, <,> 90006 90010 90011 90005 90019 shortint 90020 90006 90005 1 90006 90005 -128..127 90006 90005 +, -, /, *, Div, Mod, 90027> =, <=, =, <>, <,> 90006 90010 90011 90005 90019 longint 90020 90006 90005 4 90006 90005 -2147483648..2147483647 90006 90005 +, -, /, *, Div, Mod, 90027> =, <=, =, <>, <,> 90006 90010 90011 90012 90013 90014 90006 90010 90011 90005 90019 real 90020 90006 90005 6 90006 90005 2,9×10 90096 -39 90097 — 1,7×10 90096 38 90097 90006 90005 +, -, /, *, 90027> =, <=, =, <>, <,> 90006 90010 90011 90005 90019 single 90020 90006 90005 4 90006 90005 1,5×10 90096 -45 90097 — 3,4×10 90096 38 90097 90006 90005 +, -, /, *, 90027> =, <=, =, <>, <,> 90006 90010 90011 90005 90019 double 90020 90006 90005 8 90006 90005 5×10 90096 -324 90097 — 1,7×10 90096 308 90097 90006 90005 +, -, /, *, 90027> =, <=, =, <>, <,> 90006 90010 90011 90005 90019 extended 90020 90006 90005 10 90006 90005 3,4×10 90096 -4932 90097 — 1,1×10 90096 4932 90097 90006 90005 +, -, /, *, 90027> =, <=, =, <>, <,> 90006 90010 90011 90012 90013 90014 90006 90010 90011 90005 90019 boolean 90020 90006 90005 1 90006 90005 true, false 90006 90005 Not, And, Or, Xor, 90027> =, <=, =, <>, <,> 90006 90010 90011 90012 90013 90014 90006 90010 90011 90005 90019 char 90020 90006 90005 1 90006 90005 ASCII 90006 90005 +, 90027> =, <=, =, <>, <,> 90006 90010 90194.