В PascalABC.NET имеется упрощенный синтаксис описания однооператорных процедур:
procedure WriteStar:= write('*');
Аналогичный синтаксис имеется для функций, вычисляющих одно выражение:
function Add(a,b: real): real:= a + b;
При этом в ряде случаев для возвращаемого значения функции возможен автовывод типов:
function Add(a,b: real):= a + b;
Данные подразделы следуют друг за другом в произвольном порядке.
Далее следует блок begin / end, внутри которого находятся операторы, отделяемые один от другого символом "точка с запятой". Среди операторов может присутствовать оператор описания переменной, который позволяет описывать переменные внутри блока.
Раздел uses и раздел описаний могут отсутствовать.
Например:
program MyProgram;
var
a,b: integer;
x: real;
begin
readln(a,b);
x:= a/b;
writeln(x);
end.
или
uses GraphABC;
begin
var x:= 100;
var y:= 100;
var r:= 50;
Circle(x,y,r);
end.
Обзор типов
Типы в PascalABC.NET подразделяются на простые, структурированные, типы указателей, процедурные типы, последовательности и классы.
К простым относятся целые и вещественные типы, логический, символьный, перечислимый и диапазонный тип.
Тип данных называется структурированным, если в одной переменной этого типа может содержаться множество значений.
Кструктурированным типам относятся массивы, строки, записи, кортежи, множества и файлы.
Особым типом данных является последовательность, которая хранит по-существу алгоритм получения данных последовательности один за другим.
Все простые типы, кроме вещественного, называются порядковыми. Только значения этих типов могут быть индексами статических массивов и параметрами цикла for. Кроме того, для порядковых типов используются функции Ord, Pred и Succ, а также процедуры Inc и Dec.
Все типы, кроме типов указателей, являются производными от типа Object. Каждый тип в PascalABC.NET имеет отображение на тип.NET. Тип указателя принадлежит к неуправляемому коду и моделируется типом void*.
Все типы в PascalABC.NET подразделяются на две большие группы: размерные и ссылочные.
Размерные и ссылочные типы
Все типы в PascalABC.NET подразделяются на две большие группы: размерные и ссылочные. К размерным относятся все простые типы, указатели, записи, статические массивы, множества и строки. К ссылочным типам относятся классы, динамические массивы, файлы и процедурный тип.
Размерные типы более эффективны при вычислениях: они занимают меньше памяти и операции, выполняемые над небольшими размерными типами, максимально эффективны. Ссылочные типы обладают большей гибкостью: память под них выделяется динамически в процессе работы программы и освобождается автоматически, когда объект ссылочного типа перестаёт использоваться.
Выделение памяти
Память под переменную размерного типа распределяется на программном стеке в момент её описания. При этом переменная размерного типа хранит значение этого типа.
var i: integer; // здесь под i выделяется память
i:= 5;
Переменная ссылочного типа представляет собой ссылку на объект некоторого класса в динамической памяти. Если она не инициализирована, то хранит специальное значение nil (нулевая ссылка). Для инициализации ссылочных переменных используется вызов конструктора соответствующего класса:
type Person = auto class
name: string;
age: integer;
end;
var p: Person; // p хранит значение nil, память под объект не выделена
p:= new Person('Иванов',20); // конструктор выделяет память под объект
Присваивание
При присваивании переменных размерного типа копируются значения этого типа. Если размерный тип имеет большой размер, эта операция может выполняться долго. Например:
var a,a1: array [1..1000000] of integer;
a1:= a; // копируются все 1000000 элементов
При присваивании переменных ссылочного типа осуществляется присваивание ссылок, в итоге после присваивания обе ссылки ссылаются на один объект в динамической памяти:
var p1: Person;
p1:= p; // копируется ссылка
Сравнение на равенство
Сравнение на равенство объектов размерного типа сравнивает их значения. В частности, две переменные типа запись равны если равны все поля этих записей.
type PersonRec = record
name: string;
age: integer;
end;
var p,p1: PersonRec;
p.name:= 'Иванов'; p.age:= 20;
p1.name:= 'Иванов'; p1.age:= 20;
writeln(p1=p); // True
При сравнении на равенство переменных ссылочного типа проверяется, что они ссылаются на один и тот же объект.
var p:= new Person('Иванов',20);
var p1:= new Person('Иванов',20);
writeln(p1=p); // False
Управление памятью
Размерные типы распределяются на программном стеке, поэтому не нуждаются в специальном управлении памятью. Под глобальные размерные переменные память распределена всё время работы программы. Под локальные размерные переменные память выделяется в момент вызова подпрограммы. а освобождается в момент завершения работы этой подпрограммы.
Управление памятью для ссылочных типов осуществляется автоматически сборщиком мусора. Сборщик мусора запускается в неопределенный момент времени когда управляемой памяти перестаёт хватать. Он возвращает в пул неиспользуемой памяти те объекты, на которые больше никто не ссылается, после чего дефрагментирует оставшуюся память, в результате чего динамическая память всегда дефрагментирована и ее выделение при вызове конструктора происходит практически мгновенно.
Передача в подпрограммы
При передаче размерных типов по значению происходит копирование значения фактического параметра в переменную-формальный параметр. Если размерный тип имеет большой размер, это может занимать продолжительное время, поэтому размерный тип в этом случае передаётся по ссылке на константу:
type Arr = array [1..100] of integer;
procedure PrintArray(const a: Arr; n: integer);
begin
for var i:=1 to n do
Print(a[i])
end;
Ссылочные типы передаются в подпрограмму, как правило, по значению. При передаче таких параметров происходит копирование ссылки, в результате формальный и фактический параметр будут ссылаться на один объект.
procedure Change666(a: array of integer);
begin
a[0]:= 666;
end;
При этом в результате изменения формального параметра внутри подпрограммы меняется и содержимое соответствующего фактического параметра при вызове подпрограммы.
Ниже приводится таблица целых типов, содержащая также их размер и диапазон допустимых значений.
| Тип | Размер, байт | Диапазон значений |
| shortint | 1 | -128..127 |
| smallint | 2 | -32768..32767 |
| integer, longint | 4 | -2147483648..2147483647 |
| int64 | 8 | -9223372036854775808..9223372036854775807 |
| byte | 1 | 0..255 |
| word | 2 | 0..65535 |
| longword, cardinal | 4 | 0..4294967295 |
| uint64 | 8 | 0..18446744073709551615 |
| BigInteger | переменный | неограниченный |
Типы integer и longint, а также longword и cardinal являются синонимами.
Максимальные значения для каждого целого типа определены как внешние стандартные константы: MaxInt64, MaxInt, MaxSmallInt, MaxShortInt, MaxUInt64, MaxLongWord, MaxWord,MaxByte.
Для каждого целого типа T кроме BigInteger определены следующие константы как статические члены:
T.MinValue - константа, представляющая минимальное значение типа T;
T.MaxValue - константа, представляющая максимальное значение типа T;
Для каждого целого типа T определены статические функции:
T.Parse(s) - функция, конвертирующая строковое представление числа в значение типа T. Если преобразование невозможно, то генерируется исключение;
T.TryParse(s,res) - функция, конвертирующая строковое представление числа в значение типа T и записывающая его в переменную res. Если преобразование возможно, то возвращается значение True, в противном случае - False.
Кроме того, для T определена экземплярная функция ToString, возвращающая строковое представление переменной данного типа.
Константы целого типа могут представляться как в десятичной, так и в шестнадцатеричной форме, перед шестнадцатеричной константой ставится знак $:
25 3456 $FFFF
Вещественные типы
Ниже приводится таблица вещественных типов, содержащая их размер, количество значащих цифр и диапазон допустимых значений:
| Тип | Размер, байт | Количество значащих цифр | Диапазон значений |
| real | 8 | 15-16 | -1.8∙10308 .. 1.8∙10308 |
| double | 8 | 15-16 | -1.8∙10308 .. 1.8∙10308 |
| single | 4 | 7-8 | -3.4∙1038 .. 3.4∙1038 |
| decimal | 16 | 28-29 | -79228162514264337593543950335 .. 79228162514264337593543950335 |
Типы real и double являются синонимами. Самое маленькое положительное число типа real приблизительно равно 5.0∙10-324, для типа single оно составляет приблизительно 1.4∙10-45.
Максимальные значения для каждого вещественного типа определены как внешние стандартные константы: MaxReal, MaxDouble и MaxSingle.
Для каждого вещественного типа R кроме decimal определены также следующие константы как статические члены класса:
R.MinValue - константа, представляющая минимальное значение типа R;
R.MaxValue - константа, представляющая максимальное значение типа R;
R.Epsilon - константа, представляющая самое маленькое положительное число типа R;
R.NaN - константа, представляющая не число (возникает, например, при делении 0/0);
R.NegativeInfinity - константа, представляющая отрицательную бесконечность (возникает, например, при делении -2/0);
R.PositiveInfinity - константа, представляющая положительную бесконечность (возникает, например, при делении 2/0).
Для каждого вещественного типа R кроме decimal определены следующие статические функции:
R.IsNaN(r) - возвращает True, если в r хранится значение R.NaN, и False в противном случае;
R.IsInfinity(r) - возвращает True, если в r хранится значение R.PositiveInfinity или R.NegativeInfinity, и False в противном случае;
R.IsPositiveInfinity(r) - возвращает True, если в r хранится значение R.PositiveInfinity, и False в противном случае;
R.IsNegativeInfinity(r) - возвращает True, если в r хранится значение R.NegativeInfinity, и False в противном случае;
Для каждого вещественного типа R определены следующие статические функции:
R.Parse(s) - функция, конвертирующая строковое представление числа в значение типа R. Если преобразование невозможно, то генерируется исключение;
R.TryParse(s,res) функция, конвертирующая строковое представление числа в значение типа R и записывающая его в переменную res. Если преобразование возможно, то возвращается значение True, в противном случае - False.
Кроме того, определена экземплярная функция ToString, возвращающая строковое представление переменной типа R.
Вещественные константы можно записывать как в форме с плавающей точкой, так и в экспоненциальной форме:
1.7 0.013 2.5e3 (2500) 1.4e-1 (0.14)
Логический тип
Значения логического типа boolean занимают 1 байт и принимают одно из двух значений, задаваемых предопределенными константами True (истина) и False (ложь).
Для логического типа определены статические методы:
boolean.Parse(s) - функция, конвертирующая строковое представление числа в значение типа boolean. Если преобразование невозможно, то генерируется исключение;
boolean.TryParse(s,res) - функция, конвертирующая строковое представление числа в значение типа boolean и записывающая его в переменную res. Если преобразование возможно, то возвращается значение True, в противном случае - False.
Кроме этого, определена экземплярная функция ToString, возвращающая строковое представление переменной типа boolean.
Логический тип является порядковым. В частности, False<True, Ord(False)=0, Ord(True)=1.
Символьный тип
Символьный тип char занимает 2 байта и хранит Unicode-символ. Символы реализуются типом System.Char платформы.NET.
Операция + для символов означает конкатенацию (слияние) строк. Например: 'a'+'b' = 'ab'. Как и для строк, если к символу прибавить число, то число предварительно преобразуется к строковому представлению:
var s: string:= ' '+15; // s = ' 15'
var s1: string:= 15+' '; // s = '15 '
Над символами определены операции сравнения < > <= >= = <>, которые сравнивают коды символов:
'a'<'b' // True
'2'<'3' // True
Для преобразования между символами и их кодами в кодировке Windows (CP1251) используются стандартные функции Chr и Ord:
Chr(n) - функция, возвращающая символ с кодом n в кодировке Windows;
Ord(с) - функция, возвращающая значение типа byte, представляющее собой код символа c в кодировке Windows.
Для преобразования между символами и их кодами в кодировке Unicode используются стандартные функции ChrUnicode и OrdUnicode:
ChrUnicode(w) - возвращает символ с кодом w в кодировке Unicode;
OrdUnicode(с) - возвращает значение типа word, представляющее собой код символа c в кодировке Unicode.
Кроме того, выражение # число возвращает Unicode-символ с кодом число (число должно находиться в диапазоне от 0 до 65535).
Аналогичную роль играют явные преобразования типов:
char(w) возвращает символ с кодом w в кодировке Unicode;
word(с) возвращает код символа c в кодировке Unicode.
Строковый тип
Строки имеют тип string, состоят из набора последовательно расположенных символов char и используются для представления текста.
Строки могут иметь произвольную длину. К символам в строке можно обращаться, используя индекс: s[i] обозначает i-тый символ в строке, нумерация начинается с единицы. Если индекс i выходит за пределы длины строки, то генерируется исключение.
Над строками определены операции сравнения: < > <= >= = <>. Сравнение строк на неравенство осуществляется лексикографически: s1 < s2 если для первого несовпадающего символа с номером i s1[i]<s2[i] или все символы строк совпадают, но s1 короче s2.
Операция + для строк означает конкатенацию (слияние) строк. Например: 'Петя'+'Маша' = 'ПетяМаша'.
Расширенный оператор присваивания += для строк добавляет в конец строки - левого операнда строку - правый операнд. Например:
var s: string:= 'Петя';
s += 'Маша'; // s = 'ПетяМаша'
Строка может складываться с числом, при этом число предварительно преобразуется к строковому представлению:
s:= 'Ширина: '+15; // s = 'Ширина: 15'
s:= 20.5+''; // s = '20.5'
s += 1; // s = '20.51'
Над строками и целыми определена операция *: s*n и n*s означает строку, образованную из строки s, повторенной n раз:
s:= '*'*10; // s = '**********'
s:= 5*'ab' // s = 'ababababab'
s:= 'd'; s *= 3; // s = 'ddd'
Строки реализуются типом System.String платформы.NET и представляют собой ссылочный тип. Таким образом, все операции над строками унаследованы от типа System.String. Однако, в отличие от.NET - строк, строки в PascalABC.NET изменяемы. Например, можно изменить s[i] (в.NET нельзя). Более того, строки string в PascalABC.NET ведут себя как размерные: после
var s2:= 'Hello';
var s1:= s2;
s1[2]:= 'a';
строка s2 не изменится. Аналогично при передаче строки по значению в подпрограмму создается копия строки, т.е. обеспечивается поведение, характерное для Delphi Object Pascal, а не для.NET.
Однако, строке можно присвоить nil, что необходимо для работы с NET-кодом.
Кроме того, в PascalABC.NET реализованы размерные строки. Для их описания используется тип string[n], где n - константа целого типа, указывающая длину строки. Размерные строки, в отличие от обычных, можно использовать как компоненты типизированных файлов. Для совместимости с Delphi Object Pascal в стандартном модуле описан типshortstring=string[255].
Стандартные подпрограммы работы со строками.
Члены класса string.
Статические массивы
