Brauche Hilfe => eigene KLasse!

feiadragon

HI @ all!

Brauch jetzt was Hilfe als C++ Neuling....

Hab jetzt zum Bruchrechnen ne KLasse geschrieben, aber ich kann die Funktionen der Klasse nicht aufrufen (sind public).

Kann es sein das ich da was falsch verstanden hab, das ich da in der Klasse nen Struct machen müsste oder so, weil der die bruch variable nicht erstellen kann?

(Ich tuh mal den ganzen Code ins Forum, stört zwar aber dann seht ihr denn ***** den ich gemacht hab (ich hab kein Webspace zum uploaden)

Please help me!

MfG, feiadragon

edit: ach ja, was den code selber angeht, ich konnte ihn nicht testen!!!

[code]

#include <iostream>
#include <stdlib.h>
#include <math.h>

#define void int

using namespace std;

class bruch
{
      private:
        int nenner;
        int zaehler;
        struct BRUCH
        { int zaehler, nenner; };
      public:
        bruch() {nenner=0; zaehler=0;}
        bruch(int,int);         //konstruktor
        ~bruch();               //Destruktor
        bruch add(bruch,bruch);        //adden
        bruch sub(bruch,bruch);        //minus
        bruch div(bruch,bruch);        //division
        bruch mal(bruch,bruch);        //multiplikation
        bruch operator + (bruch &b);        //operator +
        bruch operator / (bruch &b);        //operator /
        bruch operator - (bruch &b);        //operator -
        bruch operator * (bruch &b);        //operator *

        bruch kuerzen(bruch);
        void ausgabe(bruch);
};

struct KGV
{
  int KGV,anzahl;
};

//konstruktor
bruch::bruch(int a,int b) {if(a!=0) { nenner=a; zaehler=b; }}
//standartdestruktor
bruch::~bruch() {}
//teilbar
bool teilbar(int a,int b) {
    bool d;
    for(int c=2;c<=b;c++) { if(a%b==0) { d=true; } }
    if(d) { return(true); } else { return(false); }
}
//KGV
KGV kgV(int a,int b) {
  int z;
  bool abruch;
  KGV current;
  while(!abruch)
  {
     if((a*z)==(b*z))
     {
          current.anzahl=z;
          current.KGV=a*z;
          return(current);
     }
     if(z>100) {current.anzahl=0; current.KGV=0; return(current);}
    z++; 
  }
}
//mal
bruch bruch::mal(bruch a,bruch b) {
    a.nenner*=b.nenner;
    a.zaehler*=b.zaehler;
    return(a);
}//bruch::mal
bruch bruch::operator * (bruch &b)
{
}//bruch::operator *
//add
bruch bruch::add(bruch a,bruch b) {
    //wenn gleichnamig
    if(a.nenner==b.nenner)
    {
        a.zaehler+=b.zaehler; //zähler addieren
        return(a);
    }
    else        //gleichnamig machen
    {
        if(teilbar(a.nenner,b.nenner) || teilbar(b.nenner,a.nenner))//wenn nenner teilbar möglich
        {
        //das KGV bestimmen und die brüche danach ausrichten
        KGV kgv;
        kgv=kgV(a.nenner,b.nenner);
        a.nenner=kgv.KGV;
        b.nenner=kgv.KGV;
        a.zaehler*=kgv.anzahl;
        b.zaehler*=kgv.anzahl;
        //addieren
        a.zaehler+=b.zaehler;
        return(a);
        }
    }
}//bruch::add
bruch bruch::operator + (bruch &b) {
}//bruch::operator +
//minus
bruch bruch::sub(bruch a,bruch b) {
  //wenn gleichnamig
  if(a.nenner==b.nenner) {
    if((a.zaehler-b.zaehler)>0) {
        a.zaehler-=b.zaehler;
        return(a);
    }
  }
  else        //gleichnamig machen
  {
        KGV kgv;
        kgv=kgV(a.nenner,b.nenner);
        a.nenner=kgv.KGV;
        b.nenner=kgv.KGV;
        a.zaehler*=kgv.anzahl;
        b.zaehler*=kgv.anzahl;
        //subtrahieren
        if((a.zaehler-b.zaehler)>0) {
        a.zaehler-=b.zaehler;
        return a;
        }
  }
}//bruch::sub
bruch bruch::operator - (bruch &b) {
}
//Durch
bruch bruch::div(bruch a,bruch b) {
  int zwischen;
  //Kehrbruch von bruch b
  zwischen=b.nenner;
  b.nenner=b.zaehler;
  b.zaehler=zwischen;
  //mal
  a=mal(a,b);
  return(a);
}//bruch::div
bruch bruch::operator / (bruch &b) {
}//bruch::operator /
//kürzen
bruch bruch::kuerzen(bruch a) {
  int z;
  for(z=(a.nenner/2);z<1;z--)
  {
    if((a.nenner%z==0) && (a.zaehler%z==0))
      {
            a.nenner/=z;
            a.zaehler/=z;
            return(a);
      }
  }
}//bruch::kuerzen
void bruch::ausgabe(bruch b) {
  printf("%i\n%i",b.zaehler,b.nenner); }
/*+++++++++++++++++++++++++++++++++++++++++MAIN++++++++++++++++++++++++++++++++*/
int main(int argc, char *argv[])
{
int a,b;
printf("gebe erst nenner dann zähler ein!");
scanf("%i %i",&a,&b);
bruch b1(a,b);
printf("/n gebe erst nenner, dann zähler ein!");
scanf("%i%i",&a,&b);
bruch b2(a,b);
//eingabe
bruch test;

KGV hallo;

test=bruch::add(b1,b2);
bruch::ausgabe(b1);

  system("PAUSE");	
  return 0;
}
[/code]

Windalf

test=bruch::add(b1,b2);
bruch::ausgabe(b1);
//nicht mit dem scope-operator die member eines objektes ansprechen...

test=bruch.add(b1,b2); //gleichsetzen funzt nur wenn du den operator = auch für die klasse bruch definierst...
bruch.ausgabe(b1);

interpreter

Naja, ich hab den Code nur überflogen aber dennoch kann ich wohl schon jetzt sagen, dass er nicht sehr gelungen ist

#define void int

Was soll das?

class bruch
{
      private:
        int nenner;
        int zaehler;
        struct BRUCH
        { int zaehler, nenner; };

Wieso hat die Klasse ne innere Struktur? Is doch sinnlos

bruch() {nenner=0; zaehler=0;}

Das ist mathematisch falsch.

bruch::bruch(int a,int b) {if(a!=0) { nenner=a; zaehler=b; }}

Wieso wird der 1. Übergabeparameter für den Nenner benutzt? Das ist nicht intuitiv. Und was, wenn a = 0? ...

bruch add(bruch,bruch);        //adden
        bruch sub(bruch,bruch);        //minus
        bruch div(bruch,bruch);        //division
        bruch mal(bruch,bruch);        //multiplikation

Das macht auch keinen Sinn. Wenn überhaupt, dann müssten das statische Klassenmethoden sein. Brauchst du aber nicht, da du ja eh die Operatoren überlädst.

bruch operator + (bruch &b);        //operator +
        bruch operator / (bruch &b);        //operator /
        bruch operator - (bruch &b);        //operator -
        bruch operator * (bruch &b);        //operator *

1. Sollten alle 4 Operatoren global definiert werden und 2. sollte ihnen eine konstante Referenz übergeben werden.

void ausgabe(bruch);

Warum nicht friend ostream& operator<<(ostream &o, const bruch& b); ?
Und wenn du schon die Methode haben willst, dann gib nicht mit prinft aus

KaraHead

@Windalf
Du bist aber auch in jedem Forum ruck-zuck zur Stelle

interpreter

Windalf schrieb:

test=bruch::add(b1,b2);
bruch::ausgabe(b1);
//nicht mit dem scope-operator die member eines objektes ansprechen...

Dürfte sowieso nicht funzen, weil die nicht statisch sind.

test=bruch.add(b1,b2); //gleichsetzen funzt nur wenn du den operator = auch für die klasse bruch definierst...

hm, doch. Der vom Compiler erzeugte Zuweisungsop sollte hier funzen.

feiadragon

Naja sowas dachte ich mir auch !

was das struct und das define angeht, hab ich wohl vergessen zu löschen

mmh ich dachte wohl, besser als gar nichts...

sieht dann so aus als ob ich da was verwechselt hätte oder einfach nicht aufgepasst hab als ichs hingeschrieben hab. Hab lieber versucht die C++ Syntax zu verstehen...

zu den letzten 3 Sachen (ich hätte gern die Operatoren überladen, aber nicht so ganz verstanden wie, und, zum Ersatz hab ich diese Funktionen da hingek(l)otzt...

die Ausgabe, bin halt Anfänger ...

Danke!
feiadragon

feiadragon

Danke an Alle, ich habs jetzt!!!

Kann mir aber mal irgendwer sagen warum bei dem oiperator = mit meinen tollen brüchen was logisches Rauskommt und bei var=varvar; irgendwas völlig daneben mit 5 0len und so.?!?

ich hatte als bruch 5/10 und *= hat 25/100 drausgemacht und * 3/358090

habe jetzt auch das mit dem <<gemacht, danke!

nochwas, kann man irgendwie mit dem operator = 2 Werte, also für Zähler und Nenner gleichzeitig einlesen?

mfG, danke, feiadragon

freshman

feiadragon schrieb:

nochwas, kann man irgendwie mit dem operator = 2 Werte, also für Zähler und Nenner gleichzeitig einlesen?

mit dem operator= liest du nix ein, kannst dir aber operator>> überladen

interpreter

feiadragon schrieb:

Danke an Alle, ich habs jetzt!!!

Kann mir aber mal irgendwer sagen warum bei dem oiperator = mit meinen tollen brüchen was logisches Rauskommt und bei var=varvar; irgendwas völlig daneben mit 5 0len und so.?!?

Klar, wir können hier alle hellsehen

nochwas, kann man irgendwie mit dem operator = 2 Werte, also für Zähler und Nenner gleichzeitig einlesen?

mfG, danke, feiadragon

Theoretisch schön, aber das wäre total sinnfrei:
struct zn {
int z,n;
};

bruch& bruch::operator=(const zn& rhs) { }

Wenn du jedoch einen (nicht-expliziten) Konstruktor definiert hast, den man mit EINEM Argument aufrufen kann (z.B. bruch::bruch(int z=0, int n=1) { }), dann kann dieser zur impliziten Typkonvertiertung benutzt werden:
bruch b = 2; // z=2, n=1

freshman

habe ein neues Liebligswort: sinnfrei

Brauche Hilfe =&gt; eigene KLasse!

Brauche Hilfe => eigene KLasse!