C++ / argc y argv

Bienvenidos sean a este post, hoy veremos como pasar argumentos mediante la linea de comandos.

Hasta ahora hemos trabajado con codigos simples y los datos a lo sumo los ingresamos mediante cin. Una posibilidad que poseemos es mediante argumentos al momento de llamar al programa. Para poder recibirlos y utilizarlos tenemos a argc y argv, siendo el primero el encargado de almacenar la cantidad de elementos que pasamos en la linea de comandos y el segundo es un array donde estaran estos elementos. Veamos un ejemplo simple:

#include <iostream>

int main(int argc, char **argv)
{
        int i;
        for(i = 0; i < argc; i++)
        {
                std::printf("Valor %d: %s\n", i, argv[i]);
        }
        std::cout << "argc: " << argc << std::endl;
        return 0;
}

La primera novedad si vienen de posts anteriores son los argumentos que agregamos en el main. Estos son los comentados anteriormente, siendo argc de tipo int porque almacena solo la cantidad de elementos informados y el segundo sera un array de tipo char para almacenar todos los parametros que pasemos como argumentos en este. En el codigo primero declaramos una variable que usaremos para el siguiente bucle. En este pasaremos por todos los elementos del array y mostraremos a cada uno de ellos. Para ello usaremos a printf y en este mostraremos el valor de i en cada pasada y el de cada posición del array, sobre esta funcion hablamos en este post, y una vez finalizado el bucle mostraremos el valor de argc. Compilemos y veamos como trabaja:

$ ./args arg_1 arg_2 arg_3 arg_4
Valor 0: ./args
Valor 1: arg_1
Valor 2: arg_2
Valor 3: arg_3
Valor 4: arg_4
argc: 5
$

Siempre el primer argumento el nombre del programa, por lo tanto todas las opciones que le pasen deben tomarla desde la posicion 1. Otro detalle, los nombres de estas dos variables no son obligatorias pero se los denomina de esta manera por convencion, pero podemos usar los que se ajusten mejor a nuestra necesidad. Vamos a tomar uno de los ejemplos que vimos en el post anterior y vamos a modificarlo de la siguiente manera:

#include <fstream>
#include <iostream>

int main(int paramc, char **paramv)
{
        char texto[255];
        if (paramc < 2)
        {
                std::printf("Uso: %s nombre_archivo [texto]\n", paramv[0]);
                return 1;
        }
        std::ofstream abrir(paramv[1]);
        if (paramc < 3)
        {
                std::cout << "Ingresa un texto: ";
                std::cin.getline(texto,255);
                abrir << texto << std::endl;
        } else {
                abrir << paramv[2] << std::endl;
        }
        abrir.close();

        std::ifstream leer(paramv[1]);
        char ch;
        while(leer.get(ch))
                std::cout << ch;
        leer.close();
        return 0;
}

Este codigo se encarga de crear un archivo, ingresarle un texto, abrirlo y mostrarlo. La primera modificacion fue agregar los argumentos para recibir los de la linea de comandos. Observen que se usan los mismos tipos pero les asigne otro nombre. Tenemos una variable para almacenar un texto, ya veremos porque, y un condicional donde verificamos si la cantidad de argumentos informados es menor a 2. En caso de cumplirse significa que solo pasamos el programa, si esto es asi devolvemos un mensaje para indicar el uso del mismo. Para generalizarlo, use a printf donde usaremos el nombre del programa mediante la primera posición y asi sin importar el nombre del archivo siempre lo mostrará correctamente. Despues pasamos un return 1 para indicar que esto fue un error. En caso de no cumplirse procede a usar a ofstream para crear un nuevo archivo con el nombre informado. Volvemos a chequear los parametros pasados. En este caso si es menor a 3 entendemos que solo se paso el nombre del archivo. Por lo tanto, pedimos que ingresen un texto y este lo escribiremos en el archivo. En caso contrario, procedemos a usar el valor recibido y lo escribimos en el archivo.

Luego simplemente abrimos el archivo tomamos el contenido y lo mostramos. Sobre esto hablamos en el post anterior. Con esto comentado, compilemos y veamos como trabaja:

$ ./archivo
Uso: ./archivo nombre_archivo [texto]
$

Observen que sucedio lo comentado al inicio, si lo pasamos sin argumento nos informa como usarlo y procede a salir del programa. Vamos a ejecutarlo de la siguiente manera:

$ ./archivo texto.txt
Ingresa un texto: Este es un texto de prueba
Este es un texto de prueba
$

En este caso le pasamos un nombre de archivo pero sin texto. Esto hizo que se nos muestre una opcion para ingresar un texto. Una vez realizado, lo escribe y luego lo muestra. Finalmente, vamos a ejecutarlo de la siguiente manera:

$ ./archivo texto.txt "Es un nuevo texto"
Es un nuevo texto
$

Ahora le pasamos entre comillas un nuevo texto, esto hara que tome todo el texto entre estas, y una vez ejecutado procede a hacer todo directamente y nos muestra el nuevo contenido del archivo. Este es un uso practico de como aplicar estos argumentos.

En resumen, hoy hemos visto a argc y argv, que son, para que sirven, como se aplican, y unos ejemplos practicos para verlos en accion. Espero les sea de utilidad sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.