std::vector - Verschachteltes Problem

hustbaer

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.

Kóyaánasqatsi

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.

unskilled

Kóyaánasqatsi schrieb:

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

Kóyaánasqatsi

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.

unskilled

mal versuchen...
Ich habe eine Struktur mit 2 Vektoren.

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

drakon

Ich verstehe deine Erklärung jetzt so:

#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

Kóyaánasqatsi

Sollte funktionieren, Danke.

unskilled

@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

drakon

unskilled schrieb:

@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

Kóyaánasqatsi

Ähhhm, moment mal. Die Vektoren in der Struktur beziehen sich wieder auf Strukturen (^^). Und das Problem ist, dass die Vektoren in der Struktur von dem Vektor der Struktur abhängig sind. Sprich: Pro Element des Vektors der Struktur müssen 2 neue Iteratoren für die 2 Vektoren in der Struktur angelegt werden. Und da lag ich gar nicht mal so falsch... Ich hoffe das hat jetzt irgendwie einer verstanden. .
Danke

hustbaer

Ich glaube kein Mensch versteht was du willst.

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.

Kóyaánasqatsi sieh es doch einfach ein, C++ ist eine aussterbende Sprache. Es gibt keine Experten mehr die dein Problem lösen könnten, die sind alle schon auf die Sprachen der Zukunft umgestiegen.

Dravere

@Kóyaánasqatsi,
1. Probier dich mal ein wenig korrekter auszudrücken. Ein std::vector bezieht sich nicht auf eine Struktur, sondern er beinhaltet Objekte von einer Klasse.
2. "Es gibt eine Struktur, mit einer Struktur, der Struktur durch eine Struktur und Struktur. Wie kann ich die Struktur realisieren." Das kann doch niemand lesen
Du kannst schon vereinfachen, aber gibt den Klassen sprechende Namen. Vor allem wenn du ein Beispiel schaffst, in dem das Konstrukt reinpasst, ist dies sehr hilfreich. Also zum Beispiel:
"Die Klasse Auto hat einen Motor und einen std::vector , welcher die Räder beinhaltet."
Notfalls erkläre es mit dem, was tatsächlich vorhanden ist. Wir sind ja nicht dumm und wenn du uns ein wenig Erklärung gibst, dann können wir dies nachvollziehen.
Ich verweise da auch mal auf einen wichtigen Thread in diesem Forum:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-200753.html

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

Grüssli

Kóyaánasqatsi

Dravere schrieb:

"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.

drakon

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

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

-->

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..

Kóyaánasqatsi

Dann muss ich irgendetwas falsch verstanden haben. Läuft nun, danke.

Dravere

@Kóyaánasqatsi,
Geht doch

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

unskilled

Dein Quelltext is übrigens.... zumindest komisch
dtor is nicht notwendig

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

Kóyaánasqatsi

Ich danke euch für die hilfreichen Tips . Würde mich über mehr Kritisierungen freuen .

pumuckl

unskilled schrieb:

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)