C/Visual C - LLAMADAS A PROGRAMAS CON PARAMETROS

necesito un programa que al ser llamado se le pueda dar X cantidad de parametros al final como los comandos usados en el ms-dos (dir, dir/w, dir /s, etc.) ya que tiene que leer la cadena de caracteres que se da al final y reconocerla por lo pronto leerla o meterla en un puntero y despues guardarla en una variable, no se si alguien sepa la instruccion o si tenga el codigo mucho mejor

Hola. A cualquier programa le puedes pasar n-mil parámetros. El chiste, por supuesto, es procesarlos.

int main(int argc, char* argv[])
{
...
}

El parámetro argc de la función main indica cuántos parámetros se le pasaron a la aplicación, mientras que argv es un vector de cadenas de texto, donde cada elemento del vector es un parámetro. Ya solo tendrías que parsear cada uno y darle un significado (es decir, que tu programa responda a algo en cuanto detecte el parámetro indicado.

Saludos.

pero en si el problema es no se como es la cadena que se le pasara ni se tampoco cuantos parametros se le pasaran como podria hacer eso?

de hecho hago algo como esto para ver si hacepta los parametros que le doy pero no me muestra nada al usarlo en el MS-Dos

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

void main(char *llave[])
{
char *llaveg;
llaveg=llave;
printf("%s",llaveg);
printf("\n Fin de el programa");
getch();

}

Es que no puedes hacer llaveg = llave, porque llave es un array de caracteres. Ah, y por cierto, el prototipo de main es inválido. En primera, main regresa "int", no void ni nada más que int. Segundo, solo hay dos prototipos válidos:

int main();
int main(int argc, char* argv[]);

Es decir, sin parámetros o solo con dos parámetros: un int y un vector de cadenas de texto. No puedes ponerte a inventar el número de parámetros de main (¿cómo sabría el sistema operativo cómo llamar a main?).

Este es un ejemplo:

int main(int argc, char* argv[])
{
int i;
for (i = 0; i < argc; i++)
{
printf("Parametro numero %d es: %s", i, argv[i]);
}

return EXIT_SUCCESS;
}

Como ves, cada parámetro es un elemento del array argv. Para recuperarlo, haces lo mismo que con cualquier otro array: argv[0] devuelve el primer elemento, argv[1] devuelve el segundo, argv[n] devuelve el n-eavo.

Espero haya quedado más claro.

Saludos.

si me queda claro pero el problema es que no se sabe cuantos parametros se mandan al main, necesito utilizar un puntero para que lo lea como una extrema cadena, no interesa reconocerla solo capturarla y poderla guardar para usarla despues, el main si puede regresar void pero me interesa mas que pueda capturar la cadena que acompaña a la instruccion

Hola,

mmm, creo que no te estas explicando como toca, o no estas entendiendo lo que te han dicho.

Si es un programa sin parametrizacion posible el prototipo es

void main ();

y si acepta parametros es, como te ha dicho fernando:

int main(int argc, char* argv[])

Si no quieres usar ninguna de esos dos prototipos... no vas a crear ninguna aplicacion funcional.


Cuando dices que "pero el problema es que no se sabe cuantos parametros se mandan al main", segun tu propio ejemplo del "dir" cuando escribes /p /s etc... en que momento estas diciendo "cuantos" parametros mandas? Simple y directamente los mandas, no? Pues supongo (no estoy seguro de lo que voy a decir ahora) que sera el propio Windows o MS-DOS el que interprete por si solo la linea de comando donde llamas a la aplicacion con sus parametros (los haya o no) y haga lo necesario para mandarle al main del segundo tipo, por un lado, el numero de parametros para "int argc" y por el otro los parametros en si para "char* argv[]"

Hay programas que para parametrizar se usa la " / ", otros que se usa " - " asi que imagino que es el propio sistema operativo el que discrimina los simbolos y le pasa solamente las "letras" de los parametros en si.

Para capturarla... pues si es un array de tipo char*, usalo como tal.
Que quieres imprimir los parametros en la pantalla... los imprimes, que los quieres mandar a otro lado... pues las mandas como harias normalmente con un verctor del mismo tipo declarado por ti. PERO TEN EN CUENTA QUE ES UN CHAR* (PUNTERO).

Si aun asi, sigues sin tener respuesta a lo que pides.... (Sin animo de ofender...) Explicate mejor en el siguiente mensaje. Frases cortas, separando las ideas y usa los signos de puntuacion (comas, parentesis y demas) para facilitar la lectura (la ortografia no es tan importante, si te das cuenta yo pongo casi ningun acento y no tengo enie en el teclado, pero las pausas y demas... si).

No se fernando o el resto de usuarios pero a mi, al menos, me cuesta entender lo que quieres conseguir y el por que las respuestas de fernando (por cierto, bastante concretas y claras) no te han servido.

Ok me explicare mas a fondo,

La idea es tener un programa principal que mande llamar a otro(son 2 ejecutables), el primero le manda parametros al segundo pero no se sabe cuales son, ni que tan larga sea la cadena, el problema no es el primero el primero ya lo tengo manda llamar a un progrma y se le dan los parametros, pero siempre van a cambiar, te cito un ejemplo

programa 1: menu.exe
programa 2: contab.exe

se ejecuta menu y este manda llamar contab de esta manera

contab basculas rebueltas<enter>

aqui tendria yo que leer y capurar la cadena de basculas rebueltas y poderla imprimir otro ejemplo

contab Coca Cola Compani<enter>

aqui cambian los parametros son 3 y no 2, como la cadena cambia al momento de ser llamada necesito guardarla temporalmente y poderla usar depues

creo que asi la idea es un poco mas clara, ahora ya intente usar un puntero char y al momento de mandar llamar contab no me guarda la cadena, pero al asiganrle un valor dentro de el main si me lo muestra, es si mi necesidad es poder capturar esa cadena o parametros despues de mandar llamar el exe y poderlo mostrar es el main que puse en mi anterior comentario pero aun que le doy el puntero no me lo guarda

Ok, trataré de replantear mis explicaciones anteriores.

Dado tu ejemplo:

contab basculas rebueltas

tendrás tres parámetros (cada parámetro, por cierto, es una palabra, entonces "basculas" es el segundo parámetro y "rebueltas" es el tercero), donde el primero es el nombre de tu programa, con directorio incluído (i.e. C:\Programas\contab.exe asumiendo que el programa se ejecuta en el directorio C:\Programas). Entonces argc == 3, y

argv[0] = C:\Programas
argv[1] = basculas
argv[2] = rebueltas

Ojo, todo esto según el estándar. Entonces cuando le pases tres parámetros, como en tu segundo ejemplo:

contab Coca Cola Compani

argc sería igual a 4 y argv tendría en su segunda, tercera y cuarta posición, las cadenas "Coca", "Cola" y "Compani".

Hasta aquí no entiendo cuál es el problema. Para obtener los parámetros, bastaría hacer algo como:

int main(int argc, char* argv[])
{
char TodosLosParametros[500] = "";

for (int i = 1; i < argc; i++)
{
strcat(TodosLosParametros, argv[i]);
printf("Parametro %d: %s", i, argv[i]);
}

printf("El numero de parametros es %d y la cadena de texto de todos los parámetros juntos son %s", argc, TodosLosParametros);

return EXIT_SUCCESS;
}

No sé la verdad qué más explicar al respecto. Espero que haya quedado claro. Si no, quizás estamos confundiendo términos, no sé. Si sigues teniendo dudas, me avisas. Ahora no podré dormir hasta que esto quede claro :P

Saludos.

Dice Nelek:

<<Pues supongo (no estoy seguro de lo que voy a decir ahora) que sera el propio Windows o MS-DOS el que interprete por si solo la linea de comando donde llamas a la aplicacion con sus parametros (los haya o no) y haga lo necesario para mandarle al main del segundo tipo, por un lado, el numero de parametros para "int argc" y por el otro los parametros en si para "char* argv[]">>

Esto es correcto. Precísamente por eso es que no se pueden emplear diferentes prototipos de main. Hay dos y solo dos:

int main();
int main(int argc, char* argv[]);

Como curiosidad. No tengo la certeza de que el estandar ANSI C fuerce a que "main" deba ser "int", quizá simplemente requiera que exista.

De hecho, creo que en todos los compiladores en los que lo he probado (los más habituales) compila correctmente void main() { ... }

Pero insisto, quizá eso no sea conforme con el C ANSI.

El estándar fuerza a que sea int el valor de retorno por lo siguiente. El sistema operativo, así como otros programas, deben saber si el programa se ejcutó correctamente, o hubo algún error. Por ejemplo, cuando Windows detecta un error en el programa, corre un proceso batch para liberar posibles bloques de memoria que hubieran quedado sin finalizar. Claro, en el caso de Windows, éste verifica la finalización de un programa a nivel de hilos, que controla directamente Windows, por lo que el regresar EXIT_SUCCESS y EXIT_FAIL es trivial. Sin embargo, sistemas operativos (como Minix por ejemplo) sí dependen de obtener este valor de retorno para realizar diversas operaciones. Y ANSI / ISO C/C++ se adhieren a esto.

El C de K&R (Kernighan y Ritchie) no especifica el tipo de valor de retorno de main. Por compatibilidad con versiones viejas de C, muchos compiladores aceptan el "void main". Además, también lo hacen porque posiblemente el sistema operativo hace caso omiso de estos valores.

Pero ANSI / ISO C/C++ son claros al respecto.