Ich verzweile grade daran die Maximalen und Minimalen Werte der Temperatur zu ermittel und auszugeben. Ich habe mir ein paar Zeilen aus dem Forum gesucht und damit etwas experimentiert. Jetzt wollte ich es in meinen Quelltext für die Temperatur erfassung eingeben, jeodch gibt es jetzt nur noch probleme

Die Aufgabenstellung der SGD zum Heft PCP04 lautet:

Die Daten von fünf verschiedenen Temperaturmessstationen (Nummer 1 bis 5) sollen in einem array gespeichert werden. Eine Funktion auswertung() soll herausfinden, an welcher Station der höchste und an welcher Station der niedrigste Wert gemessen wird. Die Anzeige der Station und des Messwertes soll im Hauptprogramm auf folgende Weise dargestellt werden:
Maximalwert 231.8 Grad an Station 2.
Minimalwert 198.3 Grad an Station 3.
Sollten zwei Stationen den gleichen Wert messen, wird nur eine der Stationen angezeigt.
Beachten Sie bitte folgende Vorgaben:
1. Die Größe des arrays soll über eine globale Konstante festgelegt werden, die im Quelltext immer, wenn möglich, benutzt wird.
2. Die Temperaturwerte werden zum Test in main() sofort dem array zugewiesen und zur besseren Kontrolle der Funktion sofort in geeigneter Weise ausgegeben.

Das habe ich bis jetzt zusammengeschustert.

/*#########################################
Erkennung der Max und Min Temperatur
#########################################*/

#include <iostream>

using namespace std;

void eingabe(int xFeld[5]) {
	for (int schleife = 0; schleife < 5; schleife++) {

		cout << "Bitte die Temp der " << schleife + 1 << ". Station eingeben: ";
		cin >> xFeld[schleife];

	}
	}

void auswertung(int xFeld[5]) {

	for (int schleife1 = 0; schleife1 < 5; schleife1 ++){
		cout << "Wert von Station " << schleife1 +1 << " ist: " 
		<< xFeld[schleife1] << " Grad" << endl;
		float wert, max, min;
		wert = xFeld;
		if (!(wert > min))
		{
			min = wert;
		}
		if (!(wert < max))
		{
			max = wert;
		}
		cout << max << endl;
		cout << min << endl;
	}
}

int main()
{
	int zahlenFeld[5];
	eingabe(zahlenFeld);
	auswertung(zahlenFeld);

	getchar();
	getchar();
	return 0;
}

welchen Wert muss ich verwenden für die if < min und max abfrage ?
Hoffe ihr könnt mit meinem Quelltext arbeiten und ihn zum laufen bringen.

Vielen Dank schon mal im vor raus

TIPP: wie wärs mit Bedingte Bewertung/Ausdrücke...

ganz schlecht.

[...] der Vollständigkeit wegen möchte ich gerne auf std::min und std::max hinweise.

Nathan schrieb:

Du meinst wohl eher min_element und max_element...

Oder gar minmax_element().

#include <algorithm>  // minmax_element
#include <iostream>   // cout

typedef double temperature;
const int nstations = 6;

void print(const temperature *first, const temperature* last){
  int i = 1;
  while(first!=last)
    std::cout << "Temp an Station " << i++ << ": " << *first++ << "°\n";
}

int main(){
  using namespace std;
  temperature stations[nstations] = { 74., -54., 67., 0., 120.0, 42 };
  print( stations, stations+nstations );
  const auto minmax = minmax_element( stations, stations+nstations );
  cout << "Minimalwert " << *minmax.first  << "° an Station " << minmax.first-stations+1  << ".\n";
  cout << "Maximalwert " << *minmax.second << "° an Station " << minmax.second-stations+1 << ".\n";
}

Das ist aber sicher nicht Zweck des ganzen.

Mein Ratschlag:
erstelle eine Funktion

const temperature* min(const temperature* first, const temperature* last);
// Gibt einen Zeiger auf den minimalen Temperaturwert im Array [first, last) zurück.
// Ist kein Minimum vorhanden gibt min() first zurueck.
// Sind mehrere (gleiche) Minima vorhanden gibt min() das erste zurueck.

Dann noch eine Funktion max(), die das gleiche für ein Maximum macht.

Die Stationsnummer errechnest Du dann über Zeigerarithmetik (wie oben).

Als Tipp noch: Du nimmst zu Beginn Deiner Funktionen an, dass der erste Wert das Minimum/Maximum ist, danach vergleicht Du alle Werte und setzt gegebenenfalls das Minimum neu.

const temperature* min(const temperature* first, const temperature* last);
// Gibt einen Zeiger auf den minimalen Temperaturwert im Array [first, last) zurück.
// Sind mehrere (gleiche) Minima vorhanden gibt min() das erste zurueck.
// Gibt last zurueck wenn das Array leer ist

sagt mir garnicht
und der rest verwirrt mich auch total, wirkt alles sehr kompilziert.
Ist mein Quelltext denn sooo falsch ? Da Fehlen doch eigentlich nur kleinigkeiten oder ?

Solltest du nicht eine globale Konstante benutzen für die Größe des Arrays?
Du machst bei der Ermittlung von min und max einen Denkfehler.
min und max werden bei jedem Durchlauf der Schleife neu erstellt. Deshalb kann man sich nicht darauf verlassen, dass sie die gleichen Werte beibehalten werden. Du musst sie außerhalb der Schleife definieren und initialisieren. Außerdem sollten sie nicht den Wert speichern, sondern den Index (Datentyp unsigned int reicht hierfür aus, du brauchst kein float).
Dann überprüfst du für jeden Wert im Array:
Ist er kleiner als array[min]? Wenn ja, weise min den akutellen Index zu.
Ist er größer als array[max]? Wenn ja, weise max den aktuellen Index zu.
Zum Schluss gibst du array[min] und array[max] aus.

Nein, dein Quelltext ist nicht falsch.
Er ist nur überflüssig, weil die Standardlib das bereits bietet.

#include <algorithm>

sagt mir garnicht
und der rest verwirrt mich auch total, wirkt alles sehr kompilziert.
Ist mein Quelltext denn sooo falsch ? Da Fehlen doch eigentlich nur kleinigkeiten oder ?

Glaub mir: schreib eine Funktion, die nur das Minimum bestimmt. Und sieh dann weiter. Wenn Du soweit bist ist der Rest ein Kinderspiel.

Die Loesung Ausgabe/min/max in einer Funktion ist unübersichtlich und nicht schoen.

Vergiss das #include <algorithm> für den Moment.

jetzt sagt er mit aber aber "error c2446 "<" keine konvertierung von "int" in "int" [].
Und noch vieles vieles mehr

#include <iostream> 

using namespace std;

void eingabe(int Feld[5]) 
{
	int max = Feld[1];
	int schleife;
	for (schleife = 0; schleife < 5; schleife++) {

		cout << "Bitte die Temp der " << schleife + 1 << ". Station eingeben: ";
		cin >> Feld[schleife];

		}
	if (max < Feld[schleife])
	{
			max = Feld[schleife];

	}
 cout << "Der Max-Wert betraegt: " << max << endl;
}

int main()
{
	int zahlenFeld[5];
	eingabe(zahlenFeld);
	getchar();
	getchar();
	return 0;
}

Wenn Du auf die Eingabe durch den Benutzer bestehst, sehe ich die Teilprobleme:
- Eingabe
- Ausgabe
- Minimum suchen / ausgeben
- Maximum suchen / ausgeben

Eingabe() hast Du ja quasi schon geschrieben

void eingabe(int Feld[5])
{
   int schleife;
   for (schleife = 0; schleife < 5; schleife++)
   {
     cout << "Bitte die Temp der " << schleife + 1 << ". Station eingeben: ";
     cin >> Feld[schleife];
   }
}

Die max() Funktion ist in Deiner Version von eingabe() auch schon versteckt und muss nur herausgelöst werden:

void max(int Feld[5])
{
  int max = Feld[1];  // obacht: indiziert wird mit 0 beginnend! Is' aber hier egal...
  int schleife;
  for (schleife = 0; schleife < 5; schleife++)
  {   
    if (max < Feld[schleife])
    {
      max = Feld[schleife];       
    }
  }
  cout << "Der Max-Wert betraegt: " << max << endl;
}

Das war's auch schon. Ich habe Die Funktionalitäten Deiner Funktion nur getrennt.

okay, cool.
jetzt gibt er mir den max wert aus. nur wie kann ich jetzt noch die Station ermitteln wo der max wert her kommt ?

Na komm...! Du merkst Dir in einer weiteren Variable den Index des Maximums?!

/*##########
e04_1.2
###########*/

# include <iostream>

using namespace std;

int main()
{
	double zahlenFeld[5] = {24.5,28.7,31.2,26.4,32.3};

	for (int schleife = 0; schleife < 5; schleife ++) {
		cout << "Der Wert der " << schleife+1 << ". Station ist: "
			<< zahlenFeld[schleife] << " Grad" << endl;

	}  
	double max = zahlenFeld[0];

  { 
int schleife;
  int (max > zahlenFeld[schleife]);
    {
      max = zahlenFeld[schleife];      
    }

  cout << endl << "Der Max-Wert betraegt: " << max << " Grad and Station " << endl;
  }

  double min = zahlenFeld[0];
  {  
	int schleife;
    int (min > zahlenFeld[schleife]);
    {
      min = zahlenFeld[schleife];      
    }
  }
  cout << endl << "Der Min-Wert betraegt: " << min << " Grad and Station " << endl;

	getchar();
	return 0;
}

jetzt bekomme ich gesagt "warning C4700: Die nicht initialisierte lokale Variable "schleife" wurde verwendet."
Ich finde den Fehler allerdings nicht, außerdem werden mir für Max und Min die selben werte ausgeben und auch immer nur von einer Station. Und die bestimmung von welcher Station der Max bzw. Min wert kommt bekomm ich auch net gebacken...

Danke für eure Geduld und Nerven
Hoffe ihr könnt mir schnell helfen damit ich das letzte Programm hier fertig bekomme.

int schleife;
  int (max > zahlenFeld[schleife]);

hier verwendest du "schleife", initialisiert es aber nicht.

Vermutlich möchtest du dort eine zweite Schleife haben. Und nein, "if" ist keine Schleife.

Danke für die hilfreichen antworten, jedoch muss das Programm doch anderes sein, und zwar sollen die Werte Fix sein und für den Anwender bereits vorgegeben sein.
Nun bin ich zu diesem Quelltext gekommen:[...]

Tut mir leid, aber ich habe weder Zeit noch Lust immer das gleiche zu schreiben:
Teile das Problem in kleinere Probleme auf und schreibe Funktionen für die Teilprobleme.
(Das Problem Eingabe hat sich ja gerade erledigt.)

Und dringendst solltest Du Dir nochmal das Thema Schleifen in Deinen Kursunterlagen anschauen.

Viel Erfolg.