(*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

Wobei ich folgendes irgendwie "schick" finde:

doSomething(iterator->);

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

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

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

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

...

Uch hab meinen Post nochmal überarbeitet.