| | auteurs : Anomaly, Aurélien Regat-Barrel |
Avant que le C++ ne soit normalisé, <iostream.h> était le seul fichier d'en-tête existant livré avec les compilateurs de l'époque.
La normalisation ISO du C++ en 1998 a défini que <iostream> serait l'en-tête standard pour les entrées-sorties.
L'absence de .h dans son nom indique qu'il s'agit désormais d'un en-tête standard, et donc que toutes ses définitions font partie de l'espace de nommage standard std. Inclure <iostream.h> est donc obsolète depuis ce temps là
(techniquement parlant, <iostream.h> n'est pas obsolète car il n'a jamais fait partie du standard, mais son utilisation l'est).
Pour laisser le temps aux programmeurs de modifier leur code, les compilateurs ont fourni chacun de ces fichiers d'en-tête.
<iostream.h> n'est donc encore présent que dans un but de compatibilité.
Mais maintenant certains compilateurs comme Visual C++ 7.1 (2003) ne fournissent plus que l'en-tête standard <iostream> et presque tous les autres émettent au moins un avertissement comme quoi utiliser <iostream.h> est obsolète. En le faisant, la portabilité et la compatibilité future de votre code sont menacées.
Voilà pourquoi il faut remplacer toute inclusion de <iostream.h>
#include <iostream.h>
cout << "coucou" << endl;
|
par <iostream> et une utilisation du namespace std
#include <iostream>
using namespace std;
cout << "coucou" << endl;
|
ou #include <iostream>
std::cout << "coucou" << std::endl;
|
ou encore #include <iostream>
using std::cout;
using std::endl;
cout << "coucou" << endl;
|
Il est en de même avec tous les fichiers d'en-tête standards en C++, y compris avec ceux de la bibliothèque standard C.
Pour des raisons d'uniformisation, il faut désormais les inclure sans le .h et en préfixant leur nom par la lettre c (pour souligner le fait qu'ils sont issus du C).
Par exemple
#include <stdlib.h>
#include <stdio.h>
|
devient #include <cstdlib>
#include <cstdio>
|
|
| | auteur : LFE |
cin, cout, ... sont des objets standards. Ils doivent être déclarés et utilisés de la façon suivante :
#include <iostream>
std::cout << "Test cout" << std::endl;
|
ou alors
#include <iostream>
using namespace std;
cout << "Test cout" << endl;
|
|
| | auteurs : LFE, Laurent Gomila |
Pour supprimer une ligne saisie par l'utilisateur qui se trouve dans le buffer d'entrée, il faut utiliser ignore().
#include <iostream>
#include <limits>
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );
|
Le code précédent demande d'ignorer le maximum de caractères différents de '\n' possibles. Ce maximum possible est obtenu grâce à numeric_limits.
|
| | auteurs : Luc Hermitte, Aurélien Regat-Barrel |
L'opérateur >> utilisé pour la saisie permet de vérifier la validité de celle-ci via le test suivant :
| Exemple incorrecte de vérification de saisie | #include <iostream>
int main()
{
using namespace std;
cout << "Entrez un nombre : ";
int nombre;
while ( ! ( cin >> nombre ) )
{
cerr << "Erreur de saisie.\n";
}
cout << "Le nombre entré est " << nombre << ".\n";
}
|
Pour savoir comment ce test fonctionne, lisez Comment fonctionne le test de réussite de conversion if ( str >> num ) ?.
Si vous testez cet exemple en entrant un mot au lieu d'un nombre le programme entrera dans une boucle infinie affichant Erreur de saisie..
En effet, après une erreur de saisie, le flux d'entrée cin se retrouve dans un état invalide, et la chaîne invalide qui a provoqué l'erreur est toujours dans le buffer puisque son extraction a échoué.
Ainsi la tentative suivante échoue à nouveau, ce qui provoque une boucle infinie dans l'exemple précédent.
Il faut donc supprimer la ligne invalide du buffer et restaurer l'objet cin dans un état valide. Ceci est fait grâce aux deux lignes suivantes :
cin.clear();
cin.ignore( numeric_limits<streamsize>::max(), '\n' );
|
Le code suivant corrige le précédent problème, et effectue différents tests en cas d'erreur afin d'identifier l'origine de l'échec :
#include <iostream>
#include <limits>
using namespace std;
bool read_choice( int & N )
{
cout << "Entrez un chiffre entre 1 et 6 : " ;
while ( ! ( cin >> N ) || N < 1 || N > 6 )
{
if ( cin.eof() )
{
return false;
}
else if ( cin.fail() )
{
cout << "Saisie incorrecte, recommencez : ";
cin.clear();
cin.ignore( numeric_limits<streamsize>::max(), '\n' );
}
else
{
cout << "Le chiffre n'est pas entre 1 et 6, recommencez : ";
}
}
return true;
}
int main ()
{
int choix;
if ( read_choice( choix ) )
{
cout << "Vous avez choisi : " << choix << '\n';
}
return 0;
}
|
Le résultat produit est le suivant : Entrez un chiffre entre 1 et 6 : abcdef
Saisie incorrecte, recommencez : -3
Le chiffre n'est pas entre 1 et 6, recommencez : 17
Le chiffre n'est pas entre 1 et 6, recommencez : 5
Vous avez choisi : 5
|
|
lien : Message de James Kanze sur fr.comp.lang.c++ ayant inspiré cette solution
|
| | auteur : Aurélien Regat-Barrel |
Il n'y a pas de moyen en C++ standard pour attendre que l'utilisateur tape sur n'importe quelle touche. Ce dernier doit en effet terminer sa saisie par un retour chariot (touche entrée). On peut donc faire une pause dans son programme en invitant l'utilisateur à appuyer sur la touche entrée et en ignorant sa saisie en purgeant le buffer clavier.
#include <iostream>
#include <limits>
using namespace std;
int main()
{
cout << "Appuyez sur entrée pour continuer...";
cin.ignore( numeric_limits<streamsize>::max(), '\n' );
}
|
|
| | auteur : LFE |
La fonction putback du flux std::cin permet cela. Le caractère passé en paramètre de cette fonction est ajouté à la fin du flux, comme si
l'utilisateur l'avait tapé au clavier.
#include <iostream>
std::cin.putback('T');
std::cin.putback('e');
std::cin.putback('s');
std::cin.putback('t');
|
|
Consultez les autres F.A.Q.
 
|
|
Les sources présentées sur cette page sont libres de droits
et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation
constitue une œuvre intellectuelle protégée par les droits d'auteur.
Copyright © 2008 Developpez LLC.
Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne
peut être faite de ce site ni de l'ensemble de son contenu : textes, documents
et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez
selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
