C++ const_iterator invalid type argument of ‘unary *’

[monsterhaus]

Hallo,

bin gerade dabei, mir ein wenig C++ mit dem Primer anzueignen.

Jetzt ist in einen der Übungsaufgaben ein Progrämmchen gefordert, das in einem vector<int> gespeicherte Werte addiert, nach dem Schema 1. + letztes; 2. + vorletztes; ... . Jetzt bekomme ich aber folgende Fehlermeldung, welche ja aussagt, dass ich dem "*" Operator ein falsches Argument übergebe.


Hier mal der betreffende Code:

//numbers ist der Vektor mit den Integerwerten
for(vector< int >::const_iterator i = numbers.begin(); i < numbers.end(); i++){
		cout << "The sum of " << *i << " and " << *(numbers.end() - i - 1) << " is " << *i + *(numbers.end() - i - 1) << endl;
	}

Ich komme jetzt nicht darauf, warum

(numbers.end() - i - 1)

ein ungültiges Argument für "*" ist.

Ich hoffe, mir kann jemand helfen.
Vielen Dank

 

[kuddlmuddl]

Ich bin bei deinem Schleifenkopf gerad etwas irritiert..
verwendet man Iteratoren nicht so, dass man eher prüft, ob der Iterator dem Ende entspricht? Also so:
for(vector< int >::const_iterator i = numbers.begin(); i != numbers.end(); i++){
Oder ist das in diesem Fall ok, da der Iterator für int-Werte eingesetzt wird?

 

[IceMatrix]

nein ist nicht ok. iterator kannst du nur gegen andere iterators vergleichen mit == oder !=, da nicht der wert innerhalb des containers verglichen wird, sondern die position des iterators innerhalb des containers.

*(numbers.end() - i - 1) ist generell falsch. bei * handelt es sich nicht um eine dereferenzierung, sondern um einen überladenen operator der klasse vector<int>::const_iterator. wenn du auf einen bestimmten eintrag in deinem vektor zugreifen willst, dann geht das über numbers[index] (hier in dem fall).

ich verstehe allerdings nicht wozu du hier überhaupt einen iterator verwendest. wenn du eh schon einen vektor hast, dann kannst du auch gleich direkt auf die einträge über ihren index zugreifen.

 

[antred]

Mit std::advance() und std::distance() sollte es eigentlich auch möglich sein.

for( std::vector< int >::const_iterator i = numbers.begin(); i != numbers.end(); ++i )
{
	const std::vector< int >::const_iterator beg = numbers.begin();
	const int dist = std::distance( beg, i );
	std::vector< int >::const_iterator other = numbers.end();
	std::advance( other, -( dist + 1 ) );

	std::cout << "The sum of " << *i << " and " << *other << " is " << *i + *other << std::endl;
}

Ob das jetzt allerdings eleganter ist, als operator [] oder die at()-Methode zu verwenden, das sei mal dahingestellt.

Ergänzung (10. Mai 2011)

Eine andere Lösung wäre, sich mit einem const_iterator und einem const_reverse_iterator gleichzeitig von beiden Enden des vectors durchzuarbeiten.

 

[convexus]

Unter den Voraussetzungen das numbers nicht leer ist und eine gerade Anzahl von Elementen enthält, sollte der nachfolgende Source korrekt funktionieren:

std::vector< int >::const_iterator i = numbers.begin(), j = numbers.end();
--j;
while(i < j) {
	std::cout << "The sum of " << *i << " and " << *j << " is " << *i + *j << endl;
	++i;
	--j;
}

 

[monsterhaus]

Vielen Dank für alle Bemerkungen! Ich habe es jetzt nach vielem hin und her geschafft, mit eurer Hilfe, eine funktionsfähige Schleife zu bauen. Sie deckt auch eine ungerade Zahl an Elementen:

	//Iterator starting in the back, decreasing to the begin
	vector< int >::const_iterator back_i = numbers.end();
		//Set to last element in vector
	back_i--;
		//If vector size is 0, there is nothing to do
	if(numbers.size() == 0)
		return 1;
		//Iterate from first element to the middle
	for(vector< int >::const_iterator i = numbers.begin(); i <= back_i; i++, back_i--){
			//There could be an odd count of numbers
		if(i >= back_i){
			cout << "You have an odd count of numbers, the number in the middle is: " << *i << endl;
			break;
			//Else calculate the sum
		}else{
			cout << "The sum of " << *i << " and " << *back_i << " is " << *i + *back_i << endl;
		}
	}