Wohin zeigt string::end ?

Ja und wie geht das dann mit der for schleife?
"Solange iterator ungleich irgendwo ist, inkrementiere" So kann das wohl kaum funktionieren!?

Tachyon

Klark Cent schrieb:

Ja und wie geht das dann mit der for schleife?
"Solange iterator ungleich irgendwo ist, inkrementiere" So kann das wohl kaum funktionieren!?

Nicht ungleich irgendwo sondern ungleich irgendwas. Bei 'ner Liste geht es ja auch. Und da gibt es kein "hinter dem letzten Element".

verstehe ich nicht.
irgendwo/irgendwas - gibts da irgendein unterschied ??
der != operator vergleicht jedesmal ob die adresse teil des strings ist oder was? Wär das nicht bisserl langsam? :p

unskilled

der ungleich operator prüft, ob die adresse, auf die der iterator zeigt, gleich der anderen ist - dabei ist aber nicht gesagt, wo der letzte iterator hinzeigt - man nimmt bei listen gern einen dummy-knoten, bei vectoren wird es eins hinter dem letzten element sein(nicht lt. definition, sondern in der praxis) - man könnte end aber auch auf 0 zeigen lassen - nur könnte man das eben nicht so effektiv implementieren, deshalb wird es nicht so häufig gemacht - allerdings würde ich nicht behaupten wollen, dass es nie so gemacht wird - da es keinen richtigen weg gibt, gibt es auch keinen falschen....

bb

Tachyon

unskilled schrieb:

der ungleich operator prüft, ob die adresse, auf die der iterator zeigt[...]

Nein, operator!= überprüft, ob die Iteratoren ungleich sein. Mehr nicht. Das muss nichts mit Adressen zu tun haben.

Dravere

#include <limits>
#include <iostream>

#include <cassert>

class WoodooIterator
{
public:
	static int const THE_WOODOO_LIMIT = 10;

private:
	int m_value;

public:
	WoodooIterator()
		: m_value(std::numeric_limits<int>::max())
	{
	}

	WoodooIterator(int start)
		: m_value(start)
	{
	}

public:
	WoodooIterator& operator ++()
	{
		assert(m_value <= THE_WOODOO_LIMIT);

		++m_value;

		if(m_value > THE_WOODOO_LIMIT)
		{
			m_value = std::numeric_limits<int>::max();
		}

		return *this;
	}

	WoodooIterator& operator --()
	{
		if(m_value > THE_WOODOO_LIMIT)
		{
			m_value = THE_WOODOO_LIMIT;
		}
		else
		{
			--m_value;
		}

		return *this;
	}

	int operator *() const
	{
		assert(m_value <= THE_WOODOO_LIMIT);
		return m_value;
	}

	bool operator !=(WoodooIterator const& rhs) const
	{
		return m_value != rhs.m_value;
	}
};

int main()
{
	WoodooIterator iter = WoodooIterator(-8);
	WoodooIterator end;

	for(; iter != end; ++iter)
	{
		std::cout << *iter << ',';
	}

	std::cout << *(--end) << std::endl;

	return 0;
}

Der Iterator ist zwar nicht ganz Standardkonform, aber er sollte aufzeigen, was wir dir probieren zu erklären. Der end Iterator hat einen völlig anderen Wert, als die anderen. Sein Wert ist nicht ein nachfolge Wert. Wenn man den end Iterator dekrementiert, bekommt man allerdings trotzdem den letzten Wert.
Auch siehst du hier ganz klar nochmals, dass ein Iterator nicht gleich einer Adresse sein muss. Man kann alles in einen Iterator packen.

Grüssli

Tachyon

Ein etwas kürzeres Beispiel:

std::istream_iterator<std::string> iter(std::cin);
std::istream_iterator<std::string> end;

for(; iter != end; ++iter)
{
    std::cout << *iter << '\n';
}

Wie soll hier ein Zeiger hinter das Ende des Streams aussehen? Wo ist denn das Ende des Streams? Ein Zeiger? Wohl kaum.

Edit:
Aber das Beispiel von Dravere zeigt gut, wie es intern aussehen kann. :p

Beim String könnten intern genauso gut irgendwelche Indizes verwaltet werden, und std::string::end() arbeitet irgendwie mit std::string::npos . Alles mögliche ist denkbar.

Dravere

Tachyon schrieb:

Ein etwas kürzeres Beispiel:

Da gebe ich mir extra solche Mühe ...
Aber gutes Beispiel, vielleicht helfen ja auch beide

Grüssli

yeah ich habs gecheckt! TYVM!

volkard

Das geht Dich nichts an.
(Nach reichlich zehn Jahren durfte ich endlich mal diesen Satz in einem Fachforum schreiben, yeah!)