IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Allocation de mémoire compliquée


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut Allocation de mémoire compliquée
    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.

  2. #2
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    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

  3. #3
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut
    Citation Envoyé par souviron34 Voir le message
    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 ?

  4. #4
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par _SamSoft_ Voir le message
    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;

  5. #5
    Membre éclairé Avatar de _SamSoft_
    Profil pro
    Étudiant
    Inscrit en
    Février 2007
    Messages
    798
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Février 2007
    Messages : 798
    Par défaut
    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

  6. #6
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    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..

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [debutant] : Allocation de mémoire dynamique
    Par sam.fet dans le forum Langage
    Réponses: 5
    Dernier message: 15/02/2006, 14h58
  2. Problème d'allocation de mémoire dans la pile
    Par prophet666 dans le forum x86 32-bits / 64-bits
    Réponses: 6
    Dernier message: 19/01/2006, 02h22
  3. [Debutant]Allocation de mémoire
    Par gwendal84 dans le forum C
    Réponses: 6
    Dernier message: 07/12/2005, 19h04
  4. Double allocation de mémoire
    Par hunter001 dans le forum C++
    Réponses: 16
    Dernier message: 25/08/2005, 13h53
  5. pb d'allocation de mémoire
    Par shura dans le forum C
    Réponses: 7
    Dernier message: 17/04/2005, 21h10

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo