rvalue-reference
¿La regla de Tres se convierte en Regla de Cinco con C++11?
Así que, después de ver esta maravillosa conferencia {[4] } sobre referencias rvalue, pensé que cada clase se beneficiaría de ... be tener un copy-ctor, operador de asignación y destructor si los puntos mencionados anteriormente se aplican.
¿Pensamientos?
¿Es más eficiente devolver por referencia rvalue?
Por ejemplo:
Beta_ab&&
Beta::toAB() const {
return move(Beta_ab(1, 1));
}
¿Por qué ' std::move` se llama `std:: move`?
La función C++11 std::move(x) no mueve nada en absoluto. Es solo un molde a r-valor. ¿Por qué se hizo esto? ¿No es engañoso?
¿Hay algún caso en el que sea útil devolver una referencia RValue ( & & )?
¿Hay alguna razón por la que una función debería devolver una referencia RValue? ¿Una técnica, un truco, un modismo o un pa ... cer eso? Probablemente diferente cuando se escribe código de biblioteca o API, en comparación con solo el código del cliente?
¿Las referencias rvalue a const tienen algún uso?
Supongo que no, pero me gustaría confirmarlo. ¿Hay algún uso para const Foo&&, donde Foo es un tipo de clase?
¿Puedo usar normalmente / siempre std:: forward en lugar de std:: move?
He estado viendo la charla de Scott Meyers sobre Referencias Universales de la conferencia de C++ y más allá de 2012, y tod ... ::move:
void doWork(Widget&& param) // move
{
// ops and exprs using std::forward<Widget>(param)
}
Resolución de sobrecarga entre objeto, referencia rvalue, referencia const
Dadas las tres funciones, esta llamada es ambigua.
int f( int );
int f( int && );
int f( int const & );
int q = ... o T const & y T &&, y copiar explícitamente. Pero ni siquiera estoy seguro de que eso sea estrictamente estándar.
¿Por qué algunas personas usan el intercambio para las asignaciones de movimiento?
Por ejemplo, stdlibc++ tiene lo siguiente:
unique_lock& operator=(unique_lock&& __u)
{
if(_M_owns)
... stá haciendo un trabajo innecesario. ¿Qué me estoy perdiendo?
(el unique_lock::swap solo hace un std::swap en cada miembro)
Uso de los miembros de referencia rvalue?
Me preguntaba qué uso tiene un miembro de referencia rvalue
class A {
// ...
// Is this one useful?
Foo &&f;
} ... n beneficio o inconveniente en comparación con un miembro de referencia lvalue? ¿Qué es un caso de uso principal de la misma?
¿Por qué move-constructor definido por el usuario deshabilita el copy-constructor implícito?
Mientras estoy leyendo boost/shared_ptr.hpp, vi este código:
// generated copy constructor, destructor are fine...
#if def ... move disabls the implicit copy"? ¿Siempre debemos escribir el copy ctor nosotros mismos para evitar esta situación en C++11?
los rvalues no-clase siempre tienen tipos cv-unqualified
§3.10 la sección 9 dice "los rvalues no-clase siempre tienen tipos cv-no calificados". Eso me hizo preguntarme...
int foo()
... n un valor constante:)
EDITAR: Este problema parece haberse solucionado en g++ 4.5.0, ambas líneas imprimen "rvalue" ahora.
¿Debe un constructor de movimiento tomar una referencia rvalue const o no const?
En varios lugares he visto las firmas recomendadas de constructores de copia y movimiento dadas como:
struct T
{
T();
... lue const o no const? Y segundo: ¿tengo razón en esta línea de razonamiento? Que debería parar volviendo cosas que son const?
Reenvío de valores devueltos. ¿Es necesario std:: forward?
Estoy escribiendo biblioteca que envuelve una gran cantidad de funciones y métodos de otra biblioteca. Para evitar hacer fre ... ento de UB en:
auto&& tmp = wrapper(42);
No prueba nada de causa porque es comportamiento indefinido (si es UB).
C++11 rvalue reference calling copy constructor too
He estado probando algunas características de C++11 de some some.
Me encontré con referencias de valor r y constructores de m ... código, todo el el programa se vuelve mucho más rápido, y esta vez el constructor move se llama 1024287 veces.
Alguna pista?
¿Por qué la sobrecarga rvalue de `operator<<` para `basic ostream` devuelve una referencia lvalue?
§27.7.3.9 define la siguiente sobrecarga para operator<<:
template <class charT, class traits, class T>
basic ... n preguntar aquí:
¿Hay alguna buena razón por la que la sobrecarga mencionada anteriormente devuelve una referencia lvalue?
¿Para qué son "rvalue references for * this"?
¿Cuáles son los casos de uso más típicos de "rvalue references for *this" que el estándar también llama calificadores de referencia para funciones miembro?
Por cierto, hay una muy buena explicación sobre esta característica del lenguaje aquí.
Pasar rvalues a través de std:: bind
Quiero pasar un rvalue a través de std::bind a una función que toma una referencia rvalue en C++0x. Por ejemplo:
#include ...
{
auto f = std::bind(foo<Movable>, Movable());
f(); // error, but want the same effect as foo(Movable())
}