Puntero inteligente

algun_tipo* function_ambigua(); // ¿Qué se debería hacer con el resultado?

auto_ptr<algun_tipo> funcion_obvia1();

algun_tipo& funcion_obvia2();

boost::scoped_ptr<MiClase> MiPuntero (new MiClase(1));
MiPuntero.reset(new MiClase(2));

#include <iostream>
using namespace std;
 
#include <boost/scoped_ptr.hpp>
 
/*
  Vamos a crear una clase que informe de cuándo se crea y cuando se
  destruye, y lleve un contador de elementos creados.
 
*/
 
class Elemento
{
  static int counter;
  int n;
public:
  Elemento():n(++counter){
    cout << "* Creando Elemento " << n << endl;
  };
 
  void lanzar(const char * msg){
    cout << "* Elemento " << n << " says: " << msg << endl;
  };
 
  virtual ~Elemento(){
    cout << "* So Long, Elemento " << n << endl;
  };
};
 
int Elemento::counter = 0;
 
int main(int argc, char *argv[])
{
 
  /*
    Utilizamos corchetes para abrir un nuevo entorno (scope) Vemos
    que al terminar el scope, el scoped pointer se libera
    automáticamente, mientras que en el caso del puntero clásico, si
    no liberamos manulmente se produciría una fuga de memoria.
  */
 
  cout << "Inicio del scope" << endl;
  {
    boost::scoped_ptr<Elemento> miElemento(new Elemento());
    miElemento -> lanzar("Mensaje desde myFun_1");
 
    Elemento * classicPointer = new Elemento();
    classicPointer -> lanzar ("Mensaje del elemento con puntero clásico");
 
    delete classicPointer; // Necesario borrarlo manualmente!
  }
  cout << "Fin del scope" << endl;
 
  /*
    Si tenemos un scoped pointer como atributo de una clase, o como
    variable suelta, es posible asignarle un valor utilizando el
    método reset, que borrará lo que estuviera contenido en el
    puntero previamente.
  */
 
  boost::scoped_ptr<string> ptrCadena;
  ptrCadena.reset(new string("Hola"));
 
  /*
    Los operadores habituales se conservan. En el caso del *, se
    devuelve una referencia &. Para acceder al puntero en bruto se
    utiliza el método get(), aunque NO SE RECOMIENDA, ya que hacer
    modificaciones o borrar el objeto apuntado a través de get()
    puede producir errores.
  */
 
  cout << "Longitud de cadena: " << ptrCadena -> length() << endl;
  cout << *ptrCadena << endl;
 
  return 0;
}

boost::shared_ptr<MiClase> MiPuntero (new MiClase(1));
boost::shared_ptr<MiClase> OtroPuntero = MiPuntero;
MiPuntero.reset(new MiClase(2));

#include <iostream>
#include <string>
 
using namespace std;
 
int tabulados;
 
#include <boost/shared_ptr.hpp>
 
/*
  Tenemos dos clases. La clase Mirador tiene un shared pointer a
  Observado. 
*/
 
string tab(){
  return string(tabulados, '\t');
}
 
struct Observado{
  Observado(){ cout << tab() << "+ Creando Observado" << endl; }
  ~Observado(){ cout << tab() << "- Borrando Observado" << endl; }
};
 
struct Mirador{
  boost::shared_ptr<Observado> fan;
 
  Mirador(){ cout << tab() << "+ Creando Mirador" << endl; }
  ~Mirador(){ cout << tab() << "- Borrando Mirador" << endl; }
};
 
/*
  La función popular rellena el atributo del Mirador con un shared
  pointer a Observado.
 
*/
 
void popular(Mirador & m1, Mirador & m2){
  boost::shared_ptr<Observado> O(new Observado);
  m1.fan = O;
  m2.fan = O;
}
 
int main(int argc, char *argv[])
{
  tabulados = 0;
  cout << "-- Inicio" << endl;
  {
    tabulados ++;
    cout << tab() << "-- Inicio del primer scope" << endl;
    Mirador M1;
    {
      tabulados ++;
      cout << tab() << "-- Inicio del segundo scope" << endl;
      Mirador M2;
      popular(M1, M2);
      cout << tab() << "-- Fin del segundo scope" << endl;
    }
    tabulados --;
    cout << tab() << "-- Final del primer scope" << endl;
  }
  tabulados--;
  cout << "-- Fin" << endl;
 
  return 0;
}