kleiner c++-code; finde fehler nicht. HILFE.

so, ich lerne mit viel mühe und FEHLER c++, aber diesmal komme ich nicht weiter.

habe folgenden einfachen code, um einen 2-dimensionalen vektor zu erstellen und den +-operator zu überladen.

class Vektor
{
   public:
  Vektor(){
  x=0;
  y=0;
  }
  Vektor(int a, int b):x(a), y(b){};

         Vektor &operator+(const Vektor &V){
         Vektor *z;
         z = new Vektor(x+V.x, y+V.y );
         return *z;
      }

  private:
        int x,y;

};

int main()
{
       int x,y, xx, yy;
     cout << "Bitte vom Vektor den x wert eingeben:" <<  endl;
     cin >> x;
     cout << "Bitte vom Vektor den y wert eingeben:" <<  endl;
        cin >> y;
        Vektor *V1;
        V1 = new Vektor(x,y);

        cout << "Bitte vom 2. Vektor den x wert eingeben:" <<  endl;
     cin >> xx;
     cout << "Bitte vom 2.Vektor den y wert eingeben:" <<  endl;
        cin >> yy;
        Vektor *V2;
        V2 = new Vektor(xx,yy);

          cout << (*V1 + *V2) << endl;  //Beide Vektoren sollen addiert ausgegeben werden

	return 0;
}

beim compilieren kriege ich den fehler "illegal structure operation". WARUM?

Hi,
der op<< ist nicht für deinen Vektor überladen ...

golden_jubilee

mh dabei hatten wir doch schon einen thread hier zum them vektor und + operator überladen, wobei zu recht festgestellt wurde, dass es so keinen sinn macht

Braunstein

und dein operator+ hat ein Speicherloch. Warum erstellst du den temporären Vektor überhaupt dynamisch?

Vektor operator+(const Vektor &V)
{
   Vektor z(x+V.x, y+V.y );
   return z;
}

David_pb

Braunstein schrieb:

und dein operator+ hat ein Speicherloch. Warum erstellst du den temporären Vektor überhaupt dynamisch?
Vektor operator+(const Vektor &V)
{
   Vektor z(x+V.x, y+V.y );
   return z;
}

Vektor operator+(const Vektor &V) const
{
   return Vektor(x+V.x, y+V.y );
}

class Vektor
{
  public:
  // ...

  float operator[]( int index ) const
  {
    assert( index >= 0 && index < 2 );
    return ( &x )[ index ];
  }

  float &operator[]( int index )
  {
    assert( index >= 0 && index < 2 );
    return ( &x )[ index ];
  }

  private:
  // ...
}; 

std::ostream &operator<<( std::ostream &o, const Vektor &v )
{
  o << v[ 0 ] << v[ 1 ]; 
  return o;
}

David_pb schrieb:

float operator[]( int index ) const
  {
    assert( index >= 0 && index < 2 );
    return ( &x )[ index ];
  }

Lieber hier ein const als Rückgabewert, damit man beim kompilieren schon den Fehler sieht, gleiches auch für den Paramtertypen, der lieber unsigned sein sollt bspw. size_t.

"Bevorzuge Compiler-Meldungen gegenenüber "komisches" Laufzeitverhalten"

Edit: Sry, ist ja lvalue, da sollte der Compiler auch schon meckern, aber const ist trotzdem schöner