Ejemplo para usar el rpp compartido?

Voy a añadir que una de las cosas importantes acerca de shared_ptr es solo siempre construirlos con la siguiente sintaxis:

shared_ptr<Type>(new Type(...));

De esta manera, el puntero "real" a Type es anónimo para su ámbito, y se mantiene solo por el puntero compartido. Por lo tanto, será imposible para usted utilizar accidentalmente este puntero "real". En otras palabras, nunca hagas esto:

Type* t_ptr = new Type(...);
shared_ptr<Type> t_sptr ptrT(t_ptr);
//t_ptr is still hanging around!  Don't use it!

Aunque esto funcionará, ahora tiene un puntero Type* (t_ptr) en su función que vive fuera el puntero compartido. Es peligroso usar t_ptr en cualquier lugar, porque nunca se sabe cuándo el puntero compartido que lo contiene puede destruirlo, y se segmentará.

Lo mismo ocurre con los punteros devueltos por otras clases. Si una clase que no escribiste te entrega un puntero, generalmente no es seguro simplemente ponerlo en un shared_ptr. No a menos que esté seguro de que la clase ya no está usando ese objeto. Porque si lo pones en un shared_ptr, y cae fuera del alcance, el objeto obtendrá liberado cuando la clase aún lo necesite.

Aprender a usar punteros inteligentes es, en mi opinión, uno de los pasos más importantes para convertirse en un programador competente de C++. Como usted sabe cada vez que usted nuevo un objeto en algún momento que desea eliminarlo.

Un problema que surge es que, con excepciones, puede ser muy difícil asegurarse de que un objeto se libere siempre una sola vez en todas las rutas de ejecución posibles.

Esta es la razón de RAII: http://en.wikipedia.org/wiki/RAII

Hacer una clase auxiliar con el propósito de asegurarse de que un objeto siempre se elimina una vez en todas las rutas de ejecución.

Ejemplo de una clase como esta es: std:: auto_ptr

Pero a veces te gusta compartir objetos con otros. Solo se debe eliminar cuando nadie lo use más.

Con el fin de ayudar con que se han desarrollado estrategias de recuento de referencia, pero todavía necesita recordar addref y release ref manualmente. En esencia, este es el mismo problema que new / delete.

Es por eso que boost se ha desarrollado boost:: shared_ptr, es puntero inteligente de conteo de referencia para que pueda compartir objetos y no perder memoria involuntariamente.

Con la adición de C++ tr1, esto también se agrega al estándar de c++, pero se llama std::tr1::shared_ptr.

Recomiendo usar el puntero compartido estándar si es posible. ptr_list, ptr_dequeue y so son contenedores IIRC especializados para tipos de puntero. Los ignoro por ahora.

Así que podemos empezar con tu ejemplo:

std::vector<gate*> G; 
G.push_back(new ANDgate);  
G.push_back(new ORgate); 
for(unsigned i=0;i<G.size();++i) 
{ 
  G[i]->Run(); 
} 

El problema aquí es ahora que cada vez que G sale del alcance filtramos los 2 objetos agregados a G. Reescribámoslo para usar std:: tr1:: shared_ptr

// Remember to include <memory> for shared_ptr
// First do an alias for std::tr1::shared_ptr<gate> so we don't have to 
// type that in every place. Call it gate_ptr. This is what typedef does.
typedef std::tr1::shared_ptr<gate> gate_ptr;    
// gate_ptr is now our "smart" pointer. So let's make a vector out of it.
std::vector<gate_ptr> G; 
// these smart_ptrs can't be implicitly created from gate* we have to be explicit about it
// gate_ptr (new ANDgate), it's a good thing:
G.push_back(gate_ptr (new ANDgate));  
G.push_back(gate_ptr (new ORgate)); 
for(unsigned i=0;i<G.size();++i) 
{ 
   G[i]->Run(); 
} 

Cuando G se sale del alcance, la memoria se recupera automáticamente.

Como un ejercicio con el que plagé a los recién llegados en mi equipo es pedirles que escriban su propia clase de puntero inteligente. Luego, una vez que haya terminado, deseche la clase inmediatamente y nunca vuelva a usarla. Esperemos que haya adquirido conocimientos cruciales sobre cómo funciona un puntero inteligente bajo el capó. No hay magia de verdad.

La documentación de boost proporciona un buen ejemplo de inicio: shared_ptr ejemplo (en realidad se trata de un vector de punteros inteligentes) o shared_ptr doc La siguiente respuesta de Johannes Schaub explica los punteros inteligentes boost bastante bien: se explican los punteros inteligentes

La idea detrás (en tan pocas palabras como sea posible) ptr_vector es que maneja la desasignación de memoria detrás de los punteros almacenados para usted: digamos que tiene un vector de punteros como en su ejemplo. Al salir de la aplicación o salir del ámbito en el que se define el vector tendrás que limpiar después de ti mismo(has asignado dinámicamente ANDgate y ORgate), pero simplemente borrar el vector no lo hará porque el vector está almacenando los punteros y no los objetos reales(no destruirá sino lo que contiene).

 // if you just do
 G.clear() // will clear the vector but you'll be left with 2 memory leaks
 ...
// to properly clean the vector and the objects behind it
for (std::vector<gate*>::iterator it = G.begin(); it != G.end(); it++)
{
  delete (*it);
}

Boost::ptr_vector se encargará de lo anterior, lo que significa que desasignará la memoria detrás de los punteros que almacena.

A través de Boost puedes hacerlo >

std::vector<boost::any> vecobj;
    boost::shared_ptr<string> sharedString1(new string("abcdxyz!"));    
    boost::shared_ptr<int> sharedint1(new int(10));
    vecobj.push_back(sharedString1);
    vecobj.push_back(sharedint1);

> para insertar diferentes tipos de objeto en su contenedor vectorial. mientras que para acceder tienes que usar any_cast, que funciona como dynamic_cast, espera que funcione para tu necesidad.

#include <memory>
#include <iostream>

class SharedMemory {
    public: 
        SharedMemory(int* x):_capture(x){}
        int* get() { return (_capture.get()); }
    protected:
        std::shared_ptr<int> _capture;
};

int main(int , char**){
    SharedMemory *_obj1= new SharedMemory(new int(10));
    SharedMemory *_obj2 = new SharedMemory(*_obj1);
    std::cout << " _obj1: " << *_obj1->get() << " _obj2: " << *_obj2->get()
    << std::endl;
    delete _obj2;

    std::cout << " _obj1: " << *_obj1->get() << std::endl;
    delete _obj1;
    std::cout << " done " << std::endl;
}

Este es un ejemplo de shared_ptr en acción. _obj2 fue eliminado, pero el puntero sigue siendo válido. la salida es, ./prueba _obj1: 10 _obj2: 10 _obj2: 10 hecho

La mejor manera de agregar diferentes objetos en el mismo contenedor es usar make_shared, vector y range based loop y tendrá un código agradable, limpio y "legible".

typedef std::shared_ptr<gate> Ptr   
vector<Ptr> myConatiner; 
auto andGate = std::make_shared<ANDgate>();
myConatiner.push_back(andGate );
auto orGate= std::make_shared<ORgate>();
myConatiner.push_back(orGate);

for (auto& element : myConatiner)
    element->run();