Pasar la propiedad del objeto en C++

Question

¿Cuál es la mejor manera de indicar que un objeto quiere tomar posesión de otro objeto? Hasta ahora, he estado usando un std::auto_ptr en la interfaz pública, por lo que el cliente sabe que la interfaz quiere tomar posesión del objeto pasado.

Sin embargo, el último GCC dice que auto_ptr está en desuso, entonces me pregunto qué se recomienda? boost::interprocess::unique_pointer parece un buen candidato, pero ¿es esta la mejor solución?

Answer 1

boost::interprocess es una biblioteca para la comunicación entre procesos, por lo que no la usaría para diferentes propósitos.

Como se discutió en este foro:

http://objectmix.com/c/113487-std-auto_ptr-deprecated.html

std::auto_ptr será declarado obsoleto en la próxima versión de la norma, donde se recomienda el uso de std::unique_ptr, que requiere referencias rvalue y mover la semántica de ser implementado (esa es una característica bastante complicada).

Hasta que se publique el nuevo estándar, simplemente trataría de deshabilitar la advertencia, si es posible, o ignorarla, para una máxima portabilidad.

Si desea cambiar al siguiente estándar de idioma, es posible ya que se han implementado las referencias de valores r (consulte http://russ.yanofsky.org/rref/), por lo que también debe ser compatible con std::unique_ptr.

Una de las ventajas de la nueva semántica es que puede pasar al constructor de movimiento también un valor temporal o cualquier valor r; en otros casos, esto permite evitar copiar (por ejemplo) objetos contenidos dentro de un std::vector (durante la reasignación) antes de destruir los originales.

Answer 2

std :: auto_ptr implementa pasa la propiedad de copia y asignación, por lo que no hay nada especial que debe hacer al respecto:

std::auto_ptr<T> p = somePtr; // not p owns object, referenced by somePtr 
std::auto_ptr<T> q = myObj.GetAutoPtr(); // not q owns object referenced by auto_ptr in myObj 

Pero que pasa la propiedad de objetos no es una buena práctica de diseño, se lleva a cabo a fugas y objetos relativos a errores relativos a la vida

Answer 3

No recuerdo que std :: auto_ptr esté en desuso.
¿Alguien tiene un enlace a la reunión de normas apropiada donde discuten esto?

Una rápida de Google encontraron esta: http://objectmix.com/c/113487-std-auto_ptr-deprecated.html

>> In fact the latest publicly available draft lists auto_ptr in appendix 
>> D, meaning that there is clear intent to formally deprecate it in the 
>> next revision of C++. A new class named unique_ptr is going to provide 
>> a replacement for auto_ptr, the main difference being that unique_ptr 
>> uses rvalue-references instead of voodoo magic to properly achieve 
>> move semantic. 
> 
> Is a reference implementation available? Is it too early to start using it? 
> 

In order to use unique_ptr you need first to have a compiler which 
properly supports rvalue references. These can be hard to find nowadays, 
as the feature has not yet been standardized, although the situation is 
quickly improving. For example GCC has very recently added the feature 
in v4.3 (http://gcc.gnu.org/gcc-4.3/cxx0x_status.html). If you are lucky 
enough to have one of those compilers, most probably they already ship a 
version of unique_ptr (it's a sort of benchmark for the feature, you 
know). In any case, you can find reference implementations on the 
internet by just googling unique_ptr. 

lo que parece que su son movimientos para despreciar auto_ptr a favor de unique_ptr (que tiene la misma semántica). Pero necesita un compilador que admita las nuevas características propuestas en la próxima versión de C++.

Pero todavía hay otra reunión y, por lo tanto, votar por venir para que las cosas cambien antes de que la norma se concrete.

Answer 4

std::unique_ptr es de hecho la nueva forma recomendada. Con los contenedores C++ 0x se activará el movimiento, lo que significa que pueden manejar tipos que se pueden mover correctamente (es decir, std::vector<std::auto_ptr<x> > no funciona, pero std::vector<std::unique_ptr<x>>).

Para boost, los contenedores ya admiten tipos móviles, donde boost::interprocess::unique_ptr es uno de ellos. Se asemejan a los tipos móviles en pre C++ 0x mediante el uso de algunos de la magia de la plantilla boost "normal", y usan referencias r-value donde son compatibles.

No sabía acerca de la depreciación dedicada auto_ptr, sin embargo, no he seguido de cerca el nuevo estándar de evolución.

(edición) La implementación de boost::interprocess::unique_ptr no es de hecho un smart-puntero "público" como boost::shared_ptr o boost::scoped_ptr, pero es (ver boost.interprocess's site) no sólo para la memoria compartida, pero también se puede utilizar para general- propósito.

Sin embargo, estoy bastante seguro de que si GCC deja de tener en cuenta la plantilla auto_ptr, ya proporcionan su propia implementación unique_ptr (no se usa mucho para desaprobar si aún no tiene una alternativa viable).

Sin embargo, todo se dice, si está trabajando en una plataforma C++ 0x, utilice unique_ptr, disponible en lib del compilador, si no, seguir con auto_ptr.

Answer 5

Acepto que siempre que sea posible, debe usar tipos en los que el compilador ayude a transferir la propiedad.

Cuando usted no tiene que la elección de los tipos de datos y está de paso punteros primas, que siguen las directrices de programación taligent de nombrar métodos que renunciar a la propiedad como orphanBlah y parámetros que tienen la propiedad como adoptBlah.