Vectorinhalt mit Eingabe verlgeichen

pyhax

SeppJ schrieb:

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.

H4rdstyl3

Danke erstmal für die Antworten!

@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

SeppJ

pyhax schrieb:

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.

314159265358979

typename std::iterator_traits<ForwardIterator>::value_type

SeppJ

314159265358979 schrieb:

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 .

314159265358979

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

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

SeppJ

314159265358979 schrieb:

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.

H4rdstyl3

Blöderweise wurde mein Porblem noch immer nicht gelöst...
hab mir jez was anders gedacht habe aber noch immer das Problem dass ich nicht weiß wie ich die kleinste bzw größte zahl rausbekomm.....gibts da für Vector Container vll ne Memberfunktion oder so was?!

#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;
}

Incocnito

Wurde doch bereits in der ersten Antwort gesagt.

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.

SeppJ

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?

unskilled

SeppJ schrieb:

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

SeppJ

Also wenn die Menge leer ist, dann würde ich auf einen undefinierten/default konstruierten Rückgabewert pochen. Alles andere wäre eine Lüge, die Fehler vertuscht.

Incocnito

Wäre eine Exception oder eine Assertion nicht irgendwie besser?
Wenn man std::min_element() bei nem leeren vector dereferenziert, kackt das Programm ja logischerweise auch ab.

pyhax

So stehts beim GCC in der Headerdatei:

/**
   *  @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;
    }