FAQ C++Consultez toutes les FAQ

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>

1
2
3
#include <iostream.h>  
  
cout << "coucou" << endl;

1
2
3
4
#include <iostream>  
using namespace std; 
  
cout << "coucou" << endl;

1
2
3
#include <iostream>  
  
std::cout << "coucou" << std::endl;

1
2
3
4
5
#include <iostream>  
using std::cout; 
using std::endl; 
  
cout << "coucou" << endl;

1
2
#include <stdlib.h> 
#include <stdio.h>

1
2
#include <cstdlib> 
#include <cstdio>

cin, cout. sont des objets standards. Ils doivent �tre d�clar�s et utilis�s de la fa�on suivante :

1
2
3
#include <iostream> 
  
std::cout << "Test cout" << std::endl;

1
2
3
4
#include <iostream> 
using namespace std; 
  
cout << "Test cout" << endl;

L'op�rateur >> de saisie d'une string permet de saisir des mots et donc consid�re les espaces comme des s�parateurs.
Pour saisir une cha�ne enti�re contenant des espaces, il faut r�cup�rer l'int�gralit� de la ligne au moyen de la fonction libre std::getline() d�finie dans <string> (et non pas avec la fonction membre cin.getline() qui op�re sur des char *).

1
2
std::string chaine;  
std::getline( std::cin, chaine );

Si vous constatez ce probl�me, il est fort probable que vous veniez d'appeler std::getline(std::cin) juste apr�s une lecture sur le flux avec l'op�rateur d'extraction�: std::cin >> (c'est parfaitement valable avec les flux fichiers �galement).

Ce que vous observez est normal. L'op�rateur d'extraction (operator>>) consomme ce qui vient sur le flux, mais il s'arr�te juste avant le premier espace blanc ou saut de ligne -- voire encore avant selon le type de la donn�e � extraire et de ce qui se trouve v�ritablement sur le flux (ex�: l'extraction d'un int depuis "125douze").

De ce fait, operator >> va s'arr�ter avant le saut de ligne, et quand std::getline va vouloir extraire la ligne qui suit, en fait il va r�cup�rer les caract�res entre la position courante et la fin de la ligne avant de passer � la ligne suivante. Dans le cas d'une interaction avec l'utilisateur, une chaine vide sera obtenue, et le flux sera positionn� � la ligne suivante. C'est pour cela qu'un double appel � std::getline fonctionne.

� - Donc si je comprends bien il faut appeler deux fois std::getline ? �
Seulement si vous voulez r�cup�rer les miettes qui trainent apr�s la derni�re chose lue avec >>.
En pratique, on a le choix entre�:

• un simple std::cin.get() qui marchera uniquement si ce qui suit est un saut de ligne�;
• std::cin >> std::ws qui consommera les blancs et les sauts de lignes (c'est faire ce qui est fait de mani�re implicite par la plupart des operator>>) ;
• ou purger le buffer clavier (cf. entr�e correspondante�: Comment purger le buffer clavier ?) qui fonctionnera �galement si des miettes trainent et que l'on pr�f�re les ignorer.
  

Pour supprimer une ligne saisie par l'utilisateur qui se trouve dans le buffer d'entr�e, il faut utiliser ignore().

1
2
3
4
#include <iostream>  
#include <limits>  
  
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );

L'op�rateur >> utilis� pour la saisie permet de v�rifier la validit� de celle-ci via le test suivant :

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream> 
  
int main() 
{ 
  
    std::cout << "Entrez un nombre : "; 
    int nombre; 
    while ( ! ( std::cin >> nombre ) ) 
    { 
        std::cerr << "Erreur de saisie.\n"; 
    } 
    std::cout << "Le nombre entr� est " << nombre << ".\n"; 
}

1
2
std::cin.clear(); // effacer les bits d'erreurs 
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' ); // supprimer la ligne erron�e dans le buffer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <iostream>  
#include <limits> 
  
bool read_choice( int & N ) 
{ 
    std::cout << "Entrez un chiffre entre 1 et 6 : " ;  
    while ( ! ( std::cin >> N ) || N < 1 || N > 6 ) 
    {  
        if ( std::cin.eof() ) 
        {  
            // ^D  (^Z sous windows); Fin du flux d'entree ! 
            return false;  
        } 
        else if ( std::cin.fail() ) 
        {  
            std::cout << "Saisie incorrecte, recommencez : ";  
            std::cin.clear();  
            std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' ); 
        } 
        else 
        { 
            std::cout << "Le chiffre n'est pas entre 1 et 6, recommencez : "; 
        } 
    } 
    return true; // succ�s 
} 
  
int main ()  
{  
    int choix; 
    if ( read_choice( choix ) ) 
    { 
        std::cout << "Vous avez choisi : " << choix << '\n'; 
    } 
  
    return 0;  
}

1
2
3
4
5
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

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.

1
2
3
4
5
6
7
#include <iostream> 
  
// simuler la saisie du mot 'Test'; 
std::cin.putback('T');  
std::cin.putback('e');  
std::cin.putback('s');  
std::cin.putback('t');

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.

1
2
3
4
5
6
7
8
#include <iostream>  
#include <limits>  
  
int main() 
{ 
    std::cout << "Appuyez sur entr�e pour continuer..."; 
    std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' ); 
}