Schleife rückwärts laufen lassen will nicht :(

Hi,

bisher hab ich meinen Iterator im Texturmanager vorwärtsgejagt, doch jetzt will ich aus speedgründen ich rückwärtslaufen lassen (da oft nur die hinteren texturen im Vector benutzt werden und er so einen kürzeren weg hat!)

So hab ich ihn vorwärts gejagt:

SDL_Surface* CTextureManager::getTexture (std::string FileName)
{
		// Durchlaufe den Vector
	for (std::vector<TextureItem>::iterator it=this->m_vec_Textures.end(); it != this->m_vec_Textures.begin(); --it)
	{
			// Hat eine Textur im Vector den selben Namen wie angefordert?
		if (it->FileName == FileName)
		{
				// Wenn ja, Textur zurückgeben, ansonsten weitersuchen.
			return (it->Image);
		}
	}

		// Wenn die Funktion bis hier hin kommt, ist die Textur nicht vorhanden.
		// Drum geben wir NULL zurück
	return NULL;
}

und jetzt hab ich versucht ihn so rückwärts laufen zu lassen, doch das will nicht

SDL_Surface* CTextureManager::getTexture (std::string FileName)
{
		// Durchlaufe den Vector
	for (std::vector<TextureItem>::iterator it=this->m_vec_Textures.end(); it != this->m_vec_Textures.begin(); --it)
	{
			// Hat eine Textur im Vector den selben Namen wie angefordert?
		if (it->FileName == FileName)
		{
				// Wenn ja, Textur zurückgeben, ansonsten weitersuchen.
			return (it->Image);
		}
	}

		// Wenn die Funktion bis hier hin kommt, ist die Textur nicht vorhanden.
		// Drum geben wir NULL zurück
	return NULL;
}

wieso geht das nicht?

sorry das war der code für vorwärts:

SDL_Surface* CTextureManager::getTexture (std::string FileName)
{
		// Durchlaufe den Vector
	for (std::vector<TextureItem>::iterator it=this->m_vec_Textures.begin(); it<this->m_vec_Textures.end(); ++it)
	{
			// Hat eine Textur im Vector den selben Namen wie angefordert?
		if (it->FileName == FileName)
		{
				// Wenn ja, Textur zurückgeben, ansonsten weitersuchen.
			return (it->Image);
		}
	}

		// Wenn die Funktion bis hier hin kommt, ist die Textur nicht vorhanden.
		// Drum geben wir -1 zurück
	return NULL;
}

Shade Of Mine

nimm doch reverse iteratoren

for(vector<Foo>::reverse_iterator i=vec.rbegin(); i!=vec.rend(); ++i)
{
}

nimm doch std::map

das ist ein Iterator der rückwärtsläuft? kewl wusste ich gar net danke!

Shade Of Mine

btw:
ich würde die funktion so schreiben:

struct TextureCompare
{
private:
  std::string fileName;
public:
  TextureCompare(std::string const& fileName) : fileName(fileName) {}
  bool operator()(TextureItem const& item)
  {
    return item.getFileName() == fileName; //FileName ist doch wohl nicht public, oder?
  }
};

SDL_Surface* TextureManager::getTexture (std::string const& FileName)
//wir wollen doch nicht sinnlos kopieren...
{
  std::vector<TextureItem>::reverse_iterator i=
    std::find(textures.rbegin(), textures.rend(), TextureCompare(FileName));
  //ich mag keine ungarische notation
  if(i!=textures.rend()) return i->getImage();
  return 0;
}

hi,

danke könnte man statt ner extra klasse nicht das einfach so schreiben?

inline bool compareItems (TextureItem const& item, FileName) 
  { 
    return (item.getFileName() == FileName);
  }

Shade Of Mine

und wo zauberst du FileName her?

äähm wie du siehst hab ich da das std::String vergessen sorry ich hoff aber du verstehst was ich meine, oda?

Shade Of Mine

Oh, mir ist da ein Fehler unterlaufen :o

statt find verlangt meine Version ein find_if

Deine Funktion hat das Problem: woher nimmst du FileName?
Woher soll find/find_if wissen welchern wert FileName hat

du kannst aber auch TextureItem einen operator== für std::string spendieren, dann kannst du
find(vec.rbegin(), vec.rend(), FileName);
schreiben...

Hi,

ich dachte mir das eher so:

inline bool compareItems (TextureItem const& item, std::string const &FileName)  
  {  
    return (item.getFileName() == FileName); 
  }

denn extra ne weitere klasse? findest du das nicht etwas umständlich? ich mein das müsste doch auch per funktion gehen, oder?

FileName bekomm ich ja im parameter der getTexture() funktion

Shade Of Mine

=Seraph= schrieb:

FileName bekomm ich ja im parameter der getTexture() funktion

ja, du schon. aber woher weiss find_if, dass du compare(*it, FileName) aufrufen willst?

du rufst find_if ja dann so auf:
find_if(vec.rbegin(), vec.rend(), compare);

und somit weiß find_if nicht, woher es FileName nehmen soll...

oder meinst du etwas anderes?

du kannst ja einfach für texturen den operator== überladen:

bool operator==(TextureItem const& item, std::string const& str)
{
  return item.getFileName() == str;
}

und dann kannst du einfach

find(vec.rbegin(), vec.rend(), FileName);
aufrufen...

ich finde die 'Klasse', (welche sich übrigens Functor schimpft und hier las Predicate verwendet wird - falls du googlen willst) schöner.

aber jedem das seine