std::vector<Vektor_von_Struktur>::const_iterator iStruct;

for( iStruct = Vektor_von_Struktur.begin( ); iStruct < Vektor_von_Struktur.end( ); ++iStruct)
{
	const unsigned int i = *iStruct;

	for( std::vector<Vektor_von_Struktur[i].Vektor_in_Struktur>::iterator iVec1 =Vektor_von_Struktur[i].Vektor_in_Struktur.begin( ); iVec1< Vektor_von_Struktur[i].Vektor_in_struktur.end( ); ++iVec1 )
	{
		for( std::vector<Vektor_von_Struktur[i].Weiterer_Vektor_in_Struktur>::iterator iVec2 = Vektor_von_Struktur[i].Weiterer_Vektor_in_Struktur.begin( ); iVec2 < Vektor_von_Struktur[i].Weiterer_Vektor_in_Struktur.end( ); ++iVec2 )
		{
		}
	}
}

Ist vielleicht etwas brainfucked, aber so sollte es immernoch am verständlichesten seien. Falls die Templatefehler interessieren, einfach schreien. Der Fehler sollte aber offensichtlich seien.
Danke.

std::vector<std::vector<dein_struct> >::const_iterator iStruct;

Den iterator kannst du äquivalent zu allem anderen erzeugen. In den spitzen Klammern schreibst du den Typen von dem, was der vector halten soll. Auch wenn das wieder ein vector von irgendwas ist funktioniert das genau gleicht.

ich denke mal, dass iStruct von diesem Typen hier sein sollte, nicht?

Dann gibt es einen:

1>c:\framework\3ds.cpp(278) : error C2679: binary '=' : no operator found which takes a right-hand operand of type 'std::_Vector_iterator<_Ty,_Alloc>' (or there is no acceptable conversion)

EDIT: Was hat das mit der Meldung zu tun?

std::vector<Vektor_von_Struktur[i].Vektor_in_Struktur>::iterator

Schreibst du einfach irgendwelche Sachen in ein File, wo du dir denkst so oder so ähnlich könnte C++ aussehen, oder was soll das sein?
Lern bitte die Grundlagen.

Schreibst du einfach irgendwelche Sachen in ein File, wo du dir denkst so oder so ähnlich könnte C++ aussehen, oder was soll das sein?
Lern bitte die Grundlagen.

Wenn du ein paar Posts über dir gelesen hättest, wüsstest du, dass ich den originalen Code abgeändert habe um besseres Verständniss zu schaffen.

Schreibst du einfach irgendwelche Sachen in ein File, wo du dir denkst so oder so ähnlich könnte C++ aussehen, oder was soll das sein?
Lern bitte die Grundlagen.

Wenn du ein paar Posts über dir gelesen hättest, wüsstest du, dass ich den originalen Code abgeändert habe um besseres Verständniss zu schaffen.

dann mach das mal noch mal - und zwar so, dass es auch irgendjmd durchlesen will..
ich les hier nicht 6 zeilen durch, wovon 2 zeilen ca. doppelt so breit sind wie mein monitor und ich dann noch iwelchen kryptischen bezeichner entziffern muss...

bb

dann mach das mal noch mal - und zwar so, dass es auch irgendjmd durchlesen will..

Will oder kann? Es ist eben nicht einfach zu beschreiben, wenn die potenziellen Helfer den originalen Code nicht verstehen würden.

iwelchen kryptischen bezeichner entziffern muss...

Was ist kryptisch?

Ok, ich versuche es nocheinmal:
Ich habe eine Struktur mit 2 Vektoren. Von dieser Struktur habe ich wieder einen Vektor. Und daher ist die grundlegende Frage: Wie iteriere ich durch die Vektoren in der Struktur? Muss ich dann jedesmal einen neuen Iterator von dem jeweiligen Element des Vektors (der Struktur) anlegen? Und die Preisfrage: Wie sieht das Codetechnisch aus, weil ich das nach diesem Prinzip gemacht habe und nicht verstehe warum es nicht funktioniert?
Danke.

struct two_vectors
{
  std::vector<int> first;
  std::vector<int> second;
};

Von dieser Struktur habe ich wieder einen Vektor.

typedef std::vector<two_vectors> Tvector_of_two_vectors;
Tvector_of_two_vectors vector_of_two_vectors;

Und daher ist die grundlegende Frage: Wie iteriere ich durch die Vektoren in der Struktur?

for(Tvector_of_two_vectors::const_iterator i(vector_of_two_vectors.begin()), e(vector_of_two_vectors.end()); i != e; ++i)
{
  for(std::vector<int>::const_iterator i2(i->a.begin()), e2(i->a.end()); i2 != e2; ++i2)
  {
    ;
  }
  for(std::vector<int>::const_iterator i2(i->b.begin()), e2(i->b.end()); i2 != e2; ++i2)
  {
    ;
  }
}

dann nimmst du noch pair für die beiden vectoren und schon kannst du ganz bequem mit den typedefs arbeiten - oder schreibst dir selbst nen paar in deine struktur...

bb

#include <vector>

struct foo
{
	std::vector<int> v;
	std::vector<int> v2;
};

int main ()
{
	std::vector<foo> foos;

	for (std::vector<foo>::iterator it = foos.begin () ;
			it != foos.end ();
			++it)
	{
		for (std::vector<int>::iterator it2 = it->v.begin();
			it2 != it->v.end();
			++it2)
		{
			//...
		}

		for (std::vector<int>::iterator it2 = it->v2.begin();
			it2 != it->v2.end();
			++it2)
		{
			//...
		}
	}
}

EDIT:
LOL unskilled, das nenn ich mal Gedankenübertragung.. :p

Vor allem, da wir auch beide std::vector<int> genommen haben etc : D

Aber du kannst ruhig zugeben, dass du die 4 Sekunden genutzt hast, um es zu copy&pasten und noch schnell zu ändern

bb

@drakon:
Japp ^^ Hatte ich mir auch so gedacht : D

Vor allem, da wir auch beide std::vector<int> genommen haben etc : D

Aber du kannst ruhig zugeben, dass du die 4 Sekunden genutzt hast, um es zu copy&pasten und noch schnell zu ändern

bb

So etwas musste ja noch kommen.. -.-

Aber im Ernst, ich glaube die 4 Sekunden, die ich später kam, habe ich damit vergeudet nachzudenken, ob ich auch ein typedef machen soll.. :p

Poste doch bitte etwas Code, und bitte nicht "vereinfachten" (sprich: Quatsch), sondern konkret deine Strukturen und Vektoren.

Die Schleife um da drüber zu iterieren sollte trivial sein, aber zu erraten was du meist ist ganz sicher nicht trivial.

Frage nach dem, was du erreichen willst und nicht danach womit du es erreichen willst.

Grüssli

"Die Klasse Auto hat einen Motor und einen std::vector, welcher die Räder beinhaltet."

...

hustbaer schrieb:

Ich glaube kein Mensch versteht was du willst.

Glaube ich auch. Ich denke ich poste mal den kompletten zusammengehörigen Code, bevor ihr mir hier weiter mit der Schübbe au'n Kopp haut...

Die Grundstruktur:

#pragma pack( 1 )
struct Objects
{
	~Objects()
	{
		objectName.clear( );
		faces.clear( );
		vertices.clear( );
	}

	std::string objectName;
	std::vector<Faces> faces;
	std::vector<Vertices> vertices;
};
#pragma pack( )

Faces und Vertices ist eine andere Struktur, aber die sollte erstmal unwichtig seien.

std::vector<Objects> objects;

Unser Vektor der sich auf die Struktur bezieht...

Und das letztendliche durchiterieren:

std::vector<Objects>::iterator iObject;

	for( iObject = objects.begin( ); iObject < objects.end( ); ++iObject )
	{
		for( std::vector<Faces>::iterator iFace = objects[*iObject].faces.begin( ); iFace < objects[*iObject].faces.end( ); ++iFace )
		{
			for( std::vector<objects[*iObject].vertices>::iterator iVert = objects[*iObject].vertices.begin( ); iFace < objects[*iObject].vertices.end( ); ++iVert )
			{
			}
		}
	}

Danke.

-->

std::vector<Objects>::iterator iObject;
    typedef std::vector<Faces> FacesType;
    typedef std::vector<Vertices> VerticesType;

    for( iObject = objects.begin( ); iObject < objects.end( ); ++iObject )
    {
        for( FacesType::iterator iFace = iObject->faces.begin( ); iFace != iObject->faces.end( ); ++iFace )
        {
            for( VerticesType::iterator iVert = iObject->vertices.begin( ); iFace != iObject->vertices.end( ); ++iVert )
            {
            }
        }
    }

Aber das ist genau das, was Unskilled und ich vorhin gepostet habe..

Aber wie drakon sagt, das ist genau das, was bereits vorgeschlagen wurde.

Man kann dies allerdings noch ein wenig unabhängiger machen, indem man ein paar typedef einführt.

struct Object
{
    ~Object()
    {
        objectName.clear( );
        faces.clear( );
        vertices.clear( );
    }

    typedef std::vector<Face> FaceContainer;
    typedef std::vector<Vertex> VertexContainer;

    std::string objectName;

    FaceContainer faces;
    VertexContainer vertices;
};

// ...

std::vector<Object> objects;

typedef std::vector<Object>::iterator ObjectIterator;

// Es ist uns egal, was für ein Container dahinter liegt:
typedef Object::FaceContainer::iterator FaceIterator;
typedef Object::VertexContainer::iterator VertexIterator;

// Der Rest halt wie es gezeigt wurde.
// Ein Typ ist übrigens nie von einer Variablen abhängig, sondern grundsätzlich
// immer von Typen oder Konstanten.

Wieso sind eigentlich deine Klassennamen in der Mehrzahl angegeben? Empfinde ich als ziemlich unüblich.

Grüssli

und bei iteratoren < zu nehmen anstatt != ist auch nich gerade sinnvoll... so bald du von vector auf nen anderen container umsteigst, kannst du nämlich alles ändern...
auch find ich variablen-namen á la std::vector<Faces> faces; total hässlich... wahrscheinlich würde die klasse an sich besser Face heißen... Darunter kann ich mir zwar jz auch nur begrenzt etwas vorstellen, aber es macht zumindest mehr sinn als vector<faces> faces...

und jeden schleifendurchlauf wieder end() zu bestimmen ist auch nich gerade sehr doll - ich weiß nämlich nich, in wie fern der compiler das wegoptimieren kann...

bb

und jeden schleifendurchlauf wieder end() zu bestimmen ist auch nich gerade sehr doll - ich weiß nämlich nich, in wie fern der compiler das wegoptimieren kann...

Wird zumindest schwierig, das wegoptimieren zu lassen. Wenn man selber genau weiß dass man den Container nicht verändert (d.h. dass end() immer denselben Iterator liefern wird), dann kann man ja auch problemlos eine zweite Variable im Schleifenkopf definieren:

for( FacesType::iterator iFace = iObject->faces.begin( ), 
                              last = iObject->faces.end();
          iFace != last; ++iFace)