Blog de Jorge Machín

#include <boost/bind.hpp>
#include <boost/thread/thread.hpp>

class Hilo {

   public:

      Hilo() : keepgoing( true ), thread( boost::bind( &Hilo::do_work, this ) ) { };

      ~Hilo() {

         keepgoing = false;

         // Necesitamos esperar a que el hilo se acabe

         thread.join();

      }

   private:

      bool keepgoing;

      boost::thread thread;

      void do_work() {

          // Aquí es donde se lleva a cabo toda la acción.

          while( keepgoing ) {

             std::cout <<"Hilo" << std::endl;
             sleep(1);

          }

       }

};

int main( void ) {

   Hilo *hilo = new Hilo();

   sleep(20);

   delete hilo;

   return EXIT_SUCCESS;

}

class CThread {

   public:

      // Constructor por defecto:

      CThread(void);

      // Destructor virtual
   
      virtual ~CThread(void);

      // Esta función inicia el hilo:

      bool start();

      // Esta función se debe sobrecargar con lo que tiene que hacer el hilo:

      virtual void run() = 0;

      // Esta función espera a que el hilo se detenga. Se debe llamar en el destructor de la clase derivada.

      void join();

   private:

      unsigned long id;

      void *threadHandle;

      static DWORD WINAPI entryPoint( void *pthis );

};

CThread::CThread(void) : threadHandle( NULL ) {

   MessageBox( NULL, "CThread::CThread", "Aviso", MB_OK );

}

DWORD WINAPI CThread::entryPoint( void *pthis ) {

   CThread *pt = ( CThread * ) pthis;
   pt -> run();
   return 0;

}

bool CThread::start() {

   threadHandle = CreateThread( NULL, 0, ( LPTHREAD_START_ROUTINE ) entryPoint, this, 0, &id );
   return true;

}

void CThread::join() {

   if ( threadHandle != NULL )

      WaitForSingleObject( threadHandle, INFINITE );

}

CThread::~CThread(void) {

   MessageBox( NULL, "CThread::~CThread", "Aviso", MB_OK );

   if ( threadHandle != NULL )   

      CloseHandle( threadHandle );

}

#include "curl/curl.h" 

class URLFile {

   public:

      std::string get( const std::string &URL ) {

         // Inicialización:

         CURL *curl = curl_easy_init();
         curl_easy_setopt( curl, CURLOPT_URL, URL.c_str() );
         curl_easy_setopt( curl, CURLOPT_WRITEFUNCTION, &URLImage::write_data);
         curl_easy_setopt( curl, CURLOPT_WRITEDATA, &data);

         // Obtén el archivo:
                       
         CURLcode result = curl_easy_perform(curl); 

         // Al final hay que limpiar todo:

         curl_easy_cleanup(curl);

         if (result != CURLE_OK)  {

            return "";

         }

         return data;

      }

   private:
 
      // Variable que usamos para guardar el contenido del archivo:

      std::string data;

      // Callback que utiliza curl:

      static size_t write_data( char *buffer, size_t size, size_t nmemb, void *userp ) {

         int len = size * nmemb;
 
         if ( buffer != NULL ) 

            ( ( std::string * )  userp )->append( buffer, len ); 

         return len;

      }
 
};

int main() {

   URLFile file;

   std::string test = file.get( "www.machin.com.mx" );

   std::cout <<"Test:" <<std::endl <<test <<std::endl;

   return 0;

}

  public:

    // Default constructor

    Function1() { std::cout <<"Function1 constructor" <<std::endl; }

    // Virtual destructor

    ~Function1() { std::cout <<"Function1 destructor" <<std::endl; }

    //  Function call:

    void operator() (int a) const {
        std::cout <<"operator(): " <<a <<std::endl;
    }
};

// Una clase base para hacer clases con callbacks:

class callbackbase {

   public:

      virtual void operator()() const { std::cout <<"callbackbase()" <<std::endl; };
      virtual ~callbackbase() { };

};

// El functor que implementa la funcionalidad del callback:

template <class T> class callback : public callbackbase {

   public:

      typedef void (T::*Func)();

      callback( T& t, Func func ) : object(&t), f(func) { }

      void operator()() const { (object->*f)(); }

   private:

      T* object;

      Func f;
};

template<typename T> callback<T> *make_callback( T& t, void (T::*f) () ) {

  return new callback<T>( t, f );

}

// Los tipos de eventos que soportamos:

enum notifications {

   NOTIFICATION_ONE,
   NOTIFICATION_TWO,
   NOTIFICATION_MAX

};

// Nuestro Manejador de Eventos:

class EventManager {

   public:

      void registerHandler( callbackbase *function, enum notifications notification) {

         functions[notification].push_back( function );

      }

      void notifyHandlers( enum notifications notification ) {

         for ( std::list<callbackbase*>::iterator iter = functions[notification].begin(); iter != functions[notification].end(); iter++ ) {

            (*(*iter))();

         }

      }

   private:

      std::list<callbackbase *> functions[NOTIFICATION_MAX];

};

// Clases de ejemplo

class Class1 {

   public:

      Class1( const std::string &instance ) : instance( instance ) { };

      void function1() { std::cout <<"class1::function1: " <<instance <<std::endl; };

      void function2() { std::cout <<"class1::function2: " <<instance <<std::endl; };

   private:

      std::string instance;

};

class Class2 {

   public:

      void function1() { std::cout <<"class2::function1" <<std::endl; };

};

class Class3 : public callbackbase {

   public:

     virtual void operator()() const { std::cout <<"class3::function1" <<std::endl; };

};

//

int main() {

   // Clases que van a recibir los eventos:

   Class1 class1a("1a");
   Class1 class1b("1b");
   Class2 class2;
   Class3 class3;

   // Creamos nuestro manejador de eventos:

   EventManager eventManager;

   // Creamos al vuelo callbacks a funciones de clases que no heredan de callbackbase:

   eventManager.registerHandler( make_callback( class1a, &Class1::function1 ), NOTIFICATION_ONE );

   eventManager.registerHandler( make_callback( class1a, &Class1::function2 ), NOTIFICATION_ONE );

   eventManager.registerHandler( make_callback( class1b, &Class1::function1 ), NOTIFICATION_ONE );

   eventManager.registerHandler( make_callback( class2, &Class2::function1 ), NOTIFICATION_ONE );

   // Registramos una clase que hereda callbackbase:

   eventManager.registerHandler( &class3, NOTIFICATION_ONE );

   // Lanzamos un evento a nuestras funciones:

   eventManager.notifyHandlers( NOTIFICATION_ONE  );

   return 1;

}