Partie 1 :

Ecrire le corps de la fonction affichVInt () de signature :


void affichVInt (const vector <int> & VInt);


A l’aide d’itérateurs.
Ecrire le corps de la fonction affichVector () de signature :


template <typename T>
void affichVector (const vector <T> & V);


A l’aide d’itérateurs.

Partie 2 :

Reprenez le corps de la fonction de Tri par Sélection / Echange (cf Prog#9, exercice 1), modifier le corps de façon à n’utiliser que des itérateurs.

NB: vous pouvez utiliser la fonction min_element () de la STL.

Télécharger le corrigé du TP 6 (M1102) : ici.

1. Dans le fichier nsUtil.cxx, modifier le corps de la fonction EditVString () de façon à n’utiliser que des itérateurs;
2. Dans le fichier main.cxx, modifier le corps des fonctions Delete (), Insert () et Swap () de façon à n’utiliser que des itérateurs.

Nb: pour les fonctions Insert () et Delete (), vous devez vous appuyer sur les fonctions insert () et erase () de la classe vector.

Ecrire la fonction flux_cin() qui, dans une boucle, lit une ligne au clavier et l’affiche à l’écran. La boucle se termine lorsque l’utilisateur tape le caractère “fin du fichier” au clavier (Ctrl + D). Pour cela, utiliser la fonction-membre (méthode) eof() de la classe istream à laquelle appartient le flux standard cin.

Attention : le prédicat eof() n’est vrai qu’après qu’une tentative de lecture a échoué. Il faut donc toujours faire une tentative de lecture avant de tester par eof() si elle a échoué ou non.

Dans votre répertoire courant, téléchargez le fichier LaFontaine.txt mis à votre disposition.

Ecrire la fonction afichFich() qui, dans une boucle, lit le fichier source LaFontaine.txt ligne par ligne et l’affiche à l’écran. La boucle se termine à la rencontre de la marque “fin-de-fichier”. Le fichier est associé à un flux d’entrée de la classe ifstream.

Un programme est beaucoup plus général s’il est capable de traiter n’importe quel fichier (texte par exemple), dont le nom est saisi lors de l’exécution, plutôt qu’un fichier particulier dont le nom est indiqué en dur dans le code. Il en est de même s’il doit créer un fichier résultat.

Ecrire la fonction nomFichAuClavier() qui :

1. saisit au clavier le nom du fichier source (un string),
2. saisit au clavier le nom du fichier destination (un autre string),
3. dans une boucle, lit le fichier source ligne par ligne et le recopie dans le fichier destination en numérotant “proprement” chaque ligne à partir de 1 : le numéro de chaque ligne doit précéder chaque ligne et être aligné à droite sur 4 colonnes,
4. affiche le nombre total de lignes du fichier.

La tester sur des noms de fichiers valides (en particulier, s’assurer que le fichier source existe bien).

Dans la pratique, il est indispensable de vérifier qu’un fichier a bien été associé à un flux et ouvert avant de tenter d’y lire ou d’y écrire.

Ecrire la fonction validFichier() qui :

1. saisit au clavier le nom du fichier source (un string). Placer cette saisie dans une boucle, jusqu’à ce que l’ouverture en lecture soit valide ou que trois essais infructueux aient été tentés.
2. En cas d’erreurs répétées, terminer le programme après avoir affiché dans le flux de sortie standard le message suivant :

   3 echecs d'ouverture de fichier en lecture

3. saisit au clavier le nom du fichier destination, en effectuant la même validation d’ouverture en écriture que sur le fichier source, et en affichant éventuellement le message :

   3 echecs d'ouverture de fichier en ecriture

4. dans une boucle, lit le fichier source ligne par ligne et le recopie dans le fichier destination.

Remarque : pour pouvoir tester la validation du fichier destination, vous devez créer le fichier et le protéger en écriture avant de lancer le programme.

Il est possible de ne considérer les flux que comme des suites de caractères quelconques, sans distinction entre les caractères éditables ou non, et les caractères d’espacement.

La fonction get(), membre de la classe ifstream, que nous vous proposons d’utiliser ici, extrait et renvoie le prochain caractère du flux quel qu’il soit (la classe ifstream propose trois autres versions de cette fonction, que nous vous laissons découvrir).

Ecrire la fonction fonctionGet() qui, dans une boucle, lit un fichier (dont le nom est saisi au clavier) caractère par caractère et l’affiche à l’écran. La boucle se termine à la rencontre du caractère “fin du fichier”.

Dans un fichier texte (= dans un flux), un mot est une suite de caractères sans caractère d’espacement (espace, tabulation, passage à la ligne suivante ‘\n’).

Ecrire la fonction ExtractionsMots() qui, dans une boucle, extrait (opérateur >>) au clavier (ou sur un fichier redirigé sur l’entrée standard cin) tous les mots et les affiche à l’écran à raison d’un par ligne. La boucle se termine lorsque l’extraction échoue (fail()).

Faire plusieurs essais, en saisissant un mot par ligne, plusieurs mots sur la même ligne, en utilisant les tabulations, en saisissant des lignes vierges ou seulement composées de caractères d’espacement.

Vous devez constater que :

1. n’importe quel caractère (sauf espacement) peut être considéré comme un mot (un ‘.’ seul par exemple),
2. tous les caractères d’espacement avant un mot sont ignorés,
3. la seule façon de terminer le programme est de taper le caractère “fin-de-fichier” (Ctrl+D). La condition d’arrêt peut donc aussi utiliser le prédicat eof()

Ecrire la fonction extractionsCars() qui, dans une boucle, extrait (opérateur >>) au clavier (ou sur un fichier redirigé sur l’entrée standard cin) tous les caractères et les affiche à l’écran à raison d’un par ligne. La boucle se termine lorsque l’extraction échoue (fail()).

Faire plusieurs essais, en saisissant un ou plusieurs caractères par ligne, séparés ou non par des caractères d’espacement, en saisissant des lignes vierges ou seulement composées de caractères d’espacement.

Vous devez constater que :

1. n’importe quel caractère éditable (sauf espacement) est extrait,
2. tous les caractères d’espacement sont ignorés,
3. la seule façon de terminer le programme est de taper le caractère “fin-de-fichier” (Ctrl+D). La condition d’arrêt peut donc aussi utiliser le prédicat eof() .

Un entier est une suite de caractères numériques (digits) éventuellement précédé d’un signe + ou -. Pour qu’un entier soit valide, il faut que la chaîne de caractères qui le représente soit compatible avec son type :

1. un entier non signé ne peut être précédé du signe -,
2. la valeur de la chaîne ne peut excéder la valeur maximale du type correspondant (32767 pour un short, 65535 pour un unsigned, etc.

Ecrire la fonction extractionsEntiers() qui, dans une boucle, extrait (opérateur >>) au clavier (ou sur un fichier redirigé sur l’entrée standard cin) tous les entiers et les affiche à l’écran à raison d’un par ligne. La boucle se termine lorsque l’extraction échoue (fail()).

Faire plusieurs essais, en saisissant un ou plusieurs entiers par ligne, séparés ou non par des caractères d’espacement, en saisissant des lignes vierges ou seulement composées de caractères d’espacement.

Vous devez constater que :

1. n’importe quel entier valide est extrait,
2. tous les caractères d’espacement sont ignorés,
3. le programme se termine au premier échec d’extraction. Le caractère “fin-de-fichier” (Ctrl+D) permet aussi de terminer la saisie. La condition d’arrêt ne doit pas utiliser le prédicat eof(), sauf si aucune erreur de saisie n’est à craindre (ce qui est plutôt rare !)