Grundkonzepte der Standard-C ++ - Bibliothek

Published on January 11, 2019

Grundkonzepte der Standard-C ++ - Bibliothek

    Dieser Artikel definiert die grundlegenden Konzepte der Standard-C ++ - Bibliothek. Es ist vorgesehen, in Zukunft darauf zu verweisen.

    Der größte Teil der Standard-C ++ - Bibliothek ist die STL (Standard Template Library). Die STL-Bibliothek enthält fünf Hauptkomponenten:

    • container (container) : verwaltet eine Gruppe von Objekten im Speicher.
    • Iterator (Iterator) : Ermöglicht dem Algorithmus, auf den Inhalt des Containers zuzugreifen.
    • Algorithmus (Algorithmus) : Bestimmt das Rechenverfahren.
    • Funktionsobjekt : kapselt eine Funktion in einem Objekt zur Verwendung durch andere Komponenten.
    • Adapter (Adapter) : Passt die Komponente an, um eine andere Schnittstelle bereitzustellen.



    Alle Komponenten erfüllen eine Reihe von Anforderungen und stimmen daher gut überein.

    Aus der Definition eines Containers folgt, dass jede Benutzerdatenstruktur ein Container ist. In unserem Fall verfügen Container über Standarddatenstrukturen , z. B. eine Liste (Liste), einen Vektor (Vektor), ein Wörterbuch (Karte) und viele andere. Die formalen Anforderungen an Container sind recht umfangreich, aber die Grundregel ist der Zugriff auf die Elemente. Der Zugriff auf Containerelemente erfolgt über spezielle Objekte - Iteratoren(siehe unten). Sie wissen möglicherweise nicht, wie sich die Elemente des Containers im Speicher befinden, aber Sie wissen sicher, dass Iteratoren nacheinander wiederholt werden können und jeder von ihnen Zugriff auf das Element gewährt. Ein Iterator, der auf das erste Element zeigt, kann mit der Methode begin () des Iterators abgerufen werden . Behälter. Der Iterator, der auf das letzte Element zeigt, kann mit der Methode iterator end () abgerufen werden . Behälter. Mit anderen Worten, Iteratoren befinden sich im Intervall (oder die Halb-), die als formal geschrieben werden kann [beginnen, Ende). Musterbehälterdeklaration:

    struct a_container {
        struct an_iterator;
        an_iterator begin();
        an_iterator end();
    };

    In dem erwarteten Standard C ++ 20 wird vorgeschlagen, eine Struktur zu verwenden, die Halbintervalle - Bereiche einschließt


    Iterator - ein Objekt, das Zugriff auf die Elemente des Containers bietet und ihnen eine Iteration ermöglicht. Der Iterator ist eine Containereigenschaft. In den ersten Implementierungen der Standard-C ++ - Bibliothek wurde der Iterator als Zeiger auf ein Containerelement implementiert. In modernen Implementierungen ist dies eine Klasse, die einen Zeiger auf ein Containerobjekt einkapselt.

    Die Hauptanforderungen für Iteratoren sind das Vorhandensein von Dereferenzierungsoperatoren und Inkrementen. Nachfolgend finden Sie eine Containerdeklaration mit einem Iterator.

    template<typename TYPE>
    struct a_container {
        struct an_iterator {
            void operator++();
            TYPE& operator*();
        };
        an_iterator begin();
        an_iterator end();
    };

    Ich kann den Algorithmus nicht besser definieren als den Standardalgorithmus: Der Algorithmus ist eine Folge von Aktionen, die in einer endlichen Anzahl von Schritten zum gewünschten Ergebnis führt .

    Im Falle von STL werden Algorithmen durch Vorlagenfunktionen implementiert, die als Eingabeparameter halbe Intervalle von Iteratoren verwenden. Die allgemeine Signatur dieser Algorithmen wird wie folgt beschrieben:

    template<typename ITERATOR, typename RESULT>
    RESULT an_algorithm(ITERATOR first, ITERATOR last, ...);

    In der Klassendeklaration können Sie den Operator () überschreiben. Wenn dieser Operator in einer Klasse neu definiert wird, erhalten die Objekte dieser Klasse die Eigenschaften von Funktionen (sie können als Funktionen verwendet werden). Solche Objekte sind funktionelle oder genannt functors . Die Verwendung von Funktoren ist praktisch, wenn eine Funktion über einen „Speicher“ verfügen muss, und als Ersatz für Funktionszeiger.
    Beginnend mit dem Standard C ++ 11 besteht die Möglichkeit, Funktoren kurz zu schreiben - Lambda-Funktionen.
    Es gibt keine besonderen Anforderungen an die Funktionsweise von Funktoren. Es sei denn, die Vererbung von der Funktionsfunktion kann gelegentlich erforderlich sein (bis zum Standard C ++ 11 - unary_function oder binary_function). Ein kleines Beispiel für die Implementierung des Funktors:

    template<typename TYPE>
    struct plus{
        TYPE operator ()(const TYPE& p1, const TYPE& p2) const{
            return p1 + p2;
        }
    };

    STL bietet auch eine Reihe von Klassen und Funktionen (Funktionen) an, die die Schnittstelle in die gewünschten konvertieren. Insbesondere gibt es den Stack-Adapter, bei dem es sich um behälterbasierte Geräte bzw. den Stack handelt. Betrachten Sie als Beispiel einen Binärfunktionsadapter für eine unäre Funktion (im Moment, in dem diese Funktion im C ++ - Standard für veraltet erklärt wird):

    template<typename BIDIRECTIONAL_FUNCTION, typename TYPE>
    class bind1st {
        BIDIRECTIONAL_FUNCTION _bf;
        TYPE _first;
    public:
        bind1st(BIDIRECTIONAL_FUNCTION bf, TYPE first): _bf(bf), _first(first) {}
        TYPE operator()(const TYPE& p) const {
            return _bf(_first, p);
        }
    };

    Zum selbstlesen


    1. Entwurf von Standard C ++ 20 auf Github
    2. C ++ - Referenz
    3. C ++ - Anwendungsentwicklung
    4. Range-v3, Vorschlag für Standard