Cuando un programa Linux escrito en C se ejecuta, comienza con la función main. En estos el main es:
int main(int argc, char*argv[])
donde argc es un rencuentro de los argumentos del programa y argv es un array de cadena de caracteres que representa a los propios argumentos.
Nota: Hay también programas en C para Linux que simplemente declaren main como main(). Esta opción también es válida, porque el tipo de retorno será, por defecto, int y los parámetros formales que no se usen en una función han de ser declarados. argc y argv siguen ahí, pero si no los declara, no podrá usarlos.
Siempre que el sistema operativo inicia un nuevo programa, los parámetros argc y argv se establecen y se transmiten a main. Dichos parámetros los suelen proporcionar otros programas, a menudo la shell que ha pedido que el sistema operativo inicie el nuevo programa. La shell adopta la línea de comando proporcionada, la divide en palabras individuales, y las usa para la matriz argv. Recuerde que una shell Linux suele ejecutar la expansión con comodines de los argumentos del nombre de archivo antes de que acepten los argumentos con comodines y a que ejecuten su propia expansión con comodines.
Por ejemplo, si proporcionamos a la shell el siguiente comando:
~$ MiPrograma izquierda derecha 'y centro'
el programa MiPrograma comenzará en main con parámetros:
argc: 4
argv: {"MiPrograma", "izquierda", "derecha", "y centro"}
Hay que tener en cuenta que el recuento de argumentos incluye el nombre del propio programa y la matriz argv contiene el nombre del programa como primer elemento, argv[0]. Como usamos comillas en el comando shell, el cuarto argumento está compuesto por una cadena con espacios.
Los argumentos de la línea de comandos son útiles para transmitir información a los programas. Por ejemplo, podría usarlos en una aplicación de base de datos para transmitir el nombre de la base de datos que desea usar, lo cual le permitirá usar el mismo programa en más de una base de datos. Algunos programas de prestación también utiliza los argumentos de la línea de comandos para modificar su comportamiento o para configurar ciertas opciones. Normalmente, configurará los denominados indicadores o los intercambiadores usando argumentos de línea de comandos que contienen un guión. Por ejemplo, el programa sort adopta un intercambiador para invertir el orden normal:
~$ sort -r archivo
Las opciones de línea de comando son muy comunes y si se usa coherentemente le serán de gran ayuda a los usuarios de su programa. Antes, cada programa de prestaciones adoptaba su propio enfoque sobre las opciones de la línea de comando, lo cual generaba cierta confusión. Por ejemplo:
~$ tar cvFB /tmp/archivo.tar 1024
~$ dd if=/dev/fd0 of=/tmp/archivo.dd bs=18k
~$ ps ax
~$ gcc --help
~$ ls -lstr
~$ ls -l -s -t -r
Actualmente se recomienda que los intercambiadores de línea de comandos comiencen con un guión y que estén formados por una única letra o número. Si fuese necesario, las opciones que no adoptan más argumentos se pueden agrupar tras un solo guión.
La especificación X/Open (disponible en: http://opengroup.org/) d0efine un uso estándar para las opciones de línea de comando (Utility Sintax Guideline) así como una interfaz de programación estándar para proporcionar intercambiadores de línea de comandos en los programas C. También definido por los estándares GNU.
Como en el caso de los ejemplos ls que cumplen las pautas de actuación. Cada opción debería ir seguida por cualquier valor necesario a modo de argumento independiente.
~$ ls -lstr
~$ ls -l -s -t -r
El ejemplo dd rompe nuestra regla usando opciones multi-carácter que no comienzan con guiones.
~$ dd if=/dev/fd0 of=/tmp/archivo.dd bs=18k
El ejemplo tar separa las opciones y sus valores por completo.
~$ tar cvFB /tmp/archivo.tar 1024
Es aconsejable añadir nombres de intercambio más largos y con mayor significado a modo de alternativa para las versiones de caracteres únicos y usar un guión doble para distinguirlos. Podemos usar -h y --help como opciones para obtener ayuda.
~$ gcc --help
Otra pequeña debilidad de algunos programas es hacer que la opción +x (por ejemplo) ejecute la función contraria a -x. Podemos usar set -o xtrace para configurar el trazado de ejecución de la shell, y set +o xtrace para desactivarlo.
Como podemos imaginar, recordar el orden y el significado de todas estas opciones de programas es bastante difícil ya, sin tener que preocuparse de los formatos idiosincráticos. A menudo, la única opción es usar la opción -h (ayuda) o una página man si el programador la proporciona.
A continuación presentamos el programa argumentos.c, que examina sus propios argumentos:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int arg;
for (arg = 0; arg < argc; arg++) {
if(argv[arg][0] == '-'){
printf("opcion: %s\n", argv[arg]+1);
} else {
printf("argumento: %d: %s\n",arg, argv[arg]);
}
}
exit(0);
}
Compilamos:
$ gcc argumentos.c -o argus
Cuando ejecutemos este programa, mostrará únicamente sus argumentos y detectará la presencia de opciones. La intención es que el programa adopte un argumento de cadena y un argumento de nombre de archivo opcional introducido por una opción -f.
También podemos definir otras opciones.
$ ./argus -i -lr -a 'hola amigo' -a 'nos vemos en' -f salida.txt argumento: 0: ./argus opcion: i opcion: lr opcion: a argumento: 4: hola amigo opcion: a argumento: 6: nos vemos en opcion: f argumento: 8: salida.txt
El programa usa únicamente el cómputo de argumentos argc, para configurar un bucle que examine todos los argumentos del programa.
for (arg = 0; arg < argc; arg++) {Detecta la presencia de opciones buscando un guión inicial.
if(argv[arg][0] == '-'){Podemos realizar unas pequeñas modifiaciones para que realice acciones diferentes para cada opciones del programa. Por Ejemplo:
#include <stdio.h>
#include <stdlib.h>
#include <string.h> int main(int argc, char *argv[])
{
int arg;
char texto[512];
char archivo[50];
int flagArchivo = 0;
int flagAdd = 0; for (arg = 1; arg < argc; arg++) {
if(argv[arg][0] == '-'){
switch (argv[arg][1]) {
case 'i':
printf("Programa: %s\n", argv[0]);
break;
case 'l':
printf("La cantidad de opciones pasadas es de: %d\n", argc-1);
break;
case 'a':
arg++;
strcat( texto, " " );
strcat( texto, argv[arg] );
flagAdd = 1;
break;
case 'f':
arg++;
strcpy( archivo, argv[arg] );
flagArchivo = 1;
break;
default:
printf("Parametro %s no soportado\n", argv[arg]);
break;
}
}
} if(flagArchivo==1){
printf("Se guardaria toda la informacion en: %s\n", archivo);
} if(flagAdd==1){
printf("Los datos agregados quedaron de la siguiente manera: %s\n", texto);
}
exit(0);
}
Ejecutando el programa quedaría algo así:
$ ./argumentos -i -l -a 'hola amigo' -a 'nos vemos en otro lado' -f salida.txt
Programa: ./argumentos
La cantidad de opciones pasadas es de: 8
Se guardaria toda la informacion en: salida.txt
Los datos agregados quedaron de la siguiente manera: hola amigo nos vemos en otro lado
De esta forma se ve el funcionamiento básico del uso de parámetros del programa. Cabe aclarar que hay funciones preestablecidas para el uso de estas opciones que podremos ver mas adelante.
post
ResponderBorrar