TP 1 - Premiers contacts

TP 1 - Premiers contacts

Remarques préliminaires

Ce TP est constitué de plusieurs exercices indépendants, le dernier étant la réalisation d'un menu très simple permettant à l'utilisateur de choisir l'exécution d'une des fonctions correspondant aux exercices précédents. Pour ce faire, au cours de la progression de ce TP, il vous est proposé d'ajouter successivement les différentes fonctions correspondant aux différents exercices dans le même fichier source, que nous avons noté tp_01.cxx.

Cependant, afin de pouvoir présenter séparément les différents corrigés, nous avons stocké chacun d'eux dans un fichier différent : Bonjour.cxx pour le premier exercice, 10EntiersNaturels pour le deuxième, etc.


1) - Bonjour
Objectifs

Mise en place du squelette qui servira à tous les exercices suivants (en-tête, fonction main())

Utilisation de l'espace de noms anonyme,

Définition et appel d'une fonction simple.

Premiers affichages en essayant différentes injections - dont le manipulateur endl - dans le flux standard de sortie (cout).

Sujet

Si ce n'est pas déjà fait, créer le répertoire tp/tpC++/ sur le bureau, dans le dossier net-home, modifier les droits pour que les enseignants aient les droits en lecture.

Dans le dossier net-home/tp/tpC++, créer le sous-répertoire tp_01.

Recopier le squelette suivant dans le fichier tp_01.cxx de votre répertoire de travail :

Code:

/**
 *
 * @file  tp_01.cxx
 *
 * @author ToDo
 *
 * @date  ToDo
 *
 * @brief  ToDo
 *
**/
#include <iostream>

using namespace std;

namespace
{
    void Bonjour()
    {
        // ToDo

    } // Bonjour()

} // namespace

int main ()
{
    // ToDo

    return 0;

} // main()

Dans l'espace de noms anonyme du fichier tp_01.cxx, compléter la fonction Bonjour() qui affiche "Bonjour" (ou n'importe quel autre message) proprement (retour à la ligne pour le prompt suivant).

Dans la fonction main(), appeler la fonction Bonjour().

Ouvrir un terminal, se placer dans le répertoire net-home/tp/tpC++/tp_01, compiler tp_01.cxx et l'exécuter.

Essayer plusieurs chaînes différentes, plusieurs injections successives.

Corrigé

2) - Les 10 premiers entiers
Objectifs

Traduction d'une structure répétitive avec compteur d'itération au moyen de l'instruction for ( ; ; ),

déclaration du compteur de boucle,

initialisation

sortie (ou continuation) de la boucle,

progression de la boucle (incrémentation)

Utilisation de la tabulation '\t'

Sujet

Dans l'espace de noms anonyme du fichier tp_01.cxx, ajouter la fonction _10PremiersEntiers() qui afficher à l'écran les 10 premiers entiers naturels : [0..9], séparés par une tabulation (le caractère noté '\t').

Rappel

Un identificateur ne pouvant pas commencer par un chiffre, nous avons exceptionnellement fait précéder 10PremiersEntiers du caractère '_'.
Algorithme

S'inspirer de l'énoncé de l'exercice d'algorithmique du Td 01 - Algorithmes de base : "Les 10 premiers entiers naturels"

Code:

algorithme DixEntiersNaturels
debut
    afficher (0);
    pour (i variant_de 1 a 9)
    faire
        afficher ('-', i);
    ffaire
    ligne_suivante;

fin

Rappels

1. La traduction exacte du schéma itératif pour ... faire ... ffaire de l'algorithmique n'existe pas en C++. Il est donc nécessaire de passer par le schéma itératif tant-que ... faire ... ffaire, selon le modèle suivant :
   

   Code:

   
                                               |  declarer i : entier_naturel; //ou autre
                                               |  i <- Inf;
   pour (i variant de Inf a Sup)  |  tant_que (i <= Sup)
   faire                                    |  faire
       ...                                    |      ...
                                               |      i <- i + 1;
   ffaire                                    |  ffaire
   

2. La traduction du schéma itératif tant_que ... faire ... ffaire de l'algorithmique en C++ peut être réalisée au moyen de l'instruction for ( ; ; ), selon le modèle suivant :
   
   

Exécution

L'affichage obtenu devra être rigoureusement le suivant :

Code:

Les dix premiers entiers naturels :
0      1      2      3      4      5      6      7      8      9

Corrigé

3) - Les 200 premiers entiers
Objectifs

Utilisation du manipulateur setw() et du fichier inclus associé iomanip.

Sujet

Dans l'espace de noms anonyme du fichier tp_01.cxx, écrire la fonction (procédure) _200PremiersEntiers() qui affiche les 200 premiers entiers naturels : [0..199], à raison de 10 par ligne, séparés par une tabulation. Pour que les nombres soient correctement alignés, utiliser le manipulateur de formatage setw() (déclaré dans le fichier <iomanip>).

Ajouter l'appel de _200PremiersEntiers() à la fonction main().
Algorithme

S'inspirer de l'
énoncé de l'exercice d'algorithmique du Td 01 - Algorithmes de base : "Les 200 premiers entiers naturels"

Code:

algorithme DeuxCentsEntiersNaturels
debut

    declarer ValDebutLigne : entier_naturel;
    ValDebutLigne <- 0;

    declarer NbLignes : entier_naturel;
    NbLignes <- 0;
    tant_que (NbLignes < 20)
    faire
        afficher (ValDebutLigne);

        declarer ValAffichee : entier_naturel;
        ValAffichee <- ValDebutLigne + 1;
        tant_que (ValAffichee < ValDebutLigne + 10)
        faire
            afficher ('-', ValAffichee);
            ValAffichee <- ValAffichee + 1;
        ffaire
        ligne_suivante;
        ValDebutLigne <- ValDebutLigne + 10;
        NbLignes <- NbLignes + 1;
    ffaire

fin

Exécution

L'exécution devra commencer par l'affichage du titre suivant, sur la première ligne :

Code:

Les 200 premiers entiers naturels à 10 par ligne :

Corrigé

4) - Les N premiers entiers
Objectifs

Lecture d'un entier dans le flux standard cin et son utilisation.

Sujet

Dans la fonction NPremiersEntiers() de l'espace de noms anonyme du fichier tp_01.cxx, afficher les N premiers entiers naturels : [0..N[ (intervalle semi-ouvert : N est exclus), à raison de 10 par ligne, séparés par une tabulation. Pour que les nombres soient correctement alignés, utiliser le manipulateur de formatage setw().

La valeur de N doit préalablement être lue au clavier.

Ajouter l'appel de nPremiersEntiers() à la fonction main().
Algorithme
Enoncé de l'exercice d'algorithmique du Td 01 - Algorithmes de base : "Les N premiers entiers naturels"

Code:

algorithme NEntiersNaturels
debut

    declarer N : entier_naturel;
    saisir (N);
    declarer ValDebutLigne : entier_naturel;
    ValDebutLigne <- 0;
    declarer NbLignesCompletes : entier_naturel;
    NbLignesCompletes <-  N / 10;

    // Affichage de toutes les lignes completes
    //                                                      {0}

    declarer NbLignes : entier_naturel;
    NbLignes <- 0;
    tant_que (NbLignes < NbLignesCompletes)
    faire
        afficher (ValDebutLigne);

        declarer ValAffichee : entier_naturel;              {1}
        ValAffichee <- ValDebutLigne + 1;

        // Affichage d'une ligne (forcement complete)

        tant_que (ValAffichee < ValDebutLigne + 10)
        faire
            afficher ('-', ValAffichee);
            ValAffichee <- ValAffichee + 1;
        ffaire
        ligne_suivante;
        ValDebutLigne <- ValDebutLigne + 10;
        NbLignes <- NbLignes + 1;
    ffaire
   
    // Affichage de la derniere ligne SI ELLE EST INCOMPLETE

    si (ValDebutLigne < N)
        declarer ValAffichee : entier_naturel;              {2}
        ValAffichee <- ValDebutLigne;
        tant_que (ValAffichee < N - 1)
        faire
            afficher (ValAffichee, '-');
            ValAffichee <- ValAffichee + 1;
        ffaire

        // Affichage du dernier nombre de la derniere ligne

        afficher (N - 1);
        ligne_suivante;
    fsi

fin

Exécution

L'exécution doit commencer par l'affichage du titre suivant, sur la première ligne :

Code:

Les # premiers entiers naturels à 10 par ligne

où '#' représente le nombre qui a été lu.

La saisie de N doit être précédée du message :

Code:

"Taper le nombre d'entiers voulus, suivi de <entrée> : "

Essayer pour différentes valeurs (0, 5, 10, 15 par exemple).

Essayer, "pour voir", en tapant une valeur invalide (un caractère quelconque, un entier négatif, un mot, etc.).

Corrigé

5) - Les N premiers entiers en sous-programmes
Objectifs

• Ecriture de fonctions paramétrées.
  
• Passage d'un tableau en paramètre
  
• Traduction du schéma répétitif boucle ... fboucle.
  
• Utilisation du caractère '\n' correspondant au caractère LF (Line Feed) aussi noté NL (New Line)

Sujet

Il s'agit maintenant de générer dans un tableau les N premiers entiers naturels : [0..N[ (intervalle semi-ouvert : N est exclus), puis d'afficher le contenu du tableau.

Pour obtenir la plus grande souplesse d'utilisation, plusieurs caractéristiques doivent êtres lues au clavier avant le traitement :

• la valeur de N, qui doit aussi être validée ( > 0),
  
  
• le nombre d'éléments par ligne, à valider ( > 0),
  
  
• la "largeur d'affichage" (= nombre de colonnes) de chaque entier, à valider ( > 0),
  
  
• le caractère de séparation.
  

La validation d'un entier positif saisi au clavier étant utilisée plusieurs fois dans le programme, elle sera effectuée au moyen d'une fonction.

Afin de pouvoir réutiliser ultérieurement l'affichage d'un tableau, celui-ci sera lui aussi mis sous la forme d'un sous-programme (une procédure) paramétré.

Dans l'espace de noms anonyme du fichier tp_01.cxx, et en s'inspirant des algorithmes ci-dessous :

• écrire la fonction SaisirEntierPositif(),
  
  
• écrire la fonction AffichTabInt(),
  
  
• écrire la fonction SP_NPremiersEntiers() (SP_ comme Sous-Programme) qui se décompose en :
  

saisir le nombre N d'entiers à générer,


saisir le nombre de valeurs à afficher par ligne,


saisir la largeur d'affichage de chaque entier affiché,


saisir le caractère de séparation,


remplir un tableau de ces N entiers,


afficher le contenu du tableau.

Limiter l'utilisation du manipulateur endl en le remplaçant chaque fois que possible par le caractère '\n'.

Algorithme
énoncé de l'exercice d'algorithmique du Td 02 - Tableaux (I) : "Générer un tableau de N entiers avec des sous-programmes"

A) - Fonction SaisirEntierPositif

Code:

fonction SaisirEntierPositif (Invite : in string,
                              MsgErr : in string)
    renvoie entier_naturel

debut
    declarer N : entier_naturel;

    boucle
        afficher (Invite);
        saisir  (N);
        si (N > 0) sortie;
        afficher (MsgErr);
        ligne_suivante;
    fboucle

    renvoie N;

fin

B) - Procédure AffichTabInt

Code:

procedure AffichTabInt (Tableau    : in tableau_de entier_naturel,
                        NbParLigne : in entier_naturel,
                        Separateur : in caractere)
debut
    // Affichage du tableau

    declarer RgFirstElem : entier_naturel;
    RgFirstElem <- 0;
    declarer NbLignesCompletes : entier_naturel;
    NbLignesCompletes <- taille (Tableau) / NbParLigne;

    // Affichage de toutes les lignes complètes

    declarer NbLignes : entier_naturel;
    NbLignes <- 0;
    tant_que (NbLignes < NbLignesCompletes)
    faire
        afficher (TableauRgFirstElem);

        declarer RgElem : entier_naturel;
        RgElem <- RgFirstElem + 1;

        // Affichage d'une ligne (forcément complète)

        tant_que (RgElem < RgFirstElem + NbParLigne)
        faire
            afficher (Separateur, TableauRgElem);
            RgElem <- RgElem + 1;
        ffaire
        ligne_suivante;
        RgFirstElem <- RgFirstElem + NbParLigne;
        NbLignes <- NbLignes + 1;
    ffaire
   
    // Affichage de la dernière ligne SI ELLE EST INCOMPLETE

    si (RgFirstElem < taille (Tableau))
        declarer RgElem : entier_naturel;
        RgElem <- RgFirstElem;
        tant_que (RgElem < taille (Tableau) - 1)
        faire
            afficher (TableauRgElem, Separateur);
            RgElem <- RgElem + 1;
        ffaire

        // Affichage du dernier nombre de la dernière ligne

        afficher (TableauRgElem);
        ligne_suivante;
    fsi

fin

Remarque : pour simplifier l'écriture, on pourrait remplacer l'utilisation directe et répétée de taille (Tableau) par une variable intermédiaire,ou même une constante

Code:

declarer NbElem : constante entier_naturel <- taille (Tableau);

C) - Utilisation

Code:

algorithme Stocker_N_Entiers_Naturels
debut
   
// Lecture de N declarer N : entier_naturel; N <- SaisirEntierPositif ("Tapez un entier positif : ", "Vous avez fait une erreur");

   
declarer TabInt : tableau_de N entier_naturel; // Génération du tableau pour (i variant_de 0 a N - 1) faire TabInti <- i; ffaire

   
// Affichage du tableau declarer M : entier_naturel; M <- SaisirEntierPositif ( "Tapez le nombre d'éléments par ligne (entier positif) : ", "Vous avez fait une erreur"); declarer Separateur : caractere; afficher ("tapez le caractère séparateur"); saisir (Separateur); afficher ("Tableau d'entiers"); ligne_suivante; AffichTabInt (TabInt, M, Separateur);

fin

Rappels

1. Contrairement à l'algorithmique, la taille d'un tableau ne peut en général pas être connue dans un programme en C++. Il est donc nécessaire de passer en paramètres aux sous-programmes qui traitent des tableaux non seulement les tableaux eux-mêmes mais aussi leur nombre d'éléments.
   
   
2. La traduction du schéma itératif boucle ... fboucle de l'algorithmique en C++ peut être réalisée au moyen de l'instruction for ( ; ; ), selon le modèle suivant :
   
   
3. Attention à ne pas oublier l'inclusion du fichier <string>.
   

.

Corrigé

6) - Choix entre les exercices
Objectifs

• Mise en oeuvre d'un schéma de choix
  
  
• Utilisation d'un case multiple
  
  
• Utilisation d'un default dans l'instruction switch
  
  
• Utilisation de chaînes un peu étranges
  
  
• Lecture au clavier pour temporiser
  

Sujet

Une alternative à la mise en commentaires des appels des différents exercices dans la fonction main(), est de faire un petit menu présentant les différentes possibilités, par exemple :

Code:

A : Bonjour
B : Les dix premiers entiers naturels
C : Les 200 premiers entiers naturels à 10 par ligne
D : Les N  premiers entiers naturels
Q : Quitter

Votre choix (suivi de <entrée>) :

Le traitement consiste à :

1. afficher ce menu,
   
   
2. lire le choix de l'utilisateur,
   
   
3. afficher un message d'erreur si la commande est invalide,
   
   
4. effectuer le traitement approprié si le choix est valide (lettres 'A' à 'D') puis recommencer à 1,
   
   
5. terminer le programme pour le choix 'Q',
   
   
6. recommencer à 1 directement si le choix est invalide
   

L'algorithme de haut niveau ne se perd pas en détails de réalisation (saisie/affichage) mais fait apparaître les deux grandes étapes du traitement : saisir la commande puis la traiter :

Code:

...
boucle
    declarer Commande : caractere;
    Commande <- Afficher_menu_et_saisir_commande ();

    si (Commande vaut 'Q') sortie;

    Traiter_commande (Commande);

fboucle
...

Tout le travail demandé dans cet exercice consiste à compléter (rubriques ToDo) le fichier ChoixEntreExosBase.cxx mis à votre disposition, que vous devez télécharger dans votre répertoire de travail, et dont vous devez supprimer l'extension .a.

Dans ce fichier, vous disposez de deux fonctions qui peuvent vous être utiles :

1. ClearScreen() : comme son nom l'indique, lorsqu'elle est appelée, elle efface le contenu de l'écran (ou plutôt la fenêtre d'affichage) et positionne le curseur en haut à gauche.
   
   
2. Pause() : lorsque cette fonction est appelée, un message est affiché à l'écran trois lignes au-dessous de la position courante du curseur, et le programme est suspendu jusqu'à ce que vous ayez saisi au clavier et validé (touche <entrée>) un (et un seul !) caractère non espace.
   

Réflexions préliminaires : où placer la validation de la commande saisie ?

Lorsque l'utilisateur saisit une commande invalide (un 'X' par exemple), il est "de bon ton" de le lui signaler et de lui demander de saisir à nouveau la commande. Deux possibilités sont envisageables pour effectuer la validation :

• dans la fonction ChoixDansMenu(). Il est logique de penser que cette fonction ne renvoie que des commandes valides ('A', 'B', 'C', 'D', 'Q'). La fonction serait donc une boucle de saisie jusqu'à ce que la commande soit l'un de ces cinq caractères.
  
  
• dans la fonction TraiterCommande(). Puisque l'essentiel de cette fonction est un schéma de choix, le cas autre : (default : en C++) est parfaitement adapté à ce problème.
  

Puisque le schéma de choix de TraiterCommande() de la fonction TraiterCommande() suffit à la fois à vérifier la validité de la commande et à l'effectuer, nous choisirons cette seconde solution. La fonction ChoixDansMenu() se limite donc à l'affichage de l'invite et à la saisie de la commande, sans validation.

En cas d'ajout de nouvelle(s) commande(s), cette solution offre la meilleure extensibilité, puisqu'il suffit d'ajouter un ou plusieurs cas au schéma de choix (et de modifier l'invite, bien sûr), mais la fonction ChoixDansMenu() est inchangée.

Fonction ChoixDansMenu()

Après avoir mis à blanc l'écran, elle affiche la liste de choix (en haut de l'écran), attend la saisie de la commande qu'elle renvoie. Il est peut-être bon de remettre l'écran à blanc avant de sortir de la fonction.

Fonction TraiterCommande()

Elle appelle la fonction correspondant à la commande qui lui est passée en paramètre, ou affiche un message d'erreur en cas de commande invalide.

Fonction ChoixEntreExos()

Elle correspond à l'algorithme ci-dessus. Noter que, dès la sortie de la fonction TraiterCommande(), le contrôle remonte en début de l'itération suivante et la fonction ChoixDansMenu() est immédiatement appelée. Comme celle-ci commence par une remise à blanc de l'écran, il est probable que l'utilisateur n'a pas eu le temps de lire l'affichage du traitement précédent.

Pour éviter cela, il est préconisé de temporiser la remontée à l'itération suivante en appelant la fonction Pause().

Corrigé