Описание процедур имеет такой вид:
procedure <название процедуры> (<список параметров>);
<тело подпрограммы>;
В отличие от процедур, функции возвращают результат. Описание функции имеет вид:
function <название процедуры> (<список параметров>): <тип результата>;
<тело подпрограммы>
В списке параметров можно указывать переменные которые мы передаём в процедуру или которые получаем. Причём, если переменную из списка параметров мы собираемся изменить, тогда необходимо перед переменной указать var.
Можно так же указывать для переменной значение по умолчанию. Для этого, после типа переменной через знак = необходимо указать значение.
Обычно, название процедуры или функции должно быть уникально. Но, часто бывает, что необходимо для одной и той же функции указывать различные параметры. Поэтому, в компиляторе, чтоб не было необходимости задавать различные названия процедур, предусмотрена так называемая перегрузка функции. Функции и процедуры, которые могут повторяться отмечаются зарезервированным словом overload.
Рассмотрим объявления процедур и функций:
// Перегруженная функция с одной переменной
procedure my_write(str_inp1: string); overload;
// Перегруженная функция с двумя переменными
procedure my_write(str_inp1, str_inp2: string); overload;
// Перегруженная функция с тремя переменными
procedure my_write(str_inp1, str_inp2, str_inp3: string); overload;
Таким образом, в программе мы можем задавать различное значение не задумываясь о том, какое название процедуры необходимо указать для какого случая. По сути, у нас получилась процедура, которая работает аналогично стандартной процедуре write. Мы можум писать:
my_write('Привет!');
my_write('Привет!', 'Иванов Иван Иванович');
my_write('Привет!', 'Иванов Иван Иванович', 'Как Вы поживаете?');
Если бы процедура не была перегружаемой, компилятор не разрешил бы Вам использовать различное количество параметров.
// Задаём значения по умолчанию
procedure get_user(str_inp1: string ='Иванов';age: integer=20);
// После выполнения, процедуры возвращаем параметр age
procedure get_user(str_inp1: string ='Иванов'; var age: integer=20);
// Функция с одним входным параметром. Возвращает значение косинуса
function my_cos(x: real): real;
// Функция без параметра, но с возвратом значения
function my_cos: string;
Следует отметить, что процедуры и функции можно задавать так же в типах данных. Такие типы называются: процедурный тип, тип-функция.
Пример таких функций и процедур:
Type
fmy_curr = function (summa: currency; nds: currency): currency;
fmy_proc = procedure (mess: string);
Строковые типы
Строка представляет собой последовательность символов, заключенную в одинарные или двойные кавычки. [7]
Константа типа Char представляет собой строку раз мером в 1 символ.[7]
Примеры строк:
‘Привет!’, “Тест”, “A”
Рассмотрим какие типы строк есть в Object Pascal.
| Тип строки | Максимальная длина | Есть ли нулевой символ в конце |
| ShortString | 255 байт | нет |
| AnsiString | 2 Гб | есть |
| String | 255 байт/2 Гб | нет/есть |
| WideString | 1 Гб | есть |
Тип String по умолчанию воспринимается компилятором, как AnsiString.
Если указать директиву {$H-}, тогда String воспринимается, как ShortString. По умолчанию, действует директива {$H+} – AnsiString.
Тип ShortString – это стандартные Паскалевые строки с ограничением в 255 символов. Нулевой символ содержит длину строки (в виде символа). Для того, чтоб получить длину строки по нулевому байту необходимо вызвать процедуру – ord(). К каждому символу короткой строки можно обратиться по индексу, например:
Stroka[8] – возвращает 8-й символ.
Stroka[53] – возвращает 53 символ.
ord(Stroka[0]) – возвращает количество символов в строке.
Для определения длины строки всех типов можно воспользоваться стандартной функцией – Length(<строка>).
Например:
length('Строка'); - возвратит цифру 6.
Для объединения строк используется знак +. Например:
new_str:='Иванов '+'Иван'; // Переменная new_str примет значение Иванов Иван
str:='str'+IntToStr(55); // Переменная str примет значение str55
В Паскале предусмотрено большое количество стандартных процедур и функций для работы со строками. Рассмотрим некоторые из них:
function AnsiCompareStr(const S1, S2: string): Integer;
// Сравнивает две строки S1 и S2 в кодировке с учётом регистра.
// Возвращает значение меньше 0, если S1S2.
function AnsiCompareText(const S1, S2: string): Integer;
// Аналогична предыдущей функции, но сравнение происходит без учёта регистра.
function AnsiLowerCase(const S: string): string;
// Возвращает в кодировке ANSI строку S, преобразованную у нижнему регистру.
function AnsiPos(const Substr, S: string): Integer;
// Возвращает позицию (индекс) первого вхождения Substr в S. Если Substr нет
// в S, тогда возвращается 0.
function AnsiUpperCase(const S: string): string;
// Возвращает строку S в кодировке ANSI, преобразованную к верхнему регистру.
function Concat(s1 [, s2,...,sn]: string): string;
// Возвращают строку, сцеплённую из строк s1..sn. Аналогична операции + для строк.
function Copy(S; Inex, Count: Integer): string;
// Параметр S-строка или динамический массив. Эта функция возвращает построку S,
// начинающуюся с символа S[Index] и содержащую Count символов.
procedure Delete(var S: string; Index, Count: Integer);
// Удаляет из строки S подстроку, начинающуюся с символа Index и содержащую Сount
// символов.
procedure Insert(Source: String; var S: string; Index: integer);
// Вставляет строку Source в S, начиная с символа с номером Index.
function Length(S): Integer;
// Возвращает число символов в строке S.
function Pos(Substr; S: String): Integer;
// Возвращает позицию первого вхождения строки Substr в строку S.
// Если вхождений нет, тогда возвращается 0
procedure SetLength(var S; NewLength: Integer);
// Эта процедура устанавливает строку или динамический массив к длине NewLength
// Параметр S является строкой или динамическим массивом.
function StringOfChar(Ch: Char; Count: Integer): String;
// Создаёт строку, состоящую из Count раз повторяющегося символа Сh
function Trim(const S: string): String;
// Удаляет из строки S все пробелы и управляющие символы.
function TrimLeft(const S: string): String;
// Удаляет из строки S все пробелы и управляющие символы слева в строке.
function TrimRight(const S: string): String;
// Удаляет из строки S все пробелы и управляющие символы справа в строке.
В Паскале объединять данные различных типов нельзя. Для того, чтоб объединить различные данные друг с другом, необходимо предварительно привести данные к одинаковому типу, а потом уже делать объединения.
Перечислим основные функции для преобразования типов:
function IntToStr(Value: Integer): String; Overload;
function IntToStr(Value: Int64): String; Overload;
// Функция для преобразования целого числа в строку.
// Как видите, есть две функции IntToStr. Одна для Integer, другая для Int64
function FloatToStr(Value: Extended): String;
// Преобразует вещественное значение Value в строку.
procedure Str(X [:Width [:Decimal]]; var S);
// Преобразует строку S в целое число.
// Не обязательные параметры Width - длина всего числа.
// Decimal - длина цифр после запятой.
function StrToInt(const S: string): Integer;
// Преобразует строку в целое число. Строка должна содержать только цифровые
// символы.
function StrToFloat(const S: string): Extended;
// Преобразует строку S в действительное число. Строка должна содержать только
// цифровые символы и знак разделителя дробной части.
Procedure Val(S; var V; var Code: Integer);
// Преобразует строку S в вещественный или целочисленный тип, в зависимости от
// типа данных V. В параметре Code выводится успешность преобразования.
// Если Code=0, тогда тогда преобразование прошло успешно, иначе переменная
// Code выводит позицию первого ошибочного символа.
function FloatToStrF(Value: Extended; Format: TFloatFormat; Precision,
Digits: Integer): String;
// Позволяет преобразовавть вещественное значение в строковое с возможностью
// настройки вида отображения строки
// Параметры данной функции:
// Value - число, которое мы будем преобразовывать на строку.
// Format - форматирование строки. Задаёт внешний вид строки.
// Precision - точность представления числа.
// Digits - значение зависит от используемого формата.
// Значения Format могут быть:
// ffGeneral - общий цифровой формат. Число отображается с десятичной точкой.
// Например: 34342.993
// ffExponent - Отображение в научном формате.
// Например: 34342.993E-5
// ffFixed - число с фиксированной запятой. Число отображается с десятичной точкой.
// Например: 34342.993
// ffNumber - числовой формат. Показывается число с фиксированной десятичной точкой
// и в добавок к этому показываются разделители групп разрядов. Например: 3,434,232.99
// ffCurrency - денежный формат. Подобен формату ffNumber, но в конце ещё дописывается
// денежная единица. Например: 3,332,234.32 грн.
Есть ещё две важные функции, которые я не перечислил: Format(), FmtStr(Result,…). По действию они схожи, но первая возвращает результат из вызова функции, а вторая – как параметр.[15]
Рассмотрим семантику данных функций:
function Format(const Format: string; const Args: array of const): string; overload;
function Format(const Format: string; const Args: array of const; const FormatSettings: TFormatSettings): string; overload;
procedure FmtStr(var StrResult: string; const Format: string; const Args: array of const); overload;
procedure FmtStr(var StrResult: string; const Format: string; const Args: array of const; const FormatSettings: TFormatSettings); overload;
Пример применения функции Format:
Write(Format('Мне %d лет'),[29]); // Программа выведет на экран: Мне 29 лет
Как видите, вместо %d ф-ция Format подставило значение 29.
Существует несколько спецификаторов формата, применяемых с функцией Format. Каждый из спецификаторов предваряется знаком процента и переменным числом внутренних аргументов, представленных в следующем списке [15]:
d: integer;
e: scientific;
f: fixed;
g: general;
n: number;
m: Money;
p: Pointer;
s: string;
x: Hex;
Приведём ещё несколько примеров применения ф-ции Format:
Wirite(Format('Сумма счёта: %m',[13.2]));
// Выводит: Сумма счёта: 13,2 грн
Write(Format('Возникла ошибка:'+Chr(13)+'%s: %s.', [E.ClassName, E. Message ]));
// Выводится на экран сообщение о том, что возникла ошибка и на следующих строках
// приводится текст самой ошибки
Тип-диапазон
Тип-диапазон – базовый тип. С его помощью, можно задать диапазон значений, которые может принимать переменная. Если значение переменной будет выходить за диапазон, тогда во время выполнения программы возникнет ошибка. Для того, чтоб отключить проверку диапазонов можно использовать директиву {$R-}, а для включения – {$R+}.
Пример задания типов-диапазонов:
Type
numbers=(first, second, third); // Три значения: first, second, third
num_age=20..120; // Значения могут приниматься от 20 до 120
rus_sim='а'..'я'; // Символы от а до я
Типы даты и времени
Тип дата (TDateTime) предназначен для хранения информации о дате и времени. Значения этого типа представляют собой 8-ми байтовые вещественные числа с фиксированной запятой. Целая часть такого числа обозначает количество суток, прошедших с 30 декабря 1899 года, а дробная – часть суток, прошедших с 0 часов. Таким образом, целая часть позволяет определить дату, а дробная – время.[7]
Необходимо учитывать, что в различных странах дата может быть представлена в различном виде.
Так, например для России и Украины принято написание:
17.09.2006 16:19 (день, месяц, год, часы, минуты)
А для США:
2006.09.17 4:19PM (год, месяц, день, часы, минуты)
Приведём функции для работы с датой и временем [7].
function Date: TDateTime;
// Функция возвращает текущую дату
function DateTimeToStr(DateTime: TDateTime): String;
// Функция преобразует дату и время DateTime к строковому типу
procedure DateTimeToString(var Result: String; const Format: String;
DateTime: TDateTime);
// Преобразует дату и время в строку и помещает результат в переменную Result
// с использованием формата Format.
function DateToStr(Date: TDateTime): string;
// Преобразует дату к строке. При преобразовании используется формат, указанный
// в глобальной переменной ShortDateFormat.
function DateOfWeek(Date: TDateTime): Integer;
// Возвращает день недели для указанной даты Date. Обратите внимание, что
// 1-воскресенье, 2-понедельник,..., 7 - суббота.
procedure DecodeDate(Date: TDateTime; var Year, Month, Day: Word);
// Процедура разбивает длату на отдельные цифры: год (Year), месяц (Month), день (Day).
procedure DecodeTime(Time: TDateTime; var Hour, Min, Sec, MSec: Word);
// Процедура разбивает время на отдельные цифры: час, минуты, секунды, миллисекунды.
function EncodeDate(Year, Month, Day: Word): TDateTime;
// Формирует дату из отдельных цифр: год, месяц, день.
function EncodeTime(Hour, Min, Sec, MSec: Word): TDateTime;
// Функция формирует время из отдельных цифр: часы, минуты, секунды, миллисекунды.
function FormatDateTime(const Format: String; DateTime: TDateTime): String;
// Преобразует дату и время в строку в соответствии с заданным форматом даты/времени.
function IsLeapYear(Year: Word): Boolean;
// Функция проверяет является ли заданный год высокосным
function Now: TDateTime;
// Функция возвращает текущую дату и время
function StrToDate(const S: string): TDateTime;
// Функция преобразует строку S в дату.
function StrToDateTime(const S: string): TDateTime;
// Функция преобразует строку S в дату и время.
function StrToTime(const S: string): TDateTime;
// Функция преобразует строку S во время.
function TimeToStr(Time: TDateTime): String;
// Функция преобразует время Time в строку
В некоторых функциях указывается строка формата даты. Ниже опишем возможные символы-спецификаторы для строки формата [7]:
| c | Отображает дату и время в виде мм/дд/гг чч.мм.сс. Например: 01/25/2006 17.31.42. Время не отображается, если дробная часть парамета DateTime равна нулю. |
| d | Отображается день как число без ведущего нуля (1-31). |
| dd | Отображается день как число с ведущим нулём (01-31). |
| ddd | Отображается название в сокращенном виде. Например: Sun, Sat. |
| dddd | Отображается название дня полностью. Например: Sunday, Saturday. |
| ddddd | Отображает дату в формате дд.мм.гг Например: 17.09.06 |
| dddddd | Отображает дату в формате д месяц г. Например: 23 October 1999. |
| m | Отображает месяц как число без ведущего нуля (0-12). Если данный спецификатор идёт за спецификатором h, тогда отображается не месяц, а минуты. |
| mm | Отображает месяц как число с ведущи нулем (0-12). Если данный спецификатор идёт за спецификатором h, тогда отображается не месяц, а минуты. |
| mmm | Отображается название месяца в сокращенном виде. Например: Jan, Dec. |
| mmmm | Отображается полное название месяца. Например: January, December. |
| yy | Отображается год как число, состоящее из двух цифр (00-99). |
| yyyy | Отображается год как число, состоящее из четырёх цифр (0000-9999). |
| h | Отображаются часы без ведущего нуля (0-23). |
| hh | Отображается час с ведущим нулём (00-23). |
| n | Отображаются минуты без ведущего нуля (0-59). |
| nn | Отображаются минуты с ведущим нулём (00-59). |
| s | Отображаются секунды без ведущего нуля (0-59). |
| ss | Отображаются секунды с ведущим нулём (00-59). |
| z | Отображаются миллисекунды без ведущего нуля (0-999). |
| zzz | Отображаются миллисекунды с ведущим нулём (000-999). |
| t | Отображается время в формате чч:мм. Например: 14:53. |
| tt | Отображается время в формате чч:мм:сс. Например: 17:43:55 |
| am/pm | Отображается время в двенадцатеричном формате. am – до полудня, pm – после полудня. Например: 7:33 am |
| a/p | Время в шестнадцатеричном формате. a – до полудня, p – после полудня. |
| ampm | Время в шестнадцатеричном формате, но без установки метки до полудня или после полудня. |
| ‘xx’/”xx” | Символы xx, отличные от символов-спецификаторов, помещенные в строку Format, отображаются на экране дисплея без каких-либо преобразований. Например: “hh hour, nn minutes, ss seconds”, для 17:54:23 будет от ображено: 17 hour 54 minutes 23 seconds. |
Если строка формата указывается пустой, тогда будет форматироваться так, как будто указан символ c.[7]
Массивы
Массивы бывают статические или динамические. В статических массивах не изменяется количество элементов во время выполнения программы, а в динамических массивах – изменяется количество элементов.
Статические массивы
Статический тип массивов представляет собой фиксированное количество однотипных элементов. Данный тип массива имеют такую форму:
Type
<имя типа>= array [<диапазон элементов>] of <тип элементов>;
Например:
Type
month_names= array [1..12] of string; // массив для 12 элементов массива
matrix= array [1..100, 1..100] of real; // Матрица 100x100.
Элементами статического массива могут быть любые типы, кроме Int64 и LongWord.
Для доступа к элементу массива необходимо писать: month[2] – обращение ко второму элементу. В Паскале копировать сразу две переменные разных типов элементов нельзя. Необходимо копировать каждый элемент массива индивидуально. Если же переменные одинакового типа, тогда Вы можете скопировать элементы простым присваиванием, например: arr2:=arr1;
Пример: Сделаем программу в которой производится ввод элементов массива. Потом, делается копирование элементов во второй массив, целочисленного типа и этот массив выводится на экран.
Вот листинг программы:
| program consple_laz; // Программа копирует элементы массива Arr1 в элемент массива Arr2. {$mode objfpc}{$H+} {$AppType CONSOLE} Uses SysUtils; var Arr1: array[0..6] of real; // Первый массив. (откуда копируем) Arr2: array[0..6] of integer; // Второй массив. (куда копируем) i: integer; begin // Запрашиваем ввод элементов массива for i:=0 to 6 do begin write(Format('Arr1[%d]=',[i])); readln(Arr1[i]); end; // Копируем элементы массива for i:=0 to 6 do Arr2[i]:=Round(Arr1[i]); // Так как элементы 2-го массива целочисленные, // тогда их округляем // Пропускаем расстояние Writeln; Writeln('======================'); Writeln; // Выводим элементы массива на экран for i:=0 to 6 do writeln(Format('Arr2[%d]=%d',[i,Arr2[i]])); // Обратите внимание // на использовании ф-ции Format Readln; // Ждём ожидания нажатия клавиши end. |
Результат выполнения программы:
| Arr1[0]=33.424 Arr1[1]=33.344 Arr1[2]=2 Arr1[3]=44.43 Arr1[4]=2.423 Arr1[5]=4.3 Arr1[6]=523 ====================== Arr2[0]=33 Arr2[1]=33 Arr2[2]=2 Arr2[3]=44 Arr2[4]=2 Arr2[5]=4 Arr2[6]=523 |
Динамические массивы
Динамические массивы не имеют за ранее известный размер. Их размер изменяется во время выполнения программы. Объявить динамический массив можно таким способом:
Var
<имя переменной-массива>: array of <тип элементов>;
Например:
Var
power: array of integer;
chars_table: array of char;
arr_string: array of string;
Динамические массивы могут быть так же многомерными. Для объявления многомерного массива необходимо добавить array of, причёмс только раз, сколько есть измерений.
Например:
Var
power: array of array of integer; // двух-мерный массив
chars_table: array of array of array of char; // трёхмерный массив
arr_string: array of array of string; // двухмерный массив
Установка длины массива производится с помощью процедуры SetLength.
Например:
SetLength(power,10); // Устанавливаем 10 элементов в массиве power
SetLength(chars[1],30); // Устанавливаем 30 элементов в 1-м элементе массива
Освободить память массива можно с помощью функции SetLength, указав нулевойр азмер. Так же можно присвоить переменной мас сива nil или вызвать функцию finalize(массив).
Динамические массивы могут передаваться в качестве входного параметра.
Например:
procedure mess(mess_in[: array [1..3] of string); // Передаётся массив
// со статическим массивом
procedure set_power(power_input array of integer); // Передаётся массив с
// динамическим массивом из целых чисел
procedure set_power(var power_input array of integer);
// Передаётся и возвращается массив с динамическим количеством целых чисел
Напомню, что с помощью функции Low Вы можете определить минимальное количество элементов в массиве, а с помощью High – максимальное количество элементов.
Пример. Сделаем программу, в которой задаётся указанное количество элементов, а потом они будут просортированы по методу пустого стакана (или пустого пузырька).
Метод пустого стакана заключается в применении дополнительной переменной для временного хранения значения при обмене информации при сортировке.
Листинг программы:
| program consple_laz; // В программе осуществляется ввод массива. // После этого, массив сортируется и результат выводится на экран. {$mode objfpc}{$H+} {$AppType CONSOLE} uses SysUtils; type ArrInt=array of real; // Динамический массив действительных чисел // Процедура осуществляет ввод элементов procedure inp_elems(var arr_inp: ArrInt); var i: integer; begin for i:=low(arr_inp) to high(arr_inp) do begin Write(Format('Elem[%d]= ',[i])); ReadLn(arr_inp[i]); end; end; // Процедура для сортировки элементов методов пустого стакана procedure inp_elems_sort(var arr_inp: ArrInt); var i,i2: integer; elem_tmp: real; begin for i:=high(arr_inp) downto low(arr_inp) do for i2:=low(arr_inp) to i do begin if arr_inp[i]<arr_inp[i2] then begin elem_tmp:=arr_inp[i]; arr_inp[i]:=arr_inp[i2]; arr_inp[i2]:=elem_tmp; end; end; end; // Процедура для вывода на экран элементов массива procedure show_elems(var arr_inp: ArrInt); var i: integer; begin for i:=low(arr_inp) to high(arr_inp) do begin WriteLn(Format('Elem[%d]=%f',[i, arr_inp[i]])); end; end; var arr_inp: ArrInt; // Массив введённых элементов cnt_elem: integer; // Количество элементов begin Write('Count Elements= '); ReadLn(cnt_elem); SetLength(arr_inp, cnt_elem); // Устанавливаем размер массива inp_elems(arr_inp); // Осуществляем ввод элементов inp_elems_sort(arr_inp); // Сортировка элементов Writeln; Writeln('===== Result ===='); Writeln; show_elems(arr_inp); // Вывод элементов на экран readln; // Ожидаем нажатия клавиши end. |
Результат выполнения программы:
| Count Elements= 5 Elem[0]= 333.2 Elem[1]= 23.24 Elem[2]= 242.2 Elem[3]= 2 Elem[4]= 4452 ===== Result ==== Elem[0]=2,00 Elem[1]=23,24 Elem[2]=242,20 Elem[3]=333,20 Elem[4]=4452,00 |
Множества
Множества определяются конструкцией:
<Имя типа множества>=set of <диапазон или элементы множества>;
В множества могут входить элементы любых типов данных, кроме: word, integer, longint, int64.
Пример задания множества:
Type
rus_liter= set of 'а'..'я';
number_des= set of 0..10;
Элементы множеств задаются так:
rus_l:= ['а','г','д'];
num:=[0, 1, 2, 3];
Множества можно объяединять (+), отнимать (-), сравнивать (=), проверять на вхождение элемента в множество (in).
Например:
['а','г','д']+['а','е','ж'] - получится ['а','г','д','е','ж']
['а','г','д']-['а','е','ж'] - получится ['г','д']
Пересечение множества реализуется с помощью знака *. Пересечением множества являются элементы, которые входят в оба множества. Например:
['а','г','д']*['а','е','ж'] - получится ['а']
Над множествами можно выполнять операции сравнения.
= - верно, если все элементы в сравниваемых множествах совпадают.
<> - верно, если хотябы один элемент в одном из множеств отличается.
<= - верно, если все элементы множества слева входят во множества справа от операции сравнения.
>= - истинно, если множества справа входит в множество слева от операции сравнения.
in – проверка на вхождение подмножества в множество. Верно, если подмножество входит в множество.
Например:
['а'] in ['а','г','д'] - вернёт true.
Записи
Запись – это тип данных, который включает в себя ряд переменных различных типов данных.
Объявляется запись таким образом:
Type
<имя типа записи> = record
<поле 1>: <тип поля>;
<поле 2>: <тип поля>;
...
<поле n>: <тип поля>;
end;
Пример:
Type
TRec_UserInfo = record
UserName: String;
Fam: String;
Im: String;
BirthDay: TDateTime;
end;
var r: TRec_UserInfo;
Обратиться к элементу записи можно таким образом:
r.UserName:='Sergey';
r.Fam:='Рудюк';
r.Im:='Сергей';
r.BirthDay:=StrToDate('17.04.1977');
Оператор With
В примере, приведённом выше, мы обращались к каждому элементу записи индивидуально, каждый раз повторяя ввод всего пути к переменной. Это не сложно делать, когда переменная не большая, а так же путь к конечной переменной не большой. Однако, в реальных программах такое написание сделало бы написание программы утомительным занятием да ещё и тексты получались бы не читабельными. Для того, чтоб не повторять написание переменных каждый раз в Pascal был введён оператор With:
with <переменные> do <оператор>;
Например, пример описанный выше можно написать:
with r do
Begin
UserName:='Sergey';
Fam:='Рудюк';
Im:='Сергей';
BirthDay:=StrToDate('17.04.1977');
end;
Как видите, нам не приходилось каждый раз вводить r. Кроме того, если вдруг переменная изменится, её хватит изменить в одном месте, там где with, а не менять в каждой строке. В больших и сложных программах такой подход оправданный, поэтому профессионалы применяют его часто.