Usando punteros para iterar a través de argv

Quiero usar el siguiente código, pero sin indexar la matriz con “[] ​​[]” y sustituirla por punteros

for (int i = 0; i < argc; i++) { for (int j = 0; argv[i][j] != '\0'; j++) { //code } } 

Sé que puede usar punteros para atravesar una matriz, pero no estoy seguro de cómo hacerlo con una longitud indefinida en la segunda matriz, en este caso, la cadena de entrada. Como cada elemento de argv [] puede tener una longitud diferente, quiero asegurarme de que puedo leer correctamente los caracteres y saber cuándo finaliza cada elemento de argv [], y comienza el siguiente.

Espero que sea algo como: (Si el siguiente encabezado a main es incorrecto, por favor dígame).

 int main(int argc, char **argv) { for (int i = 0; i < argc; i++) { while(argv != '\0') { //code *argv+1; } //to skip null character argv+1; } } 

Ya que for loop permite cualquier tipo de valores, no necesariamente enteros para su “índice de bucle”, su bucle podría reescribirse así:

 for (char **a = argv ; a != argv+argc ; a++) { for(char *p = *a ; *p != '\0' ; p++) { // code uses *p instead of argv[i][j] } } 

El bucle interno usa p como la variable de bucle, que se incrementa con el p++ regular y se verifica con *p != '\0' . La condición del bucle podría reducirse a *p , por lo que el bucle interno se vería así:

 for(char *p = *a ; *p ; p++) 

Dado que el último elemento en argv es NULL , no necesita indexarlo ni comparar nada con argc si realmente no lo desea.

 int main(int argc, char *argv[]) { for (char **arg = argv; *arg; ++arg) { // for each arg for (char *p = *arg; *p; ++p) { // for each character process(*p); } } } 

*arg será NULL al final de la lista de argumentos, lo cual es falso. *p será '\0' al final de cada cadena, lo cual es falso.

Desde N1256 5.1.2.2.1 / 2

Si se declaran, los parámetros de la función principal obedecerán las siguientes restricciones:

– El valor de argc será no negativo.

– argv [argc] será un puntero nulo.

Sí, puedes iterar a través de argv usando punteros.

El bucle interno le dice a p que apunte al comienzo de argv+i y lo itere hasta que llegue a \0 .

 #include  int main(int argc, char **argv) { int i; char *p; for(i=0; i < argc; i++) { for(p=*(argv+i); *p; p++) printf("%c", *p); printf("\n"); } } 

Si solo está interesado en atravesar los argumentos de cada uno, pero no está interesado en analizar cada carácter, puede hacerlo de manera simple.

 #include  int main(int argc, char **argv) { int i; char *p; for(i=0; i < argc; i++) { printf("Argument position %d is %s\n", i, *(argv+i)); } } 

Puede usar any any_t * para iterar any any_t[] , en este caso:

 int main(int argc, char **argv) { char **i = argv; //iterator of argv char **e = argv + argc; //end of argv for(; i != e; ++i) { char *j = *i; //iterator of *i //condition: *j mean *j != 0 for(; *j; ++j) { printf("%c", *j); } printf("\n"); } return 0; } 

Tenga en cuenta que argv [] es esencialmente una matriz de punteros, lo que significa que a * (argv + i) agregará i * tamaño de puntero a la base addr (en este caso es argv) y lo disuadirá de un puntero a una cadena . Entonces, podrías manipular cada puntero a una cadena a voluntad. El siguiente código es un ejemplo de impresión de todas las cadenas en argv:

 int main(int argc, char *argv[]){ int i; for(i = 0; i < argc; i++) printf("%s\n", *(argv+i)); return 0; }