Преобразование типов

Ранее в книге уже показывалось, что все данные, независимо от типа, представляют собой последовательность битов, т.е. последовательность нулей и единиц. Предназначение переменной определяет способ, которым эти данные интерпретируются. Наиболее простым примером является тип char. Этот тип представляет символ из набора символов Unicode с использованием числа. На самом деле он сохраняется в точности так же, как тип ushort, поскольку они оба могут хранить числа в диапазоне от О до 65 535.

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

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

□ Неявное преобразование. Применяется, когда преобразования из типа А в тип В возможно при любых обстоятельствах, и правила для выполнения преобразования являются достаточно простыми для того, чтобы его можно было доверить компилятору.

□ Явное преобразование. Применяется тогда, когда преобразование из типа А в тип В возможно только при определенных обстоятельствах или когда правила для преобразования являются достаточно сложными для того, чтобы было выгодным использование дополнительной обработки.

Неявное преобразование

Неявное преобразование не требует от разработчика ни приложения усилий, ни написания дополнительного кода. Рассмотрим приведенный ниже код:

varl = var2;

Эта операция присваивания может как подразумевать неявное преобразование, если тип var2 может быть неявно преобразован в тип varl, так и не подразумевать, если типы обеих переменных одинаковы. Например, значения ushort и char являются по существу взаимозаменяемыми, поскольку оба этих типа позволяют хранить числа в диапазоне от О до 65 535. Поэтому между ними может осуществляться неявное преобразование, как показано в следующем коде:

ushort destinationVar; char sourceVar = a; destinationVar = sourceVar;

Console.WriteLine( значение sourceVar: {0} , sourceVar); Console.WriteLine( значение destinationVar: {0} , destinationVar);

Здесь значение, хранящееся в sourceVar, помещается в destinationVar, а вывод переменных с помощью двух команд Console .WriteLine () приводит к отображению на экране следующего результата:

значение sourceVar: а значение destinationVar: 97

Хотя в этих двух переменных хранится одинаковая информация, интерпретируются они разными способами, зависящими от их типа.

Неявное преобразование поддерживается между многими простыми типами; типы bool и string не поддерживают ни одного варианта, но зато числовые типы имеют их несколько. Для справки в табл. 5.1 перечислены все числовые преобразования, которые компилятор может делать неявно (помните, что значения типа char сохраняются как числа, потому тип char тоже считается числовым).

Таблица 5.1. Неявные числовые преобразования

Тип Может быть безопасно преобразован в тип

Byte short, ushort, int, uint, long, ulong, float, double, decimal

Sbyte short, int, long, float, double, decimal

Short int, long, float, double, decimal

Ushort int, uint, long, ulong, float, double, decimal

Irit long, float, double, decimal

Uint long, ulong, float, double, decimal

Long float, double, decimal

Ulong float, double, decimal

Float double

Char ushort, int, uint, long, ulong, float, double, decimal

He волнуйтесь, учить эту таблицу наизусть не нужно, поскольку процесс вычисления того, какие операции преобразования компилятор может выполнять неявно, на самом деле выглядит довольно просто. В главе 3 приводилась таблица с перечнем всех возможных значений для каждого простого числового типа. Правило касательно неявного преобразования этих типов гласит, что любой тип А, диапазон возможных значений которого полностью вписывается в диапазон возможных значений типа В, может преобразовываться в этот тип неявным образом.

Объясняется это очень просто. При попытке уместить в переменную значение, выходящее за пределы диапазона значений, которые переменная этого типа может принимать, обязательно возникнет проблема. Например, переменная типа short способна хранить числа до 32 767, а максимальным значением, которое может сохраняться в переменной типа byte, является 255, поэтому при попытке преобразовать значение short в byte, естественно, могут возникнуть проблемы. В частности, в случае, если значением в переменной short окажется число в диапазоне от 256 до 32 767, тогда оно просто не поместится в переменную byte.

Если известно, что значение в переменной типа short будет меньше 255, можно ли его в таком случае преобразовать? Простым ответом, будет, конечно же, да, а более сложным - можно, но с использованием явного преобразования. Явное преобразование означает взятие ответственности за то, что произойдет, на себя.

Явное преобразование

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

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

Например, ниже приведен измененный код из предыдущего раздела, в котором предпринимается попытка преобразовать значение short в byte:

byte destinationVar; short sourceVar = 7;

destinationVar = sourceVar;

Console.WriteLine( значение sourceVar: {0} , sourceVar); Console.WriteLine( значение destinationVar: {0} , destinationVar);

При попытке скомпилировать этот код будет выдана следующая ошибка:

Cannot implicitly convert type short to byte. An explicit conversion exists (are you missing a cast?)

He удается неявным образом преобразовать тип short в byte. Возможно выполнение явного преобразования (может быть, пропущено приведение?)

К счастью для разработчиков, компилятор С# способен выявлять недостающие операции явного преобразования типов.

Чтобы этот код компилировался, в него необходимо добавить код, выполняющий явное преобразование. Наиболее простой способ предусматривает приведение переменной типа short к типу byte (как и было предложено в сообщении об ошибке). Операция приведения, по сути, заключается в принудительном преобразовании данных из одного типа в другой и подразумевает использование следующего простого синтаксиса:

(целевой тип) исходная переменная

Это строка кода позволяет преобразовывать значение, содержащееся в sourceVar, в значение типа destinationType.

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

С помощью этого синтаксиса изменить пример так, чтобы он предусматривал выполнение принудительного преобразования из short в byte, можно следующим образом:

byte destinationVar; short sourceVar = 7; destinationVar = (byte) sourceVar;

Console.WriteLine( значение sourceVar: {0} , sourceVar); Console.WriteLine( значение destinationVar: {0} , destinationVar);

После этого вывод будет выглядеть так:

значение sourceVar: 7 значение destinationVar: 7

А что будет происходить при попытке принудительно преобразовать значение переменной в такое, в которое оно не сможет уместиться? Изменим предыдущий код, как показано ниже:

byte destinationVar; short sourceVar = 281;

destinationVar = (byte)sourceVar;

Console.WriteLine( значение sourceVar: {0} , sourceVar); Console.WriteLine( значение destinationVar: {0} , destinationVar);