Локальные переменные

Материал следующих разделов этой главы сложен для восприятия и на первый взгляд непонятно, зачем он нужен. Но для уверенного плавания по океану Visual Basic он необходим. Итак, наберите побольше терпения и кислорода. Идем вглубь.

Будем называть процедуры и функции подпрограммами, так как они являются составными частями программы.

Переменные, которые объявлены в начале окна кода, могут быть использованы в любой подпрограмме этого окна. Говорят, что они видны из любой подпрограммы. Их называют локальными переменными формы.

Если же переменные объявлены внутри подпрограммы или являются параметрами подпрограммы, то они и использованы могут быть только внутри нее. Говорят, что они не видны из других подпрограмм. Их называют локальными переменными подпрограммы. О так называемых глобальных переменных поговорим позже (19.4).

Пример:

Dim a As Integer 'a - локальная переменная формы

Private Sub Проц1()

a = 1

End Sub

Private Sub Проц2()

Dim b As Integer 'b - локальная переменная процедуры

b = 2

End Sub

Private Sub Проц3(c As Integer) 'c - локальная переменная процедуры

Debug.Print c

End Sub

Private Sub Command1_Click()

Проц1

Debug.Print a

End Sub

Здесь a - локальная переменная формы, b и c - локальные переменные процедур. Вы видите, что a нормально используется в двух процедурах. Запустим проект. Щелкнем по кнопке Command1. Печатается 1. Все в порядке. Процедуры Проц2 и Проц3 здесь не работали. Они приведены только для иллюстрации.

Теперь попробуем использовать b вне процедуры Проц2. Для этого добавим к программе такую процедуру:

Private Sub Command2_Click()

Проц2

Debug.Print b 'Ошибочный оператор. Переменная b из процедуры Проц2 отсюда не видна и не будет напечатана

End Sub

Щелкнем по кнопке Command2. Вместо 2 печатается пустая строка. Также неудачей закончится попытка использования c.

Зачем такие ограничения и неудобства? Какой во всем этом смысл? Поговорим об этом.

Создание разных зон видимости для разных переменных является способом повышения надежности больших программ и понижения вероятности запутаться при их написании. Программы, создаваемые сегодня профессиональными программистами, очень велики - десятки и сотни тысяч строк. Таково, например, большинство игровых программ. Естественно, один человек не может достаточно быстро создать такую программу, поэтому пишется она обычно большой группой программистов. Для этого программа делится на части, и каждый программист пишет свою часть. И все равно, в каждой части присутствуют десятки и сотни подпрограмм с десятками и сотнями переменных, в которых человеку легко запутаться.

Исследуем взаимодействие подпрограмм в такой программе. Для этого рассмотрим бессмысленную "сложную" программу, не использующую локальных переменных подпрограмм. В ней автор озабочен вычислением переменной y и печатью переменной x:

Dim x As Integer 'x - локальная переменная формы

Dim y As Integer 'y - локальная переменная формы

Private Sub B()

y = 10 * 10

Debug.Print "Результат равен";

End Sub

Private Sub Command1_Click()

x = 5

B

Debug.Print x

End Sub

Очевидно, программа, как и хотел ее автор, напечатает:

Результат равен 5

Все хорошо. Но при большом объеме программы возникает опасность, что автор случайно использует внутри какой-нибудь подпрограммы для ее нужд имя переменной, используемой в другой подпрограмме для других нужд, и таким образом испортит ее значение. Пусть, например, в нашей процедуре В автор опрометчиво присвоил бы значение 10*10 не переменной с именем y, а переменной с именем x. Тогда эта строчка программы выглядела бы так:

x = 10 * 10

Очевидно, данная программа к неудовольствию ее автора напечатала бы

Результат равен 100

Для защиты от таких ошибок автор должен внимательно следить, чтобы разные подпрограммы не использовали переменных с одинаковыми именами. Но для больших программ этот контроль очень трудоемок и неудобен. Для того, чтобы избежать его, в современных языках программирования и разработан механизм локальных переменных. Если программист знает, что его число 10*10 нигде, кроме как в процедуре В, не нужно, он объявляет соответствующую переменную любым именем внутри процедуры В, ничуть не заботясь, что переменные с таким же именем встречаются в других местах программы, и все нормально работает:

Dim x As Integer 'x - локальная переменная формы

Private Sub B()

Dim x As Integer 'x - локальная переменная процедуры

x = 10 * 10

Debug.Print "Результат равен";

End Sub

Private Sub Command1_Click()

x = 5

B

Debug.Print x

End Sub

Данная программа к удовольствию ее автора напечатает

Результат равен 5

Произойдет это вот по какой причине: Переменные, объявленные внутри и снаружи подпрограммы или внутри разных подпрограмм, Visual Basic считает разными переменными, даже если они имеют одинаковые имена. Переменная х, объявленная снаружи подпрограммы, это совсем другая переменная, чем х, объявленная в подпрограмме, и помещаются эти переменные в разных местах памяти. Поэтому и не могут друг друга испортить. Вы можете вообразить, что это переменные с разными именами x_{локформ} и x_{локпроц}.

Переменная, объявленная внутри подпрограммы, невидима снаружи. Она локальна в этой подпрограмме. Она существует, пока работает подпрограмма, и исчезает при выходе из подпрограммы.

Переменная же, объявленная снаружи подпрограммы, видна из любой подпрограммы окна кода и каждая подпрограмма может ее испортить. Однако, когда подпрограмма натыкается на переменную x, объявленную внутри самой этой подпрограммы, то она, благодаря описанному механизму, работает только с ней и не трогает переменную x, объявленную снаружи.

Для тренировки рассмотрим еще один пример:

Dim x As Integer 'x - локальная переменная формы

Dim z As Integer 'z - локальная переменная формы

Private Sub B()

Dim x As Integer 'x - локальная переменная процедуры

Dim y As Integer 'y - локальная переменная процедуры

x = 20: y = 30: z = 40

End Sub

Private Sub Command1_Click()

x = 1: z = 2 'x и z - локальные переменные формы

B

Debug.Print x, z 'x и z - локальные переменные формы

End Sub

Программа напечатает

1 40

Пояснение: Оператор Debug.Print x, z находится снаружи процедуры В, и поэтому локальная переменная процедуры х=20, объявленная внутри В, из него не видна. Зато прекрасно видна локальная переменная формы х=1, которую он и печатает. Переменная же z не объявлена внутри В, поэтому она является локальной переменной формы, и оператор z=40 с полным правом меняет ее значение с 2 на 40.

Для полной ясности приведу порядок работы компьютера с этой программой:

В оперативной памяти Visual Basic отводит ячейки под Х локформ и Z локформ.

Процедура Command1_Click начинает выполняться с присвоения значений Х локформ = 1 и Z локформ = 2. Почему локформ, а не локпроц? Потому что переменные с именами X и Z в процедуре Command1_Click не объявлены, а значит волей-неволей процедуре приходится пользоваться локальными переменными формы.

Вызывается процедура В. При этом в оперативной памяти отводится место под Х локпроц и У локпроц.

Присваиваются значения Х локпроц = 20, У локпроц = 30 и Z локформ = 40.

Программа выходит из процедуры В. При этом исчезают переменные Х локпроц = 20 и У локпроц = 30.

Компьютер печатает Х локформ = 1 и Z локформ = 40.

Таким образом, вы видите, что смысл механизма локальных переменных - в увеличении надежности программирования. Я советую те переменные, которые наверняка не понадобятся вне процедуры, делать локальными в ней.

Статические переменные

Исчезновение значения локальной переменной при выходе из процедуры не всегда удобно. Например, если процедура предназначена для увеличения суммы, объявленной локальной переменной. Следующая процедура будет работать неверно, так как при каждом вызове процедуры сумма будет обнуляться:

Private Sub Command1_Click()

Dim Число As Integer

Dim Сумма As Integer

Число = Text1.Text

Сумма = Сумма + Число

End Sub

Чтобы она не обнулялась, объявим сумму статической переменной:

Private Sub Command1_Click()

Dim Число As Integer

Static Сумма As Integer

Число = Text1.Text

Сумма = Сумма + Число

End Sub

Теперь все в порядке.

Дата добавления: 2014-12-23