La copia de Argumentos de Línea de Comandos En una Matriz

Para un programa, me gustaría hacer una matriz copia de los argumentos enviados por línea de comandos mediante malloc().

Así, por ejemplo, si yo hago ./una.uno, dos, tres
Quiero una matriz con {a.fuera, uno, dos, tres} en ella.

Sin embargo, tengo algunos problemas para conseguir mi programa de trabajo. He aquí lo que tengo:

static char** duplicateArgv(int argc, char **argv)                                                                                                                                                         
{                                                                                                                                                                                                                                                                                                                                                                                       
    char *array;                                                                                                                                                                                                                                                                                                                                                               
    int j = 0;                                                                                                                                                                                        

    //First allocate overall array with each element of char*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           
    array = malloc(sizeof(char*) * argc);                                                                                                                                                       
    int i;                  

    //For each element allocate the amount of space for the number of chars in each      argument                                                                                                                                                              
    for(i = 1; i < (argc + 1); i++){                                                                                                                                                                      
        array[i] = malloc(strlen(*(argv + i)) * sizeof(char));                                                                                                                                        
        int j;       

        //Cycle through all the chars and copy them in one by one                                                                                                                                                                                 
        for(j = 0; j < strlen(*(argv + i)); j++){                                                                                                                                                     
            array[i][j] = *(argv + i)[j];                                                                                                                                                                                                                                                                                                                                                       
        }                                                                                                                                                                                             

    }                                                                                                                                                                                                 

    return array;

}

Como se puede imaginar, esto no funciona. Me disculpo de antemano si esto de alguna manera totalmente no tiene sentido, como acabo de empezar a aprender acerca de los punteros. También, no estoy muy seguro de cómo escribir código para liberar cada elemento en la *matriz después de hacer lo que se necesita para la copia.

Alguien podría darme algunos consejos sobre lo que debe buscar en que es hacer lo que quiero?

Gracias por la ayuda!

InformationsquelleAutor Matt | 2011-10-13

3 Comentarios

3

No eres la asignación o copiar el NULO de terminación caracteres:

Esta línea debe ser cambiado por el valor NULL.
```
array[i] = malloc((strlen(*(argv + i)) + 1) * sizeof(char));   
```
Y el bucle debe ser cambiado a esto:
```
for(j = 0; j <= strlen(*(argv + i)); j++){ 
```
También, el código puede estar mejor optimizado si usted guarda el resultado de la strlen() llame ya llame en tantos lugares.

Probar el circuito como este:
```
//For each element allocate the amount of space for the number of chars in each argument
for(i = 0; i < argc; i++){

    int length = strlen(argv[i]);

    array[i] = malloc((length + 1) * sizeof(char));
    int j;

    //Cycle through all the chars and copy them in one by one
    for(j = 0; j <= length; j++){
        array[i][j] = argv[i][j];
    }

}
```
- Traté de imprimir con while(*array){printf(«%s», *matriz++);}, pero no veo ninguna salida (me da un seg culpa). Hmm…
- Usted también necesita cambiar char *array; a char **array; Es que todavía no funciona?
- Sí que he cambiado que
- He pasado por alto una cosa más: el bucle de indización debe comenzar desde 0 y no 1. He editado en la respuesta.
- He cambiado y funciona. Muchas gracias! Sin embargo, me pregunto por qué usted utiliza argv[i][j] y la función strlen(argv[i]) en lugar de la función strlen(*(argv +i))? Pensé que las expresiones son equivalentes.
- Hice ese cambio, porque yo no estaba seguro de la precedencia entre * y []. Luego he copiado y pegado donde lo he encontrado.
- EDITADO: no importa yo veo lo que estás diciendo. Gracias de nuevo por toda su ayuda!
- Había *(argv + i)[j]. No estaba seguro de si sería analiza como (*(argv + i))[j] o *((argv + i)[j]). Y eso hace la diferencia en este caso.
- permítanos continuar esta discusión en el chat
InformationsquelleAutor Mysticial

primer lugar usted necesita para asignar un vector de tipo char*, no sólo un char*

char **array;

array = malloc(sizeof(char*)*(argc+1)); //plus one extra which will mark the end of the array

ahora usted tiene una array[0..argc] de char* punteros

a continuación, para cada uno de los argumentos que usted necesita para asignar espacio para la cadena

int index;
for (index = 0; index < argc; ++index)
{
   arrray[index] = malloc( strlen(*argv)+1 ); //add one for the int index;
for (index = 0; index < argc; ++index)
{
arrray[index] = malloc( strlen(*argv)+1 ); //add one for the \0
strcpy(array[index], *argv);
++argv;
}
array[index] = NULL; /* end of array so later you can do while (array[i++]!=NULL) {...} */
   strcpy(array[index], *argv);
   ++argv;
}
array[index] = NULL; /* end of array so later you can do while (array[i++]!=NULL) {...} */

InformationsquelleAutor Anders

0

Con
```
char *array;
```
de definir un objeto de tipo char*. Que es: un objeto cuyo valor puede apuntar a una char (y el siguiente char, …, …)

Necesita
```
char **array;
```
Con este nuevo tipo, el valor de array puntos a un char*, es decir, otro puntero. Usted puede asignar memoria y guardar la dirección de memoria asignada en un char*, usted no haría eso con una char.
- Gracias por señalarlo, que pasé por alto esto.
InformationsquelleAutor pmg

3 Comentarios

Dejar respuesta Cancelar respuesta