Par O. Bailleux, Maître de conférences HDR à l'université de Bourgogne.
Les bases du langage C
Fonction principale, variables locales, affichage, instructions de contrôles, fonctions.
Les activités #.dec (dec pour Découverte) consistent à étudier des présentations explicatives et à traiter tous les exercices de découverte proposés. Si vous ne répondez pas correctement à un exercice de découverte, revenez en arrière pour relire les explications et identifier la cause de votre erreur.
Les activités #.ent (ent pour Entrainement) consistent à traiter des exercices d’entraînement. Vous devez d’abord tenter de traiter ces exercices sans dévoiler d’indice ni regarder la solution. Vous pouvez remonter dans le document pour relire certaines explications ou consulter les solutions des exercices de découverte ou d’entraînement précédemment traités.
Activité de découverte A.dec
A.dec1 : Afficher « Bonjour »
Présentation
Voici notre premier programme.
#include <stdio.h> // Ligne A
int main() // Ligne B
{
printf("Bonjour\n"); // Ligne C
return 0; // Ligne D
}
La ligne A est une inclusion d’un fichier d’entête. Le compilateur en a besoin pour compiler correctement un programme utilisant ma fonction printf et / ou d’autre fonctions standards que nous découvrirons plus tard.
Dans la suite, certaines de ces déclarations seront omises mais vous devrez les ajouter au début de votre code source pour pouvoir compiler vos programmes.
Il existe de nombreuses documentations en ligne permettant de trouver les déclarations nécessaires pour utiliser les fonctions standards dont vous aurez besoin, comme par exemple : https://koor.fr/C.
La ligne B définit la fonction main, qui est aussi appelée fonction principale. Tous nos programmes devront comporter une telle définition de main pour être exécutables. En effet, l’exécution de tout programme en langage C commence par cette fonction.
Les deux accolades { et } encadrent un bloc de code appelé le corps de la fonction main. C’est là où se trouve le code qui sera exécuté lorsque cette fonction sera appelée, c’est à dire au début de l’exécution du programme.
La ligne C appelle la fonction standard printf qui permet d’afficher des informations à l’écran. La chaîne de caractères "Bonjour\n" est l’argument de cette fonction. Le symbole \n est appelé « retour ligne » et permet d’indiquer que les affichage suivants (si applicable) doivent commencer au début de la ligne suivante.
La ligne D s’exécute juste avant la fin de l’exécution du programme et transmet un code au système d’exploitation. Par convention, la valeur 0 indique que l’exécution est arrivée à son terme sans rencontrer d’erreur. Si une erreur se produit avant que cette ligne soit atteinte, un code différent de 0 sera transmis au système d’exploitation.
Exercice de découverte A.dec.x1
Répondez aux questions suivantes. Essayez d’abord de récupérer les réponses dans votre mémoire, et au besoin relisez les explications précédentes pour les retrouver.
Q1. Quel est le rôle de la directive de compilation #include ?
Elle permet d’inclure un fichier d’entête dont le compilateur a besoin pour compiler, notamment, la fonction printf.
Q2. Quel est le rôle de la fonction main ?
C’est le point d’entrée du programme, c’est à dire là où commence son exécution.
Q3. Quelle fonction standard permet de réaliser des affichages à l’écran ?
La fonction printf.
Q4. Où va la valeur de retour de la fonction main ?
Elle est transmise au système d’exploitation.
Q5. Que représente le mot int situé au début de la ligne B ? Attention, l’information n’a pas été donnée. Vous devez essayer la déduire vous-même.
Elle indique le type de la valeur retournée par la fonction main à l’issue de son exécution. Plus précisément, int signifie que cette valeur est un entier. En l’occurrence, dans notre exemple, c’est la valeur 0.
A.dec2 : Compiler et exécuter votre premier programme
Cette activité doit être réalisée lorsque vous disposez d’un ordinateur.
Méthode recommandée
La manière recommandée pour vos premiers pas consiste à procéder en deux étapes : l’édition, puis la compilation.
Édition du code source
Vous devez utiliser un éditeur de texte adapté à la création d’un fichier source, comme par exemple Atom, Visual Studio Code, Sublimetext… Il existe un large choix d’éditeurs gratuits. Enregistrez le code source du programme qui affiche « Bonjour » dans un fichier bonjour.c.
Compilation
Pour compiler votre programme, il faut qu’un compilateur C (et toutes ses dépendances) soit installé sur votre ordinateur. Si vous travaillez sous Linux, le compilateur gcc est probablement déjà installé et sinon recherchez sur le WEB ou demandez à une personne enseignante ou un ou une condisciple comment l’installer. Sous Windows, il est possible de lancer une session Linux en ayant installé préalablement un composant logiciel appelé WSL 2. Renseignez vous. Il est aussi possible de faire tourner Linux dans une machine virtuelle. Sous MacOS, si vous installez l’application gratuite Xcode avec les outils en ligne de commande, vous aurez accès au compilateur gcc et à un autre compilateur nommé clang qui s’utilise de la même manière que gcc.
Vous devrez ouvrir une console ayant pour répertoire de travail celui dans lequel se trouve votre fichier source bonjour.c. La ligne de commande suivante permet de lancer la compilation.
gcc bonjour.c -Wall -o bonjour
L’option -Wall demande au compilateur de faire le plus haut niveau de vérification du code et d’afficher tous les problèmes potentiels. Chaque message d’avertissement doit être pris en considération et entraîner une correction du code. C’est évidemment valable également pour les messages d’erreur.
Un message d’erreur indique qu’un fichier exécutable n’a pas pu être produit. Un message d’avertissement indique qu’un exécutable a été produit mais qu’il y a un problème, comme une ambiguïté dans le code, qui peut entraîner une erreur lors de l’exécution.
L’option -o bonjour indique que le fichier exécutable sera nommé bonjour. On peut évidemment choisir un autre nom. Il faut éviter d’utiliser le nom d’une commande système tel que test (qui est une erreur fréquente). Si l’option -o est absente, l’exécutable produit se nommera a.out.
Exécution
Le fichier exécutable produit par le compilateur est placé dans le répertoire de travail. Dans notre exemple, c’est un fichier nommé bonjour. La ligne de commande suivante lance l’exécution.
./bonjour
Elle demande simplement au système de lancer l’exécution du fichier exécutable bonjour situé dans le répertoire de travail.
Autres méthodes
Utiliser un IDE installé sur votre ordinateur
Il est possible d’utiliser une application appelée IDE qui permet d’éditer, compiler, exécuter, mettre au point un programme. Une telle application est très pratique et fait gagner du temps. Mais si vous êtes débutant, vous devez déjà maîtriser le flux de travail en ligne de commande décrit précédemment.
Utiliser un IDE en ligne
Il existe de nombreux environnement de programmation en ligne, payants et gratuits, qui permettent d’éditer, compiler et exécuter des programmes en langage C.
A.dec3 : Fonction, for, int, variable locale, affichage
Présentation
Maintenant que nous savons comment tester nos programmes, nous allons continuer la découverte des notions de bases permettant de faire des choses un peu plus compliquées et intéressantes qu’afficher « Bonjour ».
Voici un nouveau programme. Pour le tester, n’oubliez pas d’ajouter au début la ligne #include <stdio.h>.
void compteur() // Ligne A
{
for(int i = 9; i > 0; i = i-3) // Ligne B
{
printf("Valeur : %d\n", i); // Ligne C
}
}
int main()
{
compteur(); // Ligne D
return 0;
}
La première chose à observer est la structure du programme. Tout programme est constitué de blocs qui se succèdent et/ou s’imbriquent. Chaque bloc a un rôle.
Cette structure est très importante pour comprendre le fonctionnement d’un programme et être capable de créer de nouveaux programmes.
Ici, nous avons deux blocs qui sont les définitions des fonctions compteur et main. Le corps de chacune de ces fonctions est également un bloc, délimité par des accolades. Ces accolades sont parfaitement alignées pour faciliter la lisibilité du programme. Cette disposition est appelée le style d’indentation Allman. Dans le cadre de cet enseignement, il vous est demandé de respecter ce style, en particulier lorsque vous montrez un programme à une personne enseignante.
Pour information, un autre style très répandu est appelé K & R en référence aux inventeurs du langage C, Brian Kernighan et Dennis Ritchie. Voici la définition de la fonction dans le style K & R.
void compteur(){
for(int i = 9; i > 0; i = i-3){
printf("Valeur : %d\n", i);
}
}
Ce style était parfaitement justifié dans les années 1970, dans les premiers temps du langage C, parce qu’à l’époque, les écrans ne pouvaient afficher qu’un nombre très limité de lignes de code et que beaucoup de programmeurs n’utilisaient pas d’écran mais un terminal télétype qui était l’association d’une imprimante et d’un clavier. (L’auteur du présent document a programmé avec ce genre d’engin dans les années 1980.)

Il fallait économiser le papier au détriment de la lisibilité du code. De nos jours, beaucoup de développeurs utilisent ce style, mais il est banni de cet enseignement au profit du style Allman, plus pédagogique.
Voici une mise en évidence de la structure en blocs du programme d’exemple.

Commençons par regarder la fonction main. Son rôle est d’appeler la fonction compteur. On aurait pu mettre le code de la fonction compteur dans la fonction main, mais le but ici est d’illustrer l’appel d’une fonction ne retournant aucune valeur et n’ayant aucun paramètre, c’est à dire n’acceptant aucun argument.
Intéressons-nous maintenant à la fonction compteur.
void compteur() // Ligne A
{
for(int i = 9; i > 0; i = i-3) // Ligne B
{
printf("Valeur : %d\n", i); // Ligne C
}
}
En ligne A, le mot clé void indique que la fonction ne retourne rien. Une telle fonction peut être appelée procédure. Les parenthèses vides après le nom de la fonction indique qu’elle n’a aucun paramètre.
La ligne B définit une boucle à l’aide de l’instruction for.
Cette boucle est contrôlée par une variable i qui est déclarée et initialisée par la notation int i = 9. Il s’agit d’une variable locale qui n’existe que pendant l’exécution de la boucle. L’initialisation s’effectue, comme son nom l’indique, une seule fois.
L’expression i > 0 est l’expression de contrôle de la boucle. Tant que sa valeur est vraie, la boucle continue de s’exécuter. Cette condition est testée avant chaque exécution du corps de la boucle, qui est le bloc immédiatement en dessous.
Enfin, l’expression i = i-3 est la mise à jour de la boucle. Elle est exécutée après chaque itération, c’est à dire chaque exécution du corps de la boucle.
La ligne C est dans le corps de la boucle. Elle sera exécutée trois fois :
- une fois avec
iégal à 9, - une fois avec
iégal à 6, - et une fois avec
iégal à 3.
À l’issue de ces trois exécutions, la valeur de i est 0 et la condition de contrôle devient fausse. L’exécution de la boucle s’arrête.
La fonction printf est utilisée ici pour afficher la valeur de la variable i. On lui transmet deux arguments :
- une chaîne de formatage qui indique dans quelle format afficher la donnée,
- et la donnée à afficher.
Ici, la donnée est de type int. Ce type représente des entiers signés, c’est à dire pouvant prendre des valeurs négatives ou positives. Nous reviendrons plus tard sur les bornes de ces valeurs. la notation %d dans la chaîne de formatage indique que l’affichage de cet entier devra être réalisé en base 10.
A l’exécution, nous aurons l’affichage suivant :
Valeur : 9
Valeur : 6
Valeur : 3
Exercice de découverte A.dec.x2
Q1. Dans la fonction compteur, si on initialise i à 0 plutôt que 9, que se passera-t-il à l’exécution ? (Vous devez répondre sans exécuter le programme sur machine) ?
La condition de contrôle étant fausse dès le départ, le corps de la boucle ne s’exécute pas et il n’y a aucun affichage.
Q2. On remplace la fonction compteur par cette variante.
void compteur() // Ligne A
{
for(int i = 9; i > 0; i = i+3) // Ligne B
{
printf("Valeur : %d\n", i); // Ligne C
}
}
Que se passe-t-il à l’exécution ?
Si vous avez répondu que le programme boucle indéfiniment en affichant tous les multiples de 3 à partir de 9, alors vous avez bien compris le fonctionnement d’une boucle for.
La véritable réponse est que le programme va finir par s’arrêter. En effet, les données de type int sont représentées par des mots binaires de taille finie. Dans les architectures actuelles, sur 32 bits. La moitié de ces mots binaires représentent des entiers positifs et l’autre moitié des entiers négatifs. À force d’augmenter la valeur de i, on va dépasser le plus grand entier positif représentable et produire une valeur négative. Cela s’appelle un débordement. La condition de contrôle deviendra alors fausse.
A.dec4 : While, modulo, rand, Booléens, valeur de retour
Présentation
Un nouveau programme va nous permettre de découvrir ou redécouvrir de nouvelles instructions et une fonction standard très pratique pour produire des nombres pseudo-aléatoires.
int jusquaPile() // Ligne A
{
int nbEssais = 1; // Ligne B
while(rand() % 2) // Ligne C
{
nbEssais = nbEssais + 1; // Ligne D
}
return nbEssais; // Ligne E
}
int main()
{
srand((unsigned)time(NULL)); // Ligne F
printf("%d\n", jusquaPile()); // Ligne G
return 0;
}
Chaque ligne introduit un concept très utile que vous devrez savoir réutiliser plus tard.
La ligne A définit une fonction sans paramètre mais qui retourne un entier. Le rôle de cette fonction est de simuler des tirages à pile ou face jusqu’à ce que pile soit tiré, puis de retourner le nombre de tirages en comptabilisant celui qui a produit pile.
La ligne B déclare une variable nommée nbEssais et l’initialise avec la valeur 1. Cette variable est locale à la fonction jusquaPile.
La ligne C définit une boucle while. Le corps de cette boucle s’exécutera tant que la condition de contrôle sera vraie. Cette condition est rand() % 2, ce qui requiert quelques explications.
- Il existe une fonction standard
randsans paramètre qui produit un nombre aléatoire compris entre 0 et une très grande valeur, qui n’est pas très importante ici. - L’opérateur
%permet de calculer un modulo, c’est à dire le reste d’une division entière. Si l’appel retourne une valeur paire, alorsrand()%2vaut 0, sinonrand()%2vaut 1. Chaque cas se produit avec une probabilité 1/2, ce qui permet de simuler un tirage à pile ou face. - Le langage C représente les valeurs Booléennes vrai et faux par des entiers, avec la convention suivante : 0 représente faux, et toute autre valeur, comme par exemple 1, représente vrai.
Donc à chaque fois qu’elle est évaluée, la condition de contrôle de la boucle a une chance sur deux d’être vraie.
La ligne D s’exécute à chaque fois que l’évaluation de la condition de contrôle produit la valeur vrai, ce qui par convention correspond à un tirage de la valeur pile. Donc si face est tiré, le corps de la boucle s’exécute et la variable nbEssais est incrémentée.
La ligne E s’exécute quand la boucle a terminé son exécution, donc après un nombre d’itérations égal au nombre de faces tirés avant le premier tirage de pile. Si face est tirée au premier essai (rand()%2 vaut 0) alors le corps de la boucle ne s’exécute pas et la valeur de la variable nbEssais sera 1. Sinon se sera 1 plus le nombre de faces tirés avant la première valeur pile. L’instruction return demande à la fonction de retourner cette valeur.
Examinons maintenant la fonction main.
La ligne F est facultative. Elle permet d’initialiser le germe du générateur pseudoaléatoire avec le nombre de secondes écoulées depuis le premier janvier 1970. Si on omet cette ligne, le générateur produira la même séquence de nombres à chaque exécution du programme. Le résultat sera reproductible, mais peu réaliste.
La ligne G appelle la fonction jusquaPile et affiche sa valeur de retour.
Attention, pour que le programme puisse être compilé et exécuté, vous devez ajouter les lignes suivantes au début du fichier source.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
En général, dans la suite du cours, les fichiers d’entête à inclure ne seront pas données dans les exemples, mais vous devrez les ajouter pour pouvoir tester ces exemples sur machine.
Exercice de découverte A.dec.x3
Au lieu de retourner le nombre de tirages réalisés pour obtenir pile dans une simulation de tirages à pile ou face, on souhaite retourner le nombre de tirages réalisés pour obtenir un 6 dans une simulation de lancés d’un dé à 6 faces. Modifiez le programme en conséquence.
Il suffit de remplacer la condition rand()%2 par rand()%6. Les résultats possibles seront les entiers 0, 1, 2, 3, 4 et 5. On adopte la convention que la valeur 0 représente le tirage au dé de la valeur 6, ce qui n’affecte pas le résultat puisque cette valeur 0 à une chance sur 6 d’être produite.
Mais si vous tenez à simuler les tirages des valeurs 1 à 6, alors vous pouvez réécrire la fonction comme ceci.
int jusquaSix()
{
int nbEssais = 1;
int tirage = (rand() % 6) + 1; // Ligne X
while(tirage != 6)
{
nbEssais = nbEssais + 1;
tirage = (rand() % 6) + 1; // Ligne Y
}
return nbEssais;
}
Dans cette version, la variable tirage reçoit une valeur comprise entre 1 et 6 à chaque exécution des lignes X et Y. Mais comme le générateur pseudoaléatoire est non biaisé, cela ne change rien à la distribution statistique des résultats.
Exercice de découverte A.dec.x4
Complétez la définition suivante de manière a ce que l’exécution de la fonction jusquaPile ait exactement le même effet que la version initiale.
int jusquaPile()
{
int nbEssais = 1;
for(; ; );
return nbEssais;
}
Il n’y a pas d’initialisation dans la définition de la boucle for (parce qu’elle est faite avant), mais uniquement la condition de contrôle et la mise à jour.
int jusquaPile()
{
int nbEssais = 1;
for(; rand()%2; nbEssais = nbEssais + 1);
return nbEssais;
}
Il est possible de remplacer nbEssais = nbEssais + 1 par nbEssais++.
A.dec5 : If, else, type double, fonctions avec paramètres, exit
Présentation
Nous allons maintenant travailler sur un programme un peu plus complexe qui calcule combien il faut, en moyenne, de tirages à pile ou face pour obtenir la valeur pile. Pour calculer cette moyenne, il faut réaliser un certain nombre d’essais. On conserve la fonction jusquaPile de la partie précédente, dont voici la définition, pour mémoire.
int jusquaPile()
{
int nbEssais = 1;
while(rand() % 2)
{
nbEssais = nbEssais + 1;
}
return nbEssais;
}
On définit une nouvelle fonction qui va appeler jusquaPile un nombre de fois déterminé par un paramètre nommé nombreEssais et calculer la moyenne des valeurs retournées par ces appels. Voici le détail de cette nouvelle fonction.
double moyenneJusquaPile(int nombreEssais)
{
if(nombreEssais <= 0) // Ligne A
{
printf("Nombre d'essais incorrect\n");
exit(1); // ligne B
}
else
{
double somme = 0.0; // Ligne C
for(int i=0; i < nombreEssais; i++)
{
somme = somme + jusquaPile();
}
return somme / nombreEssais; // Ligne D
}
}
On voit apparaître en ligne A une alternative if … else. Son rôle doit vous parapitre assez évident si vous avez les prérequis pour suivre cet enseignement, c’est à dire une certaine pratique de la programmation procédurale ou objet.
En ligne B il y a du nouveau. L’instruction exit permet de quitter immédiatement le programme en indiquant la valeur à retourner au système d’exploitation qui se substitue à celle retournée par la fonction main. On l’utilise essentiellement en cas d’erreur ne pouvant être gérée autrement que par un arrêt du programme.
Le calcul demandé à la fonction est réalisé dans le bloc else de l’alternative.
En ligne C, une variable locale nommée somme est déclarée et initialisée. Cette variable est de type double et pourra contenir des valeurs non entières. Les valeurs qui lui seront ajoutées sont les résultats des appels à la fonction jusquaPile, qui sont de type int. On peut ajouter un int à un double et le résultat est un double.
Le rôle de la boucle for est évident.
La ligne D demande à la fonction de retourner le rapport de la somme des valeurs produites par chaque essai sur le nombre d’essais. On divise donc un double par un entier, ce qui a pour résultat une valeur de type double.
Pour compléter notre programme et tester la fonction moyenneJusquaPile, il nous faut une fonction main. la voici.
int main()
{
srand((unsigned)time(NULL));
printf("%.02f\n", moyenneJusquaPile(1000000));
return 0;
}
La nouveauté ici est le format d’affichage %02f de printf, qui affiche une valeur de type double avec 2 chiffres après le point décimal. On peut bien sûr modifier ce nombre de chiffres après la virgule.
Avec un million d’essais, on obtient la valeur 2.00, soit en moyenne deux tirages pour obtenir pile.
Exercice de découverte A.dec.x5
L’entreprise Éloïs et Morlocks a été piratée et les lignes de code suivantes ont été introduites au début de la définition d’une fonction nommée updateRound dans le code source de l’application commercialisée par l’entreprise.
if( (rand() % 10000) == 0 )
{
exit(1);
}
L’application exécute la fonction updateRound environ une fois par heure. Lors des tests, aucune anomalie n’est constatée. La version modifiée est remplacée par l’ancienne version chez 1000 clients. Que faut-il craindre et pourquoi ?
À chaque exécution de la fonction updateRound, il y a une chance sur 10000 que l’application s’arrête. La situation ne s’est jamais produite durant les tests, mais occasionnellement, un client verra son application s’arrêter.
Exercice de découverte A.dec.x6
Le directeur des établissements Éloïs et Morlocks exécute le programme suivant.
int main()
{
for(int i=0; i<10; i++)
{
srand((unsigned)time(NULL));
printf("%d ", rand() % 100);
}
printf("\n");
}
Il constate que le même nombre s’affiche 10 fois à l’écran alors qu’il pensait que la probabilité d’un tel évènement était extrêmement faible. Que s’est-il passé ? Comment corriger le problème ?
L’appel à srand initialise le germe du générateur qui détermine la séquence des nombres produits par rand. Dans le code ci-dessus, l’appel à srand est réalisé en utilisant comme germe une valeur qui change toutes les secondes. (Pour mémoire, time(NULL)) retourne le nombre de secondes écoulées depuis le premier janvier 1970. Lorsque le directeur a exécuté le programme, les 10 appels à srand ont eu lieu pendant la même seconde, et donc avec le même germe. L’appel à rand a donc retourné 10 fois la même valeur.
Pour éviter cela, il faut appeler srand une seule fois, au début de la fonction main.
L’activité est terminée. Vous devez évaluer votre réussite de cette activité par une valeur entre 1 et 4.
- Vous n’avez presque rien compris et échoué à plus de la moitié des exercices de découverte.
- Vous estimez avoir compris une partie des explications et vous avez réussi au moins la moitié des exercices de découverte, mais certaines notions sont encore floues.
- Vous estimez avoir bien compris les explications et vous avez réussi presque tous les exercices de découverte, mais certaines notions abordées étaient nouvelles et vous penser avoir besoin d’un entrainement pour bien les assimiler et être en mesure de les utiliser en pratique.
- Vous connaissiez déjà tout ce qui a été présenté (sauf peut-être quelques détails) et il ne sera pas nécessaire que vous reveniez sur ces notions.
Si votre score est 1 ou 2, vous devrez refaire cette activité rapidement, mais après au moins une nuit de sommeil, avant de passer aux activités suivantes. Si votre score est 3 ou 4, vous devez faire les activités suivantes et il ne sera pas nécessaire de revenir sur cette activité, à part pour rechercher des informations utiles pour d’autres activités.
Activité d’entraînement A.ent
Cette activité est essentielle. C’est grâce à elle que vous apprendrez vraiment à comprendre et utiliser les notions vues précédemment. Elle se décompose en plusieurs itérations : ent1, ent2, etc.
Vous devez réaliser au moins une itération et évaluer votre niveau de réussite par une valeur entre 1 et 4 selon les critères habituels. L’itération que vous avez traité le plus récemment est appelée itération courante. On appelle itération suivante celle qui suit l’itération courante, excepté si l’itération courante est la dernière disponible, auquel cas l’itération suivante est la première itération.
Si le résultat est 1, vous devrez traiter à nouveau l’activité de découverte précédente, en laissant passer au moins une nuit, avant de revenir à cette activité d’entraînement en réalisant à nouveau l’itération courante. Vous devez aussi essayer d’identifier les points de blocage et demander à votre enseignant de vous aider à les surmonter.
Si le résultat est 2, vous devrez d’abord comprendre ce qui vous a conduit à des erreurs et / ou ce qui vous a bloqué. Si vous avez des doutes, des difficultés, essayez de trouver les réponses dans les présentations et explication de l’activité de découverte précédente et demandez toute l’aide nécessaire à votre enseignant. Ensuite, vous devrez réaliser l’itération suivante de l’activité d’entraînement actuelle après un délai d’au moins deux jours et d’au plus une semaine.
Si le résultat est 3, vous devrez revenir traiter l’itération suivante après un délai de plusieurs semaines.
En traitant les exercices, vous devrez considérer que les paramètres des fonctions ont des valeurs correctes. Il ne vous est pas demandé de vérifier si certaines valeurs sont aberrantes au regard de ce que demande l’énoncé. Par exemple, si un paramètre doit être positif pour que le traitement demandé soit possible, vous considérerez que la fonction sera appelée avec une valeur positive de ce paramètre.
Vous pouvez utiliser un ordinateur pour tester vos solutions et les corriger en cas de comportement inattendu. C’est même recommandé, à condition de commencer par réfléchir avant de vous jeter sur le clavier. Si vous pensez avoir une solution différente de celle proposée, ce qui peut arriver souvent, vous ne devez en aucun cas rester dans le doute. Vous devez vérifier si votre solution est correcte ou non, soit en testant votre solution avec un ordinateur, soit en demandant à une personne enseignante.
Itération A.ent1
Exercice d’entrainement A.ent1.1
Réalisez une fonction somme ayant un paramètre n de type int et retournant un entier égal à la somme de tous les entiers compris entre 1 et n. Par exemple, l’appel somme(3) devra retourner la valeur 6, c’est à dire 1 + 2 + 3. Réalisez une fonction main qui calcule et affiche la somme des entiers compris entre 1 et 100 en utilisant la fonction somme.
Voici une partie de la définition de somme, à compléter.
int somme(int n)
{
int total = 0;
for( )
{
}
return total;
}
int somme(int n)
{
int total = 0;
for(int i=0; i <= n; i++)
{
total = total + i;
}
return total;
}
int main()
{
printf("%d\n", somme(100));
return 0;
}
Exercice d’entrainement A.ent1.2
Réalisez une fonction void printMotif(int n) qui affiche le motif suivant dont la largeur et la hauteur doivent être de 2n – 1 caractères. L’exemple est donné pour n égal à 6. Vous pouvez ajouter certaines fonctions, et c’est même conseillé pour rendre votre code plus lisible.
A A A A A A
A A
A A
A A
A A
A A A A A A
// Affiche n caractère 'A' séparés par des espaces
void printLine1(int n)
{
for(int i=0; i<n; i++)
{
// À compléter
}
}
// affiche 2 caractères 'A' séparés par 2n-4 espaces
void printLine2(int n)
{
// À compléter
}
void printMotif(int n)
{
printLine1();
// À compléter
printLine1();
}
// Affiche n A séparés par des espaces
void printLine1(int n)
{
for(int i=0; i<n; i++)
{
printf("A ");
}
printf("\n");
}
// affiche 2 A séparés par 2n-4 espaces
void printLine2(int n)
{
// À compléter
}
void printMotif(int n)
{
printLine1();
for(int i=0; i<(n-2); i++)
{
// À compléter
}
printLine1();
}
// Affiche n A séparés par des espaces
void printLine1(int n)
{
for(int i=0; i<n; i++)
{
printf("A ");
}
printf("\n");
}
// affiche 2 A séparés par 2n-4 espaces
void printLine2(int n)
{
printf("A ");
for(int i=0; i<((2*n)-4); i++)
{
printf(" ");
}
printf("A\n");
}
void printMotif(int n)
{
printLine1(n);
for(int i=0; i<(n-2); i++)
{
printLine2(n);
}
printLine1(n);
}
Exercice d’entrainement A.ent1.3
Soit la fonction suivante.
void f(int k)
{
for(int i=k; i >= 0; i--)
{
printf("%d ",i);
}
printf("\n");
}
Donnez les affichages réalisés par f(5) et réécrivez la fonction f sans utiliser de for mais en utilisant un while. La nouvelle fonction doit se comporter en tous points comme l’ancienne.
L’affichage est :
5 4 3 2 1 0
Voici un squelette à compléter de la nouvelle fonction.
void f(int k)
{
// Initialisation à compléter
while( )
{
printf("%d ",i);
// À compléter
}
printf("\n");
}
void f(int k)
{
int i = k;
while(i >=0)
{
printf("%d ",i);
i--;
}
printf("\n");
}
Itération A.ent2
Exercice d’entrainement A.ent2.1
Réalisez une fonction int mul(int a, int b) retournant le produit de tous les nombres compris entre a (inclus) et b (inclus). Réalisez une fonction main qui calcule et affiche le produit des entiers compris entre 3 et 7 des en utilisant la fonction mul.
Voici une partie de la définition de mul, à compléter.
int mul(int a, int b)
{
int produit = 1;
for( )
{
}
return produit;
}
int mul(int a, int b)
{
int produit = 1;
for(int i=a; i <= b; i++)
{
produit = produit * i;
}
return produit;
}
int main()
{
printf("%d\n", mul(3, 7));
return 0;
}
Exercice d’entrainement A.ent2.2
Réalisez une fonction void printMotif(int n) qui affiche le motif suivant dont la largeur à la base doit être de n caractères. On suppose que n est impair. L’exemple est donné pour n égal à 7. Vous pouvez ajouter certaines fonctions, et c’est même conseillé pour rendre votre code plus lisible. La clé du succès est de décomposer le traitement à réaliser en plusieurs étapes.
A
AAA
AAAAA
AAAAAAA
// Affiche n espaces suivis de m caractères 'A'
void printLine(int n, int m)
{
for(int i=0; i<n; i++)
{
// À compléter
}
// À compléter
}
void printMotif(int n)
{
// À compléter
}
// Affiche n espaces suivis de m caractères 'A'
void printLine(int n, int m)
{
for(int i=0; i<n; i++)
{
printf(" ");
}
for(int i=0; i<n; i++)
{
printf("A");
}
printf("\n");
}
void printMotif(int n)
{
int k = (n+1)/2; // Nombre de ligne à afficher
int m = 1; // Nombre de A par ligne
for(int i=k-1; i<=0; i--)
{
// À compléter
}
}
On numérote les lignes de k-1 à 0 en partant du sommet du triangle, c’est à dire de la première ligne à afficher. Combien faut-il d’espaces au début de la ligne k ? Il faut un caractère ‘A’ sur la première ligne. De combien le nombre de ‘A’ à afficher augmente d’une ligne à la suivante ? En répondant à toutes ces questions, et en faisant des essais et erreurs, tentez de trouver la solution.
// Affiche n espaces suivis de m caractères 'A'
void printLine(int n, int m)
{
for(int i=0; i<n; i++)
{
printf(" ");
}
for(int i=0; i<m; i++)
{
printf("A");
}
printf("\n");
}
void printMotif(int n)
{
int k = (n+1)/2; // Nombre de ligne à afficher
int m = 1; // Nombre de A par ligne
for(int i=k-1; i>=0; i--)
{
printLine(m, i);
m = m + 2;
}
}
Exercice d’entrainement A.ent2.3
Soit la fonction suivante.
int fact(int k)
{
int p = 1;
for(int i=1; i <= k; i++)
{
p = p * i;
}
return p;
}
Donnez la valeur retournée par fact(5) et réécrivez la fonction fact sans utiliser de for mais en utilisant un while. La nouvelle fonction doit se comporter en tous points comme l’ancienne.
La valeur de retour est 120.
Voici un squelette à compléter de la nouvelle fonction.
int fact(int k)
{
int p = 1;
// À compléter
while( )
{
p = p * i;
// À compléter
}
return p;
}
int fact(int k)
{
int p = 1;
int i = 1;
while(i <= k)
{
p = p * i;
i++;
}
return p;
}
Itération A.ent3
Exercice d’entrainement A.ent3.1
Le terme de rang (i) de la suite de Syracuse de valeur initiale (k), noté (S_k(i)), est défini ainsi :
- \(S_k(0) = k\),
- Pour tout entier pair \(i>0\), \(S_k(i) = S_k(i-1) / 2\),
- Pour tout entier impair \(i>0\), \(S_k(i) = 3 \cdot S_k(i-1) + 1\).
Par exemple, les premiers termes de la suite de Syracuse de valeur initiale 6 sont les suivants :
6, 3, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, ...
Vous devez définir une fonction int syr(int k, int i) qui calcule le terme de rang i de la suite de Syracuse de valeur initiale k.
int syr(int k, int i)
{
int s = k;
for(int rang=1; rang <= i; rang++)
{
// À compléter
}
return s;
}
Le terme de rang 0 est k. Il faut ensuite calculer les termes de rang 1 à i. Chaque nouveau terme sera calculé par une itération de la boucle et remplacera le précédent dans la variable s.
int syr(int k, int i)
{
int s = k;
for(int rang=1; rang <= i; rang++)
{
if(s % 2)
{// La valeur courante est impaire.
s = (3*s) + 1;
}
else
{// La valeur courante est paire.
s = s / 2;
}
}
return s;
}
Exercice d’entrainement A.ent3.2
Voici le code d’une fonction qui accepte deux paramètres de type int et retourne une valeur de type int.
int myst(int k, int i)
{
int s = k;
for(int rang=1; rang <= i; rang++)
{
if(s % 2)
{// La valeur courante est impaire.
s = (3*s) + 1;
}
else
{// La valeur courante est paire.
s = s / 2;
}
}
return s;
}
Vous devez décomposer ce code en deux définitions de fonctions. Une fonction myst plus courte et sans if … else, et une autre fonction calc appelée par la première. Attention, pour que le programme compile, il faudra placer la définition de la fonction calc avant celle de la fonction myst dans le fichier source.
// À compléter avec la définition de calc
int myst(int k, int i)
{
int s = k;
for(int rang=1; rang <= i; rang++)
{
s = calc(s);
}
return s;
}
Voici le code de la fonction calc.
int calc(int t)
{
if(t % 2)
{// La valeur courante est impaire.
return (3*t) + 1;
}
else
{// La valeur courante est paire.
return t / 2;
}
}
Exercice d’entrainement A.ent3.2
Dans un jeu, on fait des tirages avec des dés avec les modalités suivantes : on lance n dés à k faces et le résultat est le meilleur score des dés lancés. Par exemple, avec n égal à 3 et k égal à 6, si les valeurs obtenues par les trois dés sont 3, 5 et 5, le résultat du tirage est 5.
Vous devez réaliser une fonction int tirage(int n, int k) qui réalise un tirage selon ces modalités et retourne le résultat. On suppose que n vaut au moins 1 et k au moins 2.
int tirage(int n, int k)
{
int resultat = 1 + (rand() % k);
for( )
{
// À compléter
}
return resultat;
}
int tirage(int n, int k)
{
int resultat = 1 + (rand() % k);
for(int i=0; i < n-1; i++)
{
// Faire un lancer
// Si le score obtenu dépasse resultat
// alors mettre à jour resultat.
}
return resultat;
}
int tirage(int n, int k)
{
int resultat = 1 + (rand() % k);
for(int i=0; i < n-1; i++)
{
int lancer = 1 + (rand() % k);
if(lancer > resultat)
{
resultat = lancer;
}
}
return resultat;
}
Activité A.top
Cette activité propose des exercices de consolidation qui ne doivent être abordés que par les personnes apprenantes maîtrisant bien la partie A et les parties suivantes disponibles, c’est à dire qui ont obtenu un score au moins égal à 3 aux activités découverte et d’entraînement de ces parties.
Par exemple, si les parties actuellement disponibles sont A et B, vous devez d’abord maîtriser la parie B avant de faire cette activité de consolidation de la partie A. Faire
Itération A.top1
Cette itération consiste à traiter l’exercice suivant.
Exercice de consolidation A.top1
On représente une date l’entier entier (j + 100 \cdot m + 10000 \cdot a), où (j) est le Jour, (m) le mois et (a) l’année.
Par exemple, le 8 Janvier 2021 est codé par l’entier dont la représentation en base 10 est 20210108.
Vous devez réaliser les fonctions suivantes :
int code(int j, int m, int a)qui calcule le code d’une date d’après son jour, moi et année.int jour(int code),int mois(int code),int annee(int code)qui retournent respectivement le jour, le mois et l’année d’une date d’après son code.int compare(int date1, int date2)qui compare chronologiquement les deux dates dont les codes sont passés en paramètres. si les deux dates sont identiques, la valeur de retour doit être 0. Si la première date est située (chronologiquement) avant la deuxième, la valeur de retour doit être négative. Si la deuxième date est antérieure à la première, la valeur de retour doit être positive.
Le codage consiste à appliquer la formule donnée par l’énoncé. La comparaison est également immédiate, puisque par construction du code, une date \(d_1\) est située avant \(d_2\) si et seulement si le code de \(d_1\) est plus petit que celui de \(d_2\).
La principale difficulté est de retrouver l’année, le mois et le jour à partir du code d’une date. On peut faire cela avec des divisions entières et des modulos.
Avant de regarder les éléments de solution, testez-la sur votre sur machine.
Soit \(c\) le code d’une date. Le jour est \(c \mod 100\). Soit \(c’ = c \div 100\). (Le symbole \(\div\) représente ici la division entière). Le mois est \(c’ \mod 100\) et l’année \(c’ \div 100\).