iterator temporaer problem ....

[RHBaum]

Sorry, ich sehs momentan grad ned, gebt mir mal nen schlag aufn hinterkopf !

Ich will ne STL List Klasse kapseln, aber so das sie sich wie teilweise! ne ListKlasse verhaelt. Sprich, ich will etwas spezialisieren, und einige funktionalitaet abklemmen.

wichtig ist mir dabei, das ich STL like iterieren kann, also :

for(MyListCLass::const_iterator it = rList.begin(); (it != rList.end()); it++)
	{
		// Tu Was ... 
	}

Die klasse soll speziell fuer ne andere Klasse die Liste darstellen
also definier ich die Listenklasse folgendermassen:

Mylistclass.h

class MyListCLass
{
private: 
	typedef std::list<ListObject> List_t;
public:
	typedef List_t::iterator iterator;
	typedef List_t::const_iterator const_iterator;

	MyListCLass();
	virtual ~MyListCLass();

	MyListCLass::iterator begin();
	MyListCLass::const_iterator begin() const;

	MyListCLass::iterator end();
	MyListCLass::const_iterator end() const;

	void insert (const ListObject & rObject);

private:
	List_t m_List;

};

auszug aus Mylistclass.cpp

MyListCLass::iterator MyListCLass::begin()
{
	return m_List.begin();
}
MyListCLass::const_iterator MyListCLass::begin() const
{
	return m_List.begin();
}
MyListCLass::iterator MyListCLass::end()
{
	return m_List.end();
}
MyListCLass::const_iterator MyListCLass::end() const
{
	return m_List.end();
}

Und tatata, obrige schleife funktioniert nicht ....
er erkennt den ende iterator nicht ...
die iteratoren die er durchlaeuft sind ok, zeigen auch alle auf das richtige, vorher eingefuegte Object. Aber it != rList.end() trifft immer zu. beim debuggen zeigen die internen Iteratoren zeiger (_P) auch auf unterschiedliche Adressen ....
Aber der end iterator muesste doch noch gueltig sein ? die liste wird zwischendurch ned angefasst ....

Ciao ...

[Bashar]

RHBaum schrieb:

class MyListCLass
{
private: 
	typedef std::list<ListObject> List_t;
public:
	typedef iterator List_t::iterator;
	typedef const_iterator List_t::const_iterator;
// [ SCHA-NIPP! ]

Das compiliert? typedef kenn ich andersrum.

[RHBaum]

ups, sorry, berichtige :p

Passiert, wenn man ned richtig abschreibt !!!
Klassennamen sind im Zuge des Personenschutzes geaendert ! :p
Die Orginalfiles lassesn sich compilieren, da ist aber auch das typedef richtig rum ...

Ciao ...

[Bashar]

Komisch, ich mach das aber auch immer so. Sicher, dass du nicht auch noch was anderes falsch (bzw. "richtig") abgeschrieben hast?

[RHBaum]

ok, dann doch vielleicht mal die orginale, ich sag niemals nie ! :p
Vielleicht siehst wo ich mich verschrieben hab ...

FileCopyDefList ist das was ned funzt

// FileCopyDef.h: Schnittstelle für die Klasse FileCopyDef.
//
//////////////////////////////////////////////////////////////////////

#ifndef __FILECOPYDEF_H_
#define __FILECOPYDEF_H_

#include <string>
#include <list>

class FileCopyDef  
{
public:
	// Konstruktion ! 
	FileCopyDef();
	FileCopyDef(const FileCopyDef & rx);
	FileCopyDef(const std::string & rFileName,const std::string & rSourceDir,const std::string & rDestDir,bool aSubDirDate);
	FileCopyDef(const char * aFileName,const char * aSourceDir,const char * aDestDir,bool aSubDirDate);
	// Destruktion
	virtual ~FileCopyDef();

	// Zuweisungen 
	const FileCopyDef & operator = (const FileCopyDef & rx);

	// und noch setter und getter .... 
	void set_FileName(const char * aValue);
	void set_SourceDir(const char * aValue);
	void set_DestDir(const char * aValue);

	void set_FileName(const std::string & aValue);
	void set_SourceDir(const std::string & aValue);
	void set_DestDir(const std::string & aValue);

	void set_SubDirDate(bool aVlaue);

	const char * get_FileName() const;
	const char * get_SourceDir() const;
	const char * get_DestDir() const;
	bool get_SubDirDate() const;
	void correctStrings();

private:
	// zum bereinigen 
	void correctDirString(std::string & rx);
	void correctFileString(std::string & rx);

	std::string		m_strFileName;
	std::string		m_strSourceDir;
	std::string		m_strDestDir;
	bool			m_bSubDirDate;
};

class FileCopyDefList
{
private:
	typedef std::list<FileCopyDef> TList_;
public:
	typedef TList_::iterator iterator;
	typedef TList_::const_iterator const_iterator;
	typedef TList_::reverse_iterator reverse_iterator;
	typedef TList_::const_reverse_iterator const_reverse_iterator;

public:
	FileCopyDefList();
	FileCopyDefList(const FileCopyDefList & rx);
	virtual ~FileCopyDefList();

	// zuweisung 
	FileCopyDefList & operator = (const FileCopyDefList & rx);
	// Iteratorfunktionen 
	iterator & begin();
	const_iterator & begin() const;

	iterator & end();
	const_iterator & end() const;

	reverse_iterator & rbegin();
	const_reverse_iterator & rbegin() const;

	reverse_iterator & rend();
	const_reverse_iterator & rend() const;

	// einfuegen 
	void push_back(const FileCopyDef & rValue);
	void push_front(const FileCopyDef & rValue);
	// loeschen
	void clear();
	// bereinigen der Strings 
	void correctStrings();
private:
	TList_ m_List;

};
#endif // !defined(__FILECOPYDEF_H_)

// FileCopyDef.cpp
// Implementation von FileCopyDef 
#include "stdafx.h"
#include "FileCopyDef.h" 
#pragma warning( disable : 4172 4786)

////////////////////////////////////////////////////////////////////////////////////////////
// FileCopyDef 
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
// Konstruktion 
////////////////////////////////////////////////////////////////////////////////////////////
FileCopyDef::FileCopyDef()
{
}
FileCopyDef::FileCopyDef(const FileCopyDef & rx):
m_strFileName(rx.m_strFileName),
m_strDestDir(rx.m_strDestDir),
m_strSourceDir(rx.m_strSourceDir),
m_bSubDirDate(rx.m_bSubDirDate)
{
}
FileCopyDef::FileCopyDef(const std::string & rFileName,const std::string & rSourceDir,const std::string & rDestDir,bool aSubDirDate):
m_strFileName(rFileName),
m_strDestDir(rDestDir),
m_strSourceDir(rSourceDir),
m_bSubDirDate(aSubDirDate)
{
}
FileCopyDef::FileCopyDef(const char * aFileName,const char * aSourceDir,const char * aDestDir,bool aSubDirDate):
m_strFileName(aFileName),
m_strDestDir(aDestDir),
m_strSourceDir(aSourceDir),
m_bSubDirDate(aSubDirDate)
{
}
////////////////////////////////////////////////////////////////////////////////////////////
// Destruktion 
////////////////////////////////////////////////////////////////////////////////////////////
FileCopyDef::~FileCopyDef()
{
}
////////////////////////////////////////////////////////////////////////////////////////////
// Zuweisung
////////////////////////////////////////////////////////////////////////////////////////////
const FileCopyDef & FileCopyDef::operator = (const FileCopyDef & rx)
{
	if(&rx != this)
	{
		m_strDestDir = rx.m_strDestDir;
		m_strFileName = rx.m_strFileName;
		m_strSourceDir = rx.m_strSourceDir;
		m_bSubDirDate = rx.m_bSubDirDate;
	}
	return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////
// Getter / Setter 
////////////////////////////////////////////////////////////////////////////////////////////
void FileCopyDef::set_FileName(const char * aValue)
{
	m_strFileName = aValue;
}
void FileCopyDef::set_SourceDir(const char * aValue)
{
	m_strSourceDir = aValue;
}
void FileCopyDef::set_DestDir(const char * aValue)
{
	m_strDestDir = aValue;
}

void FileCopyDef::set_FileName(const std::string & aValue)
{ 
	m_strFileName = aValue;
}
void FileCopyDef::set_SourceDir(const std::string & aValue)
{
	m_strSourceDir = aValue;
}
void FileCopyDef::set_DestDir(const std::string & aValue)
{
	m_strDestDir = aValue;
}
void FileCopyDef::set_SubDirDate(bool aValue)
{
	m_bSubDirDate = aValue;
}

const char * FileCopyDef::get_FileName() const
{
	return m_strFileName.c_str();
}
const char * FileCopyDef::get_SourceDir() const
{
	return m_strSourceDir.c_str();
}
const char * FileCopyDef::get_DestDir() const
{
	return m_strDestDir.c_str();
}
bool FileCopyDef::get_SubDirDate() const
{
	return m_bSubDirDate;
}
void FileCopyDef::correctStrings()
{
	correctDirString(m_strDestDir);
	correctDirString(m_strSourceDir);
	correctFileString(m_strFileName); 
}

void FileCopyDef::correctDirString(std::string & rx)
{
	// die ersten slashes und backslashes abfangen .... 
	while((rx.size() > 0)  && ((rx[0] == '/') || (rx[0] == '\\')))
	{
		rx.erase(0,1);
	}
	// die letzten slashes und backslashes abfangen .... 
	while((rx.size() > 0)  && ((rx[rx.size() -1] == '/') || (rx[rx.size() -1] == '\\')))
	{
		rx.erase(rx.size() -1,1);
	}
}
void FileCopyDef::correctFileString(std::string & rx)
{
	// die letzten slashes und backslashes abfangen .... 
	while((rx.size() > 0)  && ((rx[rx.size() -1] == '/') || (rx[rx.size() -1] == '\\')))
	{
		rx.erase(rx.size() -1,1);
	}
}

////////////////////////////////////////////////////////////////////////////////////////////
// FileCopyDef 
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
// Konstruktion / Destruktion
////////////////////////////////////////////////////////////////////////////////////////////
FileCopyDefList::FileCopyDefList()
{
}
FileCopyDefList::FileCopyDefList(const FileCopyDefList & rx):
m_List(rx.m_List)
{
}
FileCopyDefList::~FileCopyDefList()
{
}
////////////////////////////////////////////////////////////////////////////////////////////
// Iteratorfunktionen 
////////////////////////////////////////////////////////////////////////////////////////////
FileCopyDefList::iterator & FileCopyDefList::begin()
{
	return m_List.begin();
}
FileCopyDefList::const_iterator & FileCopyDefList::begin() const
{
	return m_List.begin();
}

FileCopyDefList::iterator & FileCopyDefList::end()
{
	return m_List.end();
}
FileCopyDefList::const_iterator & FileCopyDefList::end() const
{
	return m_List.end();
}

FileCopyDefList::reverse_iterator & FileCopyDefList::rbegin()
{
	return m_List.rbegin();
}
FileCopyDefList::const_reverse_iterator & FileCopyDefList::rbegin() const
{
	return m_List.rbegin();
}

FileCopyDefList::reverse_iterator & FileCopyDefList::rend()
{
	return m_List.rend();
}
FileCopyDefList::const_reverse_iterator & FileCopyDefList::rend() const
{
	return m_List.rend();
}
////////////////////////////////////////////////////////////////////////////////////////////
// Zuweisung
////////////////////////////////////////////////////////////////////////////////////////////
FileCopyDefList & FileCopyDefList::operator = (const FileCopyDefList & rx)
{
	if(&rx != this)
	{
		m_List = rx.m_List;
	}
	return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////
// Einfuegen 
////////////////////////////////////////////////////////////////////////////////////////////
void FileCopyDefList::push_back(const FileCopyDef & rValue)
{
	m_List.push_back(rValue);
}
void FileCopyDefList::push_front(const FileCopyDef & rValue)
{
	m_List.push_front(rValue);
}
////////////////////////////////////////////////////////////////////////////////////////////
// loeschen
////////////////////////////////////////////////////////////////////////////////////////////
void FileCopyDefList::clear()
{
	m_List.clear();
}

die schleife selber

//////////////////////////////////////////////////////////////////////
// kopieren
//////////////////////////////////////////////////////////////////////
int FileCopyMan::copyFiles(const FileCopyDefList & rList)
{
	int ireturn = 0;
	for(FileCopyDefList::const_iterator it = rList.begin(); (it != rList.end()); it++)
	{
		FileCopyDefList::const_iterator itest = rList.end();
		// bool bTest = it != rList.end();
		if(copyFile(*it))
			ireturn ++;
	}
	return ireturn;
}

Die referenz scheint ok zu sein, laut debugger .... zeigt Liste als member correct an ...

Ciao ...

[Bashar]

Du gibst die Iteratoren per Referenz zurück. Da die aber jeweils lokale temporäre Objekte sind, existieren sie nach der Rückkehr nicht mehr -> rumms (leise).

[RHBaum]

klatsch ... omg, jetzt wo du es sagst.

danke dir !

Ciao ...