Hilfe bei einigen Funktionen



  • Hallo Leute,

    ich habe einige Fragen und hoffe ihr könnt mir helfen, da ich blutiger Anfänger bin was programmieren angeht.
    Mein Problem ist, das ich nicht verstehe wie der Code den ich habe genau funktioniert.

    #include<stdio.h>
    #include <iostream>
    
    
    using namespace std;
    
    
    void dez_to_bin(int bit_vektor[], int dez_zahl, int bitanzahl)
    {
    	bool zw_erg = false;
    	int x;
    
    		for (int i = 0; i < bitanzahl; i++)
    	{	
    		zw_erg = dez_zahl & (0b1 << i);
    		x = bitanzahl - i;
    		bit_vektor[x] = zw_erg;
    		zw_erg = false;
    	
    	}
    
    }
    
    void ausgabe(int binzahl[], int anzahl_bits)
    {
    
    	for (int i = 1; i <= (anzahl_bits); i++) {
    		cout << binzahl[i];
    	}
    	cout << '\n';
    	
    }
    
    void halb_add(int ergebnis[], int bin_zahl1[], int bin_zahl2[], bool sum_carry)
    {
    
    	if (sum_carry)
    	{
    
    		// für Summe
    		for (int i = 0; i <= 31; i++)
    		{
    
    			ergebnis[i] = (bin_zahl1[i] ^ bin_zahl2[i]);
    		}
    	}
    
    	else
    	{
    
    		//für carry
    		for (int i = 0; i <= 31; i++)
    		{
    
    			ergebnis[i] = (bin_zahl1[i] & bin_zahl2[i]);
    
    		}
    	}
    }
    
    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 1
    	int s_1[32] = { 0 };	// Summe vom Halbaddierer 1
    							//int s_2[32] = { 0 };	// Summe vom Halbaddierer 2
    	int c_2[32] = { 0 };	// analog zu c_1
    
    							//halb_add(c_in, bin_zahl1, bin_zahl2, false);
    
    
    	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] = c_1[i] | c_2[i];
    			ergebnis[i] = s_1[i] ^ c_in[i];
    			c_in[i - 1] = c_out[i];
    			//ausgabe(ergebnis, bitanzahl);
    		}
    
    
    		//for (int i = 0; i <= bitanzahl - 1; i++) {
    		//	c_out[i] = c_in[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] = c_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;
    
    
    
    }
    
    

    Ich habe mehrere Funktionen, 1. void dez_to_bin damit sollen Dezimalzahlen in Binär umgewandelt werden und der Benutzer kann die Anzahl der Bitstellen festlegen.
    2. void ausgabe diese Funktion soll die Berechnung der ersten Funktion ausgeben.

    Nun weiß ich leider nicht wie die erste Funktion das macht und wie Sie die Ergebnisse an die zweite übergibt.
    Ich habe noch mehr Fragen, möchte aber erst einmal wissen wie der Anfang im Detail abläuft.

    Fragt bitte nicht warum das alles so gelöst wurde, so waren die Vorgaben und ein großer Teil des Programms war vorgegeben.

    Danke schon einmal im Voraus

    Gruß
    Alex



  • @Al-ex sagte in Hilfe bei einigen Funktionen:

    Nun weiß ich leider nicht wie die erste Funktion das macht

    Sie nimmt eine Bitmaske (in der nur 1 Bit gesetzt ist) und verUNDet es mit der Zahl.
    Ist das enstprechende Bit gesetzt, ist das Ergebnis ungleich 0.
    Dann wird die Bitmaske für die nächste Stelle berechnet.

    Allerdings ist die Umsetzung nicht ganz richtig. ( ich hab das bool übersehen)

    @Al-ex sagte in Hilfe bei einigen Funktionen:

    und wie Sie die Ergebnisse an die zweite übergibt.

    Gar nicht.
    Das macht mainmit dem übergebenen Array bin_zahl1 bzw. bin_zahl2.

    ausgabe() ist allerdings auch nicht richtig umgesetzt.



  • Danke für die Antwort. Nicht richtig umgesetzt? Das Programm läuft ja und zwar so wie es soll. Nur konnte ich nicht genau nachvollziehen wie.



  • @Al-ex sagte in Hilfe bei einigen Funktionen:

    Das Programm läuft ja und zwar so wie es soll. Nur konnte ich nicht genau nachvollziehen wie.

    Es wird aber munter über Arraygrenzen hinaus geschrieben.
    Du kannst ja mal die ersten Zeilen von voll_add ändern:

    void voll_add(int ergebnis[], int bin_zahl1[], int bin_zahl2[], bool sum_carry, int bitanzahl)
    {
    	std::array<int, 33> c_in;	// carry in
    	std::array<int, 32> c_out;	// carry out
    
    	std::array<int, 32> c_1;	// carry vom Halbaddierer 1
    	std::array<int, 32> s_1;	// Summe vom Halbaddierer 1
    	std::array<int, 32> c_2;	// analog zu c_1
    ...
    

    Und #include <array> nicht vergessen.


Anmelden zum Antworten