Expresiones regular en C++ con boost

La mayoría lenguajes de programación modernos proporcionan la posibilidad de usar expresiones regulares de forma nativa desde el propio lenguaje, sin embargo, en C++ es necesario recurrir a alguna librería como Boost.Regex.

Boost.Regex ofrece la mayoría de funciones comunes de las expresiones regulares.

#include <iostream>
#include <string>
#include <boost/regex.hpp>

int main(){ 
 std::string s = "BEGIN->Cadena_entre_delimitadores<-END"; 
 std::string s2 = "Cadena de texto con 3 numeros para sustituir 1, 4 por incognitas"; 
 boost::regex r("BEGIN->(\\w+)<-END"); 
 boost::regex r2("\\d"); 
 boost::smatch result; 

 if (boost::regex_search(s, result, r)){ 
  for(int i=0; i<result.size(); i++){
   std::cout << "Ocurrencia n " << i+1 << ": "<< result[i] << std::endl; 
  }  
 }
 else{
  std::cout << "Ninguna coincidencia" << std::endl;
 }

 std::cout << "---" << std::endl;
 std::string number("X"); 
 std::cout << "Cadena modificada con una expresion regular: ";
 std::cout << boost::regex_replace(s2, r2, number) << std::endl; 
 
}

Con regex_search se pueden encontrar coincidencias de una expresión regular r dentro de una cadena s. Como resultado también tendrá en cuenta los grupos de captura.

Con regex_replace se pueden hacer sustituciones, cambiando las ocurrencias encontradas en la cadena s2 según el patrón r2, sustituyéndolas por number.

Papra compilar es necesario incluir tanto los headers como la librería correspondiente, en mi caso.

g++ -lboost_regex-mt -I/opt/local/include/ -L/opt/local/lib/ regex.cpp -o regex

Programación de callbacks con Boost

Usando las librerías Boost.Function y Boost.Bind se pueden crear fácilmente callbacks en c++ sin necesidad de usar punteros a función.

Un ejemplo.

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

#include <iostream>


using namespace boost;

class Example{
 private:
  int a;
 public:
  function<void(std::string)> callback; 
  
  void setA(int value){
   a = value;
   changeA();
   if(callback){callback("setA");}
  }

  void changeA(){
   a++;
   if(callback){callback("changeA");}   
  }  
};


void debug(std::string s){
 std::cout << "Method called: " << s << std::endl;
}

int main(){
 Example e;
 e.callback = bind(&debug, _1); 
 e.setA(123);   
}

Siguiendo el planteamiento anterior obtendríamos la cadena de llamadas a las funciones de la clase Example.

Si no establecemos el callback (en este caso se hace en la segunda línea de main) el comportamiento será el normal, sin embargo, en caso de necesidad se le puede hacer un bind al objeto que queramos con una función de debug.

La programación usando callbacks es especialmente útil en programación concurrente, para más información en la página de Boost.Function.

Smart pointers de la librería Boost

Una de las ventajas que tiene la programación en Java sobre C++ es la recolección de basura.

Cuando escribimos un programa en Java no nos tenemos que preocupar de liberar la memoria que vamos usando, hay un recolector de la máquina virtual que lo hace por nosotros. De esta forma se reduce el número de memory leaks y se facilita la programación.

En C++ sin embargo la gestión de memoria debe realizarla el desarrollador, proporcionando más potencia pero también dificultando el desarrollo.

Para facilitar la programación en este apartado, la librería Boost cuenta con un concepto llamado smart pointers que liberan de complejidad a la hora de gestionar la memoria al programador.

Por ejemplo, usando el tipo scoped_ptr.

#include <boost/smart_ptr.hpp>

class Example{
 public:
  int a;
};

void scoped_pointer(){
 boost::scoped_ptr<Example> ptr(new Example);
}

void pointer(){
 Example *ptr = new Example;
}


int main(){
 while(1){
  pointer();
 }
}

Al ejecutar este programa se irá reservando memoria constantemente hasta agotar la memoria total del sistema, puesto que en ningún momento se libera.

Sin embargo, si se modifica la llamada pointer por scoped_pointer el programa se ejecutará de forma estable, dado que al terminar el método, el scoped pointer libera la memoria utilizada de forma automática.

Hay smart pointers con otras políticas de gestión de memoria, para elegir cual nos conviene en la documentación de boost se detalla cada uno.