Allocation dynamique d'un tableau de BITMAP*

**yetimothee** · 02/06/2008, 22h20

Bonjour

Voilà, je suis confronté à un problème assez gènant :
J'aimerais faire une allocation dynamique sur un type BITMAP*.

J'ai donc fais ce code :

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
void alloc_tableau(BITMAP** sprite)
{
    FILE* fichier = fopen("fichier.txt", "r");
    if(fichier == NULL)
    {
        allegro_message("erreur lors de l'ouverture du fichier !");
    }
    char string_temp[255] = "" ;
    char carac_temp = ' ';
    int size_file = 0;
    int i = 0;
 
    //On assigne size_file   
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &size_file);
 
 
    //On alloue dynamiquement sprite
    sprite = malloc(size_file * sizeof(BITMAP*));
 
    fclose(fichier);
}

Ma déclaration du tableau est ainsi faite dans une autre fonction :

Code :

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

1
2
 
BITMAP** sprite ;

Mais ce code ne fonctionne pas en faisant planter le programme...

Une idée ? Merci

**Laurent Gomila** · 02/06/2008, 22h41

Les modifications effectuées sur sprite ne seront pas répercutées hors de la fonction car c'est une copie locale. Passe plutôt un pointeur sur la variable que tu veux modifier (oui je sais, ça fera 3 étoiles... vive le C), ou alors fais en sorte que ta fonction retourne le résultat.

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
void alloc_tableau(BITMAP*** sprite)
{
    *sprite = malloc(...);
}
alloc_tableau(&sprite);
 
Ou alors
 
BITMAP** alloc_tableau()
{
    BITMAP** sprite = malloc(...);
 
    return sprite;
}
sprite = alloc_tableau();

**yetimothee** · 02/06/2008, 22h52

Ah ok, c'est bon.
Merci bien, rapide et eficace, c'est pas souvent le cas

**yetimothee** · 03/06/2008, 12h58

Bien, alors nouveau problème avec ce code :

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
 
void InitBitmap(BITMAP*** sprite, char* nom_fichier)
{
    FILE* fichier = fopen(nom_fichier, "r");
    if(fichier == NULL)
    {
        allegro_message("erreur !");
    }
    char string_temp[255] = "" ;
    char carac_temp = ' ';
    int size_file = 0;
    int i = 0;
 
    //On assigne size_file   
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &size_file);
    allegro_message("Nombre de ligne : %d", size_file);
 
    //On alloue dynamiquement sprite_batiment
    *sprite = malloc(size_file * sizeof(BITMAP));
 
    //On remplie le tableau sprite_batiment
    for(i=0; i< size_file; i++)
    {
        fgets(string_temp, 255, fichier);
        *sprite[i] = load_bitmap(string_temp, NULL);
        allegro_message("i : %d\n%s", i, string_temp);
    }
 
    fclose(fichier);
 
    allegro_message("Fin de la fonction");
}

J'ai mis des "allegro_message afin de situer l'erreur". Celle ci se situe pendant l'assignement du tableau, il ne va pas plus loin que sprite[0], ou sprite[1] dès fois.

Je pense que c'est mon allocation qui est foireuse, mais je ne voit pas en quoi ?

Merci pour votre aide

**Laurent Gomila** · 03/06/2008, 14h24

Tu t'emmêles les pinceaux là

- Il faut allouer des BITMAP* (là tu alloues des BITMAP)
- Attention aux priorités : c'est (*sprite)[i] et non *sprite[i]

Tu ferais mieux de renvoyer ton tableau plutôt que de prendre son adresse en paramètre, ça t'enlèvera une indirection. Parce que là tu t'y perds complétement.

**yetimothee** · 03/06/2008, 18h12

Je suis d'accord avec toi, je m'y perd.
Donc là ça avais l'air de mieux fonctionner, mais finalement, il me retourne une erreur comme quoi après la ligne (*sprite)[i] = truc, eh bien sprite[i] = NULL (pas pour touts les cas au fait, c'est assez bizarre).

Voici mon code :

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
BITMAP** sprite ;
sprite = AllocBitmap("fichier.txt");
InitBitmap(&sprite, "fichier2.txt");
 
void InitBitmap(BITMAP*** sprite, char* nom_fichier)
{
    FILE* fichier = fopen(nom_fichier, "r");
    if(fichier == NULL)
    {
        allegro_message("erreur !");
    }
    char string_temp[255] = "" ;
    char carac_temp = ' ';
    int size_file = 0;
    int i = 0;
 
    //On assigne size_file   
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &size_file);
 
    //On remplie le tableau sprite_batiment
    for(i=0; i< size_file; i++)
    {
        fgets(string_temp, 255, fichier);
        (*sprite)[i] = load_bitmap(string_temp, NULL);
        if(sprite[i] == NULL)
        {
            allegro_message("Erreur lors de l'assignement du sprite %s !", string_temp);
        }
    }
 
    fclose(fichier);
 
}
 
BITMAP** AllocBitmap(char* nom_fichier)
{
    FILE* fichier = fopen(nom_fichier, "r");
    if(fichier == NULL)
    {
        allegro_message("erreur !");
    }
    char string_temp[255] = "" ;
    char carac_temp = ' ';
    int size_file = 0;
    int i = 0;
 
    //On assigne size_file   
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &size_file);
 
    //On alloue dynamiquement sprite_batiment
    BITMAP** sprite = malloc(size_file * sizeof(BITMAP*));
 
    fclose(fichier); 
 
    return sprite;
}

Là je sèche, je ne comprends pas pourquoi ça ne fonctionne pas ?

**Laurent Gomila** · 03/06/2008, 18h26

Tu ne dois jamais accéder à sprite[i]. sprite pointe vers ton tableau, donc tu devras toujours le déréférencer (*sprite) avant d'accéder aux éléments du tableau.

Si tu veux te simplifier le code en retirant une indirection, tu peux travailler sur ton tableau directement et ne l'affecter à *sprite qu'à la fin de la fonction :

Code :

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

1
2
3
4
5
6
BITMAP** tab;
tab = malloc(...);
 
...
 
*sprite = tab;

**yetimothee** · 03/06/2008, 18h37

Hm. J'ai la même erreur lors de l'assignement du tableau. Certains éléments sont assignés, d'autres non...
Je trouve cela curieux.

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
46
47
48
49
50
51
52
53
54
void InitBitmap(BITMAP*** sprite, char* nom_fichier)
{
    FILE* fichier = fopen(nom_fichier, "r");
    if(fichier == NULL)
    {
        allegro_message("erreur !");
    }
    char string_temp[255] = "" ;
    char carac_temp = ' ';
    int size_file = 0;
    int i = 0;
 
    //On assigne size_file   
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &size_file);
 
    //On remplie le tableau sprite_batiment
    for(i=0; i< size_file; i++)
    {
        fgets(string_temp, 255, fichier);
        (*sprite)[i] = load_bitmap(string_temp, NULL);
        if(sprite[i] == NULL)
        {
            allegro_message("Erreur lors de l'assignement du sprite %s !", string_temp);
        }
    }
 
    fclose(fichier);
 
}
 
BITMAP** AllocBitmap(char* nom_fichier)
{
    FILE* fichier = fopen(nom_fichier, "r");
    if(fichier == NULL)
    {
        allegro_message("erreur !");
    }
    char string_temp[255] = "" ;
    char carac_temp = ' ';
    int size_file = 0;
    int i = 0;
 
    //On assigne size_file   
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &size_file);
 
    //On alloue dynamiquement sprite_batiment
    BITMAP** sprite = malloc(size_file * sizeof(BITMAP*));
 
    fclose(fichier); 
 
    return sprite;
}

Je sait pas si tu as vu cette version, j'ai essayé de fragmenter comme tu l'as conseillé de faire, c'est clair que c'est plus clair.
Par contre, je ne sais pas si mon erreur est géré comme il le faut. Car si je n'écris pas dans mon Bitmap, je ne suis pas obligé de faire un truc comme ça ?

Code :

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

1
2
3
4
5
 
if((*sprite)[i] == NULL)
{
    //alors...
}

**Laurent Gomila** · 03/06/2008, 19h22

Tu n'es plus obligé de passer sprite par pointeur puisque tu l'as alloué dans une autre fonction. Maintenant tu peux simplement passer un BITMAP** directement (sprite en lui-même ne sera plus modifié dans la fonction, seulement les éléments vers lesquels il pointe).

**yetimothee** · 03/06/2008, 19h40

Tu veux dire faire ça ?

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
void InitBitmap(BITMAP** sprite, char* nom_fichier)
{
    FILE* fichier = fopen(nom_fichier, "r");
    if(fichier == NULL)
    {
        allegro_message("erreur !");
    }
    char string_temp[255] = "" ;
    char carac_temp = ' ';
    int size_file = 0;
    int i = 0;
 
    //On assigne size_file   
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &size_file);
 
    //On remplie le tableau sprite_batiment
    for(i=0; i< size_file; i++)
    {
        fgets(string_temp, 255, fichier);
        sprite[i] = load_bitmap(string_temp, NULL);
    }
 
    fclose(fichier);
 
}

**Laurent Gomila** · 03/06/2008, 20h45

Tout à fait. Sauf que... comment peux-tu allouer le tableau avant d'avoir lu le fichier, puisque c'est lui qui contient sa taille ?

**yetimothee** · 03/06/2008, 21h15

Mais je le lit mon fichier avant, pour trouver size_file :

Code :

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

1
2
3
//On assigne size_file   
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &size_file);

A moins que ce n'étais pas ce que tu voulais dire ?

Voici mes deux fonctions actuelles :

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
46
47
48
49
50
void InitBitmap(BITMAP** sprite, char* nom_fichier)
{
    FILE* fichier = fopen(nom_fichier, "r");
    if(fichier == NULL)
    {
        allegro_message("erreur !");
    }
    char string_temp[255] = "" ;
    char carac_temp = ' ';
    int size_file = 0;
    int i = 0;
 
    //On assigne size_file   
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &size_file);
 
    //On remplie le tableau sprite_batiment
    for(i=0; i< size_file; i++)
    {
        fgets(string_temp, 255, fichier);
        sprite[i] = load_bitmap(string_temp, NULL);
    }
 
    fclose(fichier);
 
}
 
BITMAP** AllocBitmap(char* nom_fichier)
{
    FILE* fichier = fopen(nom_fichier, "r");
    if(fichier == NULL)
    {
        allegro_message("erreur !");
    }
    char string_temp[255] = "" ;
    char carac_temp = ' ';
    int size_file = 0;
    int i = 0;
 
    //On assigne size_file   
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &size_file);
 
    //On alloue dynamiquement sprite_batiment
    BITMAP** sprite = (BITMAP**)malloc(sizeof(BITMAP*) * size_file);
 
    fclose(fichier); 
 
    return sprite;
}

Et un morceau de ma fonction principale, qui les appelles (pour clarifier :p) :

Code :

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

1
2
3
4
5
6
7
8
9
//On déclare le BITMAP qui va contenir les images des ressources
    BITMAP** sprite_ressources = {NULL} ;
    sprite_ressources = AllocBitmap("data/image/ressource/liste_ressource.txt");
    InitBitmap(sprite_ressources, "data/image/ressource/liste_ressource.txt");
 
    //On déclare le BITMAP qui va contenir les images de batiments
    BITMAP** sprite_batiments = {NULL} ;
    sprite_batiments = AllocBitmap("data/image/building/liste_batiments.txt");
    InitBitmap(sprite_batiments, "data/image/building/liste_batiments.txt");

EDIT : ainsi que les deux fichiers :

data/image/building/liste_batiments.txt

4
data/image/building/main_castle.bmp
data/image/building/farm.bmp
data/image/building/stable.bmp
data/image/building/barracks.bmp

data/image/ressource/liste_ressource.txt

15
data/image/ressource/tree1.bmp
data/image/ressource/tree2.bmp
data/image/ressource/tree3.bmp
data/image/ressource/tree4.bmp
data/image/ressource/tree5.bmp
data/image/ressource/tree6.bmp
data/image/ressource/tree7.bmp
data/image/ressource/tree8.bmp
data/image/ressource/tree9.bmp
data/image/ressource/tree10.bmp
data/image/ressource/tree11.bmp
data/image/ressource/tree12.bmp
data/image/ressource/gold_mine.bmp
data/image/ressource/carrier.bmp
data/image/ressource/carrier_door.bmp

**Laurent Gomila** · 03/06/2008, 22h07

Ok, j'avais pas fait gaffe. C'est quand même pas terrible de lire deux fois les mêmes informations dans un fichier, dont une fois pour rien

Du coup c'est pas vraiment utile de séparer ça en deux fonctions, puisque tu ne fais principalement que dupliquer du code pour rien (je crois pas t'avoir conseillé de faire comme ça

).

**yetimothee** · 03/06/2008, 22h18

Ouai, enfin je trouve ça plus agréable...
Sinon ça marche toujours pas :p

Y a que certains éléments des fichiers qui s'allouent correctement. Je trouve ça très bizarre...
Parce que les codes ont l'air cleans.

**Laurent Gomila** · 04/06/2008, 10h12

Ouai, enfin je trouve ça plus agréable...

Pourquoi ? Dans ta fonction AllocBitmap il n'y a qu'une ligne utile ; tout le reste est un clone de InitBitmap. Dans ce cas on peut s'en faire plein : DeclareBitmap, OpenBitmap, ReadBitmap, AllocBitmap, InitBitmap, AssignBitmap, CloseBitmap, ...

Pour voir ce qui ne va pas, essaye de debugger un peu : par exemple affiche les informations que tu lis du fichier, vérifie qu'elles sont toutes bonnes. Vérifie aussi plus en détail les erreurs renvoyées par Allegro (si possible).

**yetimothee** · 04/06/2008, 15h00

je pense qu'il faudrait que je regarde la taille de mes tableaux.
Y a un moyen de faire ça ?

**Laurent Gomila** · 04/06/2008, 15h54

Afficher size_file ?

**yetimothee** · 04/06/2008, 17h53

Nanan, c'est bon, j'ai réussi

Au fait, l'erreure venais de :

Code :

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

1
2
3
4
5
for(i=0; i< size_file; i++)
    {
        fgets(string_temp, 255, fichier);
        sprite[i] = load_bitmap(string_temp, NULL);
    }

J'ai remplacé par :

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
for(i=0; i< size_file; i++)
    {
        for(j=0; j< 255; j++)
        {
            string_temp[j] = NULL ;   
        }
        j = 0 ;
        carac_temp = ' ';
        do
        {
            carac_temp = fgetc(fichier);
            if(carac_temp != '\n' && carac_temp != EOF)
            {
                string_temp[j] = carac_temp ;
            }
            j++ ;
        }while(carac_temp != '\n' && carac_temp != EOF);
        sprite[i] = load_bitmap(string_temp, NULL);
        if(sprite[i] == NULL)
        {
            allegro_message("Erreure lors de l'allocation de : %s", string_temp);
        }
    }

Et là ça fonctionne impec'. Merci encore pour ton aide

Allocation dynamique d'un tableau de BITMAP*

Allegro

Discussions similaires

Partager

Partager