$\text{I}$ metoda konwersji bin → hex

Zanim napiszemy program konwertujący liczbę dwójkową do systemu o podstawie 16 (szesnastkowego), omówimy niezbędne do wykonania czynności. Całą operację przeprowadzimy dwuetapowo: najpierw liczbę dwójkową przedstawimy w systemie dziesiętnym. Następnie zamienimy ją na odpowiednik w systemie szesnastkowym.

Metodę konwersji pokażemy na przykładzie. Ułatwi nam to zrozumienie komputerowej realizacji algorytmu.

Przykład 1

Zapiszemy liczbę 10100111Indeks dolny (2)₍₂₎ w postaci szesnastkowej.

$${10100111}_{\left(2\right)}=1\cdot 2^7+1\cdot 2^5+$$

$$+1\cdot 2^2+1\cdot 2^1+1\cdot 2^0={167}_{\left(10\right)}$$

Najpierw mnożymy wszystkie cyfry liczby dwójkowej przez odpowiadające im wagi, czyli potęgi liczby 2. Po zsumowaniu iloczynów otrzymujemy zapis liczby w postaci dziesiętnej.

Oto wynik pierwszej konwersji:

$${10100111}_{\left(2\right)}={167}_{\left(10\right)}$$

Następnie przedstawimy liczbę dziesiętną w postaci szesnastkowej.

REZwxvRwiORp5

Ilustracja przedstawia po lewej stronie 4 liczby po 2 w 2 kolumnach oddzielonych pionową linią. Po lewej stronie linii: 167 oraz pod spodem 10, po prawej stronie linii w tych samych rzędach: 7 oraz A (które odpowiada liczbie 10). Od dołu do góry skazuje strzałka. Po prawej stronie ilustracji porzedstawiono ręczne dzielenie w 2 rzędach. Pierwszy rząd (górny): 167 : 16 = 10 reszty 7, drugi rząd: 10 : 16 = 0 reszty 10.

W tym celu wykonujemy następujące czynności:

1. Dzielimy liczbę przez 16 (czyli przez podstawę systemu szesnastkowego).

2. Zapamiętujemy iloraz oraz resztę z dzielenia.

3. Wracamy do punktu 1. Dzielimy przez 16 obliczony wcześniej iloraz. Czynności opisane w punktach 1. i 2. wykonujemy dopóty, dopóki iloraz jest większy niż zero.

4. Rezultatem konwersji są reszty z dzielenia, zapisane w kolejności od ostatniej do pierwszej.

Po zakończeniu całej operacji otrzymujemy wynik:

$${10100111}_{\left(2\right)}={167}_{\left(10\right)}={\mathrm{A7}}_{\left(16\right)}$$

Realizacja algorytmu w języku C++

Możemy już przejść do napisania programu, który zamieni liczbę w systemie dwójkowym na system szesnastkowy.

Zaczniemy od napisania funkcji odpowiadającej za konwersję liczby binarnej do systemu dziesiętnego. Nazwiemy ją konwertujBinDec(). Jako parametrparametr funkcjiparametr funkcja przyjmie liczbę zapisaną w systemie dwójkowym. Zwróć uwagę, że podajemy ją w postaci ciągu znaków liczbaBin (jest to istotne, ponieważ jej elementy są traktowane jak znaki kodu ASCII):

int konwertujBinDec(std::string liczbaBin) {
	int liczbaDec = 0;
	int bit = 0;
	int waga = 1; // ponieważ 2^0 = 1

	for (int i = liczbaBin.length() - 1; i >= 0; i--) {
		bit = liczbaBin[i] - '0';
		liczbaDec = liczbaDec + bit * waga;
		waga *= 2;
	}
    
	return liczbaDec;
}

Omówmy poszczególne linie kodu.

Na początku deklarujemy trzy zmienne typu całkowitego i nadajemy im wartości początkowe. Będą to:

• bit = 0, którą wykorzystamy do przechowywania wartość aktualnie rozpatrywanego bitu

• liczbaDec = 0, która będzie przechowywała nasz rezultat konwersji

• waga = 1, która będzie przechowywała wagę obecnie rozpatrywanego bitu

Następnie tworzymy pętlę for, w której będziemy kolejno przechodzili po znakach naszej liczby binarnej od końca, tj. zaczynając od bitu o najmniejszej wadze. W każdym cyklu pętli for wykonamy następujące operacje:

• Zmiennej bit przypisujemy wartość liczbaBin[i] - '0'. Innymi słowy, nadajemy jej wartość kodu ASCII znaku zapisanego w tablicy liczbaBin[], pomniejszoną o kod ASCII znaku '0'. W rezultacie bit przybiera wartość 0 lub 1. Wynika to z faktu, że zmienna liczbaBin[i] jest znakiem '0' lub '1'; odpowiadające im wartości w kodzie ASCII wynoszą – kolejno – 48 i 49. Kiedy liczbaBin[i] będzie znakiem '1', zostanie wykonane działanie 49‑48, a bit przyjmie wartość 1. Jeżeli liczbaBin[i] to znak '0', po operacji odejmowania (48‑48) bit wyniesie 0.W każdym cyklu pętli for mnożymy ją przez podstawę systemu binarnego, czyli 2.

• Do zmiennej liczbaDec przypisujemy wartość liczbaDec + bit*waga, czyli obliczony do tej pory wynik powiększymy o waga jeżeli bit będzie równy 1 – w przeciwnym razie wartość liczbaDec pozostanie bez zmian.

• Zmienną waga pomnożymy przez podstawę systemu liczbowego, czyli 2

Na koniec zwracamy wynik konwersji, czyli liczbę zapisaną w systemie dziesiętnym. Korzystamy z instrukcji return liczbaDec.

waga = waga * 2;

#include <string>

Pierwsza funkcja jest zatem gotowa. Pora zamienić liczbę dziesiętną na szesnastkową.

Posłużymy się funkcją o nazwie konwertujDecHex(). Jej jedynym parametrem będzie liczba dziesiętna, otrzymana w wyniku działania funkcji konwertujBinDec():

std::string konwertujDecHex(int liczbaDec) {
	if (liczbaDec == 0) {
		return "0";   
	}

	std::string liczbaHex = "";
	int reszta;

	while (liczbaDec > 0) {
		if (liczbaDec % 16 >= 0 && liczbaDec % 16 <= 9) {
			reszta = liczbaDec % 16;
			liczbaHex = std::to_string(reszta) + liczbaHex;
		} else {
			reszta = liczbaDec % 16 - 10 + 'A';
			char znak = reszta;
			liczbaHex = znak + liczbaHex;
		}

		liczbaDec = liczbaDec / 16;
	}
    
	return liczbaHex;
}

Na samym początku należy sprawdzić, czy podany do funkcji argumentargument funkcjiargument jest zerem. Jeżeli tak, funkcja od razu powinna zwrócić ciąg znaków „0”.

Kolejnym krokiem jest deklaracja zmiennych:

• std::string liczbaHex – jest to tablica znaków, w której zapiszemy wynik konwersji.

• int reszta – będziemy w niej przechowywać reszty z dzielenia przez 16.

Następnie otwieramy pętlę while. Dzięki zapisanym w niej instrukcjom sprawdzimy, czy reszta z dzielenia konwertowanej liczby mieści się  w przedziale <0, 9>.

• Jeżeli tak jest, przypisujemy zmiennej reszta wynik operacji liczbaDec % 16. Następnie, korzystając z funkcji std::to_string(), zamieniamy wartość całkowitą na znakową i dopisujemy („doklejamy”) ją do zmiennej liczbaHex.

• Jeżeli reszta z dzielenia jest większa niż 9, w zmiennej reszta zapisujemy wynik operacji liczbaDec % 16 - 10 + 'A'. Odjęcie liczby 10, a następnie dodanie wartości odpowiadającej w tablicy ASCII literze 'A' spowoduje, że zmienna reszta przybierze wartości odpowiadające pozycjom znaków od 'A' do 'F' w tablicy ASCII. Przykładowo, jeżeli wynik działania liczbaDec % 16 będzie równy 14 (w notacji szesnastkowej odpowiada mu znak 'E'), to zostanie wykonana instrukcja reszta = 14 - 10 + 65. Jej wynikiem jest 69, czyli liczbowy odpowiednik znaku 'E' w tablicy ASCII. Przypisując zmiennej znak wartość 69 otrzymujemy literę 'E'. Następnie dopisujemy ją do zmiennej liczbaHex.

Musimy pamiętać, aby w każdym cyklu pętli podzielić iloraz liczbaDec przez podstawę systemu szesnastkowego. W innym przypadku pętla będzie działać w nieskończoność:

liczbaDec = liczbaDec / 16;

Na końcu zwracamy wynik konwersji, czyli zmienną liczbaHex.

Niezbędne funkcje mamy już napisane.

Dodajmy jeszcze instrukcje, dzięki którym użytkownik poda liczbę do przekształcenia. Odpowiedni kod umieszczamy w funkcji głównej int main():

std::string liczbaTest;

std::cout << "Podaj liczbę w systemie binarnym, która ma zostać przekonwertowana do systemu szesnastkowego" << std::endl;
std::cin >> liczbaTest;

Ostatnim etapem jest wywołanie funkcji dla liczby podanej jako argument. Zwróć uwagę, że musimy zdefiniować zmienną liczbaDec, w której zapiszemy wynik pierwszego etapu konwersji (bin → dec). Wynika to z faktu, że zastosowany algorytm nie dokonuje bezpośredniej konwersji między systemami bin → hex.

int liczbaDec = konwertujBinDec(liczbaTest);

std::cout << konwertujDecHex(liczbaDec);

Oto cały kod programu:

#include <iostream>
#include <string>

int konwertujBinDec(std::string liczbaBin) {
	int liczbaDec = 0;
	int bit = 0;
	int waga = 1; // dlatego że 2 ^ 0 = 1

	for (int i = liczbaBin.length() - 1; i >= 0; i--) {
		bit = liczbaBin[i] - '0';
		liczbaDec = liczbaDec + bit * waga;
		waga *= 2;
	}

	return liczbaDec;
}

std::string konwertujDecHex(int liczbaDec) {
	if (liczbaDec == 0) {
		return "0";   
	}
    
	std::string liczbaHex = "";
	int reszta;

	while (liczbaDec > 0) {
		if (liczbaDec % 16 >= 0 && liczbaDec % 16 <= 9) {
			reszta = liczbaDec % 16;
			liczbaHex = std::to_string(reszta) + liczbaHex;
		} else {
			reszta = liczbaDec % 16 - 10 + 'A';
			char znak = reszta;
			liczbaHex = znak + liczbaHex;
		}
        
		liczbaDec = liczbaDec / 16;
	}
    
	return liczbaHex;
}

int main() {
	std::string liczbaTest;

	std::cout << "Podaj liczbę w systemie binarnym, która ma zostać przekonwertowana do systemu szesnastkowego" << std::endl;
	std::cin >> liczbaTest;

	int liczbaDec = konwertujBinDec(liczbaTest);

	std::cout << konwertujDecHex(liczbaDec);

	return 0;
}

$\mathrm{II}$ metoda konwersji bin → hex

Przekształcenia liczby dwójkowej w szesnastkową możemy dokonać także wykorzystując fakt, że po podniesieniu liczby 2 (czyli podstawy systemu binarnego) do czwartej potęgi uzyskamy liczbę 16 (czyli podstawę systemu szesnastkowego).

Każdy znak systemu szesnastkowego da się więc zapisać za pomocą czterech bitów.

Przeanalizujmy metodę konwersji:

Konwersja części ułamkowej

Korzystając z właściwości baz skojarzonych możemy także konwertować część ułamkową liczby. Oto przykład:

Przykład 3

Zapiszemy liczbę $0,{101011010111}_{\left(2\right)}$ w systemie szesnastkowym.

Ry8SOmqJgWgio

Ilustracja przedstawia w 2 rzędach następujące napisy: 0,101011010111 subskrypt (2) strzałka w prawo ( ) subskrypt (16). Oznaczając kowersję z systemu binarnego do szesnastkowego. w drugim rzędzie znajduje się jedynie: 0,AD7 subskrypt (16). Kolory bitów i liczb są dopasowane: pierwsze 4 bity po przecinku odpowiadają A, kolejne 4 odpowiadają D a ostatnie 7.

W kolejnej sekcji zaimplementujemy ten właśnie algorytm.

Słownik