Allocation dynamique de structure

Version imprimable

Bonjour,

J'aimerai savoir si l'un d'entre vous sait comment je peux declarer, allouer et initialiser un tableau de structures.

En fesant ainsi :

Code:

1
2
3
4
5
6
7
8
t_op gl_operators[] = {                                                                           
  {' ', my_plus, 1},                                                                              
  {' ', my_moin, 1},                                                                              
  {' ', my_mul, 2},                                                                               
  {' ', my_mod, 2},                                                                               
  {' ', my_div, 2},                                                                               
  {0, 0, 0}                                                                                       
};

tout marche correctement mais lorsque je tente de faire de cette maniere :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
t_op  *op_priorities;
op_priorities = (t_op *)malloc(sizeof(*op_priorities) * 7);
op_priorities = {                                                                               
    {op_base[1], my_plus, 1},                                                                     
    {op_base[2], my_moin, 1},                                                                     
    {op_base[3], my_mul, 2},                                                                      
    {op_base[4], my_mod, 2},                                                                      
    {op_base[5], my_div, 2},                                                                      
    {0, 0, 0} 
};

j'ai un parse error ...

pareille si j'essayer d'initialiser ligne par ligne:

Code:

op_priorities[0] = {op_base[1], my_plus, 1};

Je suis obliger d'initialiser champ par champ ??

Merci

27/10/2006, 16h26
Faiche
Code:

1 2 3 t_op *op_priorities; op_priorities = (t_op *)malloc(sizeof(*op_priorities) * 7);
sizeof (*op_priorities) ?? y a rien qui te choque ?

Et puis si tu alloues un tableau de pointeur, n essaye pas d y mettre des structures.
27/10/2006, 16h48
Emmanuel Delahaye
Citation:
Envoyé par Faiche

Code:

1 2 3 t_op *op_priorities; op_priorities = (t_op *)malloc(sizeof(*op_priorities) * 7);

sizeof (*op_priorities) ?? y a rien qui te choque ?
Non, au contraire.

http://emmanuel-delahaye.developpez....tes.htm#malloc

mais au risque de te choquer encore plus, je l'aurais écrit comme ça :

Code:

t_op *op_priorities = malloc (sizeof *op_priorities * 7);

Citation:

Et puis si tu alloues un tableau de pointeur, n essaye pas d y mettre des structures.

C'est bel et bien un tableau de 7 structures qui a été alloué tout à fait régulièrement. Il n'y a rien à redire sur cette partie du code de l'OP.

Citation:

Envoyé par malves

Bonjour,

J'aimerai savoir si l'un d'entre vous sait comment je peux declarer, allouer et initialiser un tableau de structures.

En fesant ainsi :

Code:

1
2
3
4
5
6
7
8
t_op gl_operators[] = {                                                                           
  {' ', my_plus, 1},                                                                              
  {' ', my_moin, 1},                                                                              
  {' ', my_mul, 2},                                                                               
  {' ', my_mod, 2},                                                                               
  {' ', my_div, 2},                                                                               
  {0, 0, 0}                                                                                       
};

tout marche correctement mais lorsque je tente de faire de cette maniere :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
t_op  *op_priorities;
op_priorities = (t_op *)malloc(sizeof(*op_priorities) * 7);
op_priorities = {                                                                               
    {op_base[1], my_plus, 1},                                                                     
    {op_base[2], my_moin, 1},                                                                     
    {op_base[3], my_mul, 2},                                                                      
    {op_base[4], my_mod, 2},                                                                      
    {op_base[5], my_div, 2},                                                                      
    {0, 0, 0} 
};

j'ai un parse error ...

pareille si j'essayer d'initialiser ligne par ligne:

Code:

op_priorities[0] = {op_base[1], my_plus, 1};

Je suis obliger d'initialiser champ par champ ??

Merci

Oui, ou alors, il faut définir un tableau de structures initialisée et faire une copie.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
{
   t_op  *op_priorities = malloc (sizeof *op_priorities * 6);
   if (op_priorities != NULL)
   {
      /* initialisation */
      {
         /* tableau de structures initialisee en lecture seule */
         static t_op const z[] = 
         {                                                                           
           {' ', my_plus, 1},                                                                              
           {' ', my_moin, 1},                                                                              
           {' ', my_mul, 2},                                                                               
           {' ', my_mod, 2},                                                                               
           {' ', my_div, 2},                                                                               
           {0, 0, 0}                                                                                       
         };
          /* recopie */
         *op_priorities = z;
      }
 
      /* ... suite ... */
   }

02/11/2006, 11h58
malves

Merci pour l'astuce :D
02/11/2006, 12h07
Stevie Wonder

Ca sent encore le ptit gars d'EPITECH ca ;) Tous les ans a la meme periode ce forum voit debouler des gens avec le meme genre de questions :p