La librería Standard Template Library

1. Espacios de nombres

El lenguaje C solo conoce dos niveles de ámbito: el nivel global, al que pertenece la función main(), y el nivel local, destinado a instrucciones y variables locales. Con la aparición de las clases, apareció un nivel adicional, destinado al registro de campos y métodos. Luego, la introducción de la derivación (herencia) y de los miembros estáticos terminó de completar la gama de los niveles de alcance.

Por las razones mencionadas en la introducción, se hizo necesario estructurar el espacio global. Para mantener solo uno, el espacio global es demasiado arriesgado para almacenar variables y funciones de programas antiguos. Los conflictos son inevitables.

Por lo tanto, podemos particionar este espacio global usando espacios de nombres:

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

Ambos espacios de nombres, Edificio y Cadenas, contienen una variable llamada longitud, que es de un tipo diferente. Las funciones medir() y calculo_longitud() siempre usan 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 usar cualquiera de estas funciones, la función main() debe usar la operación de resolución de alcance :: 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; 
} 

Observamos que llamar a una función declarada dentro de un espacio de nombres se parece mucho a llamar a un método estático. Esta analogía continúa para el acceso a una variable...

1. Generalidades

Para comenzar a aprender las entradas-salidas correctamente, debe diferenciar entre archivo y flujo. Un archivo se caracteriza por un nombre, una ubicación, derechos de acceso y, algunas veces, también un periférico. Un flujo (stream en inglés) es un contenido, una información que el programa lee o escribe. Esta información puede ser de alto o bajo nivel. En la base, naturalmente, encontramos el byte, pero luego éste se especializa en datos de tipo entero, decimal, booleano, string, etc. Finalmente, podemos crear registros compuestos por información muy diversa. Es bastante lógico considerar que la forma de estos registros se corresponde con la formación de una clase, es decir, un tipo en sentido C++.

Los flujos de C++ se organizan en tres niveles; el primero, el más abstracto, agrupa los ios_base, un formato de entrada-salida independiente del estado y del formato. Luego encontramos el nivel basic_ios, versión que integra la noción de parámetro regional (locale en inglés).

Finalmente, encontramos el nivel basic_iostream, un grupo de modelos de clase destinados a soportar el formateo de todos los tipos base conocidos por el lenguaje. Trabajaremos en este nivel.

La circulación de información se realiza...

1. Representación de las cadenas en la STL

Para la STL, una cadena es un conjunto ordenado de caracteres. Por lo tanto, una cadena se parece mucho al vector, una clase que también está presente en la librería. Sin embargo, la cadena desarrolla accesos y procesamientos que le son específicos, por lo que soporta mejor los algoritmos traducidos a C++.

Las cadenas de la librería estándar utilizan una clase de caracteres para omitir la codificación. La STL proporciona soporte para caracteres ASCII (char) y para caracteres extendidos (wchar_t), pero uno podría considerar desarrollar otros formatos destinados a algoritmos basados en cadenas. La ingeniería genética utiliza cadenas formadas por caracteres específicos, A, C, G, T. Por lo tanto, codificar con un char es muy costoso en términos de espacio, ya que dos bits son suficientes para expresar dicho vocabulario, tanto más cuanto las secuencias de genes pueden afectar a varios cientos de miles de bases. También puede especificar caracteres adecuados para alfabetos no latinos, para los cuales la tabla ASCII no es eficaz.

La clase basic_string...

1. Contenedores

Los contenedores son estructuras de datos para almacenar objetos de varios tipos. Los contenedores STL respetan las principales construcciones...

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), un procedimiento.

En tiny-lisp, el objeto Variant forma parte de un entorno, un contenedor dotado de una tabla de símbolos. Esta estructura es necesaria para la ejecución de las funciones y de las expresiones lambda LISP, para pasar los parámetros y crear variables locales.

enum variant_type 
{ 
   Symbol, Number, List, Proc, Lambda, Cadena 
}; 
 
// definición por venir; Variant y Entorno se referencian mutuamente 
struct Entorno; 
 
// 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 de 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; 
 
   // entorno 
   Entorno* 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(); ...