Discussion :

[darkwall_37]

Bonjour,

J'ai un petit souci de compréhension on dirait bien. Le compilateur braille en me disant :

error: invalid type argument of '->' (have 't_armee')

pour la fonction suivante. Les erreurs provenant des lignes surlignées de la même couleur.

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
t_armee *allouerArmee( int *quantite )
{
    t_armee *armee = (t_armee*)malloc(2*sizeof(t_armee));

    if ( armee != NULL )
    {
        int i,j;
        for ( i=0 ; i<2 ; i++)
        {
            if ( i==0 )
            {
                for ( j=0 ; j<quantite[i] ; j++)
                {
                    armee[i]->peloton[j] = (t_peloton*)malloc(sizeof(t_peloton));
                }
            }

            else
            {
                for ( j=0 ; j<quantite[i] ; j++)
                {
                    armee[i]->peloton[j] = (t_peloton*)malloc(sizeof(t_peloton));
                }
            }
        }
    }

    else perror("\n allouerArmee : ");
}

J'aurais aimé aussi pouvoir tester l'allocation de chaque champs. Mais je ne sais pas comment m'y prendre proprement.

Merci d'avance !

[Amnésix]

Salut !

armee est bien un pointeur, mais par armee[i]. D'ou l'erreur. Du dois écrire armee[i].peloton[j].

[darkwall_37]

J'avais essayé mais cela ne marchait pas non plus !

Toujours sur les mêmes lignes le compilateur me renvoi ça :

Code :

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

error: incompatible types when assigning to type 't_peloton' from type 'struct t_peloton *'|

[jeroman]

Et si tu nous montrais t_peloton ?...

[Lucien63]

Je suppose que peloton est un t_peloton alors
ça n'est pas plutot ça que tu voulais faire :

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
 
t_armee *allouerArmee( int *quantite )
{
    t_armee *armee = malloc(2*sizeof(t_armee));
 
    if ( armee != NULL )
    {
        int i;
        for ( i=0 ; i<2 ; i++)
        {            
	armee[i].peloton = (t_peloton*)malloc(quantite[i]*sizeof(t_peloton));            
        }
    }
 
    else perror("\n allouerArmee : ");
}

car la tu essaye d'affecter un pointeur t_peloton a un t_peloton

[darkwall_37]

Non parceque chaque armée dispose de différents pelotons

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* structure representant une unité */
typedef struct
{
    int quantite;
    int type;
    int forceUnitaire;
    int force;
}t_peloton;
 
/* structure representant une armée composée d'unités */
typedef struct
{
    t_peloton *peloton;
}t_armee;

[Pouet_forever]

Tu n'as pas alloué de mémoire pour 'peloton' donc accéder à 'peloton[j]' revient à accéder à... n'importe où. Il te manque un malloc.

Code :

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

1
2
 
armee[i].peloton = malloc(....);

De plus, si tu as un pointeur 'simple' et non pas un pointeur sur pointeur tu n'as pas à allouer de mémoire pour 'armee[i].peloton[j]'.

[darkwall_37]

En fait dans une armée il y a différents pelotons et cela est dynamique d'où l'utilisation d'un pointeur sur t_peloton. Je peux très bien avoir armee0 avec 5 pelotons et armee1 avec 2 pelotons. Alors je ne suis pas sûr de bien comprendre ce que tu m'expliques ici :

De plus, si tu as un pointeur 'simple' et non pas un pointeur sur pointeur tu n'as pas à allouer de mémoire pour 'armee[i].peloton[j]'.

Concernant l'allocation des pelotons, oui en effet faudrait peut être les allouer.
D'où la modification suivante :

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
t_peloton *allouerPeloton ( int *quantite, int armee )
{
    t_peloton *peloton = (t_peloton*)malloc( quantite[armee]*sizeof(t_peloton) );
 
    if ( peloton != NULL )
    {
        return peloton;
    }
 
    else perror("\n allouerPeloton : ");
}
 
t_armee *allouerArmee( int *quantite )
{
    t_armee *armee = (t_armee*)malloc(2*sizeof(t_armee));
 
    if ( armee != NULL )
    {
        int i,j;
        for ( i=0 ; i<2 ; i++)
        {
            if ( i==0 )
            {
                t_peloton *peloton = allouerPeloton( quantite, 0 );
                for ( j=0 ; j<quantite[i] ; j++)
                {
                    armee[i].peloton[j] = (t_peloton*)malloc(sizeof(t_peloton));
                }
            }
 
            else
            {
                t_peloton *peloton = allouerPeloton( quantite, 1 );
                for ( j=0 ; j<quantite[i] ; j++)
                {
                    armee[i].peloton[j] = (t_peloton*)malloc(sizeof(t_peloton));
                }
            }
        }
    }
 
    else perror("\n allouerArmee : ");
}

La grosse blague c'est que le compilateur me sort toujours la même erreur.
Merci.

[Lucien63]

Tu n'as rien compris aux pointeurs !

armee[i].peloton est un pointeur, il peut pointer sur un tableau dynamique de t_peloton

armee[i].peloton[x] est un t_peloton et tu tiens absoluement à lui affecter un pointeur.

Donc tu aura toujours l'erreur.
Et ça ce n'est pas une blague.

[Pouet_forever]

Il te manque un pointeur si tu veux faire comme tu le fais :

Code :

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

1
2
3
4
5
/* structure representant une armée composée d'unités */
typedef struct
{
    t_peloton **peloton;
}t_armee;

Note qu'il y aura aussi quelques modifications à faire dans ton code.

[darkwall_37]

Ah oui en effet, les structures je galère un peu, ce pourquoi je fais cela. Donc remarque pertinente.

Si j'ai bien compris mon erreur cette fois, je suppose que cela devrait être correct. En tout cas cette fois ci, ça compile !

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
t_peloton *allouerPeloton( t_armee *armee, int *quantite, int idArmee )
{
    armee[idArmee].peloton = (t_peloton*)malloc(quantite[idArmee]*sizeof(t_peloton));
 
    if ( armee[idArmee].peloton != NULL )
    {
        return armee[idArmee].peloton;
    }
 
    else perror("\n allouerPeloton");
}
 
t_armee *allouerArmee( int *quantite )
{
    t_armee *armee = (t_armee*)malloc(2*sizeof(t_armee));
 
    if ( armee != NULL )
    {
 
            armee[0].peloton = allouerPeloton( armee, quantite, 0 );
 
            armee[1].peloton = allouerPeloton( armee, quantite, 1 );
    }
 
    else perror("\n allouerArmee : ");
}

[darkwall_37]

Il te manque un pointeur si tu veux faire comme tu le fais :

Code :

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

1
2
3
4
5
/* structure representant une armée composée d'unités */
typedef struct
{
    t_peloton **peloton;
}t_armee;

Note qu'il y aura aussi quelques modifications à faire dans ton code.

Oui car je fais de l'allocation dans une fonction, et pour que l'allocation soit existante en revenant je devrais passer par adresse & la variable peloton d'ou le ** ? c'est bien ça ?