[C] Realloc

[invite16925a82]

Bonjour, je voudrais un peu d'aide s'il vous plait. Le but est de ranger des caractères dans une variable s de type char *. La variable s doit pointée vers une zone allouée dynamiquement, redimensionné à l'aide de realloc dès qu'elle est pleine(en lui ajoutant 5 caractères par exemple). Le souci c'est que je ne sais pas quand mon tableau s est rempli . Est ce que je dois faire un malloc avant la reallocation ? Merci de l'aide

int main(){
  char c ;
  int i =0;
  char *s = NULL; // char *s = malloc(5*sizeof(char)) ??
  c = getchar();
  while(! isspace(c)){
    putchar(c);
    s[i] = c;
    c =  getchar();
    i++;
  }
  putchar('\n');

-----

[invite1c6b0acc]

Bonjour,

Est ce que je dois faire un malloc avant la reallocation ?

Non, ce n'est pas nécessaire.
Il faut juste initialiser à 0 (NULL) le pointeur à réallouer. La norme précise que dans ce cas, realloc se comporte comme malloc.
A+

[invite7a96054d]

Bonjour, je voudrais un peu d'aide s'il vous plait. Le but est de ranger des caractères dans une variable s de type char *. La variable s doit pointée vers une zone allouée dynamiquement, redimensionné à l'aide de realloc dès qu'elle est pleine(en lui ajoutant 5 caractères par exemple). Le souci c'est que je ne sais pas quand mon tableau s est rempli . Est ce que je dois faire un malloc avant la reallocation ? Merci de l'aide

Bonjour,
Il te faut 3 données pour ça : la capacité de ton tableau, l'espace utilisé et en endroit pour stocker tes données. La capacité c'est le nombre d'éléments alloués, l'espace utilisé c'est le nombre d'éléments dans ton tableau. En général on met tout ça dans une structure :

struct dyn_array {
  int capacity;
  int count;
  char* data;
};

Ensuite il faut écrire les fonctions classiques pour manipuler ta structure :
Une fonction de création du tableau dynamique :

struct dyn_array* dyn_array_create(int initial_capacity);

qui alloue et renvoie une structure avec capacity=initial_capacity, count=0 (aucun élément dans le tableau) et data qui a été mallocé pour contenir capacity éléments.

Une fonction de désallocation du tableau dynamique :

void dyn_array_delete(struct syn_array* da);

qui libère toute la mémoire utilisée, autant par la structure que par les données.

Une fonction qui augmente la taille du tableau

void syn_array_grow(struct dyn_array* da, int factor);

Il est plus intéressant de suivre une progression géométrique qu'une progression arithmétique, si ça t'intéresse je peux t'expliquer pourquoi dans un post suivant. C'est dans cette fonction que tu va réallouer la mémoire. Éventuellement tu peux prévoir une fonction qui rétrécit le tableau.

Une fonction qui ajoute une donnée :

void syn_array_add_element(struct dyn_array* da, char c);

C'est ici que l'essentiel va se passer. Tu as count éléments dans ton tableau (de data[0] à data[count-1]), et ton tableau peut contenir au maximum capacity éléments (de data[0] à data[capacity-1]). Si tu insères un nouvel élément il viendra en position data[count]. Si count==capacity alors il n'y a plus de place et tu dois appeler grow(), ensuite tu es certain d'avoir suffisamment de place donc il te suffit d'insérer ton élément en data[count] puis d'incrément count.

N'oublie pas de vérifier après chaque allocation/réallocation que tout se passe bien, etc ...