c++ - significa - parametros por linea de comandos c

¿Qué es char*const argv[]?

Question

Estoy estudiando la programación de linux C ++ cuando veo

int execve(const char *path,
           char *const argv[],
           char *const envp[]);

No entiendo qué es char *const argv[] . Sé que char *const foo es un puntero constante para char. Y const char *foo es un puntero a un const char. Pero, ¿qué es char *const argv[] ?

¿Es una serie de punteros de const para char o una variedad de punteros para const char?

Y ahora tengo un vector<string> , ¿cómo convertirlo a char *const argv[] ?

Answer 1

// says: argv is a constant pointer pointing to a char*
int main(int c, char *const argv[]);

No podrá cambiar "argv" dentro de la función.

Como acaba de aprender C, le recomiendo que realmente intente comprender las diferencias entre las matrices y los punteros primero en lugar de las cosas comunes.

En el área de parámetros y matrices, hay algunas reglas confusas que deberían ser claras antes de continuar. Primero, lo que declaras en una lista de parámetros se trata de manera especial. Hay situaciones en las que las cosas no tienen sentido como un parámetro de función en C. Estas son

• Funciones como parámetros
• Arrays como parámetros

Arrays como parámetros

El segundo quizás no esté inmediatamente claro. Pero queda claro cuando se considera que el tamaño de una dimensión de matriz forma parte del tipo en C (y una matriz cuyo tamaño de dimensión no se proporciona tiene un tipo incompleto). Por lo tanto, si crea una función que toma un valor por orden de matriz (recibe una copia), ¡podría hacerlo solo para un tamaño! Además, las matrices pueden volverse grandes y C intenta ser lo más rápido posible.

En C, por estos motivos, los valores de matriz no existen. Si desea obtener el valor de una matriz, lo que obtiene en su lugar es un puntero al primer elemento de esa matriz. Y aquí en realidad ya se encuentra la solución. En lugar de dibujar un parámetro de matriz no válido por adelantado, un compilador de C transformará el tipo del parámetro respectivo para que sea un puntero. Recuerda esto, es muy importante. El parámetro no será una matriz, sino que será un puntero al tipo de elemento respectivo.

Ahora, si intenta pasar una matriz, lo que se pasa es un puntero al primer elemento de la matriz.

Excursión: funciones como parámetros

Para completarlo, y porque creo que esto te ayudará a comprender mejor el asunto, veamos cuál es el estado de las cosas cuando tratas de tener una función como parámetro. De hecho, primero no tendrá ningún sentido. ¿Cómo puede un parámetro ser una función? Huh, queremos una variable en ese lugar, por supuesto! Entonces, lo que hace el compilador cuando eso sucede es, una vez más, transformar la función en un puntero de función. Intentar pasar una función pasará un puntero a esa función respectiva. Por lo tanto, los siguientes son los mismos (análogos al ejemplo de matriz):

void f(void g(void));
void f(void (*g)(void));

Tenga en cuenta que se necesitan paréntesis alrededor de *g . De lo contrario, se especificaría una función que devuelve void* , en lugar de un puntero a una función que devuelve void .

De vuelta a las matrices

Ahora, dije al principio que las matrices pueden tener un tipo incompleto, lo que sucede si aún no se da un tamaño. Como ya pensamos que un parámetro de matriz no existe, sino que cualquier parámetro de matriz es un puntero, el tamaño de la matriz no importa. Eso significa que el compilador traducirá todo lo siguiente, y todos son lo mismo:

int main(int c, char **argv);
int main(int c, char *argv[]);
int main(int c, char *argv[1]);
int main(int c, char *argv[42]);

Por supuesto, no tiene mucho sentido ser capaz de poner cualquier tamaño en él, y simplemente se descarta. Por esa razón, C99 tuvo un nuevo significado para esos números, y permite que aparezcan otras cosas entre los corchetes:

// says: argv is a non-null pointer pointing to at least 5 char*''s
// allows CPU to pre-load some memory. 
int main(int c, char *argv[static 5]);

// says: argv is a constant pointer pointing to a char*
int main(int c, char *argv[const]);

// says the same as the previous one
int main(int c, char ** const argv);

Las últimas dos líneas dicen que no podrá cambiar "argv" dentro de la función, se ha convertido en un puntero const . Sin embargo, pocos compiladores C admiten esas características C99. Pero estas características dejan en claro que la "matriz" no es en realidad una. Es un puntero.

Una palabra de advertencia

Tenga en cuenta que todo lo que dije arriba es verdadero solo cuando tiene una matriz como parámetro de una función. Si trabaja con matrices locales, una matriz no será un puntero. Se comportará como un puntero, porque como se explicó anteriormente, una matriz se convertirá en un puntero cuando se lea su valor. Pero no se debe confundir con punteros.

Un ejemplo clásico es el siguiente:

char c[10]; 
char **c = &c; // does not work.

typedef char array[10];
array *pc = &c; // *does* work.

// same without typedef. Parens needed, because [...] has 
// higher precedence than ''*''. Analogous to the function example above.
char (*array)[10] = &c;

Answer 2

¿Es una serie de punteros de const para char o una variedad de punteros para const char?

Leer tipos de derecha a izquierda:
const siempre se une a la izquierda (a menos que esté a la izquierda)

char *const argv[]

                ^^ Array of
      ^^^^^        const
     ^             pointer to
^^^^               char

Una matriz de "const pointer" para char

Por lo tanto, los punteros del conjunto no se pueden modificar.
Pero lo que señalan puede ser modificado.

Nota: Como lo señala Steve a continuación. Porque esto se está utilizando como un parámetro. De hecho, se descompone en un puntero "A puntero "const pointer" a "char" o "char * const *".

Y ahora tengo un vector <string>, ¿cómo convertirlo a char * const argv []?

int execve(const char *path,
       char *const argv[],
       char *const envp[]);

int main()
{
    std::vector<std::string>   data;  /// fill
    std::vector<char*>         argv;
    std::vector<char*>         envp;

    for(std::vector<std::string>::iterator loop = data.begin(); loop != data.end(); ++loop)
    {
        argv.push_back(&(*loop)[0]);
    }

    // I also bet that argv and envp need to be NULL terminated
    argv.push_back(NULL);
    envp.push_back(NULL);
    execve("MyAppName", &argv[0], &envp[0]);
}

Answer 3

cdecl.org dice:

char *const argv[]

declarar argv como una matriz de const pointer a char