Модул 23

Представяне на числа, препълване и побитови операции

Как компютърът записва цели числа в допълнителен код и реални числа по IEEE 754, защо `int.MaxValue + 1` превърта и `0.1 + 0.2` не е `0.3`, и кога помагат `checked`, `unchecked` и `decimal`. Побитовите оператори `&`, `|`, `^`, `~`, `<<`, `>>`, маски и флагове с `[Flags]` – с готови идиоми за проверка, вдигане и сваляне на бит.

Теория

Компютърът пази всичко като битове (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#

ТипРазмерДиапазонБележка
byte8 бита0 … 255Беззнаков; byte b = 255; b++; дава 0
sbyte8 бита-128 … 127Знаков, допълнителен код
short16 бита-32 768 … 32 767Рядко нужен извън файлови формати
int32 бита-2 147 483 648 … 2 147 483 647Подразбиращ се за цели числа; int.MaxValue, int.MinValue
long64 битаоколо ±9.2 × 10 на 18-аЛитерал 100L; 20! се побира, 21! – не
float32 битаоколо ±3.4 × 10 на 38-а~7 значещи цифри; литерал 2.5f
double64 битаоколо ±1.8 × 10 на 308-а~15–16 цифри; подразбиращ се за реални числа
decimal128 битаоколо ±7.9 × 10 на 28-а28–29 цифри, десетична основа; литерал 9.99m; за пари

Побитови оператори и идиоми

ОператорИмеПримерРезултат
&Побитово И12 & 10 (1100 & 1010)8 (1000)
|Побитово ИЛИ12 | 1014 (1110)
^Изключващо ИЛИ (XOR)12 ^ 106 (0110)
~Побитово НЕ~12-13 (всички битове обърнати)
<<Ляво изместване1 << 416
>>Дясно изместване (аритметично)-100 >> 2-25 (знакът се запазва)
>>>Дясно изместване без знак (C# 11)-16 >>> 2815
x & (1 << n)Проверка на бит n(37 & (1 << 2)) != 0true (бит 2 на 100101 е 1)
x & (x - 1)Сваля най-десния вдигнат бит12 & 118 (1100 & 1011 = 1000)

Код за анализ и пренаписване

Битове, допълнителен код и препълване

Program.cs
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 без закръгляне.

Побитови оператори, маски и флагове

Program.cs
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); // True

0.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)); // False

Execute = 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` е вдигнат, и как го сваляме, без да пипаме останалите битове?

Речник на термините

Виж пълния речник на курса
Бит (bit)
Най-малката единица информация – 0 или 1. Всички числа в паметта са редици от битове с фиксирана дължина според типа.
Байт (byte)
Група от 8 бита; int заема 4 байта, long – 8. Типът byte в C# е беззнаково число от 0 до 255.
Допълнителен код (two's complement)
Начин за запис на отрицателни цели числа: най-левият бит е знаков, а -x се получава, като се обърнат битовете на x и се прибави 1.
Препълване (overflow)
Резултат, който не се побира в диапазона на типа. В unchecked режим стойността превърта, в checked се хвърля OverflowException.
Плаваща запетая (floating point, IEEE 754)
Представяне на реални числа чрез знак, експонента и мантиса. Типовете float и double са приблизителни, затова не се сравняват с ==.
`checked` / `unchecked`
Контексти в C#, които определят дали аритметиката с цели числа проверява за препълване. Обикновеният код е unchecked, константните изрази – checked.
Побитов оператор (bitwise operator)
Оператор, който работи върху всеки бит на цяло число поотделно: &, |, ^, ~, <<, >>. Различен е от логическите &&, ||, !, които работят с bool.
Маска (bit mask)
Число, в което само определени битове са единици, например 1 << n. С &, |, ^ и ~ чрез нея проверяваме, вдигаме, сваляме или обръщаме точно тези битове.
Флаг (flag)
Единичен бит, който означава състояние „включено/изключено“. В C# набор от флагове се описва с изброим тип с атрибут [Flags] и стойности степени на двойката.

Провери знанията

Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.

Провери знанията си

9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.

Препоръки за този модул

  • Докато учите, печатайте битовете на всяка стойност с Convert.ToString(x, 2).PadLeft(32, '0') – побитовите операции стават очевидни, когато виждате двете числа едно под друго.
  • Пишете маските като двоични литерали с разделители – 0b1111_0000 – или като 1 << n, а не като „магически“ числа от типа 240; така кодът обяснява сам себе си.
  • Упражнявайте ръчно превръщане на малки числа между десетична, двоична и шестнадесетична система и се проверявайте с калкулатора на Windows в режим „Programmer“ – той показва и допълнителния код.
  • Когато сбор или произведение изведнъж стане отрицателно или абсурдно малко, подозирайте препълване: оградете изчислението с checked и пуснете отново – изключението ще покаже точното място.

Учебен наръчник — теория, примери, задачи и тестове по предметите от учебния план.

Натисни Ctrl K или / отвсякъде, за да търсиш.