Ich will hier ein kleines Programm schreiben, dass mir den Mittelwert von Werten berechnet, welche der Benutzer eingeben muss. Nun benutze ich "vector". Der sollte sich ja eigentlich dynamisch zur Laufzeit vergrößern, wenn mehr Werte eingegeben werden, als bei der Initialisierung angegeben worden sind. Wenn ich mein noch nicht ganz fertiges Programm laufen lasse, dann funktioniert alles bis zum zehnten Wert Einwandfrei, wenn man aber den 11. Wert eingibt schmeißt mir das Programm einen Fehler. Ich weiß aber leider nicht warum...

#include<iostream>
#include<vector>
using namespace std;

int main()
{
	int anzahl = 0, i = 0, c = 0;
	vector<double> wert(10);

	cout << "Mittelwert-Berechnung" << endl << endl;

	do
	{
		cout << i+1 << ". Wert angeben: ";

		c = cin.peek();
		if(c != 'e')
		{
			cin >> wert[i];
			char cend = cin.get();
			i++;
		}
	}
	while(c != 'e');

return 0;
}

Nun benutze ich "vector". Der sollte sich ja eigentlich dynamisch zur Laufzeit vergrößern, wenn mehr Werte eingegeben werden, als bei der Initialisierung angegeben worden sind.

Wie jeder andere Container vergrößert sich ein vector dann, wenn du Elemente audrücklich einfügst. Bei einem Zugriff auf ein ganz bestimmtes Element ist es hingegen deine Aufgabe dafür zu sorgen, dass dieses Element überhaupt existiert.
Anstatt also dem vector eine bestimmte Anfangsgröße zu geben, solltest du ihn zunächst einmal leer lassen und dann mit jeder Eingabe ein Element hinzufügen (push_back).

Der vector vergrößert sich nur, wenn du explizit durch ein push_back etwas anhängst.

Genau gesagt erzeugt dein Code undefiniertes Verhalten. Der Feldoperator liest/schreibt ohne eine Bereichsprüfung. Nutze vector::resize oder vector::push_back um ihn zu vergrössern.

Wie soll man das dann machen? Muss ich dann quasi die zehn Iterationen der do-while-Schleife abzählen und dann das push_back ausführen?

Warum fängst du denn überhaupt mit 10 Elementen an?

Wie soll man das dann machen?

Statt cin >> wert[i]; schreibst du einfach:

int Temp;
cin >> Temp;
wert.push_back(Temp);

double wert;
cin>>wert;
werte.push_back(wert);

Aber wieso selber schreiben - die einfachste Lösung wäre std::accumulate()

Kannst du mir noch ein bisschen draufhelfen?

http://www.sgi.com/tech/stl/accumulate.html

Den Vector mit Zeigern oder mit einer der Standardmethoden an dei Funktion übergeben ist wohl nicht möglich?

Klar ist es möglich, aber ist nicht sinnvoll (Übergabe als Kopie wird recht aufwendig wenn der vector<> größer wird, Übergabe als Pointer ist ein Relikt aus C-Zeiten).

Aber: Ich verstehe irgendwie nicht, dass C++ hier quasi "verweigert", bzw. es anscheinend sehr schwer macht den Vector an eine Funktion zu übergeben und in der dann den Vector mit einer for-Schleife auslesen und dann eben die Werte aufaddieren und durch 2 zu teilen.

So, wie ich das verstanden habe, benötige ich ja für accumulate() auch noch Iteratore von denen ich widerum (noch) nicht weiß wie das gehen soll...

Hm, gut. Dann ist hier wohl das an eine Funktion übergeben wohl wirklich nicht so der bringer.

Aber: Ich verstehe irgendwie nicht, dass C++ hier quasi "verweigert", bzw. es anscheinend sehr schwer macht den Vector an eine Funktion zu übergeben und in der dann den Vector mit einer for-Schleife auslesen und dann eben die Werte aufaddieren und durch 2 zu teilen.

Was heißt hier "verweigert"? Es ist möglich, vector<>en zu kopieren, du mußt nur damit rechnen, daß dort eine ganze Menge Daten zusammenkommt. Deshalb verwendet man da lieber eine (const) Referenz.

So, wie ich das verstanden habe, benötige ich ja für accumulate() auch noch Iteratore von denen ich widerum (noch) nicht weiß wie das gehen soll...

Iteratoren sind eine Abstraktion, damit die Algorithmen nicht für jeden Container neu angepasst werden müssen (außerdem kannst du mit ihnen auch blanke Arrays oder Teilbereiche deines Containers beschreiben). Und die STL-Containerklassen bieten die Methoden begin() und end(), um Iteratoren für alle Elemente zu ermitteln:

double mv = accumulate(werte.begin(),werte.end(),0.0) / werte.size();

Hier der Code:

#include<iostream>
#include<vector>
#include<numeric>
using namespace std;

//void mittelwert(vector<double>* werte)
//{
//	int i, anzahl;
//
//	anzahl = werte[i];
//
//}

int main()
{
	int anzahl = 0, c = 0;
	int wert = 0, summe = 0, ergebnis = 0;
	vector<double> werte(1);

	cout << "Mittelwert-Berechnung" << endl << endl;

	do
	{
		cout << anzahl+1 << ". Wert angeben: ";

		c = cin.peek();
		if(c != 'e')
		{
			cin >> wert;
			werte.push_back(wert);
			char cend = cin.get();
			anzahl++;
		}
	}
	while(c != 'e');

	cout << werte[3];

	for(int i=0; i<anzahl; i=i+1)
	{
		summe = summe + werte[i];
	}

	ergebnis = summe / anzahl;

return 0;
}

So, jetzt vielleicht nochmal zum Thema vectoren an Funktionen übergeben. Wie mach ich das jetzt am Besten, bzw. ich hab dazu noch einige Frage:

double mv = accumulate(werte.begin(),werte.end(),0.0) / werte.size();

Wenn ich jetzt den Code von dir anschau ist mir da jetzt einiges nicht klar. Dass die Methode size() die Anzahl der im vector<> enthaltenen Element zurückgibt hab ich erlesenen können; somit ist das klar.

Returns the result of accumulating all the values in the range [first,last) to init.

accumulate ( InputIterator first, InputIterator last, T init );

Was aber nun accumulate() genau macht ist mir noch nicht ganz klar. Laut cplusplus ist die Standardoperation das Aufsummieren aller Elemente in einem Bereich und zurückgeben des berechneten Wertes. Was mir aber nicht klar ist, ist was mit dem "init" in obigem Zitat gemeint ist. Ich kann mir zwar denken, dass die Methode .begin quasi den Wert liefert der von obiger Definition durch first gefordert ist und die Methode .end den Wert liefert der von obiger Definition durch last gefordert ist. Was aber mach nunt begin und end wirklich?

Gibts eigentlich noch eine andere Seite als cplusplus bei der man evtl. einfach er auf die Methoden-Erklärung der STL kommt?

Wenn ich jetzt den Code von dir anschau ist mir da jetzt einiges nicht klar. Dass die Methode size() die Anzahl der im vector<> enthaltenen Element zurückgibt hab ich erlesenen können; somit ist das klar.

Returns the result of accumulating all the values in the range [first,last) to init.

accumulate ( InputIterator first, InputIterator last, T init );

Was aber nun accumulate() genau macht ist mir noch nicht ganz klar. Laut cplusplus ist die Standardoperation das Aufsummieren aller Elemente in einem Bereich und zurückgeben des berechneten Wertes. Was mir aber nicht klar ist, ist was mit dem "init" in obigem Zitat gemeint ist. Ich kann mir zwar denken, dass die Methode .begin quasi den Wert liefert der von obiger Definition durch first gefordert ist und die Methode .end den Wert liefert der von obiger Definition durch last gefordert ist. Was aber mach nunt begin und end wirklich?

Du kannst dir die Iteratoren als eine Weiterentwicklung von Zeigern vorstellen - du kannst sie dereferenzieren, weiterschieben und vergleichen. begin() liefert einen Iterator auf den Anfang des Containers, end() einen auf das Ende (genauer: hinter das letzte Element), damit hast du einen Bereich, den du als first/last an den Algorithmus übergeben kannst.
Der Wert init ist der Startwert für die Summierung (und entspricht dem summe = 0 bei deiner manuellen Schleife. Der ist nötig, weil dort je nach Anwendung andere Ausgangswerte notwendig werden könnten, z.B.:

//geometrisches Mittel:
double geo = pow( accumulate(werte.begin(),werte.end(),1.0,multiplies<double>), 1/werte.size() );

//String-Verkettung:
vector<string> zeilen;
...
string datei = accumulate(zeilen.begin(),zeilen.end(),string());

Returns the result of accumulating all the values in the range [first,last) to init.

accumulate ( InputIterator first, InputIterator last, T init );

Nochmal ein bisschen anders erklaert: Stell dir einen Iterator wie ein Zeiger vor. Dieser zeigt an eine bestimmte Stelle in deiner Datentruktur, in deinem Falle ein vector. Die Funktion accumulate will von dir zwei solcher Zeiger haben. Einen der auf den Anfang und einen der auf das Ende der Datenstruktur zeigt.

Beispiel:

vector<int> werte;

// Fülle den vector 'werte' mit den zahlen von 0-9
for(int i = 0; i < 10; ++i)
    werte.push_back(i);

Das sieht dann grafisch ungefaehr so aus:

=================================================
        | 0 || 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9 | 
        =================================================

Jetzt stellt dir dein vector diese Iteratoren bereit. In deinem Falle begin() und end(). Die würden dann hierhin zeigen:

=================================================
        | 0 || 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9 | 
        =================================================
  begin()-^                                         end() -^

begin() zeigt auf das erste Element und end() auf das Element nach dem letzten Element.

Jetzt sagst du accumulate: Hey, summiere mir mal die Wete von begin() bis end(). Dann laeuft accumulate gemütlich von Element zu Element bis es im Nichts (bei end()) landet und hört dann auf. Es macht also 0+1+2+3+4+5+6+7+8+9. Nebenbei hast du halt die Möglichkeit einen eigenen Startwert anzugeben, also: meinStartWert+0+1+2+3+4+5+6+7+8+9. Und genau dieser Startwert ist das init.

Nach diesem Iteratorprinzip laufen alle Container der STL. Diese Iterator geben dir die Möglichkeit unabhaegig von der wirklichen Datenstruktur dahinter mit Algorithmen (wie accumulate) darauf zu arbeiten. Jede Datenstrukur stellt Iteratoren bereit, sodass du an accumulate gerne auch ein std::list oder ein std::deque übergeben könntest.

Siehst du wie schön das ist! Du hast eine Funktion und kannst verschieden Datenstrukturen übergeben ohne für jede Datenstruktur ein eigenes accumulate zu schreiben und von diesem accumulate gibt es noch weitere Zahlreiche in der STL.

vip@r schrieb:

Gibts eigentlich noch eine andere Seite als cplusplus bei der man evtl. einfach er auf die Methoden-Erklärung der STL kommt?

Das Forum und die dir genannte Referenz. Wie oben beschrieben laeuft alles nach einem Prinzip. Hast du es einmal verstanden, verstehst du auch alles