Wie finden Sie die Größe einer variable mit out Verwendung von sizeof

Nehmen wir an, ich habe erklärt die variable 'i' bestimmter Datentyp (int, char, float oder double) ...

HINWEIS: man bedenke nur, daß 'ich' deklariert ist und nicht stört, wenn es ein int oder char oder float-oder double-Datentyp. Da möchte ich eine generische Lösung, ich bin einfach zu erwähnen, dass die variable 'ich' werden kann, ohne das eine der Datentyp, nämlich int, char, float oder double.

Nun finde ich die Größe der variable 'i' ohne sizeof-operator?

warum wollen Sie nicht die Verwendung von sizeof() ?
Gefunden eine ähnliche Frage. stackoverflow.com/questions/1219199/...
Eine ähnliche Frage ist hier, durch die Art und Weise: stackoverflow.com/questions/1219199/...
Meh, ninja würde...
Das klingt wie eine interview-Frage.....

InformationsquelleAutor codingfreak | 2009-09-08

  1. 21

    Können Sie den folgenden makro verwenden, entnommen hier:

    #define sizeof_var( var ) ((size_t)(&(var)+1)-(size_t)(&(var)))

    Die Idee ist die Verwendung von Zeiger-Arithmetik ( (&(var)+1) ), um zu bestimmen, den offset der variable, und subtrahieren Sie dann die original Adresse der Variablen, was zu seiner Größe. Zum Beispiel, wenn Sie eine int16_t i - variable an 0x0002 Sie wäre Subtraktion 0x0002 aus 0x0006, und damit den Erhalt 0x4 oder 4 bytes.

    Allerdings sehe ich nicht wirklich einen triftigen Grund nicht zu verwenden sizeof, aber ich bin sicher, Sie müssen haben eine.

    Verdammt ... Sie versuchen es und bekommen die syntax der richtige für mein erstes C-code in Alter machte mich langsam 😉
    Ich denke, diese Logik wäre hilfreich finde ich die Größe von einem Datentyp aber wie wäre es mit einer variable mit unbekannter Datentyp
    Was meinst du mit unbekannt, wie würden Sie es erklären ? Wenn Sie eine variable wie, sagen wir, int i, sizeof_var(i) geben Sie Ihre Größe.
    Lassen Sie uns nehmen Sie an, Sie haben einfach vergessen, für welchen Datentyp Sie haben, deklariert die variable 'ich'. Was ich damit sagen will ist, unabhängig von der Datentyp, zu dem Sie erklärt wurde, sollten wir noch finden können, die Größe der Variablen 'i'
    Dies kann zu undefinierten Verhalten, wenn die Adresse nicht representible in size_t (z.B. segmentierte Architektur), und es ist auch nicht gewährleistet, dass Sie zurück in der richtigen Größe

    InformationsquelleAutor João Silva

  2. 6

    Es ist schon lange her, seit ich schrieb beliebigen C-code, und ich war nie gut darin, aber das sieht richtig:

    int i = 1;
size_t size = (char*)(&i+1)-(char*)(&i);
printf("%zi\n", size);

    Ich bin mir sicher, dass mir jemand sagen kann viele Gründe, warum dies falsch ist, aber es gibt einen sinnvollen Wert für mich.

    Die einzige Sache, die Sie beheben müssen ist, ändern void * zu char * - Sie sind eigentlich nicht zu tun, Zeiger-Arithmetik mit void *.
    Habe ich geprüft, es ist OK mit Polsterung sizeof macht das gleiche und umfasst die Polsterung in der Größe der var. Daher ist es woks genau das gleiche.
    Mit (char*) statt (void*) würde verhindern, dass der compiler Warnungen über void* arithmetische und hat das gleiche Ergebnis, da ein char immer die Größe 1.
    Dies funktioniert auf den Prozessoren, die byte-adressierbaren Speicher. Ich bin mir nicht sicher, ob das funktionieren würde auf die DSP56300-Prozessoren der Serie, wo die char und int sind beide gespeichert in einzelne 24-bit Breite Speicheradressen. Der Prozessor muss nicht byte-Adressierung, so dass der Unterschied zwischen der Zeiger Werte für aufeinander folgende chars oder ints werden beide 1.
    irrelevant. sizeof ist definiert in Bezug auf char Einheiten, so dass das Ergebnis richtig sein wird. Wenn Ihre Implementierung verwendet 24 bit chars aber künstlich beschränkt Sie auf 8-bit-Palette, dann ist es nicht C. C-Mandate, die char keinen padding-bits.

    InformationsquelleAutor Joachim Sauer

  3. 3

    Das funktioniert..

    int main() {
    int a; //try changing this to char/double/float etc each time//
    char *p1, *p2;
    p1 = &a;
    p2 = (&a) + 1;
    printf("size of variable is:%d\n", p2 - p1);
}
    p2 - p1 sollte (int)(p2 - p1) entsprechend der Formatbezeichner %d
    Und Sie brauchen, wirft der Zeiger Konvertierungen: p1 = (char *)&a;

    InformationsquelleAutor Achu

  4. 2
    int *a, *b,c,d;/* one must remove the declaration of c from here*/
int c=10;
a=&c;
b=a;
a++;
d=(int)a-(int)b;
printf("size is %d",d);
    eine begleitende Erklärung wäre nett.
    Erklärung wäre nett.
    Während dieser code kann die Frage beantworten, die zusätzliche Bereitstellung von Kontext in Bezug auf wie und/oder warum es löst das problem verbessern würde, die Antwort, die langfristigen Wert.

    InformationsquelleAutor ra1

  5. -1

    Versuchen, diese,

    #define sizeof_type( type )  ((size_t)((type*)1000 + 1 )-(size_t)((type*)1000))

    Für die folgenden user-defined datatype,

    struct x
{
    char c;
    int i;
};

sizeof_type(x)          = 8
(size_t)((x*)1000 + 1 ) = 1008
(size_t)((x*)1000)      = 1000

    InformationsquelleAutor josh

  6. -1

    Dies sollte Ihnen die Größe der variable

    #define mySizeof(type) ((uint)((type *)0+1))
    Dies bewirkt Undefiniertes Verhalten (obwohl nicht so der topvoted Lösung)

    InformationsquelleAutor Karthick S

  7. -1

    Programm zu finden, die Größe der Variablen ohne Verwendung sizeof Betreiber

    #include<stdio.h>
int main()
  {
  int *p,*q;
  int no;
  p=&no;
   printf("Address at p=%u\n",p);
  q=((&no)+1);
  printf("Address at q=%u\n",q);
  printf("Size of int 'no': %d Bytes\n",(int)q-(int)p);

  char *cp,*cq;
    char ch;
  cp=&ch;
  printf("\nAddress at cp=%u\n",cp);
  cq=cp+1;
  printf("Address at cq=%u\n",cq);
  printf("Size of Char=%u Byte\n",(int)cq-(int)cp);

  float *fp,*fq;
  float f;
  fp=&f;
 printf("\nAddress at fp=%u\n",fp);
  fq=fp+1;
  printf("Address at fq=%u\n",fq);
  printf("Size of Float=%u Bytes\n",(int)fq-(int)fp);

  return 0;
}

    InformationsquelleAutor debaonline4u

  8. -2
    #include<stdio.h>

#include<conio.h>

struct size1


  {
int a;
char b;
float c;
};

void main()
{
struct size1 *sptr=0;  //declared one pointer to struct and initialise it to zero//
sptr++;                 
printf("size:%d\n",*sptr);
getch();
}

    InformationsquelleAutor Nitesh Pratap Singh

  9. -2

    Unter Anweisung geben wird generische Lösung:

    printf("%li\n", (void *)(&i + 1) - (void *)(&i));

    i ist ein Variablen-Namen, das kann jeder Datentyp (char, short, int, float, double, struct).

    C nicht erlaubt, Zeiger-Arithmetik auf void * Zeiger. Dies ist (in der Regel), ein GNU-C Erweiterung.

    InformationsquelleAutor vikram p

Schreibe einen Kommentar