Langage C débutant

Ca dépend , qu'est ce que tu connais comme autres languages ?
Contrairement à Linux, Qui choisit Windows s'expose aux virus, spys et aux tracas peu constructifs

j'ai programmé en Pascal et en delphi.

Une procédure c'est une fonction.

Par exemple, tu fais un programme qui fait une opération plusieurs fois, comme par exemple une addition qui affiche le résultat puis une soustraction qui affiche le résultat.

Sachant que tu vas les appeler par exemple 10 fois dans ton programme, tu peux faire une fonction que tu appeleras 10 fois plutôt que de tout recopier :

void fonction_procédure(int valeur1, int valeur2)
{
printf("Addition : %i\n,valeur1+valeur2);
printf("Soustraction : %i\n,valeur1-valeur2);
}

et dans ton programme tu auras juste à faire :

bla bla code 
fonction_procédure(80,10); // c'est qu'un exemple !
bla bla code

Autant de fois que tu veux ;)
Par ailleurs, cela allège la fonction principale (appelée main) et rend le code plus propre (et plus transparent).

mais une fonction peut-elle sortir plusieurs résultats, disons par exemple le quotien et le reste pour une division euclidienne (oui, je sais, c'est pas très utile une division euclidienne, mais cest un exemple:)

c'est à dire, je voudrais pouvoir taper un truc du genre :

EUCLID(A,B ; Q, R)

où A et B seraient des variables ou des paramètres type entier, et Q et R le quotient et le reste de la division euclidiennne du plus grand des 2 nombres par le plus petit calculés par la procédure EUCLID.

En Pascal, une fonction ne sort qu'un résultat, j'ai parcouru vaguement quelques sites, et j'ai l'impresion que c'est pareil en C, non ?

Il suffit de passer en paramètre les variables dans lesquelles tu veux stocker le résultat. Exemple

#include <stdio.h>

void euclide(int a,int b,int *q,int *r){
  *q = a/b;
  *r = a- q*b;
}

int main(){
  int q,r;
  euclide(8,3,&q,&r);
  printf("q=%d r=%d\n",q,r);
  return 0;
}

ou de passer par une structure :

struct qr{
  int q;
  int r;
};

struct qr euclide2(int a,int b){
  struct qr res;
  res.q = a/b;
  res.r = a - q*b;
  return res;
}

int main(){
  struct qr res = euclide2(8,5);
  printf("q=%d r=%d\n",res.q,res.r);
  return 0;
}

Bonne chance

Merci pour la réponse, je vais essayer ceci qui semble tout à fit correspondre à ce que je cherchais :)

Toutefois, une question subsidiaire : laquelles des 2 méthodes serait elle la mieux préconisée (ou quelle est la différence "phylosophique" entre les 2 possibilités :)

Oui tu peux évidemment, seulement c'est vrai que c'est pas si simple. En fait, quand on parle de procédures, on peut faire la distinction entre action et fonction (les termes varient selon les livres/profs).

Action : procédure qui ne renvoie rien (comme mon exemple)
Fonction : procédure qui renvoie une valeur (comme ton exemple)

Pour cela plusieurs possibilités :
*Soit tu n'as qu'une valeur simple, tu fais un

return valeur;

Ca te fera un truc genre

int fonction_procédure(int valeur1, int valeur2)
{
int resultat=valeur1+valeur2;
printf("Addition : %i\n,resultat);
return resultat
}

Ce code fera l'addition, et retournera le résultat qui pourra être exploité.
*Soit tu as plusieurs variables, dans ce cas
- tu peux faire une structure regroupant toutes tes variables

struct{
int valeur1;
int valeur2;
};

et faire le return dessus.
- tu peux faire des passages de paramètres par pointeur, ou par référence (C++), ainsi tu n'envoies non pas la valeur, mais l'adresse mémoire de cette variable. Donc tu modifies directement la case, et non la valeur, et ce changement est effectif même en dehors de la fonction.
- tu peux utiliser des variables globales (bouh), des variables définies pour tout le programme. C'est moche.
- surement d'autres moyens mais je mets les plus courants sans trop prendre le temps d'approfondir !



Salut, il n'y a pas de meilleure solution entre le return et les pointeurs, en fait ça dépend des cas. La grande différence entre les deux est dans le fait que quand tu travailles sur des pointeurs, tu travailles sur les cases mémoire. Ce qui fait que tu modifies la valeur même en dehors de la fonction, ce qui n'est pas le cas du return.

int addition (int valeur1, int valeur2)
{
int resultat=valeur1+valeur2;
return resultat;
}

Ici resultat est une variable locale à la fonction. Dans ton main, si tu veux afficher resultat, ça ne marchera pas. Par contre si tu travailles sur des pointeurs

int addition (int valeur1, int valeur2, int *resultat)
{
*resultat=valeur1+valeur2;
}

C'est la variable se situant à l'adresse de resultat qui sera modifiée, et non la variable elle-même. En pratique, le resultat que tu auras déclaré dans ton main sera effectivement modifié !

Le return est quant à lui plus pratique dans le cas où tu ne réutilises pas la variable, en effet, les variables locales allègent le programme et le rendent plus clair.

je suis etudiant en NTIC et je voudrai des exrcices et corriges en langage c et en algorithme merci et je compte sur vous.
bede olivier