Folgende Aufgabe habe ich gelöst und möchte diese nun in eine Klasse verpacken ( zur Übung):

Eine Datei MESS.DAT im Stammverzeichnis der Festplatte C: enthält genau 100 Messwerte vom double-Typ. Die Messwerte sollen aus der Datei in ein Feld eingelesen werden. Mittels dreier Funk-tionen, die Sie definieren sollen, werden a) der Mittelwert, b) das Maximum und c) das Minimum der Messwerte bestimmt und in eine Datei ERGEBNIS.DAT im Stammverzeichnis der Festplatte C: ab-gelegt.

Mit Unterfunktionen realisiert ( ist Funktionsfähig)

#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#define ANZAHL 10

using namespace std;

//Funktionsdeklarationen
int einlesen(string quell_datei, double* messwerte);
double mittelwert(double* messwerte);
double maximum(double *messwerte);
double minimum(double *messwerte);
void ausgabe(string ausgabe_datei, double* messwerte);

int main()
	{
		//Dateien
		string quell_datei = "C:\\MESS.DAT";
		string ausgabe_datei = "C:\\ERGEBNIS.DAT";
		double* messwerte = new double [ANZAHL];

		//File input
		einlesen(quell_datei,messwerte);

		//File output
		ausgabe(ausgabe_datei,messwerte);
	}

int einlesen(string quell_datei, double* messwerte)
	{
		ifstream input;
		input.open(quell_datei.c_str(), ios_base::in);

		if (!input)
			{
				cout << "Datei öffnen fehlgeschlagen!";
				return -1;
			}

		for (int i = 0; i < ANZAHL; i++)
			{
				input >> messwerte[i];
			}

		input.close();
	}
void ausgabe(string ausgabe_datei, double* messwerte)
	{
		ofstream output;
		output.open(ausgabe_datei.c_str(), ios_base::out);

		if (!output)
			{
				cout << "Datei erstellen fehlgeschlagen!";
			}

		output << "Mittelwert der " << ANZAHL << " Werte lautet: " << mittelwert(messwerte);;
		output << "\nMaximum der " << ANZAHL << " Werte lautet: " << maximum(messwerte);;
		output << "\nMinimum der " << ANZAHL << " Werte lautet: " << minimum(messwerte);;

		output.close();
	}

double mittelwert(double* messwerte)
	{
		double mittelwert=0;
		for (int j=0; j < ANZAHL; j++)
			{
				mittelwert += messwerte[j];
			}

		return (mittelwert/ANZAHL);
	}
double maximum(double* messwerte)
	{
		double maximum = *max_element(messwerte, messwerte+ANZAHL);

		return maximum;
	}
double minimum(double* messwerte)
	{
		double minimum = *min_element(messwerte, messwerte+ANZAHL);

		return minimum;
	}

**So und ab hier ist mein Lösungsansatz um das ganze mit einer Klasse zu realisieren:

mit dem Ausgabe Operator stimmt bei dem Programm scheibar was noch nicht:

error C2804: Binärer Operator '<<' hat zu viele Parameter

**

#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#define ANZAHL 10

using namespace std;

class Detail
	{
		private:
				string inFile;
				string outFile;
		public:

				Detail(); //Default-Konstruktor
				Detail(string inFile, string outFile); //Parameter-Konstruktor

				//Getter
				int auslesen(string in,double* messwerte)const;

				double mittelwert(double* messwerte)const;
				double maximum(double* messwerte)const;
				double minimum(double* messwerte)const;

				//Setter
				friend ofstream& operator << (ofstream& outFile,Detail const& wert, double* messwerte);
	};

Detail::Detail()
	{
		inFile= "C:\\MESS.DAT";
		outFile= "C:\\ERGEBNIS.DAT";
	}

Detail::Detail(string inFile, string outFile)
	{
		this->inFile= inFile;
		this->outFile= outFile;
	}

int Detail::auslesen(string in,double* messwerte)const
	{
		ifstream input;
		input.open(in.c_str(), ios_base::in);

		if (!input)
			{
				cout << "Datei öffnen fehlgeschlagen!";
				return -1;
			}

		for (int i = 0; i < ANZAHL; i++)
			{
				input >> messwerte[i];
			}

		input.close();
	}

double Detail::mittelwert(double* messwerte)const
	{
		double mittelwert=0;
		for (int j=0; j < ANZAHL; j++)
			{
				mittelwert += messwerte[j];
			}

		return (mittelwert/ANZAHL);
	}
double Detail::maximum(double* messwerte)const
{
	double maximum = *max_element(messwerte, messwerte+ANZAHL);

	return maximum;
}
double Detail::minimum(double* messwerte)const
	{
		double minimum = *min_element(messwerte, messwerte+ANZAHL);

		return minimum;
	}

int main()
{
Detail Standard ();
cout << Standard;
}

ofstream& operator << (ofstream& outFile,Detail const& wert, double* messwerte)
	{
		return (outFile << "Der Mittelwert ist: " << wert.mittelwert(messwerte) << "\nDer Maximalwert ist: " << wert.maximum(messwerte) << "\nDer Minimalwert ist: " << wert.minimum(messwerte));
	}

Hat jemand ne ahnung was der Fehler ist?

vielen dank im voraus
mfg fraggelfragger

Der Operator << bekommt als Parameter einmal den ostream, und dazu noch deine Klasse für die du ihn schreibst. Was du da noch übergeben willst ist mir schleierhaft.

In deiner main übergibst du ihm ja auch nur eine Instanz deiner Klasse.

Ps:
Wenn ich mir den Code so anschaue, passt ein Operator<< nicht gerade zu deiner Klasse.
Im Grunde ist sie ja nur eine Ansammlung von Funktionen sowie zwei Strings, durch die du Werte einlesen kannst.

Mein Vorschlag: Speichere in deiner Klasse noch ein Array von Messwerten, und speichere so die eingelesenen Daten in deiner Klasse.
Dann kannst du diese auch im operator<< ausgeben.

Also von vorne:
Als erstes musst du dir überlegen, was die Klasse soll. Sie soll deine Daten verwalten. Also muss sie die Daten kennen.
Daraus ergibt sich:

class measurements
{
	std::vector<double> m_data;
};

m_data ist also private (bei class default, bei struct wäre es public).
Dann willst du die Daten aus einem Stream lesen können. Welcher das ist, soll dir doch egal sein? So lange du mit den Funktionen von std::ostream auskommst, musst du dich doch nicht auf einen bestimmten beschränken.
Also musst du den Stream-Operator >> überladen. Das selbe zum Ausgeben!

class measurements
{
	std::vector<double> m_data;

public:
	friend std::istream& operator>>(std::istream& in, measurements& data);
	friend std::ostream& operator<<(std::ostream& out, measurements const& data);
};

Dann optimieren wir mal deinen Code zum einlesen:

int Detail::auslesen(string in,double* messwerte)const
    {
        ifstream input;
        input.open(in.c_str(), ios_base::in);

        if (!input)
            {
                cout << "Datei öffnen fehlgeschlagen!";
                return -1;
            }

        for (int i = 0; i < ANZAHL; i++)
            {
                input >> messwerte[i];
            }

        input.close();
    }

Nun als erstes hat std::ifstream einen Konstruktor, sodass du nicht zusätzlich die Funktion open aufrufen musst. Dann ist bei std::ifstream sowieso klar, das es std::ios_base::in ist
Wenn du von 0 bis >0 hochzählst, kannst du einen unsignieren Typen nehmen, da es eh positive Zahlen sind
Zu guter letzt kannst du den Aufruf von close dir sparen, da dieser im Destruktor (beim verlassen des Scopes(in dem Fall der Funktion)) aufgerufen wird.

int Detail::auslesen(string in, double* messwerte) const
{
	std::ifstream input(in.c_str());

	if (!input)
	{
		cout << "Datei öffnen fehlgeschlagen!";
		return -1;
	}

	for (unsigned int i = 0; i < ANZAHL; i++)
		input >> messwerte[i];
}

nun fällt auf, das du auch einen Wert zurück geben musst, wenn die Funktion erfolgreich war! Und evtl. kommst du auch mit true und false hin. Achja und in solltest du besser als const Reference übergeben. Aber das interessiert uns nun nicht weiter, da wir das nicht brauchen, wenn wir operator >> nutzen, da dort weder eine Möglichkeit gegeben ist einen Wert zurück zu geben noch einen String diesem zu übergeben Aber wir bekommen einen std::istream! Und diese hat das fail & bad - bit, das wir jeweils setzen können, wenn etwas schief geht!

Achja, ein Problem haben wir noch. Wie viele Werte sind den nun in der Datei? Das interessiert uns nicht! Wenn nichts mehr drin steht, schlägt input >> messwerte[i]; fehl!

friend std::istream& operator>>(std::istream& in, measurements& data)
{
	double tmp(0.0);
	while (in >> tmp) m_data.push_back(tmp);
	return in;
}

wäre doch gut! Wir lesen ein und gucken ob alles in ordnung war (while (in >> tmp)) und wenn jahr packen wir es zu unseren daten (m_data.push_back(tmp)).

Nun das selbe zum Ausgeben!

friend std::ostream& operator<<(std::ostream& out, measurements const& data)
{
	return (out << "Der Mittelwert ist: " << data.midpoint() << "\nDer Maximalwert ist: " << data.max() << "\nDer Minimalwert ist: " << data.min());
}

So.

Jetzt noch deine 3 Funktionen und schon fertig:

double measurements::midpoint() const
{
    double tmp(0);
    for (std::size_t i(0); i < m_data.size(); ++i)
        tmp += m_data[i];

    return tmp / m_data.size();
}

Nun kann man hier das ein wenig kürzen, in dem man mit std::plus<double> und std::transform arbeitet, aber das wäre difinitiv über dem Niveau der restlichen Klasse

double measurements::max() const
{
    return *std::max_element(m_data.begin(), m_data.end());
}

double measurements::min() const
{
    return *std::min_element(m_data.begin(), m_data.end());
}

. Soweit wäre das alles:
measurements.hpp

#if !defined (MEASUREMENTS_HPP__INCLUDED)
#define MEASUREMENTS_HPP__INCLUDED

#if (_MSC_VER >= 1300)
#pragma once
#endif // (_MSC_VER >= 1300)

#include <vector>
#include <iostream>
#include <algorithm>

class measurements
{
	std::vector<double> m_data;

public:
	friend std::istream& operator>>(std::istream& in, measurements& data)
	{
		double tmp(0.0);
		while (in >> tmp) m_data.push_back(tmp);
		return in;
	}
	friend std::ostream& operator<<(std::ostream& out, measurements const& data)
	{ return (out << "Der Mittelwert ist: " << data.midpoint() << "\nDer Maximalwert ist: " << data.max() << "\nDer Minimalwert ist: " << data.min()); }

public:
	double measurements::max() const
	{ return *std::max_element(m_data.begin(), m_data.end()); }
	double measurements::min() const
	{ return *std::min_element(m_data.begin(), m_data.end()); }
	double measurements::midpoint() const
	{
		double tmp(0);
		for (std::size_t i(0); i < m_data.size(); ++i)
			tmp += m_data[i];
		return tmp / m_data.size();
	}
};

#endif // MEASUREMENTS_HPP__INCLUDED

Beispiel (main.cpp)

#include <iostream> // std::cout
#include <fstream> // std::ifstream
#include "measurements.hpp" // measurements

int main()
{
    std::ifstream file_stream("C:\\Messadaten.dat");
    if (!file_stream) { std::cerr << "FEHLER: Datei nicht vorhanden!" << std::endl; return 1; }
    measurements data;
    file_stream >> data;
    std::cout << data;

    std::cin.get();
}

Statt aus der Datei könnten nun auch einfach per (std::cin >> data) die Daten vom Benutzer eingegeben werden müssen, usw. usf.

Nun kann man hier das ein wenig kürzen, in dem man mit std::plus<double> und std::transform arbeitet, aber das wäre difinitiv über dem Niveau der restlichen Klasse

du meinst wohl

return std::accumulate(data.begin(), data.end(), 0.0) / data.size();

die frage ist allerdings, ob der OP nicht so etwas wie min_element auch selbst implementieren soll.

PS. schon wieder std::endl?

(D)Evil schrieb:

Ach du Scheiße ..

hehe das dachte ich auch als ich das Programm geschrieben habe, da ich eigentlich geglaubt habe, das Prinzip verstanden zu haben. Aber dies war wohl nicht 100% der Fall.:D

Hier ein paar Fragen zu deinem Lösungsvorschlag:

1. Du hast viele Library Funktionen benutzt die ich noch nie gehört habe wie z.b

size_t var()
begin()
end()
push_back()

std::cerr
std::size()

In welcher Bibliothek stehen diese drin? In der iostream?!
size_t var()
begin()
end()
push_back()

Die Funktion von push_back() ist mir noch etwas unklar.

friend std::istream& operator>>(std::istream& in, measurements& data)
    {
        double tmp(0.0);
        while (in >> tmp) m_data.push_back(tmp);
        return in;        
    }

Es wird erstmal eine temp variable mit dem Rückgabewert double definiert,

double tmp(0.0);

danach wird der stream vom input File gestartet, alles bis zum nächsten Leerzeichen bzw. Leerzeile wird hierbei in tmp geschrieben.

in >> tmp

Mit der While schleife wird überprüft ob der stream true ist, in diesem Fall wird das was in tmp steht zu m_data übergeben.

Jetzt fehlt mir alledings die Kenntniss wie dieser Vector aussieht,
In Mathe: Zeilenvector ( 0, 1, 0,....) Sieht dieser Vector auch so aus?
Warum benutzt man dann hierzu kein gewöhnliches Array? Sondern benutzt diese Vector Funktion?

Wie kann ich die Ausgabedatei angeben? Weil momentan wird das ja nur auf Bildschirmconsole ausgegeben oder?
so vllt.!?

ifstream input("C:\\MESS.DAT");
		if(!input)
			{
				cerr << "Die Datei konnte nicht geöffnet werden"<< endl;
				//alternativ zu
				//cout << "Die Datei konnte nicht geöffnet werden"<< endl;

				return 1;		
			}
		Messungen data;
		input >> data;
                ofstream output("C:\\ERGEBNIS.DAT");
		output << data;

		cin.get();

mfg fraggelfragger

Ps: Soweit habe ich den Code nun: ( hier (Z32) error C2065: 'm_data': nichtdeklarierter Bezeichner)

#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>

using namespace std;

class Messungen
	{
	private: //(bei Klasse ist dies Default-> man kanns weglassen)

		vector<double> m_data;

	public:

		//Operatoren überladen
		friend istream& operator>> (istream& inFile, Messungen& data);
		friend ostream& operator<< (ostream& outFile, Messungen const& data);

		//Getter
		double mittelwert()const;
		double maximum()const;
		double minimum()const;

	};

istream& operator>> (istream& inFile, Messungen& data)
	{
		double temp = 0.0;
		while (inFile >> temp)
			{
				m_data.push_back(temp);
			}

		return inFile;
	}
ostream& operator<< (ostream& outFile, Messungen const& data)
	{
		return ( outFile << "Mittelwert: " << data.mittelwert() << "\nMaximum : " << data.maximum() << "\nMinimum : " << data.minimum());
	}

double Messungen::mittelwert()const
	{
		double temp=0.0;
		for(unsigned int i=0;i < m_data.size(); i++)
			{
				temp *= m_data[i];
			}

		return temp/m_data.size();
	}

double Messungen::maximum()const
	{
		return *max_element(m_data.begin(),m_data.end());
	}
double Messungen::minimum()const
	{
		return *min_element(m_data.begin(), m_data.end());
	}

int main()
	{
		ifstream input("C:\\MESS.DAT");
		if(!input)
			{
				cerr << "Die Datei konnte nicht geöffnet werden"<< endl;
				//alternativ zu
				//cout << "Die Datei konnte nicht geöffnet werden"<< endl;

				return 1;		
			}
		Messungen data;
		input >> data;
		cout << data;

		cin.get();
	}

1. Du hast viele Library Funktionen benutzt die ich noch nie gehört habe wie z.b

size_t var()
begin()
end()
push_back()

std::cerr
std::size()

In welcher Bibliothek stehen diese drin? In der iostream?!
size_t var()
begin()
end()
push_back()

. Die Container Klassen des Standards haben alle ein relativ ähnliches Interface, um die Arbeit damit leicht zu machen (.push_back(T) bsw. zum einfügen eines Elementes an das Ende des Containers, .size() zum Abfragen der Größe)

std::size_t ist laut Standard ein Datentyp zur Angabe von Größen und ist oftmals als unsigned int definiert.

begin() und end() geben jeweils sog. Interatorn zurück (des Containers). Iterator ist ein Design-Pattern (Entwurfsmuster) das dazu dient eine einheitliche Abhandlung der Datentypen zu gewähren. Sie dir z.B. einmal die Funktionen des <algorithm>-Header an. (Erklärung zu Iterator: http://de.wikibooks.org/wiki/Muster:_Iterator)

std::size_t var(0) ist eine Variable vom Typ std::size_t die mit 0 initialisiert wird.

std::cerr ist ein Ausgabestream, ähnlich wie std::cout, doch für die Ausgabe von Fehlern vorgesehen. Wenn man sich streng daran hält, kann man nachher hingehen und diesen Stream z.B. in eine Datei umleiten und bekommt dann nur die Fehlermeldungen in die Datei

std::size() wo hast du das gefunden? Wenn dann als Memberfunktion einer Containerklasse.

Die Funktion von push_back() ist mir noch etwas unklar.

friend std::istream& operator>>(std::istream& in, measurements& data)
{
    double tmp(0.0);
    while (in >> tmp) m_data.push_back(tmp);
    return in;        
}

Also, du musst push_back im Kontext sehen. push_back ist eine Memberfunktion der Klasse std::vector. std::vector ist ein dynamischer Array (vereinfacht gesagt!) d.h. die Daten liegen aufm Heap und die Größe muss nicht von vornerrein vorbestimmt sein, sondern du kannst sie während der Laufzeit verändern.

std::vector<T>::push_back(T const& data) fügt am Ende des "dynamsichen Array" ein Item hinzu(data).

Es wird erstmal eine temp variable mit dem Rückgabewert double definiert,

double tmp(0.0);

danach wird der stream vom input File gestartet, alles bis zum nächsten Leerzeichen bzw. Leerzeile wird hierbei in tmp geschrieben.

in >> tmp

Mit der While schleife wird überprüft ob der stream true ist, in diesem Fall wird das was in tmp steht zu m_data übergeben.

Ehm ja, also als erstes lege ich in der tat eine Temporär Variable an, in die ich nun im folgenden einlesen.

in >> tmp ließt nun die Daten ein. Wenn das Ende der Datei erreich ist oder aus einem anderen Grund nichtmehr eingelesen werden kann, wird das failbit gesetzt (des Streams). operator>> von std::fstream gibt eine Referenz auf diesen wieder zurück. d.h. steht dann, wenn man das einlesen mal außer acht lässt, in der Schleife:

while (in)

. Dabei wird "in" per operator void* in einen void* Umgewandelt. Dieser nimmt NULL an (damit abbruch der Schleife!), wenn ein fail oder bad-bit gesetzt ist.

Wenn der Wert eingelesen wurde, wird er nun in den "dynamsichen Array" (m_data) gepackt (push_back).

Jetzt fehlt mir alledings die Kenntniss wie dieser Vector aussieht, [...]
kann ich mir das so vorstellen wie ein Array? warum benutzt man hierzu kein array?

Im Prinzip schon. Es ist ein Array auf dem Heap. Um nun nicht bei jedem Hinzufügen eines Elements neu den Speicher anfordern zu müssen und alle Daten zu kopieren, geht std::vector hin und reserviert schonmal eine gewisse Menge an Speicher vor (so zu sagen ). Wenn auch der reservierte Bereich voll ist, wird ein noch größerer Bereich reserviert und die Daten aus dem alten Bereich werden in den neuen rüber kopiert.
Das ist das Merkmal eines std::vector. Die Daten sind als ein Block gespeichert und nicht, wie bsw. eine std::list, die Daten quer über den Speicher verteilt.

Warum man hier keinen Array benutzt? Weil du dann auf die Größe angewiesen bist, die du vorher fest in deinem Programm angegeben hast (ok man kann sich da auch selber was schreiben(läuft aber auch übern Heap und nicht übern Stack) und das ist ja nicht unbedingt deine Absicht. Wie viele Daten nun in der Datei stehen weißt du ja nicht unbedingt vorher!

Hoffe das war erstmal genug zum Verständnis

Vielen Dank euch beiden für eure Antworten,

(D)Evil schrieb:

Ach du Scheiße ..

hehe das dachte ich auch als ich das Programm geschrieben habe, da ich eigentlich geglaubt habe, das Prinzip verstanden zu haben. Aber dies war wohl nicht 100% der Fall.:D

Hier ein paar Fragen zu deinem Lösungsvorschlag:

1. Du hast viele Library Funktionen benutzt die ich noch nie gehört habe wie z.b

size_t var()
begin()
end()
push_back()

std::cerr
std::size()

In welcher Bibliothek stehen diese drin? In der iostream?!
size_t var()
begin()
end()
push_back()

hm, da haben wir dich vielleicht etwas überfordert.
std::cerr ist der standardfehlerausgabestream (tolles wörtchen), sowie std::cout der standardausgabestream ist. std::cerr schreibt in die fehlerausgabe, std::cout auf die standardausgabe (so kann man sich bei eigenen konsolenprogrammen dann beispielsweise die standardausgabe in eine datei umleiten und nur von der fehlerausgabe trennen). außerdem ist std::cerr ungepuffert, wohingegen std::cout gepuffert ist (deshalb mein hinweis auf das überflüssige endl. obwohl, endl ist eigentlich so gut wie immer überflüssig).

std::vector ist eine der container-klassen, die bei C++ quasi "mit dabei" sind. es repräsentiert ein dynamisches array, das sich automatisch um die speicherverwaltung kümmer, wenn bspw. neue elemente hinzugefügt werden. ist für dein beispiel etwas suboptimal, weil du ja genau weißt, wieviele messwerte eingelesen werden sollen.

begin, end, push_back, size sind elementfunktionen von vector, push_back fügt einfach ein element an das ende des vectors (des dynamischen arrays) ein, und kümmert sich automatisch um jegliche speicherverwaltung. begin und end liefern jeweils iteratoren auf das erste bzw. (nach)letzte element des vectors. iteratoren kannst du dir ein bisschen wie zeiger vorstellen, mit denen du durch ein array navigieren kannst. (sie sind bei vector auch meist als zeiger implementiert, muss aber nicht sein) die standardalgorithmen arbeiten nicht mit zeigern, sondern mit iteratoren, quasi eine abstrahierte form von zeigern. size letztendlich liefert dir einfach die anzahl der elemente in einem vector.
size_t hat damit wenig zu tun, std::size_t ist einfach der standardtyp für größenangaben, definiert im header <cstddef>.

istream& operator>> (istream& inFile, Messungen& data)
    {
        double temp = 0.0;
        while (inFile >> temp)
            {
                m_data.push_back(temp);
            }

        return inFile;
    }

m_data ist ein member der klasse data, d.h. um darauf zugreifen zu können brauchst du eine instanz. und wie man auf membervariablen zugreifen kann (und hier unterscheidet sich std::vector nicht von builtins wie int, double, ...), weißt du (wie ich weiß):

istream& operator>> (istream& inFile, Messungen& data)
{
   double temp = 0.0;
   while (inFile >> temp)
   {
      data.m_data.push_back(temp); //m_data ist ein member von data und push_back ist eine memberfunktion von m_data.
   }
   return inFile;
}

Jetzt fehlt mir alledings die Kenntniss wie dieser Vector aussieht,
In Mathe: Zeilenvector ( 0, 1, 0,....) Sieht dieser Vector auch so aus?
Warum benutzt man dann hierzu kein gewöhnliches Array? Sondern benutzt diese Vector Funktion?

std::vector ist eine klasse
es vereinfacht das arbeiten mit rohem speicher. roher speicher ist schlecht, meistens nicht ausnahmesicher und es wirkt "grob", damit zu hantieren. std::vector übernimmt z.b. jegliche speicherverwaltung, wenn er über seine grenzen hinaus wächst. generell sind solche containerklassen zu bevorzugen, zumal sie -relativ einheitlich- funktionen zum einfachen umgang mit ihnen bereitstellen. (bspw. iteratoren oder memberfunktionen wie size() usw.) du verwendest für strings ja auch std::string (ebenso eine containerklasse mit iteratoren und automatischer speicherverwaltung) und hantierst nicht selbst mit rohen char-zeigern herum

in deinem konkreten fall ist ein vector allerdings vielleicht doch nicht ganz angebracht. du hast zwei möglichkeiten, wenn du zur compile-zeit schon weißt, wie viele daten du einlesen willst: du verwendest die built-in arrays oder eine containerklasse für ebendiese.

erster fall: du nimmst statt dem vector ein array.

class Messungen
{
//...
private:
   double m_data[100];
//...
}

das stellt allerdings keine funktionen wie begin, end und size zur verfügung. size berechnest du in diesem fall mit

size_t size = sizeof(m_data)/sizeof(*m_data);

lies: size ist gleich die größe des arrays in bytes dividiert durch die größe des eines (in diesem fall des ersten) elements - ergibt die anzahl der elemente in dem array.

die eingabefunktion sieht dann so aus:

istream& operator>> (istream& inFile, Messungen& data)
    {
        double temp = 0.0;
        int i = 0;
        while (inFile >> temp)
            {
                data.m_data[i++] = temp;
            }

        return inFile;
    }

die mittelwertfunktion musst du im hinblick auf die nicht mehr automatisch berechnete größe ("size") ändern und die iteratoren für min_element und max_element sind dann zeiger auf das erste element des arrays und auf eins hinter dem letzten:

size_t size = sizeof(m_data) / sizeof(*m_data);
return min_element (m_data, m_data+size)

in der funktion mittelwert solltest übrigens nicht multiplizieren sondern addieren

die alternative sind gekapselte arrays. dafür gibt es std::tr1::array. den code musst du dabei dann nur bei der eingabe verändern, mittelwert und die anderen funktionen funktionieren dann so wie in (D)Evils beispiel. std::tr1::array liegt im header <tr1/array> und seine definition in Messungen sieht so aus:

class Messungen
{
//...
   std::tr1::array<int, 100> m_data;
//...
};

allerdings ist die wahrscheinlichkeit groß, dass entweder dein prof oder dein compiler std::tr1::array nicht kennen. beides ist nicht gut.

PS. ich sehe gerade mit der vorschaufunktion, dass (D)Evil bereits geantwortet hat.

Warum man hier keinen Array benutzt? Weil du dann auf die Größe angewiesen bist, die du vorher fest in deinem Programm angegeben hast (ok man kann sich da auch selber was schreiben(läuft aber auch übern Heap und nicht übern Stack) und das ist ja nicht unbedingt deine Absicht. Wie viele Daten nun in der Datei stehen weißt du ja nicht unbedingt vorher!

in diesem fall weiß er es natürlich ist deine version einfacher erweiterbar.

PPS.
ich habe lang überlegt, ob ich dir (fraggelfragger) vielleicht noch kurz etwas über klassen und objekte erzählen soll. ich habe zeit

in C++ hast du zwei arten von funktionen, sogenannte "freie" funktionen, das sind funktionen in der art

int foo ();

int bar ()
{
}

int main ()
{
}

und memberfunktionen, die als member einer klasse definiert sind. so z.b.

class Foo
{
public: 
   void bar ();
   void foo ();
   void bar (int, int);
};

eine klasse ist eine vorlage, eine vorlage für eine spezifische art von objekten. ein objekt ist ein konkretes ding, das im speicher liegt. eine klasse, die ja nur eine vorlage ist, gibt es im speicher deines programmes letztendlich gar nicht. du arbeitest immer nur mit objekten, d.i. mit instanzen einer klasse. du kannst von einer klasse (außer du verbietest es explizit) mehrere instanzen anlegen:

class Bar
{
public:
   int i;
};

//...
Bar a;
Bar b;
Bar c;

zeile 1-5 beschreiben, wie ein objekt vom typ Bar (klassissfiziert als Bar, klasse wird hier ein bisschen so verwendet wie in der biologie) auszusehen hat: es hat einen einzigen, öffentlichen member, und das ist ein int mit dem namen i. jede der drei instanzen (a, b und c) sieht nun genauso aus: jede hat einen integer namens i, auf den man zugreifen kann:

a.i = 42;
b.i = 23;
c.i = 5;

analog kannst du memberfunktionen definieren, die du für jede instanz der klasse separat aufrufen kannst. in unserem beispiel:

class Bar
{
public:
   int i;
   void foo ();
};

void Bar::foo ()
{
   cout << "in Bar::foo\n";
}

//...
Bar a, b, c;
a.foo();
b.foo();
c.foo();

foo wird in diesem fall für jede instanz aufgerufen. das besondere an memberfunktionen ist, dass sie in jedem fall, auch in unserem - und auch wenn es nicht so aussieht - ein argument mitübergeben bekommen, dieses ist der this-pointer. dieser zeiger zeigt auf gerade jene instanz, für die die memberfunktion aufgerufen wurde. rufst du a.foo() auf, zeigt this auf die adresse von a, bei b und c analog.

memberfunktionen funktionieren also wie freie funktionen, deren erster parameter ein zeiger auf eine struktur ist. in C könntest du das ungefähr so nachbilden:

struct Bar
{
   int i;
};

void foo (Bar* this)
{
    cout << "in Bar::foo\n";
}

//...
Bar a, b, c;
foo (&a);
foo (&b);
foo (&c);

das verstehen des mechanismus "dahinter" hilft dir vielleicht, besser mit klassen und instanzen zurecht zu kommen.

zurück zu den memberelementen (oder auch: elementvariablen)
da jede instanz ihre eigenen elementvariablen hat und der this-zeiger ein zeiger auf die instanz ist, für die die aktuelle memberfunktion aufgerufen wurde, kannst du über den this-zeiger auf die membervariablen der einen instanz (für die die funktion aufgerufen wurde) zugreifen:

class Bar
{
public:
   int i;
   void foo ();
};

void Bar::foo ()
{
   cout << "in Bar::foo. member i = " << this->i << '\n';
}

//...
Bar a, b, c;
a.i = 42;
b.i = 23;
c.i = 5;

a.foo(); //gibt 42 aus
b.foo(); //gibt 23 aus
c.foo(); //gibt 5 aus

mit dem nötigen hintergrundwissen über den this-zeiger solltest du also nun verstehen, warum jeweils unterschiedliche zahlen ausgegeben werden - es wird schließlich foo() jeweils für unterschiedliche instanzen (derselben klasse) aufgerufen.

nun wäre es umständlich, in allen memberfunktionen "this->" zu schreiben, deshalb ist es erlaubt, diesebn expliziten zugriff wegzulassen.
Bar::foo könnten wir deshalb auch so implementieren:

void Bar::foo ()
{
    cout << i;
    //gleichbedeutend mit: cout << this->i;
}

dass das nur in memberfunktionen funktioniert, sollte dir nun auch klar sein, denn eine freie funktion hat den zusätzlichen parameter "this" nun einmal nicht.

weiter: eine funktion, die als friend deklariert wird, ist keine memberfunktion der klasse. (alle memberfunktionen der klasse sind automatisch ihr "friend", alles andere wäre auch unsinnig). deshalb hat sie auch keinen this-zeiger und deshalb musst du oben in deinem operator << auch eine referenz auf ein Messungen-objekt übergeben.

ich hoffe, das macht dir einiges klarer und verständlicher. wenn du noch fragen hast, stell sie