[JAVA] Breuken Applet

[HekkeySE]

Ik moet deze klasse voor mijn opleiding maken. Maar het lukt me niet om het af te krijgen...kan iemand mij helpen? pleazzzz?

Schrijf een klasse "Breuk" die de omgang met breuken versimpelt. Er dienen op de Breuk klasse methoden aanwezig te zijn om breuken op te tellen, af te trekken, te vermenigvuldigen en te delen. Tevens dient een methode een breuk te kunnen vereenvoudigen, bijvoorbeeld 6/8 wordt 3/4. De weergave van een breuk op het scherm dient ook steeds t/n te zijn, waarin t en n de teller resp. de noemer zijn. Voorbeeld : 7/8 of 31/32 etc.

Maak voor de klasse twee constructoren : één zonder parameter en één met parameters teller en noemer. De klasse dient te worden gedemonstreerd m.b.v. een applet waarin vier invoervelden ten behoeve van de invoer van twee breuken en een aantal knoppen om de verschillende bewerkingen te laten uitvoeren.

Java:

public class Applet1 extends Applet {
    private Breuk b;
    TextField v_teller1, v_teller2, v_noemer1, v_noemer2;
    Button k_telop, k_trekaf, k_vermedigvuldig, k_deel;

    public void init() {
        setLayout(null);

        b = new Breuk();

        v_teller1 = new TextField();
        v_teller1.setBounds(50, 90, 20, 20);

        v_teller2 = new TextField();
        v_teller2.setBounds(50, 110, 20, 20);

        v_noemer1 = new TextField();
        v_noemer1.setBounds(100, 90, 20, 20);

        v_noemer2 = new TextField();
        v_noemer2.setBounds(100, 110, 20, 20);

        add(v_teller1);
        add(v_teller2);
        add(v_noemer1);
        add(v_noemer2);

        k_telop = new Button("+");
        k_telop.addActionListener(new TelOpHandler());
        k_telop.setBounds(75, 70 , 20, 20);

        k_trekaf = new Button("-");
        k_trekaf.addActionListener(new TrekAfHandler());
        k_trekaf.setBounds(75, 90 , 20, 20);

        k_vermedigvuldig = new Button("x");
        k_vermedigvuldig.addActionListener(new vermedigvuldigHandler());
        k_vermedigvuldig.setBounds(75, 110 , 20, 20);

        k_deel = new Button("/");
        k_deel.addActionListener(new DeelHandler());
        k_deel.setBounds(75, 130 , 20, 20);

        add(k_telop);
        add(k_trekaf);
        add(k_vermedigvuldig);
        add(k_deel);
    }



    public void paint (Graphics g) {
        b.tekenBreuk(g);
    }


    class TelOpHandler implements ActionListener {
        public void actionPerformed(ActionEvent e) {
        b.telOp(Integer.parseInt(v_teller1.getText()),
            Integer.parseInt(v_noemer1.getText()),
            Integer.parseInt(v_teller2.getText()),
            Integer.parseInt(v_noemer2.getText()));
            repaint();
        }
    }


    class TrekAfHandler implements ActionListener {
        public void actionPerformed(ActionEvent e) {
        b.trekAf(Integer.parseInt(v_teller1.getText()),
            Integer.parseInt(v_noemer1.getText()),
            Integer.parseInt(v_teller2.getText()),
            Integer.parseInt(v_noemer2.getText()));
            repaint();
        }
    }


    class vermedigvuldigHandler implements ActionListener {
        public void actionPerformed(ActionEvent e) {
        b.vermedigvuldig(Integer.parseInt(v_teller1.getText()),
            Integer.parseInt(v_noemer1.getText()),
            Integer.parseInt(v_teller2.getText()),
            Integer.parseInt(v_noemer2.getText()));
            repaint();
        }
    }


    class DeelHandler implements ActionListener {
        public void actionPerformed(ActionEvent e) {
        b.deel(Integer.parseInt(v_teller1.getText()),
            Integer.parseInt(v_noemer1.getText()),
            Integer.parseInt(v_teller2.getText()),
            Integer.parseInt(v_noemer2.getText()));
            repaint();
        }
    }

}


class Breuk {
    private int teller, noemer;

    public Breuk() {

    }

    public Breuk(int teller, int noemer) {
        this.teller = teller;
        this.noemer = noemer;
    }

    public void telOp(int tel1, int noem1, int tel2, int noem2) {
        teller = tel1 + tel2;
        noemer = noem1 + noem2;
    }

    public void trekAf(int tel1, int noem1, int tel2, int noem2) {
        teller = tel1 - tel2;
        noemer = noem1 - noem2;
    }

    public void vermedigvuldig(int tel1, int noem1, int tel2, int noem2) {
        teller = tel1 * tel2;
        noemer = noem1 * noem2;
    }

    public void deel(int tel1, int noem1, int tel2, int noem2) {
        teller = tel1 * noem2;
        noemer = tel2 * noem1;
    }

    public void tekenBreuk(Graphics g) {
        g.drawString("" + teller, 150, 105);
        g.drawLine(150, 110, 162, 110);
        g.drawString("" + noemer, 150, 125);

    }


}

[gorgi_19]

2 vragen:
1. Wat lukt er niet? Foutmeldingen etc. zijn we hier dol op
2. Kan je [code=java][/code] gebruiken om je code heen?

[ Voor 6% gewijzigd door gorgi_19 op 12-05-2003 21:35 ]

[HekkeySE]

gorgi_19 schreef op 12 May 2003 @ 21:35:
2 vragen:
1. Wat lukt er niet? Foutmeldingen etc. zijn we hier dol op
2. Kan je [code=java][/code] gebruiken om je code heen?

1. Geen foutmeldingen maar krijg de verkleining en de juiste breuk verhouding niet.
2. Gedaan! Thnx

[Hu9o]

zet je code ff tusen [ code=java ] tags (zonder spatie)

beter zo.

[ Voor 15% gewijzigd door Hu9o op 12-05-2003 21:37 ]

[Glimi]

Huiswerk mag je zelf maken! Concrete vragen, waarbij je laat zien dat je gezocht hebt en er zelf moeite voor gedaan hebt zijn geen probleem, maar zo je opgave maken? Nee!

Pas dus ajb je topic zo aan dat je laat zien dat je moeite hebt gedaan, de FAQ hebt gelezen, aangeeft wat er fout ging en iets duidelijker je probleem omschrijft (want wat gaat er in hemelsnaam fout)
Anders gaat ie op slot Hard, I know

[HekkeySE]

Glimi schreef op 12 May 2003 @ 21:38:
Huiswerk mag je zelf maken! Concrete vragen, waarbij je laat zien dat je gezocht hebt en er zelf moeite voor gedaan hebt zijn geen probleem, maar zo je opgave maken? Nee!

Pas dus ajb je topic zo aan dat je laat zien dat je moeite hebt gedaan, de FAQ hebt gelezen, aangeeft wat er fout ging en iets duidelijker je probleem omschrijft (want wat gaat er in hemelsnaam fout)
Anders gaat ie op slot Hard, I know

Deze code heb ik dus al gemaakt maar waar ik dus nu voor sta is de vereenvoudiging.
Ik weet niet waarmee ik moet beginnen om het eenvoudiger te maken. Gezocht op google en in het boek (en dan is er java) maar niks gevonden daarover.
Vandaar dat ik het vraag dat iemand mij op weg kan helpen.
Vraag dus niet om de opdracht te maken!

Sorry als ik niet duidelijk was

[ Voor 9% gewijzigd door HekkeySE op 12-05-2003 21:41 ]

[gorgi_19]

Hoe vereenvoudig je een breuk? Door te zoeken naar de grootste deler die geldig is voor zowel de teller als de noemer.

3 / 6; grootste deler die geldig is voor beiden is 3.
36 / 48: grooste deler die geldig is voor beiden is 12

* gorgi_19 kan alleen een heel ranzig 'algoritme' bedenken om deze te vinden, dus doet dat maar niet....

[ Voor 19% gewijzigd door gorgi_19 op 12-05-2003 21:43 ]

[Glimi]

[google=grootste gemene deler Java]
En nu weer aan het werk jij!

Als extra nog de helium implementatie

code:

gcd x y = gcd' (abs x) (abs y)
          where
             gcd' x 0 = x
             gcd' x y = gcd' y (x `rem` y)

[ Voor 58% gewijzigd door Glimi op 12-05-2003 21:52 ]

[HekkeySE]

gorgi_19 schreef op 12 May 2003 @ 21:42:
Hoe vereenvoudig je een breuk? Door te zoeken naar de grootste deler die geldig is voor zowel de teller als de noemer.

3 / 6; grootste deler die geldig is voor beiden is 3.
36 / 48: grooste deler die geldig is voor beiden is 12

* gorgi_19 kan alleen een heel ranzig 'algoritme' bedenken om deze te vinden, dus doet dat maar niet....

Java:

public void vereenvoudig noem1, int tel2, int noem2) { 
        teller = tel1 / noem2; 
        noemer = tel2 / noem1; 
    } 

Hoe zet ik dit dan in de code om het gelijk te krijgen...snap het principe wel, maar hoe te vertalen naar code

[HekkeySE]

Glimi schreef op 12 May 2003 @ 21:46:
[google=grootste gemene deler Java]
En nu weer aan het werk jij!

Thnx...ik ga het proberen.
Ik zal het posten als het is gelukt!

[crisp]

van het weekend toevallig eventjes een snelle PHP impelementatie in elkaar gefietst om breuken te verkleinen dmv faktorisering met priemgetallen. Aan jou de eer om het om te zetten naar Java

PHP:

<?php

$primes = Array(2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61);

$teller = 207;
$noemer = 441;

simplify_division($teller, $noemer);

echo $teller.'/'.$noemer;

function simplify_division(&$teller, &$noemer) {

  global $primes;

  $i = 0;

  while (sqrt(min($teller, $noemer)) >= $primes[$i]) {

    if ($teller % $primes[$i] === 0 && $noemer % $primes[$i] === 0) {
      $teller = $teller / $primes[$i];
      $noemer = $noemer / $primes[$i];
    } else {
      $i++;
      if (!isset($primes[$i])) $primes[$i] = find_next_prime($primes[$i - 1]);
    }

  }

}

function find_next_prime($lastprime) {

  global $primes;

  $nextprime = $lastprime;

  do {

    $nextprime += 2;

    $i = 1; // start with second prime
    $sqrt = floor(sqrt($nextprime));
    $is_prime = 1;

    do {

      if ($nextprime % $primes[$i] === 0) $is_prime = 0;

    } while ($is_prime && $primes[++$i] <= $sqrt);

  } while (!$is_prime);

  return $nextprime;

}

?>

[ Voor 14% gewijzigd door crisp op 12-05-2003 22:27 ]

[Nibble]

Ziehier mijn breuk klasse die ik tijdens C++ heb gemaakt. maar c++ en java schelen niet zo heel veel van elkaar dus hier moet je toch wel iets mee kunnen

C++:

Breuk::Breuk(){                                  //lege constructor
};

int Breuk::returnTeller(){
        return teller;
};

int Breuk::returnNoemer(){
        return noemer;
};

Breuk::Breuk(int teller, int noemer){            //maakt breuk waarden
        this->teller = teller;
        this->noemer = noemer;
};

Breuk::telOp(Breuk &b){                          //telt een nieuwe breuk bij de oude op
        this->teller    *= b.noemer;             //breuken gelijkmaken:
        b.teller        *= this->noemer;         //tellers vermenigvuldigen
        this->noemer *= b.noemer;                //noemer vermenigvuldigen
        b.noemer = this->noemer;                 //..
        b.teller += this->teller;                //optellen
        b.ggd();                                 //vereenvoudigen
        return 0;
};

Breuk::trekAf(Breuk &b){                          //telt een nieuwe breuk bij de oude op
        this->teller    *= b.noemer;             //breuken gelijkmaken:
        b.teller        *= this->noemer;         //tellers vermenigvuldigen
        this->noemer *= b.noemer;                //noemer vermenigvuldigen
        b.noemer = this->noemer;                 //..
        b.teller -= this->teller;                //verminderen
        b.ggd();                                 //vereenvoudigen
        return 0;
};

bool Breuk::compare(Breuk &b){                   //telt een nieuwe breuk bij de oude op
        b.ggd();                                 //gelijkmaken
        this->ggd();                             //als mogelijk
        if (b.returnTeller() == this->returnTeller() && b.returnNoemer() == this->returnNoemer()) return true;
        return false;
};


Breuk::vermenigvuldig(Breuk &b){                 //vermenigvuldig breuk met nieuwe breuk
        b.teller *= this->teller;                //vermenigvuldig teller met teller meegegeven breuk
        b.noemer *= this->noemer;                //idem met noemer;
        b.ggd();
        return 0;
};

Breuk::deel(Breuk &b){
        b.teller *= this->noemer;                //verminigvuldig huidige breuk met tijdelijk omgekeerde breuk
        b.noemer *= this->teller;                //.
        b.ggd();
        return 0;                                //deling compleet
};

int Breuk::ggd(){                                //schrijft de huidige breuk zo klein mogelijk
        int h,getal1,getal2;                     //vars
        getal1 = this->teller;
        getal2 = this->noemer;
           do {                      //bepaal ggd
              h = getal1 % getal2;
              getal1 = getal2;
              getal2 = h;
           } while (h);                  //doe zolang  h <> 0 s
                                                 //hier staat de GGD in getal1
        this->teller = (this->teller / getal1);  //deel de teller door de GGD
        this->noemer = (this->noemer / getal1);  //deel de noemer door de GGD
        return 0;
};

[ Voor 6% gewijzigd door Nibble op 12-05-2003 21:51 ]

[HekkeySE]

Nibble schreef op 12 May 2003 @ 21:51:
Ziehier mijn breuk klasse die ik tijdens C++ heb gemaakt. maar c++ en java schelen niet zo heel veel van elkaar dus hier moet je toch wel iets mee kunnen

C++:

Breuk::Breuk(){                                  //lege constructor
};

int Breuk::returnTeller(){
        return teller;
};

int Breuk::returnNoemer(){
        return noemer;
};

Breuk::Breuk(int teller, int noemer){            //maakt breuk waarden
        this->teller = teller;
        this->noemer = noemer;
};

Breuk::telOp(Breuk &b){                          //telt een nieuwe breuk bij de oude op
        this->teller    *= b.noemer;             //breuken gelijkmaken:
        b.teller        *= this->noemer;         //tellers vermenigvuldigen
        this->noemer *= b.noemer;                //noemer vermenigvuldigen
        b.noemer = this->noemer;                 //..
        b.teller += this->teller;                //optellen
        b.ggd();                                 //vereenvoudigen
        return 0;
};

Breuk::trekAf(Breuk &b){                          //telt een nieuwe breuk bij de oude op
        this->teller    *= b.noemer;             //breuken gelijkmaken:
        b.teller        *= this->noemer;         //tellers vermenigvuldigen
        this->noemer *= b.noemer;                //noemer vermenigvuldigen
        b.noemer = this->noemer;                 //..
        b.teller -= this->teller;                //verminderen
        b.ggd();                                 //vereenvoudigen
        return 0;
};

bool Breuk::compare(Breuk &b){                   //telt een nieuwe breuk bij de oude op
        b.ggd();                                 //gelijkmaken
        this->ggd();                             //als mogelijk
        if (b.returnTeller() == this->returnTeller() && b.returnNoemer() == this->returnNoemer()) return true;
        return false;
};


Breuk::vermenigvuldig(Breuk &b){                 //vermenigvuldig breuk met nieuwe breuk
        b.teller *= this->teller;                //vermenigvuldig teller met teller meegegeven breuk
        b.noemer *= this->noemer;                //idem met noemer;
        b.ggd();
        return 0;
};

Breuk::deel(Breuk &b){
        b.teller *= this->noemer;                //verminigvuldig huidige breuk met tijdelijk omgekeerde breuk
        b.noemer *= this->teller;                //.
        b.ggd();
        return 0;                                //deling compleet
};

int Breuk::ggd(){                                //schrijft de huidige breuk zo klein mogelijk
        int h,getal1,getal2;                     //vars
        getal1 = this->teller;
        getal2 = this->noemer;
           do {                      //bepaal ggd
              h = getal1 % getal2;
              getal1 = getal2;
              getal2 = h;
           } while (h);                  //doe zolang  h <> 0 s
                                                 //hier staat de GGD in getal1
        this->teller = (this->teller / getal1);  //deel de teller door de GGD
        this->noemer = (this->noemer / getal1);  //deel de noemer door de GGD
        return 0;
};

Jongens! Bedankt!
Ben nu hard aan het werk om hem over te krijgen naar java en denk dat dat wel gaat lukken.

Ik laat het jullie weten

[whoami]

Tja, Nibble.... Dat is niet echt de bedoeling geloof ik. Zo leert de TS er ook niets van; het enige dat hij nu nog hoeft te doen is de code porten.

[HekkeySE]

whoami schreef op 12 May 2003 @ 22:04:
Tja, Nibble.... Dat is niet echt de bedoeling geloof ik. Zo leert de TS er ook niets van; het enige dat hij nu nog hoeft te doen is de code porten.

Naja eigenlijk wel vind ik toch hoor. Porten naar java gaat ook niet 1,2,3. Door de fouten die ik dan onderweg tegenkom leer ik het zeker wel!

[Donderwolk]

Java:

public Breuk vereenvoudig( Breuk b ) {
    int kleinste = Math.min( Math.abs(b.teller), Math.abs(b.noemer) );
    for( int i = kleinste; i > 0; i-- ){
        if( (b.teller % i == 0) && (b.noemer % i == 0) )
            return new Breuk( b.teller / i, b.noemer / i );
    }
    return b;
}

[ Voor 21% gewijzigd door Donderwolk op 12-05-2003 22:48 . Reden: Het kan altijd efficienter ]

[crisp]

Die van Nibble is zeker netjes, en volgens mij ook nog een stuk efficienter dan dat ranzige ding van mij

[Nibble]

crisp schreef op 12 mei 2003 @ 22:10:
Die van Nibble is zeker netjes, en volgens mij ook nog een stuk efficienter dan dat ranzige ding van mij

danku danku danku danku
Ach, die opdracht heeft me een 8,5 opgeleverd.. dusse
Maar in mijn ervaring is het vaak irritanter om naar een oplossing te moeten blijven zoeken dan een voorbeeld uit te pluizen waarom dat zo gedaan is.
123 overnemen werkt niet nee.

[Soultaker]

Waarom gebruik je geen operator overloading voor de manipulatie van breuk-objecten in C++? En waarom leren ze je een ranzige Nederlandse coding standard aan?

[Nibble]

Soultaker schreef op 12 May 2003 @ 23:37:
Waarom gebruik je geen operator overloading voor de manipulatie van breuk-objecten in C++? En waarom leren ze je een ranzige Nederlandse coding standard aan?

operator overloading -> dat was niet de opdracht
nederlandse coding standaard -> nou, het zou wel eens kunnen dat je in nederland een nederlandse coding standard aanleerd. (klinkt vreemd he maar het is toch echt zo).
Maar ik moet eerlijk bekennen dat ik het alles behalve ranzig vind en zelfs erg duidelijk en helder, dus ik heb er totaal geen problemen mee. School en tevens bedrijven waarvoor ik gewerkt heb ook niet. Dus.. alles ok, alles onder control

[Verwijderd]

Toch is een Engelse methode naam 'netter' dan een Nederlandse...niet dat het ene r**t uimaakt, maar Java zelf is ook niet Nederlands....tis misschien maar net wat je gewend bent...maar als je Engels niet te slecht is dan zou ik voor Engelse namen gaan. Tenzij je docent daar problemen mee heeft natuurlijk...

[Soultaker]

Naar mijn ervaring kom je bij elk niet-triviaal project waarbij je met de rest van de wereld te maken hebt in de problemen met Nederlandse coding standards, maar goed, als jullie geen problemen zien, dan zal ik ze niet maken. (Verwacht echter niet dat ik jouw libraries wil herbruiken!). Als ik je code echter wat beter bekijk, dan zie ik je al zoveel fouten maken die de consistentie en (daarmee) bruikbaarheid van je klasse schenden, dat ik ergens wel kan begrijpen dat je het nut van een degelijke, consequente (en dus Engelse!) coding standard niet begrijpt.

Vind je het nu zelf logisch om "telOp" te gebruiken enerzijds, maar "compare" in plaats van "vergelijk" anderzijds? "returnNoemer" (wat sowieso al "get" in plaats van "return" had moeten zijn) in plaats van "retourneerNoemer" of iets dergelijks?

Met je methode "ggd" is trouwens alles fout: ten eerste vind ik "ggd" in plaats van "grootsteGemeneDeler" twijfelachtig (gezien de overige namen als "telOp") maar veel belangrijker dan dat is dat de methode iets heel anders doet: namelijk de breuk vereenvoudigen naar een normaalvorm! Dat je om te vereenvoudigen de grootste gemene deler berekent is heel mooi, maar de methode die de breuk vereenvoudigt daarom "ggd" noemen is compleet fout! Vanuit het perspectief van de gebruiker van je klasse gezien, heeft die methode namelijk niets met het berekenen van een grootste gemene deler te maken. En waarom retuourneert die methode een int? Wat is daar de betekenis van? En waarom is die dan altijd 0?

[Nibble]

Soultaker schreef op 13 mei 2003 @ 03:06:
Vind je het nu zelf logisch om "telOp" te gebruiken enerzijds, maar "compare" in plaats van "vergelijk" anderzijds? "returnNoemer" (wat sowieso al "get" in plaats van "return" had moeten zijn) in plaats van "retourneerNoemer" of iets dergelijks?

Het feit is gewoon dat ik er niet warm of koud van wordt.
Het doet wat het moet doen, het is leesbaar, en zeker voor educatieve doeleinden bruikbaar.
Wat zal het mij dan jeuken of die tekst engels of nederlands is...
Ik begrijp je argumenten wel, maar ze doen me in dit geval gewoon niets.

Met je methode "ggd" is trouwens alles fout: ten eerste vind ik "ggd" in plaats van "grootsteGemeneDeler" twijfelachtig (gezien de overige namen als "telOp") maar veel belangrijker dan dat is dat de methode iets heel anders doet: namelijk de breuk vereenvoudigen naar een normaalvorm! Dat je om te vereenvoudigen de grootste gemene deler berekent is heel mooi, maar de methode die de breuk vereenvoudigt daarom "ggd" noemen is compleet fout! Vanuit het perspectief van de gebruiker van je klasse gezien, heeft die methode namelijk niets met het berekenen van een grootste gemene deler te maken. En waarom retuourneert die methode een int? Wat is daar de betekenis van? En waarom is die dan altijd 0?

Die int returned 0 om er zeker van te zijn dat die functie goed is afgesloten.
Maar nogmaals, of ik het ding GGD of blabla had genoemd... wat hij DOET blijft hetzelfde. Ik ben hier niet aan het coderen voor een groot bedrijf vriend.
Ik loop mijn code achteraf ook niet na om dergelijke kleine in mijn ogen in dit geval zeverachtige dingetjes. Dat was ook niet belangrijk in dit geval.
Wij worden getraind op spul dat WERKT en niet om formulieren te maken met waar de code allemaal aan voldoet. ... ik ben geen manager
Maar ff serieus, het is spul voor school, en daar telt dit gewoon allemaal nog niet zo zwaar (sterker nog, dit was de best leesbare code ertussen!) en idd ze hebben graag dat je nederlands aanhoud.

Natuurlijk weet ik dat er beter code is, en dat mijn spul niet heilig is, maar een feit is dat als je het spul compileerd, en de klant het rund, hij totaal niet ziet of de naamgeving correct is of dat je commentaar wel goed staat
Natuurlijk telt dit niet in grote onwikkelingsprojecten, teams of open source spul, maar be my guest:

Post jij dan maar eens een stuk feilloze perfecte code waarme hekkieSE vooruit kan, hij begrijpt wat er staat, en vooral: hij een HOGER punt gaat halen. Dan heb je recht van spreken imho
Succes!

[ Voor 4% gewijzigd door Nibble op 13-05-2003 12:17 ]

[Verwijderd]

En stel nou is dat jij na je opleiding voor een groot bedrijf iets professioneels in elkaar moet gaan zetten? Wat ik bedoel: als je weet of kunt vermoeden dat je later wel "nettere" methodenamen enzo moet gaan gebruiken, dan is het toch een kleine moeite om nu in je "learning-phase" dat al aan te leren.
Natuurlijk moet je het zelf weten en ik deed het ook zo toen ik begon met Java. Als het maar werkte..maar pak zo'n class een half jaar later er maar weer eens bij...dan kost het je relatief veel tijd om eerst weer eens uit te zoeken welke methode wat deed!
Het is gewoon maar een tip, ik wil niet zeggen dat je een slechte programmeur bent, maar je een beetje aan de conventies houden maakt je wel een nettere/completerer programmeur denk ik...maar ja wie ben ik

[Soultaker]

Nibble schreef op 13 May 2003 @ 12:16:
[..]

Tja, je hele argumentatie komt dus neer op "het werkt goed, dus zeur niet over hoe het in elkaar steekt", als ik het zo bondig mag samenvatten. Op zich een aardige instelling, als je verwacht dat je na het schrijven van de code nooit meer een fout hoeft op te sporen, een aanpassing te maken, een feature toe te voegen, de code over hoeft te dragen aan iemand anders, of stukken code hoeft te herbruiken in een andere applicatie.

Je sluit met zo'n instelling dus een heleboel mogelijkheden uit, maar toegegeven: als je er één keer een voldoende mee moet halen, is dat allemaal niet zo belangrijk. Ik neem echter aan dat ze jou ook leren programmeren zodat je je ervaring kunt gebruiken in een wat serieuzer project, waarin tenminste een aantal van deze mogelijkheden allemaal wél relevant zijn. Het kan dus geen kwaad om er alvast mee te oefenen, want je zult het toch moeten leren, vroeger of later.

Post jij dan maar eens een stuk feilloze perfecte code waarme hekkieSE vooruit kan, hij begrijpt wat er staat, en vooral: hij een HOGER punt gaat halen. Dan heb je recht van spreken imho
Succes!

Zo slecht is je code ook weer niet hoor, maar ik zou (zoals ik al zei) die methodenamen mooi consequent in het Engels maken, met "getXXX" voor methoden die een attribuut opvragen. Verder zou ik de meeste operaties zo aan willen passen dat ze een nieuw object retourneren, in plaats van het huidige object aanpassen. (Zodat een expressie als (Breuk(1,2) + Breuk(3,4)) gewoon een Breuk oplevert). Het is sowieso ook wel de moeite waard om te beslissen of het nu wel of niet om een mutable klasse gaat. Als het een mutable klasse is, hoort 'ie ook gewoon publieke setters te hebben.

Verder zou ik overal die "this->" weghalen, want dat is nogal overbodig, en zou ik, waar mogelijk, functie argumenten willen vervangen door const-reference argumenten, zodat er niet onnodig temporaries geconstrueerd hoeven te worden. Hetzelfde geldt voor een aantal methoden, die ook wel const mogen worden, als ze een nieuw object retourneren in plaats van het huidige aan te passen.

Nu ik een beetje aan het lezen ben: het is wel ontzettend lelijk dat compare() de waarde van het huidige object wijzigt (door 'm te vereenvoudigen)! Dat kan absoluut niet (zeker niet zonder documentatie, maar dan nog is het bijzonder lelijk), dus dat zou ik ook zeker aanpassen. (Je kunt ook heel goed breuken vergelijken zonder eerst een dure GGD te berekenen). Overigens is het ook hoogst ongebruikelijk dat bij een operatie als "a.vermenigvuldig(b)" b aangepast wordt en a gelijk blijft (wat nergens uit je commentaar blijkt); maak dan tenminste één van de twee objecten const, zodat duidelijk is dat precies één van de twee objecten gewijzigd wordt.

Verder zou ik dus de diversie mathematische operaties vervangen door operators, zodat je die breuken op prettige wijze kan manipuleren, en zo zijn er nog wel wat kleine dingetjes die de klasse heel wat bruikbaarder maken. Feitelijke code ga ik niet geven; jij hebt de topicstarter al meer op weg geholpen dan goed voor 'm is.

[Glimi]

Nibble schreef op 13 May 2003 @ 12:16:
Post jij dan maar eens een stuk feilloze perfecte code waarme hekkieSE vooruit kan, hij begrijpt wat er staat, en vooral: hij een HOGER punt gaat halen. Dan heb je recht van spreken imho
Succes!

Niets van waar. Iedereen heeft recht van spreken als hij/zij argumenten aan draagt. Als je daar niet voor open wilt staan, zou ik je willen aanraden geen code hier meer te posten.
Je zit hier met coders, coders willen code zo mooi mogelijk hebben en willen elkaar wat leren (wat heet, ze zijn koppig en willen hun eigen wil doordrukken). Hou daar dan rekening mee

Die int returned 0 om er zeker van te zijn dat die functie goed is afgesloten.

Ik zie niet in hoe die functie anders kan afsluiten? Als er al iets gebeurd waardoor hij dat statement niet bereikt, dan zal die check op 0 ook nooit uitgevoerd worden

[ Voor 17% gewijzigd door Glimi op 13-05-2003 15:28 ]

[.oisyn]

Nibble schreef op 13 May 2003 @ 12:16:
Post jij dan maar eens een stuk feilloze perfecte code waarme hekkieSE vooruit kan, hij begrijpt wat er staat, en vooral: hij een HOGER punt gaat halen. Dan heb je recht van spreken imho
Succes!

Hoge punten halen is niet het doel van de opleiding. Die opleiding is ervoor om jou wat te leren. Goed, punten zijn nodig voor de school om te controleren of jij idd de stof begrijpt, maar als iemand dan hoge punten haalt zonder dat ie er zelf wat van snapt dan is het hele doel van de opleiding weg: er wordt immers niets geleerd.

En nee, leren doe je niet door andermans code over te nemen (ookal staat die in een andere taal)