Reemplazando auto_ptr en VC++ 8

Question

std::auto_ptr está roto en VC++ 8 (que es lo que usamos en el trabajo). Mi principal queja es que permite auto_ptr<T> x = new T();, lo que por supuesto conduce a accidentes horribles, mientras que es fácil de hacer por error.

Desde un answer a otra pregunta aquí en stackoverflow:

Nota que la aplicación de std :: auto_ptr en Visual Studio 2005 es terriblemente roto. http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=98871 http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=101842

Quiero usar

• boost::scoped_ptr, para los punteros que no debe pasar la propiedad.
• boost::shared_ptr, para punteros en contenedores y en otros lugares donde se necesiten.
• std::auto_ptr, para punteros que deben/pueden pasar la propiedad.

Pero desde std::auto_ptr se rompe para mí, me pregunto cuál sería el mejor enfoque:

• Reemplazar std::auto_ptr con algo de la red. Me gusta esto this uno de Rani Sharoni (no lo he probado todavía).
• Use boost::shared_ptr en su lugar. Por supuesto, funcionará, aunque habrá algunos gastos menores que no me importan. Pero quiero usar auto_ptr para señalar la intención del puntero. (Consulte this respuesta para una votación sobre este enfoque.)
• Nunca tendré que pasar la propiedad en la práctica, así que no debería preocuparme por esto.

---

Actualización: Esto es lo que hice: copié la implementación auto_ptr citada por Rani Sharoni. From here.

hizo algunas pruebas menores:

class T 
{ 
public: 
    T() { 
     OutputDebugStringA("T\n"); 
    }; 
    ~T() { 
     OutputDebugStringA("~T\n"); 
    }; 
}; 

{ 
    fix::auto_ptr<T> x(new T); // This just works. 
} 
{ 
    fix::auto_ptr<T> x = (new T); // Doesn't compile. Great! 
} 
{ 
    fix::auto_ptr<T> x = fix::auto_ptr<T>(new T); // Transfer of ownership works also. 
} 

Por supuesto, estas pruebas son de ninguna manera exhaustiva y no se debe confiar en ellos. Implementar una clase de plantilla segura de excepción es un asunto peliagudo. Al menos esto funciona mejor que el construido en uno.

Nota: No sé si todavía puedo utilizar esta implementación, con respecto a los derechos de autor. He enviado un correo electrónico a Rani y estoy esperando una respuesta. Actualizaré esta publicación cuando sepa más. Se otorga permiso para que todos puedan usar la implementación auto_ptr de Rani Sharoni como lo deseen.

Gracias por todas sus respuestas.

Answer 1

movimiento para impulsar punteros inteligentes.

Mientras tanto, es posible que desee extraer una implementación auto_ptr que funcione de una STL anterior/otra, por lo que tiene un código de trabajo.

Creo que la semántica de auto_ptr está fundamentalmente rota: ahorra tipeo, pero la interfaz en realidad no es más simple: todavía tiene que rastrear qué instancia es el propietario actual y asegurarse de que el propietario se va.

unique-ptr "corrige" que, al realizar la liberación, no solo renuncia a la propiedad, sino que también establece el RHS como nulo. Es el reemplazo más cercano para auto-ptr, pero con su semántica diferente no es un reemplazo directo.

Hay un artículo introductorio al boost smart pointers, por, ejem, yo.

Answer 2

Utilice boost :: shared_ptr/boost :: scoped_ptr. Será el puntero inteligente preferido en los próximos estándares C++ (ya está en TR1).

Editar: por favor, encontrar una discusión relacionada aquí: Idiomatic use of std::auto_ptr or only use shared_ptr?

Answer 3

¿Por qué cree std :: auto_ptr <> se rompe.

¡Hubiera pensado que algo tan malo como eso habría sido informado al comité de normas!

¿Quiere decir que usted necesita:

std::auto_ptr<T> x(new T); // Use the explicit constructor. 

Answer 4

¿Ha considerado el uso de STLPort?

Answer 5

Utilice un unique_ptr. Creo que estos fueron introducidos para ser un mejor auto_ptr.

http://www.boost.org/doc/libs/1_35_0/doc/html/interprocess/interprocess_smart_ptr.html#interprocess.interprocess_smart_ptr.unique_ptr

De hecho, tengo entendido que auto_ptr puede estar desfasada y en que:

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

Answer 6

Por lo que yo recuerdo, no era eso:

auto_ptr<T> x = auto_ptr<T>(new T()); ?? 

Answer 7

No es una respuesta, pero para el interés general de las personas para quienes estos errores son relevantes. Hay one more related bug con VC8 auto_ptr, que tiene que ver con las transmisiones implícitas. Es probablemente el más malo del grupo, porque otros errores solo te permiten compilar código que de otra manera sería ilegal según Standard sin fallar, pero al menos el código compatible funciona bien. Con este error, el código que es realmente compatible no funciona correctamente.

El problema es esto. Standard especifica los constructores auto_ptr y los operadores de conversión de tal manera que admiten upcasting implícito de auto_ptr s, al igual que con los punteros normales. Sin embargo, la implementación VC8 de eso hace un reinterpret_cast en lugar de un static_cast allí. Naturalmente, no solo esto es U.B. por la letra del estándar, pero también se rompe con múltiples clases base y/o herencia virtual. Aquí está un ejemplo de código legal roto por esto:

struct Base1 { int x; }; 
struct Base2 { int y; }; 
struct Derived : Base1, Base2 {}; 

std::auto_ptr<Derived> createDerived() 
{ 
    return std::auto_ptr<Derived>(new Derived); 
} 

std::auto_ptr<Base2> base2(createDerived()); 

En uno de mis últimos trabajos, cuando nos encontramos con este problema en la producción, terminamos simplemente remendar las cabeceras de nosotros mismos (que es una solución de 2 líneas trivial) .