pregunta acerca del uso de string :: intercambio() con los temporales

Question

El siguiente segmento demuestra mi problema: (error de compilación en GCC)

stringstream ss; 
string s; 
ss << "Hello"; 

// This fails: 
// s.swap(ss.str()); 

// This works: 
ss.str().swap(s); 

Mi error:

constSwap.cc:14: error: no matching function for call to 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::swap(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)' 
basic_string.tcc:496: note: candidates are: void std::basic_string<_CharT, _Traits, _Alloc>::swap(std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>] 

Si bien entiendo que str () en stringstream devuelve un temporal, no tiene sentido y no fue inmediatamente evidente que debería haber estado llamando el intercambio en el temporal con la variable local como parámetro en lugar de mi primer instinto.

Obviamente, la asignación directa funciona mejor, y los estándares más nuevos de C++ tienen una semántica de movimiento que es perfecta, pero estos no están disponibles para mi implementación.

Visual Studio no proporciona este problema debido a que se relaja con respecto al estándar de C++. Ya entiendo un poco la referencia completa de una cosa temporal (que supongo que es la razón de mis errores de compilación).

Mi pregunta es: ¿Alguien me puede explicar si esta es la única solución, y tal vez me explique cómo pensar en esto en el futuro para poder detectar y solucionar problemas similares?

(Si nadie tiene ningún grandes ideas que estoy al menos publicar esto aquí para las personas con problemas similares)

Answer 1

Después de haber utilizado el canje-con-temporales modismo suficientes veces, con líneas como

std::vector<int>().swap(v); // clear and minimize capacity 

o

std::vector<int>(v).swap(v); // shrink to fit 

esto no parece tan fuera de lugar. Es normal para llamar a swap como una función miembro de un objeto temporal. Por supuesto, no es tan idiomático usar swap para completar una cadena construida por defecto en lugar de usar un constructor de copia, como ya se mencionó.

Answer 2

No se puede obligar a un temporal a una referencia no const. Por esta razón, el temporal devuelto desde ss.str() no se puede pasar al std::string::swap que espera modificar su parámetro (por lo tanto, toma su argumento usando non-const&).

La segunda versión funciona como está llamando a una función miembro en el objeto temporal que está permitido.

¿Pero por qué quieres cambiar en primer lugar? Normalmente, un simple:

std::string s(ss.str()); 

debería ser lo suficientemente bueno. Esto no es menos eficiente que el intercambio (al menos en C++ 0x con semántica de movimiento), pero al mismo tiempo es mucho más legible.

Answer 3

El motivo por el que no se puede pasar el argumento temporal como swap es que el argumento se pasa por referencia no constante. Y los temporales solo pueden estar limitados por const-references. Esto se extiende sobre §8.5.3, con el ser apropiada en el párrafo 5, segundo punto:

§8.5.3 A reference to type “cv1 T1” is initialized by an expression of type “cv2 T2” as follows:

• [bullet one, does not apply here: binding to non-const ref ]

• Otherwise, the reference shall be to a non-volatile const type (i.e., cv1 shall be const).

La razón por la escritura de la llamada en la dirección opuesta funciona es que la norma permite llamar a mutar funciones miembro de temporal objetos.

§3.10/10 An lvalue for an object is necessary in order to modify the object except that an rvalue of class type can also be used to modify its referent under certain circumstances. [Example: a member function called for an object (9.3) can modify the object. ]

La línea de razonamiento que se solicita para el futuro es que, mientras que se puede modificar un temporal a través de él de las propias funciones, no se puede pasar a una función o un método que podría modificarlo (pasan por no constante referencia)