Pointeur de structure dans fonction C Résolu/Fermé

Question

Salut à 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

mamiemando · Accepted Answer

Bon un petit rappel pour commencer. Rappel sur les fonctions en C - En C les paramètres de fonction sont des recopies. - A la fin d'une fonction les variables locales sont effacées. - Par contre ce qui a pu être alloué dans la fonction n'est pas désalloué si ce n'est pas demandé explicitement. Rappel sur les pointeurs Un pointeur sert : 1- à modifier quelque chose qu'on aurait aimé passer en paramètre. Concrètement l'adresse est recopiée, mais pas ce qui est à cette adresse 2- à passer un paramètre plus petit (une adresse est plus rapide à recopier qu'une grosse structure) 3- à ne stocker qu'une fois qu'une donnée si on a besoin dans plusieurs structures. Les allocations mémoires En toute rigueur : - à chaque malloc est associé un free situé dans le même horizon (un horizon est une paire d'accolade) - parfois ce n'est pas possible donc on crée une sorte de constructeur qui fait l'allocation, et on pense à appeler le destructeur à la fin pour libérer la mémoire. Les listes chainées 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 // 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 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

Char Snipeur · Answer

Salut.
En effet, lors de l'appel d'une fonction avec passage par pointeur, l'adresse est RECOPIER.
exemple :
void sqr(double *x){return*x**x;}
int main {double *y=21;*y=sqr(y);...}
ce qui se passe :
Quand tu declare ta variable y, et que tu l'initialise y prend la valeur \0x001. qui pointe vers une mémoire qui contient 21.
Lors de l'appel de la fonction, tu créé une nouvelle variable 'x' qui prend pour valeur : \0x001.
Si au sein de cette fonction tu modifie x en lui changeant sa valeur :
x=\0x003, et que ensuite tu modifie la case pointé par x, tu ne modifie pas la valeur de y, ni sa valeur pointé.
C'est un peu comme si tu fesait la séquance suivante :
double *y=21;// y vaut \0x001
double* x;x=y;
*x=3;//Ok, tu modifie bien la valeur *y
x=new double;// tu modifie le pointeut x qui vaut \0x002
*x=32;// tu modifie *x, mais pas *y car y vaut toujours \0x001

Voilà, j'espère que ça va t'aider et que j'ai été suffisament clair.

solid360 · Answer

Ok, j'ai compris mon problème merci d'avoir répondu aussi vite.

Pointeur de structure dans fonction C

3 réponses

Discussions similaires