Se connecter avec
S'enregistrer | Connectez-vous

struct en C

Dernière réponse : dans Programmation

Bonjour,

J'ai un probleme avec ma structure suivante :

typedef struct Bloc{
NODE *Instruction;
struct Bloc *Suivant;
struct Bloc *Precedent;
int NbInstruct;
int NbPred;
int NbSucc;
}Block;

Instruction,Suivant et Precedent sont des tableaux;

j'initialise ainsi :

Cour->Instruction=(NODE *) malloc(sizeof(NODE));;
Cour->Suivant=(Block*)malloc(sizeof(Block));
Cour->Precedent=(Block*)malloc(sizeof(Block));


les affectations de ce type ne marche pas :
Cour->Suivant[Cour->NbSucc]=suivant;

suivant est de type :
Block suivant;

le probleme est une erreur de type lors de l'affectation :
incompatible types in assignment.
J'aimerais pouvoir utiliser des tableaux de successeurs et précédents puisqu'il y ena plusieurs.
Merci d'avance.

Autres pages sur : struct

Lassé par la pub ? Créez un compte

Vamos2 a dit :
le probleme est une erreur de type lors de l'affectation :
incompatible types in assignment.
J'aimerais pouvoir utiliser des tableaux de successeurs et précédents puisqu'il y ena plusieurs.
Merci d'avance.

Je crois que tu fais une grave confusion entre tableaux et listes chainées. Cour->Suivant n'est pas un tableau. Cour->Suivant[...] n'a donc aucun sens.

Ceci compile, mais je ne sais pas ce que tu veux faire exactement.

#include <stdlib.h>

typedef struct
{
int dummy;
}
NODE;

typedef struct Bloc
{
NODE *Instruction;
struct Bloc *Suivant;
struct Bloc *Precedent;
int NbInstruct;
int NbPred;
int NbSucc;
}
Block;

int main(void)
{
Block *Cour = malloc(sizeof * Cour);

Cour->Instruction = malloc (sizeof * Cour->Instruction);
Cour->Suivant = malloc (sizeof * Cour->Suivant);
Cour->Precedent = malloc (sizeof * Cour->Precedent);

{
Block *suivant = malloc(sizeof * Cour);

Cour->Suivant = suivant;
}
return 0;
}

Attention, ni contrôle, ni libération.

http://mapage.noos.fr/emdel/notes.htm#malloc

Vamos2 a dit :
J'aimerais pouvoir gérer plusieurs successeurs et prédécesseurs pour cette structure si t'a une idée plus "propreé je suis preneur

Dans ce cas, il faut faire un tableau de pointeurs :

soit statique (static array) :
typedef struct Bloc
{
<...>
struct Bloc *sa_Suivant[NbSucc];
}
Block;

soit dynamique (dynamic array)
typedef struct Bloc
{
<...>
struct Bloc **da_Suivant;
int NbSucc;
}
Block;


L'allocation se fait alors ainsi (non compilé, non testé) :

Block *p = malloc (sizeof *p);

if (p != NULL)
{
int NbSucc = 10; /* arbitraire (reallocable si besoin est) */
/* allocation du tableau de pointeurs */
p->da_Suivant = malloc (sizeof *p->da_Suivant * NbSucc);

if (p->da_Suivant != NULL)
{
int i;

p->NbSucc = NbSucc;

/* initialisation du tableau de pointeurs */
for (i = 0; i < p->NbSucc;
{
p->da_Suivant[i] = NULL;
}
/* ready ... */
}
Lassé par la pub ? Créez un compte

Créer un nouveau sujet