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

ah mais non ca marche c exactement ce que je voulais, j'avais compris qu'il fallait mettre la structure ds la fonction mais c bon
merci pollux

edit:j'avais ecris un petite betise

bon g encore un bleme,comment ca marche scanf ???
quand je fais ca, camarche pas :
int t=0;
scanf("%d",t);
tigcc dit: format argument is not a pointer (arg5) ?!

ça te dirait vraiment pas de lire un tuto sur le C, ou la doc des fonctions que tu utilises?
essaies &t par ex ...

oui dsl , jmen sui rendu compte apres avoir posté

bon maintenant g un probleme avec les listes chaînées et le C, aucune de mes fonctions c++ ne fonctionne...
si on prend la definition de liste chaînées ci dessous,

typedef struct
{
char data;
struct liste *psuiv;
}liste;

pourquoi dans une fonction je peux pas faire :

p1->psuiv=malloc(sizeof(liste));
p1->psuiv->data='a';//ici ca ne va pas du tou

Ça passe avec un compilo c++, ça ?
demande même si on peut pas virer le "struct" };

À mon avis, pour compiler en C++, tu écrivais ça :struct liste
{
  char data;
  struct liste *psuiv; // Je me

ruct s_liste { char data; struct s_liste *psuiv; }liste;Enfin, quoiqu'il en soit en C, c'est comme ça qu'il faut faire :typedef st

oui enfin le typedef n'est pas indispensable, tu peux aussi faire en C comme dans ton premier exemple (mais sûrement pas virer le struct)

Et en C++, tu peux le virer le struct ?

ouep ... ne pas virer le struct, perso, je fais toujours comme ça:

typedef struct liste liste_t;
struct liste
{
  char data;
  liste_t *psuiv;
};

M'enfin, apres, c'est chacun sa merde pour ça

Il me semble sasume ... pke le struct est en fait une classe en C++

ba oui, j'ai jamais dit que ma declaration etait du cpp , les listes chaines sont defini par des classes en cpp(plu simple)

mais je ne comprends pas pourquoi tigcc n'accepte pas la notation el->el->data

j'ai reglé le probleme en passant pas un poiteur intermediaire mais maintenant j'arrive pas a libere la place occupé par ma liste ...
voila mon code :

typedef struct
{
char data;
short r;
struct liste *psuiv;
}liste;
liste *pini=0;
void creation(char i)
{
  if(pini==0)
  {
    pini=malloc(sizeof(liste)); 
    pini->data=i ; 
    pini->r=0;
    pini->psuiv=0;   }
  else   {
    liste *p1=malloc(sizeof(liste));liste *p2=malloc(sizeof(liste));
    int r=0;
    p1=pini;
    while(p1!=0) 
    {
      p2=p1;
      p1=(liste*)p1->psuiv;
      r++;
    }
    p1=(liste*)p2->psuiv=malloc(sizeof(liste));   
   p1->data=i ; 
    p1->r=r; 
    p1->psuiv=0; 
  }  
}
void destruction()
{
  liste *p1=malloc(sizeof(liste));liste *p2=malloc(sizeof(liste));
    p1=pini;
    while(p1!=0) 
    {
      p2=p1;
      p1=(liste*)p1->psuiv;
      free(p2);
    }
    p1->psuiv=NULL;
}

ma fonction "destruction" ne fonctionne pas !!! et au bout d'1 moment ca fait planter grave la caltos... je ne comprend pas pkoi...

p->(e.truc)

On t'a dit pourquoi, t'as lu ?
iste;

ceci :typedef struct 
{ 
char data; 
short r; 
struct liste *psuiv; 
}l

ne peut pas marcher... il faut utiliser une des deux méthodes de Sasume ou celle de nEUrOO (mais si tu utilises la première méthode de Sasume il faut aussi remplacer partout après "liste" par "struct liste" donc c'est moins pratique a priori)

Meuh non moi aussi j'ai mis un typedef donc pas besoin de remplacer quoi que ce soit.

void destruction() 
{ 
  liste *p1=malloc(sizeof(liste));liste *p2=malloc(sizeof(liste)); 
    p1=pini; 
    while(p1!=0)  
    { 
      p2=p1; 
      p1=(liste*)p1->psuiv; 
      free(p2); 
    } 
    p1->psuiv=NULL; 
}

Euhhh... regarde là, tu fais un *p1=malloc(xxx) et après tu changes la valeur de p1... autrement dit tu jettes à la poubelle toute la mémoire que tu viens d'allouer... alors si tu fais ça souvent c'est pas étonnant qu'il ne t'en reste plus beaucoup à la longue.

mais non ca marche parfaitement la premiere partie , y'a que "destruction" qui marche pas ! ,j'ai testé une dizaine de fois avec ceci

void affich() // affiche toute la liste
{
  liste *p1=malloc(sizeof(liste));
  printf("\n{");
  p1=pini;
  for(;;) // boucle infini
  {
    printf("%c",p1->data); // on affiche l'elemeny
    p1=(liste*)p1->psuiv; // on passe au suivant
    if(p1==0) // si c'est le dernier on ferme l'accolade et on se casse
    {
      printf("}") ;
      return;
    }

  }  
}
void _main(void)
{
short i;
char a[10]={'c','a',' ','m','a','r','c','h','e','!'};
for(i=0;i<10;i++)
  {
  
  creation(a[i]);  
  }
clrscr()  ;affich(); ngetchx();
destruction();
}

C ce que Sally t'expliques

p1=(liste*)p2->psuiv=malloc(sizeof(liste));euh ça tu ferais mieux de l'écrire un peu plus clairement (perso je ne connais pas assez bien les priorités du C pour savoir ce que ça fait )
sinon ta fonction destruction fait n'importe quoi :
1/ elle alloue de la mémoire pour rien (pquoi y a des malloc ???)
2/ regarde mieux la dernière ligne... tu déréférences un pointeur nul.

oui dsl y'a eu un cross
en fait si y'a des malloc c'est parce que ss malloc c'a fait protected memory violation, c'est ca qui me derange

quant à p1=(liste*)p2->psuiv=malloc(sizeof(liste)); voila ce que ca fait :
dans p2 on a le dernier element de la liste car p2->psuiv=0; il faut donc lui allouer la memoire necessaire pour pointer sur un nouvel element de la liste, c pkoi je fais p2->psuiv=malloc(sizeof(liste)); ensuite si je met ce pointeur dans p1 c'est parceque tigcc refuse categoriquement de mettre deux '->' a la suite, il lui faut un pointeur intermediaire :
tigcc rfuse p2->psuiv->data mais accepte, p1=p2->psuiv; p1->data

par contre si j'enleve p1->psuiv=NULL; ca ne marche que 1 fois ensuite, adress error

matthieu :
ensuite si je met ce pointeur dans p1 c'est parceque tigcc refuse categoriquement de mettre deux '->' a la suite, il lui faut un pointeur intermediaire :
tigcc rfuse p2->psuiv->data mais accepte, p1=p2->psuiv; p1->data

C'est normal... regarde ce qui est pointé
toi, tu écris que ce qui est pointé est un pointeur vers une structure liste
or c'est une structure liste
p2->psuiv.data devrait marcher

Il n'y a aucun rapport entre protected memory violation et tes malloc !
La violation c'est parce que tu fais « p1->psuiv=NULL; » avec p1 = NULL (autrement dit tu tentes d'écrire 0 à l'adresse 0x04, ce qui heureusement ne peut pas marcher...)

adress error ça veut dire que tu fais free sur une adresse qui n'est pas le résultat d'un malloc.

Sinon je crois qu'avec tigcc les variables globales (comme là pini si j'ai bien suivi) ne sont pas réinitialisées à chaque exécution si le programme n'est pas archivé ; ça peut peut-être poser des problèmes.

Sally
: adress error ça veut dire que tu fais free sur une adresse qui n'est pas le résultat d'un malloc.

Pas vraiment, ça veut dire que tu tentes de lire ou écrire une donnée de deux ou quatres octets à une adresse impaire.

Sally
: Sinon je crois qu'avec tigcc les variables globales (comme là pini si j'ai bien suivi) ne sont pas réinitialisées à chaque exécution si le programme n'est pas archivé ; ça peut peut-être poser des problèmes.

Tout à fait.

d'accord mais maintenant ca marche plus du tou, pini reste nulle je ne comprend VRAIMENT pas pkoi!!!

#include <tigcclib.h>
typedef struct
{
	char data;
	short r;
	struct liste *psuiv;
}liste;
liste * creation(void)
{
return NULL;
}
void ajout(char i,liste *pini)
{  
  if(pini==0) 
  {
    pini=malloc(sizeof(liste)); 
    pini->data=i ; 
    pini->r=0; 
    pini->psuiv=0; 
  }
  else 
  {
    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; 
  }  
}
void affich(liste *pini) 
{
  liste *p1=malloc(sizeof(liste));
  printf("\n{");
  p1=pini;
  for(;; )
  {
    printf("%c",p1->data); 
    p1=(liste*)p1->psuiv; 
    if(p1==0) 
    {
      printf("}") ;
      return;
   }
  }  
}
void destruction(liste *pini)
{
  	liste *p1,*p2;
    p1=pini;
    while(p1!=0) 
    {
      p2=p1;
      p1=(liste*)p1->psuiv;
      free(p2);
    }
   // p1->psuiv=NULL;
}
void _main(void)
{
short i;
char a[11]={'c','a',' ','m','a','r','c','h','a','i','t'};
liste* p=creation();

for(i=0;i<10;i++)
  {
 
  ajout(a[i],p);  
  }
//clrscr()  ;affich(p); ngetchx();
destruction(p);
}

Et il garde toujours son struct liste * dans son typedef erroné...
avec son typedef, il n'y a pas de struct liste...
Il y a un type personalisé liste qui équivaut à struct {...}
Donc, c'est ça qui empêche de marcher...

liste *p1=malloc(sizeof(liste));liste *p2=malloc(sizeof(liste));
int r=0;
p1=pini;

Erreur: tu perds la mémoire allouée: ce n'est pas du java, elle ne sera pas libérée automatiquement!!

PS: Evite de mélanger les 0 et les NULL: je te conseille de mettre tous tes pointeurs zéros en NULL, tu t'y retrouveras plus facilement

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

je crois qu'il avait mis pini en var globale...