0.5.Типы данных и точность вычислений

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

Integer и Long - целые числа

Создайте проект с кнопкой и введите такую программу:

Dim a As Integer

Dim b As Integer

Private Sub Command1_Click()

a = 100

b = 1

Debug.Print a, b, a + b

End Sub

Работает она нормально. Посмотрим, насколько большие числа способна воспринимать наша программа. Заменим b=1 на b=40000. Visual Basic выдает сообщение об ошибке "Overflow", что означает "Переполнение ячейки". В чем дело?

Как вы уже знаете, в Visual Basic принято правило, что если человек объявил переменную, как Integer, то он разрешает ей принимать значения только целых чисел. Число типа Integer занимает в памяти два байта. Значит, под переменные а и b компьютер отводит в памяти ячейки по два байта каждая. Два байта - это маленький объем памяти и уместиться в него может лишь небольшое целое число, а именно - число в диапазоне от -32768 до 32767.

Для того, чтобы переменная имела право принимать значения больших целых чисел, она должна быть объявлена не как Integer, а как Long (Длинное Целое). Под переменную типа Long компьютер отводит в памяти 4 байта и поэтому она может принимать значения в диапазоне от ‑2147483648 до 2147483647.

Зачем нужен Integer, если есть Long? Ну, хотя бы для того, чтобы экономить память, она же не резиновая.

Задание 10: Население Москвы равняется а=9000000 жителей. Население Васюков равняется b=1000 жителей. Вся Москва переехала в Васюки. Сколько там стало жителей? Используйте переменные величины.

Single и Double - десятичные дроби

Создайте проект с кнопкой и введите такую программу:

Dim a As Single

Dim b As Single

Private Sub Command1_Click()

a = 100.78656954325 : b = 40000.1234567895 : Debug.Print a, b, a + b

End Sub

Запустите проект. Вот результат:

100,7866 40000,13 40100,91

Как видите, Visual Basic обрезал наши длинные числа до 7 значащих цифр. Сделал он это потому, что 4 байта, отведенные под ячейку памяти для переменной типа Single, не в состоянии вместить больше. Если мы хотим иметь большую точность, то объявляем наши переменные имеющими другой тип - Double - десятичная дробь двойной точности. Под переменную типа Double компьютер отводит в памяти 8 байтов и поэтому она может быть гораздо длиннее.

Dim a As Double

Dim b As Double

Private Sub Command1_Click()

a = 100.78656954325 : b = 40000.1234567895 : Debug.Print a, b, a + b

End Sub

Запустите проект. Вот результат:

100,78656954325 40000,1234567895 40100,9100263327

Здесь максимум - 15 значащих цифр. Если вам интересно задать в программе еще более длинное значение b, например, b = 40000.12345678957453457, то у вас ничего не получится, Visual Basic обрежет его прямо в программе, зная, что с такими длинными числами работать он все равно не умеет.

Зачем нужен Single, если есть Double? Ну хотя бы для экономии памяти.

Целые числа или десятичные дроби? Числовой тип Currency

Вы спросите: зачем использовать типы целых чисел Integer и Long, если типы десятичных чисел Single и Double обеспечивают нам работу и с целыми и с дробными числами? Кроме экономии памяти здесь есть еще проблема абсоютной точности вычислений. Дело в том, что при использовании типов десятичных дробей вполне мыслима ситуация, когда дважды два будет не точно 4, а, скажем, 4.00000000000381. Связано это с особенностями представления десятичных дробей в компьютерах. В большинстве реальных задач такая маленькая погрешность несущественна, однако существуют задачи, где точность нужна абсоютная. При использовании же типов целых чисел Visual Basic присматривает за тем, чтобы все числа и результаты были абсолютно точными целыми числами. Конечно, при делении в этом случае приходится округлять.

Если вам нужна абсолютная точность при работе с числами, а величина чисел превышает два миллиарда, тип Long будет слишком узок для вас. Воспользуйтесь типом Currency. Этот тип хоть и имеет дробную часть в размере 4 десятичных знаков после запятой, действия над числами выполняет абсолютно точно. Диапазон представляемых им величин весьма велик - примерно от -900 000 000 000 000 до 900 000 000 000 000.

Совет: Если вам необходимо, чтобы переменная была целым числом и никогда дробным, объявляйте ее целым типом, в противном случае - десятичным.

Не очень устаревшие способы объявления переменных

"Я советую всем нарочно написать на бумаге Испания, то и выйдет Китай"

Гоголь

Вы еще не столкнулись со странной привычкой Visual Basic ставить после чисел в окне кода какие-то значки? Например, вы не объявляли переменную a и собираетесь написать a = 123456789012345, получается же a = 123456789012345#. Ничего страшного, не обращайте внимания, это Visual Basic сообщает вам, что с его скромной точки зрения переменная a имеет тип Double.

У шести типов есть свои значки, по которым их можно узнать (тип String еще не проходили):

Integer	Long	Single	Double	String	Currency
%	&	!	#	$	@

Дальше. Если вам лень писать Dim b As Double, вам достаточно в окне кода, там, где переменная b встречается в первый раз, написать b# вместо b, например, b# = 5 вместо b=5. Visual Basic будет считать, что вы нормально объявили переменную. Впрочем, этот способ объявления мне не нравится.

Есть еще один способ объявления, совсем страшный. Написав DefInt I - M, вы тем самым объявите компьютеру, что переменнные, имена которых начинаются с букв I, J, K, L, M, N, обязаны иметь тип Integer. Ну и для других типов аналогично: DefLng, DefSng, DefDbl и так далее.

Форматирование результата

Взгляните на такую программу:

Dim a As Double

Dim b As Double

Dim y As Double

Private Sub Command1_Click()

a = 2457642345034.78 : b = 0.00000000037645 : y = a / b : Debug.Print y

End Sub

Прикиньте без компьютера, каков будет результат. Ясно, что очень большое число, но какое - неясно. Запустите программу. Вот результат:

6,52846950467467E+21

Что это значит? Это значит, что Visual Basic, видя, что вы работаете с такими гигантскими числами, подумал, что вы большой ученый, и представил вам результат не в нормальном, как для простых смертных, а в так называемом экспоненциальном или научном формате (виде). Но не так страшен черт. Оказывается, это получается шесть целых и сколько-то там дробных и все это умножено на 10 в 21-й степени. Конструкция Е+21 и означает умножение на 10²¹. По-другому, вам нужно передвинуть запятую на 21 позицию направо - и получится нормальное число, то есть 6528469504674670000000. Кстати, о точности. Обратите внимание, что поделено было неточно. Точно получилась бы бесконечная периодическая дробь, а где ее хранить, бесконечную?

Если бы вместо Е+21 было Е-21, это означало бы умножение на 10^-21, то есть деление на 10²¹, то есть передвижение запятой на 21 позицию налево, то есть очень маленькое число.

Если после этих объяснений вы все еще не полюбили экспоненциальный формат, вы можете приказать компьютеру, чтобы он вас им не утомлял, а показывал результаты по-человечески. Для этого в операторе Debug.Print нужно вместо y написать Format(y, "0.0000"). Получится Debug.Print Format(y, "0.0000"). Конструкция в кавычках состоит из нулей и точки и означает, что вы желаете видеть число в обычном виде, дробную часть числа состоящей ровно из 4 цифр, а остальные пусть Visual Basic вам не показывает. Целую же часть числа Visual Basic покажет вам полностью в любом случае, какова бы она ни была. Вот тот же результат в новом формате:

6528469504674670000000,0000

Вот вам и первое улучшение для калькулятора, ведь он тоже норовит показывать длинные результаты в экспоненциальном формате. Вместо

Результат.Text = Val(Число1.Text) / Val(Число2.Text)

можете написать

Результат.Text = Format(Val(Число1.Text) / Val(Число2.Text), "0.00000000000000000000")

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

Еще о пользе переменных

Значения переменных величин не обязаны, подобно надписям и значениям текстовых полей, отображаться "на медлительной поверхности проекта". Они спрятаны глубоко в сверхбыстрой оперативной памяти компьютера, там над ними удобно и быстро проводить вычисления и разнообразные логические преобразования. Фактически вся мыслительная работа компьютера проводится над переменными величинами. И лишь иногда, когда человеку понадобится, они показываются "на поверхности" в виде содержимого текстовых полей или как-нибудь еще.

Создавая калькулятор, мы не ведали ни о каких переменных, поэтому вместо изящного

Рез = Чис1 + Чис2

писали громоздкое

Результат.Text = Val(Число1.Text) + Val(Число2.Text)

Вообще, попытки использовать для вычислений вместо переменных текстовые поля напоминает попытку неуклюжих королей-тугодумов (текстовых полей) договориться между собой. После безуспешных попыток они вызывают своих шустрых министров иностранных дел (переменные величины), которые в два счета договариваются и отдают готовый договор на подпись королям (имеется в виду, что результат вычислений показывается в текстовом поле).

С учетом сказанного попробуем улучшить программу калькулятора:

Dim Чис1 As Double 'Переменная, содержащая число из текстового поля Число1

Dim Чис2 As Double 'Переменная, содержащая число из текстового поля Число2

Dim Рез As Double 'Переменная-результат, предназначенный для текстового поля Результат

_____________________________________________________________________________

Private Sub Кл_сложения_Click()

Чис1 = Число1.Text 'Значения исходных данных переходят в переменные из текстовых полей

Чис2 = Число2.Text

Рез = Чис1 + Чис2 'Обработка переменных для получения результата

Результат.Text = Рез 'Значение результата переходит из переменной в текстовое поле

End Sub

Эта схема, когда информация из текстовых полей (или других средств задания исходных данных) передается в переменные, затем обрабатывается, а затем из переменных передается обратно - в текстовые поля - весьма разумна и я рекомендую ей пользоваться.