PROFDINFO.COM

Votre enseignant d'informatique en ligne

Laboratoire 4 - Fonctions

Exercice 4.1

Écrivez le prototype ainsi que la définition de la fonction AfficherBonjour qui ne fait qu'afficher le mot « Bonjour » à l’écran.  Testez votre fonction avec un programme principal (main) qui appelle la fonction AfficherBonjour et rien de plus.

Exercice 4.2

Écrivez le prototype ainsi que la définition de la fonction DemanderNombre qui demande un nombre à l'usager et qui retourne ce nombre.  Testez votre fonction avec un programme principal (main) qui appelle la fonction DemanderNombre et qui affiche le nombre retourné par la fonction. Notez que c'est DemanderNombre qui fait la lecture du nombre et qui le retourne, puis c'est le programme principal qui affiche le nombre reçu.

Exercice 4.3

Écrivez le prototype ainsi que la définition de la fonction AfficherMenu qui affiche le menu suivant :

  1. Calcul de la circonference d’un cercle
  2. Calcul de la surface d’un cercle
  3. Calcul du volume d’une sphère
  4. Quitter

La fonction doit demander à l'usager d'entrer son choix et redemander le choix à l'usager tant et aussi longtemps que le choix est invalide. La fonction retourne ensuite le choix valide effectué par l’usager.

Testez votre fonction avec un programme principal qui appelle la fonction AfficherMenu. Le programme principal doit ensuite poser les questions et effectuer les calculs nécessaires pour traiter le choix reçu par AfficherMenu. Il sait que le choix est nécessairement valide et n'a donc pas à gérer les cas d'erreur!

Exercice 4.4

Écrivez le prototype ainsi que la définition de la fonction AfficherLigne qui affiche la ligne suivante en utilisant une boucle:

oooooooooo

Écrivez le prototype ainsi que la définition de la fonction AfficherCarre qui affiche le dessin suivant en utilisant une boucle et un appel à la fonction AfficherLigne:

oooooooooo
oooooooooo
oooooooooo
oooooooooo
oooooooooo
oooooooooo
oooooooooo
oooooooooo
oooooooooo
oooooooooo

Testez vos fonctions avec un programme principal qui appelle simplement la fonction AfficherCarre.

Bonus pour les pros : arriveriez-vous à ajouter un paramètre à AfficherCarre afin que l'on puisse lui donner la dimension du carré voulue? Par exemple, AfficherCarre(5) donnerait:

ooooo
ooooo
ooooo
ooooo
ooooo

Exercice 4.5

Écrivez la série de fonctions mathématiques ci-dessous. Écrivez aussi un programme principal (main) qui permet de tester chacune de ces fonctions. Ce programme devra faire en sorte que l'usager peut choisir ce qu'il veut tester ou devra lui-même appeler chacune des fonctions afin de tester les différentes possibilités pour prouver que tout fonctionne bien.

ATTENTION! Il est interdit d'effectuer des lectures (cin) et des écritures (cout) dans vos fonctions mathématiques. Celles-ci doivent simplement accepter leurs intrants en paramètres et retourner leur résultat, sans rien demander ni afficher. C'est le programme principal qui se chargera de ces opérations et qui appellera les fonctions simplement pour faire les calculs.

Exercice 4.6

Soit le diagramme hiérarchique suivant :

dh

Le programme principal commence par appeller GererMenu en lui passant une borne minimale et une borne maximale. GererMenu appelle AfficherMenu qui affiche un message du genre "Veuillez entrer un nombre entre [BorneMin] et [BorneMax]". GererMenu appelle LireNombre qui demande un nombre à l'usager et retourne ce nombre à GererMenu. GererMenu recommence tant que le nombre lu n'est pas entre les bornes et retourne le nombre au programme principal. Par la suite le programme principale appelle CommenterNombre. CommenterNombre appelle EstPair avec le nombre. EstPair retourne vrai ou faux. CommenterNombre appelle EstPremier avec le nombre. EstPremier retourne vrai ou faux. Finalemment, CommenterNombre appelle AfficherResultats avec le nombre et deux booléens pour afficher le résultat final.

Pour chaque sous-programme, vous devez faire un en-tête qui contient:

Exercice 4.7

Écrire un programme qui permet de calculer le total d'une facture d'épicerie. Le programme doit commencer par afficher le menu suivant:

  1. Ajouter un article non-taxable
  2. Ajouter un article taxable
  3. Afficher le total
  4. Quitter

Ensuite le programme demande à l'usager de faire un choix.

Si le choix 1 est sélectionné, le programme demande le montant de l'article à l'usager (entre 0 et 1000$) et ajoute le montant au total.

Si le choix 2 est sélectionné, le programme demande le montant de l'article à l'usager (entre 0 et 1000$), calcule les taxes (TPS=5% et TVQ=9,975%) et ajoute le montant et les taxes au total. N'oubliez pas que la TVQ ne s'applique plus sur le montant avec la TPS depuis le 1er janvier 2013. On la calcule simplement sur le montant sans taxe, comme la TPS.

Si le choix 3 est sélectionné, le programme affiche le total actuel de la facture d'épicerie.

Si le choix 4 est sélectionné, le programme affiche "au revoir!" et se termine.

Votre programme doit obligatoirement suivre le diagramme hierarchique suivant:

ex4.8

De plus, pour chaque sous-programme, vous devez faire un en-tête qui contient:

Exercice 4.8

Écrivez et testez la fonction Factorielle() qui :

Note :        

Factorielle(0) = 1
Factorielle(1) = 1
Factorielle(N) = 1 * 2 * 3 * ... * N (avec N > 1)

Exemple : Factorielle (3) = 1 * 2 * 3 = 6
Exemple : Factorielle (5) = 1 * 2 * 3 * 4 * 5 = 120

N.B.: Pouvez-vous trouver la valeur de N au-dessus de laquelle votre fonction donne un mauvais résultat??

N'oubliez pas votre en-tête de fonction.

Exercice 4.9

N.B.: Pour cet exercice, il est important de suivre les étapes dans l'ordre!

ÉTAPE A

Écrivez un sous-programme qui demande un nombre entier entre 1 et 100 et le valide. Le sous-programme doit retourner le nombre validé au programme appellant.

Testez le bon fonctionnement de votre sous-programme et n'oubliez pas l'en-tête!

ÉTAPE B

Écrivez un sous-programme qui recoit deux nombres entiers et qui affiche à l'écran "plus petit" si le premier nombre est plus petit que le deuxième nombre, "plus grand" si le premier nombre est plus grand que le deuxième nombre et "égal" si les deux nombres sont égaux.

Testez le bon fonctionnement de votre sous-programme et n'oubliez pas l'en-tête!

ÉTAPE C

Programmez un petit jeu de devinette. Le premier joueur entre un nombre entre 1 et 100 sans que le deuxième joueur le voit. Le programme demande alors au deuxième joueur d'entrer un nombre entre 1 et 100 et le programme lui indique si le nombre entré est plus petit, plus grand ou égal au nombre du premier joueur. Le programme recommence tant et aussi longtemps que le deuxième usager n'a pas trouvé le nombre du premier joueur. Pour réaliser ce jeu petit jeu, vous devez utiliser les sous-programmes développés aux étapes précédentes.

Testez le bon fonctionnement de votre programme.

Pour effacer la console console, utilisez l'instruction system("cls");

Exercice 4.10

Utilisez l'approche "top-down" afin d'écrire un programme qui affichera le dessin suivant:

 

***
***
***
----
----
----
----
=====
=====
=====
=====
=====

Votre programme doit contenir au minimum deux sous-programmes sans compter le programme principal.

IMPORTANT: Aucun sous-programme, ni le programme principal, ne doit contenir plus d'une boucle!

Exercice 4.11

Écrire un programme qui permet de récupérer une sous-chaîne à partir d’une chaîne de caractère.  Créez une fonction qui acceptera la chaîne de caractère, la position de départ et la position de fin pour la sous-chaîne.  La fonction retourne la sous-chaîne au programme appelant.

Exercice 4.12

Écrivez une fonction qui accepte une chaîne de caractère et qui vérifie si la chaîne reçue est un palindrome.  Une chaîne est un palindrome si la chaîne est la même de gauche à droite et de droite à gauche.  Exemples : radar, laval, mazam.  La fonction retournera vraie si la chaîne est un palindrome et faux dans le cas contraire.

Exercice 4.13

Écrivez une fonction qui accepte une chaîne de caractère et qui retourne cette même chaîne en caractère majuscule.

Exercice 4.14

Écrivez un programme qui permet de faire la conversion de la base 2 à la base 10 et inversement.  Pour ce faire, vous devez écrire une fonction qui accepte en paramètre le nombre à convertir, la base de départ du nombre reçu et la base dans laquelle le nombre doit être converti.  La fonction retournera le nombre converti au programme appelant.

Exercice 4.15

Écrire le diagramme hiérarchique et le programme qui permet de jouer au célèbre jeu du bonhomme pendu. Le programme doit dans un premier temps demander un mot au premier joueur, effacer l'écran et afficher un nombre de traits d'union correspondant au nombre de lettres dans le mot. Ensuite, le programme demande une lettre au deuxième joueur et, si la lettre appartient au mot, il doit afficher la lettre aux bons endroits dans le mot. Si la lettre n'appartient pas au mot, une vie est perdue. Le programme redemande une lettre tant que le mot n'a pas été trouvé au complet ou que le joueur a perdu cinq vies. Si vous désirez un plan pour débuter, cliquez ici.

Exercice 4.16

Écrire le diagramme hiérarchique ainsi que le programme C++ qui permettra de résoudre le problème ci-dessous.

On veut produire les résultats annuels d'une classe composée d'un certain nombre d'étudiants.  Les données fournies pour chaque étudiant sont son numéro et ses 3 notes.

La fin des données est signalée par un numéro fictif égal à 999999. 

On désire afficher, pour chaque étudiant son numéro et sa moyenne. Pour l'ensemble de la classe, on affichera le nombre d'étudiants et la moyenne de la classe.

N.B.: Pour réaliser cet exercice, vous devez utiliser judicieusement le passage de paramètres par référence!

 

Exercice 4.17

Sans utiliser Visual Studio, indiquez la sortie du programme suivant. Ensuite, produisez les deux tableaux d'état de la mémoire suite à l'exécution de ce programme. 

#include <iostream>
using namespace std;

void FctA(int A, int B);
void FctB(int &A, int B);
void FctC(int A, int &B);
void FctD(int &A, int &B);

int main()
{
   int Pomme = 5;
   int Tomate = 10;

   FctA(Pomme, Tomate);
   FctB(Pomme, Tomate);
   FctC(Pomme, Tomate);
   FctD(Pomme, Tomate);

   cout << " Pomme = "
      << Pomme
      << endl
      << " Tomate = "
      << Tomate
      << endl;
}

void FctA(int A, int B)
{
   A += 100;
   B += 100;
}

void FctB(int &A, int B)
{
   A += 100;
   B += 100;
}

void FctC(int A, int &B)
{
   A += 100;
   B += 100;
}

void FctD(int &A, int &B)
{
   A += 100;
   B += 100;
}

Exercice 4.18

Sans utiliser Visual Studio, remplissez les tableaux suivants indiquant les valeurs des variables après chaque appel de fonction, si les nombres de la première ligne de chaque tableau ont été entrés à l'étape 0.

 

Étape
Val1
Val2
Val3
0
1
3
8
1
2
3
4
5
6


Étape
Val1
Val2
Val3
0
2
4
5
1
2
3
4
5
6

 

#include <iostream>
using namespace std;

void fct1(int  X, int  Y, int &Z);
void fct2(int  X, int &Y, int  Z);
void fct3(int &X, int  Y, int  Z);
void fct4(int  X, int &Y, int &Z);
void fct5(int &X, int  Y, int &Z);
void fct6(int &X, int &Y, int &Z);

int main()
{
   int Val1;
   int Val2;
   int Val3;

   cin >> Val1;
   cin >> Val2;
   cin >> Val3;            // Étape 0

   fct1(Val1, Val2, Val3); // Étape 1
   cout << Val1 << " " << Val2 << " " << Val3 << endl;

   fct2(Val1, Val2, Val3); // Étape 2
   cout << Val1 << " " << Val2 << " " << Val3 << endl;

   fct3(Val1, Val2, Val3); // Étape 3
   cout << Val1 << " " << Val2 << " " << Val3 << endl;

   fct4(Val1, Val2, Val3); // Étape 4
   cout << Val1 << " " << Val2 << " " << Val3 << endl;

   fct5(Val1, Val2, Val3); // Étape 5
   cout << Val1 << " " << Val2 << " " << Val3 << endl;

   fct6(Val1, Val2, Val3); // Étape 6
   cout << Val1 << " " << Val2 << " " << Val3 << endl;
}

void fct1(int X, int Y, int &Z)
{
   X = X + Y;
   Y = (X + Y) * 2;
   Z = Z - X;
}

void fct2(int X, int &Y, int Z)
{
   X = X + Y;
   Y = X + Y * 2;
   Z = Z - X;
}

void fct3(int &X, int Y, int Z)
{
   X = X + Y;
   Y = (X + Y) * 2;
   Z = Z - X;
}

void fct4(int X, int &Y, int &Z)
{
   X = X + Y;
   Y = X + Y * 2;
   Z = Z - X;
}

void fct5(int &X, int Y, int &Z)
{
   X = X + Y;
   Y = (X + Y) * 2;
   Z = Z - X;
}

void fct6(int &X, int &Y, int &Z)
{
   X = X + Y;
   Y = X + Y * 2;
   Z = Z - X;
}