std::forward_list<T,Allocator>::resize

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::forward_list

Memberfunktionen
forward_list::forward_list forward_list::~forward_list forward_list::operator= forward_list::assign forward_list::assign_range (C++23)   forward_list::get_allocator Elementzugriff forward_list::front Iteratoren forward_list::before_beginforward_list::cbefore_begin forward_list::beginforward_list::cbegin forward_list::endforward_list::cend Kapazität forward_list::empty forward_list::max_size	Modifizierer forward_list::clear forward_list::emplace_front forward_list::push_front forward_list::insert_after forward_list::emplace_after forward_list::erase_after forward_list::insert_range_after (C++23) forward_list::prepend_range (C++23) forward_list::pop_front forward_list::resize forward_list::swap Operationen forward_list::merge forward_list::splice_after forward_list::removeforward_list::remove_if forward_list::reverse forward_list::unique forward_list::sort
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::forward_list) erase(std::forward_list)erase_if(std::forward_list) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Deduction guides (C++17)

 

void resize( size_type count );	(1)	(seit C++11)
void resize( size_type count, const value_type& value );	(2)	(seit C++11)

Ordnet die Containergröße auf count Elemente neu zu. Wenn count == std::distance(begin(), end()) (d. h. wenn count der aktuellen Größe entspricht), wird nichts unternommen.

Wenn die aktuelle Größe größer als count ist, wird der Container auf seine ersten count Elemente reduziert.

Wenn die aktuelle Größe kleiner als count ist, dann

1) Werden zusätzliche standardmäßig eingefügte Elemente angehängt.

2) Werden zusätzliche Kopien von value angehängt.

Parameter

zählt	-	neue Größe des Containers
value	-	der Wert, mit dem die neuen Elemente initialisiert werden sollen
Typanforderungen
- T muss die Anforderungen von DefaultInsertable erfüllen, um Überladung (1) verwenden zu können.
- T muss die Anforderungen von CopyInsertable erfüllen, um Überladung (2) verwenden zu können.

Komplexität

Linear in der Differenz zwischen der aktuellen Größe und count. Zusätzliche Komplexität kann durch Listen-Traversal entstehen, um das erste zu löschende Element bzw. die Einfügeposition zu erreichen.

Anmerkungen

Wenn die Wertinitialisierung in Überladung (1) unerwünscht ist, zum Beispiel, wenn die Elemente von einem nicht-Klassen-Typ sind und kein Nullsetzen benötigt wird, kann dies durch die Bereitstellung eines benutzerdefinierten Allocator::construct vermieden werden.

Beispiel

Führen Sie diesen Code aus

#include <forward_list>
#include <iostream>
 
void print(auto rem, const std::forward_list<int>& c)
{
    for (std::cout << rem; const int el : c)
        std::cout << el << ' ';
    std::cout << '\n';
}
 
int main()
{
    std::forward_list<int> c = {1, 2, 3};
    print("The forward_list holds: ", c);
 
    c.resize(5);
    print("After resize up to 5: ", c);
 
    c.resize(2);
    print("After resize down to 2: ", c);
 
    c.resize(6, 4);
    print("After resize up to 6 (initializer = 4): ", c);
}

Ausgabe

The forward_list holds: 1 2 3
After resize up to 5: 1 2 3 0 0
After resize down to 2: 1 2
After resize up to 6 (initializer = 4): 1 2 4 4 4 4

Siehe auch

max_size	Gibt die maximal mögliche Anzahl von Elementen zurück (public member function)
empty	prüft, ob der Container leer ist (public member function)