Namensräume
Varianten
Aktionen

std::map<Key,T,Compare,Allocator>::map

Von cppreference.com
< cpp‎ | container‎ | map

[Bearbeiten-Vorlage]
 
C++
 
Container-Bibliothek
 
std::map
Memberfunktionen
map::map
             
Nicht-Member-Funktionen
(bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Leitfaden zur Ableitung (C++17)
 
(1)
map();
 (bis C++11)
map()
    : map(Compare()) {}
 (seit C++11)
explicit map( const Compare& comp,
              const Allocator& alloc = Allocator() );
 (2)
explicit map( const Allocator& alloc );
 (3) (seit C++11)
template< class InputIt >

map( InputIt first, InputIt last,
     const Compare& comp = Compare(),

     const Allocator& alloc = Allocator() );
 (4)
template< class InputIt >

map( InputIt first, InputIt last,
     const Allocator& alloc )

    : map(first, last, Compare(), alloc) {}
 (5) (seit C++14)
map( const map& other );
 (6)
map( const map& other, const Allocator& alloc );
 (7) (seit C++11)
map( map&& other );
 (8) (seit C++11)
map( map&& other, const Allocator& alloc );
 (9) (seit C++11)
map( std::initializer_list<value_type> init,

     const Compare& comp = Compare(),

     const Allocator& alloc = Allocator() );
 (10) (seit C++11)
map( std::initializer_list<value_type> init,

     const Allocator& alloc )

    : map(init, Compare(), alloc) {}
 (11) (seit C++14)
template< container-compatible-range<value_type> R >

map( std::from_range_t, R&& rg,
     const Compare& comp = Compare(),

     const Allocator& alloc = Allocator() );
 (12) (seit C++23)
template< container-compatible-range<value_type> R >

map( std::from_range_t, R&& rg,
     const Allocator& alloc )

    : map(std::from_range, std::forward<R>(rg), Compare(), alloc) {}
 (13) (seit C++23)

Konstruiert einen neuen Container aus einer Vielzahl von Datenquellen und optional unter Verwendung des vom Benutzer bereitgestellten Allokators alloc oder des Vergleichsfunktions-Objekts comp.

1-3) Konstruiert einen leeren Container.
4,5) Konstruiert den Container mit den Elementen des Bereichs [first, last). Wenn mehrere Elemente im Bereich Schlüssel haben, die als äquivalent verglichen werden, ist nicht spezifiziert, welches Element eingefügt wird (abhängig von LWG2844).
Wenn [first, last) kein gültiger Bereich ist, ist das Verhalten undefiniert.
6,7) Kopierkonstruktor. Konstruiert den Container mit einer Kopie der Inhalte von other.

Wenn alloc nicht angegeben ist, wird der Allokator durch Aufrufen von std::allocator_traits<allocator_type>::
    select_on_container_copy_construction(other.get_allocator()) abgerufen.

 (seit C++11)

Während der Klassentempeltext-Argumentdeduktion trägt nur das erste Argument zur Deduktion des `Allocator`-Template-Parameters des Containers bei.

 (seit C++23)
8,9) Move-Konstruktor. Konstruiert den Container mit den Inhalten von other unter Verwendung von Move-Semantik. Wenn alloc nicht angegeben ist, wird der Allokator durch Move-Konstruktion aus dem Allokator von other bezogen.

Während der Klassentempeltext-Argumentdeduktion trägt nur das erste Argument zur Deduktion des `Allocator`-Template-Parameters des Containers bei.

 (seit C++23)
10,11) Initialisierungslisten-Konstruktor. Konstruiert den Container mit den Elementen der Initialisierungsliste init. Wenn mehrere Elemente im Bereich Schlüssel haben, die als äquivalent verglichen werden, ist nicht spezifiziert, welches Element eingefügt wird (abhängig von LWG2844).
12,13) Konstruiert den Container mit den Elementen von rg. Wenn mehrere Elemente im Bereich Schlüssel haben, die als äquivalent verglichen werden, ist nicht spezifiziert, welches Element eingefügt wird (abhängig von LWG2844).

Inhalt

[bearbeiten] Parameter

alloc - Allocator, der für alle Speicherallokationen dieses Containers verwendet wird
comp - Vergleichsfunktions-Objekt, das für alle Vergleiche von Schlüsseln verwendet wird
first, last - das Iteratorpaar, das den Quell-Bereich der zu kopierenden Elemente definiert
Sonstiges - ein anderer Container, der als Quelle zur Initialisierung der Elemente des Containers verwendet werden soll
init - Initialisierungsliste zum Initialisieren der Elemente des Containers
rg - ein containerkompatibler Bereich, d.h. ein input_range, dessen Elemente in value_type konvertierbar sind
Typanforderungen
-
InputIt muss die Anforderungen von LegacyInputIterator erfüllen.
-
Compare muss die Anforderungen an Compare erfüllen.
-
Allocator muss die Anforderungen an Allocator erfüllen.

[bearbeiten] Komplexität

1-3) Konstant.
4,5) N·log(N), wobei N std::distance(first, last) ist, im Allgemeinen, linear in N, wenn [first, last) bereits nach value_comp() sortiert ist.
6,7) Linear zur Größe von other.
8,9) Konstant. Wenn alloc gegeben ist und alloc != other.get_allocator(), dann linear.
10,11) N·log(N) wobei N init.size() ist im Allgemeinen, linear in N, wenn init bereits nach value_comp() sortiert ist.
12,13) N·log(N) wobei N ranges::distance(rg) ist im Allgemeinen, linear in N, wenn rg bereits nach value_comp() sortiert ist.

[bearbeiten] Ausnahmen

Aufrufe von Allocator::allocate können Ausnahmen auslösen.

[bearbeiten] Hinweise

Nach der Move-Konstruktion eines Containers (Überladung (8,9)) bleiben Referenzen, Zeiger und Iteratoren (außer dem End-Iterator) zu other gültig, zeigen aber auf Elemente, die sich nun in *this befinden. Der aktuelle Standard gibt diese Garantie durch die allgemeine Aussage in [container.reqmts]/67, und eine direktere Garantie wird durch LWG issue 2321 in Betracht gezogen.

Obwohl bis C++23 nicht formell gefordert, haben einige Implementierungen den Template-Parameter Allocator bereits in früheren Modi in nicht-deduzierte Kontexte verschoben.

Feature-Test-Makro Wert Std Feature
__cpp_lib_containers_ranges 202202L (C++23) Bereichs-bewusste Konstruktion und Einfügung; Überladungen (12,13)

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
 
template<typename Key, typename Value, typename Cmp>
std::ostream& operator<<(std::ostream& os, std::map<Key, Value, Cmp> const& map)
{
    os << "{ ";
    for (auto comma{map.size()}; auto const& p : map)
        os << '\'' << p.first << "' is " << p.second << (--comma ? ", " : " ");
    return os << "}\n";
}
 
struct Point
{
    double x, y;
 
    friend std::ostream& operator<<(std::ostream& os, Point pt)
    {
        return os << '(' << pt.x << ", " << pt.y << ')';
    }
};
 
struct PointCmp
{
    bool operator()(const Point& lhs, const Point& rhs) const
    {
        return lhs.x < rhs.x; // NB: y is intentionally ignored
    }
};
 
int main()
{
    // (1) Default constructor
    std::map<std::string, int> map1;
    map1["something"] = 69;
    map1["anything"] = 199;
    map1["that thing"] = 50;
    std::cout << "map1 = " << map1;
 
    // (4) Range constructor
    std::map<std::string, int> iter(map1.find("anything"), map1.end());
    std::cout << "\niter = " << iter;
    std::cout << "map1 = " << map1;
 
    // (6) Copy constructor
    std::map<std::string, int> copied(map1);
    std::cout << "\ncopied = " << copied;
    std::cout << "map1 = " << map1;
 
    // (8) Move constructor
    std::map<std::string, int> moved{std::move(map1)};
    std::cout << "\nmoved = " << moved;
    std::cout << "map1 = " << map1;
 
    // (10) Initializer list constructor
    const std::map<std::string, int> init
    {
        {"this", 100},
        {"can", 100},
        {"be", 100},
        {"const", 100}
    };
    std::cout << "\ninit = " << init;
 
    std::cout << "\nCustom Key class option 1:\n";
    // Use a comparison struct
    std::map<Point, double, PointCmp> mag =
    {
        {{5, -12}, 13},
        {{3, 4}, 5},
        {{-8, -15}, 17}
    };
    std::cout << "mag = " << mag << '\n';
 
    std::cout << "Custom Key class option 2:\n";
    // Use a comparison lambda
    // This lambda sorts points according to their magnitudes, where
    // these magnitudes are taken from the local variable mag.
    auto cmpLambda = [&mag](const Point& lhs, const Point& rhs)
    {
        return mag[lhs] < mag[rhs];
    };
 
    // You could also use a lambda that is not dependent on local variables, like this:
    // auto cmpLambda = [](const Point& lhs, const Point& rhs){ return lhs.y < rhs.y; };
    std::map<Point, double, decltype(cmpLambda)> magy(cmpLambda);
 
    // Various ways of inserting elements:
    magy.insert(std::pair<Point, double>({5, -12}, 13));
    magy.insert({{3, 4}, 5});
    magy.insert({Point{-8.0, -15.0}, 17});    
    std::cout << "magy = " << magy << '\n';
 
    std::cout << "Construction from a range:\n";
    using PS = std::pair<const std::string, int>;
    const auto rg = {PS{"one", 1}, {"one", 101}, {"two", 2}, {"three", 3}};
#if __cpp_lib_containers_ranges
    std::map<std::string, int> nums(std::from_range, rg); // overload (12)
#else
    std::map<std::string, int> nums(rg.begin(), rg.end()); // fallback to (4)
#endif
    std::cout << "nums = " << nums << '\n';
}

Ausgabe

map1 = { 'anything' is 199, 'something' is 69, 'that thing' is 50 }
 
iter = { 'anything' is 199, 'something' is 69, 'that thing' is 50 }
map1 = { 'anything' is 199, 'something' is 69, 'that thing' is 50 }
 
copied = { 'anything' is 199, 'something' is 69, 'that thing' is 50 }
map1 = { 'anything' is 199, 'something' is 69, 'that thing' is 50 }
 
moved = { 'anything' is 199, 'something' is 69, 'that thing' is 50 }
map1 = { }
 
init = { 'be' is 100, 'can' is 100, 'const' is 100, 'this' is 100 }
 
Custom Key class option 1:
mag = { '(-8, -15)' is 17, '(3, 4)' is 5, '(5, -12)' is 13 }
 
Custom Key class option 2:
magy = { '(3, 4)' is 5, '(5, -12)' is 13, '(-8, -15)' is 17 }
 
Construction from a range:
nums = { 'one' is 1, 'three' is 3, 'two' is 2 }

[bearbeiten] Defect Reports

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 2076 C++11 Überladung (4) erfordert bedingt, dass `Key` und `T` in *this CopyInsertable sind nicht erforderlich.
LWG 2193 C++11 Der Standardkonstruktor war `explicit` Wurde nicht-`explicit` gemacht

[bearbeiten] Siehe auch

 weist dem Container Werte zu
(public member function) [edit]
Zugriff von "https://cppreference.de/mwiki/index.php?title=cpp/container/map/map&oldid=135939"