Объектно-ориентированное программирование.-7

x1 == y1

ref x1 != ref y1

x2 = System.Object; y2 = System.Object

x2 == y2

ref x2 == ref y2

Итак, по умолчанию целые переменные равны нулю (и имеют соответствующее строковое представление), а строковое представление экземпляров класса System.Object содержит имя данного класса. Поэтому x1 = y1 и x2 = y2. Но экземпляры класса int хранят свои данные в разных ячейках памяти на стеке, поэтому и ссылки на них не совпадают. А экземпляры класса Object ссылаются на один и тот же объект.

И последний из рассматриваемых методов, пятый метод класса Object, возвращает метакласс типа. Метаданные – это данные о данных, а метакласс, соответственно – это класс, инкапсулирующий сведения о другом классе. О метаданных мы будем говорить в § 5.3.

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

Пример: Samples\3.1\3_1_1_object.

3.1.2. Типы данных по значению

Отметим следующие особенности типов данных по значению:

1)Данные, как и в языке C++, хранятся на стеке;

2)Размещаются в памяти гораздо быстрее;

3)Автоматически удаляются при выходе из зоны видимости;

4)Только для данных фиксированной длины.

Типы по значению разделяются на простые типы, перечисляемые (Enum), обнуляемые (Nullable) типы и типы структуры. К простым типам от-

носятся целые типы (SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64),

типы с плавающей точкой (Single, Double, Decimal), логический (булев) тип (Boolean) и символьный тип (Char). Базовым классом для всех типов по значению является класс System.ValueType, который наследуется от System.Object (см. п. 3.1.5). Новых методов этот класс не объявляет, перегружая лишь некоторые методы базового класса (в т.ч. Equals и ToString). Однако, все производные от System.ValueType классы, представляющие собой типы данных по значению, реализуют интерфейсы IComparable,

81

IFormattable, IEquatable и IConvertible (см. п. 4.9.4), поэтому обладают неко-

торыми общими членами. Также в эти классы добавлены новые члены, присущие этим типам данных (табл. 3.3).

Табл. 3.3 – Общие члены типов данных по значению

Примечания:

(1)Здесь и далее владелец – это класс, от которого данный класс наследует описываемый член, или интерфейс, член которого реализует данный класс;

(2)Перечисление TypeCode содержит коды типов объектов (табл. 3.4);

(3)Здесь <тип> – это тип данных, а <класс> – имя соответствующего ему класса .NET (например, класс Int16 – тип short);

(4)Отсутствует в классах System.Boolean и System.Enum;

(5)Только в классе System.Boolean.

Здесь и далее, если не оговорено другое, рассматриваются только открытые (public) члены классов, т.к. только к ним мы имеем доступ.

Табл. 3.4 – Символические константы перечисления TypeCode

3.1.2.1. Целые типы

Список целых типов языка C# приведен в таблице 3.5.

Как видно, каждый класс, описывающий тип, имеет более короткий псевдоним. Так, например, для описания 16-битного целого числа без знака, можно использовать тип ushort, UInt16 или System.UInt16.

Примеры описания целых переменных:

System.Int32 x; int y = 5;

ulong z = 0xfa12;

int n = new Int32(); // 0

В первой строке объявлена переменная x, являющаяся 32-битным целым со знаком. Она не инициализирована, поэтому попытка вызвать какиелибо методы класса System.Int32 или попытка присвоить x другой переменной вызовет ошибку компиляции:

n = x; // ошибка – использование локальной переменной, // которой не присвоено значение

Console.WriteLine(x.ToString()); // то же самое

Во второй строке объявляется переменная y такого же типа. Для ее инициализации используется константа 5. Переменная z, 64-битное целое без знака, инициализирована шестнадцатеричной константой. Как и в языке C++, такие константы начинаются с префикса «0x» или «0X». Переменная n инициализирована конструктором по умолчанию. Это эквивалентно инициализации нулем. Следующие варианты инициализации приводят к одинаковому результату:

int n1 = new System.Int32(); int n2 = new Int32();

int n3 = new int(); int n4 = 0;

Как и в C++, любая целая константа относится к типу int. При необходимости она неявно преобразуется к требуемому типу. Если необходимо явно указать тип целой константы, используются суффиксы:

123 – int

123U – uint

123L – long 123UL – ulong

Регистр суффиксов не важен, буквы U и L для типа ulong можно пере-

85

ставлять местами.

Однако, компилятор принимает во внимание значение самой константы. Так, константа 4000000000 будет иметь тип uint, т.к. ее значение выходит за пределы типа int. Если значение будет выходить за пределы типа uint, будет использован тип long, а если и его диапазона не хватит – ulong.

3.1.2.2. Типы с плавающей точкой

Список типов с плавающей точкой языка C# приведен в таблице 3.6.

Табл. 3.6 – Типы с плавающей точкой

Все, сказанное выше для целых типов данных, верно и для типов с плавающей точкой. Примеры описания переменных:

System.Single s = 12.3f; double d = 12.3;

decimal m = 12.3m;

Опять же, как и в языке C++, константа с плавающей точкой по умолчанию имеет тип double. Для указания другого типа данных используются суффиксы:

Для констант типа double тоже можно использовать суффикс (d или D), но это не обязательно. Так делают, чтобы показать, что целочисленная константа должна рассматриваться как константа с плавающей точкой. Однако, того же можно добиться, добавив ей ноль после десятичного разделителя:

Если в приведенном выше примере описания переменных суффиксы не указать, то произойдет ошибка компиляции. Подробнее про явное и неявное

86

преобразование типов данных мы поговорим в п. 3.1.2.8.

Следует отметить, что для переменных с плавающей точкой доступен не весь диапазон значений – накладываются ограничения, связанные с количеством значащих цифр. Например, в переменной типа float может храниться значение 7,123456f (7 значащих цифр), а значение 7,1234567f (8 значащих цифр) – уже нет, одна цифра будет потеряна.

В типе decimal диапазон значений был уменьшен для увеличения количества значащих цифр. Т.е. больше бит отводится для мантиссы числа и меньше – для экспоненты. Чаще всего этот тип данных применяется для хранения денежных сумм.

Как известно, все числа хранятся в двоичной системе. Поэтому без погрешностей в памяти может храниться только такое нецелое число, которое является суммой степеней числа 2. Например, число 2,75 может быть сохранено без погрешности:

2,75 = 21 + 2–1 + 2–2,

а число 7,1 – нет. Убедимся в этом:

float f = 7.1f; double d = f; Console.WriteLine(f); Console.WriteLine(d);

При запуске этого кода на экране отобразятся числа:

7,1

7,09999990463257

Переменная d имеет больше значащих цифр, поэтому показывает, что на самом деле в переменной f хранится не число 7,1, а некое близкое к нему число. Число 2,75 в обоих случаях отобразилось бы одинаково.

Обратите внимание – при наборе текста программы разделителем целой и дробной части числа является точка, а при выводе на экран – символ, указанный в региональных настройках ОС. Подробнее об этом мы поговорим в § 3.2.

3.1.2.3. Логический тип

Логический тип данных представлен единственным типом (табл. 3.7).

Табл. 3.7 – Логический (булев) тип

В языке C++ многие типы данных могут быть неявно преобразованы к логическому типу. Например:

if (x)

{

// блок операторов

}

Данный код будет успешно компилироваться, если типом переменной будет bool, а также, если это будет указатель (на данные, на функцию или процедуру, на метод класса, класс, интерфейс – неважно), целый тип данных (языке C++ символьный тип также считается целым) или тип данных с плавающей точкой. Если значение переменной x равно 0 (NULL для указателей), то оно неявно преобразуется в значение false, во всех остальных случаях – в значение true. Однако, в языке C# более строгая типизация – данный код будет компилироваться только в том случае, если переменная x имеет тип bool:

int x;

if (x) // ошибка! неявное преобразование типа "int" в "bool"

//невозможно; явное тоже: при использовании (bool)x

//будет показана та же ошибка

{

// блок операторов

}

Для явного преобразования типов могут использоваться операции отношения либо специальные методы:

if (x != 0) // или if (!x.Equals(0))

{

// блок операторов

}

Символьные типы со знаком и без знака, т.е. signed char и unsigned char, имевшиеся в языке C++, в языке C# отсутствуют. Все символы пред-

88

ставляются как символы Unicode (UTF-16), представляющие собой двухбайтовые значения. Посмотреть, какой код соответствует каждому символу, можно в Таблице символов Windows (рис. 3.1).

Рис. 3.1 – Таблица символов Unicode

Открыть ее можно через меню «Пуск → Программы → Стандартные → Служебные → Таблица символов», или через меню «Пуск → Выполнить» (Win+R), набрав в нем «charmap». Далее следует в выпадающем списке наборов символов выбрать категорию Unicode.

Для инициализации переменных символьного типа можно использовать символьные литералы (как и в языке C++, заключенные в одинарные кавычки) или явное преобразование целых чисел к символьному типу:

System.Char a = 'A'; char b = (char)65; char c = '\u0041'; char d = '\x0041';

В символьных литералах также можно указывать код символа в шест-

89

надцатеричном виде с префиксом \x или \u. Все описанные переменные будут содержать большую латинскую букву A.

В настоящее время, кроме кодировки UTF-16, используются также UTF-8 и UTF-32. Первая из них позволяет уменьшить размер текста в байтах, если используются в основном символы из начала кодовой таблицы (U+0000… U+07FF). Использование второй обусловлено тем, что в настоящее время в кодировке Unicode имеется около 100 000 символов. Очевидно, что 16 бит для их представления недостаточно, поэтому был разработан стандарт UTF-32. При необходимости некоторые символы Unicode могут представляться последовательностью из двух значений типа char (т.е. 4 байтами). Кодировка UTF-8 может, теоретически, использовать до 6 байт для представления символа Unicode (см. ru.wikipedia.org/wiki, статья «Unicode»).

Также есть ряд специальных символов, впрочем, знакомых еще по C++

(табл. 3.9).

Полный список управляющих символов можно посмотреть на сайте Википедии (ru.wikipedia.org/wiki) в статье «Управляющие символы».

Помимо тех членов, что описаны в п. 3.1.2, класс Char имеет несколько других полезных членов (табл. 3.10).