c++ - library - stringstream s

restablecer un stringstream

Question

¿Cómo "restablezco" el estado de un stringstream a lo que era cuando lo creé?

int firstValue = 1;
int secondValue = 2;

std::wstringstream ss;

ss << "Hello: " << firstValue;

std::wstring firstText(ss.str());

//print the value of firstText here


//How do I "reset" the stringstream here?
//I would like it behave as if I had created
// stringstream ss2 and used it below.


ss << "Bye: " << secondValue;

std::wstring secondText(ss.str());

//print the value of secondText here

Answer 1

Esta es la forma en que generalmente lo hago:

ss.str("");
ss.clear(); // Clear state flags.

Answer 2

Sobre la base de la respuesta anterior, también debemos restablecer cualquier formato. En total, estamos restableciendo el contenido del búfer, los indicadores de estado de la ruta y cualquier formato a sus valores predeterminados cuando se construye una nueva instancia std :: stringstream.

void reset(std::strinstream& stream)
{
    const static std::stringstream initial;

    stream.str(std::string());
    stream.clear();
    stream.copyfmt(initial);
}

Answer 3

yo lo haría

std::wstringstream temp;
ss.swap(temp);

Editar: solucionó el error informado por christianparpart y Nemo. Gracias.

PD: El código anterior crea un nuevo objeto de secuencia de cadenas en la pila y cambia todo en ss con los del nuevo objeto.

Ventajas:

1. Garantiza que ss ahora estará en un nuevo estado.
2. El nuevo objeto se crea en línea y en la pila, de modo que el compilador puede optimizar fácilmente el código. Al final, será como restablecer todos los datos internos ss al estado inicial.

Más:

1. Comparado con el operador de asignación: los métodos de intercambio de STL pueden ser más rápidos que el operador de asignación en los casos en que el nuevo objeto tiene un almacenamiento intermedio asignado en el almacenamiento dinámico. En tal caso, el operador de asignación debe asignar el búfer para el nuevo objeto, luego PUEDE necesitar asignar otro búfer para el objeto anterior, y luego copiar los datos del búfer del nuevo objeto al nuevo búfer del objeto viejo. Es muy fácil implementar un intercambio rápido, que simplemente intercambia punteros de los búferes, por ejemplo.

2. C ++ 11. He visto alguna implementación del operador de asignación de movimiento que es más lenta que el intercambio, aunque eso puede ser reparado, pero probablemente el desarrollador de STL no quiera dejar un objeto movido con una gran cantidad de datos

3. std::move() no garantiza que el objeto movido se haya vaciado. return std::move(m_container); no borra m_container. Entonces deberás hacer

   auto to_return (std :: move (m_container)); m_container.clear (); regresar a_return;

Que no puede ser mejor que

auto to_return;
m_container.swap(to_return);
return to_return;

porque este último garantiza que no copiará los búferes.

Por lo tanto, siempre prefiero el swap() siempre que se ajuste.