est ce qu'on peut faire passer un 'type' en argument d'une fonction? - Page 3

ah ? possible bon, bah si c le cas ... pas la peine de le passer en paramètre:
void ajout(char i,liste *pini)

Link > non apparemment il a changé ça... donc nEUrOO a raison, il faut utiliser liste **pini comme paramètre dans ajout, remplacer partout pini par *pini dans cette fonction, et dans main passer en argument à ajout &p et non p

matthieu>Je c pas si tu le sais déjas, mais en C, quand tu as un pointeur vers une structure, tu utilises soit p_struct->champ (recommandé) soit (*p_struct).champ. Si t'as une structure, tu doit faire v_struct.champ.

Ouep, ce que j'ai dit plus haut koi

Exact^^

mais qu'est ce que vous racontez ?!!! vous voulez que j'utilise un poiteur sur un poiteur sur une structure liste et ensuite vous voulez que j'utilise '->'.

laissez tomber, l'erreur se situe au niveau de l'initialisation de pini, la fonction creation, voit pini toujours null meme si elle l'a modifie :
si on fait ceci :

liste * creation(void)
{
liste *pini=malloc(sizeof(liste)); 
    pini->data=0 ; 
    pini->r=0; 
    pini->psuiv=0; 
    return pini;
}
void ajout(char i,liste *pini)
{  
  
    liste *p1=malloc(sizeof(liste));liste *p2=malloc(sizeof(liste));
    int r=0;
    p1=pini;
    while(p1) 
    {
      p2=p1;
      p1=(liste*)p1->psuiv;
      r++;
    }
    p1=(liste*)p2->psuiv=malloc(sizeof(liste)); 
    p1->data=i ; 
    p1->r=r; 
    p1->psuiv=0; 
    
}

on perd la taille d'1 element de la liste mais ca marche,

et dites , ...la ds mon code ya que des pointeurs, pourquoi vous me parlez de v_struct.champ...

parceque ta liste est une structure !!
et enfin, si tu relis tous les posts, tu sauras répondre à ton problème

liste *p1=malloc(sizeof(liste));liste *p2=malloc(sizeof(liste));
ça c'est toujours aussi n'importe quoi que dans l'autre fonction... tu jettes de la mémoire à la poubelle...
et sinon quand on parle de pointeur vers un pointeur c'est justement pour que tu puisses modifier la variable sans devoir utiliser un return ; si tu ne fais pas comme ça, la variable que tu modifies dans ta fonction est une copie locale de la variable passée en argument et ne modifie donc pas cette dernière.
C'est-à-dire que tu aurais pu faire :

liste * creation(liste **pini) 
{ 
*pini=malloc(sizeof(liste));  
    *pini->data=0 ;  
    *pini->r=0;  
    *pini->psuiv=0;  
} 

Et ensuite appeler cette fonction par « creation (&pini); ». Tu peux aussi faire ça avec un return, effectivement.

ok g pigé g suivi vos conseil et desormail 0 de memoire perdu (pfiouuu deja un probleme de reglé)
maintenant je comprend pas cette histoire de pointeur que je ne peux pas modifier,

tu dois passer par un pointeur de pointeur sur liste por pouvoir modifier pini dans ajout

pourquoi ????

a j'ai compris !!! c'est parce que je modifie le pointeur meme, et pas ce que pointe le pointeur !!!!!

merci sally

y dechire ce forum !!!

#et donnez moi la réponse directement la prochaine fois#

... j'ai jamais dis ca !!!!!

Sinon, pour la question d'origine: on peut s'amuser avec des macros dans certains cas. Les sources du linker de TIGCC sont un bon endroit pour trouver des macros utilisées pour des fonctions polymorphes.