La librería STL estándar

1. Espacio de nombres

El lenguaje C sólo tiene dos niveles de ámbito: el nivel global, al que pertenece la función main() y el nivel local, destinado a las instrucciones y variables locales. Con la aparición de las clases, se añadió un nivel adicional, para registrar campos y métodos. La introducción de la derivación (herencia) y los miembros estáticos refinó aún más la gama de niveles de alcance.

Por las razones expuestas en la introducción, se hizo necesario estructurar el espacio global. Por mencionar sólo una de ellas, el espacio global es demasiado arriesgado para almacenar variables y funciones de programas antiguos. Los conflictos son inevitables.

Este espacio global se puede dividir mediante:

namespace Edificio 
{ 
  double longitud; 
 
  void medir() 
  { 
    longitud=50.3; 
  } 
} ; 
 
namespace Cadenas 
{ 
  int longitud; 
 
  void calculo_longitud(char*s) 
  { 
    longitud=strlen(s); 
  } 
} ; 

Dos espacios de nombres, Edificio y Cadenas, contienen ambos una variable llamada longitud, que es de un tipo diferente. Las funciones medir() y calculo_longitud() siempre utilizan la versión correcta, porque la regla de accesibilidad también se verifica en los espacios de nombres: el compilador siempre busca la versión más cercana.

Para utilizar cualquiera de estas funciones, la función main() debe utilizar la operación de resolución de ámbito :: o una instrucción using:

int main(int argc, char* argv[]) 
{ 
  Edificio::medir(); 
  printf("La longitud del edificio es %g\n",Edificio::longitud); 
 
  using Cadenas::longitud; 
  Cadenas::calculo_longitud("hola"); 
  printf("La longitud de la cadena es %d\n",longitud); 
  return 0; 
} 

Podemos ver que llamar a una función declarada dentro de un espacio de nombres es muy similar a llamar a un método estático. Esta analogía se extiende al acceso a una variable, que se puede...

1. General

Para empezar el aprendizaje de la E/S con buen pie, debemos distinguir entre archivos y flujos. Un archivo se caracteriza por un nombre, una ubicación, derechos de acceso y a veces también un periférico. Un flujo o stream es contenido, información que es leída o escrita por el programa. Esta información puede ser de nivel superior o inferior. Se empieza naturalmente por el byte, luego se especializa en datos de tipo entero, decimal, booleano, cadena, etc. Por último, podemos crear registros compuestos por información muy variada. Es bastante lógico considerar que la forma de estos registros corresponde a la formación de una clase, es decir, de un tipo en el sentido de C++.

Los flujos C++ se organizan en tres niveles. El primero -el más abstracto- es ios_base, un formato de entrada-salida independiente del estado y el formato. Luego está el nivel basic_ios, una versión que incorpora la noción de argumento regional (locale en inglés).

Por último, está el nivel basic_iostream, un grupo de modelos de clases diseñados para soportar el formateo de todos los tipos básicos conocidos por el lenguaje. Este es el nivel en el que vamos a trabajar.

La información fluye a través de un sistema...

1. Representación de cadenas en la librería STL

Para la librería STL, una cadena es un conjunto ordenado de caracteres. Una cadena es, por tanto, muy similar a vector, clase también presente en la librería. Sin embargo, la cadena desarrolla sus propios accesos y procesamiento, proporcionando un mejor soporte a los algoritmos traducidos a C++.

Las cadenas de la librería estándar utilizan una clase de caracteres para evitar la codificación. La librería STL ofrece soporte para caracteres ASCII (char) y caracteres extendidos (wchar_t), pero sería posible desarrollar otros formatos para algoritmos basados en cadenas. La ingeniería genética utiliza cadenas formadas por caracteres específicos, A, C, G, T. Por tanto, la codificación con un char es muy costosa en términos de espacio, ya que bastan dos bits para expresar un vocabulario de este tipo, sobre todo teniendo en cuenta que las secuencias de genes pueden implicar varios cientos de miles de bases. También es posible especificar caracteres adaptados a alfabetos no latinos, para los que la tabla ASCII resulta ineficaz.

La clase basic_string utiliza un vector para almacenar...

1. Contenedores

Los contenedores son estructuras de datos para almacenar objetos de varios tipos. Los contenedores de la librería STL respetan las principales construcciones desarrolladas...

1. Operaciones de secuencia sin modificación

Se trata principalmente de algoritmos de búsqueda y recorrido.

He aquí un ejemplo de búsqueda de un valor en un vector de cadenas char*:

#include <iostream> 
#include <algorithm> 
#include <vector> 
using namespace std; 
 
int main(int argc, char* argv[]) 
{ 
  vector<char*> tab; 
  tab.push_back("Sonata"); 
  tab.push_back("Partita"); 
  tab.push_back("Cantate"); 
  tab.push_back("Concerto"); 
  tab.push_back("Sinfonía"); 
  tab.push_back("Aria"); 
  tab.push_back("Preludio"); 
 
  vector<char*>::iterator pos; 
  char*palabra="Concerto"; 
  pos=find(tab.begin(),tab.end(),palabra); 
  cout << *pos << endl; // muestra Concerto 
  return 0; 
} 

2. Secuencia de operaciones con modificación

1. Las expresiones lambda

En C++, una expresión lambda (o lambda) es una función anónima (conocida como closure) llamada en el mismo punto donde se define. Es una forma práctica de describir pequeños algoritmos sin intentar que las funciones sean reutilizables.

Lambda es una notación compuesta por los siguientes elementos:

[capture] (argumentos) mutable exception { corps } 

La captura permite a lambda trabajar con variables declaradas en el ámbito que la define, por referencia & o por valor =. La captura por defecto puede ser por valor =, lo que significa que la lambda recibe una "copia" de las variables que aparecen en el cuerpo de la instrucción. Si la captura es por referencia &, la lambda puede modificar las variables.

Los argumentos son opcionales, aunque a menudo una lambda recibe elementos para ser probados, comparados, evaluados, procesados, etc.

La palabra clave mutable también es opcional. Como regla general, el operador de llamada a una lambda es const por valor, pero la presencia de mutable anula esta regla, permitiendo al cuerpo de la instrucción modificar localmente variables capturadas por valor.

La indicación de excepciones mediante throw o noexcept es opcional, como en todas las funciones C++.

El tipo de retorno es deducido por el compilador a partir del cuerpo. Por defecto, es void, a menos que una instrucción return expresión permita al compilador deducir un tipo particular.

Veamos la función ends_with(), que comprueba la terminación de una cadena:

// comprueba si la cadena termina con el sufijo (ejemplo cadena = 
prueba.txt termina con sufijo = .txt) 
inline bool ends_with(std::string const& cadena, std::string 
const& sufijo) 
{ 
  if (sufijo.size() > cadena.size()) 
     return...

1. Instalación de la librería

Hay varias formas de instalar la librería en un proyecto. En Linux, puede seguir las instrucciones del sitio web https://boost.org/ para recuperar un paquete fuente o binario.

Desde Visual Studio, la forma más directa es descargar un paquete NuGet. En el menú Proyecto, utilice el comando Administrar paquetes NuGet. Introduzca boost en el cuadro de búsqueda de la pestaña Examinar. El catálogo de paquetes mostrará entonces la librería completa, así como los volúmenes de esta librería.

Tras pulsar el botón Instalar, el gestor de paquetes le pedirá que confirme que la librería se ha instalado en el directorio:

La confirmación activa el proceso de descarga del paquete NuGet (desde la solución de Visual Studio) y la instalación de la librería en el proyecto.

2. Un primer ejemplo con boost

Este ejemplo sigue perteneciendo al ámbito de los algoritmos y las colecciones. Muestra cómo las boost...

1. La clase Variant

Variant es el tipo de datos universal de tiny-lisp. Puede ser un símbolo, un número, una lista (de Variant) o un procedimiento.

En tiny-lisp, el objeto Variant forma parte de un entorno, un contenedor con una tabla de símbolos. Esta estructura es necesaria para ejecutar funciones LISP y expresiones lambda, para pasar argumentos y crear variables locales.

enum variant_type 
{ 
   Symbol, Number, List, Proc, Lambda, Cadena 
}; 
 
// definición ; Variant y Environment se hacen referencia mutuamente 
struct Environment; 
 
// un Variant representa cualquier tipo de valor Lisp 
class Variant { 
public: 
 
   // función que devuelve Variant y que recibe como argumento variants 
 
   typedef Variant(*proc_type) ( const std::vector<Variant>& ); 
 
   typedef std::vector<Variant>::const_iterator iter; 
 
   typedef std::map<std::string, Variant> map; 
 
   // tipos tomados en la enumeración: symbol, number, list, proc o lamda 
   variant_type type; 
 
   // valor escalar 
   std::string val; 
 
   // valor list 
   std::vector<Variant> list; 
 
   // valor lambda 
   proc_type proc; 
 
   // environment 
   Environment * env; 
 
   // constructores 
   Variant(variant_type type = Symbol) : type(type) , env(0), proc(0) { 
 
   } 
 
   Variant(variant_type type, const std::string& val) : 
type(type), val(val) , env(0) , proc(0) { 
 
   } 
 
   Variant(proc_type proc) : type(Proc), proc(proc) , env(0) { 
 
   } 
 
   std::string to_string(); 
   std::string to_json_string(); 
   static...