operator<<,>>(std::basic_string)

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de cadenas

Cadenas terminadas en nulo

Cadenas de bytes

Cadenas multibyte

De caracteres anchos

Clases

basic_string

basic_string_view (C++17)

char_traits

 

std::basic_string

Funciones miembro basic_string::basic_string basic_string::operator= basic_string::assign basic_string::get_allocator Acceso a elementos basic_string::at basic_string::operator[] basic_string::front (C++11) basic_string::back (C++11) basic_string::data basic_string::c_str basic_string::operator basic_string_view (C++17) Iteradores basic_string::beginbasic_string::cbegin (C++11) basic_string::endbasic_string::cend (C++11) basic_string::rbeginbasic_string::crbegin (C++11) basic_string::rendbasic_string::crend (C++11) Capacidad basic_string::empty basic_string::sizebasic_string::length basic_string::max_size basic_string::reserve basic_string::capacity basic_string::shrink_to_fit (C++11)

Operaciones basic_string::clear basic_string::insert basic_string::erase basic_string::push_back basic_string::pop_back (C++11) basic_string::append basic_string::operator+= basic_string::compare basic_string::starts_with (C++20) basic_string::ends_with (C++20) basic_string::replace basic_string::substr basic_string::copy basic_string::resize basic_string::swap Búsqueda basic_string::find basic_string::rfind basic_string::find_first_of basic_string::find_first_not_of basic_string::find_last_of basic_string::find_last_not_of Constantes basic_string::npos

Funciones no miembro operator+ swap(std::basic_string) operator""s (C++14) erase(std::basic_string)erase_if(std::basic_string) (C++20)(C++20) E/S operator<<operator>> getline Comparación operator==operator!=operator<operator>operator<=operator>=operator<=> (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(C++20) Conversión numérica (C++11) stoistolstoll stoulstoull stofstodstold to_string to_wstring Clases auxiliares hash<std::string>hash<std::wstring>hash<std::u32string>hash<std::u16string>hash<std::u8string> (C++11)(C++11)(C++11)(C++11)(C++20) hash<std::pmr::string>hash<std::pmr::wstring>hash<std::pmr::u32string>hash<std::pmr::u16string>hash<std::pmr::u8string> (C++20)(C++20)(C++20)(C++20)(C++20) Guías de deducción(C++17)

 

<tbody> </tbody>

Definido en el archivo de encabezado <string>
template <class CharT, class Traits, class Allocator> std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const std::basic_string<CharT, Traits, Allocator>& str);	(1)
template <class CharT, class Traits, class Allocator> std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is, std::basic_string<CharT, Traits, Allocator>& str);	(2)

See More

1) Se comporta como una función de salida formateada, FormattedOutputFunction. Después de construir y comprobar el objeto centinela, determina el relleno del formato de salida de la siguiente manera:

a) si str.size() no es menor que os.width(), usa el rango [str.begin(), str.end()) tal y como es;

b) de lo contrario, si (os.flags() & ios_base::adjustfield) == ios_base::left, ubica os.width()-str.size() copias del carácter os.fill() después de la secuencia de caracteres;

c) de lo contrario, ubica os.width()-str.size() copias del carácter os.fill() antes de la secuencia de caracteres.

Luego almacena cada carácter de la secuencia resultante (el contenido de str más el relleno) al flujo de salida os, como si se llamara a os.rdbuf()->sputn(seq, n), donde n=std::max(os.width(), str.size()).

Finalmente, llama a os.width(0) para cancelar los efectos de std::setw, si es que los hubo.

2) Se comporta como una función de entrada formateada, FormattedOutputFunction. Después de construir y comprobar el objeto centinela, que puede saltarse espacios en blanco a la cabeza, primero borra str con str.erase(), luego lee caracteres de is y los añade a str como si fuera mediante str.append(1, c), hasta que una de las siguientes condiciones se vuelve verdadera:

• se leen N caracteres, donde N es is.width() si is.width() > 0, de lo contrario, N es str.max_size();
• ocurre la condición de fin de archivo en el flujo is;
• std::isspace(c,is.getloc()) es verdadero para el próximo carácter c en is (este carácter de espacio en blanco permanece en el flujo de entrada).

Si no se extraen caracteres, entonces std::ios::failbit se establece en is, que puede lanzar std::ios_base::failure.

Finalmente, llama a is.width(0) para cancelar los efectos de std::setw, si es que los hubo.

Excepciones

1) Puede lanzar std::ios_base::failure si se lanzó una excepción durante la salida.

2) Puede lanzar std::ios_base::failure si no se extrajeron caracteres de is (p. ej., el flujo se encuentra al final del archivo, o consiste de espacios en blanco solamente), o si se lanza una excepción durante la entrada.

Parámetros

os	-	Un flujo de salida de caracteres.
is	-	Un flujo de entrada de caracteres.
str	-	La cadena a insertarse o extraerse.

Valor de retorno

1) os

2) is

Ejemplo

Ejecuta este código

#include <iostream>
#include <string>
#include <sstream>
 
int main()
{
    std::string saludo = "Hola, crayola!";
    std::istringstream is(saludo);

    std::string hola_coma;
    std::string crayola;

    is >> hola_coma;
    is >> crayola;

    std::cout << saludo << '\n';
    std::cout << hola_coma << '\n' << crayola << '\n';
}

Salida:

Hola, crayola!
Hola,
crayola!