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..

[_SamSoft_]

R�solu !