Halb Addierer, Voll Addierer Problem

[Hudini]

Hallo leute,

Ich hab dar ein Problem beim programmieren eines Voll und Halb Addierers.

vielleicht könntet ihr ja mir helfen;

Das program hat 4 Klassen,

Klasse Bit:

/**

 * Die Klasse Bit repraesentiert eine Binaerziffer. 

 */

class Bit {


    // Binaerziffer 

    boolean b;


    /**

     * Erzeugt Bitobjekt und initialisiert Binaerziffer mit Wert 0 (false).

     */

    Bit() {

	this.b = false;

    } 


    /**

     * Erzeugt Bitobjekt und initialisiert Binaerziffer mit uebergebenen Wert. 

     */

    Bit(boolean  {

	this.b = b;

    }    

    /**

     * Erzeugt Bitobjekt und initialisiert Binaerziffer mit uebergebenen Wert. 

     * Der uebergebene int-Wert muss entweder 0 oder 1 sein. Die Binaerziffer 

     * wird mit false initialisiert, genau dann, wenn n = 0.

     */

    Bit(int n) {


	if(n == 0) {

	    this.b = false;

	} else {

	    this.b = true;

	}

    }


    /**

     * Liefert true genau dann zurueck, wenn dieses Bit gesetzt (= 1, true) ist.

     */

    boolean isSet() {

	return b;

    }


    /**

     * Liefert 1 zurueck, wenn dieses Bit gesetzt ist und andernfalls 0.

     */ 

    int getValue() {

	if( {

	    return 1;

	} else {

	    return 0;

	}

    }

}[/code]




Halb Addierer:

[code]/** * Die Klasse HalfAdder implementiert einen Halbaddierer. */ class HalfAdder { // Uebertrag Bit carry; /** * Erzeugt neuen Halbaddierer mit Uebertrag 0. */ HalfAdder() { this.carry = new Bit(); } /** * Liefert die Summe der uebergebenen Bits zurueck. Der Uebertrag der * Addition wird im Attribut carry gespeichert. */ Bit add(Bit x, Bit y) { if (x==new Bit(1) && y == new Bit(1)){ this.carry= new Bit(1); } else{ this.carry= new Bit(0); } if ((x == new Bit(1) && y == new Bit(1)) || (x == new Bit(0) && y == new Bit(0))){ return (new Bit(0)); } else {return (new Bit(1));} } /** * Liefert den Uebertrag zurueck. */ Bit getCarry() { return this.carry; } }

Voll Addierer:

/**

 * Die Klasse FullAdder implementiert einen Volladdierer. 

 */

class FullAdder {


    // Uebertrag

    Bit carry;


    // Halbaddierer.

    HalfAdder ha1;

    HalfAdder ha2;



    /**

     * Erzeugt neuen Volladdierer mir Uebertrag 0 und zwei Halbaddierern.

     */

    FullAdder() {

	this.carry = new Bit();	

	this.ha1 = new HalfAdder();

	this.ha2 = new HalfAdder();

    }


    /**

     * Liefert die Summe der uebergebenen Bits zurueck. Der Uebertrag der 

     * Addition wird im Attribut carry gespeichert.

     */ 

    Bit add(Bit x, Bit y, Bit c_in) {

        Bit add = this.ha1.add(x, y);

     c_in=ha1.getCarry();

     x= add;

     y= c_in;

        Bit add1 = this.ha2.add(x, y);

        this.carry =ha2.getCarry();

        return add1;

     } 


    /**

     * Liefert den Uebertrag zurueck. 

     */ 

    Bit getCarry() {

        return this.carry;

    }

}

TestKlasse:

/**

 * Die Klasse TestAdder implementiert einen Test fuer die Klasse FullAdder. #

 * Die Addition des Volladdieres wird fuer alle 8 moeglichen Eingabekombi-

 * nationen x, y, c getestet. Die Wertetabelle wird im Format 

 *

 *     x  y  c  z  cout

 *

 * ausgegeben. Dabei ist z die Summe der Addtion und cout der Uebertrag. 

 */

class TestAdder {


    // Eingabewerte x, y, c

    static int[][] x = {

	{0, 0, 0},

	{0, 0, 1},

	{0, 1, 0},

	{0, 1, 1},

	{1, 0, 0},

	{1, 0, 1},

	{1, 1, 0},

	{1, 1, 1},

    };



    public static void main(String[] args) {

	FullAdder fa = new FullAdder();

	Bit[] val = new Bit[5];

	System.out.println("x  y  c  z  cout");

	for(int k = 0; k < 8; k++) {

	    for(int i = 0; i < 3; i++) {

		val[i] = new Bit(x[k][i]);

	    }

	    val[3] = fa.add(val[0], val[1], val[2]);

	    val[4] = fa.getCarry();


	    for(int i = 0; i < 5; i++) {

		System.out.print(val[i].getValue() + "  ");

	    }

	    System.out.println();

	}

    }

}

Der Fehler ist dass bei der Ausgabe cout für jeden fall 0 ist und Die summe für jeden fall 1 ist Konsole ausgabe:

init:

deps-jar:

Compiling 1 source file to /home/cihan/NetBeansProjects/Addierer/build/classes

compile:

run:

x  y  c  z  cout

0  0  0  1  0  

0  0  1  1  0  

0  1  0  1  0  

0  1  1  1  0  

1  0  0  1  0  

1  0  1  1  0  

1  1  0  1  0  

1  1  1  1  0  

BUILD SUCCESSFUL (total time: 0 seconds)

Ich danke schon jetzt auf jede antwort.

[Klotzkopp]

if (x==new Bit(1) && y == new Bit(1)){

Das ist niemals wahr. Der == Operator prüft bei Referenztypen nicht auf Gleichheit, sondern auf Identität, also ob die beiden Operanden auf dasselbe Objekt verweisen. Da du das eine aber gerade eben erst erzeugst, ist das immer false.

Überschreibe equals für deine Bit-Klasse und benutz das.

Außerdem machst du in FullAdder.add eine Zuweisung an c_in, bevor du den Wert darin verwendet hast. Der ursprünglich übergebene Parameterwert ist damit weg.

[Hudini]

Danke nochmals aber es gibt immer noch die Gleiche Ausgabe aus. Hier ist nochmal was ich geändert habe

/**

 * Die Klasse FullAdder implementiert einen Volladdierer. 

 */

class FullAdder {


    // Uebertrag

    Bit carry;


    // Halbaddierer.

    HalfAdder ha1;

    HalfAdder ha2;



    /**

     * Erzeugt neuen Volladdierer mir Uebertrag 0 und zwei Halbaddierern.

     */

    FullAdder() {

	this.carry = new Bit();	

	this.ha1 = new HalfAdder();

	this.ha2 = new HalfAdder();

    }


    /**

     * Liefert die Summe der uebergebenen Bits zurueck. Der Uebertrag der 

     * Addition wird im Attribut carry gespeichert.

     */ 

    Bit add(Bit x, Bit y, Bit c_in) {

         this.ha1.add(x, y);

     Bit c1=this.ha1.getCarry();


        Bit add = this.ha2.add(c1, c_in);

        this.carry = this.ha2.getCarry();

        return add;

     } 


    /**

     * Liefert den Uebertrag zurueck. 

     */ 

    Bit getCarry() {

        return this.carry;

    }

}

Halb addierer:

/**

 * Die Klasse HalfAdder implementiert einen Halbaddierer. 

 */

class HalfAdder {


    // Uebertrag

    Bit carry;


    /**

     * Erzeugt neuen Halbaddierer mit Uebertrag 0. 

     */

    HalfAdder() {

	this.carry = new Bit();


    }


    /**

     * Liefert die Summe der uebergebenen Bits zurueck. Der Uebertrag der 

     * Addition wird im Attribut carry gespeichert.

     */ 

    Bit add(Bit x, Bit y) {

     if ((x.equals(new Bit(1))) && (y.equals(new Bit(1)))){

            this.carry= new Bit(1);

     }


     else{

         this.carry= new Bit(0);

     }

if ((x.equals(new Bit(1)) && y.equals(new Bit(1))) || (x.equals(new Bit(0)) && y.equals(new Bit(0)))){    


return (new Bit(0));

    }


        else {

         return (new Bit(1));}


    } 


    /**

     * Liefert den Uebertrag zurueck. 

     */ 

    Bit getCarry() {

	return this.carry;


	 }

}

[Dragon8]

Jetzt musst du aber auch noch die equals()-Methode in deiner Klasse Bit überschreiben, ansonsten passiert auch so, dasselbe wie vorher, da die equals()-Methode von Object, die du ja jetzt in deiner Bit-Klasse benutzt, auch nur die Referenzen vergleicht.

[VaNaTiC]

if ((x == new Bit(1) && y == new Bit(1)) || (x == new Bit(0) && y == new Bit(0)))

ich vermute, Du wolltest damit die beiden möglichen Zustände abbilden, die ein bool annehmen kann und als Schnellzugriff bereithalten. Sowas macht man mit static const privaten (oder selten public) members. private static const Bit.TRUE = new Bit(1); private static const Bit.FALSE = new Bit(0); Diese kannst Du dann in Deinen eigenen Klassen verwenden, indem Du aber IMMER (und deshalb ist das hier in diesem Fall eine gefährliche Alternative) diese Konstanten benutzt. Denn Du vergleichst wie bereits gesagt Referenzen. Wie auch bereits gesagt ist in Deinem Fall ist equals() auf alle Fälle besser.

if(n == 0) {

    this.b = false;

} else {

    this.b = true;

}

schreibt man auch einfach als

this.b = ( n != 0 );