Forum Programmation.c Stocker directement des pointeurs qui pointent sur des structures

Posté par  . Licence CC By‑SA.
Étiquettes : aucune
0
18
jan.
2014

Bonjour,

Je suis évidemment novice en programmation, et dans l'idée de flemmarder en apprenant des trucs, je bidouille structures et pointeurs…
Expérimenter et rechercher m'ont beaucoup aidé dans ma compréhension des pointeurs, mais j'ai besoin d'un guru pour m'éclairer.

faisons parler le code :

    typedef struct MaStructure MaStructure;
    struct MaStructure
    {
        int State;  //  0
        int Prevstate;  //  -1
        int Position;   //  0
        int Target; //  -100
    };
    MaStructure* Ensemble[3];
        Structure STRUCT1;
        Structure STRUCT2;
        Structure STRUCT3;
        Ensemble[0]=&STRUCT1;
        Ensemble[1]=&STRUCT2;
        Ensemble[2]=&STRUCT3;
        for (i=0;i<3;i++)
        {
            Ensemble[i]->State=0;
            Ensemble[i]->Prevstate=0;
            Ensemble[i]->Position=0;
            Ensemble[i]->Target=0;
        }

Alors voila, je veux favoriser l'évolutivité, et éviter les instanciations répétitives laides…
Dans la théorie, je voudrais instancier les structures en les sérialisant comme élément du tableau Ensemble[]…
J'ai beau essayer, que ce soit directement ou avec un pointeur temporaire je ne parviens pas à trouver les combinaisons idoines (*,& ou ->)pour qu'il accepte de rentrer dans le tableau sans faire glapir le compilo au passage.

  • # malloc ?

    Posté par  . Évalué à 1.

    salut je ne comprend pas trop ce que tu désire faire
    petit conseil de notation :

    typedef struct _MaStructure
{
     int State;  //  0
    int Prevstate;  //  -1
    int Position;   //  0
    int Target; //  -100

    _MaStructure *next //si tu souhaite réaliser une liste chainée 
}MaStructure;

MaStructure **tab;


tab = malloc(sizeof(*tab) * nbElem);

for (i= 0 ; i< nbElem ; i++)
{
  tab[i] = malloc(sizeof(*tab[i]);
  memset(tab[i],0,sizeof(*tab[i]));
}

    en fonction de la valeur nbElem tu peux créer autant d’élément pour ton tableau

  • # Rien compris :s mais…

    Posté par  . Évalué à 2. Dernière modification le 18 janvier 2014 à 14:25.

    ton code est équivalent à :

    typedef struct MaStructure MaStructure;
struct MaStructure
{
    int State;  //  0
    int Prevstate;  //  -1
    int Position;   //  0
    int Target; //  -100
};
// on créé un tableau de structures dans la pile (si c'est dans le segment data, il est inutile de les initialiser, ça sera à 0 implicitement)
MaStructure structures[3] = {{0,0,0,0}}; 
//ton tableau Ensemble contient des pointeurs sur structures[0], structures[1]...
// car &structure[n] == &(*structures + n) == structure + n
MaStructure* Ensemble[] = {structures,
               structures + 1,
               structures + 2};

    Please do not feed the trolls

  • # Facile.

    Posté par  (site web personnel) . Évalué à 2.

    Tu veux allouer sur le tas, et pas sur la pile. Donc malloc.

    #include <stdio.h>
#include <stdlib.h>

struct maStructure
{
  int state;  //  0
  int prevstate;  //  -1
  int position;   //  0
  int target; //  -100
};
typedef struct maStructure MaStructure;

int main (int argc, char *argv[]){

  MaStructure* Ensemble[3];

  int i;
  for (i=0;i<3;i++) {
    // Alloue sur le tas.
    Ensemble[i] = malloc(sizeof(MaStructure));
    Ensemble[i]->state=i;
    Ensemble[i]->prevstate=i;
    Ensemble[i]->position=i;
    Ensemble[i]->target=i;
  }

  for (i=0;i<3;i++) {
    printf("%d, %d, %d, %d\n", Ensemble[i]->state,
                               Ensemble[i]->prevstate,
                               Ensemble[i]->position,
                               Ensemble[i]->target);
  }


  return 0;
}

    • [^] # Re: Facile.

      Posté par  . Évalué à 5.

      je sais qu'à la fin du programme tout est désalloué, mais le monsieur (ou la madame) souhaite apprendre donc il faut donner les réflexes de bases, sinon c'est encore bibi qui passe derrière pour balayer.

      Quand on écrit malloc (en c) ou new/new il faut OBLIGATOIREMENT penser à la durée de vie des données et les libérer lorsqu'elles ne sont plus utile (via free(c) ou delete/delete ) .

      Note bien qu'en java ou tout autre langage on est aussi confronté à la durée de vie des données mais c'est une problématique à la fois plus simple et plus complexe ;)

      En gros il faut rajouter avant le return 0

      for( i=0; i < 3 ; ++i)
  free(Enemble[i]);

      à noter que :

      • 3 peut avantageusement être remplacé par const int nbEnsemble = 3;
      • tu peux remplacer for(i=0…) par for( MaStructure *it = Ensemble ; it < Ensemble + nbEnsemble ; ++it ) et utiliser it->state

      Il ne faut pas décorner les boeufs avant d'avoir semé le vent

      • [^] # Re: Facile.

        Posté par  (site web personnel) . Évalué à 2.

        Je fais plus de C. J'avais complètement oublié de désallouer :)

        • [^] # Re: Facile.

          Posté par  . Évalué à 2.

          hihi ;) en fait y a pleins de choses qui peuvent être faites ;)
          comme au lieu d'avoir un tableau de pointeur de structure, avoir un pointeur de tableau de structure. Ici la taille de la structure est suffisamment petite et le nombre d'allocation suffisamment faible pour qu'on puisse avoir 

          Structure *ensemble
ensemble = (Structure*) malloc( sizeof(Structure) * nbElement ) ;

// et on y accède comme ça
ensemble[i].state;
// ou 
for( Structure *itEns = ensemble ; itEns < ( ensemble + nbElement) ; ++itEns ) 
  itEns->state;
//et  on libère le tout comme ça
free(ensemble);

          Je rajoute que

          • compiler avec l'option -Wall permet de repérer beaucoup d'erreurs
          • les majuscules sur les noms de variable/champ prête à confusion, par convention les majuscules sont pour les types (comme les structures, les classes), une variables écrite avec le caps_lock est une constante (ou une macro )

          Il ne faut pas décorner les boeufs avant d'avoir semé le vent

  • # sizeof()

    Posté par  . Évalué à 2.

    depuis quelque temps je passe à sizeof le nom de la variable plutôt que son type exemple

        typedef struct MaStructure MaStructure;
    struct MaStructure
    {
        int State;  //  0
        int Prevstate;  //  -1
        int Position;   //  0
        int Target; //  -100
    };


    MaStructure *pMa_struct = malloc(sizeof(*pMa_struct ));

    avec *pMa_struct j'indique a mon compilateur d'utiliser la taille de l'objet pointé par pMa_struct.

    mais je ne retrouve pas cette syntaxe dans les forum et autre doc.

    est elle déconseillée ?

    perso je la trouve sympa je n'ai pas utiliser le nom de la structure qui peux changer

    • [^] # Re: sizeof()

      Posté par  . Évalué à 2.

      En utilisant struct mastruct *t = malloc(sizeof(struct mastruct)); tout est très explicite.
      Avec l'autre syntaxe, struct mastruct *t = malloc(sizeof(t))` ça l'est plus du tout.

      Et voilà un code très joli, concis, qui compile sans warning, et va produire des bugs aléatoire car on a alloué que sizeof(void*) octets au lieux de sizeof(struct montype)… Il manque une étoile…

      Please do not feed the trolls

      • [^] # Re: sizeof()

        Posté par  . Évalué à 1.

        c'est pas faux le coup du bug aléatoire :(

        j'étais bien content de ma petite macro 

         #define NEW_STRUCT(_st) (_st=malloc(sizeof(*st))

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.