class vektor
{
      private:
              float *v;

              float x;
              float y;
              float z;

      public:
             vektor();
             vektor(vektor &ref);

             vektor(float);
             vektor(float, float);
             vektor(float, float, float); 

             void definiere(float, float, float);
             void ausgabe();
             float* get_vektor();

             /*rechnen*/
             vektor mult(vektor v);
             vektor div(vektor v);
             vektor add(vektor v);
             vektor sub(vektor v);

             vektor mult(float t);
             vektor div(float t);
             vektor add(float t);
             vektor sub(float t);           
};

vektor mult(vektor &v, vektor &v2);
vektor div(vektor &v, vektor &v2);
vektor add(vektor &v, vektor &v2);
vektor sub(vektor &v, vektor &v2); 

vektor mult(vektor &v, float t);
vektor div(vektor &v, float t);
vektor add(vektor &v, float t);
vektor sub(vektor &v, float t);

vektor::vektor() : x(0), y(0), z(0) {};
vektor::vektor(vektor &ref) : x(ref.x), y(ref.y), z(ref.z) {};
vektor::vektor(float rx) : x(rx), y(0), z(0) {};
vektor::vektor(float rx, float ry) : x(rx), y(ry), z(0) {};
vektor::vektor(float rx, float ry, float rz) : x(rx), y(ry), z(rz) {};

void vektor::definiere(float rx, float ry, float rz)
{
     x = rx;
     y = ry;
     z = rz;
}

void vektor::ausgabe()
{
     cout<<"X: "<<x<<endl;
     cout<<"Y: "<<y<<endl;
     cout<<"Z: "<<z<<endl;

}

float* vektor::get_vektor()
{
       v = new float[3+1];
       v[0] = x;
       v[1] = y;
       v[2] = z;
       v[3] = 4; //groeße
       return v;
       delete [] v;
}

vektor vektor::mult(vektor v)
{
     x *= v.x;
     y *= v.y;
     z *= v.z;
     return *this;
}
vektor vektor::mult(float t)
{
     x *= t;
     y *= t;
     z *= t;
     return *this;
}
vektor mult(vektor &v, vektor &v2)
{
       vektor v_r = v;
       v_r.mult(v2);
       return v_r;
}

int main(int argc, char *argv[])
{
    vektor temp;
    vektor a(4,1);
    vektor b(-2,-1);
    vektor c(-2,2);
    vektor d(1,-3);

    temp = a.mult(b); //mecker....
    temp.ausgabe();

    system("PAUSE");
    return EXIT_SUCCESS;
}

//mecker....

ist natürlich sehr hilfreich...
Aber naja mal was anderes wozu machst du alle operationen einaml als member und denn auch nochmal als nicht member.
Afaik sollte du bei return *this;
nen const vector zurückgeben .
Naja ansonsten wäre ne Fehlermeldung echt toll.

temp = a.mult(b.mult(2) );

also eine art verkettung?
ich bekomm da immer

/home/dgrat/Documents/vektor/src/vektor.cpp:136: error: no matching function for call to `vektor::vektor(vektor)'
/home/dgrat/Documents/vektor/src/vektor.cpp:77: error: candidates are: vektor::vektor(float)
/home/dgrat/Documents/vektor/src/vektor.cpp:76: error: vektor::vektor(vektor&)
/home/dgrat/Documents/vektor/src/vektor.cpp:136: error: initializing argument 1 of `vektor vektor::mult(vektor)'

an sich liefert "b.mult(2)" ein ojekt vom typ vektor zurück, da müsst doch a.mult() sich mit anfreunden können

an sich liefert "b.mult(2)" ein ojekt vom typ vektor zurück, da müsst doch a.mult() sich mit anfreunden können

Weiß leider nicht, woran das liegt, aber wenn du schon

return *this;

zurückgibst, kannst du auch eine Referenz auf dein Objekt zurückgeben. =>

vektor& vektor::mult(float t)
{
     x *= t;
     y *= t;
     z *= t;
     return *this;
}

So sollte es funktionieren.

Btw: Folgender Code-Snippet:

...
class foo
{
   int value;
   public:
      foo(int v = 0) : value(v) {}
      foo(foo& f) { this->value = f.value; }
      foo pow(foo f) { this->value = f.value * f.value; return* this; }
};

...

int main()
{
   foo obj1(9), obj2(obj1); // funktioniert

   foo obj3(obj2.pow(obj1)); // funktioniert nicht...
}

/edit1:
Warum schmeißt die zweite Zeile den von dem OP angesprochenen Fehler?
Wieso wird nicht beide Male der Copy-Ctor aufgerufen? (Ist dieser Überhaupt definiert wenn ich schreibe

foo(foo& f);

? Ich erinner mich nämlich dunkel daran, dass der Copy-Ctor so aussehen sollte

foo(const foo& f);

... (Dann lässt sich das Beispiel auch problemlos compilieren...)))

Wäre nett wenn ihr mich aufklären könntet

/edit2: Ich glaube ich weiß woran jetzt woran das liegt: in dem Code-Snippet fungiert

foo(foo& f);

bereits als Copy-Ctor. Dadurch kann in pow

return *this;

nicht in obj3 kopiert werden, da hier eine temporäres Objekt erzeugt wird, auf welche man ja bekanntlich keine nicht-const Referenzen binden kann. Ist das so korrekt? Bitte korrigiert mich, bei etwaigen Falschaussagen!

Caipi

an sich liefert "b.mult(2)" ein ojekt vom typ vektor zurück, da müsst doch a.mult() sich mit anfreunden können

mult liefert ein temporäres Objekt zurück, an welches eine Referenz nicht gebunden werden kann. Als Parameter wird aber genau so eine erwartet. Lösung: übergib by-value oder noch besser, per const Referenz.

btw:
Schau dir mal an was const-correctness ist.

mult liefert ein temporäres Objekt zurück, an welches eine Referenz nicht gebunden werden kann. Als Parameter wird aber genau so eine erwartet. Lösung: übergib by-value oder noch besser, per const Referenz.

darum: was meinst du mit temporären objekt genau?
warum wird eine referenz als parameter gewollt?

referenzen hab ich ja (imho völlig sinnfrei) in den fkt. die außerhalb der klasse stehen genutzt?

mult liefert ein temporäres Objekt zurück, an welches eine Referenz nicht gebunden werden kann. Als Parameter wird aber genau so eine erwartet. Lösung: übergib by-value oder noch besser, per const Referenz.

darum: was meinst du mit temporären objekt genau?

Ein temporäres Objekt ist ein (vom Compiler generiertes) Objekt, welches der Programmierer strenggenommen nie zu Gesicht bekommt.

warum wird eine referenz als parameter gewollt?

Warum? Weil du deinen Copy-Ctor so geschrieben hast Zur Erinnerung: Der Prototyp desselben sieht so aus:

vektor(vektor &ref);

Das (imho nicht direkt ersichtliche) Problem an deinem Code ist, dass dein Copy-Ctor eine Referenz auf einen vektor-Objekt erwartet. Der Standard verbietet dir nun, dass du temporäre Objekte an nicht-konstante Referenzen binden darfst, woraus dein Fehler letztendlich resultiert. Warum das? Fragst du?
Nun, was würde denn passieren wenn es erlaubt wäre Referenzen auf temporäre Objekte zu erzeugen? Dann würde folgender Code fehlerfrei übersetzt werden. (Früher wurde er es manchmal tatsächlich, weshalb es damals manchmal total verwirrt dreinblickende Programmierer gab... [ok, die gibt es heute auch noch...])

// gibt das Zeichen an der Position pos  von str zurück
size_t get_char_at(string& str, size_t pos)
{
    if(pos < str.length())
        return str[pos];
    else
        exit(1); // Fehler...
}

int main()
{
    char* c_str = "Hello C++-World!";
    char c = get_char_at(c_str, 9);

}

Was passiert beim Aufruf von get_char_at() mit einem Argument, dass nicht vom Typ std::string ist und worauf deshalb auch keine Referenz vom Typ std::string abgebildet werden kann? Der Compiler fragt sich ungefähr folgendes: "ist c_str vom Typ std::string?" Nein. "Kann ich c_str in ein Objekt vom Typ std::string konvertieren?" Ja. Also tut dies der Compiler und erzeugt ein temporäres konstantes Objekt vom Typ std::string. Auf ein konstantes Objekt kann jetzt aber keine nicht-konstante Referenz "zeigen", weshalb ein Fehler ausgegeben wird.

Angenommen der Compiler erzeugt kein _konstantes_ temporäres Objekt (was er ja früher tlw. getan und weswegen es früher keine Fehlermeldung gegeben haben soll), wäre es trotzdem nicht sinnvoll mit der Referenz auf dieses zu arbeiten. Jegliche Änderungen an der Referenz würden sich auf das *temporäre* Objekt beziehen und nich auf c_str...
Das ist nicht das, was man erwartet, weshalb es dann auch durch den Standard verboten wurde.

Du fragst dich jetzt eventuell noch, was das jetzt mit deinem Problem zu tun haben soll? Als return-wert gibt eine Funktion oft ebenfalls ein temporäres Objekt zurück (so auch in deinem Fall), was zu den angesprochenen Komplikationen mit nicht-const Referenzen führt...

Caipi