Allocation dynamique d'un tableau de BITMAP*

Version imprimable

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:

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:

1 2 BITMAP** sprite ;
Mais ce code ne fonctionne pas en faisant planter le programme...

Une idée ? Merci :)

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:

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();

02/06/2008, 22h52
yetimothee

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

Bien, alors nouveau problème avec ce code :

Code:

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 :)

03/06/2008, 14h24
Laurent Gomila

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.

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:

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 ?

03/06/2008, 18h26
Laurent Gomila
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:

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

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:

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:

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

03/06/2008, 19h22
Laurent Gomila

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).

Tu veux dire faire ça ?

Code:

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);
 
}

03/06/2008, 20h45
Laurent Gomila

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

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

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:

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:

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

Citation:

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

Citation:

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

03/06/2008, 22h07
Laurent Gomila

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 ;)).
03/06/2008, 22h18
yetimothee

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.
04/06/2008, 10h12
Laurent Gomila

Citation:

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).
04/06/2008, 15h00
yetimothee

je pense qu'il faudrait que je regarde la taille de mes tableaux.
Y a un moyen de faire ça ?
04/06/2008, 15h54
Laurent Gomila

Afficher size_file ?

Nanan, c'est bon, j'ai réussi :)
Au fait, l'erreure venais de :

Code:

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:

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 :D