Das Standardbeispiel komplizieren

Lesen Sie ein Array von Ganzzahlen, die durch Leerzeichen von der Datei input.txt getrennt sind. Sortieren Sie sie und schreiben Sie in output.txt

#include <vector> #include <algorithm> #include <fstream> int main(){ //  input.txt   std::ifstream fin("input.txt"); //  output.txt   std::ofstream fout("output.txt"); //       std::vector<int> v; //  ,           std::copy(std::istream_iterator<int>(fin), std::istream_iterator<int>(), std::inserter(v, v.end())); //   std::sort(v.begin(), v.end()); //  ,          std::copy(v.begin(), v.end(), std::ostream_iterator<int>(fout, " ")); return 0; } 

• Eine der Grundlagen der Bibliothek sind Iteratoren sowie die von ihnen definierten Halbintervalle. Durch die Semantik (Read-by-Verhalten) stimmen sie mit Zeigern überein. Das heißt, der Dereferenzierungsoperator * gibt Ihnen das Element zurück, auf das sich der Iterator bezieht. ++ übersetzt den Iterator in das nächste Element. Insbesondere wird jeder Container durch seine Enditeratoren (begin, end) dargestellt, wobei begin auf das erste Element zeigt, end - für das letzte ;
• Algorithmen, die mit Containern als Parameter arbeiten, nehmen den Anfang und das Ende des Containers (oder eines Teils davon);
• Der Kopierkopieralgorithmus schreibt einfach Elemente von einem halben Intervall in ein anderes um. Wenn im Zielcontainer kein Speicher zugewiesen ist, ist das Verhalten nicht vorhersehbar [ Kopie ].
• Die Inserter-Funktion fügt vor dem angegebenen Iterator [ Inserter ] einen Wert in den Container ein.
• istream_iterator und ostream_iterator bieten Container-Zugriff auf Streams [ istream_iterator , ostream_iterator ]

Die Datei input.txt enthält eine Liste mit Informationen zu Personen: Nachname, Vorname, Alter (jede Zeile ist ein Datensatz, Daten sind durch ein Leerzeichen getrennt). Lesen Sie diese Daten in ein Array, sortieren Sie sie nach Alter und schreiben Sie in die Datei output.txt. Zeigen Sie Informationen zu einer Person an, deren Alter mehr als 20, aber weniger als 25 Jahre beträgt.

1. Deklarieren Sie eine Datenstruktur. - Sie können etwas Nützliches definieren, aber in einem bestimmten Fall reicht die Struktur aus:
   
   

    struct man{ std::string firstname, secondname; size_t age; }; 

   
   Ich empfehle dringend, dass Sie die Implementierung von Kopierkonstruktoren mit Standardparametern und dem Kopieroperator in Betracht ziehen. Mit der Weiterentwicklung des Projekts werden Sie sie definitiv brauchen.
2. Überlastungs-E / A- Operatoren - Diese Operatoren werden von Iteratoren über Threads bearbeitet. Wie auch immer, es ist üblicher, sie zu verwenden.
   
   

    std::ostream& operator << (std::ostream& out, const man& p){ out << p.firstname << " " << p.secondname << " " << p.age; return out; } std::istream& operator >> (std::istream& in, man& p){ in >> p.firstname >> p.secondname >> p.age; return in; } 

3. Regeln für die Reihenfolge von Objekten definieren - Dies ist bereits eine große Fläche: Sie können den Operator <überschreiben, Sie können eine Funktion, einen Funktor oder einen Lambda-Ausdruck beschreiben. Verwenden Sie in diesem Fall die Funktion.
   
   

    bool comparator(const man& p1, const man& p2){ return p1.age < p2.age; } 

4. Definieren Sie eine Regel für die Auswahl von Objekten - Wieder eine ziemlich große Auswahl an Implementierungen. Diesmal soll es einen Funktor geben (ein Objekt der Klasse, in dem der Operator in Klammern [ Funktor ] definiert ist), an den Sie die Altersspanne übergeben können:
   
   

    struct predicate{ size_t begin, end; predicate(int p1, int p2): begin(p1), end(p2) {} bool operator ()(const man& p){ return (p.age > begin) && (p.age < end); } }; 

   
   Achten Sie auf den Konstruktor des Funktors - auf diese Weise können wir sein Verhalten anpassen.

 int main(){ std::ifstream fin("input.txt"); std::ofstream fout("output.txt"); std::vector<man> v; std::copy(std::istream_iterator<man>(fin), std::istream_iterator<man>(), std::inserter(v, v.end())); std::sort(v.begin(), v.end(), comparator); std::copy_if(v.begin(), v.end(), std::ostream_iterator<man>(std::cout, "\n"), predicate(20, 25)); std::copy(v.begin(), v.end(), std::ostream_iterator<man>(fout, "\n")); return 0; } 

1. Das Wissen und die aktive Verwendung der Algorithmen der Standardbibliothek beschleunigt die Entwicklung erheblich (genauer gesagt, dies führt zu Automatismus).
2. Das Deklarieren verschiedener Konstruktoren und Kopieroperatoren für Datenstrukturen ist nützlich. Sie werden in verschiedenen Situationen eingesetzt, insbesondere beim Einfügen von Elementen in Container.
3. Der Einfachheit halber können Sie die Eingabe- und Ausgabeoperatoren sowie den Vergleichsoperator und den Bestelloperator überladen.
4. Funktoren - ein leistungsstarkes Tool, mit dem Sie Funktionen mit "Speicher" oder zusätzlichem Verhalten implementieren können
5. ... vielleicht noch mehr ...

 #include <string> #include <vector> #include <fstream> #include <algorithm> #include <iostream> #include <iterator> struct man{ std::string firstname, secondname; size_t age; }; std::ostream& operator << (std::ostream& out, const man& p){ out << p.firstname << " " << p.secondname << " " << p.age; return out; } std::istream& operator >> (std::istream& in, man& p){ in >> p.firstname >> p.secondname >> p.age; return in; } bool comparator(const man& p1, const man& p2){ return p1.age < p2.age; } struct predicate{ size_t begin, end; predicate(int p1, int p2): begin(p1), end(p2) {} bool operator ()(const man& p){ return (p.age > begin) && (p.age < end); } }; int main(){ std::ifstream fin("input.txt"); std::ofstream fout("output.txt"); std::vector<man> v; std::vector<man>::iterator i; std::copy(std::istream_iterator<man>(fin), std::istream_iterator<man>(), std::inserter(v, v.end())); std::sort(v.begin(), v.end(), comparator); std::copy_if(v.begin(), v.end(), std::ostream_iterator<man>(std::cout, "\n"), predicate(20, 25)); std::copy(v.begin(), v.end(), std::ostream_iterator<man>(fout, "\n")); return 0; } 

1. Stepanov Al. Lee Meng, The Standard Template Library, 1995
2. CPP-Referenz, Kopie
3. CPP-Referenz, Inserter
4. CPP-Referenz, istream_iterator
5. CPP-Referenz, ostream_iterator
6. Wiki-Funktor