Incrementando punteros C

Question

Pensé que si se incrementaba un puntero c apuntando a una matriz char, apuntaría al siguiente elemento en esa matriz. Pero cuando probé esto, descubrí que tenía que incrementarlo dos veces. Probando el incremento usando sizeof (char) encontré que agregar el tamaño de un char era demasiado, así que tenía que dividirse por dos.

#include <stdio.h> 

int main(int argc, char * argv[]){ 
    char *pi; 
    int i; 
    pi = argv[1]; 
    printf("%d args.\n",argc-1); 
    printf("input: "); 
    for(i=0;i<argc-1;i++){ 
     printf("%c, ",*pi); 
     /*The line below increments pi by 1 char worth of bytes */ 
     //pi+=sizeof(pi)/2; 
     /* An alternative to the above line is putting pi++ twice - why? */ 
     pi++; 
     pi++; 
    } 
    printf("\n"); 
    return 0; 
} 

¿Hago algo mal? o estoy malentendiendo el método de incremento de punteros?

Answer 1

Si usted tiene un puntero de tipo ptrT* y se agrega N, el puntero se adelantará por N * sizeof (*ptr) o equivalente N * sizeof (T) bytes. Simplemente olvidó desreferenciar pi. Entonces, lo que obtuviste con sizeof (pi) fue el tamaño de char*, pero no el tamaño de char. Su línea era equivalente a pi+=sizeof(char*)/2; Los punteros en su plataforma tienen 4 bytes de tamaño. Por lo tanto, en efecto, lo hizo pi+=2;. Escriba pi+=2 si desea incrementar 2 veces. Tenga en cuenta que char tiene un tamaño de 1 por definición. No necesita hacer sizeof (char), siempre es 1.

Answer 2

sizeof (char) se garantiza que es 1, pero sizeof (char *) no lo es.

Sin embargo, su función solo funciona por accidente.

Por ejemplo, trate de llamar con los siguientes parámetros:

abc defg 

Esto dará lugar a:

2 args. 
input: a, c, 

que es simplemente erróneo. El problema es que está incrementando un puntero al elemento 1 de argv en lugar de un puntero a argv.

Prueba esto:

#include <stdio.h> 

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

    pi = argv + 1; 
    printf("%d args.\n",argc-1); 
    printf("input: "); 
    for(i=0;i<argc-1;i++){ 
     printf("%c, ",**pi); 
     pi++; 
    } 
    printf("\n"); 
    return 0; 
} 

Esto imprimirá el primer carácter de cada argumento:

2 args. 
input: a, d, 

Answer 3

sizeof (pi) está devolviendo el tamaño de (char *), que es el tipo de pi (un puntero, probablemente dos, cuatro u ocho bytes). sizeof (char) devolverá 1.

Sin embargo, otra cosa para entender es que cada vez que incremente un puntero por un número (p. ej .: pi + = sizeof (char); pi ++; etc.) está incrementando el puntero el tamaño de la base de todos modos. Por lo tanto:

int *ipointer = &int_array[0]; 
ipointer += 2; 

realmente incrementar ipointer por 2 veces sizeof int.

Otra cosa que parece estar haciendo mal es señalar pi en el primer argumento, y luego recorrer todos los argumentos. Si desea colocar a través de los argumentos, intentar algo como esto:

for (i = 1; i < argc; i++) { 
    pi = argv[i]; 
    // ... do something with pi 
}