iterator in den Typ umwandeln?

lord_fritte

Hallo ich habe eine Klasse, z.b. Artikel.
Nun speichere ich davon mehrre objekte in einer list<Artikel>.
Zum auslesen benutze ich eine for-Schleife mit einem list<Artikel>::iterator, jetzt möchte ich die einzeleinträge weiter an eine Funktion
übergeben, aber wie kann ich ein list<Artikel>::iterator in ein z.b. Artikel* convertieren`?

Nexus

std::list<Artikel>::iterator Iterator;

Artikel  Object    =   *Iterator;
Artikel& Reference =   *Iterator;
Artikel* Pointer   = &(*Iterator);

(*Iterator).DoAnything();

lord_fritte

Danke, es geht.

Dravere

juzklzfujktsrh schrieb:

(*Iterator).DoAnything();

Das geht einfacher:

iterator->DoAnything();

Der operator -> ist bei den Iteratoren überladen, so dass man dadurch Zugriff auf das Objekt dahinter hat.

Grüssli

Fellhuhn

Kannst aber nicht per -> an den Wert um ihn an eine Funktion zu übergeben, wie es im Eingangsposting gefragt ist.

Wobei ich folgendes irgendwie "schick" finde:

doSomething(iterator->);

Dravere

Fellhuhn schrieb:

Kannst aber nicht per -> an den Wert um ihn an eine Funktion zu übergeben, wie es im Eingangsposting gefragt ist.

1. Ich bezog mich ja auch nur auf die Aussage von juzklzfujktsrh.
2. Auch wenn es idiotisch ist, doch es geht:

#include <vector>

void foo(int*)
{
}

int main()
{
	std::vector<int> vec;
	vec.push_back(0);

	foo(vec.begin().operator->());
}

Kompiliert bei mir einwandfrei :p

Grüssli

pumuckl

Dravere schrieb:

foo(vec.begin().operator->());
Kompiliert bei mir einwandfrei :p

Nur solange, wie vector<T>::iterator::operator-> ein T* zurückliefert. Das wird vom Standard nicht garantiert. Es ist dort lediglich verlangt, dass iter->m das selbe ergibt wie (*iter).m.

Wenn der Iterator intern nicht mit Pointern, sondern anderen Pointer-ähnlichen Objekten arbeitet (z.B. einem anderen Iterator, wie das bei einer Implementierung von reverse_iterator der Fall sein könnte), dann kann op-> durchaus ein anderes Objekt zurückliefern, das auch op-> implementiert hat.

Bsp:

template<class RAIter>
class simple_reverse_iter 
{
  RAIter iter;
public:
  typedef typename RAIter::reference reference;
  simple_reverse_iter& operator ++() {--iter; return *this}

  reference operator*() {return *iter;}
  RAIter& operator->() {return iter;}
};

int main()
{
  typedef std::vector<int>::iterator Iter:
  typedef simple_reverse_iter<Iter> ReverseIter;
  typedef simple_reverse_iter<ReverseIter> NotReallyReverseIter;
  typedef simple_reverse_iter<NotReallyReverseIter> WTFNowIAmConfusedIter;
}

Ich denk mal du kannst dir vorstellen was ich meine
(sonst siehe auch Artikel zur Operatorüberladung, Abschnitt zu op-> )

Dravere

pumuckl schrieb:

Ich denk mal du kannst dir vorstellen was ich meine

Herje, es war ja auch nicht wirklich ernst gemeint. Ja ich kann mir vorstellen, was du meinst. Ich habe doch nur auf den Post von ... (copy & paste) ... juzklzfujktsrh geantwortet.

Hmmm, da kommt mir eine Idee ...

#include <vector>
#include <iostream>

template<typename ObjT, typename FuncT>
void send_to(ObjT* obj, FuncT func)
{
	func(obj);
}

template<typename ObjT, typename FuncT>
void send_to(ObjT& obj, FuncT func)
{
	send_to(obj.operator->(), func);
}

void foo(int* p)
{
	std::cout << *p << std::endl;
}

int main()
{
	std::vector<int> vec;
	vec.push_back(5);

	send_to(vec.begin(), &foo);
	send_to(vec.rbegin(), &foo);

	return 0;
}

Zufrieden?

Grüssli

Tachyon

Eine Erweiterung meines Horizontes bezüglich C++ hat ergeben, dass mein hier gegebenes Statement Unsinn war.

Dravere

Tachyon schrieb:

pumuckl schrieb:

...

Bei einem Reverseiterator sollte operator->() aber nicht wirklich den gekapselten Iterator zurückgeben, sondern das Objekt, das durch den gekapselten Iterator referenziert wird.
Bei Deiner Version müsste man ReverseIter.operator->().operator->() schreiben, um an das unterliegende Objekt zu kommen. Das widerspricht aber dem definierten Standardverhalten von Iteratoren.

Siehst du, das hast du davon pumuckl. Jetzt müssen wir den Leuten och erklären, dass dies bei einem operator -> automatisch passiert. Solange der operator -> keinen Zeiger zurückgibt, wird von dem Objekt, welches zurückgegeben wurde, wieder der operator -> aufgerufen, bis entweder ein Zeiger zurückkommt oder kein operator -> mehr überladen ist. Steht irgendwo im Standard, bin zu faul die genaue Stelle rauszusuchen. Kannst aber gerne selber testen

Steht übrigens auch in diesem Artikel:
http://magazin.c-plusplus.net/artikel/%DCberladung%20von%20Operatoren%20in%20CPlusPlus%20(Teil%201)

Grüssli

Tachyon

Dravere schrieb:

...

Uch hab meinen Post nochmal überarbeitet.