Теория
Компютърът пази всичко като битове (bit) – най-малката единица информация, която е или 0, или 1. Осем бита образуват байт (byte), а числата заемат фиксиран брой байтове според типа си: byte е 1 байт, short – 2, int – 4, long – 8. Представянето на цели числа започва от двоичната бройна система: 13 е 1101, защото 8 + 4 + 1 = 13, като позициите отдясно наляво тежат 1, 2, 4, 8, 16 и така нататък. В C# можем да пишем числата направо двоично (0b1101) или шестнадесетично (0xFF), а с Convert.ToString(x, 2) виждаме битовете на всяка стойност. С 32 бита има точно 2 на степен 32 комбинации, затова int изразява 4 294 967 296 различни числа – но кои точно, зависи от това как записваме знака.
Отрицателните числа се пазят в допълнителен код (two's complement): най-левият бит е знаков – 0 за положително, 1 за отрицателно. За да получим -x, обръщаме всички битове на x и прибавяме 1: 5 е 0000…0101, обърнато е 1111…1010, плюс 1 дава 1111…1011, което е -5. Така -1 е 32 единици, а събирането работи по една и съща схема за положителни и отрицателни – процесорът няма нужда от отделна операция за изваждане. Диапазонът на int е несиметричен: от -2 147 483 648 (int.MinValue, единица и 31 нули) до 2 147 483 647 (int.MaxValue, нула и 31 единици), защото нулата заема една от „положителните“ комбинации. Беззнаковите типове (uint, byte) нямат знаков бит и използват всички комбинации за положителни стойности: byte е от 0 до 255.
Какво става, когато към int.MaxValue прибавим 1? Битовете 0111…1111 стават 1000…0000, а това в допълнителен код е int.MinValue. Това е препълване (overflow): резултатът не се побира в типа и „превърта“ като километраж – без грешка и без предупреждение. По подразбиране C# работи в unchecked режим и мълчаливо връща грешната стойност; ако оградим израза с checked(...) или блок checked { }, при препълване се хвърля OverflowException. Компилаторът хваща само константите: int x = int.MaxValue + 1; е грешка при компилация (CS0220), но същото с променлива минава и дава -2147483648. Най-честият случай е умножение в цикъл: 13! вече не се побира в int, а 21! – дори в long; затова за големи стойности избираме по-широк тип и слагаме checked там, където грешката би била скъпа.
Представянето на реални числа следва стандарта IEEE 754 с плаваща запетая (floating point): числото се разбива на знак, експонента и мантиса, както в научния запис 1.101 по 2 на трета степен. float ползва 32 бита (23 за мантисата) и е точен до около 7 значещи цифри, double – 64 бита (52 за мантисата) и около 15–16 цифри. Проблемът е, че в двоична система дроби като 0.1 са безкрайни периодични, както 1/3 в десетична, затова се закръглят. Така 0.1 + 0.2 дава 0.30000000000000004 и сравнението 0.1 + 0.2 == 0.3 е false. Правилото е: реални числа не се сравняват с ==, а чрез допустима разлика – Math.Abs(a - b) < 1e-9. Делението на нула при double не хвърля изключение, а дава double.PositiveInfinity или double.NaN („не е число“).
За пари, цени и всичко, което се брои в стотинки, има тип decimal: 128 бита, около 28–29 значещи цифри и десетична основа, така че 0.1m + 0.2m == 0.3m е истина. Литералите му завършват с m (19.99m), на float – с f (2.5f), а double е подразбиращият се тип за 3.14. Цената е скорост – операциите с decimal са значително по-бавни от double, затова за физика, графика и статистика остава double. Няма неявно преобразуване между double и decimal – пише се (decimal)x – и дори decimal не може да запише 1m / 3m точно, а само с 28 тройки след запетаята.
Побитовите операции (bitwise operations) работят с всеки бит на числото поотделно, по същите таблици като логическите, но върху цели числа. & (И) дава 1 само ако и двата бита са 1; | (ИЛИ) – ако поне единият е 1; ^ (изключващо ИЛИ, XOR) – ако битовете са различни; ~ (НЕ) обръща всеки бит, затова за int ~x е равно на -x - 1. Например 12 & 10 е 1100 & 1010 = 1000, т.е. 8, а 12 | 10 е 1110 = 14 и 12 ^ 10 е 0110 = 6. Не ги бъркайте с логическите &&, || и !, които работят върху bool. Внимавайте и с приоритета: == се изпълнява преди &, затова проверката винаги е (x & 1) == 1, а x & 1 == 1 дори не се компилира.
Изместванията (shifts) местят всички битове: x << n измества наляво и умножава по 2 на степен n, а x >> n измества надясно и дели цяло на 2 на степен n, като при отрицателни числа знаковият бит се копира и знакът се запазва (-100 >> 2 е -25). Изразът 1 << n дава число с единствена единица на позиция n – това е маска (mask). С нея проверяваме бит: (x & (1 << n)) != 0; вдигаме го: x | (1 << n); сваляме го: x & ~(1 << n); обръщаме го: x ^ (1 << n). Така в едно int пазим 32 състояния „включено/изключено“ – права за достъп, избрани дни, настройки – и ги наричаме флагове (flags). В C# това се оформя с изброим тип с атрибут [Flags] и стойности степени на двойката (1, 2, 4, 8): | комбинира флаговете, а HasFlag или & ги проверява.
Златни правила
Знай диапазона на типа
int стига до 2 147 483 647 – това не е много, когато умножавате. За големи стойности вземете long, за пари – decimal, и мислете за най-лошия случай още при избора на типа.
Препълването е тихо
По подразбиране C# не проверява аритметиката с цели числа – грешната стойност просто продължава надолу по програмата. Там, където грешката е недопустима, оградете изчислението с checked.
`double` не се сравнява с `==`
Реалните числа са приблизителни. Сравнявайте с допустима разлика Math.Abs(a - b) < eps, а за парични суми използвайте decimal.
Скоби около всяка побитова операция
&, | и ^ са с по-нисък приоритет от == и !=. Пишете (x & mask) != 0 винаги, дори когато мислите, че не е нужно.
Един флаг – един бит
Стойностите в [Flags] изброим тип са степени на двойката: 1, 2, 4, 8. Комбинации като All = Read | Write са допустими, но никога не задавайте 3 или 5 като самостоятелен флаг.
Бърз справочник
Числови типове в C#
| Тип | Размер | Диапазон | Бележка |
|---|---|---|---|
byte | 8 бита | 0 … 255 | Беззнаков; byte b = 255; b++; дава 0 |
sbyte | 8 бита | -128 … 127 | Знаков, допълнителен код |
short | 16 бита | -32 768 … 32 767 | Рядко нужен извън файлови формати |
int | 32 бита | -2 147 483 648 … 2 147 483 647 | Подразбиращ се за цели числа; int.MaxValue, int.MinValue |
long | 64 бита | около ±9.2 × 10 на 18-а | Литерал 100L; 20! се побира, 21! – не |
float | 32 бита | около ±3.4 × 10 на 38-а | ~7 значещи цифри; литерал 2.5f |
double | 64 бита | около ±1.8 × 10 на 308-а | ~15–16 цифри; подразбиращ се за реални числа |
decimal | 128 бита | около ±7.9 × 10 на 28-а | 28–29 цифри, десетична основа; литерал 9.99m; за пари |
Побитови оператори и идиоми
| Оператор | Име | Пример | Резултат |
|---|---|---|---|
& | Побитово И | 12 & 10 (1100 & 1010) | 8 (1000) |
| | Побитово ИЛИ | 12 | 10 | 14 (1110) |
^ | Изключващо ИЛИ (XOR) | 12 ^ 10 | 6 (0110) |
~ | Побитово НЕ | ~12 | -13 (всички битове обърнати) |
<< | Ляво изместване | 1 << 4 | 16 |
>> | Дясно изместване (аритметично) | -100 >> 2 | -25 (знакът се запазва) |
>>> | Дясно изместване без знак (C# 11) | -16 >>> 28 | 15 |
x & (1 << n) | Проверка на бит n | (37 & (1 << 2)) != 0 | true (бит 2 на 100101 е 1) |
x & (x - 1) | Сваля най-десния вдигнат бит | 12 & 11 | 8 (1100 & 1011 = 1000) |
Код за анализ и пренаписване
Битове, допълнителен код и препълване
using System;
class Program
{
static string Bits(int x) => Convert.ToString(x, 2).PadLeft(32, '0');
static void Main()
{
Console.WriteLine($" 5 = {Bits(5)}");
Console.WriteLine($" -5 = {Bits(-5)}");
Console.WriteLine($" -1 = {Bits(-1)}");
Console.WriteLine($"Max = {Bits(int.MaxValue)} ({int.MaxValue})");
Console.WriteLine($"Min = {Bits(int.MinValue)} ({int.MinValue})");
int max = int.MaxValue;
int wrapped = max + 1;
Console.WriteLine($"int.MaxValue + 1 = {wrapped}");
try
{
int safe = checked(max + 1);
Console.WriteLine(safe);
}
catch (OverflowException e)
{
Console.WriteLine($"Препълване: {e.Message}");
}
long big = (long)max + 1;
Console.WriteLine($"Като long: {big}");
double d = 0.1 + 0.2;
Console.WriteLine($"0.1 + 0.2 = {d}");
Console.WriteLine($"0.1 + 0.2 == 0.3 ? {d == 0.3}");
Console.WriteLine($"С толеранс: {Math.Abs(d - 0.3) < 1e-9}");
decimal m = 0.1m + 0.2m;
Console.WriteLine($"decimal: {m} == 0.3m ? {m == 0.3m}");
}
}Какво се случва тук?
-
Bitsправи 32-символен низ чрезConvert.ToString(x, 2), който за отрицателни числа връща допълнителния код, аPadLeftдопълва положителните с нули отляво. - Изходът показва, че
-5е обърнатото5плюс 1,-1е 32 единици,int.MaxValueе нула и 31 единици, аint.MinValue– единица и 31 нули. -
max + 1се смята в подразбиращия сеuncheckedрежим и превърта до-2147483648; компилаторът не се оплаква, защотоmaxе променлива, а не константа. -
checked(max + 1)прави същото събиране с проверка и хвърляOverflowExceptionсъс съобщение „Arithmetic operation resulted in an overflow“, което хващаме сtry/catch. -
(long)max + 1първо разширява стойността до 64 бита и чак тогава събира, затова дава верните2147483648;(long)(max + 1)би преобразувало вече превъртялата стойност. -
0.1 + 0.2се отпечатва като0.30000000000000004, сравнението с0.3еFalse, а проверката с толеранс1e-9–True. - Същото събиране с
decimalдава точно0.3иTrue, защотоdecimalработи в десетична основа и представя0.1без закръгляне.
Побитови оператори, маски и флагове
using System;
[Flags]
enum Permission
{
None = 0,
Read = 1, // 0001
Write = 2, // 0010
Execute = 4, // 0100
Delete = 8 // 1000
}
class Program
{
static string Bits(int x, int width) => Convert.ToString(x, 2).PadLeft(width, '0');
static void Main()
{
int a = 0b1100; // 12
int b = 0b1010; // 10
Console.WriteLine($"a & b = {Bits(a & b, 4)}"); // 1000
Console.WriteLine($"a | b = {Bits(a | b, 4)}"); // 1110
Console.WriteLine($"a ^ b = {Bits(a ^ b, 4)}"); // 0110
Console.WriteLine($"~a = {~a}"); // -13
Console.WriteLine($"1 << 4 = {1 << 4}"); // 16
Console.WriteLine($"100 >> 2 = {100 >> 2}"); // 25
Console.WriteLine($"-100 >> 2 = {-100 >> 2}"); // -25
int flags = 0;
flags |= 1 << 2; // вдигаме бит 2
flags |= 1 << 0; // вдигаме бит 0
Console.WriteLine($"flags = {Bits(flags, 8)}"); // 00000101
bool bit2 = (flags & (1 << 2)) != 0;
Console.WriteLine($"бит 2 е вдигнат? {bit2}"); // True
flags &= ~(1 << 2); // сваляме бит 2
flags ^= 1 << 7; // обръщаме бит 7
Console.WriteLine($"flags = {Bits(flags, 8)}"); // 10000001
Permission p = Permission.Read | Permission.Write;
Console.WriteLine(p); // Read, Write
Console.WriteLine(p.HasFlag(Permission.Write)); // True
Console.WriteLine((p & Permission.Execute) != 0); // False
p |= Permission.Execute;
p &= ~Permission.Write;
Console.WriteLine($"{p} = {(int)p}"); // Read, Execute = 5
}
}Какво се случва тук?
-
aиbса записани като двоични литерали, за да се вижда кои битове участват;Bits(…, 4)печата само четирите значещи позиции. -
a & bоставя само общите единици (1000),a | bсъбира всички (1110),a ^ b– само различните (0110), а~aобръща и 32-те бита и дава-13, точно-a - 1. -
1 << 4е 16 (умножение по 2 на четвърта степен),100 >> 2е 25 (цяло деление на 4), а-100 >> 2е-25, защото аритметичното изместване копира знаковия бит. - Променливата
flagsпоказва четирите идиома:|=с маска вдига бит,& (1 << n)го проверява,&= ~маскаго сваля,^=го обръща – останалите битове не се пипат. - Изброимият тип
Permissionима атрибут[Flags]и стойности степени на двойката, затоваPermission.Read | Permission.Writeе 3 и се отпечатва катоRead, Write, а не като число. -
HasFlagи(p & Permission.Execute) != 0правят една и съща проверка; сравнението с0е позволено, защото литералът 0 се преобразува към всеки изброим тип. - Операциите
|=и&= ~работят и с изброими типове, затова накраяpеRead, Executeс числова стойност 5.
Внимавай! Чести грешки
Грешките, които почти всеки прави в тази тема — виж разликата между грешния и правилния код.
Факториел в `int` превърта мълчаливо
Грешно
int f = 1;
for (int i = 1; i <= 15; i++)
{
f *= i;
}
Console.WriteLine(f); // 2004310016 – грешно, 15! е 1307674368000Правилно
long f = 1;
for (int i = 1; i <= 15; i++)
{
f = checked(f * i); // при препълване – OverflowException
}
Console.WriteLine(f); // 1307674368000Още 13! надхвърля int.MaxValue; в unchecked режим битовете над 32-рия просто се губят и излиза „правдоподобно“, но грешно число. По-широкият тип отлага проблема, а checked гарантира, че при препълване ще разберете, вместо да получите тиха грешка.
Сравнение на `double` с `==`
Грешно
double total = 0.1 + 0.2;
if (total == 0.3) // false: total е 0.30000000000000004
{
Console.WriteLine("Точно 0.30");
}Правилно
double total = 0.1 + 0.2;
if (Math.Abs(total - 0.3) < 1e-9) // сравнение с допустима разлика
{
Console.WriteLine("Точно 0.30");
}
decimal price = 0.1m + 0.2m; // за пари: decimal
Console.WriteLine(price == 0.3m); // True0.1 и 0.2 нямат точен двоичен запис, затова сборът им се различава от 0.3 в 17-ата цифра и условието е лъжа. Сравнявайте реални числа с толеранс, а суми в пари пазете в decimal, където 0.1m + 0.2m е точно 0.3m.
`x & 1 == 1` не прави това, което изглежда
Грешно
int x = 7;
if (x & 1 == 1) // грешка CS0019: '&' между int и bool
{
Console.WriteLine("Нечетно");
}Правилно
int x = 7;
if ((x & 1) == 1) // първо &, после ==
{
Console.WriteLine("Нечетно");
}== има по-висок приоритет от &, затова компилаторът първо смята 1 == 1 (което е bool) и после не може да приложи & между int и bool. В C# това поне е грешка при компилация, но в езици като C кодът минава и тихо дава грешен резултат – навикът за скоби е задължителен.
Флагове, които не са степени на двойката
Грешно
[Flags]
enum Access { None = 0, Read = 1, Write = 2, Execute = 3, Admin = 4 }
Access a = Access.Read | Access.Write;
Console.WriteLine(a.HasFlag(Access.Execute)); // True, а никой не е давал ExecuteПравилно
[Flags]
enum Access { None = 0, Read = 1, Write = 2, Execute = 4, Admin = 8 }
Access a = Access.Read | Access.Write;
Console.WriteLine(a.HasFlag(Access.Execute)); // FalseExecute = 3 е 0011 – същите битове като Read | Write, затова всеки с права за четене и писане „има“ и изпълнение. Всеки самостоятелен флаг трябва да заема собствен бит: 1, 2, 4, 8, 16 или по-четливо 1 << 0, 1 << 1, 1 << 2.
Задачи за самостоятелна работа
Опитай първо сам — подсказката е там само ако наистина закъсаш.
Битовете на едно число
Напишете програма, която прочита цяло число n от конзолата и без да използва Convert.ToString отпечатва: 32-битовия му двоичен запис, броя на единиците в него и дали е четно (чрез побитова операция, не чрез %). Накрая отпечатайте и резултата от Convert.ToString(n, 2), за да сравните. Тествайте с 5, -5, 0 и -1.
Факториел с проверка за препълване
Напишете метод long Factorial(int n), който смята n! в checked режим. В Main го извикайте за n от 1 до 25 и отпечатвайте резултатите, докато не настъпи препълване; тогава съобщете при кое n се е случило и спрете цикъла. След това сменете long с int и вижте при кое n препълва той.
Седмичен график с флагове
Моделирайте седмичен график за тренировки с изброим тип Days с атрибут [Flags]: Mon … Sun като отделни битове, плюс комбинираните Weekend и Workdays. Напишете методи за добавяне, премахване и обръщане на ден, за проверка дали всички дни от дадена група са включени и за броене на вдигнатите битове. В Main съставете график от три дни, отпечатайте го като имена и като битове, после го променете и отпечатайте отново.
Мини-тест за проверка
Отговори си наум (или на глас!) и чак тогава разкрий отговора.
1. Имаме `int max = int.MaxValue;`. Какво връща изразът `max + 1` по подразбиране и как да получим грешка вместо грешна стойност?
2. Защо `0.1 + 0.2 == 0.3` е `false` в C#, а `0.1m + 0.2m == 0.3m` е `true`?
3. Пресметнете `5 & 3`, `5 | 3` и `5 ^ 3`.
4. Как с една побитова операция проверяваме дали бит номер `n` на `x` е вдигнат, и как го сваляме, без да пипаме останалите битове?
Речник на термините
Виж пълния речник на курсаint заема 4 байта, long – 8. Типът byte в C# е беззнаково число от 0 до 255.-x се получава, като се обърнат битовете на x и се прибави 1.unchecked режим стойността превърта, в checked се хвърля OverflowException.float и double са приблизителни, затова не се сравняват с ==.unchecked, константните изрази – checked.&, |, ^, ~, <<, >>. Различен е от логическите &&, ||, !, които работят с bool.1 << n. С &, |, ^ и ~ чрез нея проверяваме, вдигаме, сваляме или обръщаме точно тези битове.[Flags] и стойности степени на двойката.Провери знанията
Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.
Провери знанията си
9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.
Препоръки за този модул
- Докато учите, печатайте битовете на всяка стойност с
Convert.ToString(x, 2).PadLeft(32, '0')– побитовите операции стават очевидни, когато виждате двете числа едно под друго. - Пишете маските като двоични литерали с разделители –
0b1111_0000– или като1 << n, а не като „магически“ числа от типа 240; така кодът обяснява сам себе си. - Упражнявайте ръчно превръщане на малки числа между десетична, двоична и шестнадесетична система и се проверявайте с калкулатора на Windows в режим „Programmer“ – той показва и допълнителния код.
- Когато сбор или произведение изведнъж стане отрицателно или абсурдно малко, подозирайте препълване: оградете изчислението с
checkedи пуснете отново – изключението ще покаже точното място.