c++ - que - ¿Por qué tipo de datos es necesario en la declaración de puntero?

punteros y arreglos en c

Question

Por lo que sé sobre el tipo de datos , al declarar una variable, necesitamos declarar su tipo de datos, lo que le dice al compilador que reserve la cantidad de bytes en la memoria en consecuencia.

Pero en el caso de los punteros , sabemos que su tamaño es siempre de 2 bytes (en Turbo Compiler), independientemente del tipo de datos de la variable a la que apunta.

Mi pregunta es: si los punteros siempre toman 2 bytes , ¿cuál es la necesidad de mencionar el tipo de datos al declararlos? O ¿Mi comprensión acerca de los punteros es incorrecta?

Answer 1

El problema no se trata del tamaño del puntero sino de la eliminación de referencias del puntero. (ya sea en C o C ++)

Di que tienes:

int* someint;
float* somefloat;

*someint referencia a un tamaño de memoria de sizeof(int) , mientras que *somefloat referencia a un tamaño de memoria de sizeof(float) que son diferentes.

Answer 2

El tamaño que necesita un puntero depende del sistema que esté utilizando. En un sistema x86_64 , el tamaño del puntero podría ser de 64 bits.

La razón por la que necesita el tipo de datos para los punteros es porque el compilador tiene que saber cuál es el tamaño de la celda de memoria, entre otros, al que apunta el puntero. Tampoco se puede garantizar el tipo de seguridad sin el tipo. Además, tendría que encasillar todos los punteros al acceder a las estructuras desde el puntero.

También puedes usar un puntero de void y hacer todo a mano. Pero ¿por qué debería querer eso?

Answer 3

El tipo de datos de un puntero es necesario en dos situaciones:

1. Diferir el puntero
2. Aritmética de punteros

¿Cómo se usa para desreferenciar el puntero ?
Considere el siguiente ejemplo:

    {
        char *k; //poniter of type char
        short j=256;
        k=&j;    // Obviously You have to ignore the warnings
        printf("%d",*k)
    }

Ahora porque k es de tipo char por lo que solo leerá un byte. Ahora el valor binario de 256 es 0000000100000000 pero como k es de tipo char entonces solo leerá el primer byte, por lo tanto, la salida será 0.
Nota : si asignamos j = 127, la salida será 127 porque 127 se mantendrá en primer byte.

Ahora ven a la aritmética de punteros :
Considere el siguiente ejemplo:

    {
        short *ptr;
        short k=0;
        ptr=&k;
        k++;
        ptr++;// pointer arithmetic
    }

¿Las afirmaciones k++ y ptr++ son lo mismo? No, k++ significa k=k+1 y ptr++ significa ptr=ptr+2 . Debido a que el compilador "sabe" esto es un puntero y que apunta a un corto, agrega 2 a ptr en lugar de 1, por lo que el puntero "apunta" al siguiente entero.

Para más información consulte el segundo capítulo de this tutorial.

Answer 4

El tipo de datos es necesario al desreferenciar el puntero para que sepa cuántos datos debe leer. Por ejemplo, al anular la referencia de un puntero de caracteres debe leer el siguiente byte de la dirección a la que apunta, mientras que un indicador de int debe leer 2 bytes.

Answer 5

En primer lugar, el tamaño y la representación de los punteros en sí mismos no siempre son los mismos para los diferentes tipos . Es solo algo que sucede en muchas implementaciones.

En segundo lugar, al utilizar punteros, no le importa el tamaño de los punteros en sí. Necesitas el tamaño del tipo puntiagudo .

Por ejemplo, prueba esto:

int var[5];
char *c = (char *)var;
int  *x = var;

printf("%p/n%p/n", p + 1, x + 1);

Verá que la aritmética de punteros depende en gran medida del tamaño del tipo puntiagudo.

Answer 6

Los tipos de datos son necesarios simplemente para la verificación de tipos.

Answer 7

Supongamos que este código se compila sin error (como le gustaría):

int a;
int b = 42;
void * d = &b;

a = *d;

¿Cuál debería ser el valor de un?

Ahora con este:

int a;
float b = 42.0;
void * d = &b;

a = *d;

¿Qué esperas en un?

En realidad, el tipo especifica cómo debe interpretarse el área puntiaguda. Debe especificar int * en el primer ejemplo y float * en el segundo, en lugar de void * .

Answer 8

es el concepto de una tipificación fuerte utilizada en c ++. el tamaño del puntero puede ser el mismo pero el tamaño del tipo puntiagudo puede diferir. Sin embargo, siempre puede convertir un puntero de un tipo en un puntero de otro tipo.