Discussion :

[Aioros]

J'ai debuté mon apprentissage du langage C, il y a maintenant un
moment. Seulement, cela fait 2 ans que j'ai arrété ( et oui 2 ans de prepa
). J'ai donc repris presque à zero avec un peu plus de rigueur il y a 2
semaines.

Ma question porte sur le lien entre paramètre formel et paramètre
courant :

D'aprés ce que j'ai compris pour une fonction utilisant des variables
normales ( pas des pointeurs ), la définition de la fonction ce fait sous la
forme :
void fonction( int a, int b) { ... } par exemple

lorsque l'on appelle cette fontion, l'instruction s'ecrit sous la forme :
fontion(5, 7) ; par exemple

L'affectation des entiers 5 et 7 avec les variables locales a et b est sous
entendu -> int a = 5 ; int b = 7 ;

-------------------------------------

Maintenant si je veux modifier les valeurs des paramètres, je doit passé
par les pointeurs et donc utiliser une fonction dit "de référence".
la fonction s'écrit sous la forme :

void fonction(int *ptr_a, int *ptr_b) { ... } par exemple

je veut modifier la valeur des variables : int a ; int b ; à l'aide de la
fonction ci-dessus, pour cela j'appelle cette dernière fonction de la
manière suivante :

fonction(&a, &b) ;

Cette foi ci, l'affectation sous entendu est la suivante :
int *ptr_a = &a ; int *ptr_b = &b ;

Cependant *ptr_a et *ptr_b sont des entiers, et &a et &b sont des
adresses mémoires, il s'agit donc de deux groupes d'éléments appartenant
à deux ensembles différents, les affections précédentes n'ont pour moi
aucun sens !
l'affectation sous entendu serait plutot :
int ptr_a = &a ; int ptr_b = &b ;

Aidez moi à comprendre le lien entre paramètre formel et paramètre
courant. Cela est encore pour moi trés obscure !

[Strab]

Cette foi ci, l'affectation sous entendu est la suivante :
int *ptr_a = &a ; int *ptr_b = &b ;

Oui, à comprendre comme : (int *) ptr_a = &a et non comme int (*ptr_a) = &a. Autrement dit, on affecte au pointeur ptr_a l'adresse de a, ce qui est cohérent, et non "on affecte à l'entier *ptr_a l'adresse de a" comme tu sembles l'avoir compris.

Ca va mieux ?

Edit : correction de fautes

[gege2061]

Bonjour et bienvenue sur les forums de developpez

Cette foi ci, l'affectation sous entendu est la suivante :
int *ptr_a = &a ; int *ptr_b = &b ;

En fait le * fait partie du type et n'est pas ici l'opérateur de déréférencement, certains préfére écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int* ptr_a = &a ; int* ptr_b = &b ;

Mais dans ce cas, si on utilise l'opérateur virgule pour faire plusieurs déclaration sur une seul ligne, il est facile d'oublier le * :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int* ptr_a, ptr_b;

parait correcte or, il faut écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int* ptr_a, * ptr_b;

J'espère avoir été clair

[Aioros]

merci pour ces deux réponses rapides !
j'y vois déjà beaucoup plus clair, je peux continuer mon apprentissage sereinement !

Longue vie à ce Forum manifique !

[Strab]

N'oublie pas le bouton (ni de lire les règles du forum si ce n'esst déjà fait).
A bientôt sur developpez

[Emmanuel Delahaye]

Ma question porte sur le lien entre paramètre formel et paramètre
courant :

Gni ?

D'aprés ce que j'ai compris pour une fonction utilisant des variables
normales ( pas des pointeurs ), la définition de la fonction ce fait sous la
forme :
void fonction( int a, int b) { ... } par exemple

Oui.

lorsque l'on appelle cette fontion, l'instruction s'ecrit sous la forme :

fontion(5, 7) ; par exemple

Oui, par exemple. On peut aussi mettre une variable ...

fontion(x, 7) ; par exemple

De toutes façon, en C, seule la valeur est transmise.

L'affectation des entiers 5 et 7 avec les variables locales a et b est sous
entendu -> int a = 5 ; int b = 7 ;

Mmm.... 'variable locale' est un terme un peu osé. Ce sont des paramètres, et, oui, on peut les assimiler à des variables locales par leur comportement. Mais les modifier n'impacte pas la valeur originale dans l'appelant).

-------------------------------------

Maintenant si je veux modifier les valeurs des paramètres, je dois passer
par les pointeurs et donc utiliser une fonction dit "de référence".

Arg! Non! Pas de réference en C. Comme d'habitude, on passe une valeur. Sauf qu'ici, on passe une adresse (c'est une valeur comme une autre). Comme les seules variables qui savent prendre une valeur de type 'adresse' sont les pointeurs, on met un pointeur (du même type que la variable dont on passe l'adresse).

la fonction s'écrit sous la forme :

void fonction(int *ptr_a, int *ptr_b) { ... } par exemple

Ok.

je veut modifier la valeur des variables : int a ; int b ; à l'aide de la
fonction ci-dessus, pour cela j'appelle cette dernière fonction de la
manière suivante :

fonction(&a, &b) ;

Oui. Les valeur passées sont les adresses des deux variables. (résultat de l'opérateur &)

Cette foi ci, l'affectation sous entendu est la suivante :
int *ptr_a = &a ; int *ptr_b = &b ;

Ce que tu montres est une définition avec initialisation. Elle est correcte. Mais ce n'est pas une affectation, qui serait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
ptr_a = &a ; 
ptr_b = &b ;

Cependant *ptr_a et *ptr_b sont des entiers, et &a et &b sont des
adresses mémoires, il s'agit donc de deux groupes d'éléments appartenant
à deux ensembles différents, les affections précédentes n'ont pour moi
aucun sens !

Ok. La confusion vient de ce que le m^meme signe (*) a 2 sémantiques différentes selon le contexte.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int *ptr_a = &a ; 
int *ptr_b = &b ;

pourrait s'écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
int *ptr_a = &a ; 
int *ptr_b = &b ; 
 
   ptr_a = &a ; 
   ptr_b = &b ;

Le '*' signifie que l'on définit un pointeur. Ne pas confondre avec l'opérateur '*' qui sigifie 'déréférencer un pointeur' (càd accéder à la valeur pointée).

l'affectation sous entendu serait plutot :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int ptr_a = &a ; int ptr_b = &b ;

Argh, non !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

ptr_a = &a ; ptr_b = &b ;

A apprendre par coeur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
   extern T var; /* declaration */
   T var;        /* defintion[ incluant une declaration] */
   T var = 123;  /* defintion[ incluant une declaration] avec initialisation */
 
   var = 123;    /* affectation*/

http://emmanuel-delahaye.developpez....tm#definitions

[Nasky]

et oui 2 ans de prepa
[...]
il s'agit donc de deux groupes d'éléments appartenant à deux ensembles différents, les affections précédentes n'ont pour moi aucun sens !

On voit bien que t'as fait prépa toi

Nas'