habe ein Vektor:

std::vector<doubl> vTime;

Wenn ich nun ein Element anfüge:
double time=5;

vTime.push_back(time);

soll die bereich bestehenden Elemente des Vectors um diese Zeil ausummiert
werden.

for(std::vector<double>iterator it= vTime.begin(); it< vTime.end();it++)
   (*it)+=Time;

das quaise so eine art Pyramidenform entsteht.. Wenn ich versteht was ich meine.

Bsp:

1. Iteration

time =3

2. Interation

time= 2

3. Iteration

time 4

Elemeente im Vector:
1. 3
2. 5
3. 9

Num meine FRage:

Gibt es ne elegantere Lösung, als jedesmal wenn ich ein neues Element anfüge alle elemente durchlaufe und hochaddiere?

Aber ich denke wohl nicht!!

merk dir doch in einer variable das ergebnis. dann brauchst du es nur beim naechsten push_back mitaddieren und selbst nochmal um die neue zahl hochaddieren.

Meep Meep

int PushBack(std::vector<int> &vec, int x, int result)
{
   vec.push_back(x + result);
   return result + x;
}

int main(void)
{
   std::vector<int> vec;
   int result = 0;
   result = PushBack(vec,1); // result == 1;
   result = PushBack(vec, 4); // result == 1 + 4 == 5;
   result = PushBack(vec, 7); // result == 5 + 7 == 12;
}

bsp.

1. Add mit 4

Vector: (4)

2. Add mit 3

Vector: (7),(3)

3. Add mit 2

Vector: (9),(5),(3)

4. Add mit 5

Vector: (14),(9),(8),(5)

so muss der vector dann aussehen...

2. nö is immernoch nicht klar.
nach dem wie ich das verstanden hab, sollte am ende ein 14,10,7,5 herauskommen

man kann es sehr elegant lösen, wenn du diese operation nur einmal durchführen musst:

std::vector<double> numbers;//da sind alle deine zahlen drin die aufsummiert werden müssen
std::vector<double> times;

double accumulator=0;
for(std::vector<double>::reverse_iterator number=numbers.rbegin();number!=numbers.rend();++number)
{
    accumulator+=*number;
    times.push_back(accumulator);
}
reverse(times.begin(),times.end());

Ungetestet (Header <functional> + <algorithm>).

@Konrad: Was macht der code genau?

wenn das element eingefügt werden soll, wird zuerst auf jedes element im vector der wert aufaddiert.

transform(vec.begin(),vec.end(),vec.begin(),bind2nd(plus<int>,elem));

Und mit dieser Anpassung bewirkt der Code, daß der neue Summand auf jedes bisher vorhandene Element aufaddiert wird.

class Vector
{
   public:
      Vector(void) : result(0) { vec.push_back(result); }
      void push_back(int x)
      {
         vec.push_back(result += x);
      }
      int operator[](std::size_t pos)
      {
         return vec.back() - vec[pos];
      }
      std::size_t size(void) const { vec.size() - 1; }
      void clear(void)
      {
         vec.clear();
         vec.push_back(result = 0);
      }

   private:
      std::vector<int> vec;
      int result;
};

der zugriff dauert zwar bissl laenger, jedoch ersparst du dir das aufsummieren der einzelnen werte im vector.

Meep Meep

Wenn, dann wäre eher transform() geeignet:

Arg. Es ist nicht nur "geeignet" sondern war auch gemeint.

ok, und dies ist schneller wenn ich das mit nem normalen iterator mache und jedes elem += hochaddiere?

Für nichttriviale Typen ist das manuelle Durch-Iterieren eventuell schneller, weil man eben '+=' statt '+' verwenden kann und somit das Anlegen temporärer Objekte verhindert. Für 'int' sollte es relativ egal sein.

ok, und dies ist schneller wenn ich das mit nem normalen iterator mache und jedes elem += hochaddiere?

Komplexitätstheoretisch dürfte das keinen Unterschied bringen. Die einzige echte Verbesserung (jenseits von Mikro-Optimierung), die mir hier einfällt, ist Lazy Evaluation (das bringt aber nur dann etwas, wenn du erst alle Werte einliest und das Aufsummieren auf Später verschiebst):

for(...)
{
  cin>>val;
  vec.push_back(val);//hier sammeln wir nur die Elemente, ohne zu summieren
}
partial_sum(vec.rbegin(),vec.rend(),vec.rbegin());//damit summierst du alle oben eingelesenen Elemente auf

Wenn du immer abwechselnd Werte eingeben und Zwischensummen berechnen willst, wird der Verwaltungsaufwand für diesen Ansatz vermutlich zu hoch.