FAQ C++ - Club d'entraide des développeurs francophones

Sommaire > Entrées / sorties avec les flux > Manipulation de la console
        Quelle est le différence entre #include <iostream.h> et #include <iostream> ?
        A quoi sert "using namespace std;" ?
        cout n'est pas reconnu à la compilation, que se passe-t-il ?
        Comment purger le buffer clavier ?
        Comment vérifier les valeurs saisies avec cin ?
        Comment faire une pause (attendre que l'utilisateur tape une touche) ?
        Est-il possible de simuler une saisie clavier ?

Quelle est le différence entre #include <iostream.h> et #include <iostream> ?

[haut]

auteurs : Anomaly, Aurelien.Regat-Barrel

Avant que le C++ ne soit normalisé, <iostream.h> était le seul fichier d'entête existant livré avec les compilateurs de l'époque. La normalisation ISO du C++ en 1998 a défini que <iostream> serait l'entête standard pour les entrées-sorties. L'absence de .h dans son nom indique qu'il s'agit désormais d'un entê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à (<iostream.h> n'est pas obsolète en soi 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'entête. <iostream.h> n'est donc encore présent que dans un but compatibilité.
Mais maintenant certains compilateurs comme Visual C++ 7.1 (2003) ne fournissent plus que l'entê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;

#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'entê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>

A quoi sert "using namespace std;" ?

[haut]

auteurs : Anomaly, Luc Hermitte, Aurelien.Regat-Barrel

Toute la bibliothèque standard C++ est définie dans son propre espace de noms, le namespace std. Ainsi, il faut systématiquement utiliser le préfixe std:: devant tous les éléments qui en sont issus.

#include <iostream>

int main()
    std::cout << "cout" << std::endl;
}

Pour alléger l'écriture, on utilise l'expression using namespace std; ce qui permet de s'affranchir de l'obligation de préfixer par std::. Le code précédent peut alors s'écrire ainsi :

#include <iostream>
using namespace std;

int main()
{
    cout << "coucou" << endl;
}

Il est conseillé de limiter l'utilisation de using namespace car cela fait tout simplement perdre l'utilité des namespaces. En particulier, son usage est à proscrire dans les fichiers d'entêtes, ainsi que des les cas où il génère des conflits avec d'autres namespaces. On peut pour cela restreindre la portée de la close using à un bloc en particulier :

#include <iostream>

void affiche_coucou()
{
    using namespace std;
    // dans tout le corps de la fonction préfixer par std:: est facultatif

    cout << "coucou" << endl;
}

int main()
{
    // ici il est obligatoire de préfixer par std::
    affiche_coucou();
    std::cout << "coucou" << std::endl;
}

Autre possibilité : importer un symbole du namespace et non le namespace tout entier :

#include <iostream>

using std::cout;
using std::endl;

int main()
{
    // si on veut utiliser cin par exemple, il faudra écrire std::cin
    cout << "coucou" << endl;
}

Pour plus d'informations, lire Qu'est-ce qu'un namespace ?.

cout n'est pas reconnu à la compilation, que se passe-t-il ?

[haut]

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;

Comment purger le buffer clavier ?

[haut]

auteurs : LFE, Loulou24

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<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.

Comment vérifier les valeurs saisies avec cin ?

[haut]

auteurs : Luc Hermitte, Aurelien.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.ignore( numeric_limits<streamsize>::max(), '\n' ); // supprimer la ligne erronée dans le buffer
cin.clear(); // effacer les bits d'erreurs

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() )
        { 
            // ^D  (^Z sous windows); Fin du flux d'entree!
            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; // succès
}

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

Comment faire une pause (attendre que l'utilisateur tape une touche) ?

[haut]

auteur : Aurelien.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' );
}

Est-il possible de simuler une saisie clavier ?

[haut]

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>

// simuler la saisie du mot 'Test';
std::cin.putback('T'); 
std::cin.putback('e'); 
std::cin.putback('s'); 
std::cin.putback('t');

Consultez les autres F.A.Q's

Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduit en français ici.
Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement.
Certaines parties de ce document sont sous copyright Marshall Cline Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à trois licences, en fonction des contributeurs :
- Les contributions de Clément Cunin et LFE sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin et LFE tant que cette note apparaît clairement :
"Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement".
- Les contributions de Marshall Cline sont sous copyright
- Pour ce qui est des autres contributions : Copyright © 2005 Developpez LLC : Tous droits réservés Developpez LLC. Aucune reproduction, ne peut en être faite sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.