TP programmation C++ - SMP S4

TP1 (suite)

A- Namespace
Les noms des éléments de la bibliothèque iostream en rapport avec les entrées sortie sont
toujours précédées de std::
Pour ne pas avoir à répéter à chaque fois ce préfixe on peut demander au compilateur de
l’ajouter automatiquement grâce à l’instruction : using namespace std ;

Exemple d’usage :
#include<iostream>
using namespace std;
int main()
{
/**
std::cout << "Hello, World !"<< std::endl ;
s'ecrit
*/
cout << "Hello, World !"<< endl ;
return (0);
}

B- Contrôle de l’affichage avec les manipulateurs

1- Les bases 10, 8 et 16
Avant de commencer, utiliser la calculatrice (Windows) pour avoir les conversions d’un
nombre entier donné. Par exemple 57 :
57(base 10) → 71 (base 8) → 39 (base 16)
C++ adopte une convention d’écriture des constantes littérales (nombres) :
 L’écriture ordinaire : 57 signifie que la base de ce nombre est la base 10
 Si on ajoute un 0 (zéro) devant un nombre, cela signifie que le nombre est écrit en base
8 (octal). Exemple : 0234 si on le convertit en décimal, ça donne 156 [calculatrice]
 Si on ajoute 0x (zéro suivi de la lettre x) devant un nombre, cela signifie que le nombre
est écrit en base 16 (hexadécimal). Exemple : 0x95 convertit en décimal ça donnerait 149
[calculatrice]

2- La classe iomanip
Inclure la classe iomanip
Elle contient les manipulateurs dec, hex, oct, setbase( ), showbase( )
Ils permettent de contrôler certains aspects de l’affichage.

a) Dec, hex, oct

 Convertir en hexadécimal un nombre écrit en décimal : cout << hex << 57 ; affiche 39
 Convertir en octal un nombre écrit en décimal : cout << oct << 57 ; affiche 71
 Convertir en décimal un nombre écrit en décimal : cout << dec << 57 ; affiche 57
 Etc.
Si on ne précise pas dans quelle base les affichages sont faits, le compilateur travaille par défaut
dans le système décimal.
Une fois que la base est changée, par oct ou hex, elle est conservée jusqu’au prochain
changement.

b) Setbase( )
setbase(10) produit le même effet que dec.
setbase(16) produit le même effet que hex.
setbase(8) produit le même effet que oct.

c) Showbase
Ce manipulateur permet d’afficher les nombres avec sa convention de représentation :
 un nombre hexadécimal est précédé de 0x.
 un nombre octal est précédé de 0.
 un nombre décimal commence par un chiffre différent de 0.

Exemple
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
// le nombre 57 (base 10) = 71(base 8) = 39(base 16) [calculatrice]
cout << "defaut base 10 :" << 57 << endl; // decimal par defaut
cout << "en base 10 :" << dec << 57 << endl; // decimal, specifié
cout << "en base 8 :" << oct << 57 << endl; // octal
cout << "en base 16 :" << hex << 57 << endl; // hexadecimal
cout << "defaut base 16 :" << 57 << endl; // hexadecimal devenu defaut

/** convention écriture octal et hexa **/

cout << setbase(10) << endl; // Repasse en base 10
 cout << 071 << endl; // 071 (octal) affiche en decimal (57)
cout << 0x39 << endl;// 0x39 (hexadecimal) affiche en decimal (57)

/** Montrer la base **/

cout << endl << "Montrer la base : " << endl;
cout << showbase;
cout << dec << 57 << endl;
cout << oct << 57 << endl;
cout << hex << 57 << endl;
}

d) Setw( ) et setfill
setw est un manipulateur qui permet de contrôler la largeur de l’affichage.
Ainsi dans la ligne suivante l’affichage sera fait sur 10 places de caractères.
cout << setw(10) << 735 << endl;
On obtient le résultat suivant :

setfill est un manipulateur qui va permettre de remplir les espaces blancs avec un caractere
choisi. Si on écrit :
cout << setw(10) << setfill(‘*’) << 735;
on obtient :

e) Left et right
Les deux manipulateurs permettent la justification gauche et droite respectivement. Par défaut
la justification est droite.
Voici un exemple d’usage.
cout << left << setw(15) << setfill('*') << 3.151592;

Exemple complet
/*
setw()
setfill()
left
right
*/
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
cout << "12345678901234567890 compteur de caracteres" << endl;
///affichage par defaut
cout << 735 << endl;
///setw : affihage avec largeur egale a 10 places
cout << setw(10) << 735 << endl;
///setfill : affichage avec remplissage avec caractere *
cout << setfill('*') << setw(10) << 735 << endl;
cout << setw(10) << setfill('*') << 735 << endl; ///ordre indifferent
///left et right
cout << left << setw(15) << setfill('*') << 3.151592 << endl;
cout << right << setw(15) << 3.151592 << endl;///correspond au defaut
return (0);
}

f) Setprecision
Elle permet de préciser le nombre de chiffres dans l’affichage, virgule non comprise. C’est en
fait le nombre maximal de chiffres dans la mantisse du nombre. Elle prend comme argument
un nombre entier n, comme dans cette écriture : setprecision(n)

Exemple
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
cout << "123456789012345678901234567890 Compteur" << endl;
long double pi = 3.1415926535897932384626433832795; //copie de Window calculator
cout << pi << " Defaut precision (6): " << endl;
// affiche 6 chiffres(mantisse) 3.14159
///action de setprecision
cout << setprecision(10) << pi << endl;
// 3.141592654 et arrondi sur le dernier
 return (0);
}

g) scientific
Ce manipulateur permet de passer en notation scientifique. Par exemple 0.001234 s’écrirait
1.234e-03
cout << scientific << 0.001234 << endl;
affiche : 1.234000e-003

h) Fixed
Ce manipulateur permet de passer en notation de virgule flottante (floating-point). Par
exemple 1.234e-03 s’erirait 0.001234
cout << fixed << 0.001234e-3 << endl;
affiche : 0.001234

Exercice:
On veut vérifier qu’il y a débordement sur le type int quand on fait des opérations avec des
valeurs au-delà des limites permises.
1) Inclure la bibliothèque limits.
2) Afficher les limites permises pour le type int. On peut extraire ces valeurs grâce
aux grandeurs : numeric_limits<int>::max( ) et numeric_limits<int>::min( )
3) Déclarer une variable A de type int et lui assigner la valeur maximale permise par ce
type. Afficher A+ 1, et Conclure.
5) Assigner à A la valeur minimale permise par le type int . Afficher A-1, et conclure.