Читать онлайн «C# 4.0 полное руководство - 2011». Страница 20

// Продемонстрировать приведение типов.

using System;

class CastDemo {

static void Main() { double x, y; byte b; int i; char ch; uint u; short s; long 1;

x = 10.0;

У = 3.0;

11 Приведение типа double к типу int, дробная часть числа теряется, i = (int) (х / у) ;

Console.WriteLine("Целочисленный результат деления х / у: " + i) ; Console.WriteLine();

// Приведение типа int к типу byte без потери данных, i = 255; b = (byte) i;

Console.WriteLine("b после присваивания 255: " + b +

" -- без потери данных.");

// Приведение типа int к типу byte с потерей данных, i = 257; b = (byte) i;

Console.WriteLine("b после присваивания 257: " + b +

" — с потерей данных.");

Console.WriteLine();

// Приведение типа uint к типу short без потери данных, и = 32000; s = (short) u;

Console.WriteLine("s после присваивания 32000: " + s + " — без потери данных.");

// Приведение типа uint к типу short с потерей данных, и = 64000; s = (short) u;

Console.WriteLine("s после присваивания 64000: " + s + " — с потерей данных. ") ;

Console.WriteLine();

// Приведение типа long к типу uint без потери данных.

1 = 64000; u = (uint) 1;

Console.WriteLine("и после присваивания 64000: " + u +

" -- без потери данных.");

// Приведение типа long к типу uint с потерей данных.

1 = -12; u = (uint) 1;

Console.WriteLine("и после присваивания -12: " + u +

" — с потерей данных.");

Console.WriteLine();

// Приведение типа int к типу char, b = 88; // код ASCII символа X ch = (char) b;

Console.WriteLine("ch после присваивания 88: " + ch);

}

}

Вот какой результат дает выполнение этой программы.

Целочисленный результат деления х / у: 3

b после присваивания 255: 255 -- без потери данных.

Ь после присваивания 257: 1 — с потерей данных.i

s после    присваивания    32000:    32000    --    без потери данных,

s после    присваивания    64000:    -1536    --    с потерей данных.

и после-присваивания    64000:    64000    —    без потери данных,

и после    присваивания    -12: 4294967284    -- с потерей данных.

ch после присваивания 88: X

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

Когда переменной b присваивается значение 255, то информация не теряется, поскольку это значение входит в диапазон представления чисел для типа byte. Но когда переменной b присваивается значение 257, то часть информации теряется, поскольку это значение превышает диапазон представления чисел для типа byte. Приведение типов требуется в обоих случаях, поскольку неявное преобразование типа int в тип byte невозможно.

Когда переменной s типа short присваивается значение 32 000 переменной и типа uint, потери данных не происходит, поскольку это значение входит в диапазон представления чисел для типа short. Но в следующей операции присваивания переменная и имеет значение 64 000, которое оказывается вне диапазона представления чисел для типа short, и поэтому данные теряются. Приведение типов требуется в обоих случаях, поскольку неявное преобразование типа uint в тип short невозможно.

Далее переменной и присваивается значение 64 000 переменной 1 типа long. В этом случае данные не теряются, поскольку значение 64 000 оказывается вне диапазона представления чисел для типа uint. Но когда переменной и присваивается значение -12, данные теряются, поскольку отрицательные числа также оказываются вне диапазона представления чисел для типа uint. Приведение типов требуется в обоих случаях, так как неявное преобразование типа long в тип uint невозможно.

И наконец, когда переменной char присваивается значение типа byte, информация не теряется, но приведение типов все же требуется.

Преобразование типов в выражениях

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

Преобразования типов выполняются по принятым в C# правилам продвижения типов. Ниже приведен алгоритм, определяемый этими правилами для операций с двумя операндами.

ЕСЛИ один операнд имеет тип decimal, ТО и второй операнд продвигается к типу decimal (но если второй операнд имеет тип float или double, результат будет ошибочным).

ЕСЛИ один операнд имеет тип double, ТО и второй операнд продвигается к типу double.

ЕСЛИ один операнд имеет тип float, ТО и второй операнд продвигается к типу float.

ЕСЛИ один операнд имеет тип ulong, ТО и второй операнд продвигается к типу ulong (но если второй операнд имеет тип sbyte, short, int или long, результат будет ошибочным).

ЕСЛИ один операнд имеет тип long, ТО и второй операнд продвигается к типу long.

ЕСЛИ один операнд имеет тип uint, а второй — тип sbyte, short или int, ТО оба операнда продвигаются к типу long.

ЕСЛИ один операнд имеет тип uint, ТО и второй операнд продвигается к типу uint.

ИНАЧЕ оба операнда продвигаются к типу int.

Относительно правил продвижения типов необходимо сделать ряд важных замечаний. Во-первых, не все типы могут смешиваться в выражении. В частности, неявное преобразование типа float или double в тип decimal невозможно, как, впрочем, и смешение типа ulong с любым целочисленным типом со знаком. Для смешения этих типов требуется явное их приведение.

Во-вторых, особого внимания требует последнее из приведенных выше правил. Оно гласит: если ни одно из предыдущих правил не применяется, то все операнды продвигаются к типу int. Следовательно, все значения типа char, sbyte, byte, ushort и short продвигаются к типу int в целях вычисления выражения. Такое продвижение типов называется целочисленным. Это также означает, что результат выполнения всех арифметических операций будет иметь тип не ниже int.

Следует иметь в виду, что правила продвижения типов применяются только к значениям, которыми оперируют при вычислении выражения. Так, если значение переменной типа byte продвигается к типу int внутри выражения, то вне выражения эта переменная по-прежнему относится к типу byte. Продвижение типов затрагивает только вычисление выражения.

Но продвижение типов может иногда привести к неожиданным результатам. Если, например, в арифметической операции используются два значения типа byte, то происходит следующее. Сначала операнды типа byte продвигаются к типу int. А затем выполняется операция, дающая результат типа int. Следовательно, результат выполнения операции, в которой участвуют два значения типа byte, будет иметь тип int. Но ведь это не тот результат, который можно было бы с очевидностью предположить. Рассмотрим следующий пример программы.

// Пример неожиданного результата продвижения типов!

using System;

class PromDemo {

static void Main() { byte b;

b = 10;

b = (byte) (b * Ь); // Необходимо приведение типов!!

Console.WriteLine("b: "+ b);

}

}

Как ни странно, но когда результат вычисления выражения b*b присваивается обратно переменной Ь, то возникает потребность в приведении к типу byte! Объясняется это тем, что в выражении b*b значение переменной b продвигается к типу int и поэтому не может быть присвоено переменной типа byte без приведения типов. Имейте это обстоятельство в виду, если получите неожиданное сообщение об ошибке несовместимости типов в выражениях, которые, на первый взгляд, кажутся совершенно правильными.

Аналогичная ситуация возникает при выполнении операций с символьными операндами. Например, в следующем фрагменте кода требуется обратное приведение к типу char, поскольку операнды chi и ch2 в выражении продвигаются к типу int.

char chi = 'a', ch2 = 'b1;

chi = (char) (chi•+ ch2);

Без приведения типов результат сложения операндов chi и ch2 будет иметь тип int, и поэтому его нельзя присвоить переменной типа char.

Продвижение типов происходит и при выполнении унарных операций, например с унарным минусом. Операнды унарных операций более мелкого типа, чем int (byte, sbyte, short и ushort), т.е. с более узким диапазоном представления чисел, продвигаются к типу int. То же самое происходит и с операндом типа char. Кроме того, если выполняется унарная операция отрицания значения типа uint, то результат продвигается к типу long.