Bonsoir,
je débute en C, je suis actuellement au chapitre sur les pointeurs, voici un exemple de programme :

 
Donc de ce que j'ai compris, ce programme multiplie par 3 la variable nombre, mais je ne comprends pas pourquoi.
Pour moi ce programme fait donc :  
dans la fonction, " *pointeur_du_nombre " ceci correspond à une adresse, ce serai cette adresse qui serai multiplié par 3 et non la valeur que cette adresse représente.
Pouvez vous m'éclaicir sur ce point ? Merci
 
 

Il ne faut pas confondre la déclaration dans le nom de la fonction int *pointeur_du_nombre qui dit que pointeur_du_nombre est une adresse et *pointeur_du_nombre dans le corps de la fonction qui prend la valeur pointée par l'adresse pointeur_du_nombre.
Ais-je été clair ?
 *pointeur_du_nombre*=3; signifie que le nombre pointé par l'adresse  pointeur_du_nombre est multiplié par 3.

Ouais, voilà.
 
Pour t'en assurer, tu peux faire quelque chose comme ça :
 

Quand tu fais ceci,  
fonction(&nombre);
tu passes à fonction l'adresse de la variable nombre de type entier.
Maintenant, pour que ça marche, il faut que fonction accepte comme paramètre l'adresse d'une variable de type entier.
Et en C, qui est un langage très primitif, il n'y a pas moyen de dire "je définis une fonction qui accepte comme paramètre l'adresse d'une variable de type entier" (des langages plus évolués le permettent), alors, il faut ruser:
En C, une variable pointeur sur le type int, int *toto, c'est une variable toto, dont la valeur est l'adresse d'une zone contenant un certain nombre d'entiers. Et nous, ce qu'on veut passer, c'est l'adresse d'une zone contenant un (seul) entier. C'est donc compatible, et c'est ce qu'on va utiliser faute de mieux:
en déclarant void fonction(int *pointeur_du_nombre);
on va pouvoir utiliser fonction en lui passant l'adresse de nombre, fonction(&nombre) sans que le compilateur y trouve à redire.
Et quand dans la fonction, je vais travailler sur la valeur pointée, *pointeur_du_nombre, c'est que je considère que pointeur_du_nombre est l'adresse d'une zone contenant un certain nombre d'entiers, et que *pointeur_du_nombre est le premier entier de la zone (le second serait *(pointeur_du_nombre+1))
Donc si pointeur_du_nombre vaut &nombre, le premier entier de la zone sera la valeur de nombre (et si je modifie *pointeur_du_nombre, alors je modifie aussi la valeur de nombre)
 
Pourquoi fais t-on ceci fonction(&nombre) et non pas fonction(nombre)?
Parce que le langage C est primitif, quand on fait fonction(toto); on copie la valeur de toto, et on travaille sur la copie (en oubliant d'ou elle vient).
Quand le fonction est terminée, c'est la copie qui a été modifiée, mais pas l'original.
quand on fait fonction(&toto); on copie la valeur de &toto, et on travaille sur la copie (en oubliant d'ou elle vient).
Mais cette copie a toujours pour valeur l'adresse de toto, et donc au final ce sera toujours toto qui sera modifié par la fonction.
 
Donc on passe par adresse quand on veut une fonction qui modifie les valeurs des variables passées, et on passe par valeur quand on ne veut pas de modification des valeurs des variables passées.
 
Un autre de cas de figure de passage par adresse, c'est quand on veut passer quelque chose de gros à une fonction: copier quelque chose de gros c'est long, juste copier son adresse, c'est rapide.
 
A+,

Merci beaucoup pour vos réponses, j'y vois plus clair !
 
Donc enfaîte ici : void fonction(int *pointeur_du_nombre)
le fait de mettre * sert à indiquer que la fonction attend une valeur de type pointeur mais si je veux retrouver ce pointeur plus tard c'est en demandant  pointeur_du_nombre et non *pointeur_du_nombre.
Et donc *pointeur_du_nombre correspond à la valeur pointée.
 
Merci bien  

Oui:
int *pointeur_du_nombre
*pointeur_du_nombre est un int et donc pointeur_du_nombre est un pointeur sur un/des int(s)
 
A+,