habe ein kleines programm zur vektoraddition und multiplikation geschrieben. leider tut die addition nicht, statt der summe zweier vektoren wird stets nur der erste vektor wiedergegeben. das problem liegt an der additionsanweisung sum.v[i] = v[i] + x.v[i]; an sich, genau genommen am letzten summand. kann mir jemand sagen, was das problem ist?

für andere tipps bzgl meines programmierstils bin ich auch dankbar!

danke!

#include <iostream>
using namespace std;

class vector
{
      private:
      int dim;
      double* v;

      public:
      vector(int);
      ~vector();

      friend istream& operator >> (istream& is, vector& x);
      friend ostream& operator << (ostream& os, vector x);

      vector operator + (vector);
      double operator * (vector);
};

vector::vector(int n)
{
      v = new double[n];
      dim = n;
      for(int i=0; i<dim; i++) v[i]=0;
}

vector::~vector()
{
      delete[] v;
}

istream& operator >> (istream& is, vector& x)
{
         for(int i=0; i<x.dim; i++) cin >> x.v[i];
         return is;
}

ostream& operator << (ostream& os, vector x)
{
         for(int i=0; i<x.dim; i++) cout << x.v[i] << "\n";
         return os;
}

vector vector::operator + (vector x)
{
       vector sum(x.dim);
       for (int i=0; i<x.dim; i++) sum.v[i] = v[i] + x.v[i];
       return sum;
}

double vector::operator * (vector x)
{
       double produkt=0;
       for (int i=0; i<x.dim; i++) produkt += v[i] * x.v[i];
       return produkt;
}

int main()
{
    int n;
    cin >> n; cout << endl;

    vector a(n); vector b(n);

    cin >> a; cin >> b; cout << endl;

    cout << a; cout << "\n"; cout << b; cout << "\n";

    double skalarprodukt = a*b; cout << skalarprodukt << endl << endl;

    vector add(n); add  = a + b; cout << add;

    system("PAUSE");
    return 0;
}

außerdem fehlen dir ein kopierkonstruktor und ein zuweisungsoperator.

istream& operator >> (istream& is, vector& x)
{

for(int i=0; i<x.dim; i++) cin >> x.v[i];
return is;

}

Für was übergibst du den istream, wenn du ihn nicht nutzen willst?

aber wieso klappt denn nun die addition nicht? es muss irgendwas geben, wieso die komponente des zu addierenden vektors ignoriert wird, denn mit zahlen oder der komponente des ursprünglichen vektors geht es problemlos.

Da du deine operator+ und operator* nicht mit ner Referenz sondern einem Value als Argument implementieren willst (k.A. warum) hast du hier schon mal eine Kopie, die wohl auch schief gehen wird.

Und wegen dem istream als Argument:

istream& operator >> (istream& is, vector& x)
{
   for(int i=0; i<x.dim; i++) is >> x.v[i];
   return is;
}

So willst du es haben Damit schreibst du auch in den Stream, in den geschrieben werden soll, und gibst den auch noch zurück
Ein cout << 3; ist nichts anderes als der Aufruf operator<<(cout, 3);. Dass du mein voriges Anliegen verstehst.

Grüße
Franz

die idee mit dieser vektorrechnung hatte ich selbst und wollte es zur übung implementieren, in der uni hatten wir den copyconstructor etc noch nicht wirklich geübt.

bei dem instream habe ich anfangs using namespace std verwendet, sodass die eingabe und ausgabe bisher auch problemlos verlief. ist die formulierung mit cin / cout "falsch"?

danke!!

...in der uni hatten wir den copyconstructor etc noch nicht wirklich geübt....

Falls Du das erstmal nicht selbst machen willst, kannst Du natürlich auch statt C-Arrays direkt std::vector nehmen (also nicht anstelle von Deinem vector, sondern nur als Ersatz für das "new[]/delete[]-Geschäft" ... der bringt seine "Big3" (CpyCtor, operator=(), Dtor) schon fertig mit und lässt sich ansonsten genauso bearbeiten wie ein dynamisch alloziertes Array.

Gruß,

Simon2.

bei dem instream habe ich anfangs using namespace std verwendet, sodass die eingabe und ausgabe bisher auch problemlos verlief. ist die formulierung mit cin / cout "falsch"?

In dem Fall ist es falsch, ja. Oder besser gesagt es macht nicht das, was du willst. Du willst ja in einen beliebigen stream einlesen. Und das stellst du mit der Funktion ja bereit. Nun musst du ja noch in genau den übergebenen stream einlesen und dann stimmt es. Und das schöne ist, dass du ebenfalls in die Konsole schreiben kannst, oder davon einelesen, ohne eine neue Funktion zu definieren. Und das kommt daher, da cout und cin auch streams sind, welche einfach extern deklariert wurden und auf die Standardausgabe verweisen:
http://www.cplusplus.com/reference/iostream/

Die << und >> Operatoren sind eigentlich ganz normale Funktionen, welche aber syntaktischen Zucker bieten. (z.B das schöne verknüpfen, was du von der Ausgabe her kennst). Sie übergeben die Argumente einfach auf eine für Funktionen ungewöhnliche Art und das kann verwirren.
Wie franz schon sagte, bedeutet ein

std::cout << "hallo, welt";

nichts anderes, als :

std::operator << (std::cout,"hallo, welt");

Ist aber verständlicherwiese nicht schön zu lesen.