Discussion :

[Elstak]

Bonjour,

voilà j'ai le code suivant qui me permet de créer une liste de bombe. Au fur et à mesure que je crée un élément bombe, celui-ci s'ajoute à la suite (et je veux absolument qu'il s'ajoute à la suite).

Tout va bien jusque là mais ensuite je voudrais vérifier si une bombe doit exploser ou non (il s'agit toujours uniquement de la premiere). Si elle doit exploser (le test n'est pas présent mais on fait tout comme ) alors je voudrais supprimer la premiere bombe de ma liste.

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
void Ajouter(ListeBombe * Liste,const float DatePose,const int  PositionX,const int PositionY);
ListeBombe * CreerListe(void);
 
int main(void)
{
    ListeBombe * ListeTest;
    ListeTest = CreerListe();
    Ajouter(ListeTest, 3.5,10,20);
    Ajouter(ListeTest, 3.5,11,20);
    printf("Premiere bombe, positionY : %d",ListeTest->data[ListeTest->combien - 1].PositionX );
 
 
    return 0;
}
 
ListeBombe * CreerListe(void)
{
    ListeBombe * L;
    L = (ListeBombe *)malloc(sizeof(ListeBombe));
    L->data = NULL;
    L->combien = 0;
    return L;
}
 
void Ajouter(ListeBombe * Liste,const float DatePose,const int  PositionX,const int PositionY)
{
    Bombe * B;
 
    if(Liste == NULL)
    {
        printf("impossible d'allouer de la mémoire pour créer la liste de bombes");
        exit(-1);
    }
    B = (Bombe *)realloc(Liste->data, (Liste->combien + 1) * sizeof(Bombe));
    if(B == NULL)
    {
        printf("impossible d'allouer de la mémoire pour créer une bombe");
        exit(-1);
    }
    Liste->data = B;
    Liste->combien ++;
    Liste->data[Liste->combien -1].DatePose = DatePose;
    Liste->data[Liste->combien -1].PositionX = PositionX;
    Liste->data[Liste->combien -1].PositionY = PositionY;
}

Voici mes structures :

Code :

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

1
2
3
4
5
6
7
8
9
10
typedef struct Bombe{                
                float DatePose;
                int PositionX;
                int PositionY;
            }Bombe;
 
typedef struct ListeBombe{                
                Bombe * data;
                int combien;
               }ListeBombe;

Le problème est que je n'y arrive pas. Est ce que je dois tout décaler "d'un cran vers la droite"? je veux dire tant qu'il y a une bombe, je la met dans un indice du tableau inférieur (la 2 à la place de la 1 puis la 3 a la place de la 2 etc....) ou est-il possible de décaler le début de ma liste "d'un cran vers la gauche" et ainsi avoir la seconde bombe pointé directement (et qui deviendra donc la premiere) ?

j'espere avoir été clair dans mes explications car c'est pas tres evident à décrire

merci d'avance

EDIT : il faut bien utiliser un malloc dans ma fonction CreerListe? (ou calloc? je vois pas vraiment la différence entre les 2... )

[fearyourself]

Quelle idée !

Tu as une liste d'éléments que tu vas continuellement ajouter et retirer des éléments... Il te faut donc une liste chaînée pure pas une implémentation utilisant un tableau.

Ou alors, il faudrait jouer avec des indices qui accéderont au tableau d'une certaine facon pour simuler une liste chaînée. Mais c'est largement plus compliqué et le gain n'est pas immédiat.

Je pense que tu devrais repenser ta structure de données.

Jc

[Elstak]

euh...

oui peut etre...

mais en fait j'ai un cours sur des liste chainées et je vois comment ca marche... j'ajoute un element puis un autre mais c'est toujours en tete de liste (non?)

et pour supprimer ca supprime aussi celui en tete de liste(?)

enfin j'ai un exemple qui fonctionne comme ca dans mon cours... il y a un pointeur sur l'element suivant (dans la structure). donc en gros ca marche comme du LIFO et moi ca me va pas (enfin si je me trompe qu'on me le dise )... je veux trouver le premier element ajouté directement (car je ne regarde que lui) et pouvoir le supprimer facilement...

je pensais que par tableau ca irai mieux

en fait j'ai à créer bomberman et à chaque bombe posée j'ajoute un element... donc c'est sur ca arrive souvent mais je me disai qu'avec un tableau à chaque tour de boucle je n'avais qu'à regarder la date de la premiere bombe et voir si je devais la faire exploser ou non

[Elstak]

j'ai reussi...

en faisant ca (tout decaler de 1 case vers la gauche... tampi... sachat qu'au max il y aura 10 elements c'est pas si handicapant je pense):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void SupprimerTete(ListeBombe * Liste)
{
    int i;
 
    Liste->combien--;
 
    for(i=0;i<(Liste->combien);i++)
    {
        Liste->data[i].DatePose = Liste->data[i+1].DatePose;
        Liste->data[i].PositionX = Liste->data[i+1].PositionX;
        Liste->data[i].PositionY = Liste->data[i+1].PositionY;
    }
}

[souviron34]

ben ce que tu montres c'est l'utilisaton d'un TABLEAU

LE SEUL VRAI AVANTAGE des listes chaînées, c'est de ne pas avoir à faire ça... (outre l'allocation dynamique élément par élément)

Donc si ton exercice est de faire une liste chaînée, tu vas te prendre un magistral zéro...

[Elstak]

hehe,

merci de te péoccuper de ma note mais c'est pour un projet donc on utilise ce qu'on pense etre le mieux donc y'a pas de pb