2011-02-08 8 views

Respuesta

57

Ocasionalmente son útiles. El proyecto de C++ 0x sí los utiliza en algunos lugares, por ejemplo:

template <class T> void ref(const T&&) = delete; 
template <class T> void cref(const T&&) = delete; 

Los dos sobrecargas superiores a asegurar que las demás ref(T&) y cref(const T&) funciones no se unen a rvalues ​​(que de otro modo sería posible).

actualización

he acaba de comprobar la norma oficial N3290, que por desgracia no está disponible al público, y tiene en objetos 20.8 Función [function.objects]/p2:

template <class T> void ref(const T&&) = delete; 
template <class T> void cref(const T&&) = delete; 

Luego revisé el borrador más reciente posterior a C++ 11, que está disponible públicamente, N3485, y en 20.8 Objetos de función [función.objetos]/p2 aún dice:

template <class T> void ref(const T&&) = delete; 
template <class T> void cref(const T&&) = delete; 
+0

Al mirar [cppreference] (http://en.cppreference.com/w/cpp/utility/functional/ref) parece que ya no es el caso. ¿Alguna idea de por qué? ¿Se usa cualquier otro lugar 'const T &&'? – Pubby

+0

En realidad, cppreference podría no mostrar las funciones eliminadas. No he comprobado el estándar. – Pubby

+0

@Pubby cppreference ciertamente muestra las funciones eliminadas, esas fueron omitidas por error. – Cubbi

2

Son permitidas e incluso las funciones clasificadas basadas en const, pero como no se puede mover desde el objeto const referido por const Foo&&, no son útiles.

+0

¿Qué quiere decir exactamente con el comentario "clasificado"? ¿Algo relacionado con la resolución de sobrecarga, supongo? – fredoverflow

+0

¿Por qué no se podía mover de una const rvalue-ref, si el tipo dado tiene un cursor de movimiento que toma una const rvalue-ref? –

+3

@FredOverflow, el ranking de sobrecarga es el siguiente: 'const T &, T &, const T &&, T &&' –

1

No puedo pensar en una situación en la que esto sería útil directamente, sino que podrían ser utilizados indirectamente:

template<class T> 
void f(T const &x) { 
    cout << "lvalue"; 
} 
template<class T> 
void f(T &&x) { 
    cout << "rvalue"; 
} 

template<class T> 
void g(T &x) { 
    f(T()); 
} 

template<class T> 
void h(T const &x) { 
    g(x); 
} 

La T en g es T constante, así f 'SX es una T const & &.

Es probable que esto se traduce en un error de comilla en f (cuando se trata de mover o usar el objeto), pero f podría tener un valor p-ref modo que no se puede llamar en lvalues, sin modificar el valor r (como en el ejemplo demasiado simple anterior).

Cuestiones relacionadas