Schleife nach Funktionsaufruf weiterlaufen lassen?

happystudent

Hallo,

angenommen ich hab so einen Code:

#include <iostream>
#include <vector>

void do_something(std::vector<int> &v)
{
	v.push_back(8);
}

int main()
{
	std::vector<int> v = { 1, 2, 3, 4, 5 };

	for (auto it = v.begin(); it != v.end(); ++it) {
		std::cout << *it << ' ';
		do_something(v);
	}
	std::cout << '\n';
}

Wie kann ich sicherstellen dass die Schleife am aktuellen Element weiter läuft? Also Ausgabe stelle ich mir so vor:

1 2 3 4 5 8 8 8 .... (Endlos-Schleife)

Zwischenspeichern kann ich den iterator ja nicht, da der ja invalidiert wird, daher führt der Code so auch zu einem Laufzeitfehler...

'nen Index nehmen?

Aber: Warum?!

for (auto it = v.begin(); ;) {
   if (it != v.end()) ++it;
   //...
}

Nicht getestet.

happystudent

Furble Wurble schrieb:

'nen Index nehmen?

Aber: Warum?!

Also, es sollte halt für beliebige Container gehen, also etwa so (daher will ich keinen Index verwenden):

#include <iostream>
#include <vector>

template <typename container, typename T> // Spezialisierbar für andere Container
void add_to_container(container &c, T value) { c.push_back(value); } 

void do_something(std::vector<int> &v)
{
    add_to_container(v, 8);
}

int main()
{
    std::vector<int> v = { 1, 2, 3, 4, 5 };

    for (auto it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << ' ';
        do_something(v);
    }
    std::cout << '\n';
}

Geht das also irgendwie auch mit Iteratoren?

Edit:

IBV schrieb:

for (auto it = v.begin(); ;) {
   if (it != v.end()) ++it;
   //...
}

Nicht getestet.

Ja, also das geht nicht weil der Iterator ja invalidiert wird. Daher bringt das jetzt auch nichts, das Inkrement aus dem Schleifenkopf rauszuziehen...

Wenn kein Speicher angefordert wird, bleiben die Iteratoren gültig. Also:

v.reserve(2*v.size());

Nathan

happystudent schrieb:

Furble Wurble schrieb:

'nen Index nehmen?

Aber: Warum?!

Also, es sollte halt für beliebige Container gehen, also etwa so (daher will ich keinen Index verwenden):

Trotzdem: Warum? Warum brauchst du das? Kannste nicht erst alles adden und dann iterieren?

happystudent

Nathan schrieb:

Trotzdem: Warum? Warum brauchst du das? Kannste nicht erst alles adden und dann iterieren?

Hm, werd vielleicht nochmal genauer über das Design nachdenken, vermutlich schon. Falls doch nicht, schreib ich hier nochmal.

Auf jeden Fall Danke für die Kommentare.

Ich hoffe ich habe dich richtig verstanden, dass du in deinem Vektor die 8 als letztes Element schieben möchtest und das letzte Element (die dann in einer Endlosschleife ausgeben möchtest.

Hier wäre meine Beispiele

Mit der Endlosschleife

#include <iostream> 
#include <vector> 
using namespace std;

void do_something(std::vector<int> &v) 
{ 
    v.push_back(8); 
} 

int main() 
{ 
    std::vector<int> v = { 1, 2, 3, 4, 5 }; 
    for(unsigned i = 0; true; ++i){
       if(i == 0){
         for(auto v1: v){
           cout << v1 << " ";
         }
       }
    do_something(v);    vector<int>::iterator vLast = v.end() -1;
    cout << *vLast << " ";

    }
    std::cout << '\n'; 
}

ohne die Endlosschleife

#include <iostream> 
#include <vector> 
using namespace std;

void do_something(std::vector<int> &v) 
{ 
    v.push_back(8); 
} 

int main() 
{ 
unsigned achtdranhaengen = 2; // verändern nach wunsch 
    std::vector<int> v = { 1, 2, 3, 4, 5 }; 
    for(unsigned i = 0; i < achtdranhaengen; ++i){
       if(i == 0){
         for(auto v1: v){
           cout << v1 << " ";
         }
       }
    do_something(v);
    vector<int>::iterator vLast = v.end() -1;
    cout << *vLast << " ";

    }
    std::cout << '\n'; 
}