Correction Devoir 1 :

Exercice 1 :
#include <iostream>
class pile_entier {
private:
int* tableau;
int capacite;
int sommet;

public:
pile_entier(int n) {
capacite = n;
tableau = new int[capacite];
sommet = -1;
}

pile_entier() {
capacite = 20;
tableau = new int[capacite];
sommet = -1;
}

~pile_entier() {
delete[] tableau;
}
pile_entier(const pile_entier& autre) {
capacite = autre.capacite;
tableau = new int[capacite];
sommet = autre.sommet;
for (int i = 0; i <= sommet; i++) {
tableau[i] = autre.tableau[i];
}
}
void empile(int p) {
if (!pleine()) {
sommet++;
tableau[sommet] = p;
} else {
std::cout << "La pile est pleine. Impossible d'empiler." << std::endl;
}
}

int depile() {
if (!vide()) {
int valeur = tableau[sommet];
sommet--;
return valeur;
} else {
std::cout << "La pile est vide. Impossible de dépiler." << std::endl;
return -1; // Valeur par défaut en cas d'erreur
}
}
 int pleine() {
return sommet == capacite - 1;
}

int vide() {
return sommet == -1;
}
};

int main() {
pile_entier pile1;

pile1.empile(10);
pile1.empile(20);
pile1.empile(30);

std::cout << "Sommet de la pile1 : " << pile1.depile() << std::endl;

// Utilisation d'objets dynamiques

pile_entier* pile2 = new pile_entier(5); // Utilisation du constructeur avec
allocation dynamique

pile2->empile(5);
pile2->empile(15);

std::cout << "Sommet de la pile2 : " << pile2->depile() << std::endl;

 delete pile2;
return 0;
}
Exercice 2 :
1. Fonctions membres :
class pile_entier {
private:
int dim;
int* adr;
int nelem;

public:

void operator<(int n) {
if (nelem < dim) {
adr[nelem] = n;
nelem++;
} else {
std::cout << "La pile est pleine. Impossible d'ajouter " << n << std::endl;
}
}

void operator>(int& n) {
if (nelem > 0) {
nelem--;
n = adr[nelem];
} else {
 std::cout << "La pile est vide. Aucun élément à retirer." << std::endl;
n = -1; // Valeur par défaut en cas d'erreur
}
}
};
2. Fonctions amies :
class pile_entier {
private:
int dim;
int* adr;
int nelem;

public:

friend pile_entier& operator<(pile_entier& p, int n) {

if (p.nelem < p.dim) {
p.adr[p.nelem] = n;
p.nelem++;
} else {
std::cout << "La pile est pleine. Impossible d'ajouter " << n << std::endl;
}
return p;
}

friend int operator>(pile_entier& p, int& n) {

if (p.nelem > 0) {
p.nelem--;
 n = p.adr[p.nelem];
} else {
std::cout << "La pile est vide. Aucun élément à retirer." << std::endl;
n = -1;
}
return n;
}
};
Exercice 3:
#include <iostream>
#include <cstring>

class chaine {
private:
char* contenu;
int longueur;

public:
chaine() : contenu(nullptr), longueur(0) {}

chaine(const char* str) {

longueur = strlen(str);
contenu = new char[longueur];
strcpy(contenu, str);
}

chaine(const chaine& other) {

 longueur = other.longueur;
contenu = new char[longueur];
strcpy(contenu, other.contenu);
}

~chaine() {
delete[] contenu;
}

chaine& operator=(const chaine& other) {

if (this != &other) {
delete[] contenu;
longueur = other.longueur;
contenu = new char[longueur];
strcpy(contenu, other.contenu);
}
return *this;
}

bool operator==(const chaine& other) const {

return (longueur == other.longueur) && (strcmp(contenu, other.contenu)
== 0);
}

chaine operator+(const chaine& other) const {

chaine result;
result.longueur = longueur + other.longueur;
result.contenu = new char[result.longueur];
 strcpy(result.contenu, contenu);
strcat(result.contenu, other.contenu);
return result;
}

char& operator[](int index) {

if (index >= 0 && index < longueur) {
return contenu[index];
}
// Gestion de l'erreur (vous pouvez choisir une autre méthode)
throw std::out_of_range("Index hors limites");
}

void afficher() const {

std::cout << contenu;
}
};

int main() {
chaine a("Bonjour");
chaine b("Monde");

a.afficher();
std::cout << std::endl;

b.afficher();
std::cout << std::endl;
 chaine c = a + b;
c.afficher();
std::cout << std::endl;

c[0] = 'H';
c.afficher();

return 0;
}