|
|
|
|
Pointeur de structure dans fonction C
Dernière réponse le 7 déc 2006 à 11:08:31 solid360, le 6 déc 2006 à 22:48:36Salut à tous,
j'ai une fonction InsereDansListe rien de plus normal qui doit commme son nom l'indique inserer un pointeur vers un element dans une liste.
Le probleme c'est que lorsque je passe un pointeur sur une liste vide ou même pleine et que j'alloue un emplacment mémoire pour la stocker, je perd le pointeur quand je sors de la fonction et c'est comme si javai pisser dans un violon.
Pourtant, je pensai qu'en faisant un pointeur cela conserverai mes opérations même à la sortie de la fonction.
Voila la fonction :
int InsereDansListe(Liste *L, Tache *Nouvelle) //insérer une nouvelle tache dans la liste L.
{
Liste* New = (Liste*)malloc(sizeof(struct liste));
if (New == NULL)
return 0;
InitListe(New);
New->t = Nouvelle; //pointeur sur la tâche
if (ListeVide(L)){
L = New;
}
else {
while (L->suivant != NULL){
L = L->suivant;
// Si la tâche est déjà présente dans la liste
if (L->t == Nouvelle){
free(New);
return 0;
}
}
L->suivant = New;
}
return 1;
}
Merci d'avance à ceux qui me répondront
Bon un petit rappel pour commencer.
typedef struct maillon{
struct maillon * suivant;
int *data; // dans ton cas une tâche
} maillon_t;
typedef maillon_t * liste_t;
int inserer_tache(liste_t * l,int nouveau){
maillon_t * mcur,mlast;
for(mcur = l; mcur; mcur = mcur->suivant){
if( *(mcur->data) == nouveau ) return 0; // deja présent dans la liste
}
// liste parcourue, on a rien trouvé ! ajout du nouveau maillon
mcur->suivant = (maillon_t *)malloc(sizeof(maillon_t));
mlast = mcur->suivant;
mlast->suivant = NULL;
mlast->data = nouveau;
return 1;
}
Mieux que les listes, les sets Concrètement ce n'est pas une structure très rapide car l'insertion et l'accès se font en O(n). Une structure de liste triée serait plus rapide, mais idéalement il faudrait une structure d'arbre pour bénéficier d'une dichotomie. Celà suppose que tu aies une relation d'ordre sur les datas. En C++ ca s'écrit présque immédiatement :
#include <set>
// Definition d'une tache
struct tache_t{
int x;
tache_t(int x0=0):x(x0){}
};
// La relation d'ordre
bool operator<(
const tache_t & t1,
const tache_t & t2
){
return (t1.x < t2.x);
}
int main(){
std::set<tache_t> taches; // ensemble des taches
tache_t t1(1),t2(5),t3(2);
taches.insert(t1);
taches.insert(t2);
taches.insert(t3);
return 0;
}
Le set permet définit un ensemble ordonné d'élément insérés de manière unique. L'accès et l'insertion se font en O(log(n)) ce qui est nettement plus rapide... Bonne chance |
Salut.
|

