Enoncé exercice 1

Ecrire un programme C qui définit et utilise une fonction de prototype int Somme(int,int) qui prend en paramètres deux entiers et renvoie leur somme.

Correction exercice 1

Dans ce premier exercice on va définir une fonction très simple. Elle prend deux entiers comme paramètres, calcule puis renvoie leur somme. Mais avant d’aller plus loin, il faut essayer de cerner la différence entre les trois éléments suivants:

• La définition de la fonction: C’est là où on définit ce que la fonction va faire, le nombre et les types de ses paramètres ainsi que le type du résultat qu’elle renvoie. Elle est située généralement avant la fonction principale main mais peut aussi apparaître après celle-ci.
• Le prototype de la fonction: Son rôle est d’indiquer au compilateur le type de chaque paramètre de la fonction et celui du résultat renvoyé. Il est placé de préférence avant la déclaration des variables dans la fonction main, mais doit apparaître avant le premier appel de la fonction. Sa présence est obligatoire lorsque la fonction est définie après la fonction main.
• L’appel de la fonction: C’est l’utilisation de la fonction pour répondre au problème en main.

En revenant maintenant à l’exercice, la fonction Somme (ligne 3-8) doit avoir deux paramètres entiers qui représentent les deux entiers dont on veut calculer la somme. On indique leurs types dans l’entête (ligne 3) et on leur attribue chacun un nom (ici a et b) pour pouvoir les manipuler au sein de la fonction. Toujours sur l’entête on spécifie aussi le type de la variable qui sera renvoyée par la fonction. A l’intérieur de la fonction on déclare une variable s pour recevoir la somme calculée puis on la renvoie en utilisant le mot return (ligne 7).

Avant d’utiliser la fonction Somme, on indique son prototype (ligne 11) pour que le compilateur comprenne la façon correcte d’appel de cette fonction.

Pour utiliser cette fonction, on lit deux entiers a et b. Qui ne doivent pas forcement avoir les mêmes noms que les paramètres de la fonction Somme. On les lui passe en paramètres, et on intercepte la valeur renvoyée dans une variable som (ligne 15).

Solution exercice 1

#include<stdio.h>
#include<stdlib.h>
int Somme(int a,int b)
{
    int s;
    s=a+b;
    return s;
}
int main()
{
    int Somme(int,int);
    int a,b,som;
    printf("donnez deux entiers\n");
    scanf("%d%d",&a,&b);
    som=Somme(a,b);
    printf("%d + %d = %d\n",a,b,som);
    system("pause");
    return 0;
}

Enoncé exercice 2

Ecrire un programme C qui définit et appelle une fonction bonjour qui affiche le message Bonjour.

Correction exercice 2

Dans cet exercice on va écrire un programme qui définit et utilise une fonction bonjour qui affiche le message Bonjour. Cette fonction est donc caractérisée par son indépendance du reste du programme, du point de vue qu’elle n’aura pas besoin d’être alimenté par aucune information provenant de ce dernier pour accomplir sa tâche. En plus elle n’a besoin d’en renvoyer aucune.

Concrètement cette fonction sera sans arguments. Et pour son type de retour on mettra void, qui signifie que la fonction ne va renvoyer aucune variable. Ceci dit, pour définir la fonction bonjour (lignes 3-6) on utilisera void comme type de retour, et l’endroit réservé pour indiquer les arguments et leurs types restera vide. On utilisera ensuite la fonction printf pour l’affichage du message souhaité.

Il est à noter que même si la fonction est constituée d’une seule instruction, on ne peut pas se passer des accolades comme il en est le cas pour les boucles.

Pour pouvoir appeler une fonction à l’intérieur du programme, on doit indiquer au compilateur le type de renvoi et les types des arguments à travers le prototype de la fonction. Et qui doit figurer dans les lignes qui précèdent le premier appel de la fonction concernée. De préférence au début de la fonction principale main.

Pour le prototype de la fonction bonjour (ligne 9) et à l’endroit réservé aux types des paramètres, on écrit simplement void pour dire que la fonction n’attends aucun argument.

L’objectif de la définition d’une fonction et l’expression de son prototype est de pouvoir l’exploiter à l’intérieur du programme. Donc pour afficher le message Bonjour, il suffit d’appeler la fonction bonjour (ligne 10). On remarque qu’on a ni passé d’arguments à la fonction ni intercepter la valeur qu’elle renvoie.

Solution exercice 2

#include<stdio.h>
#include<stdlib.h>
void bonjour()
{
   printf("Bonjour\n");
}
int main()
{
    void bonjour(void);
    bonjour();
    system("pause");
    return 0;
}

Enoncé exercice 3

Ecrire un programme C qui détermine le max de quatre entiers à l’aide d’une fonction Max_4, et qui doit utiliser une autre fonction Max_2 qui trouve le max de deux entiers.

Correction exercice 3

Dans cet exercice on va exploiter une fonction Max_2, qui calcule le max de deux entiers, pour définir une autre Max_4 qui fait la même chose, mais pour quatre entiers.

Max_2 prend comme paramètres deux entiers a et b, et renvoie leur max, qui lui aussi est du même type (ligne 3). Pour déterminer le max, on compare a avec b (ligne 5). Si a est supérieur à b, l’instruction return a sera exécutée, et la fonction renverra alors a qui représente dans ce cas le max. Dans l’autre cas, b sera le max et l’instruction return b (ligne 6) sera exécutée au lieu de return a. Ceci est rendu possible grâce au fait qu’une seule instruction return est exécutée à chaque appel de la fonction et constitue une sortie de celle-ci. Donc, dans le cas où a est le max, elle ne va pas faire le return a suivit du return b, mais elle s’arrêtera au niveau du premier return.

Pour la définition de la fonction Max_4 (lignes 8-15) on commencera par l’indication du prototype de Max_2 (ligne 10), chose qui n’est pas obligatoire dans notre cas, puisque Max_2 est définie bien avant Max_4.

Maintenant, pour retrouver le max des quatre entiers, on appelle Max_2 deux fois pour calculer le max de chaque deux entiers parmi les quatre (lignes 12-13). Et on se retrouvera alors seulement avec deux entiers max1 et max2 au lieu de quatre. Ces deux entiers seront ensuite transmis à Max_2 qui va renvoyer cette fois le max recherché. Ce max sera directement renvoyé une deuxième fois par l’instruction return de la fonction Max_4 (ligne 14).

Pour tester la fonction Max_4, on lui passe en paramètres quatre entiers lus à l’intérieur de la fonction principale main (ligne 22). On intercepte ensuite le résultat renvoyé dans la variable max pour l’affiché.

Solution exercice 3

#include<stdio.h>
#include<stdlib.h>
int Max_2(int a,int b)
{
    if(a>b) return a;
    return b;
}
int Max_4(int a,int b,int c,int d)
{
    int Max_2(int,int);
    int max1,max2;
    max1=Max_2(a,b);
    max2=Max_2(c,d);
    return Max_2(max1,max2);
}
int main()
{
    int Max_4(int,int,int,int);
    int a,b,c,d,max;
    printf("Entrez quatre entiers:\n");
    scanf("%d%d%d%d",&a,&b,&c,&d);
    max=Max_4(a,b,c,d);
    printf("les max est: %d\n",max);
    system("pause");
    return 0;
}

Enoncé exercice 4

Ecrire un programme C qui affiche les carrés des éléments d’un tableau d’entiers en utilisant les deux méthodes suivantes: la première se base sur une fonction Affiche_Carre qui prends en paramètre le tableau est affiche les carrés de tout ses éléments, et la deuxième utilise une fonction Carre qui affiche le carré d’un entier entré en paramètre.

Correction exercice 4

Pour la première méthode, la fonction Afficher_Carre (lignes 3-9) se chargera elle même de l’affichage des carrés. Donc il n’y aura rien à renvoyer par celle-ci. Et en ce qui concerne ses paramètres, on doit avoir le tableau dont on veut afficher les carrés des éléments, représenté par un pointeur sur son premier élément, et bien évidement un entier pour le nombre des éléments du tableau.

A l’intérieur de la fonction, on déclare un compteur pour parcourir le tableau avec une boucle for. A chaque itération de cette dernière on affiche le carré de l’élément correspondant. A titre de rappel, les noms des paramètres d’une fonction et les variables déclarées à l’intérieur de celle-ci ne chevaucheront en aucun cas avec les variables qui portent les mêmes noms et qui se situent dans d’autres fonctions en particulier dans la main.

Maintenant, pour afficher les carrés des n éléments du tableau t par cette fonction, il suffit de lui passer t et n en paramètres (ligne 28). En respectant l’ordre utilisé lors de la définition de la fonction.

Pour la deuxième méthode on va se servir de la fonction Carre (lignes 10-13), qui calcule et affiche le carré d’un entier entré en paramètre. Cette fois-ci, on va parcourir le tableau t dans la fonction main à l’aide d’une boucle for (ligne 30). Et pour chaque itération, on appelle la fonction Carre en lui passant en paramètre l’élément actuel (ligne 31) pour calculer puis afficher son carré.

Solution exercice 4

#include<stdio.h>
#include<stdlib.h>
void Afficher_Carre(int *p,int n)
{
     int i;
     for(i=0;i<n;i++)
        printf("%d ",p[i]*p[i]);
     printf("\n");
}
void Carre(int a)
{
    printf("%d ",a*a);
}
int main()
{
    void Afficher_Carre(int*,int);
    void Carre(int);
    int t[100];
    int i,n;
    printf("Entrez le nombre des elements du tableau:\n");
    scanf("%d",&n);
    printf("Entrez les elements du tableau:\n");
    for(i=0;i<n;i++)
    {
       scanf("%d",&t[i]);
    }
    printf("En utilisant la fonction Afficher_Carre:\n");
    Afficher_Carre(t,n);
    printf("En utilisant la fonction Carre:\n");
    for(i=0;i<n;i++)
       Carre(t[i]);
    printf("\n");
    system("pause");
    return 0;
}

Enoncé exercice 5

Ecrire un programme C qui définit et utilise une fonction Permuter qui permute les valeurs de deux variables réelles.

Correction exercice 5

Les fonctions traitées dans les exercices qui précèdent, utilisent les variables qu’on leur passe pour accéder à des informations comme le nombre des éléments d’un tableau, ou à leurs valeurs pour pouvoir les afficher, calculer une somme ou trouver un max. Mais jamais on n’a tenté de changer la valeur d’une variable de la fonction main à partir de ces fonctions. De plus ça n’est pas possible sans la mise en œuvre de la notion de transmission d’arguments par adresse.

Par opposition à la transmission par adresse on trouve la transmission par valeur, c’est ce qu’on a utilisé dans les quatre premiers exercices. Et qui consiste simplement à passer des variables à une fonction, alors qu’avec l’autre mode on transmit les adresses de ces variables au lieu de leurs valeurs.

Lors d’une transmission par valeur, à chaque appel de la fonction celle-ci crée des copies dans la mémoire sur les variables passées en paramètres et toute transformation touche seulement ces copies. Par contre si on passe les adresse de ces variables on peut aller à ces adresse et changer les valeurs qui s’y trouvent en utilisant les pointeurs et c’est l’avantage d’une transmission par adresse.

Dans cet exercice, il est demandé de permuter le contenu de deux variables réelles, ce qui nécessitera la modification des valeurs de celles-ci, et donc la manipulation des adresses.

Les paramètres de la fonction Permuter (lignes 3-9) seront alors deux pointeurs p et q qui représentent les adresses des deux variables dont on veut permuter le contenu. Et comme on a vu avec les pointeurs, *p et *q remplaceront ces deux dernières. A l’aide d’une troisième variable tmp déclarée à l’intérieur de la fonction, on effectuera la permutation (lignes 6-8).

Lors de l’appel de cette fonction (ligne 16) pour permuter les deux variables de la fonction main a et b on lui passe leurs deux adresses consécutives &a et &b. Et on affiche les deux variables avant et après l’appel de la fonction pour s’assurer de la réussite de l’opération.

Solution exercice 5

#include<stdio.h>
#include<stdlib.h>
void Permuter(float *p,float *q)
{
    float tmp;
    tmp = *p;
    *p = *q;
    *q = tmp;
}
int main()
{
    float a,b;
    printf("Entrez deux nombres reels:\n");
    scanf("%f%f",&a,&b);
    printf("Avant la permutation: a = %f et b = %f\n",a,b);
    Permuter(&a,&b);
    printf("Apres la permutation: a = %f et b = %f\n",a,b);
    system("pause");
    return 0;
}