¿Qué tipo de puntero uso y cuándo?

Ok, la última vez que escribí C++ para ganarme la vida, std::auto_ptrera todo lo que tenía disponible la biblioteca estándar y boost::shared_ptrestaba de moda. Realmente nunca investigué el aumento de otros tipos de punteros inteligentes proporcionados. Entiendo que C++ 11 ahora proporciona algunos de los tipos que se le ocurrieron, pero no todos.

Entonces, ¿alguien tiene un algoritmo simple para determinar cuándo usar qué puntero inteligente? Preferiblemente incluir consejos sobre punteros tontos (punteros sin formato como T*) y el resto de punteros inteligentes de impulso. (Algo como esto sería genial).

Jan 03 '12 05:01 sbi

Decidir qué puntero inteligente utilizar es una cuestión de propiedad . Cuando se trata de gestión de recursos, el objeto A es propietario del objeto B si tiene el control de la vida útil del objeto B. Por ejemplo, las variables miembro son propiedad de sus respectivos objetos porque la vida útil de las variables miembro está ligada a la vida útil del objeto. Usted elige punteros inteligentes según la propiedad del objeto.

Tenga en cuenta que la propiedad en un sistema de software está separada de la propiedad, ya que la consideraríamos fuera del software. Por ejemplo, una persona puede ser "dueña" de su casa, pero eso no significa necesariamente que un Personobjeto tenga control sobre la vida útil de un Houseobjeto. Combinar estos conceptos del mundo real con conceptos de software es una forma segura de programarse en un agujero.

Si tienes la propiedad exclusiva del objeto, utiliza std::unique_ptr<T>.

Si tiene propiedad compartida del objeto...
- Si no hay ciclos de propiedad, use std::shared_ptr<T>.
- Si hay ciclos, definir una "dirección" y utilizar std::shared_ptr<T>en un sentido y std::weak_ptr<T>en el otro.

Si el objeto es de su propiedad, pero existe la posibilidad de que no tenga propietario, utilice punteros normales T*(por ejemplo, punteros principales).

Si el objeto es de su propiedad (o tiene existencia garantizada), utilice referencias T&.

Advertencia: tenga en cuenta los costos de los punteros inteligentes. En entornos con memoria o rendimiento limitado, podría resultar beneficioso utilizar simplemente punteros normales con un esquema más manual para gestionar la memoria.

Los costos:

• Si tiene un eliminador personalizado (por ejemplo, utiliza grupos de asignación), esto generará una sobrecarga por puntero que puede evitarse fácilmente mediante la eliminación manual.
• std::shared_ptrtiene la sobrecarga de un incremento del recuento de referencias en la copia, más una disminución en la destrucción seguida de una verificación de recuento 0 con eliminación del objeto retenido. Dependiendo de la implementación, esto puede inflar su código y causar problemas de rendimiento.
• Tiempo de compilación. Como ocurre con todas las plantillas, los punteros inteligentes contribuyen negativamente a los tiempos de compilación.

Ejemplos:

struct BinaryTree
{
    Tree* m_parent;
    std::unique_ptr<BinaryTree> m_children[2]; // or use std::array...
};

Un árbol binario no posee su padre, pero la existencia de un árbol implica la existencia de su padre (o nullptrraíz), por lo que utiliza un puntero normal. Un árbol binario (con semántica de valores) tiene propiedad exclusiva de sus hijos, por lo que esos son std::unique_ptr.

struct ListNode
{
    std::shared_ptr<ListNode> m_next;
    std::weak_ptr<ListNode> m_prev;
};

Aquí, el nodo de lista posee sus listas siguiente y anterior, por lo que definimos una dirección y usamos shared_ptrfor next y weak_ptrprev para romper el ciclo.

Jan 02 '2012 23:01 Peter Alexander

Úselo unique_ptr<T>todo el tiempo excepto cuando necesite un recuento de referencias, en cuyo caso úselo shared_ptr<T>(y en casos muy raros, weak_ptr<T>para evitar ciclos de referencia). En casi todos los casos, la propiedad única transferible está bien.

Punteros sin procesar: buenos solo si necesita rendimientos covariantes, lo cual puede suceder. De lo contrario, no son tremendamente útiles.

Punteros de matriz: unique_ptrtiene una especialización para T[]la cual invoca automáticamente delete[]el resultado, por lo que puedes hacerlo de forma segura, unique_ptr<int[]> p(new int[42]);por ejemplo. shared_ptraún necesitaría un eliminador personalizado, pero no necesitaría un puntero de matriz único o compartido especializado. Por supuesto, estas cosas suelen ser mejor reemplazadas por de std::vectortodos modos. Desafortunadamente, shared_ptrno proporciona una función de acceso a la matriz, por lo que aún tendría que llamar manualmente get(), pero unique_ptr<T[]>proporciona operator[]en lugar de operator*y operator->. En cualquier caso, debes comprobarlo tú mismo. Esto lo hace shared_ptrun poco menos fácil de usar, aunque podría decirse que la ventaja genérica y la ausencia de dependencia de Boost los convierte unique_ptren shared_ptrlos ganadores nuevamente.

Punteros con alcance: se vuelven irrelevantes por unique_ptr, al igual que auto_ptr.

Realmente no hay nada más. En C++03 sin semántica de movimientos esta situación era muy complicada, pero en C++11 el consejo es muy simple.

Todavía hay usos para otros punteros inteligentes, como intrusive_ptro interprocess_ptr. Sin embargo, son muy específicos y completamente innecesarios en el caso general.

Jan 02 '2012 23:01 Puppy

Casos de cuándo utilizar unique_ptr:

• Métodos de fábrica
• Miembros que son punteros (incluido pimpl)
• Almacenamiento de punteros en contenedores stl (para evitar movimientos)
• Uso de grandes objetos dinámicos locales.

Casos de cuándo utilizar shared_ptr:

• Compartir objetos entre hilos
• Compartir objetos en general

Casos de cuándo utilizar weak_ptr:

• Mapa grande que actúa como referencia general (por ejemplo, un mapa de todos los enchufes abiertos)

Siéntete libre de editar y agregar más

Jan 02 '2012 23:01