Модул 22

Бройни системи

Как компютърът брои с нули и единици и защо програмистите пишат числата в шестнадесетична система. Позиционен запис, тегла на позициите и преобразуване между десетична, двоична, осмична и шестнадесетична система – с делене с остатък, по тегла и чрез групиране на битове. Готовите средства в C#: литерали `0b`/`0x`, `Convert.ToString` и `Convert.ToInt32`.

Теория

Всеки ден използваме десетичната бройна система, без да се замисляме как работи. Тя има десет цифри (0–9) и е позиционна: стойността на една цифра зависи от мястото ѝ в числото. В записа 4096 четворката не означава „четири“, а четири хиляди, защото стои на позиция с тегло 1000. Общото правило е, че позициите отдясно наляво имат тегла 1, 10, 100, 1000 – степени на основата (base, radix) 10, започвайки от нулева степен. Така 4096 = 4·1000 + 0·100 + 9·10 + 6·1. Същата идея работи с всяка основа: сменяме десетката с друго число и получаваме нова бройна система, а за да е ясно коя е, записваме основата като индекс – 1011₂, 755₈, 2D₁₆.

Компютърът няма десет пръста. Паметта и процесорът му са изградени от милиарди транзистори, а всеки от тях е надеждно различим само в две състояния – има ток или няма. Затова машината работи в двоична система (binary) с основа 2 и само две цифри: 0 и 1; с два символа няма как да объркаш „малко напрежение“ с „много напрежение“, както би станало с десет нива. Една двоична цифра се нарича бит (bit), а група от 8 бита – байт (byte). Теглата на позициите са степените на двойката 1, 2, 4, 8, 16, 32, 64, 128, така че 1011₂ = 1·8 + 0·4 + 1·2 + 1·1 = 11. С 8 бита се записват 2⁸ = 256 различни стойности – от 0 до 255 – и точно затова компонентите на RGB цвета и типът byte в C# свършват на 255.

Двоичните записи бързо стават дълги и нечетими: 45 е 101101, а един IP адрес е 32 бита. Затова програмистите използват две „съкратени“ системи, чиито основи са степени на 2. Осмичната система (octal) има основа 8 и цифри от 0 до 7 – една осмична цифра побира точно 3 бита. Шестнадесетичната система (hexadecimal, hex) има основа 16, а след 9 цифрите продължават с буквите A = 10, B = 11, C = 12, D = 13, E = 14, F = 15 – една hex цифра побира точно 4 бита, тоест половин байт, а цял байт е винаги две hex цифри. Ще ги срещате навсякъде: цветът #FF8800 в CSS, адресите в паметта при дебъгване, MAC адресите и кодовете на Unicode символите са шестнадесетични, а правата върху файлове в Linux (chmod 755) са осмични.

Най-универсалният начин да превърнем десетично число в друга основа е деленето с остатък: делим числото на основата, записваме остатъка, после делим частното и повтаряме, докато частното стане 0. За 45 в двоична: 45 : 2 = 22 ост. 1; 22 : 2 = 11 ост. 0; 11 : 2 = 5 ост. 1; 5 : 2 = 2 ост. 1; 2 : 2 = 1 ост. 0; 1 : 2 = 0 ост. 1. Остатъците се четат отдолу нагоре – последният е най-старшата цифра – и получаваме 101101₂. Същият алгоритъм с основа 16 дава 45 : 16 = 2 ост. 13 (D) и 2 : 16 = 0 ост. 2, тоест 2D₁₆, а с основа 8 – 55₈. За двоичната система има и втори начин, методът на теглата: вадим последователно най-голямата степен на двойката, която се побира (45 − 32 = 13, 13 − 8 = 5, 5 − 4 = 1, 1 − 1 = 0), слагаме 1 на позициите с тегла 32, 8, 4 и 1, а 0 на останалите, и пак четем 101101.

Обратната посока – от произволна основа към десетична – е сумиране по тегла: умножаваме всяка цифра по теглото на позицията ѝ и събираме. 2D₁₆ = 2·16 + 13·1 = 45, а 755₈ = 7·64 + 5·8 + 5·1 = 493. Когато пишем програма, е по-удобна схемата на Хорнер: тръгваме от 0 и за всяка цифра отляво надясно правим result = result * основа + цифра. За 101101₂ междинните стойности са 0 → 1 → 2 → 5 → 11 → 22 → 45 и нито една степен не се пресмята отделно. Винаги проверявайте, че всяка цифра е по-малка от основата: 129₈ не е валидно число, защото в осмичната система няма цифра 9.

Между двоична, осмична и шестнадесетична система изобщо не минаваме през десетична – използваме групиране на битове. Разделяме двоичния запис на групи отдясно наляво: по 4 бита за шестнадесетична и по 3 бита за осмична, като най-лявата група допълваме с нули. 101101₂ → 0010 1101 → 2D₁₆, а на тройки 101 101 → 55₈. Обратно, всяка шестнадесетична цифра се разписва в точно 4 бита: F6₁₆ → 1111 0110, а всяка осмична – в точно 3. Групирането отляво е най-честата грешка: 1011 01 би дало B1, което е 177, а не 45. Запомнете шестнадесетте комбинации от 0000 до 1111 и ще преобразувате цели байтове наум.

В C# едно int се съхранява винаги като 32 бита – основата е свойство на записа, не на стойността. Литералите се пишат с префикс 0b за двоична и 0x за шестнадесетична, а долната черта служи само за четимост: 0b0010_1101, 0x2D и 45 са едно и също число (осмичен префикс в C# няма). За извеждане има Convert.ToString(n, 2), Convert.ToString(n, 8) и Convert.ToString(n, 16) – методът приема само основи 2, 8, 10 и 16, връща string без водещи нули и с малки букви за hex; за главни букви и фиксирана ширина използвайте форматите n.ToString("X") и n.ToString("X8"), а PadLeft(8, '0') допълва двоичния запис до цял байт. За четене има Convert.ToInt32("101101", 2), Convert.ToInt32("755", 8) и Convert.ToInt32("2D", 16) – при невалидна цифра хвърлят FormatException, а при основа 16 приемат и префикса 0x. Внимание: int.Parse("101") ще прочете „сто и едно“, защото без указана основа текстът винаги е десетичен. Отрицателните числа се показват така, както машината ги пази – Convert.ToString(-1, 2) връща 32 единици.

Златни правила

Цифрите са от 0 до основата минус 1

В двоичната система няма цифра 2, в осмичната няма 8 и 9, а в шестнадесетичната след 9 идват A–F. Щом видите „цифра“, по-голяма или равна на основата, записът е грешен.

Остатъците се четат отдолу нагоре

При деленето с остатък първият остатък е най-младшата (най-дясната) цифра, а последният – най-старшата. Записвайте ги в колона и четете от последния към първия.

Групирай битовете отдясно: по 4 за hex, по 3 за осмична

Броенето на групите започва от най-младшия бит, а най-лявата група се допълва с нули. Една hex цифра е точно половин байт, затова цял байт е винаги две hex цифри.

Основата е свойство на записа, не на числото

0x2D, 0b101101 и 45 са едно и също int. Префиксът и индексът казват само как е написано числото; в паметта то е винаги двоично.

Проверявай с обратното преобразуване

След като получите резултат, върнете го в десетична система по теглата. Ако не излезе същото число, грешката е в остатъците или в реда на цифрите.

Бърз справочник

Съответствие между системите (където се появяват буквите)

ДесетичноДвоичноОсмичноШестнадесетично
91001119
10101012A
11101113B
12110014C
13110115D
14111016E
15111117F
16100002010
25511111111377FF

Бройни системи в C#

Какво искамеКодРезултатБележка
Двоичен литералint n = 0b0010_1101;45Префикс 0b; долната черта е само за четимост
Шестнадесетичен литералint n = 0x2D;45Префикс 0x; 0x2d е същото. Осмичен литерал в C# няма
Десетично → двоичноConvert.ToString(45, 2)"101101"Връща string без водещи нули
Десетично → осмичноConvert.ToString(45, 8)"55"Основата може да е само 2, 8, 10 или 16
Десетично → шестнадесетичноConvert.ToString(45, 16)"2d"Малки букви; за главни – 45.ToString("X") → "2D"
Фиксирана ширинаConvert.ToString(5, 2).PadLeft(8, '0')"00000101"За hex: n.ToString("X2"), n.ToString("X8")
Двоично → десетичноConvert.ToInt32("101101", 2)45Невалидна цифра → FormatException; префикс 0b не се приема
Осмично → десетичноConvert.ToInt32("755", 8)493Цифра 8 или 9 → FormatException
Шестнадесетично → десетичноConvert.ToInt32("2D", 16)45Приема и "0x2D"; малки и главни букви са равностойни

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

Делене с остатък, стъпка по стъпка

Program.cs
using System;
using System.Text;

class Program
{
    static string ToBase(int number, int toBase)
    {
        const string digits = "0123456789ABCDEF";
        if (number == 0)
        {
            return "0";
        }

        StringBuilder result = new StringBuilder();
        int n = number;
        while (n > 0)
        {
            int remainder = n % toBase;
            Console.WriteLine($"{n} : {toBase} = {n / toBase}, остатък {remainder} -> цифра {digits[remainder]}");
            result.Insert(0, digits[remainder]);
            n /= toBase;
        }

        return result.ToString();
    }

    static void Main()
    {
        int number = 45;
        foreach (int b in new[] { 2, 8, 16 })
        {
            Console.WriteLine($"--- {number} в основа {b} ---");
            string manual = ToBase(number, b);
            string builtIn = Convert.ToString(number, b).ToUpper();
            Console.WriteLine($"Ръчно: {manual}, Convert: {builtIn}, съвпадат: {manual == builtIn}");
        }
    }
}

Какво се случва тук?

  • Методът ToBase приема число и основа от 2 до 16; низът digits съдържа всички възможни цифри, така че digits[13] дава буквата D.
  • Специалният случай number == 0 е нужен, защото цикълът while (n > 0) иначе не би се изпълнил и бихме върнали празен низ вместо "0".
  • На всяка стъпка n % toBase дава остатъка – следващата цифра, а n /= toBase е целочисленото частно, с което продължаваме деленето.
  • result.Insert(0, ...) слага новата цифра в началото на низа: така остатъците се подреждат отдолу нагоре автоматично и не се налага обръщане накрая.
  • Редът с Console.WriteLine вътре в цикъла отпечатва всяка стъпка точно както се записва в тетрадката – 45 : 2 = 22, остатък 1 – и е удобен за самопроверка.
  • В Main обхождаме основите 2, 8 и 16 и сравняваме ръчния резултат с Convert.ToString(number, b); викаме ToUpper(), защото Convert връща малки букви за шестнадесетичните цифри.
  • Програмата извежда 101101, 55 и 2D и за трите основи печата съвпадат: True; опитайте с 255 – трябва да получите 11111111, 377 и FF.

Литерали 0b/0x, схема на Хорнер и групиране на битове

Program.cs
using System;

class Program
{
    static int FromBase(string text, int fromBase)
    {
        const string digits = "0123456789ABCDEF";
        int result = 0;
        foreach (char c in text.ToUpper())
        {
            int value = digits.IndexOf(c);
            if (value < 0 || value >= fromBase)
            {
                throw new FormatException($"'{c}' не е цифра в основа {fromBase}");
            }
            result = result * fromBase + value;
        }
        return result;
    }

    static void Main()
    {
        int a = 0b0010_1101;   // двоичен литерал; долната черта е само за четимост
        int b = 0x2D;          // шестнадесетичен литерал
        Console.WriteLine($"0b0010_1101 = {a}, 0x2D = {b}, равни: {a == b}");

        string binary = "101101";
        Console.WriteLine($"{binary}(2) = {FromBase(binary, 2)} (Convert: {Convert.ToInt32(binary, 2)})");
        Console.WriteLine($"2D(16) = {FromBase("2D", 16)} (Convert: {Convert.ToInt32("2D", 16)})");
        Console.WriteLine($"755(8) = {FromBase("755", 8)} (Convert: {Convert.ToInt32("755", 8)})");

        // Групиране по 4 бита: допълваме отляво с нули до дължина, кратна на 4
        string padded = binary.PadLeft((binary.Length + 3) / 4 * 4, '0');
        Console.Write($"{padded} -> ");
        for (int i = 0; i < padded.Length; i += 4)
        {
            string group = padded.Substring(i, 4);
            Console.Write($"[{group} = {Convert.ToInt32(group, 2):X}] ");
        }
        Console.WriteLine();

        try
        {
            FromBase("129", 8);
        }
        catch (FormatException ex)
        {
            Console.WriteLine($"Грешка: {ex.Message}");
        }
    }
}

Какво се случва тук?

  • FromBase реализира схемата на Хорнер: за всяка цифра отляво надясно прави result = result * fromBase + value, което замества пресмятането на степени на основата.
  • digits.IndexOf(c) превръща символа в число; ако върне -1 (непознат символ) или стойност, по-голяма или равна на основата, хвърляме FormatException с ясно съобщение – както прави и вграденият Convert.
  • Литералите 0b0010_1101 и 0x2D се компилират до едно и също int със стойност 45, затова първият ред извежда равни: True; долната черта е само за четимост и компилаторът я игнорира.
  • Трите реда с Convert.ToInt32(..., 2), (..., 16) и (..., 8) показват, че вграденият метод дава същите резултати като нашия – 45, 45 и 493.
  • За групирането по 4 бита първо допълваме низа отляво с нули до дължина, кратна на 4, с PadLeft, после режем с Substring(i, 4) и извеждаме всяка група като hex цифра чрез формата :X – резултатът е [0010 = 2] [1101 = D].
  • Блокът try/catch демонстрира, че 129 не е валидно осмично число: цифрата 9 не съществува в основа 8 и програмата извежда Грешка: '9' не е цифра в основа 8.

Внимавай! Чести грешки

Грешките, които почти всеки прави в тази тема — виж разликата между грешния и правилния код.

Остатъците в обратен ред

Грешно

int n = 12;
string result = "";
while (n > 0)
{
    result += n % 2;      // добавя в края: 0, 0, 1, 1
    n /= 2;
}
Console.WriteLine(result); // 0011 – огледално!

Правилно

int n = 12;
string result = "";
while (n > 0)
{
    result = (n % 2) + result;   // добавя в началото
    n /= 2;
}
Console.WriteLine(result); // 1100

Първият остатък е най-младшата цифра и трябва да застане най-отдясно. Ако просто добавяте в края, получавате огледалния запис – за 12 излиза 0011 вместо 1100.

Текстът „101“ не е петица

Грешно

string input = "101";   // потребителят е въвел двоично число
int n = int.Parse(input);
Console.WriteLine(n);     // 101, а не 5

Правилно

string input = "101";
int n = Convert.ToInt32(input, 2);
Console.WriteLine(n);     // 5

int.Parse и int.TryParse винаги четат текста като десетично число. Щом записът е в друга основа, подайте я изрично чрез Convert.ToInt32(text, 2), 8 или 16.

Групиране на битовете отляво

Грешно

string binary = "101101";
string hi = binary.Substring(0, 4);  // "1011" -> B
string lo = binary.Substring(4);     // "01"   -> 1
Console.WriteLine($"{Convert.ToInt32(hi, 2):X}{Convert.ToInt32(lo, 2):X}"); // B1 = 177, грешно

Правилно

string binary = "101101".PadLeft(8, '0');  // "00101101"
string hi = binary.Substring(0, 4);        // "0010" -> 2
string lo = binary.Substring(4, 4);        // "1101" -> D
Console.WriteLine($"{Convert.ToInt32(hi, 2):X}{Convert.ToInt32(lo, 2):X}"); // 2D = 45, вярно

Групите се броят от най-младшия бит, тоест отдясно наляво, а най-лявата се допълва с нули. Групирането отляво превръща 45 в 177.

Префиксът не се отпечатва

Грешно

int color = 0xFF;
Console.WriteLine(color);   // 255 – а искахме FF
Console.WriteLine(0b1010);  // 10

Правилно

int color = 0xFF;
Console.WriteLine(color.ToString("X"));         // FF
Console.WriteLine($"0x{color:X2}");             // 0xFF
Console.WriteLine(Convert.ToString(0b1010, 2));  // 1010

Префиксите 0x и 0b съществуват само в изходния код – компилаторът ги превръща в обикновено int. За да видите числото в друга основа, трябва изрично да го форматирате при извеждане.

Задачи за самостоятелна работа

Опитай първо сам — подсказката е там само ако наистина закъсаш.

Байт в четири системи

Напишете програма, която чете от конзолата цяло число от 0 до 255 и го извежда в двоична система с точно 8 цифри (с водещи нули), в осмична и в шестнадесетична с главни букви и две цифри. Ако въведеното не е цяло число в този диапазон, изведете съобщение за грешка.

Разлагане по тегла

Напишете метод PrintExpansion(string text, int fromBase), който получава число като низ и основа (2, 8 или 16) и извежда разлагането му по тегла и десетичната стойност. За "2D" и 16 трябва да се получи 2D(16) = 2*16 + 13*1 = 32 + 13 = 45, а за "1011" и 2 – 1011(2) = 1*8 + 0*4 + 1*2 + 1*1 = 8 + 0 + 2 + 1 = 11. Ако някоя цифра не е валидна за основата, изведете съобщение за грешка. Накрая проверете резултата с Convert.ToInt32.

Групиране на битове без десетична система

Напишете програма с два метода: BinaryToHex(string binary), който преобразува двоичен низ в шестнадесетичен чрез групиране по 4 бита (с допълване с нули отляво), и BinaryToOctal(string binary) – същото, но по 3 бита. Вътре в методите не използвайте Convert или int.Parse; направете си таблица за съответствие (например масив от 16 низа "0000", "0001", … "1111", в който индексът е стойността на групата). Методите трябва да проверяват, че низът съдържа само 0 и 1, и да премахват излишните водещи нули от резултата (но "0" да си остава "0"). В Main тествайте с "101101", "11110110", "0", "1" и "100000000" и сверете с Convert.ToString(Convert.ToInt32(binary, 2), 16).

Мини-тест за проверка

Отговори си наум (или на глас!) и чак тогава разкрий отговора.

1. Колко е `1011₂` в десетична система и защо не може да го прочетем като „хиляда и единадесет“?

2. При преобразуване на 13 в двоична система получаваме остатъци 1, 0, 1, 1 в този ред. Какъв е двоичният запис на 13?

3. Как ще превърнете `11110110₂` в шестнадесетична система, без да минавате през десетична?

4. Какво извежда `Console.WriteLine(int.Parse("101") + Convert.ToInt32("101", 2));` и защо?

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

Виж пълния речник на курса
Бройна система (number system)
Правило за записване на числа с краен набор от цифри. В позиционните системи стойността на една цифра зависи от мястото ѝ в записа.
Основа (base, radix)
Броят на различните цифри в системата и множителят между две съседни позиции: 2 за двоичната, 8 за осмичната, 10 за десетичната, 16 за шестнадесетичната.
Тегло на позицията (place value)
Степента на основата, съответстваща на дадена позиция, като се брои от нулева степен отдясно наляво: в двоична система 1, 2, 4, 8, 16 и така нататък.
Бит (bit)
Една двоична цифра – 0 или 1; най-малката единица информация в компютъра.
Байт (byte)
Група от 8 бита, която побира 256 стойности (от 0 до 255) и се записва с точно две шестнадесетични цифри.
Най-старши и най-младши бит (MSB, LSB)
Най-левият бит с най-голямо тегло и най-десният бит с тегло 1. При деленето с остатък първият получен остатък е най-младшият бит.
Шестнадесетична цифра (hex digit)
Един от символите 0–9 и A–F, който представя стойност от 0 до 15, тоест точно 4 бита (половин байт).
Префикс на литерал (0b, 0x)
Означение в C# кода за основата, в която е написан литералът: 0b1010 е двоичен, 0x1A – шестнадесетичен. За осмична система в C# няма префикс.
Схема на Хорнер (Horner's method)
Начин за пресмятане на стойността на число по цифрите му отляво надясно чрез result = result * основа + цифра, без основата да се повдига на степен.

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

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

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

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

Материали от часовете

Задачи и тестове, давани в клас по тази тема.

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

  • Научете наизуст степените на двойката до 2¹⁰ = 1024 и шестнадесетте четирибитови комбинации (0000 = 0 … 1111 = F) – с тях повечето преобразувания стават наум.
  • Решавайте на хартия в колона: отляво частните, отдясно остатъците, после прочетете остатъците отдолу нагоре и оградете резултата. Чак след това проверете с Convert.ToString(n, 2) в C# или с калкулатора на Windows в режим Programmer.
  • Винаги записвайте основата: 101 без индекс е двусмислено – може да е сто и едно или пет. В тетрадката използвайте 101₂, а в кода – префикса 0b101.
  • Напишете си малка конзолна програма „проверител“, която извежда всяко въведено число в четирите системи. Тренирайте по пет числа дневно на ръка и сверявайте с нея.

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

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