Valor de un puntero es la dirección de una variable. Por qué el valor de un int pointer aumentó de 4 bytes después de la int puntero se incrementa en 1.

En mi opinión, creo que el valor de puntero(dirección de la variable) sólo aumentará en 1 byte después de puntero de incremento.

El código de la prueba:

int a = 1, *ptr;
ptr = &a;
printf("0x%X\n", ptr);
ptr++;
printf("0x%X\n", ptr);

Resultado esperado:

0xBF8D63B8
0xBF8D63B9

Realidad de salida:

0xBF8D63B8
0xBF8D63BC

EDITAR:

Otra pregunta – ¿para visitar los 4 bytes de un int ocupa uno por uno?

InformationsquelleAutor Jason | 2011-04-10

6 Comentarios

  1. 97

    Al incremento de un T*, se mueve sizeof(T) bytes. Esto es debido a que no tiene sentido para mover cualquier otro valor: si estoy apuntando a un int que es de 4 bytes de tamaño, por ejemplo, ¿cuál sería el incremento de menos de 4 me dejan? Un parcial de int mezclado con algunos otros datos: sin sentido.


    Considerar esto en memoria:

        [↓      ]
    [...|0 1 2 3|0 1 2 3|...]
    [...|int    |int    |...]

    Que tiene más sentido cuando me incrementar ese puntero? Este:

                [↓      ]
    [...|0 1 2 3|0 1 2 3|...]
    [...|int    |int    |...]

    O este:

          [↓      ]
    [...|0 1 2 3|0 1 2 3|...]
    [...|int    |int    |...]

    El pasado no es en realidad un punto de cualquier tipo de int. (Técnicamente, entonces, usando ese puntero es UB.)

    Si realmente desea mover un byte, un incremento char*: el tamaño de char siempre es uno:

    int i = 0;
    int* p = &i;
    
    char* c = (char*)p;
    char x = c[1]; //one byte into an int

    †Un corolario de esto es que usted no puede incremento void*, porque void es un tipo incompleta.

    • «usted no puede incremento void*, porque void es un tipo incompleta» — es cierto, pero gcc soporta aritmética void* como una extensión (lo trata como si fuera char*).
    • «no tiene sentido» para un entero, casi siempre, pero esto tiene el sentido perfecto para situaciones como una matriz de una estructura de longitud variable («tengo un total de búfer de paquetes, quiero mover CurrentPacketPointer para el próximo paquete»).
    • «Si usted realmente desea mover un byte, el incremento de un char*: el tamaño de char es siempre un» no, no es siempre uno, usted debe utilizar uint8_t lugar.
    • siempre es uno. No siempre puede ser de 8 bits, pero siempre es de 1 byte. En C y C++, un byte es la más pequeña unidad direccionable, que no es necesariamente siempre de 8 bits.
    • Mi mal, está totalmente a la derecha.
    • No se preocupe. Él es una buena idea de los tipos de uso, tales como (u)intN_t cuando se desea un diseño específico, tal como un byte de 8 bits. 🙂

  2. 8

    Puntero incremento se basa en el tamaño del tipo señalado. Si un entero de 4 bytes, el incremento de un int* por 1 va a aumentar su valor por la 4.

    Si el corto es de 2 bytes, el incremento de un corto* 1 va a aumentar su valor por 2.

    Este es el comportamiento estándar de C aritmética de punteros.

    • Creo que pregunta por el fundamento.
    • Esperemos que esta claro que la razón de ser es la aritmética de punteros siempre trabaja en las unidades de la pointee del tipo de tamaño.
    • Justificación sería porque que es el caso.
  3. 3

    Punteros se aumenta el tamaño del tipo que elija, si los puntos de puntero a char, pointer++ se incrementará puntero por 1, si apunta a un 1234 bytes struct, pointer++ incrementará el puntero por 1234.

    Esto puede ser confuso la primera vez que lo cumpla, pero en realidad es hacer un montón de sentido, esto no es una característica de procesador, pero el compilador calcula que durante la compilación, así que cuando usted escribe pointer+1 el compilador compila como pointer + sizeof(*pointer)

  4. 1

    La idea es que después de incremento, el puntero apunta a la siguiente int en la memoria. Desde enteros de 4 bytes de ancho, que se incrementa en 4 bytes. En general, un puntero a tipo T se incrementará por sizeof(T)

  5. 1

    Como usted ha dicho, un int pointer puntos a un int. Un int generalmente ocupa 4 bytes y por lo tanto, al incrementar el puntero que apunta a la «siguiente» int en la memoria – es decir, un incremento del 4 bytes. Actúa de esta manera para cualquier tamaño de tipo. Si usted tiene un puntero a tipo A, entonces el incremento de un A* incrementará por sizeof(A).

    Pensar – si sólo se incrementa el puntero de 1 byte, que apuntará a una media de un int y no puedo pensar en una oportunidad en la que se desea hacer esto.

    Este comportamiento es muy cómodo cuando se itera sobre una matriz, por ejemplo.

  6. 0

    Un puntero puntos en el COMIENZO de algo en la memoria. Un INT ocupa 4 bytes (32 bits) y un DOBLE ocupa 8 bytes (64 bits) en la memoria. Así que si usted tiene un DOBLE número almacenado, y usted desea en un nivel muy bajo apuntando a la siguiente posición de memoria, el puntero wooud ser aumentado por 8 bytes. Si por alguna razón usted señaló en +4bytes desde el inicio de un DOBLE valor, que podría dañar su valor. La memoria es un muy gran terreno llano que no tiene conciencia de sí mismo, por lo que es hasta que el software se divide adecuadamente, y que «el respeto de las fronteras» de los elementos que se encuentran en ese campo.

Dejar respuesta

Please enter your comment!
Please enter your name here