Namespaces
Variants

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

From cppreference.net
C++
Strings library
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, um count Zeichen zu enthalten.

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 vom Typ char ist).
2) Initialisiert angehängte Zeichen mit ch .

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

Inhaltsverzeichnis

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)