Don’t get set into one form, adapt it and build your own, and let it grow, be like void*. Empty your mind, be formless, shapeless — like void*. If you put an int into a void*, it becomes the int. You put float into a void* it becomes the float. You put in a char it becomes the char. Now, void* can flow or it can overflow. Be void* my friend.

Comentario en Barrapunto. De McPolu — Martes, 31 de Octubre 2006 (link)

printf ()

scanf ()

stdarg.h

• va_list

  : es el tipo de dato utilizado para declarar la variable que será utilizada con las macros que ofrece

  stdarg.h

  . Define un puntero a la lista de argumentos variable y en entornos como Dev-C++ o el compilador GCC se trata de un alias de un puntero a caracter (

  typedef char * va_list;

  ).

• void va_start (va_list ap, last);

  : macro que se encarga de inicializar una variable

  pa

  (parámetro de argumentos) para poder utilizarla con el par de macros restantes.

  last

  es un argumento fijo que hay que pasar siempre a la función, como primer parámetro, ya que le sirve como referencia a

  va_start

  para saber dónde localizar la lista de argumentos variables (estos argumentos estarán en posiciones de memoria adyacentes a

  last

  , de ahí a que se le deba pasar siempre un argumento “estático” a la función).

• type va_arg (va_list ap, type);

  : macro con la que recorreremos la lista de argumentos variable. Devuelve el contenido del siguiente de estos argumentos.

• void va_end (va_list ap);

  : macro encargada de finalizar el uso de la variable

  ap

  previamente inicializada con

  va_start

  .

Bien, el mecanismo para emplear estas macros sin obtener resultados inesperados es básicamente siempre el mismo: lo primero de todo es declarar correctamente una función que utilizará lista de argumentos variable. Para ello se emplea un parámetro fijo inicial pasado por valor y, seguidamente, el operador especial

...

tipo_f foo (tipo_p bar, ...);

Hago especial hincapie en el paso del parámetro

bar

va_start

printf ()

scanf ()

Lo siguiente es declarar una variable que sea del tipo de dato

va_list

va_start

va_end

tipo_f foo (tipo_p bar, ...)
{
    va_list pa;
    tipo_p param;

    ...

    va_start (pa, bar);

    ... por aquí se podría usar va_arg -> param = va_arg (pa, tipo_p);

    va_end (pa);
    return;
}

Esta técnica, a priori, parece no tener demasiadas aplicaciones prácticas en la vida real. A mí al menos no se me ocurren demasiadas y, tal vez, como curiosidad está la mar de bien :-) Aunque lo cierto es que creo que la utilización de funciones con lista de argumentos variables podría venir muy bien para procesos de refactorizaación de código fuente; para según que casos / funciones concretas que tengamos hechas tal vez pueda valer.

Es un tema interesante y seguramente no haya quedado del todo claro con mis escuetas explicaciones. Os recomiendo la lectura de un artículo muy logrado sobre el tema que justamente ayer encontré en El Rincón del Programador y con el que he aprendido a utilizar un poco este juego de macros que trae

stdarg.h

Y ahora de la teoría a la práctica. Esta mañana en clase he estado jugando un poco con lo dicho anteriormente, sobre todo para afianzar lo aprendido ayer y hacer algún ejercicio chorra de prueba. El siguiente programilla lee por línea de comandos de dos a cuatro caracteres e imprime por pantalla una concatenación de ellos. Para cada número de argumentos, se utiliza una función que trabaja con una lista de argumentos variable. El código está hecho en plan guarro y, obviamente, solo sirve para liar un poco la cosa y aportar algún ejemplo algo más extraño a lo que personalmente he podido encontrar buscando por ahí (aunque, a fin de cuentas, es lo mismo).

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char * get_mem (int);
char * concatena (int, ...);

int main (int argc, char **argv)
{
  size_t i, error = 0;
  char * cad;

  switch (argc)
  {
      case 3 :
        cad = get_mem (argc);
        strcpy (cad, concatena (argc, argv [1], argv [2]));
        break;

      case 4 :
        cad = get_mem (argc);
        strcpy (cad, concatena (argc, argv [1], argv [2], argv [3]));
        break;

      case 5 :
        cad = get_mem (argc);
        strcpy (cad, concatena (argc, argv [1], argv [2], argv [3], argv [4]));
        break;

      default :
        error = 1;
        break;
  }

  if (!error)
  {
    for (i = 1; i < argc; i++)
        fprintf (stdout, "(%s) ", argv [i]);

    fprintf (stdout, "-> %s", cad);
    free (cad);
  }
  else
    fprintf (stderr, "uso: %s car1 car2 [car3 car4]", *argv);

  putchar ('n');
  return 0;
}

char * get_mem (int args)
{
  char * result = (char *) malloc (sizeof (char) * (--args));

  if (result == NULL)
    exit (1);

  return result;
}

char * concatena (int args, ...)
{
  char * result;
  va_list pa;

  result = get_mem (--args);
  va_start (pa, args);
  *result = '';

  while (args--)
    strcat (result, va_arg (pa, char *));

  va_end (pa);

  return result;
}

Lo dicho, recomendado:

• Funciones en C con lista de argumentos variable

Por mis manos ya han pasado unos cuantos libros sobre introducción a la programación en C y, sin lugar a dudas, Curso de programación C/C++, de Fco. Javier Ceballos Sierra (un Genial divulgador), es el que más interesante y completo me ha parecido. Sin pretender ser un libro enciclopédico o bíblico, esta joya sí se puede considerarse como un buen manual de referencia y apoyo para personas que estén estudiando lenguaje C. Personalmente pienso que se centra en esto último, en detallar del modo más claro, completo y práctico posible las entrañas de C y cómo programar de manera estructurada. Apuesto a que a más de uno bastante familiarizado con C le puede servir como material de apoyo, sobre todo por los últimos temas dedicados a detallar multitud de estructuras dinámicas (listas lineales: simple y doblemente enlazadas, pilas y colas; listas circulares, árboles: binarios, binarios de búsqueda y binarios perfectamente equilibrados) y problemas algorítmicos (recursividad, ordenación de vectores –burbuja, inserción y quicksort–, ordenación de ficheros –acceso secuencial, acceso aleatorio–, búsqueda –secuencial, binaria, algoritmo/métodos Hash–). Está claro que existe bibliografía mucho más extensa y avanzada sobre el tema pero creo que este libro puede ser una muy buena elección tanto para empezar a aprender lenguaje C como para quienes lleven una base.

El libro se divide en doce capítulos preparados con el fin de ir destripando el lenguaje de menos a más. Es otra de las ventajas que le veo, que está muy muy bien diferenciado todo y muy organizado. Cada capítulo se compone de multitud de puntos que, a su vez, desglosan cada uno de los elementos / técnicas de la programación con C. A groso modo, aquí os dejo el indica global:

1. Fases en el desarrollo de un programa C
2. Elementos del lenguaje C
3. Estructura de un programa
4. Estrada y salida estándar
5. Sentencias de control
6. Tipos estructurados de datos
7. Punteros
8. Funciones
9. Funciones estándar de E/S
10. El preprocesador C
11. Estructuras dinámicas de datos
12. Algoritmos
13. Apéndices
    1. Depurar un programa
    2. Visual C++
    3. Códigos de caracteres
    4. Índice alfabético

Y por si no fuese poco, cada concepto que se explica es enriquecido con al menos un ejemplo práctico. El libro está repletito de ellos, incluso con explicaciones sobre los ejemplos en muchos casos (a veces incluso detallando la ejecución del programa). Se explican multitud de funciones, casi todas relativas a la biblioteca estándar de C (cada función detallada viene presentada con su librería necesaria así como la compatibilidad –ANSI, UNIX y/o MS-DOS– con el sistema y acompañada con ejemplos prácticos jeje).

Además de dar una muy completa base sobre lo que es la programación en C, este libro forma parte de una trilogía encaminada terminar aprendiendo a desarrollar aplicaciones visuales. Los tres libros son del mismo autor y están editados por RA-MA. Y son:

1. Curso de programación C/C++
2. Programación orientada a objetos con C++
3. Visual C++. Aplicaciones para Windows

En la actualidad, y al menos que yo sepa, el primero de los tres libros va por la segunda edición. Yo dispongo de los dos primeros :-) aunque lo cierto es que no son del todo míos, mi padre fue quien se los compró hace ya unos cuantos años (y he cogido yo y me los he agenciado rápidamente jeje). Dispongo de las primeras ediciones de ambos libros. La primera edición del que os hablo aquí es de 1995. Y aunque me lo haya leído completo este verano, 2004, me sigue pareciendo un gran libro. Así que ni os cuento cómo debe estar de bien la segunda edición, con (me parece) casi un par de cientos de páginas más :-)

En definitiva, muy recomendable para un alto número de público variopinto jeje. Fco. Javier Ceballos tiene una extensa bibliografía editada de la mano de RA-MA. Personalmente si necesitase un libro sobre algún tema de programación, no dejaría de visitar esta bibliografía y comprobar si el señor éste le ha dedicado tiempo a enseñar sobre lo que esté buscando. Sinceramente, me ha encantado la manera de explicar cada cosa; y si el resto de sus libros viene tan plagada de ejemplos y problemas resueltos/propuestos como en el de Curso de programación C/C++, seguro que están geniales (por cierto, no es familiar ni le conozco de nada. Solo es que me ha ayudado mucho con C nada más).

Título: Curso de programación C/C++
Autor: Fco. Javier Ceballos.
ISBN: 84-7897-200-5
Precio: 4950 pesetas (al menos en 1996 :))
Editorial: RA-MA Editorial.
Copyright RA-MA Editorial.
Imprimido en España. Primera impresión en Septiembre de 1995.

Todo consiste en hacer una simple operación y comparar el resultado de la misma en una tabla de números enteros que va desde el 0 hasta el 22 y en la que cada número tiene definido una letra distinta. Basta hacer el módulo entre el número de 8 cifras que forma un DNI y 23 o, lo que es lo mismo, dividir el DNI entre 23 y fijarnos en el resto. Dependiendo de qué resto nos de (el cual estará entre 0 y 22) obtendremos una u otra letra y ésta es la letra del NIF para el DNI en cuestión jeje.

Dicho de un modo más gráfico, la supuesta tabla podemos verla como un vector de 23 elementos. De este modo:

T  R  W  A  G  M  Y  F  P  D  X   B   N   J   Z   S   Q   V   H   L  C  K  E
0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19 20 21 22

Un ejemplo: Halla el NIF del DNI: 48537318

1. ( 48537318 % 23 ) = 4
2. Mirar en la tabla y extraer la letra correspondiente al número obtenido. 4 -> G
3. Solucion: 48537318-G

No sé hasta qué punto es fiable este sencillo algoritmo, toda sugerencia es bienvenida :)

Y ahí va la chapuza de marras en C/C++

const char letra[] = "TRWAGMYFPDXBNJZSQVHLCKE";
const int kTAM = 8; // numero de cifras para el DNI
using namespace std;
int main (int argc, char *argv[])
{
    int dni;
    if (argc != 2)
        cout << "uso: " << argv[0] << " <DNI>nn";
    else
    {
        if (strlen(argv[1]) != kTAM)
            cout << "DNI no valido.nn";
        else
        {
            dni = atoi (argv[1]);
            dni %= 23;
            cout << argv[1] << "-" << letra[dni] << endl;
        }
    }
}

Jeje, ahora entiendo por qué mis profesores me obligan a declarar el DNI como dato de tipo entero ;)

Vía GULA me entero del comienzo de un curso de programación en C++ impartido por Ernesto Barragán López y llevado a cabo en esta página.

El autor va desarrollando el curso poco a poco (intentando llevar un capítulo por semana). Por ahora hay tres publicados (así que aun estamos a tiempo de subirnos al tren :)

La peculiaridad de este curso es el cómo su autor lo enfonca: de un modo gráfico utilizando como entorno de desarrollo a Kylix Open Edition. Este enfoque gráfico es debido a que las cosas, vistas desde un punto de vista gráfico, se entienden (generalmente) mejor y más rápido que de un modo más abstracto. Otra peculiaridad es la utilización de aspectos avanzados (como objetos) desde las primeras lecciones.

[ »» ] Web del curso
[ »» ] FAQ del curso
[ »» ] Foro del curso

Solución: Esta
es la solución mas eficiente. Es la que uno debe pensar. Estamos
en un entorno BASH, así que ejecutemos una orden propia de este entorno capaz de hacerlo.

   for i
in `find . -name mensajeitor.txt`; do chmod 666 $i; done

Con ese simple, bucle el problema esta solucionado :)

Solución chapucera:
¿Y si escribo un pequeño algoritmo en C++ que me resuelva
el problema de una tacada? … Esto es mucho menos eficiente. Pues hay
que tener en cuenta que en BASH tenemos que teclear una simple
línea, mientras que de otro modo (con C++ por ejemplo) son
bastantes más líneas de código jeje. Además
que no es coherente hacerlo de este modo pero vamos… estaba aburrido
y quería hacerlo porque implicaba utilizar ficheros (¡y
así practicaba! ;) Este es el resultado:

/*
 * Chapuza v2.0
 *
 * lo que hace este algoritmo es lo mismo que lo que se puede hacer
 * en UNA linea utilizando "lenguaje bash" dicha linea seria:
 *      for i in `find . -name mensajeitor.txt`; do chmod 644 $i; done
 *
 */
 
#include <iostream>
#include <fstream>
 
const int kCHMOD = 100;
const int kLINEA = 50;
 
using namespace std;
 
void chapuza(int files) {
   fstream ficLogico;
   char chmod[kCHMOD]="chmod 666 ";
   char copiaChmod[kCHMOD]="chmod 666 ";
   char linea[kLINEA];
   int i;
 
   ficLogico.open("lista.txt", ios::in); // leeremos el archivo lista.txt
   if (!ficLogico)
           cout << "Error de apertura";
   else {
       /* he de usar este bucle que emula a la funcion eof()
        * si lo pongo tal y como esta en la version 1.0 de chapuza
        * el system(chmod) funciona. las concatenaciones se van realizando
        * y todo parece funcionar bien. pero al final da un error
        *
        * # ./chapuza
        * chmod: too few arguments
        * Try `chmod --help' for more information.
        */
 
       for (i=1; i<=files; i++) {
              ficLogico.getline(linea,kLINEA);
              strcat(chmod,linea); // modificamos chmod[]
              system(chmod); // esto ejecuta un chmod 666 numLinea[i]
              strcpy(chmod,copiaChmod); // dejamos chmod[] como estaba
        }
 
        ficLogico.close(); // cierre del fichero
   }
}
 
int main() {
   int numLineas;
 
   // miramos cuantos archivos 'mensajeitor.txt' hay y los contamos
   numLineas = system("find . -name mensajeitor.txt | wc -l");
   chapuza(numLineas); // este parametro es para el bucle for de arriba
}

#include <iostream>
#include <fstream>
const int kTAM=99;
using namespace std;
 
int main() {
        int i;
        fstream nomLogico;
        char nomFisico[15];
 
        cout << â??Nombre del fichero de salida: â??;
        cin.getline(nomFisico,kTAM);
 
        nomLogico.open(nomFisico,ios::out);
        if (!nomFisico)
               cout << â??Error de apertura.\nâ?;
        else {
               for (i=0; i<=kTAM; i++)
                       nomLogico << i << endl;
               nomLogico.close();
        }
}

$ g++ 0a99.cpp
$

Tema 11. Estructuras de datos IV: FICHEROS
( … ) -página 290- « Para trabajar con ficheros se deberá incluir el fichero de cabecera fstream-h, que incluye al iostream-h, por lo que ya no será necesario incluir este último. »

Estoy mirándome este tema de programación. Si le hago caso al libro y excluyo del código de arriba el archivo de cabecera iostream (tal y como indica el libro):

#include <fstream>
const int kTAM=99;
using namespace std;
 
int main() {
   [ ... ]

E intento compilar así:

$ g++ 0a99.cpp
0a99.cpp: In function `int main()â??:
0a99.cpp:13: `coutâ?? undeclared (first use this function)
0a99.cpp:13: (Each undeclared identifier is reported only once
   for each function it appears in.)
0a99.cpp:14: `cinâ?? undeclared (first use this function)
$

Osea… que por lo visto iostream no está incluído en fstream. Al menos utilizando la version 3.2.2 de GCC. El libro (escrito hace unos cuantos años) utiliza GCC 2.95.

Cuando me entere de un modo seguro del por qué de esto, pondré un comentario en este post para acordarme jeje. (Y si sabes tu el por qué de esto… no te cortes y ¡¡ sacame de dudas !!)

post.close(); // Sayonara baby!