Aller au contenu


Photo
- - - - -

imbrication de stucture -> Gros Soucis


  • Veuillez vous connecter pour répondre
5 réponses à ce sujet

#1 philou-RX

philou-RX

    Habitué

  • Membres
  • PipPip
  • 261 messages
  • Gender:Male
  • Location:Riviera - Vaudoise
  • Interests:Electronique / Informatique / Robotique / BD / et surtout les boissons fermentées au houblon

Posté 12 octobre 2011 - 08:35

Bonsoir à tous,

Je crie HELP :bomb: :bomb: :bomb: car je suis vraiment bloqué, et je me tire un peu les cheveux, et donc avant que le PC ne vole au travers de la chambre, je fais d'abord appel à vous.

Voilà, j'aimerai créé plusieurs personnes qui ont comme référence le nom, la taille, la couleur de cheveux, etc... pi ces personnes doivent être liée entre elles, c'est-à-dire que la personne en-elle-même connaît si elle a quelqu'un qui la précède ou qui la devance. En gros c'est juste un exemple qui pourrait correspondre à mon soucis, sauf que j'utilise des tâches ou lieu des personnes.

j'utilise une structure qui définit la personne, puis j'utilise une autre structure qui devrait me permettre de connaître le détail de la personne, ainsi la personne qui suit, ou qui précède...

bref je pense que le code sera peut-être plus explicite :
//--- structure interne de la tâche
//---------------------------------
struct s_tache
{
    char task_name[100];            // nom de la tâche
    unsigned char priority;         // niveau de priorité la plus élévée
                                    // = plus importante
    int cpu_used;                   // utilisation du CPU
    int ready_at;                   // gibilité de la tâche
    int to_exec;                    // temps d'exécution restante
};

//--- structure de la tâche externe (liant entre les différentes tâches)
//----------------------------------------------------------------------
struct s_element
{
    s_tache tache_i;                        // la tâche en elle-même
    struct s_element    *pt_before_task;    // pointeur indiquant la tâche d'avant
    struct s_element    *pt_next_task;      // pointeur indiquant la tâche d'apèrs
};

void main()
{
    //--- déclaration des différents éléments (tâches externes)
    //---------------------------------------------------------
    typedef struct s_element tache1;
    typedef struct s_element tache2;
    typedef struct s_element tache3;

    //--- déclaration des différents éléments (tâches externes)
    //---------------------------------------------------------
    s_tache* t1 = malloc(sizeof(s_tache));
    s_tache* t2 = malloc(sizeof(s_tache));
    s_tache* t3 = malloc(sizeof(s_tache));

    tache1.tache_i = t1;
}


En gros le problème, c'est que je ne sais pas comment on arrive à lier la structure de la s_tache et la structure s_element... car pour moi représente s_element correspond à la personne, et s_tache correspond à la description de la personne en elle-même...

Voilà si vous avez des remarques sur mes explications, c'est bien volontiers que je vous apporte des précisions,... et si vous avez compris mes explication et c'est bien volontiers que je vais prendre plaisir à vous lire car je suis vraiment bloqué...

Amicalement Philou
Amicalement PHILOU QUI a BU, BOIRA !!! VU euh non BU! alcoolique non, assoiffé OUI^^ :P :|

#2 Black Templar

Black Templar

    Membre

  • Membres
  • PipPipPipPipPip
  • 1 430 messages
  • Gender:Male
  • Location:Lille

Posté 12 octobre 2011 - 09:12

Salut !

T'as quoi comme erreur de compil ?

Black Templar

Mon site internet : http://ferdinandpiette.com/


#3 Otatiaro

Otatiaro

    Membre occasionnel

  • Membres
  • Pip
  • 135 messages

Posté 13 octobre 2011 - 11:58

Salut,

Ca s'appel une liste chainée à double sens (2 way linked list en anglais), extension de la liste chainée simple, c'est un pattern très connu.
Son avantage est d'offrir une plus grande flexibilité par rapport au tableau sur l'utilisation de la mémoire (les noeuds se sont pas forcément directement à la suite en mémoire), par contre on ne peut accéder directement à un noeud particulier (par un offset mémoire) donc pour un accès aléatoire on passe de O(1) à O(n).

Bref, le comment faire est décrit un peu partout une fois qu'on a les bons mots clefs ;)

Par exemple http://www.siteduzero.com/tutoriel-3-36245-les-listes-chainees.html

Thomas.

#4 PapaPoilut

PapaPoilut

    Membre occasionnel

  • Membres
  • Pip
  • 115 messages
  • Gender:Male
  • Location:Etampes (91)
  • Interests:Informatique (Ingé)
    Robotique (Débutant)

Posté 13 octobre 2011 - 12:19

    //--- déclaration des différents éléments (tâches externes)
    //---------------------------------------------------------
    typedef struct s_element tache1;
    typedef struct s_element tache2;
    typedef struct s_element tache3;

    //--- déclaration des différents éléments (tâches externes)
    //---------------------------------------------------------
    s_tache* t1 = malloc(sizeof(s_tache));

    tache1.tache_i = t1;
l'erreur est là dedans je pense.
si je me souvient bien
"typedef MACHIN TRUC" signifie quand je créé un TRUC c'est en fait un MACHIN et non pas je déclare un MACHIN

sinon pour creer les objet un seul peut suffire dépend ce que t'en fais après à toi de voir :)
struct s_tache
{
    char task_name[100];            // nom de la tâche
    unsigned char priority;         // niveau de priorité la plus élévée
                                    // = plus importante
    int cpu_used;                   // utilisation du CPU
    int ready_at;                   // gibilité de la tâche
    int to_exec;                    // temps d'exécution restante

    s_tache* prev;
    s_tache* next;
};

enlève les typedef là!

ps: pour la priorité je te conseil de gérer via soit un intervalle fixe (0 à 100) soit par lvl de 1 à 5
sinon si tu met pas de limite les valeurs n'ont pas toute la signification souhaité pour un niveau de priorité

#5 philou-RX

philou-RX

    Habitué

  • Membres
  • PipPip
  • 261 messages
  • Gender:Male
  • Location:Riviera - Vaudoise
  • Interests:Electronique / Informatique / Robotique / BD / et surtout les boissons fermentées au houblon

Posté 15 octobre 2011 - 11:36

Bonjour à tous,

Déjà un grand merci à tous pour vos réponses, ca me permet d'évoluer dans l'écriture de mon code ; je donne encore des précisions sur les évolutions de mes soucis et des debuggages :

1/ création de 3 fichiers distincts : main.c - test.c - test.h

2/ dans le fichier point test.h, c'est ici que je défini ma structure :

voici le code :

//-----------------------------------------------------------------------------//
//--- déclaration de structures
//-----------------------------------------------------------------------------//
//--- structure interne de la tâche
//---------------------------------
struct s_tache
{
    char task_name[100];            // nom de la tâche
    unsigned char priority;         // niveau de priorité la plus élévée
                                    // = plus importante
    int cpu_used;                   // utilisation du CPU
    int ready_at;                   // gibilité de la tâche
    int to_exec;                    // temps d'exécution restante

};

//--- déclaration du nouveau type structure (s_tâche)
//---------------------------------------------------
typedef struct s_tache s_tache_int;

//--- structure de la tâche externe (liant entre les différentes tâches)
//----------------------------------------------------------------------
struct s_element
{
    struct s_element *pt_before_task;    // pointeur indiquant la tâche d'avant
    struct s_element *pt_next_task;      // pointeur indiquant la tâche d'apèrs

    s_tache_int propri_taches;           // tâche en elle-même
};

//--- déclaration du nouveau type structure (s_tâche)
//---------------------------------------------------
typedef struct s_element s_tache_ext;

ça a l'air de marché !!! ;) Merci à vous ;)


3/ dans le main, je veux créer plusieurs listes (tableau) de la structure qui correspond à la tâche externe et d'envoyer une de ces listes à une fonction pour initialisation selon le choix du client

voici le code :

    //--- création de différentes listes à utilisé
    //--------------------------------------------
    s_tache_ext liste_elements_prets[100];     // tb contenant les éléments prêt
    s_tache_ext liste_elements_bloques[100];   // tb contenant les éléments bloqué
    s_tache_ext elements_exec;                 // variable en exécution

    //..... 

    //--- appel la fonction : init_task_list
    //--------------------------------------
    init_task_list(rep_client, &liste_elements_prets);


Apparemment ca aussi, ca à l'air de fonctionner -_-

4/ création d'un fichier test.c pour traîter mes différentes listes.... Pour l'instant je me concentre sur l'initialisation, et c'est là que coinsouille :l_sparrow:

// Nom de la fonction   : init_task_list
// Description          : initialise différentes tâches
//                        selon l'exemple choisi
// Entrée(s)            : choix_exemple
// Sortie(s)            : -
// IN-OUT               : pt_liste_pret
//----------------------------------------------------------------------------//
void init_task_list(int choix_exemple, s_tache_ext *pt_liste_pret)
{
    //--- déclaration des différents éléments (tâches externes et interne)
    //--------------------------------------------------------------------
    s_tache_ext* tache1 = malloc(sizeof(s_tache_ext));    // cération tâche 1
    s_tache_int t1_struct;                          // structure de la tâche 1
    s_tache_ext* tache2 = malloc(sizeof(s_tache_ext));    // cération tâche 2
    s_tache_int t2_struct;                          // structure de la tâche 1
    s_tache_ext* tache3 = malloc(sizeof(s_tache_ext));    // cération tâche 3
    s_tache_int t3_struct;                          // structure de la tâche 1

    //--- selon choix client
    switch(choix_exemple)
    {
        case 1 :
            //--- création de la structure interne de la tache 1
            //--------------------------------------------------
            t1_struct.task_name[100] = "T1";
            t1_struct.priority = 128;           // P(ti)
            t1_struct.cpu_used = 5;             // P = période
            t1_struct.ready_at = 5;             // D = deadline
            t1_struct.to_exec = 4;              // C = durée de la tâche

            //--- liaison entre la structure interne et la structure externe
            tache1.propri_taches = t1_struct;

c'est la dernière ligne qui me crée une erreur, mais je pige par pourquoi !!!

je vous mets aussi l'erreur que ca produit :

|63|error: request for member `propri_taches' in something not a structure or union|

Si vous avez des idées bien volontiers

Merci de me lire encore :blush:

Amicalement Philou
Amicalement PHILOU QUI a BU, BOIRA !!! VU euh non BU! alcoolique non, assoiffé OUI^^ :P :|

#6 Black Templar

Black Templar

    Membre

  • Membres
  • PipPipPipPipPip
  • 1 430 messages
  • Gender:Male
  • Location:Lille

Posté 15 octobre 2011 - 05:25

Salut !

Déjà, tu n'as pas mis ton code en entier, il manque 2 accolades fermantes.

Pour l'erreur que tu obtiens, tu as déclaré tache1 en tant que pointeur. Pour appeler un attribut de ta structure, tu dois donc préciser que tu ne veux pas l'adresse en mémoire, mais la valeur de tache1

(*tache1).propri_taches = t1_struct;   // façon complète
tache1->propri_taches = t1_struct;   // ça marche aussi

++
Black Templar

Mon site internet : http://ferdinandpiette.com/





0 utilisateur(s) li(sen)t ce sujet

0 members, 0 guests, 0 anonymous users