Hi ich wollte mal fragen, ob mir jemand helfen kann eine Operator Überladung der
Addition operator+ hier für diese Klasse 2Dvec durchzuführen.
Irgendwie werde ich nicht schlau, wie ganau das Funktioniert.

Hier mein Versuch:

vec2D operator+ (const vec2D &v){
    vec2D sum;
    sum.x1 = x1 + v.x1;
    sum.x2 = x2 + v.x2;
    return sum;
  }

Habe ich vielleicht einen Fehler in meiner Klasse(siehe unten)?

#include <iostream>

//Class 2Dvec=2DimensionalVector
class vec2D{
public:
  //default constructor sets x1=x2=0.0
  vec2D();     
  //initialisation constructor sets x1=X1 and x2=X2
  vec2D(double X1, double X2);    
  //sets x1=X1 and x2=X2
  void setVec(double X1, double X2);
  //cout coordinatres
  void showX1X2();
  //Here i want to create a vector operator v1+v2
  vec2D operator+ (const vec2D &v){
    vec2D sum;
    sum.x1 = x1 + v.x1;
    sum.x2 = x2 + v.x2;
    return sum;
  }
  void operator<< (const vec2D &v1){
    std::cout << "( " << v1.x1 << " | " << v1.x2 << " )\n";
    }   

private:
  //x1 and x2 are coordinates of the 2Dvectors      
  double x1;
  double x2;                 

};

//default constructor sets x1=x2=0.0
vec2D::vec2D(){
  x1 = 0.0; x2 = 0.0;
  }             

//initialisation constructor sets x1=X1 and x2=X2
vec2D::vec2D(double X1, double X2){
  //using method setVec to set values
  setVec(X1, X2);
  } 

//sets x1=X1 and x2=X2  
void vec2D::setVec(double X1, double X2){
  x1 = X1; x2 = X2;   
  }

//cout coordinatres
void vec2D::showX1X2(){
  std::cout << "( " << x1 << " | " << x2 << " )" << std::endl;
  }

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

auf den ersten blick sieht das ganze richtig aus...

Binäre Operatoren sollten allerdings als freie Funktionen implementiert werden, weil sie flexibler einzusetzen sind als member Funktionen:

Vec2D operator+( const Vec2D& op1, const Vec2D& op2 )
{
 ...
}

DocShoe schrieb:

Dein Klassenname beginn mit einer Ziffer beginnt, das ist nicht erlaubt.

Binäre Operatoren sollten allerdings als freie Funktionen implementiert werden, weil sie flexibler einzusetzen sind als member Funktionen:

Vec2D operator+( const Vec2D& op1, const Vec2D& op2 )
{
 ...
}

Wie meinst du das genau? Aber + ist doch nur ein binärer operator und kein tärnärer? Könntest du das ein bisschen besser erklären, evtl. auch mit dem Code?
Und welche vorteile hätte ich durch diese Notation? Ist das schneller? Oder sicherer?

das hat den vorteil, dass die addition kommutativ ist und zur not können casts durchgeführt werden. bei vec1 + vec2 hat das keine probleme...
aber z.b. bei bruchzahlen (im folgenden b1 und b2): hier wäre b1 + b2 kein problem. aber was ist wenn du eine bruchzahl b mit einer ganzen zahl addieren möchtest?!? b + i wäre das, ok. aber was ist nun i + b?
dann müsstest du ja den plus operator von int überschreiben. wenn du nun aber die addition von den bruchzahlen global deklarierst und auch einen konstruktor hast der als argumetn nur einen int erwartet, castet der compiler das implizit und es funktioniert ===> schreibarbeit gespart

also erstmal was mathe:

das gilt, wie du wissen solltest. ein-halb plus eins ist gleich eins komma fünf ist gleich eins plus 1-halb (man beachte die kommutativität, also das vertauschen der beiden summanden)

hast du jetzt eine bruchklasse:

class Bruch
{
    int nenner;
    int zaehler;
public:
    Bruch(int zahler, int nenner = 1)
      : zaehler(zaehler), nenner(nenner)
    { } // sicherheitsfunktionen wie assert lasse ich weg, der nenner könnte nun auch 0 sein!

    Bruch operator+(Bruch const& rhs)
    {
         Bruch tmp(this->zaehler*rhs.nenner + rhs.zaehler*this->nenner, 
                   this->nenner*rhs.nenner); // bruch addition
         return tmp;
    }
};

int main()
{
    Bruch a(1, 2);
    Bruch b(1); // durch default parameter auf 1/1 gesetzt
    Bruch ergebnis = a + b;  // -> 1/2 + 1 = 3/2 = 1,5  ok!
    Bruch ergebnis2 = b + a; // auch noch ok, weil a und b Bruch instanzen sind
    Bruchergebnis3 = a + 1; // ok, da 1 wegen dem konstruktor implizit zu einem bruch gecastet werden kann
    Bruch ergebnis4 = 1 + a; // FALSCH! trotz der + operator überladung

    return 0;
}

umgehen kann man dies durch folgendes:

class Bruch
{
    // ... wie oben alles
    friend Bruch operator+(Bruch const& a, Bruch const& b);
};

Bruch operator+(Bruch const& a, Bruch const& b)
{
    Bruch tmp(a.zaehler*b.nenner + b.zaehler*a.nenner, a.nenner*b.nenner);
    return tmp;
}

int main()
{
    // .. wie oben, nun funktioniert ergbenis4 jedoch
}

verstanden soweit?

Aber was genau bedeutet denn der Schlüsselbegriff friend?

friend Bruch operator+(Bruch const& a, Bruch const& b);

ich kenne nur public, private und protected(obwohl ich den unterschied zu private nicht ganz verstehe:D)

Aber was genau bedeutet denn der Schlüsselbegriff friend?

friend bedeutet, dass das, was da als "Freund" deklariert wird, zwar (syntaktisch) nicht zur Klasse gehört, aber dennoch Zugriff auf die privaten Member hat. Das sollte aber auch im Einführungsbuch deiner Wahl stehen.

C++ - where friends can touch your privates, but your family can't.

ich kenne nur public, private und protected(obwohl ich den unterschied zu private nicht ganz verstehe:D)

Nur der Vollständigkeit halber: Dieser Unterschied wird erst relevant, wenn du dich mit Vererbung beschäftigst - protected-Elemente dürfen von den eigenen Methoden, Freunden und den Methoden abgeleiteter Klassen verwendet werden.

C++ - where friends can touch your privates, but your family can't.

Ich habe eine neue Signatur.