 |
Case SomeStringVariable of
|
|
|
|
'One': { code }
'Two': { code }
end;
Синтаксис оператора case имеет вид
case selector of
value_1: statements_1;
value_2: statements_2;
.
.
.
value_n: statements_n;
Else
else_statements;
end;
Оператор case выполняет один из блоков кода, выбирая его по значению выражения–селектора (selector). Тип выражения селектора относится к одному из упорядоченных типов Object Pascal.
Блок кода statements_1 выполняется при условии что значение selector равно (соответствует) value_1, блок кода statements_2 выполняется при условии что значение selector равно (соответствует) value_2 и т.д.
Если значение селектора не соответствует ни одной из ветвей value_1...value_n выполняется блок else_statements.
Блок else не обязателен.
Область видимости идентификаторов
Область действия (scope) идентификатора есть часть пространства программы, в котором он доступен для использования.
Обычно область действия идентификатора начинается там, где он объявлен, а заканчивается там где это объявление теряет силу.
Большинство переменных являются локальными. Их область видимости – блок кода, в котором они объявлены. Рассмотрим программу на листинге 2.1. (На этом листинге показан модуль, текст которого сгенерирован Delphi.)
Листинг 2.1. SCOPEU.PAS.
01: unit ScopeU;
02:
Interface
04:
Uses
06: Windows, Messages, SysUtils, Classes, Graphics,
Controls, Forms, Dialogs, StdCtrls;
08:
Type
10: TForm1 = class (TForm)
11: Button1: TButton;
12: Memo1: TMemo;
13: procedure Button1Click(Sender: TObject);
14: procedure FormCreate(Sender: TObject);
Private
16: { Private declarations }
Public
18: { Public declarations }
19: end;
20:
Var
22: Form1: TForm1;
23:
Implementation
25:
Var
27: X: Integer;
29: {$R *.DFM}
30:
31: procedure TForm1.Button1Click(Sender: TObject);
Var
33: X: Integer;
34:
35: procedure Test;
Var
37: X: Integer;
Begin
39: X:= 300;
40: {Здесь переменная X имеет значение 300. }
41: Memo1.Lines.Add(`Локальная функция X: ` + IntToStr(X));
|
|
|
42: end;
43:
Begin
45: X:= 100;
46: Memo1.Lines.Clear;
47: { Локальная переменная X имеет значение 100. }
48: Memo1.Lines.Add(`Локальная X: ` + IntToStr(X));
49: { Глобальная переменная X имеет значение 200. }
50: Memo1.Lines.Add(`Глобальная X: ` + IntToStr(ScopeU.X));
51: { Вызываем процедуру Test. }
52: Test;
53: end;
54:
55: procedure TForm1.FormCreate(Sender: TObject);
Begin
57: { Инициализируем переменную модуля X. }
58: X:= 200;
59: end;
60:
End.
Прежде всего отметим то, что переменная X объявлена в трех местах этой программы. Она объявлена в строке 27 в разделе реализации, затем в строке 33 (метод Button1Click), наконец – в строке 37 (в локальной процедуре с именем Test). Если объявление переменной встречается дважды, компилятор фиксирует ошибку «Identifier redeclared: 'X'», а компиляция прекращается. Но эта программа прекрасно работает. Почему? Потому, что каждая из переменных с именем X в этом листинге имеет свою облась действия.
Посмотрите на листинг 2.1 внимательней. В строке 37 переменная X объявлена внутри локальной процедуры Test и «видима» только в блоке кода этой процедуры. (Здесь мы несколько забежали вперед, говоря о локальных процедурах и функциях. Необходимые разъяснения будут даны ниже в разделе «Локальные функции и процедуры»). Вне процедуры Test переменная X, которая объявлена в строке 37, не существует. Эта переменная имеет локальную область действия. Точно так же объявление переменной X на строке 33 является локальным по отношению к методу Button1Click. Вне этого метода переменная, объявленная в строке 33, не существует. (Если бы в процедуре Test не было объявления Х в строке 37, то она изменяла бы значение переменной Х, объявленной в строке 33!!!).
Теперь рассмотрим область действия переменной X, объявленной в разделе implementation. Эта переменная видима из любого места модуля. Раз так, то она «видна» и в методе Button1Click. Но в этом методе переменная Х объявляется дважды. Возникает вопрос, а какое же из трех объявлений переменной Х должно использоваться? Ответ: действует локальное объявление в методе Button1Click, и локальное объявление в процедуре Test. Иными словами, действует то объявление, которое «ближе к телу».
|
|
|
Итак, переменная X, которая объявлена в разделе implementation модуля, доступна всюду в этом модуле. Локальная переменная с таким же именем «главнее» переменной модуля. Но что если внутри метода Button1Click нам понадобится переменная модуля, а не локальная? В этом случае переменную модуля необходимо квалифицировать. Строка 50 листинга 2.1 содержит:
Memo1.Lines.Add(¢Global X: ¢ + IntToStr(ScopeU.X));
Нетрудно видеть, что квалификатором переменной X является имя модуля (ScopeU). Квалификация переменной именем модуля буквально означает «Дайте мне переменную X модуля, а не локальную переменную X». Символом присоединения квалификатора является точка (.).
Как было сказано выше, переменная X, объявленная в разделе implementation, доступна в любом месте модуля. Если необходимо чтобы переменная была доступной в других модулях, ее объявление следует разместить в разделе interface. (На листинге 2.1 такой переменной является Form1). Любая переменная, объявленная в разделе interface доступна в любом модуле проекта. Такие переменные часто называют глобальными. Чтобы сделать глобальные переменные, объявленные в некотором модуле, достаточно добавит этот модуль с список uses. Если в двух разных модулях объявлены переменные с одинаковыми именами, для исключения неоднозначности надо применять квалификаторы так, как это показано выше.
ПРИМЕЧАНИЕ. На самом деле, определение глобальной переменной не совсем корректно. Действительно, переменные из раздела интерфейса модуля становятся доступны только после того как соответствующее имя появится в списке uses. Использовать такие переменные автоматически мы не можем. Истинно глобальной является только такая переменная, которая доступна всегда, везде и без ссылок на модули в списке uses. Delphi имеет несколько стандартных глобальных переменных, но мы не можем создавать такие переменные.
Подпрограммы
Подпрограммы в Object Pascal – это автономные исполняемые секции программы. Подпрограммы лежат в основе методики процедурного структурирования программ, предлагающей способ уменьшения программного кода за счет вынесения части функциональных возможностей программы в программную единицу специального вида – процедуру или функцию.
|
|
|
Новый термин. Подпрограмма – это блок кода с именем, состоящий из заголовка, объявлений и набора исполняемых операторов. Object Pascal представляет два существенно различных вида подпрограмм –процедуры и функции.
Процедуры и функции
Процедуры и функции – это секции кода вне главной программы. Они исполняются тогда когда соответствующие действия необходимы программе. Например, мы можем иметь функцию, которая выполняет сложные математические вычисления, используя в качестве исходных данных два числа и возвращает результат (вспомните упражнение с решением уравнения Кеплера). Возможно, нам понадобится функция, которая получает исходные данные в виде строки, а возвращает часть исходной строки, выделенную по каким-то правилам. К любой функции можно обратиться из программы вместо того чтобы всякий раз записывать одни и те же операторы когда необходимо выполнить соответствующие им действия с различными исходными данными.
Функции и процедуры называют подпрограммами. Простейшие подпрограммы не имеют параметров (исходных данных) и не возвращают результат. Другие подпрограммы могут иметь несколько параметров и возвращают результат.
Любая функция или процедура идентифицируется уникальным именем. Правила именования функций и процедур аналогичны правилам именования переменных..
Новый термин. Функция – это секция автономного по отношению к главной программе кода, которая выполняет некоторые действия и возвращает результат.
Новый термин. Параметр – это значение, которое передается в функцию или в процедуру и является ее аргументом.
Структура объявления функции имеет следующий вид:
// Заголовок функции
function SomeFunction(parameter_list):Type_of_result;
{ Объявления типов данных,констант,переменных}
{ Определения функций и процедур}
Begin
{ Код, реализующий алгоритм вычисления результата}
|
|
|
Result:= <значение типа Type_of_result>;
end;
Нетрудно видеть, что функция в чем–то сходна с модулем. Так, она может содержать объявления типов, констант, переменных, процедур и функций. Однако, эти объявления имеют локальный характер. Их область действия – блок кода, ограниченный ключевыми словами begin – end.
Список параметров (parameter_list) в заголовке функции перечисляет ее аргументы, но он не обязателен: функция может и не иметь параметров.
Обратим внимание на то что обязательно надо указать тип результирующего значения функции, а в блоке кода, реализующего алгоритм, должен быть оператор, возвращающий результат:
Result:= <значение типа Type_of_result>;
Новый термин. Процедура – это секция автономого по отношению к главной программе кода, которая выполняет некоторое действие, но не возвращает результат.
Структура объявления процедуры имеет следующий вид:
// Заголовок процедуры
procedure SomeProcedure(parameter_list);
{ Объявления типов данных,констант,переменных}
{ Определения функций и процедур}
Begin
{ Код, реализующий алгоритм вычислений}
end;
Упражнение. Рассмотрим пример определения функции. Начните новый проект и выполните следующие действия:
1. Поместите на форму кнопку и надпись.
2. Дважды щелкните на кнопке формы чтобы создать обработчик события OnClick.
3. Поместите курсор редактора кода перед обработчиком события и напечатайте следующий текст:
function Multiply(Num1, Num2: Integer): Integer;
Begin
Result:= Num1 * Num2;
end;
4. Придайте обработчику события OnClick следующий вид:
procedure TForm1.Button1Click(Sender: TObject);
Var
X: Integer;
Begin
X:= Multiply(10, 20);
Label1.Caption:= IntToStr(X);
end;
Запустите программу и нажмите кнопку. Надпись отобразит число 200.
Эта программа работает так. В ответ на нажатие кнопки вызывается подпрограмма – обработчик события Button1Click. Обработчик события вызывает функцию Multiply и передает ей два параметра – числа 10 и 20. Результат вычислений запоминается в переменной Х и отображается в надписи.
ПРИМЕЧАНИЕ. Этот пример иллюстрирует применение автономной функции в программе Delphi. Обычно такого рода функции включают в состав класса главной формы приложения. Об этом будет сказано ниже.
Возникает вопрос, а каким же образом результат перемножения двух чисел из функции передается в программу? Обратимся к тексту функции Multiply:
function Multiply(Num1, Num2: Integer): Integer;
Begin
Result:= Num1 * Num2;
end;
Любая функция в Object Pascal имет локальную переменную Result. Эта переменная неявно объявлена компилятором и используется для записи результата, возвращаемого функцией. Таким образом, чтобы вернуть результат, его значение надо присвоить локальной переменной функции Result. Чтобы получить результат функции в программе, надо просто использовать имя этой функции в составе выражения допустимого вида.
|
|
|
К функции Multiply можно обращаться по-разному. Так, ее фактическими аргументами могут быть переменные, константы или выражения:
X:= Multiply(2,5); {аргументы – константы }
Y:= Multiply(A,B); {аргументы - переменные }
{ аргумент – квадрат переменной, а сама функция есть аргумент другой функции:}
Label1.Caption:= IntToStr(Multiply(X, Sqr(Y));
Язык Object Pascal разрешает игнорировать результат функции. Так, абсолютно корректен следующий оператор:
Multiply(X,Y); { результат игнорируется }
Применительно к функции Multiply этот пример не имеет смысла. В то же время, игнорирование результата функции довольно типично. Так, в Object Pascal есть много функций, которые возвращают сведения об условиях, при которых та или иная функция выполнила свою работу. Результат обращения к такой функции можно и не использовать если это не противоречит логике программы.
|
|
|
