Série d’exercices corrigés de C++

Voici une liste des exercices corrigés de C++ :

Exercices 1 :

Éliminer les parenthèses superflues dans les expressions suivantes :

a = (x+5) /* expression 1 */
a = (x=y) + 2 /* expression 2 */
a = (x==y) /* expression 3 */
(a<b) && (c<d) /* expression 4 */
(i++) * (n+p) /* expression 5 */

Solution :

a = x+5 /* expression 1 */
L’opérateur + est prioritaire sur l’opérateur d’affectation =.

a = (x=y) + 2 /* expression 2 */
Ici, l’opérateur + étant prioritaire sur =, les parenthèses sont indispensables.

a = x==y /* expression 3 */
L’opérateur == est prioritaire sur =.

a<b && c<d /* expression 4 */
L’opérateur && est prioritaire sur l’opérateur <.

i++ * (n+p) /* expression 5 */
L’opérateur ++ est prioritaire sur * ; en revanche, * est prioritaire sur +, de sorte qu’on ne peut éliminer les dernières parenthèses.

Exercice 2:

Soient les déclarations :
char c = ‘\x01’ ;
short int p = 10 ;

Quels sont le type et la valeur de chacune des expressions suivantes :

p + 3 /* 1 */
c + 1 /* 2 */
p + c /* 3 */
3 * p + 5 * c /* 4 */

Solution :

1. p est d’abord soumis à la conversion « systématique » short -> int, avant d’être ajouté à la valeur 3 (int). Le résultat 13 est de type int.
2. c est d’abord soumis à la conversion « systématique » char -> int (ce qui aboutit à la valeur 1), avant d’être ajouté à la valeur 1 (int). Le résultat 2 est de type int.
3. p est d’abord soumis à la conversion systématique short -> int, tandis que c est soumis à la conversion systématique char -> int ; les résultats sont alors additionnés pour aboutir à la valeur 11 de type int.
4. p et c sont d’abord soumis aux mêmes conversions systématiques que ci-dessus ; le résultat 35 est de type int.

Exercice 3 :

Soient les déclarations :

char c = ‘\x05’ ;
int n = 5 ;
long p = 1000 ;
float x = 1.25 ;
double z = 5.5 ;

Quels sont le type et la valeur de chacune des expressions suivantes :

n + c + p /* 1 */
2 * x + c /* 2 */
(char) n + c /* 3 */
(float) z + n / 2 /* 4 */

Solution :

1. c est tout d’abord converti en int, avant d’être ajouté à n. Le résultat (10), de type int, est alors converti en long, avant d’être ajouté à p. On obtient finalement la valeur 1010, de type long.
2. On évalue d’abord la valeur de 2*x, en convertissant 2 (int) en float, ce qui fournit la valeur 2.5 (de type float). Par ailleurs, c est converti en int (conversion systématique). On évalue ensuite la valeur de 2*x, en convertissant 2 (int) en float, ce qui fournit la valeur 2.5 (de type float). Pour effectuer l’addition, on convertit alors la valeur entière 5 (c) en float, avant de l’ajouter au résultat précédent. On obtient finalement la valeur 7.75, de type float.
3. n est tout d’abord converti en char (à cause de l’opérateur de « cast »), tandis que c est converti (conversion systématique) en int. Puis, pour procéder à l’addition, il est nécessaire de reconvertir la valeur de (char) n en int. Finalement, on obtient la valeur 10, de type int.
4. z est d’abord converti en float, ce qui fournit la valeur 5.5 (approximative, car, en fait, on obtient une valeur un peu moins précise que ne le serait 5.5 exprimé en double). Par ailleurs, on procède à la division entière de n par 2, ce qui fournit la valeur entière 2. Cette dernière est ensuite convertie en float, avant d’être ajoutée à 5.5, ce qui fournit le résultat 7.5, de type float.

Exercices 4 :

Dites ce qui sera affiché par le programme suivant :

#include <iostream.h>
class point {
private:
float x,y;
public :
point(float abs=0.0,float ord=0.0) {
x=abs; y=ord;
}
void affiche() {
cout << "point ("<<x<< ","<< y<< ")\n ";
}
void deplace(float dx, float dy) {
x=x+dx; y=y+dy;
}
};
class pointcol :public point {
private:
int cl;
public :
pointcol(float abs=0.0,float ord=0.0,int coul=2) : point(abs,ord) {
cl=coul;
}
void colore(int coul) {
cl=coul;
}
void affiche() {
point::affiche();
cout<<"\t couleur :"<<cl<<"\n";
}
};
main(){
pointcol c(2,3,1);
c.affiche();
((point)c).affiche();
c.deplace(-1,-1);
c.affiche();
}

Solution :

point <2,3>
couleur: 1
point <2,3>
point <1,2>
couleur:1

Exercice 5 :

Définir une classe tableau ayant les caractéristiques suivantes:
Repose sur un tableau de dimension n, n étant passé au constructeur (allocation dynamique)
Implémenter les 4 opérateurs +,-,*,:
On accède aux données à l’aide de l’opérateur []. En cas de débordement, cet opérateur imprime un message et ne fera rien de dangereux.

solution :

#include <iostream.h>
#include <conio.h>
class tableau {
private:
const int sz;
int *A;
int reserve;
void copie (int src, int *dest, int s) {
for (int i=0; i<s; i++)
*(dest++)=src;
}
void copie (int *src, int *dest, int s) {
for (int i=0; i<s; i++)
*(dest++)= *(src++);
}
public:
tableau (int n): sz(n),reserve(0) {
cerr << "constructeur sz = " << n<<endl;
A = new int[sz];
copie(0,A,sz);
}
tableau (const tableau & t): sz(t.sz),reserve(0) {
cerr << "constructeur de copie" << endl;
A = new int[sz];
copie(t.A,A,sz);
}
tableau & operator=(const tableau &t) {
cerr << "operateur =" << endl;
if (sz != t.sz) {
cerr << "Ne peut pas egaliser deux tableaux de tailles differentes" << endl;
};
copie(t.A,A,sz);
return *this;
}
~tableau() { delete [] A;}
int taille() const { return sz;};
int operator[](int i) {
if (i<0 || i>=sz) {
cerr << "ATTENTION Debordement de tableau";
return reserve;
} else
return *(A+i);
}
tableau & operator+=(const tableau & t) {
if (sz != t.sz)
cerr << "Ne peut pas ajouter deux tableaux de tailles differentes" << endl;
else
for (int i=0; i < sz; i++)
A[i] += t.A[i];
return *this;
}
void affiche () const {
for (int i=0; i < sz; i++)
cout << *(A+i) << " ";
cout << endl;
}
tableau operator+(const tableau& t2) {
tableau s(t2.taille());
if (taille() != t2.taille())
cerr << "Ne peut pas ajouter deux tableaux de tailles differentes" << endl;
else {
s = *this;
s += t2;
};
return s;
}
};

Les opérateurs – et * seront définis de la même façon que +