Eric Galin

TPC

TP 1 Boucles et tests

std::cin

std::cout

iostream

Écrire un programme qui demande à l'utilisateur d'entrer un entier au clavier et qui affiche le carré et le cube de cet entier.
entrez un entier : 5
Le carre de 5 est : 25
Le cube de 5 est : 125
Écrire un programme qui lit un entier au clavier et qui affiche un message indiquant si cet entier est pair ou impair, exemple d'utilisation :
entrez un entier : 43
l'entier 43 est impair
Écrire un programme qui lit deux entiers au clavier et qui affiche le plus grand des deux, exemple d'utilisation :
entrez deux entiers : 5 2
la plus grande valeur est 5
Écrire un programme qui demande à l'utilisateur d'entrer un entier n et affiche n fois la chaine de caractère "Bonjour", exemple :
entrez un entier : 3
Bonjour 1 fois Bonjour 2 fois Bonjour 3 fois
Écrire un programme qui calcule la factorielle (algorithme itératif) d'un entier entré au clavier :
entrez un entier : 6
La factorielle de 6 est : 720
Écrire un programme qui demande à l'utilisateur d'entrer un entier au clavier tant que celui-ci est positif et qui affiche Fin lorsque le programme est terminé. Exemple :
entrez un entier : 5
entrez un entier : 15
entrez un entier : 8
entrez un entier : -25
Fin
Écrire un programme qui calcule et affiche les n premiers termes de la suite de Fibonnacci, n sera saisi par l'utilisateur.
U1=1, U2=1, Un = Un-2 + Un-1
Exemple d'utilisation :
entrez un entier : 8
1 1 2 3 5 8 13 21
Écrire un programme qui effectue la division euclidienne de deux entiers. En entrée le programme demandera la saisie de deux entiers a et b et en sortie il affichera le quotient et le reste de la division entière de a/b. Ne pas utiliser l'opérateur % du langage C. Faites cet exercice en n'utilisant que les opérateurs + et -.
Écrire un programme qui affiche la table de multiplication jusqu'à 10 d'un entier lu aus clavier, exemple d'utilisation :
entrez un entier : 5
0 5 10 15 20 25 30 35 40 45 50
Écrire un programme qui effectue la saisie d'un entier n et qui affiche la somme des n premières puissances de 2 (sans utiliser la bibliothèque mathématique).
i.e : s = 1 + 2 + 4 + 8 + 16 + .... + 2^n

TP 2 Procédures et fonctions

procedure.cpp

Écrire une procédure qui réalise l'échange du contenu de deux variables.
int a=3, b=2; Permute(a,b); // Donne a=2 et b=3
Écrire une procédure Ligne qui affiche une ligne de n caractères * dans lequel le nombre de caractères sera passé par paramètre.
Ligne(5); // Donne *****
Modifier la procédure Ligne pour afficher une ligne de n caractères, le nombre de caractères et le caractère seront les paramètres
Écrire une procédure Rectangle qui affiche à le un rectangle, le caratère, la largeur et la hauteur seront 3 valeurs saisies par l'utilisateur, par exemple :
Rectangle(5,3,'#');
#####
#####
#####
Écrire une fonction qui teste si un entier est premier
Afficher tous les nombres premiers inférieurs à 100.
Écrire une fonction qui teste si un entier est parfait (un nombre parfait est un entier qui est égale à la somme de ses diviseurs, n exclus).
Exemple : 6 est parfait car 6 = 1 + 2 + 3

Afficher tous les nombres parfaits inférieurs à 1000.
Écrire une fonction (non récursive et sans utiliser de tableau) ) qui retourne le nème terme de la suite de Syracuse : \(S_0\) sera initialisée par l'utilisateur (valeur entière), et \(S_n = \frac{S_{n-1}}{2}\) si \(S_{n-1}\) est pair, \(S_n = 1 + 3S_{n-1} \) sinon

Dans cette fonction, n et S(0) seront des paramètres de la fonction
Ensuite écrire une fonction qui affiche les n premiers termes de cette suite (n et S(0) seront de paramètres de cette fonction)
Exemple, si S(0)=10 et n=12, cette dernière fonction devra afficher :
10 5 16 8 4 2 1 4 2 1 4 2
Écrire une fonction qui retourne la racine carrée d'un nombre en utilisant l'algorithme suivant : soit a est le nombre dont on veut extraire la racine carrée.
La racine carrée de ce nombre est obtenue en calculant la limite de la suite : \[x_{n+1} = \frac{x_n + a/x_n}{2} \qquad x_0=a\]
Pour arrêter la récurrene, on peut se fixer le nombre d'itérations à effectuer ou bien s'arrêter quand le résultat est proche de la solution. Testez les deux.
Écrire une fonction qui retourne la racine carrée d'un nombre positif passé en paramètre de fonction en utilisant la dichotomie.
A est le nombre dont on veut extraire la racine carrée.
On se donne un intervalle dans lequel on est sur de trouver le résultat, exemple [0 A].
On teste si la valeur intermédiaire de cet intervalle, A/2, est plus petite ou plus grande que le résultat recherché.
S'il est plus petit, on réitère sur l'intervalle [1 A/2], s'il est plus grand sur l'intervalle [A/2 A].
Modifiez l'algorithme afin qu'il fonctionne aussi pour les valeurs comprises entre 0 et 1.
Écrire une fonction qui retourne un nombre aléatoire compris entre deux entiers a et b, a < b (utiliser la fonction rand()).

accessible ici

TP 3 Tableaux

On utilisera un seul fichier tableau.cpp pour rassembler toutes les procédures et les appels de test. Les tableaux seront définis à comme des vecteurs de taille variable de type std::vector .

Écrire une fonction qui réalise la saisie au clavier d'un tableau de float.
Écrire une fonction qui affiche le contenu du tableau.
Écrire une fonction qui renverse le contenu du tableau.
Écrire une fonction qui retourne la somme des éléments du tableau.
Écrire une fonction qui retourne la moyenne des éléments du tableau. Compléter avec une fonction Ecart qui calcul l'écart type.
Écrire une fonction Identique qui passe en paramètre 2 tableaux d'entiers de dimension n et qui retourne la valeur true si les 2 tableaux sont identiques (i.e. meme valeur à la meme position), false sinon.
Écrire une fonction qui trie dans l'ordre croissant un tableau d'entier passé en paramètre en utilisant l'algorithme du tri par bulle (utilisez la fonction permutation de deux entiers du TP2.1).
Écrire une fonction Alea qui initialise un tableau de n entiers avec des valeurs aléatoires entre 2 bornes a et b (n, a et b seront des paramètres de la fonction)
Ecrivez une fonction qui teste si un tableau d'entier est trié dans l'ordre croissant.
Cette fonction est indispensable pour tester les fonctions de tri, en effet, il n'est pas pensable, dans la suite du tp, d'afficher un tableau de plusieurs dizaines de milliers d'éléments pour vérifier si le tri s'est bien déroulé !
Dans le programme principal : tester chacune des fonctions précédentes sur des tableaux de petite dimension, par exemple int T[]={12,1,65,12,876,0,13,87,-14} ;
Initialiser un tableau de 100 000 entiers compris entre -100 000 et +100 000 avec la fonction Alea. Trier ce grand tableau avec la fonction de tri et tester si ce tableau a ete trie correctement.

accessible ici

TP 4 Chaines de caractères

On utilisera un seul fichier chaine.cpp pour rassembler toutes les procédures et les appels de test. On utilisera le type std::string.

Écrire une fonction qui renvoie la valeur true si une chaine passée en paramètre est un palindrome, false sinon.
Écrire une fonction qui transforme en majuscule tous les caractères minuscules d'une chaine de caractères.
Écrire une fonction qui renvoie la valeur true si cette chaine est exclusivement composée de caractères de l'alphabet, false sinon.
Re-coder une fonction qui analyse deux chaines de caractères composées exclusivement de lettres de l'alphabet et renvoie la valeur -1 si la première est située avant la deuxième dans l'ordre alphabétique, 0 si elles sont égales, 1 si la première est située après la deuxième.
Note: cette fonction existe dans la classe std::string sous la forme d'une surcharge des opérateurs de comparaison.
Écrire une fonction Conversion qui reçoit en paramètre une chaine de caractères composée uniquement des caractères 0 1 2 3 4 5 6 7 8 9 et qui retourne l'entier correspondant : Conversion("23582"); renverra l'entier 23582.
Écrire une fonction qui passe en paramètre d'entrée un tableau de caractères de dimension n et en sortie un tableau d'entiers qui comptabilise le nombre d'occurrence de chacun des caractères (en majuscule ou minuscule) du premier tableau. Exemple :
std::string a = "Bonjour"; std::vector n; Compte(A,n); // Le vecteur n devrait contenir {0,1,0,0,0,0,0,0,0,1,0,0,0,1,2,0,0,1,0,0,1,0,0,0,0,0}

TP 5 Structures

.hpp

.cpp

exe.cpp

Définir dans un fichier rationnel.h une structure Rationnel avec deux entiers représentant le numérateur et le dénominateur.
Écrire une fonction d'affichage, on traitera les cas particuliers: 0/4 devra afficher 0, 5/1 devra afficher 5.
Écrire les fonctions d'addition, de soustraction, de multiplication de nombres rationnels.
Écrire une procédure Inverse inversant la fraction.
Écrire une procédure transformant le rationnel en une forme irréductible. On rappelle la fonction récursive de calcul du PGCD :
int pgcd(int a,int b) { int r = 1; while(r != 0) { r = a%b; if(r == 0) { return b; } else { a = b; b = r; } } return r; } Appeler cette fonction dans les fonctions de multiplication, d'addition, de soustraction pour simplifier les fractions résultats avant de les retourner.
Ecire le fichier Makefile pour compiler le programme à partir des sources exe.cpp, rationnel.h et rationnel.cpp.
Dans un fichier exe.cpp, include l'en-tête rationnel.h et tester les fonctions précédentes en calculant par exemple la somme 1/2+1/3, puis son produit avec 6/7, en affichant le résultat, puis en simplifiant la fraction sous forme irréductible, et en affichant à nouveau le résultat.

TP 6 Classes

Transformer la structure Rationnel en une classe avec les champes protégés, et les constructeurs publiques : écrire un constructeur vide, et un constructeur avec paramètres ; on devra pouvoir écrire :
Rationnel a(2,3), b; // a représente 2/3 et b initialisé à 0/1.
Écrire des fonctions membre d'affichage, d'addition, de soustraction, de multiplication de nombres rationnels.
Écrire une procédure Inverse inversant un nombre rationnel.
Surcharger les opérateurs d'addition, de soustraction, de multiplication de nombres rationnels, et l'opérateur de flot ; on devra pouvoir écrire :
Rationnel c = a + b * 2.0; std::cout << c << std::endl; // Calcul et affichage.

TP 7 Classes et documentation

On utilisera un fichier .hpp pour déclarer les nouvelles classes et les déclarations de fonctions, un fichier .cpp pour le code du corps des fonctions. Le programme principal sera codé dans exe.cpp.
La documentation devra être codée au format doxygen et générée à l'aide de la commande doxygen -g code.oxy pour générer le fichier de configuration, puis doxygen code.oxy pour générer la documentation.

Définir une classe Entier permettant de représenter de très grands nombres entiers sous leur forme décimale, à l'aide d'un tableau de chiffres codés sur des caractères (prendre par exemple 60 chiffres).
Ecrire un constrcteur définissant un grand Entier à partir d'un entier de type int.
Écrire une fonction permettant d'afficher ce nombre.
Ecrire une fonction qui additionne deux nombres de type Entier et une fonction de multiplication. Pour cette dernière, on écrira deux fonctions utilitaires permettant de multiplier un Entier par un nombre à un seul chiffre, et une fonction multipliant un Entier par une puissance de 10 (décalage).
Écrire une fonction permettant de calculer la factorielle d'un Entier passé en paramètre.
Tester les fonctions précédentes en calculant la factorielle de 27, le résultat doit être 10 888 869 450 418 352 160 768 000 000.
Veiller à ce que toutes les classes et fonctions soient documentées, et vérifier la génération de documentation.

TP 8 Gestion de la mémoire

Ecrire une classe Set définissant un tableau d'entiers de taille variable, et les constructeurs publiques : un constructeur vide, et un constructeur avec un paramètre entier (initialisation avec un seul élément) ; on devra pouvoir écrire :
Set a, b(2); // a est un ensemble vide, b le singleton {2}.
Écrire les constructeurs par copie et la surcharge de l'opérateur d'affectation.
Écrire une fonction membre At retournant l'entier à la position i ; on devra pouvoir écrire :
int e = b.At(0); // e vaut 2
Écrire une fonctions membre d'affichage, éventuellement en surchargeant l'opérateur de flot.
Ecrire une fonction membre Add ajoutant un élément dans l'ensemble. On pourra également surcharger l'opérateur << pour pouvoir écrire :
a.Add(3); // a = {3}
a << 5 << 7; // a = { 3, 5 , 7 }
Écrire une fonction membre Remove retirant le i-ème élément du tableau, si l'indice de position n'est pas valide l'ensemble ne devra pas être changé.
Ecrire une fonction membre de tri des éléments.
Surcharger l'opérateur + permettant de concaténer deux tableaux dans un troisième, on devra pouvoir écrire :
a.Add(4); b.Add(5); // a = {4}, et b = {2, 5}
Set c = a + b; // c = { 4, 2, 5 }

TP 9 Compilation séparée

Écrire une classe Color définissant une couleur à partir de 3 composantes rouge, vert et bleu, codées sur 3 caractères non signés.
Écrire un constructeur à trois paramètres, et un constructeur à un paramètre pour faire du gris, définir la couleur constante Black.
Écrire une classe Image définie comme un tableau de couleurs de taille \(l\times h\), on utilisera la classe std::vector de Color pour représenter ce tableau de taille variable. Pour simplifier l'accès aux couleurs des pixels, on définira que la classe Image est amie de Color.
Écrire le constructeur vide, le destructeur, un constructeur avec comme paramètres la taille de l'image initialisant les pixels de l'image en noir ; on devra pouvoir écrire :
Image i(512,256); // Image de taille 512x256
Écrire une fonction membre Index calculant la position dans le tableau d'un pixel (i,j) ; écrire une fonction At retournant la couleur du pixel (i,j) ; on devra pouvoir écrire :
Color c=i.at(12,27); // Couleur du pixel en 12,27
Écrire des fonction Rectangle, Cercle, Disque, carre permettant de dessiner ces formes géométriques dans l'image.
Implémenter une fonction de sauvegarde de l'image au format PPM ; le code devrait ressembler à :
std::ofstream ofs("name.ppm", ios_base::out | ios_base::binary);// Ouverture du fichier
ofs << "P6" << endl << l << ' ' << h << endl << "255" << std::endl;// Signature, largeur et hauteur
for (int i = 0; i < l; i++)
for (int j = 0; j < h; j++)
ofs << At(i,j).red << At(i,j).green<< At(i,j).blue; // Pixels
ofs.close();
Coder une fonction membre transformant une image couleur en image en niveaux de gris.