std::basic_string<CharT,Traits,Allocator>::resize (3) - Linux Man Pages

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

NAME

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

Synopsis


void resize( size_type count ); (1)
void resize( size_type count, CharT ch ); (2)


Resizes the string to contain count characters.
If the current size is less than count, additional characters are appended.
If the current size is greater than count, the string is reduced to its first count elements.
The first version initializes new characters to CharT(), the second version initializes new characters to ch.

Parameters


count - new size of the string
ch - character to initialize the new characters with

Return value


(none)

Exceptions


std::length_error if count > max_size(). Any exceptions thrown by corresponding Allocator.


If an exception is thrown for any reason, this function has no effect (strong exception guarantee).
(since C++11)

Example


// Run this code


  #include <iostream>
  #include <stdexcept>


  int main()
  {
      std::cout << "Basic functionality:\n";
      const unsigned desired_length(8);
      std::string long_string( "Where is the end?" );
      std::string short_string( "Ha" );


      // Shorten
      std::cout << "Before: \"" << long_string << "\"\n";
      long_string.resize( desired_length );
      std::cout << "After: \"" << long_string << "\"\n";


      // Lengthen
      std::cout << "Before: \"" << short_string << "\"\n";
      short_string.resize( desired_length, 'a' );
      std::cout << "After: \"" << short_string << "\"\n";


      std::cout << "\nErrors:\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&) {
              std::cout << "1. bad alloc\n";
          }


          try {
              // size is OK, no length_error
              // (may throw bad_alloc)
              s.resize(s.max_size(), 'x');
          } catch (const std::bad_alloc& exc) {
              std::cout << "2. bad alloc\n";
          }


          try {
              // size is BAD, throw length_error
              s.resize(s.max_size() + 1, 'x');
          } catch (const std::length_error&) {
              std::cout << "3. length error\n";
          }
       }
  }

Possible output:


  Basic functionality:
  Before: "Where is the end?"
  After: "Where is"
  Before: "Ha"
  After: "Haaaaaaa"


  Errors:
  1. bad alloc
  2. bad alloc
  3. length error

Complexity


Linear in the size of the string.

See also


       returns the number of characters
size (public member function)
length