✔ [C++] klassen und funktionen (komplexe zahlen)

[Gody]

Hallo,

ich hab ein Problem und zwar....

Der Befehl soll im main stehn
z3 = add (z1,z2)
Zur Erklärung:
z1, z2 sind Komplexe Zahlen. Ergebnis auf Komplexe Zahl z3.

Die z1, z2, z3 haben jeweils einen Real und Imaginärteil

add soll nur das machen
z1.re + z2.re;
z1.im + z2.im;

Meine Frage ist jetzt wie muss die Funktion definiert sein damit ich das so machen kann bzw, geht das überhaupt?

Thx schon im Voraus

 

[Fabian H]

Klar geht das

Angenommen deine Struktur bzw. dein Typ heisst cmplx:

cmplx add(cmplx a, cmplx b)
{
    cmplx c;

    c.re = a.re + b.re;
    c.im = a.im + b.im

    return c;
}

Edit; Oder auch:

cmplx add(cmplx a, cmplx b)
{
    cmplx c = {
        a.im + b.im,
        b.re + b.re
    }

    return c;
}

Die Methode faellt aber weg, wenn du auf reines ISO C bestehst (und keine Warnungen haben willst).

 

[Gody]

Hab ich gemacht, und daher die Funktion in der Klasse drinnen steht hab ich das gemacht

Complex Complex :: Add(Complex z1, Complex z2)
{
//da steht dann genau der gleiche code
}

In der Klasse is die Funktion (is dann glaub ich eine Methode (besser mich bitte aus wenns falsch is)) so definiert

class{
private: float re, im;
public: Complex Add(Complex, Complex);
};

Jetzt sagt er mir beim borland
<Call to undifined function 'Add'>

 

[canuzzi]

c-Variante

/* Komplexe Zahlen in c */

   struct complex {
        double re;
        double im;
   };

   typedef struct complex com;  /* Synonym */

   comp add(comp,comp);
   comp ncomp(float,float);

int main(void) {
    comp a=ncomp(1,2);
    comp b=ncomp(2,3);
    comp c;

     c=add(a,b);

   return 0;
}

comp add(comp a, comp b) {
   return ncomp(a.re+b.re,a.im+b.im);
}

comp ncomp (float re, float im) {
    comp r = {re,im};
     return r;
}

 

[canuzzi]

Variante c++ [edit] fehler korrigiert

/* Variante in c++ */

/* Klassendefinition */

class komplex {
    private:
        double re,im; // Die internas deiner neuen Zahlenklasse sind mal schoen intern!

    public:
        komplex(double _re=0.0, double _im=0.0): re(_re), im(_im) {}

       doube real() const { return re; }
       double img() const {return im; }
};

/* Das sieht bisher alles viel komplizierter aus als in c -- dafuer wirds jetzt aestethischer. */

komplex& komplex::operator+= (komplex _k) {
   re += _k.re;
   im += _k.im;
   return *this;
}

/* dein add als + :) */

komplex operator+ (komplex _x, komplex _y) {
   komplex tmp=_x;
   return tmp+= _y;
}