Discussion :

[_SamSoft_]

Bonjour, je souhaite utiliser realloc dans le but de créer un tableau de char à partir d'un tableau de structure (je ne sais pas si les mots utilisés sont bons). Voilà un exemple:

Ma structure :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
typedef struct probot
{
    char *commands; /* tableau de toutes les actions */
    char *name; /* nom du robot */
    pos position; /* position du robot sur la carte */
    int type; /* type du robot */
    int lines; /* lignes totales du fichier */
} robot;

pos est une autre structure.

Je sais déjà créer un tableau pour robot :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
 
robot *my_robot = NULL;
 
my_robot = realloc(my_robot, sizeof(robot)*nbr_of_robots);

Mais pour commands, je vois pas. J'ai déjà fait :

Avec i une variable quelconque.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(my_robot+i)->commands = realloc((my_robot+i)->commands, sizeof((my_robot+i)->commands+j)*(my_robot+i)->lines);

Mais ca n'a pas l'air d'être ca du tout.

Merci d'avance

PS: Si j'utilise direct realloc sur un pointeur valant "NULL" sans passer par malloc c'est bon ? Sachant que je n'ai besoin d'allouer qu'une seul fois commands.

[souviron34]

alors déjà avec ce qu'on a dit dans l'autre post, tu n'as pas besoin d'un tableau de commandes en char..

Je vais cependant t'aider là-dessus :

D'une part ton paramètre ne devrait pas s'appeller lines mais n_commands

Ensuite, il suffit de fairre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
char **tmp=NULL ;
 
tmp = realloc (robot[i].commands, (robots[i].n_commands+1)*sizeof(char *));
if ( tmp != NULL )  /* la reallocation a marche */
{
    robot[i].commands = tmp ;
 
    robot[i].commands[robot[i].n_commands]] = strdup ( action ); 
/* ou bien */
     robot[i].commands[robot[i].n_commands]] = calloc ((strlen(action)+1), 1); 
    if ( robot[i].commands[robot[i].n_commands]] != NULL )
       strcpy ( robot[i].commands[robot[i].n_commands]], action );
 
    if (  robot[i].commands[robot[i].n_commands]] != NULL ) 
           robot[i].n_commands = robot[i].n_commands + 1 ;
}

Mais maintenant, si tu stockes les int, ce sera plus facile :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
int *tmp=NULL ;
 
tmp = realloc (robot[i].commands, (robots[i].n_commands+1)*sizeof(int));
if ( tmp != NULL )  /* la reallocation a marche */
{
    robot[i].commands = tmp ;
 
    robot[i].commands[robot[i].n_commands]] = decode_action(action); 
    robot[i].n_commands = robot[i].n_commands + 1 ;
}

ou la fonction decode_action est du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
int decode_action ( char *action )
{
   int result ;
 
    if ( strcmp( action, "demarre") == 0 )
         reult = DEMARRE ;
   else
  ...
 
   return result ;
}

le char *action en paramètre étant le mot trouvé dans la ligne du fichier

[_SamSoft_]

alors déjà avec ce qu'on a dit dans l'autre post, tu n'as pas besoin d'un tableau de commandes en char..

Pardonnez moi si me trompe mais vous avez écrit :

Ensuite, tu fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
       /* stockage des actions de chaque robot */
pour(i ; i < nbr de robots ; i++)
{
 ouvir fichier  robot i
 
 faire tant que fin de fichier != vrai
 {
    lire ligne
    lire action
    reallouer tableau des actions dans la structure robot   
    if ( strcmp(action, "demarre" ) == 0 )
         robot[i].action[x] = DEMARRE; /* action étant un tableau de int */
   ....
  x++
}

Notez cette ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
robot[i].action[x];

C'est bien ce que je fais. Ah mais oui, j'ai oublié de dire que j'avais renommé la variable action (char *) en commands (char *)

Voilà la structure :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
typedef struct ppos
{
    signed int x;
    signed int y;
} pos;
 
typedef struct probot
{
    SDL_Surface *surface;
    char *commands; /* tableau de toutes les actions */
    char *name; /* nom du robot */
    pos position; /* position du robot sur la carte */
    int type; /* type du robot */
    int lines; /* lignes totales du fichier */
} robot;

Je vais cependant t'aider là-dessus :

Merci Je vais tester.

pas lines mais n_commands

Je prends note mais cela ne revient-il pas au même ?

PS: Je viens de me rendre compte d'un truc, si comme vous dites, je stock que des int (ce qui est plus simple et plus rapide), je n'ai plus besoin de char *commands dans ma structure mais seulement int *n_commands. C'est bien cela ?

[souviron34]

S: Je viens de me rendre compte d'un truc, si comme vous dites, je stock que des int (ce qui est plus simple et plus rapide), je n'ai plus besoin de char *commands dans ma structure mais seulement int *n_commands. C'est bien cela ?

non pas vraiment.. Il te faut forcément le compteur , à moins que tu n'alloues 1 de plus à chaque fois et que tu testes si null.. mais par contre ce n'est plus char* commands mais int* commands ...

Mais ta structure devient :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
typedef struct probot
{
    SDL_Surface *surface;
    int   *commands; /* tableau de toutes les actions */
    char *name; /* nom du robot */
    pos position; /* position du robot sur la carte */
    int type; /* type du robot */
    int n_commands; /* nbre total de commandes */
} robot;

[_SamSoft_]

Je n'avais pas encore modifié la structure désolé.

En effet, j'ai maintenant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
typedef struct ppos
{
    signed int x;
    signed int y;
} pos;
 
typedef struct probot
{
    SDL_Surface *surface;
    char *name; /* nom du robot */
    pos position; /* position du robot sur la carte */
    int *commands; /* actions du robot */
    int type; /* type du robot */
    int lines; /* lignes contenues du fichier */
} robot;

Mais pourquoi l'appelez vous n_commands, lines n'est pas plus simple ?
Je test le tout

[souviron34]

ben ton tableau s'appelle commands.. qui est bien le tableau des commandes..

Ce que cet entier défini c'est bien le nombre de commandes...

Et si par exemple tu avais des lignes blanches, ou des lignes de commentaires, dans ton fichier, ton nombre ne serait pas le nombre de lignes du fichier, mais bien le nombre de commandes.

De même si une allocation échoue à un moment, tu n'auras peut-être pas le
nombre de commandes qu'il y a dans le fichier..

Donc en général, c'est mieux d'appeller les choses par leur nom..