|
|
Главная » 2010 » Февраль » 10 » Переменные
|
Переменные
Как упоминалось во введении к этой главе, переменные тесно связаны с хране-
нием данных. По существу, переменные в памяти компьютера можно представить
в виде коробочек, лежащих на полке. Такие коробочки могут использоваться для
того, чтобы что-нибудь в них класть, а затем вынимать обратно, или же можно
просто заглянуть в них и узнать, есть там что-то или нет. Все это относится и к пе-
ременным, в которые мы можем помещать данные, а затем брать их оттуда или
просматривать по мере необходимости.
Хотя все данные в компьютере фактически представляют собой одно и то же
(последовательность, состоящую из нулей и единиц), переменные могут отличаться
друг от друга, образуя так называемые типы. Возвращаясь к нашей аналогии с ко-
робочками, можно представить коробочки различных размеров и форм, причем
разные объекты могут помещаться только в специально предназначенные для них
коробочки. Обоснование системы типов заключается в том, что для манипуляций
над данными различных типов могут требоваться различные методы, и, приписав
переменным конкретные типы, мы можем избежать серьезной путаницы. Ведь вряд
ли получится что-то осмысленное, если рассматривать последовательность нулей
и единиц, представляющую собой оцифрованное изображение, в качестве звуково-
го файла.
Для того чтобы использовать переменную, необходимо ее объявить. Это озна-
чает, что ей должны быть присвоены имя и тип. Как только переменная объяв-
лена, она может использоваться как хранилище для данных того типа, который
указан в ее объявлении.
Синтаксис объявления переменных в С# состоит из указания типа переменной
и ее имени:
<тип> <имя>;
Если попытаться использовать переменную, которая не была объявлена, то
программа не будет откомпилирована. Однако в этом случае компилятор сможет
точно указать, в чем именно заключается проблема, и поэтому такой тип ошибок
не очень опасен. Попытка использовать переменную, которой не присвоено ника-
кого значения, тоже приведет к ошибке; в этом случае компилятор также сможет
точно установить причину ее возникновения.
Итак, какие типы можно использовать?
На самом деле существует бесконечное множество типов, которые можно ис-
пользовать, так как мы имеем возможность описывать свои собственные типы,
предназначенные для хранения любых самых "хитрых" данных.
Однако существуют определенные типы данных, которые раньше или позже по-
требуются всем, например, переменные, в которых могут храниться числа. По этой
причине существует некоторое количество простых, предварительно описанных ти-
пов данных, с которыми мы сейчас и начнем знакомиться.
Простые типы
Простые типы — это такие типы значений, как численные или логические (true
(истина) или false (ложь)), которые являются фундаментальными составными час-
тями любых приложений, а также других, более сложных типов. Большинство из
имеющихся в нашем распоряжении типов являются численными, что на первый
взгляд выглядит несколько странно: разве для хранения чисел не достаточно одно-
го типа?
26 Глава 3
Причина такого изобилия численных типов кроется в способе хранения чисел
в памяти компьютера как последовательности нулей и единиц. В случае целых зна-
чений мы используем несколько бит (отдельных цифр, которые могут принимать
значение нуля или единицы) и просто представляем число в двоичном формате.
Переменная, в которой может храниться N бит, позволяет представлять любые чис-
ла в диапазоне от 0 до (2N - 1). Числа, превышающие последнее значение, оказыва-
ются слишком большими и не могут быть размещены в переменной данного типа.
В качестве примера давайте рассмотрим переменную, в которой может хранить-
. - ся 2 бита. Соответствие между целыми числами и их двоичным представлением
в этом случае будет следующим:
0 = оо
1 = 01
2 = ю
3 = 11
Если нам необходимо хранить большие числа, то для этого потребуется боль-
шее количество бит (3 бита, например, позволят хранить числа, лежащие в диапа-
зоне от 0 до 7).
Отсюда неизбежно следует вывод о том, что хранение произвольного числа тре-
бует бесконечного количества бит, что, безусловно, неприемлемо для персонального
компьютера. Но даже если бы необходимое количество бит и имелось, использо-
вать такой объем памяти для числа, изменяющегося, скажем, от 0 до 10, было бы
крайне неэффективно (из-за неиспользуемой памяти). В данном случае вполне до-
статочно 4 бит, которые позволяют разместить в одной и той же области памяти
все числа указанного диапазона.
Именно для этого существует несколько целых типов, которые могут быть ис-
пользованы для хранения чисел из различных диапазонов и которые занимают раз-
личный объем памяти (вплоть до 64 битов). Эти типы целых чисел сведены
в таблицу, приводимую ниже.
Обратите внимание, что каждый тип использует один
из стандартных типов, определенных в .NET Framework.
Как уже упоминалось в главе 1, применение стандартных
типов — это как раз то, что делает возможным совместное
использование различных языков программирования.
Имена, которые используются для этих типов в С#,
обозначают определенные типы, описанные в .NET Framework.
В таблице приводятся имена типов и указывается, какому
типу в библиотеке .NET Framework они соответствуют.
Тип Тип .NET Framework Допустимые значения
Целое в диапазоне от -128 до 127
Целое в диапазоне от 0 до 255
Целое в диапазоне от -32 768 до 32 767
Целое в диапазоне от 0 до 65 535
Целое в диапазоне от -2 147 483 648 до 2 147 483 647
Целое в диапазоне от 0 до 4 294 967 295
Целое в диапазоне от -9 223 372 036 854 775 808
до 9 223 372 036 854 775 807
Целое в диапазоне от 0 до 18 446 744 073 709 551 615
sbyte
byte
short
ushort
int
uint
long
ulong
System.SByte
System.Byte
System.Int16
System. Uint 16
System.Int32
System. Uint 32
System.Int64
• System.UInt64
Переменные и выражения 27
Буква "и", встречающаяся перед некоторыми из имен, является сокращением
от слова "unsigned" ("без знака"). Это говорит о том, что в переменных соответст-
вующего типа не могут храниться отрицательные значения. Этот факт отражен
в столбце "Допустимые значения".
Естественно, что кроме целых чисел нам требуется хранить значения с плаваю-
щей запятой, которые представляют нецелые числа. Существует три типа пере-
менных с плавающей запятой, которые мы можем использовать: float, double
и decimal. Первые два из них хранят числа с плавающей запятой в виде +/-m x 2е,
причем диапазон допустимых значений m и е для каждого типа свой. Тип decimal
использует альтернативную форму представления чисел +/-m x юе . Эти три типа
приводятся ниже вместе с допустимыми значениями m и е и диапазонами действи-
тельных чисел:
Е
. 1 1
о
I
о5
ф
о
I I
s $
2 5
2 Ф
§ 1
float
double
decimal
System.Single
System.Double
System.Decimal
0
0
0
224
253
296
-149
-1075
-26
104
970
0
1,5 xlO~45
5,0 xlO"3 2 4
1,0 xlO"28
3,4 xlO3 8
1,7 xlO3 0 8
7,9 xlO2 8
Кроме численных типов, существует еще три простых типа:
Тип Тип .NET Framework Диапазон допустимых значений
char
bool
string
System.Char
System.Boolean
System.String
Отдельный символ в кодировке Unicode, хранящийся в виде
целого числа в диапазоне от 0 до 65 535
Логическое значение (Boolean), которое может принимать
значения true (истина) или false (ложь)
Последовательность символов
Обратите внимание, что верхней границы количества символов, составляющих
строки типа string, не существует, поскольку они могут занимать изменяющиеся
объемы памяти.
Логический тип bool — один из наиболее часто используемых в С# типов пе-
ременной; аналогичные типы часто встречаются в кодах на других языках програм-
мирования. Использование переменной, которая может принимать только два
значения — либо true, либо false,— создает очень важную возможность ветвле-
ния логики приложения. В качестве простого примера представьте себе, какое
огромное количество вопросов допускают в качестве ответа true или false ("да"
или "нет"). Сравнение значений переменных и проверка допустимости введенной
информации как раз представляют собой примеры программного использования
логических переменных (эти примеры вскоре станут предметом нашего изучения).
Теперь, когда мы познакомились с этими типами, давайте рассмотрим неболь-
шой пример их объявления и использования.
28 Глава 3
Практикум: использование переменных простых типов
1. Создайте новое консольное приложение с именем ch03Ex0i
В директории C:\BegCSharp\Chapter3.
2. Добавьте следующий код в ciassi.cs (и уберите строки с комментариями):
static void Main (string [] args)
{
int my Integer; :••••.•.•••: •.. ••:•. ,.
string myString;
myInteger =17;
myString - "\*nty Integer \ " is";
Console.WriteLine(*{0} {1}.", myString, rnylnteger);
3. Выполните программу (не забудьте, что при выполнении программы
в режиме отладки окно консольного приложения закроется быстрее,
чем вы сможете понять, что произошло):
C:\BegCSharp\Chapter3\Ch03EH01\bin\Debyq\
"rotjlinteger** is 17*
Press any key to continue^
Как это работает
Код, который мы ввели, выполняет три действия:
• Объявляет две переменные.
• Присваивает этим переменным значения.
• Выводит значения этих двух переменных на консоль.
Объявление переменных осуществляет следующий код:
int myInteger;
string myString;
В первой строке объявляется переменная типа int с именем myinteger, а во
второй строке объявляется переменная типа string с именем myString.
Запомните, что выбор имен для переменных имеет
свои ограничения и нельзя использовать любую произвольную
последовательность символов. Этот вопрос будет рассмотрен
в разделе, посвященном именованию переменных.
В следующих двух строках кода происходит присваивание значений:
myinteger = 17;
myString = "X'mylntegerV is" ;
В данном случае происходит присваивание переменным двух фиксированных
значений (известных под названием литеральных значений) посредством оператора
присваивания — (более близко мы познакомимся с операторами в разделе "Выра-
жения" этой главы). Мы присваиваем целое значение 17 переменной myinteger,
Переменные и выражения 29
а строку "myinteger* is (включая кавычки) переменной mystring. Обратите вни-
мание, что когда мы присваиваем строковые литеральные значения таким спосо-
бом, строка должна обрамляться двойными кавычками. При этом существуют
определенные символы (например, символ двойных кавычек), включение которых
в строку может привести к возникновению некоторых проблем; поэтому необходимо
избегать появления ряда символов путем их замены на некоторую последователь-
ность символов (так называемую escape-последовательность), которая обозначает
символ, который нам нужен. В данном примере мы используем последователь-
ность символов \п для того, чтобы избежать появления двойных кавычек внутри
переменной:
myString = *\*mylnteger\" is";
Если бы мы не стали пользоваться этими escape-последовательностями и по-
пытались бы записать данный оператор следующим образом:
myString = ""myInteger" is";
это привело бы к ошибке при компиляции.
Здесь необходимо обратить внимание на то, что присваивание литеральных
строк — это еще одна ситуация, при которой необходимо соблюдать аккуратность
в использовании символов конца строки: компилятор С# не воспринимает литераль-
ные строки, располагающиеся более чем на одной строке программы. Если нам
требуется включить в строку символ конца строки, то в этом случае мы можем
воспользоваться escape-последовательностью для символа возврат каретки \п. На-
пример, полученная в результате следующего присваивания строка:
myString = "Данная строка содержит \псимвол конца строки.*;
будет выводиться на консоли в виде двух строк:
Данная строка содержит
символ конца строки.
Любая escape-последовательность состоит из символа обратного слэша, за ко-
торым следует еще один символ из весьма ограниченного множества символов
(с этим множеством мы познакомимся немного позднее). Поскольку символ обрат-
ного слэша используется для такой специфической цели, то для него существует
своя собственная escape-последовательность, которая представляет собой просто
последовательность из двух обратных слэшей — \\.
Возвращаясь к нашему коду, мы видим еще одну строку, которую пока еще не
рассматривали:
Console.WriteLine("{0} {1}.*, myString, mylnteger);
Эта строка напоминает тот простой метод вывода текста на консоль, которым
мы воспользовались в нашем первом примере, но на этот раз мы выводим пере-
менные. Поскольку нет необходимости бежать впереди паровоза, на данном этапе
мы не будем слишком глубоко вдаваться в подробности, касающиеся этой строки
кода. Достаточно сказать, что этим способом мы будем пользоваться на протяже-
нии всей первой части книги для вывода текста в консольное окно. Внутри скобок
имеются два элемента:
• Строка
• Список переменных, значения которых мы хотим включить
в выходную строку, разделенные запятыми
30 Глава 3
Строка, которую мы выводим — '{0} {1}.*,— не производит впечатления
очень полезного текста. Однако, как вы можете заметить, это вовсе не тот текст,
который выводится при запуске приложения. Причина заключается в том, что эта
строка в действительности является неким шаблоном, в который вставляется со-
держимое переменной. Каждый комплект фигурных скобок в этой строке представ-
ляет собой зарезервированное место, в котором будет размещаться содержимое
всех переменных, перечисленных в списке. Каждое такое зарезервированное место
(или форматная строка) имеет вид целого числа, заключенного в фигурные скобки.
Эти целые числа имеют значения, начинающиеся с 0 и увеличивающиеся на 1,
а суммарное количество таких мест должно соответствовать общему числу пере-
менных, указанных в следующем за строкой списке через запятую. Когда происхо-
дит вывод текста на консоль, в каждое из зарезервированных мест помещается
значение соответствующей переменной. В примере, приведенном выше, {0} заме-
няется на фактическое значение первой переменной — mystring, a {1} заменяется
на содержимое mylnteger.
Этим методом мы впредь будем пользоваться для вывода на консоль текста из
наших следующих программ.
|
|
Категория: информатика |
Просмотров: 1083 |
Добавил: basic
| Рейтинг: 0.0/0 |
|
Статистика
Онлайн всего: 1 Гостей: 1 Пользователей: 0
|