Types définis par l’utilisateur avec taille dynamic en C

Je veux définir un nouveau type de données consistant en un tableau avec une taille entrée par l’utilisateur. Par exemple, si l’utilisateur entre 128, alors mon programme doit créer un nouveau type qui est fondamentalement un tableau de 16 octets. La définition de cette structure doit être globale car je vais utiliser ce type par la suite dans mon programme. Il est nécessaire d’avoir une taille dynamic pour cette structure car je vais avoir une énorme firebase database peuplée par ce type de variables à la fin.

Le code que j’ai maintenant est:

struct user_defined_integer; . . . void def_type(int num_bits) { extern struct user_defined_integer { int val[num_bits/sizeof(int)]; }; return; } 

(qui ne fonctionne pas)

J’ai trouvé que la chose la plus proche de ma question se trouve ici: je dois créer un tableau global en C avec une taille entrée par l’utilisateur (ce qui n’est pas utile)

Y a-t-il un moyen de faire cela pour que ma structure soit reconnue dans tout le fichier?

En faisant:

 extern struct user_defined_integer { int val[num_bits/sizeof(int)]; }; 

Vous devriez avoir l’avertissement:

 warning: useless storage class specifier in empty declaration 

parce que vous avez une déclaration vide. extern ne s’applique pas à user_defined_integer , mais à la variable qui le suit . Deuxièmement, cela ne fonctionnera de toute façon pas, car une structure contenant un tableau de longueur variable ne peut avoir de lien.

 error: object with variably modified type must have no linkage 

Même dans ce cas, les tableaux de longueur variable allouent de la mémoire au moment de la déclaration. Vous devriez plutôt opter pour la mémoire dynamic.

 #include  typedef struct { int num_bits; int* val; } user_defined_integer; void set_val(user_defined_integer* udi, int num_bits) { udi->num_bits = num_bits; udi->val = malloc(num_bits/sizeof(int)); } 

Ce dont vous avez besoin, c’est d’un membre de VLA, comme demandé ici . Fondamentalement, vous déclarez une struct avec un champ de taille et la valeur de stockage d’un élément en tant que dernier membre, puis la surallouez.

Importé de cette question:

 typedef struct Bitmapset { int nwords; uint32 words[1]; } Bitmapset; Bitmapset *allocate(int n) { Bitmapset *p = malloc(offsetof(Bitmapset, words) + n * sizeof *p->words); p->nwords = n; return p; } 

Je veux définir un nouveau type de données consistant en un tableau avec une taille entrée par l’utilisateur. Par exemple, si l’utilisateur entre 128, alors mon programme doit créer un nouveau type qui est fondamentalement un tableau de 16 octets.

Ceci n’est pas possible en C, car les types C sont une compilation et n’existent pas du tout au moment de l’ exécution .

Cependant, avec un compilateur conforme à C99, vous pouvez utiliser un membre de tableau flexible. Vous aurez besoin d’une struct contenant des membres et se terminant par un tableau sans dimension donnée, par exemple

 struct my_flex_st { unsigned size; int arr[]; // of size elements }; 

Voici un moyen de l’allouer:

 struct my_flex_st *make_flex(unsigned siz) { struct my_flex_st* ptr = malloc(sizeof(struct my_flex_st) + siz * sizeof(int)); if (!ptr) { perror("malloc my_flex_st"); exit(EXIT_FAILURE); }; ptr->size = siz; memset (ptr->arr, 0, siz*sizeof(int)); return ptr; } 

N’oubliez pas de le free une fois que vous ne l’utilisez plus.

Bien sûr, vous devrez utiliser des pointeurs dans votre code. Si vous voulez vraiment avoir une variable globale, déclarez-la comme par exemple

 extern struct my_flex_st* my_glob_ptr; 

Essayez cette méthode

 #include #include #include struct user_defined_integer { int *val; }user_int; void memory_allocate(int num_bit) { int result; result = (num_bit+CHAR_BIT-1)/CHAR_BIT; // since 8 bit =1 byte user_int.val=malloc(result*sizeof(int)); if(user_int.val == NULL){ printf("Failed to allocate memory\n"); return ; } else printf("Allocated %d bytes for val\n",result); } int main() { int num_bit; printf("Enter the number of bits\n"); scanf("%d",&num_bit); memory_allocate(num_bit); // do your stuff here free(user_int.val); // free the memory at the end; return 0; }