Теория
Всеки ден използваме десетичната бройна система, без да се замисляме как работи. Тя има десет цифри (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. Префиксът и индексът казват само как е написано числото; в паметта то е винаги двоично.
Проверявай с обратното преобразуване
След като получите резултат, върнете го в десетична система по теглата. Ако не излезе същото число, грешката е в остатъците или в реда на цифрите.
Бърз справочник
Съответствие между системите (където се появяват буквите)
| Десетично | Двоично | Осмично | Шестнадесетично |
|---|---|---|---|
| 9 | 1001 | 11 | 9 |
| 10 | 1010 | 12 | A |
| 11 | 1011 | 13 | B |
| 12 | 1100 | 14 | C |
| 13 | 1101 | 15 | D |
| 14 | 1110 | 16 | E |
| 15 | 1111 | 17 | F |
| 16 | 10000 | 20 | 10 |
| 255 | 11111111 | 377 | FF |
Бройни системи в 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"; малки и главни букви са равностойни |
Код за анализ и пренаписване
Делене с остатък, стъпка по стъпка
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, схема на Хорнер и групиране на битове
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); // 5int.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));` и защо?
Речник на термините
Виж пълния речник на курса0b1010 е двоичен, 0x1A – шестнадесетичен. За осмична система в C# няма префикс.result = result * основа + цифра, без основата да се повдига на степен.Провери знанията
Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.
Провери знанията си
9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.
Материали от часовете
Задачи и тестове, давани в клас по тази тема.
Препоръки за този модул
- Научете наизуст степените на двойката до 2¹⁰ = 1024 и шестнадесетте четирибитови комбинации (0000 = 0 … 1111 = F) – с тях повечето преобразувания стават наум.
- Решавайте на хартия в колона: отляво частните, отдясно остатъците, после прочетете остатъците отдолу нагоре и оградете резултата. Чак след това проверете с
Convert.ToString(n, 2)в C# или с калкулатора на Windows в режим Programmer. - Винаги записвайте основата:
101без индекс е двусмислено – може да е сто и едно или пет. В тетрадката използвайте101₂, а в кода – префикса0b101. - Напишете си малка конзолна програма „проверител“, която извежда всяко въведено число в четирите системи. Тренирайте по пет числа дневно на ръка и сверявайте с нея.