Allocation de tableau de structure

Version imprimable

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:

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 !

17/09/2010, 08h52
Amnésix

Salut !

armee est bien un pointeur, mais par armee[i]. D'ou l'erreur. Du dois écrire armee[i].peloton[j].
17/09/2010, 12h29
darkwall_37

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

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

Code:

error: incompatible types when assigning to type 't_peloton' from type 'struct t_peloton *'|
17/09/2010, 12h44
jeroman

Et si tu nous montrais t_peloton ?... ;)

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

Code:

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

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

Code:

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;

17/09/2010, 16h27
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:

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]'.

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:

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.

17/09/2010, 17h23
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.
17/09/2010, 17h39
Pouet_forever
Il te manque un pointeur si tu veux faire comme tu le fais :
Code:

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.

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:

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

21/09/2010, 02h19
darkwall_37
Citation:
Envoyé par Pouet_forever

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

Code:

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 ?