¿Qué int argc, char *argv[] significa?

En muchos C++ IDE de programación y compiladores, cuando se genera la función principal para la que, se parece a esto:

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

Cuando me de código C++ sin un IDE, sólo que con un compilador de línea de comandos, de tipo:

int main()

sin parámetros. ¿Qué significa esto, y es de vital importancia para mi programa?

Si el programa se va a ignorar los argumentos de línea de comandos, entonces lo que escribes está muy bien. Si el programa necesita para procesar argumentos de línea de comandos, a continuación, el IDE está haciendo la derecha.
Una sugerencia para los hackers: intente declarar int main(int argc, char* argv[], char* envp[]) y la impresión del último argumento. ;)
no es bueno que usted debe enseñar a los novatos a introducir la vulnerabilidad en sus programas 😉
cómo la simple impresión de variables de entorno que conducen a la vulnerabilidad? Sólo que no pase de los tainted cadenas literales a system() llamadas, consultas DB, etc. Como de costumbre, con la entrada del usuario.
Interesante.. se Puede exponer por qué usted no tiene que pasar contaminados cadenas, db consultas, etc. mientras que el uso de char **envp argumento?

OriginalEl autor Greg Treleaven | 2010-06-11

8 Kommentare

  1. 541

    argv y argc son la forma en la línea de comandos que se pasan argumentos a main() en C y C++.

    argc será el número de cadenas de caracteres apuntada por argv. Esto (en la práctica) 1 más el número de argumentos, como prácticamente todas las implementaciones se antepone el nombre del programa a la matriz.

    Las variables se denominan argc (argumento contar) y argv (vector de argumento) por convención, pero que puede ser dada en cualquier identificador válido: int main(int num_args, char** arg_strings) es igualmente válida.

    También pueden omitirse completamente, produciendo int main(), si usted no tiene la intención de procesar argumentos de línea de comandos.

    Tratar el siguiente programa:

    #include <iostream>
    
    int main(int argc, char** argv) {
        std::cout << "Have " << argc << " arguments:" << std::endl;
        for (int i = 0; i < argc; ++i) {
            std::cout << argv[i] << std::endl;
        }
    }

    Correr con ./test a1 b2 c3 de salida será de

    Have 4 arguments:
    ./test
    a1
    b2
    c3
    argc puede ser 0, en cuyo caso argv puede ser NULL. Es permitido por la norma AFAIK. Nunca he oído hablar de un sistema que hace esto en la práctica, pero sin duda podría existir y no violar ninguna de las normas.
    Desde «El valor de argv[argc] será 0″ (C++03 §3.6.1/2), argv no puede ser null.
    C (al menos C99) tiene el mismo requisito.
    Pensé que debería agregar, este es el mismo en la mayoría de los sistemas que hay por ahí, aunque son abstraídos algunas veces. Por ejemplo, en Pascal/Delphi/Lázaro, que se obtiene; ParamStr y ParamCount (si la memoria no me falla, a la derecha). Mi punto es, cuando (si alguna vez) escribir aplicaciones nativas en otros idiomas/sistemas operativos, hay una buena probabilidad de que el anterior se define por su uso, y, funcionan a la perfección el mismo (count/string list) en todos los sistemas que las soportan.
    No, eso es un grave error que probablemente resulta en una violación de segmento. *NULL definitivamente no es igual a NULL.

    OriginalEl autor meagar

  2. 46

    argc es el número de argumentos pasados en su programa desde la línea de comandos y argv es la matriz de argumentos.

    Puede recorrer a través de los argumentos conocer el número de ellos como:

    for(int i = 0; i < argc; i++)
    {
        //argv[i] is the argument at index i
    }

    OriginalEl autor John Boker

  3. 15

    Supongamos que ejecutar el programa, por tanto (por el uso de sh sintaxis):

    myprog arg1 arg2 'arg 3'

    Si se declara su principal como int main(int argc, char *argv[]), entonces (en la mayoría de los entornos), su main() será llamado como si gusta:

    p = { "myprog", "arg1", "arg2", "arg 3", NULL };
    exit(main(4, p));

    Sin embargo, si se declara su principal como int main(), se llamará algo así como

    exit(main());

    y no obtener los argumentos pasados.

    Dos cosas adicionales a la nota:

    1. Estos son los dos únicos estándar mandato de firmas para main. Si una plataforma particular que acepta los argumentos extra o un diferente tipo de retorno, luego de que una extensión y no debe ser invocado en un portátil de programa.
    2. *argv[] y **argv son exactamente equivalentes, por lo que puede escribir int main(int argc, char *argv[]) como int main(int argc, char **argv).
    Si tenemos que ser técnicos, basic.start.main/2 permite explícitamente definida por implementación versiones adicionales de main(), siempre que la aplicación ofrece las dos versiones predefinidas. Así, no exactamente no conformes. El más común es envp, que es tan bien conocido en C y C++ que es, literalmente, la primera entrada en la sección J. 5 (extensiones Comunes) de el C estándar.
    Gracias por la buena pedante @Justin. Respuesta actualizada para ser más correctos.
    lo que si argc<3, se devuelve un error? ¿qué podría salió mal?
    oh, lo siento, esa es una pregunta que tengo 🙂 , lo que será, posiblemente, la razón de que tipo de error?
    Tengo un programa que también han int main(int argc, char *argv[]) que da un error, si es argc<3. lo que posiblemente podría ser la razón? 🙁 no estoy seguro de que así permitir que la pregunta a contestar, ya que su opinión basada en la pregunta 🙂

    OriginalEl autor Toby Speight

  4. 8

    Los parámetros para main representan los parámetros de línea de comandos proporcionado al programa, cuando se inició. El argc parámetro representa el número de argumentos de línea de comandos, y char *argv[] es una matriz de cadenas (punteros a caracteres) en representación de la persona argumentos en la línea de comandos.

    Argv[] siempre ha argv[arg] como un puntero nulo. y Argv[0] es el de siempre (ruta completa)/executableName como una cadena terminada en null
    No necesariamente; argv[0] es lo que el el inicio del programa el programa de C dio como argv[0]. En el caso de Bash, es a menudo (tal vez siempre) la ruta de acceso del ejecutable, pero Bash no es el único programa que ejecuta otros programas. Es permissisble, aunque excéntrico, para usar: char *args[] = { "cat", "/dev/null", "/etc/passwd", 0 }; execv("/bin/ls", args);. En muchos sistemas, el valor visto por el programa como argv[0] será cat, aunque el ejecutable es /bin/ls.

    OriginalEl autor BlueMonkMN

  5. 5

    El primer parámetro es el número de argumentos y el segundo parámetro es una lista de cadenas que representan los argumentos.

    la primera entrada en argv[0] es el nombre del programa, no es un argumento
    Nombre del programa con el programa la ruta de acceso. 😉

    OriginalEl autor Nick Gerakines

  6. 5

    La main función tiene dos parámetros, argc y argv. argc es un número entero (int) parámetro, y es el número de argumentos pasados al programa.

    El nombre del programa es siempre el primer argumento, por lo que habrá al menos un argumento para un programa y el valor mínimo de argc será uno. Pero si un programa tiene dos argumentos, el valor de argc será de tres.

    Parámetro argv apunta a una matriz de tipo string y se llama la vector de argumento. Es una dimensión de matriz de cadena de argumentos de la función.

    OriginalEl autor moshtagh

  7. 2
    int main();

    Esta es una simple declaración. No puede tomar ninguna argumentos de línea de comandos.

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

    Esta declaración se utiliza cuando el programa debe tomar argumentos de línea de comandos. Cuando se ejecuta como tal:

    myprogram arg1 arg2 arg3

    argc, o el Argumento de Contar, se establece en 4 (cuatro argumentos), y argv, o el Argumento de Vectores, se rellenará con la cadena de punteros a «miprograma», «arg1», «arg2», y «arg3». El programa de invocación (myprogram) se incluye en los argumentos!

    Como alternativa, puede utilizar:

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

    Esto también es válido.

    Hay otro parámetro que puede añadir:

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

    La envp parámetro también contiene las variables de entorno. Cada entrada sigue este formato:

    VARIABLENAME=VariableValue

    como este:

    SHELL=/bin/bash    

    Las variables de entorno de la lista terminada en null.

    IMPORTANTE: NO utilice ningún argv o envp valores directamente en las llamadas a system()! Este es un enorme agujero de seguridad como usuarios malintencionados podrían establecer las variables de entorno de línea de comandos y (potencialmente) causar un daño masivo. En general, simplemente no usar system(). Casi siempre hay una solución mejor implementado a través de librerías C.

    OriginalEl autor Adrian Zhang

  8. 1

    Tanto de

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

    son definiciones legales de el punto de entrada para un C o C++ programa. Stroustrup: C++ el Estilo y la Técnica de preguntas frecuentes detalles de algunas de las variaciones son posibles o legales para su función principal.

    Podría poner vacío en… int main() ==> int main(void)… para la compatibilidad y la legibilidad. No sé si todas las versiones anteriores de C permite anular las funciones de haber un vacío de la lista de parámetros en la declaración.
    esto no da la legibilidad de ganancia, y es exactamente equivalente en todos los C++ versiones. Sólo en C esto tiene una diferencia, pero sólo en declaraciones, no en la definición.
    Lo siento, he publicado esto cuando yo estaba aprendiendo C, y yo podría haber leído que en las primeras versiones de C la void es necesario. No me fijé en eso, y ahora sé que es un poco tonto comentario. No puede hacer daño, aunque.
    lo que si argc<3, se devuelve un error? ¿qué podría salió mal?

    OriginalEl autor Chris Becke

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea