Problème struture - malloc
Bonjour à tous !
N'utilisant presque jamais le langage C je me retrouve avec un problème de base :yaisse2:
Voilà je souhaiterais créer :
- une structure "piece" contenant un int couleur et un int "taille"
- une structure "pile" contenant un int "position" et un tableau de pointeurs de pieces.
Seulement voilà, j'arrive à créer des "piece", à afficher leurs contenus. Mais le problème est de créer une "pile" car je ne vois pas comment allouer la mémoire.
voici mon code de "piece" :
Code:
1 2 3 4 5 6 7 8 9 10 11
|
//le piece.h
struct piece{
int taille; //nb etage
int couleur; //peut aussi correspondre au numero du joueur
};
typedef struct piece piece;
piece *createPiece(int,int);
void affichePiece_pt(piece*);
void affichePiece_val(struct piece); |
Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
|
//le piece.c
#include "piece.h"
piece *createPiece(int t, int c){
piece *mapiece;
mapiece=(struct piece*)malloc(sizeof(struct piece));
mapiece->taille=t;
mapiece->couleur=c;
return mapiece;
}
void affichePiece_pt(piece *mapiece){
printf("taille=%d couleur=%d\n",mapiece->taille,mapiece->couleur);
}
void affichePiece_val(struct piece mapiece){
printf("taille=%d couleur=%d\n",mapiece.taille,mapiece.couleur);
} |
Voici mon ébauche de "pile"
Code:
1 2 3 4 5 6 7 8 9
|
//le pile.h
struct pile{
piece **tab;
int position;
};
typedef struct pile pile;
pile *createPile(int); |
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
|
//le pile.c
pile *createPile(int taille){
pile *mapile;
mapile=(pile*)malloc(taille*sizeof(pile));
mapile->tab=(piece**)malloc(taille*sizeof(piece*));
mapile->position=0;
return mapile;
}
void putPiece(pile *mapile,piece *mapiece){
int pos;
pos=mapile->position;
mapile->tab[pos]=mapiece;
mapile->position=pos+1;
}
void affichePile(pile *mapile){
int i,pos;
pos=mapile->position;
for(i=0;i<pos;i++){
affichePiece_pt(mapile->tab[i]);
}
} |
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
|
//le main de pile.c
int main(int argc, char **argv){
piece *mapiece1;
piece *mapiece2;
piece *mapiece3;
piece *mapiece4;
pile *mapile;
printf("debut\n");
mapile=createPile(1);
mapiece1=createPiece(1,1);
affichePiece_pt(mapiece1);
mapiece2=createPiece(2,2);
affichePiece_pt(mapiece2);
mapiece3=createPiece(3,3);
affichePiece_pt(mapiece3);
mapiece4=createPiece(4,4);
affichePiece_pt(mapiece4);
printf("debut ajout\n");
putPiece(mapile,mapiece1);
printf("ca devrait planter\n");
putPiece(mapile,mapiece2);
putPiece(mapile,mapiece3);
putPiece(mapile,mapiece4);
affichePile(mapile);
printf("fin\n");
system("pause");
return 0;
} |
si vous testez ça marche (en théorie) mais ça ne devrais aps car je créer une "pile" de 1 "piece" et je peux en ajouter presque autant que je veux.
Je dois à coup sûr mal allouer (et sachant que la suite de mon projet repose sur des matrices de piles je peux pas me permettre de faire n'importe quoi).
Si quelqu'un pouvait me donne la bonne méthodologie ! D'avance merci :king: