Konvertieren eine Binärzahl in eine Dezimalzahl in C

1. Konvertieren Binär in Dezimal in C
2. Methode 1: Konvertieren mit Loop- und Integer-Variablen
3. Methode 2: Verwenden Sie einen prozeduralen Ansatz
4. Methode 3: Verwenden Sie das char-Array, um die Binärzahl zu speichern

Dieser Artikel beschreibt umfassend mehrere C-Implementierungen zum Konvertieren von Binärzahlen in Dezimaläquivalente. Wir müssen jedoch nach unvermeidlichen Konvertierungsgrundlagen suchen, bevor wir uns mit den Implementierungen befassen.

Konvertieren Binär in Dezimal in C

Binärzahlen können nur zwei Werte enthalten: 0 und 1. Die Dezimalschreibweise hat jedoch zehn Symbole: 0 bis 9 (0,1,2,3,4,5,6,7,8,9).

Die binäre (0,1) Notation ist nativ für Computerhardware, während Dezimalwerte die ganzzahligen Werte sind, die Menschen leicht verstehen können.

Konvertierungsmethode

Die Binärzahl 0101 entspricht dezimal 5. Die Binär-zu-Dezimal-Konvertierungsmethode ist ziemlich einfach, wie durch die folgende Formel beschrieben:

Hier ist B die vollständige Binärzahl und B_{i} repräsentiert das i^th^-Bit in der gegebenen Binärzahl. Das n steht für die Gesamtzahl der Bits in der gegebenen Binärzahl.

Wenden wir obige Formel auf eine Binärzahl 0101 an. Wenn wir von links nach rechts summieren, erhalten wir:

Auf der Hardwareseite wird Binärsprache verwendet, weil es in einer elektronischen Schaltung Signale und Logikgatter gibt; es ist für das System leicht verständlich. Jede einzelne Binärzahl 0 oder 1 wird als 1-Bit bezeichnet.

Algorithmus zum Konvertieren einer Binärzahl in ein Dezimaläquivalent

Sehen wir uns ein schrittweises Verfahren an, um dieses Konvertierungsproblem zu lösen.

1. Starten Sie das Programm.
2. Nehmen Sie eine Binärzahl als Eingabe.
3. Wenn die Zahl größer als 0 ist, teilen Sie die Zahl durch zehn und bilden Sie das Produkt des Rests mit 2*i, wobei i bei Null beginnt.
4. Fahren Sie mit dem Dividieren des Quotienten wie in Schritt 3 besprochen fort und erhöhen Sie i bei jeder Iteration um eins.
5. Addieren Sie alle Produkte und geben Sie die Ergebnisse zurück.

Es gibt mehrere Implementierungsmöglichkeiten, um das Problem zu lösen. Beginnen wir mit der Diskussion dieser Ansätze nacheinander.

Methode 1: Konvertieren mit Loop- und Integer-Variablen

Die Schleifen for und while können Binär- in Dezimalzahlen umwandeln.

Verwenden Sie die while-Schleife

Bei diesem Ansatz wandelt die Divisionsoperation binär in dezimal um.

#include <math.h>
#include <stdio.h>
int main() {
  int binary_number;
  printf("Enter Binary number: ");
  scanf("%d", &binary_number);
  int decimal = 0, temp = 0, reminder;
  while (binary_number != 0) {
    reminder = binary_number % 2;
    binary_number = binary_number / 10;
    decimal = decimal + reminder * (int)pow(2, temp);
    temp++;
  }
  printf("Decimal number is : %d", decimal);
  return 0;
}

Die erste Zeile in main() deklariert eine Variable namens binary_number, um binäre Eingaben zu akzeptieren. Nachdem wir Eingaben für Binärzahlen entgegengenommen haben, deklarieren wir die drei Variablen weiter:

1. decimal: um den resultierenden Dezimalwert zu speichern
2. temp: um als Iterationszähler zu dienen
3. remainder: um den Rest in jeder Iteration zu speichern

Bei jeder Iteration der while-Schleife ermitteln wir zuerst das Bit ganz rechts aus der binary_number und speichern es in der Variablen remainder.

Dann dividieren wir die binary_number durch zehn und überschreiben das Ergebnis mit sich selbst. Dadurch verliert die binary_number ihr rechtes Bit.

Darüber hinaus wenden wir, wie am Anfang des Artikels besprochen, die Formel an, um die gewichteten Produkte in der Variablen decimal zu aggregieren. Am Ende drucken wir das resultierende Dezimaläquivalent aus.

Schauen wir uns die Ausgabe an.

Verwenden Sie die for-Schleife

Die Grundstruktur beider Schleifen (for und while) ist ähnlich. Der Vorteil der Verwendung einer for-Schleife ist die einfache Deklaration und Initialisierung der Variablen in einer einzigen Zeile.

Hier ist ein weiteres Programm, um die Binärzahlen mithilfe der for-Schleife in Dezimalwerte umzuwandeln.

#include <stdio.h>
int main() {
  int binary, decimal = 0, base = 1, remainder, temp;
  printf("Enter binary number: ");
  scanf("%d", &binary);
  for (temp = binary; temp > 0; temp = temp / 10) {
    remainder = temp % 2;
    decimal = decimal + remainder * base;
    base = base * 2;
  }
  printf("Decimal number is:%d", decimal);
  return 0;
}

Bei der Implementierung der for-Schleife haben wir einen etwas anderen Ansatz verwendet als bei der while-Schleife.

Anstatt eine kostspielige pow()-Funktion zu verwenden, haben wir einfach eine Variable base erstellt, die sich bei jeder Iteration mit einem Wert von 2 multipliziert. Dadurch wird sichergestellt, dass zu Beginn der i^th^-Iteration die Variable base einen Wert hat, der 2^i^ entspricht, wobei i bei Null beginnt.

Ausgang:

Methode 2: Verwenden Sie einen prozeduralen Ansatz

Diese Methode verwendet eine benutzerdefinierte Prozedur oder Funktion, um das Konvertierungsproblem zu lösen. Dieser Ansatz ist am wünschenswertesten, wenn Sie Ihren Code wiederverwendbarer und modularer machen möchten.

#include <math.h>
#include <stdio.h>
int binarytodecimal(int binary_number) {
  int decimal = 0, temp = 0, remainder;
  while (binary_number != 0) {
    remainder = binary_number % 2;
    decimal = decimal + (remainder * pow(2, temp));
    binary_number = binary_number / 10;
    temp++;
  }
  return decimal;
}

int main() {
  int binary_number, decimal;
  printf("Enter binary number: ");
  scanf("%d", &binary_number);
  decimal = binarytodecimal(binary_number);

  printf("Decimal Number is: %d", decimal);
  return 0;
}

Alles ist dasselbe wie bei unserer vorherigen Methode, außer dass wir den gesamten Konvertierungscode in eine einzige Prozedur eingeschlossen haben, binarytodecimal().

Methode 3: Verwenden Sie das char-Array, um die Binärzahl zu speichern

Bei allen zuvor besprochenen Methoden ist das Hauptproblem die Größe der ganzen Zahl. Wir haben Binärzahlen in Integer-Codierung gespeichert.

Für einen 16-bit-Compiler war die größte Zahl, die wir bereitstellen konnten, 111111.

Die 32-bit- und 64-bit-Compiler mit grösseren Integer-Größen werden sicherlich den Eingabebereich erhöhen und das Problem lösen. Das Problem wird uns jedoch in den älteren Versionen erschrecken.

Glücklicherweise haben wir einen Hack, um das Problem zu lösen, d. h. verwenden Sie ein dynamisches char-Array, um Binärzahlen anstelle der Integer-Variablen zu speichern. Schauen wir uns den folgenden Code an, um die Strategie zu verstehen.

#include <conio.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
  long decimal = 0;
  int size;
  printf("\nEnter maximum number of digits in your Binary number: ");
  scanf("%d", &size);

  char* BinaryArr = (char*)malloc(size + 1);

  printf("Please Enter your Binary Number: ");
  scanf("%s", BinaryArr);

  char ch;
  for (int i = size - 1, j = 0; i >= 0; i--, j++) {
    ch = BinaryArr[i];
    decimal += atoi(&ch) * (int)pow(2, j);
  }

  printf("The equivalent decimal number is: %d", decimal);
  return 0;
}

Wir bitten die Benutzer zunächst, die Größe der Binärzahl zu bestätigen, die sie in ein Dezimaläquivalent umwandeln möchten.

Da wir die Größe der Binärzahl kennen, weisen wir mit der Funktion malloc() dynamisch ein Array dieser Größe zu. Das malloc() ist in stdlib.h definiert und weist dynamischen Speicher in Bytes zu.

Um es zu einem Zeichenarray zu machen, haben wir den Rückgabezeiger von malloc() explizit in einen char*-Typ umgewandelt.

Hinweis: Die zusätzliche 1 in malloc(size +1) ist darauf zurückzuführen, dass wir Platz für das Zeichen \0 am Ende haben wollen.

Als nächstes nehmen wir die Binärzahl als Eingabe in das Zeichenarray, auf das der Zeichenzeiger BinaryArr zeigt.

Danach beginnen wir mit der Iteration dieses Zeichenarrays ab dem letzten Index (d. h. dem niedrigstwertigen Bit der Binärzahl) und nehmen Binärzeichen, die sich nach jeder Iteration näher an den Index 0 bewegen.

Wir speichern den i^th^-Index bei jeder Iteration in einer ch-Hilfsvariablen. Dann wenden wir die Funktion atoi() an, um einen äquivalenten ganzzahligen Wert zu erhalten.

Dann fügen wir alles in die Formel ein, die am Anfang dieses Artikels besprochen wurde.

Schließlich, sobald die Schleife endet, geben wir den endgültigen Dezimalwert aus. Mal sehen, wie es sich auf der Ausgabekonsole anfühlt.