Ich muss en Prog schreiben, indem ich in ner Schleife einen Wert einlese, den in zwei Variablen speicher und dann überprüfen muss, ob der eingebene Wert der größte bzw. der kleinste bis jetzt ist.... Ich komm nur einfach nicht übers einlesen hinweg weil ich offensichtlich irgendwas übersehe...-.-
hier mein Code:

#include<iostream>
#include<string>
#include<vector>

using namespace std;
int main(){
    double zahl=0;
    double zahl2=0;
    double zahl3=0;
    char schleifenbeender =' ';
    char beender=' ';
    vector<double> werte;

    while(cin>>zahl && schleifenbeender!='b'){
                    werte.push_back(zahl);
                    cout << zahl << endl;
                    zahl=zahl2;
    // ab hier weiß ich nicht mehr weiter 

    system("Pause");

    return 0;
}

hoffe mir kann geholfen werden

LG

Du hast nichts übersehen, sondern Du willst einen Lösungsansatz.
So wie ich das verstehe, sollst du keinen vector nutzen, sondern die zwei Variablen. Die könnten besser den Namen Min und Max haben (anstelle von zahl2 und zahl3)
Du initialisierst diese Variablen wie gehabt mit 0.
Nach dem einlesen von 'zahl' schaust du in Min, ob dort ein Wert kleiner dem eingelesenen Wert 'zahl' ist. Wenn nein, schreibst die den eingelesenen Wert 'zahl' in Min; Min hat jetzt den kleinsten jemals eingelesenen Wert und der eingelesenen Wert 'zahl' ist der bislang kleinste Wert, was Du ja ausgeben kannst.
Ähnlich verfährst Du mit Max.
Das machst Du natürlich solange in einer Schleife bis zum schleifenbeender.
PS. Wenn der eingelesene Wert 'zahl' nicht der kleinste oder größte Wert ist, solltest Du das auch ausgeben.
Gruß

Die Variablen sollten mit dem ersten Wert initialisiert werden. Das ist die allgemeinste Lösung und funktioniert egal, um was für Objekte es sich handelt. Dann kann man sich diese Lösung als Funktionstemplate aufschreiben und immer wieder benutzen . Ups, gibt's ja schon genau so in der Standardbibliothek .

Meinst du min_element und max_element? Aber bei dem Beispiel ist es sinvoller, es selber zu schreiben, da man die Variablen min und max ja eh braucht um festzustellen, ob ein neuer min oder max wert hinzugekommen ist.

@Jakoby aber wie sollte ich das ohne Vector Container machen, dann würde ja nach jedem einlesen neue Zahlen als Referenz da sein anstatt einer eingelesenen Zahlenmenge die man zum Vergleich für die kleinste bzw größte Zahl braucht?

@Phyax & Seppj:

Bin noch ziemlich am Anfang des Buches und es wurden gerade mal logische Operatoren und eben am Ende des Kapitels der Vector Container vorgestellt..
Sind das was Phyax gepostet hat auch nch zwei weitere Vector-Container die von +unendlich bis - unendlich gehen oder was?

LG

Meinst du min_element und max_element?

Ja. Und ich weiß, die laufen auf Iteratoren, da sie die Elemente nicht kopieren wollen. Aber wenn man wie hier Iteratoren hat, die ungültig werden können, dann ist das auch ganz flott selbst geschrieben:

#include <iostream>
#include <utility>
#include <iterator>

template<typename ForwardIterator> 
std::pair<typename ForwardIterator::value_type, typename ForwardIterator::value_type> 
minmax(ForwardIterator first, ForwardIterator last)
{
  typedef typename ForwardIterator::value_type val_t;

  val_t min = *first, max = *first;
  for (;first != last; ++first)
    {
      if (*first < min) min = *first;
      if (*first > max) max = *first;
    }
  return std::make_pair(min, max);
}

int main () 
{
  using namespace std;
  istream_iterator<double> it(cin), end;
  pair<double, double> result = minmax(it, end);
  cout << "Kleinste Zahl: " << result.first << '\n'
       << "Größte Zahl: " << result.second << '\n';
}

Oder etwas allgemeiner mit C++11, so dass die Funktion auch Pointer verträgt:

#include <iostream>
#include <tuple>
#include <iterator>
#include <type_traits>

template<typename ForwardIterator> 
auto
minmax(ForwardIterator first, ForwardIterator last)
  -> std::tuple<
    typename std::remove_const<typename std::remove_reference<decltype(*first)>::type>::type, 
    typename std::remove_const<typename std::remove_reference<decltype(*first)>::type>::type
    > 
{
  typedef typename std::remove_const<typename std::remove_reference<decltype(*first)>::type>::type val_t;

  val_t min = *first, max = *first;
  for (;first != last; ++first)
    {
      if (*first < min) min = *first;
      if (*first > max) max = *first;
    }
  return std::make_tuple(min, max);
}

int main () 
{
  using namespace std;
  double min, max;
  tie(min, max) = minmax(istream_iterator<double>(cin), istream_iterator<double>());
  cout << "Kleinste Zahl: " << min << '\n'
       << "Größte Zahl: " << max << '\n';
}

(In C++11 sind std::min und std::max übrigend in der Lage, eine ganze Liste von Elementen als Argument zu verarbeiten)

Entschuldigung an die Threadersteller für die Komplettlösung! Ich glaube so sehr hilfreich ist das für einen Anfänger sowieso nicht wirklich.

Fällt eigentlich jemandem etwas besseres für die Zeilen 10, 11 und 14 im zweiten Beispiel ein? Ich gebe ja gerne zu, dass ich in C++11 noch nicht so fit bin, manchmal übersehe ich einfache Lösungen.

typename std::iterator_traits<ForwardIterator>::value_type

Quark, mal wieder, leider. Hmm, so ganz begeistert bin ich noch nicht. Das deckt zwar Pointer ab (und hätte auch gleich im ersten Beispiel benutzt werden können, da C++98), aber gegen schlampig geschriebene Iteratoren ohne Traits schützt es noch nicht. Aber akzeptabel, da ich Schlamperei nicht unterstütze.

edit: Ich sollte mal dein Greasemokeyskript so langsam abschalten .

-> decltype(std::make_tuple(*last, *last))

Du könntest du Rückgabetyp evtl noch einfacher schreiben als:

-> decltype(std::make_pair(*last, *last))

Ahh, nun kommen wir zu Konstrukten, die gefallen.

#include<iostream>
#include<string>
#include<vector>

using namespace std;
int main(){
    double zahl=0;
    double min;
    double max=0;
    char schleifenbeender=' ';
    vector<double> werte;
    while(cin>>zahl && schleifenbeender!='b'){
                    werte.push_back(zahl);

    }

    for(int i=0;i<werte.size();i++){
            cout << werte[i]<<endl;
// wie krieg ich den Vektor dazu mir die gew. Werte auszugeben?!

}
system("Pause");
return 0;
}

Du willst also in einem vector<int> nach dem goessten Element suchen.

Im Idealfall soll das in der main so verwendet werden:

int groesste_zahl = groesstes_element(meinVector);

Die Funktion brauchste nur noch schnell schreiben:

int groesstes_element(const std::vector<int>& zahlen);

Der Parameter ist const , weil du ihn nicht verändern willst.

Du willst also den groessten Wert haben. Dann mach dir schonmal ne Variable dafür.

int groesste_zahl = 0;

Muss mit 0 gemacht werde, denn wenn ein leeres Array übergeben wird sollte die kleinste Zahl am besten 0 und nicht Müll sein.

Jetzt gehst du einfach von Anfang bis Ende des Arrays durch.
Dafür eignet sich natürlich wie immer prima ne for-Schleife:

for(unsigned i = 0; i < zahlens.size(); ++i)

Nun kannst du mithilfe einer einfachen if-Abfrage gucken, ob das jeweilige Element, also zahlen[i] groesser ist als groesste_zahl . Wenn ja, dann weißt du zahlen[i] groesste_zahl einfach zu.

Irgendwann biste dann durch damit. Jetzt brauchste nur noch den Wert durch ne return-Anweisung zurückgeben.
Die Funktion kann dann ganz einfach mit

int groesstes = groesstes_element(meinVector);

in der main-Funktion verwendet werden.

Wenn Du das jetzt immer noch nicht hinkriegst, kann ich dir auch nicht mehr helfen.

Muss mit 0 gemacht werde, denn wenn ein leeres Array übergeben wird sollte die kleinste Zahl am besten 0 und nicht Müll sein.

Wieso?

Incocnito schrieb:

Muss mit 0 gemacht werde, denn wenn ein leeres Array übergeben wird sollte die kleinste Zahl am besten 0 und nicht Müll sein.

Wieso?

entweder. du nimmst das erste element oder nimmst als max numeric_limits<T>::min und als min dann numeric_limits<T>::max. aber 0 ist bissl doof.

bb

/**
   *  @brief  Return the minimum element in a range.
   *  @ingroup sorting_algorithms
   *  @param  __first  Start of range.
   *  @param  __last   End of range.
   *  @return  Iterator referencing the first instance of the smallest value.
  */
  template<typename _ForwardIterator>
    _ForwardIterator
    min_element(_ForwardIterator __first, _ForwardIterator __last)
    {
      // concept requirements
      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
      __glibcxx_function_requires(_LessThanComparableConcept<
	    typename iterator_traits<_ForwardIterator>::value_type>)
      __glibcxx_requires_valid_range(__first, __last);

      if (__first == __last)
	return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
	if (*__first < *__result)
	  __result = __first;
      return __result;
    }