Comment trouver la taille d'une variable à l'aide d'sizeof

Nous supposons je l'ai déclaré à la variable " i " de certains type de données (peut être de type int, char, float ou double) ...

REMARQUE: Simplement de considérer que " je " est déclarée et ne prennent pas la peine si c'est un int ou char ou float ou double type de données. Étant donné que je veux une solution générique, je suis simplement mentionner que la variable " i " peut être de l'un quelconque des types de données, à savoir de type int, char, float ou double.

Maintenant que je peux trouver la taille de la variable " i " sans opérateur sizeof?

pourquoi ne voulez-vous pas utiliser sizeof() ?
Trouvé une semblable question. stackoverflow.com/questions/1219199/...
Une question similaire est ici, par la manière: stackoverflow.com/questions/1219199/...
Meh, ninja avais...
Cela sonne comme une question d'entrevue.....

OriginalL'auteur codingfreak | 2009-09-08

  1. 21

    Vous pouvez utiliser la macro suivante, prise de ici:

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

    L'idée est d'utiliser l'arithmétique des pointeurs ((&(var)+1)) pour déterminer le décalage de la variable, puis soustraire le original adresse de la variable, céder sa taille. Par exemple, si vous avez un int16_t i variable situé au 0x0002, vous seriez en soustrayant 0x0002 de 0x0006, obtenant ainsi 0x4 ou 4 octets.

    Cependant, je ne vois pas vraiment de raison valable de ne pas utiliser sizeof, mais je suis sûr que vous devez avoir un.

    Bougresse ... l'essayer et obtenir la syntaxe de droit pour mon premier code C dans les âges m'a fait ralentir 😉
    Je pense que cette logique pourrait être utile pour trouver la taille d'un type de données, mais comment agit d'une variable inconnue de type de données
    Qu'entendez-vous par des inconnus, comment voulez-vous déclarer ? Si vous disposez d'une variable, comme, par exemple, int i, sizeof_var(i) vous donnera sa taille.
    Supposons que vous avez tout simplement oublié de quel type de données que vous avez déclaré la variable "i". Ce que je veux dire, c'est quel que soit le type de données pour lequel il a été déclaré que nous devrions toujours être en mesure de trouver la taille de la variable "i"
    Cela peut entraîner un comportement indéterminé si l'adresse n'est pas representible dans size_t (par exemple, architecture segmentée), et c'est aussi, sans garantie de retour de la taille correcte

    OriginalL'auteur João Silva

  2. 6

    Cela fait bien longtemps depuis que j'ai écrit tout le code en C et je ne l'ai jamais été, mais cela semble correcte:

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

    Je suis sûr que quelqu'un peut me dire beaucoup de raisons pour lesquelles cela est faux, mais il affiche une valeur raisonnable pour moi.

    La seule chose que vous avez besoin de fixer c'est de changer de void * à char * - vous n'êtes pas censé faire de l'arithmétique des pointeurs avec void *.
    J'ai vérifié, c'est OK avec un rembourrage sizeof fait la même chose et comprend un rembourrage dans la taille de la var. Par conséquent, il woks exactement la même.
    À l'aide de (char*) au lieu de (void*) permettrait d'éviter les avertissements du compilateur sur void* calcul et ne donnent le même résultat, car un char a toujours de la taille 1.
    Cela va fonctionner sur des processeurs qui ont octet de mémoire adressable. Je ne suis pas sûr de savoir si cela fonctionnerait sur le DSP56300 processeurs de la série où le char et int sont à la fois stockés sur 24 bits pour les emplacements de la mémoire. Le processeur n'a pas l'octet d'adressage de sorte que la différence entre les valeurs de pointeur pour les caractères ou les ints permettra à la fois d'être 1.
    hors de propos. sizeof est définie en termes de char unités, de sorte que le résultat sera correct. Si votre application utilise 24 bits caractères, mais artificiellement restreint à 8 bits de large, alors il n'est pas de C. C de mandats char n'ont pas de rembourrage bits.

    OriginalL'auteur Joachim Sauer

  3. 3

    Cela fonctionne..

    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 devrait être (int)(p2 - p1) pour correspondre le spécificateur de format %d
    Et vous avez besoin d'lance le pointeur de conversions: p1 = (char *)&a;

    OriginalL'auteur 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);
    une lettre d'explication, ce serait bien.
    explication sera agréable.
    Alors que ce code peut répondre à la question, en fournissant plus de contexte sur comment et/ou pourquoi, il résout le problème serait d'améliorer la réponse à long terme de valeur.

    OriginalL'auteur ra1

  5. -1

    Essayer cela,

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

    Pour la suite définie par l'utilisateur type de données,

    struct x
{
    char c;
    int i;
};

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

    OriginalL'auteur josh

  6. -1

    Cela devrait vous donner la taille de votre variable

    #define mySizeof(type) ((uint)((type *)0+1))
    Cela provoque un comportement indéterminé (bien que le fait de la topvoted solution)

    OriginalL'auteur Karthick S

  7. -1

    Programme pour trouver la Taille de la variable sans l'aide de sizeof opérateur

    #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;
}

    OriginalL'auteur 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();
}

    OriginalL'auteur Nitesh Pratap Singh

  9. -2

    Déclaration ci-dessous donnera la solution générique:

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

    i est un nom de variable, qui peut être n'importe quel type de données (char, short, int, float, double, struct).

    C ne permet pas de l'arithmétique des pointeurs sur void * pointeurs. C'est (généralement) un C de GNU extension.

    OriginalL'auteur vikram p