Université Cadi Ayyad Année universitaire : 2022 – 2023

ENSA de Marrakech

Langage C/C++
TD n°2.

Exercice 0:
1) Quelles différences il-y-t-il entre les deux constantes MAX1 et MAX2 définies de la façon suivante ?
– #define MAX1 100
– static const int MAX2 = 100
Essayer d’accéder à l’adresse (pointeur) de MAX1 (int *p1=&MAX1) et à l’adresse de MAX2
(int *p2=&MAX2). Que se passe-t-il ?
2) Tester la Macro et la fonction inline du cours et démontrer pourquoi on a un effet de bord pour la macro.

Exercice 1 :
Ecrire un programme qui permet la saisie d’un tableau d’entiers, l’affiche et le trie. Le tri sera fait de cette
façon :-Mettre le plus petit entier en première position du tableau. On opère par comparaison deux à deux
entre le premier élément du tableau et un élément d’indice i du tableau. On échange les deux éléments
lorsque ceux-ci ne sont pas dans un ordre correct.

Exercice 2: Plusieurs fonctions un même nom, bizarre bizarre!! Sur papier

Soient les déclarations (C++) suivantes :
int fct (int) ; // fonction I
int fct (float) ; // fonction II
void fct (int, float) ; // fonction III
void fct (float, int) ; // fonction IV
int n, p ; float x, y ; char c ; double z ;
Les appels suivants sont-ils corrects et, si oui, quelles seront les fonctions effectivement appelées et les
conversions éventuellement mises en place ?
a. fct (n) ;
b. fct (x) ;
c. fct (n, x) ;
d. fct (x, n) ;
e. fct (c) ;
f. fct (n, p) ;
g. fct (n, c) ;
h. fct (n, z) ;
i. fct (z, z) ;

Exercice 3: En ligne!!! Avantage C++

1. Ecrire un programme C avec une macro qui calcule le carré d'un nombre entier x?
2. Testez ce programme pour a=2; et calculez carre(a) et carre(a+3)? obtenez-vous le résultat
escompté?
3. Ecrire un programme C++ avec une fonction carre() qui calcule le carré d'un nombre entier ?Pour
pouvoir utiliser l'avantage des macros en C++ on utilise le mot clé inline devant la fonction carre (). cela fait
qu'à la compilation chaque fois que le compilateur rencontre un appel à la fonction carre() il le remplace par
le code de la dite fonction. Faites le test de la question 2). Avez-vous eu le même problème? Conclure.

Exercice4: Arguments par défaut

Recopiez et sauvegarder le programme suivant:
#include <iostream>
void fct(int, int = 15); // prototype
int main()
{
int n = 10, p = 20;
 fct(n,p); // appel normal
fct(n); // appel avec un seul argument
system(''Pause'');
return 0;
}
void fct( int a, int b)
{
cout << "Argument 1 : " << a;
cout << "Argument 2 : " << b << endl;
}
conclure?

Remplacer le prototype par : void fct( int = 15, int); conclure?

EXERCICE 5 : votre première classe !

1) Ecrivez une classe Vecteur3D comportant :
– trois données membre de type double x,y,z (privées)
– deux fonctions membres d’affichage :
– void affiche() affichant le vecteur.
– void affiche(const char* chaine) affichant chaine avant l’affichage du vecteur.
– deux constructeurs à définir en dehors de la classe:
* l’un sans argument, initialisant chaque composante à 0.
* l’autre, avec trois arguments correspondant aux coordonnées du vecteur.
Modifiez ensuite le code pour que les constructeurs soit des fonctions en ligne (inline).
2) Rajouter les fonctions suivantes à la classe Vecteur3D :
* Des fonctions permettant d’accéder aux coordonnées d’un vecteur :
– int abscisse( ) pour x,
– int ordonnee( ) pour y et
– int cote( ) pour z.
* Des fonctions permettant de modifier les coordonnées d’un vecteur :
– void fixer_abscisse(int nouvelle_abscisse) pour x,
– void fixer_ordonnée(int nouvelle_ordonnée) pour y et
– void fixer_cote(int nouvelle_ordonnée) pour z.
* bool coincide(Vecteur3D v) qui renvoie true si v et l’objet courant ont les mêmes coordonnées, false sinon.

EXERCICE 6 :
Rajouter les fonctions suivantes à la classe Vecteur3D :
– double produit_scalaire(Vecteur3D v) qui calcule le produit scalaire de v avec l’objet courant.
– Vecteur3D somme(Vecteur3D v) qui calcule le vecteur somme de v avec l’objet courant.

EXERCICE 7: classe dynamique!

Écrivez une classe nommée pile_entier permettant de gérer une pile d’entiers. Ces derniers seront conservés
dans un tableau d’entiers alloué dynamiquement. La classe comportera les fonctions membres suivantes

– pile_entier (int n) : constructeur allouant dynamiquement un emplacement de n entiers,

– pile_entier () : constructeur allouant dynamiquement un emplacement de 20 entiers,
– pile_entier (pile_entier &pile const) : constructeur de copie créant une copie de la pile d’entier pile,
– ~pile_entier () : destructeur
– void empile (int p) : empile l’entier p sur la pile,
– int depile () : fournit la valeur de l’entier en haut de la pile et le supprime de la pile,
– int pleine () : renvoie 1 si la pile est pleine (nombre d’entiers dans la pile = taille du tableau) et 0 sinon,
– int vide () : renvoie 1 si la pile est vide et 0 sinon.