qué - Implementación del operador sizeof.

sizeof implementation

Question

He intentado implementar el operador sizeof .. Lo he hecho de esta manera ...

#define my_sizeof(x) ((&x + 1) - &x)

Pero siempre terminó dando el resultado como ''1'' para cualquiera de los tipos de datos ...

Entonces lo busqué en Google para esto ... y encontré el código tipificado.

#define my_size(x) ((char *)(&x + 1) - (char *)&x)

Y el código está funcionando si está tipificado: no entiendo por qué ... Este código también está MALDANDO una ESTRUCTURA perfectamente ...

También está trabajando para

#define my_sizeof(x) (unsigned int)(&x + 1) - (unsigned int)(&x)

¿Alguien puede explicar cómo funciona si está tipificado y si no lo está?

Gracias por adelantado..

Answer 1

Pero siempre terminó dando el resultado como ''1'' para cualquiera de los tipos de datos

Sí, así es como funciona la aritmética de punteros. Funciona en unidades del tipo al que se apunta. Así que casting to char * funciona en unidades de char , que es lo que quieres.

Answer 2

#define my_sizeof(x) ((char *)(&x + 1) - (char *)&x)

Esta macro my_sizeof() no funcionará en los siguientes casos:

1. sizeof 1 - 4 byte (para una plataforma con int 4 bytes)
   my_sizeof(1) - no compilará en absoluto.

2. sizeof (int) - 4 bytes (para una plataforma con 4 bytes int )
   my_sizeof(int) - no compilará el código en absoluto.

Funcionará solo para variables. No funcionará para tipos de datos como int , float , char , etc., para literales como 2 , 3.4 , ''A'' , etc., ni para expresiones de valores como a+b o foo() .

Answer 3

# define my_sizeof (x) ((& x + 1) - & x)

& x da la dirección de su variable e incrementándola con uno (& x + 1), le dará la dirección, donde podría almacenarse otra variable de tipo x. Ahora, si hacemos aritmética sobre estas direcciones como ((& x + 1) - & x), entonces dirá que dentro de ((& x + 1) - & x) se puede almacenar una variable de rango 1 de tipo x.

Ahora, si encadenamos esa cantidad de memoria con (char *) [porque el tamaño de char es de 1 byte y el incremento de un char * se movería solo con un byte], obtendríamos la cantidad de bytes que consume el tipo x

Answer 4

Busqué esto ayer, y encontré esta macro:

#define mysizeof(X)  ((X*)0+1)

Lo que expande X solo una vez (no error como evaluación doble de expresión como x ++), y funciona bien hasta ahora.

Answer 5

El operador sizeof es parte de la especificación del lenguaje C (y C ++) y se implementa dentro del compilador (el extremo frontal). No hay forma de implementarlo con otras construcciones en C (a menos que use extensiones GCC como typeof ) porque puede aceptar tipos o expresiones como operando, sin producir ningún efecto secundario (por ejemplo, sizeof((i>1)?i:(1/i)) no se bloqueará cuando i==0 pero su macro my_sizeof se bloquearía con una división por cero). Ver también las pautas de codificación C , y wikipedia .

Debes entender la aritmética de punteros C. Ver, por ejemplo, esta pregunta . La diferencia de puntero se expresa en elementos, no en bytes.

Answer 6

El resultado de la resta del puntero está en elementos y no en bytes. Así, la primera expresión se evalúa a 1 por definición.

Aparte de esto, deberías usar paréntesis en macros:

#define my_sizeof(x) ((&x + 1) - &x)
#define my_sizeof(x) ((char *)(&x + 1) - (char *)&x)

De lo contrario, intentar usar my_sizeof() en una expresión puede generar errores.

Answer 7

#define my_sizeof(x) ((&x + 1) - &x)

&x da la dirección de la variable (digamos doble x) declarada en el programa y al incrementarla con 1, da la dirección donde se puede almacenar la siguiente variable del tipo x (aquí addr_of(x) + 8 , para el tamaño de una doble es 8Byte).

La diferencia da como resultado que la cantidad de variables de tipo de x se pueden almacenar en esa cantidad de memoria que obviamente será 1 para el tipo x (para incrementarlo con 1 y tomar la diferencia es lo que hemos hecho).

#define my_size(x) ((char *)(&x + 1) - (char *)&x)

al escribirlo en char* y tomar la diferencia nos dirá cuántas variables de tipo char se pueden almacenar en el espacio de memoria dado (la diferencia). Dado que cada char requiere solo 1 byte de memoria, por lo tanto (cantidad de memoria) / 1 dará el número de bytes entre dos ubicaciones de memoria sucesivas del tipo de variable que se pasa a la macro y, por lo tanto, la cantidad de memoria que la variable de tipo x requiere.

Pero no podrá pasar ningún literal a esta macro y conocer su tamaño.