Salut tout le monde,
 
 
J'ai créé une stucture "Mon_Tampon" :
 

 
Une fonction :

 
et une autre dont la definition est :

 
Mon probleme c'est que je ne sais pas quoi mettre a la place des ??? dans la fonction si dessous, je pensais que c'était des adresses donc des "&" mais ca a pas l'air de marcher. Est ce du au fait que je considère des fois mon tampon comme modifiable et d autres fois non ?
 

 
merci de m'avoir lu : )

dans ton preleve_valeur_tampon, tu fais passer un pointeur sur une structure mon_tampon, et dans la fonction tampon_vide tu attends une structure mon_tampon
 
pourquoi tu utilise pas des pointeurs dans les deux cas  ?

je pensais que je devait creer ces structures "modifiables" en mettant un pointeur que quand je les modifiais, quand je remplis le tampon je rentre des valeurs dans mon tableau tampon de la structure alors que quand je regarde si le tampon est vide, je ne le modifie pas. Donc je pensais pas avoir besoin d' *.
 
D'apres ce que tu me dis, si dans ma fonction preleve_valeur_tampon je veux utiliser un pointeur sur une structure il faut donc que ma fonction booleenne aient aussi obligatoirement ces caracteristiques ?
 
_Bool tampon_vide (Mon_Tampon *le_tampon)    
      {        
           return  (le_tampon->dernier_element_lu==TAILLE_TAMPON) ;    
      }
 
ok. et pourquoi je peux pas appeller
remplir_tampon (&le_tampon,nomdufichier) ;
>> logiquement ca devrait marcher, non ?

non si tu passe un pointeur par référence, ça peux pas être la structure mon_tampon que tu attends...

ça n'existe pas en C

ce n'est pas ce qu'il essai de faire ?

edit: j'ai pas dit que ça existait mais que c'est ce qu'il faisait... non ?    

je comprends pas tout...
Suis pas tres doué.
 
qu'est ce que vous appelez "passer un pointeur par référence" ?

&variable, c'est passer variable par référence
 
hors variable dans ton cas est un pointeur... donc ça ne vas pas

ben... dans mon main :     remplir_tampon (&my_tampon,nomdufichier); marche tres bien.  
Ah, a moins que ce soit parce que dans le main j'ai déclaré:
Mon_tampon my_tampon;
 
Bref, il y a pas de solution alors ?

dans ton main, tu fait un "Mon_tampon tampon" ou "Mon_tampon *tampon" ?
c'est différent !

dans mon main je fait un :
Mon_Tampon tampon;
 
car une fois j'avais mis une étoile et je m'étais fait jeter...

ahah normal
 
va jeter un coup d'oeil aux pointeurs et passage de valeur par référence

"ahah normal" ?
qu'est ce qui est normal que je me sois fait jeter ou que ca marche pas ?

que ça marche pas

et que tu te fasse jeter par GCC aussi    

bon j'abandonne...
merci quand meme
bye

c'est absolument faux. Après tu vas me dire que joues sur les mots ... mais absolument pas. La seule sémantique du C, c'est le passage par valeur. Ne pas comprendre ça, c'est ne rien comprendre aux pointeurs.

N'abandonne pas, je vais essayer de t'expliquer
 

ok
 

Bon, là c'est moins bon. T'as dû apprendre qu'en C, toute fonction recevait une copie de la variable qu'on lui passe. Là, chaque fois que t'appelleras "tampon_vide", le C devra copier toute la structure dans la variable "le_tampon". Ca marche mais c'est énorme et trop lourd.
Pourquoi ne passerais-tu pas simplement l'adresse de ta structure à ta fonction, qui elle la stockerait dans un pointeur réservé à cet effet ? Une adresse ne faisant que 2 octets tu gagnes amplement en rapidité

 
Et dans le main, au lieu de faire

 
Tu fais

 
C'est en effet la principale difficulté de l'apprentissage des pointeurs. Ma fonction reçoit un pointeur mais quand je l'appelle, je ne sais pas s'il faut lui mettre "*" ou "&"

On va raisonner

• ta fonction reçoit une variable de type "Mon_Tampon étoile" (t'as remarqué, j'ai écrit le mot "étoile" car il est important, il faut partie intégrante du type). C'est donc une adresse sur un type "Mon_tampon"

Maintenant, dans l'appelant, quelle est ma variable qui est de type "Mon_Tampon étoile" ? je n'en vois qu'une: il s'agit de "le_tampon". Donc c'est "le_tampon" que tu passes tel quel à ta fonction...

Ce raisonnement est correct pour une variable simple. Si la fonction doit la modifier alors on lui passera un pointeur sur la variable, sinon on ne lui passera qu'une copie.
Le raisonnement reste valable pour une structure mais on tombe dans le problème du temps de copie justement. Comme ce temps peut devenir incalculable, on préfère généralement ne pas avoir à s'en préoccuper et on n'utilise que des pointeurs
 

Exact
 

Parce qu'il faut maintenant te placer du point de vue de l'appelant. Si l'appelant est lui-même une fonction qui n'a reçu qu'un pointeur, elle passe ce pointeur tel quel à la fonction appelée
Ex:

 
Maintenant, si l'appelant a en main la vraie variable de type "Mon_Tampon" et non-plus un simple pointeur (par exemple si l'appelant est le "main()" ), alors l'appelant doit passer un pointeur à la fonction. Donc il doit lui passer l'adresse...
Ex:

Laisse tomber. C'est une notion de C++ qui n'existe pas en C. En C, tu n'as que 2 façons de passer une variable

• par copie
• par adresse