Volladdierer



  • Hallo Leute,

    da ich seit Stunden nicht weiter Komme habe ich mal eine Frage an euch.
    Ich muss einen einige Funktionen entwickeln, einen Dezimal zu Binär Rechner, einen Halbaddierer und einen Volladdierer.

    Habe alles gemacht und musste leider feststellen, dass mein Volladdierer falsche Werte für den carry und die summe ausgibt.
    Irgendwie stehe ich auf dem Schlauch und kann mich nicht genug konzentrieren um den Fehler zu finden.

    Ich werde es natürlich weiter versuchen, wäre aber für eure Hilfe sehr dankbar.

    Liebe Grüße
    Andrej

    #include<stdio.h>
    #include <iostream>
    
    using namespace std;
    
    
    
    
    void dez_to_bin(int bit_vektor[], int dez_zahl, int bitanzahl)
    
    {
    
    	for (int i = 0; i < bitanzahl; i++)
    	{
    		bit_vektor[i] = fabs((dez_zahl >> i) % 2);
    	}
    
    
    }
    
    void halb_add(int ergebnis[], int bin_zahl1[], int bin_zahl2[], bool sum_carry)
    {
    
    	if (sum_carry)
    	{
    
    		// fuer Summe
    		for (int i = 0; i <= 31; i++)
    		{
    
    			ergebnis[i] = (bin_zahl1[i] ^ bin_zahl2[i]);
    		}
    	}
    
    	else
    	{
    
    		//fuer carry
    		for (int i = 0; i <= 31; i++)
    		{
    
    			ergebnis[i] = (bin_zahl1[i] & bin_zahl2[i]);
    
    		}
    	}
    }
    
    void ausgabe(int binzahl[], int anzahl_bits)
    {
    
    
    	for (int i = anzahl_bits - 1; i >= 0; i--)
    	{
    		cout << binzahl[i];
    	}
    
    
    
    	cout << endl;
    }
    
    void voll_add(int ergebnis[], int bin_zahl1[], int bin_zahl2[], bool sum_carry, int bitanzahl)
    {
    	int c_in[33] = { 0 };	// carry in
    	int c_out[32] = { 0 };	// carry out
    
    	int c_1[32] = { 0 };	// carry vom Halbaddierer
    	int s_1[32] = { 0 };	// Summe vom Halbaddierer
    	int c_2[32] = { 0 };	// analog zu c_1
    
    
    
    	if (sum_carry)
    	{
    		for (int i = bitanzahl; i > 0; i--)
    		{
    			c_1[i] = bin_zahl1[i] & bin_zahl2[i];
    			s_1[i] = bin_zahl1[i] ^ bin_zahl2[i];
    			c_2[i] = s_1[i] & c_in[i];
    			c_out[i] = s_1[i] | c_2[i];
    			ergebnis[i] = s_1[i] ^ c_in[i];
    			c_in[i - 1] = c_out[i];
    
    		}
    
    	}
    	else
    	{
    		for (int i = bitanzahl; i > 0; i--)
    		{
    			c_1[i] = bin_zahl1[i] & bin_zahl2[i];
    			s_1[i] = bin_zahl1[i] ^ bin_zahl2[i];
    			c_2[i] = s_1[i] & c_in[i];
    			c_out[i] = s_1[i] | c_2[i];
    			ergebnis[i] = c_out[i];
    			c_in[i - 1] = c_out[i];
    
    		}
    
    	}
    
    }
    
    
    	int main()
    	{
    
    	
    
    		int dez_zahl1, dez_zahl2, anzahl_bits;
    
    		int bin_zahl1[32] = { 0 };
    		int bin_zahl2[32] = { 0 };
    		int summe[32] = { 0 };
    		int carry[33] = { 0 };
    
    		cout << "Geben Sie 2 dezimale Zahlen ein:" << endl;
    		cin >> dez_zahl1 >> dez_zahl2;
    		cout << endl;
    
    		cout << "Geben Sie Anzahl der Bits fuer binaere Darstellung ein:" << endl;
    		cin >> anzahl_bits;
    
    		// Konvertierung in Bin�rdarstellung
    		dez_to_bin(bin_zahl1, dez_zahl1, anzahl_bits);
    		dez_to_bin(bin_zahl2, dez_zahl2, anzahl_bits);
    
    		// Ergebnisse f�r Halbaddierer
    		cout << "\n\n========Halbaddierer========" << endl;
    
    		cout << " ";
    		ausgabe(bin_zahl1, anzahl_bits);
    		cout << "+";
    		ausgabe(bin_zahl2, anzahl_bits);
    		cout << "______________________" << endl;
    
    		halb_add(summe, bin_zahl1, bin_zahl2, true);
    		halb_add(carry, bin_zahl1, bin_zahl2, false);
    
    		ausgabe(carry, anzahl_bits);
    		cout << " ";
    		ausgabe(summe, anzahl_bits);
    		cout << endl;
    
    		cout << "========Halbaddierer========" << endl;
    
    		// Ergebnisse f�r Volladdierer
    		cout << "\n\n========Volladdierer========" << endl;
    
    		cout << " ";
    		ausgabe(bin_zahl1, anzahl_bits);
    		cout << "+";
    		ausgabe(bin_zahl2, anzahl_bits);
    		cout << "______________________" << endl;
    
    
    		voll_add(summe, bin_zahl1, bin_zahl2, true, anzahl_bits);
    		voll_add(carry, bin_zahl1, bin_zahl2, false, anzahl_bits);
    
    		ausgabe(carry, anzahl_bits);
    		cout << " ";
    		ausgabe(summe, anzahl_bits);
    		cout << endl;
    
    		system("pause");
    		return 0;
    	}
    
    


  • Erstmal: Für deine ganzen arrays gibt es in C++ std::vector (oder, wenn's feste länge haben soll, std::array). Damit würde sich auch die Eingabe der Länge erübrigen.
    Dann kann ein Volladierer (wenn ich mich richtig erinnere) genau 3 einstellige Binärzahlen addieren: zahl 1 + zahl 2 + carry in
    Wenn du mehrstellige Zahlen addieren willst, läuft das über eine Hintereinanderschaltung von Volladierern. Das würde ich auch genau so implementieren und nicht versuchen mit 6 Arrays in einer Schleife zu lösen.
    Was macht das "sum_carry" Flag?

    Prinzipiell ist bei solchen Fragestellungen auch interessant: was ist deine Eingabe, was deine Ausgabe und was deine erwartete Ausgabe?

    Hilfreich für dich könnte sein, dich mit einem Debugger vertraut zu machen und die einzelnen Steps mal durchzugehen. Dann siehst du genau, was wo drin steht und wann es von deiner Erwartung abweicht.



  • Das Problem ist das vieles vorgegeben ist, z.B. das mit den ganzen Vectoren/arrays und auch die Eingabe wie viele Bits angezeigt werden sollen.



  • Was genau ist denn vorgegeben?
    Edit: Die Benennung im Volladdierer ("carry vom Halbaddierer") lässt eigentlich darauf schließen, dass du da den Halbaddierer wiederverwenden sollst.



  • Habe vergessen mich sofort zu melden, hab es aber dann aber doch selber zum laufen gebracht. Trotzdem Danke für die Hilfeversuche :).

    Hier ist der Teil mit dem Volladdierer:

    #include<stdio.h>
    #include <iostream>
    #include "Header.h"
    using namespace std;
    
    /* zu Aufgabe 4b.1:
    Beschreibung:
    
    Funktion beschreibt einen Volladdierer durch logische Gleichungen
    fuer Summe und Uebertag.
    
    Uebergabeparameter:
    
    bin_zahl1	- die zu addierende Binaerzahl (als Feld),
    bin_zahl2	- die zu addierende Binaerzahl (als Feld),
    sum_carry	- Je nach Auswahl Berechnung der Summe oder des Uebertrags.
    ergebnis	- Ergebnisarray aus den Bitstellen der Summe / des Uebertrags.
    
    */
    void voll_add(int ergebnis[], int bin_zahl1[], int bin_zahl2[], bool sum_carry, int bitanzahl)
    {
    	int c_in[33] = { 0 };	// carry in
    	int c_out[32] = { 0 };	// carry out
    
    	int c_1[32] = { 0 };	// carry vom Halbaddierer
    	int s_1[32] = { 0 };	// Summe vom Halbaddierer
    	int c_2[32] = { 0 };	// analog zu c_1
    
    
    	// *******************************************************************************
    	// dieser Block beschreibt Funktionsweise eines Volladdierers
    	
    	if (sum_carry)
    	{
    		for (int i = 0; i < 32; i++)
    		{
    			s_1[i] = halb_add_1bit(bin_zahl1[i], bin_zahl2[i], true);
    			c_1[i] = halb_add_1bit(bin_zahl1[i], bin_zahl2[i], false);
    			c_2[i] = halb_add_1bit(s_1[i], c_in[i], false);
    
    			ergebnis[i] = halb_add_1bit(s_1[i], c_in[i], true);
    
    			c_out[i] = c_1[i] | c_2[i];
    			c_in[i + 1] = c_out[i];
    		}
    	}
    
    	else
    	{
    		for (int i = 0; i < 32; i++)
    		{
    			c_1[i] = halb_add_1bit(bin_zahl1[i], bin_zahl2[i], false);
    			s_1[i] = halb_add_1bit(bin_zahl1[i], bin_zahl2[i], true);
    
    			c_2[i] = halb_add_1bit(s_1[i], c_in[i], false);
    
    			ergebnis[i] = c_1[i] | c_2[i];
    
    			c_in[i + 1] = ergebnis[i];
    		}
    	}
    
    
    	
    
    	
    
    	// *******************************************************************************
    }
    
    
    


  • Du machst das glaube unnötig kompliziert, da man pro Bit nur 2 Halbaddierer braucht, bei dir seh ich 4 Aufrufe. Ausserdem hat ein Halbaddierer 2 Bit als Ausgabe. Vlt sollte es ungefähr so ausehen:

    halbAddierer h1(summandA[i], SummandB[i]);
    halbAddierer h2(carry[i-1],h1.sum);
    ergebnis[i]=h2.sum
    carry[i]= h1.carry or h2.carry;
    

Log in to reply