Перетворення типів

Часто потрібно перетворювати дані з одного типу в іншій. Розглянемо код:

byte value1 = 10;

byte value2 = 23;

byte total;

total = valuel + value2;

//Коли додаються два значення byte, вони неявно перетворяться в int, тому спроба

// записати результат назад в byte викличе помилку

Console.WriteLine(total);

При компіляції цих рядків буде повідомлення про помилку Cannot implicitly convert type "int" to "byte" (Неможливо неявно перетворити 'int' в 'byte'). Проблема в тому, що при додаванні двох значень byte результат матиме тип int, а не byte. Це відбувається тому, що byte може містити вісім бітів даних (0 до 255), і при додаванні двох байтів можна отримати величину, яка не поміститься в один байт. Якщо необхідно все ж таки зберегти результат у змінній byte, потрібно явно перетворити результат в byte. Це може бути зроблено двома способами: неявно – компілятор виконає перетворення за нас, не питаючи підтвердження, або явно – компілятору необхідно спеціально вказати на те, щоб він перетворив дані до іншого типу.

Неявні перетворення

Перетворення типів можуть бути виконані автоматично, але тільки в тому випадку, якщо перетворюване значення не змінюється. Отже, значення short або int може бути присвоєне змінній long без проблем. Змінну без знаку можна присвоювати змінній із знаком, поки значення змінної без знаку потрапляє в допустимий діапазон для змінної зі знаком. Крім того, можуть бути виконані певні перетворення цілих типів в типи з плаваючою комою.

Попередній код не можна було виконати тому, що при перетворенні int в byte ми потенційно могли б втратити 3 байти даних. Компілятор не дозволить зробити цього, якщо тільки ми спеціально не вкажемо йому, що це саме те, чого ми добиваємося. Якщо ми збережемо результат в змінній long, а не byte, проблема зникне:

byte value1 = 10;

byte value2 = 23;

long total;

total = value1 + value2;

Console.WriteLine(total);

Тип long має більше бітів даних, чим int, тому не існує ризику втрати даних. У цих обставинах компілятор виконає перетворення за нас, тобто неявно. У таблиці приводяться неявні перетворення типів, допустимі в С#:

З У

sbyte short, int, long, float, double, decimal

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

short int, long, float, double, decimal

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

Int long, float, double, decimal

uint long, ulong, float, double, decimal

long, ulong float, double, decimal

float double

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

Відмітимо, що виконувати неявні перетворення можна тільки по відношенню до типів, які перетворяться з менших цілих типів в більші або з цілих без знаку в цілі зі знаком такого ж розміру. Це означає, що неприпустимим є перетворення з uint в int або навпаки, оскільки ці типи охоплюють різні діапазони значень, і в процесі перетворення дані можуть бути втрачені. Проте можна здійснити перетворення з uint в long, оскільки діапазон uint фактично є верхньою частиною діапазону long (від нуля і вище). Також можна перетворювати цілі числа в числа з плаваючою комою. Тут правила трохи відрізняються. Можна здійснювати перетворення між типами одного розміру, наприклад int/uint в float і long/ulong в double, і допустимо також перетворення long/ulong в float. В процесі цього можна втратити 4 байти даних, проте це всього лише означає, що величина float матиме меншу точність, ніж у разі double; значення величини взагалі не зачіпається. Перетворення float в double слідує тим же правилам що для цілих із знаком.