Namespaces
Variants

    std::basic_string<CharT,Traits,Allocator>::resize

    Von de.cppreference.net
     
    C++
     
    Zeichenkettenbibliothek
     
    std::basic_string
     
    void resize( size_type count );
    		(1) (constexpr seit C++20) 
    void resize( size_type count, CharT ch );
    		(2) (constexpr seit C++20)

    Ändert die Größe der Zeichenkette so, dass sie count Zeichen enthält.

    Wenn die aktuelle Größe kleiner als count ist, werden zusätzliche Zeichen angehängt:

    1) Initialisiert angehängte Zeichen mit CharT() ('\0', falls CharT gleich char ist).
    2) Initialisiert angehängte Zeichen mit ch.

    Wenn die aktuelle Größe größer als count ist, wird die Zeichenkette auf ihre ersten count Elemente reduziert.

    Parameter

    count - neue Größe des Strings
    ch - Zeichen zur Initialisierung der neuen Zeichen

    Exceptions

    std::length_error falls count > max_size ( ) true ist. Alle Ausnahmen, die von der entsprechenden Allocator -Implementierung geworfen werden.

    Wenn aus irgendeinem Grund eine Exception ausgelöst wird, hat diese Funktion keine Wirkung ( strong exception safety guarantee ).

    Beispiel

    Diesen Code ausführen 
    #include <iomanip>
#include <iostream>
#include <stdexcept>
int main()
{
    const unsigned desired_length{8};
    std::string long_string("Where is the end?");
    std::string short_string("H");
    std::cout << "Basic functionality:\n"
              << "Shorten:\n"
              << "1. Before: " << std::quoted(long_string) << '\n';
    long_string.resize(desired_length);
    std::cout << "2. After:  " << std::quoted(long_string) << '\n';
    std::cout << "Lengthen with a given value 'a':\n"
              << "3. Before: " << std::quoted(short_string) << '\n';
    short_string.resize(desired_length, 'a');
    std::cout << "4. After:  " << std::quoted(short_string) << '\n';
    std::cout << "Lengthen with char() == " << static_cast<int>(char()) << '\n'
              << "5. Before: " << std::quoted(short_string) << '\n';
    short_string.resize(desired_length + 3);
    std::cout << "6. After:  \"";
    for (char c : short_string)
        std::cout << (c == char() ? '@' : c);
    std::cout << "\"\n\n";
    std::cout << "Errors:\n";
    std::string s;
    try
    {
        // size is OK, no length_error
        // (may throw bad_alloc)
        s.resize(s.max_size() - 1, 'x');
    }
    catch (const std::bad_alloc& ex)
    {
        std::cout << "1. Exception: " << ex.what() << '\n';
    }
    try
    {
        // size is OK, no length_error
        // (may throw bad_alloc)
        s.resize(s.max_size(), 'x');
    }
    catch (const std::bad_alloc& ex)
    {
        std::cout << "2. Exception: " << ex.what() << '\n';
    }
    try
    {
        // size is BAD, throw length_error
        s.resize(s.max_size() + 1, 'x');
    }
    catch (const std::length_error& ex)
    {
        std::cout << "3. Length error: " << ex.what() << '\n';
    }
}

    Mögliche Ausgabe: 

    Basic functionality:
Shorten:
1. Before: "Where is the end?"
2. After:  "Where is"
Lengthen with a given value 'a':
3. Before: "H"
4. After:  "Haaaaaaa"
Lengthen with char() == 0
5. Before: "Haaaaaaa"
6. After:  "Haaaaaaa@@@"
Errors:
1. Exception: std::bad_alloc
2. Exception: std::bad_alloc
3. Length error: basic_string::_M_replace_aux

    Fehlerberichte

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

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 847 C++98 es gab keine Exception-Sicherheitsgarantie starke Exception-Sicherheitsgarantie hinzugefügt
    LWG 2250 C++98 das Verhalten war undefiniert wenn
    count > max_size ( ) ist true     		wirft in diesem Fall immer eine Exception

    Siehe auch

    		gibt die Anzahl der Zeichen zurück
    (öffentliche Elementfunktion)
    		reserviert Speicher
    (öffentliche Elementfunktion)
    ( DR* )
    		reduziert die Speichernutzung durch Freigabe ungenutzten Speichers
    (öffentliche Elementfunktion)