Utiliser DEV C++ pour :
1. Définir une classe fleur avec ces attributs qui
sont privés.
2. Définir à l´extérieur de la classe Fleur :
a. Un constructeur par défaut ayant pour nom de
la fleur Ancolie, de couleur verte et de taille 15 cm.
b. Un constructeur qui prend des paramètres.
c. Une fonction getNom qui affiche le nom de la
Fleur.
d. Une méthode setCouleur pour changer la
couleur de la fleur.
e. Une méthode infoFleur qui affiche toutes les
informations sur la fleur.
3. Votre programme principal main ne contient que
l´appel à test.
Correction :
#include <iostream>
#include <string>
using namespace std;
class Fleur {
private:
string nom;
string couleur;
int taille;
public:
// Déclaration des constructeurs et méthodes
Fleur();
Fleur(string nom, string couleur, int taille);
string getNom();
void setCouleur(string couleur);
void infoFleur();
};
// Constructeur par défaut
Fleur::Fleur() {
nom = "Ancolie";
couleur = "verte";
taille = 15;
}
// Constructeur avec paramètres
Fleur::Fleur(string nom, string couleur, int taille) {
this->nom = nom;
this->couleur = couleur;
this->taille = taille;
}
// Méthode getNom
string Fleur::getNom() {
return nom;
}
// Méthode setCouleur
void Fleur::setCouleur(string couleur) {
this->couleur = couleur;
}
// Méthode infoFleur
void Fleur::infoFleur() {
cout << "Nom : " << nom << endl;
cout << "Couleur : " << couleur << endl;
cout << "Taille : " << taille << " cm" << endl;
}
// Fonction test
void test() {
Fleur fleur1; // Appel du constructeur par défaut
Fleur fleur2("Rose", "rouge", 20); // Appel du
constructeur avec paramètres
cout << "Fleur 1 :" << endl;
fleur1.infoFleur();
cout << "\nFleur 2 :" << endl;
fleur2.infoFleur();
cout << "\nNom de la fleur 1 : " <<
fleur1.getNom() << endl;
fleur1.setCouleur("jaune");
cout << "Couleur de la fleur 1 après modification
: ";
fleur1.infoFleur();
}
int main() {
test();
return 0;
}
*Exercice 1 : Classe "Voiture"*
- Définir une classe `Voiture` avec des attributs
privés `marque`, `modele`, `annee` et `couleur`.
- Définir à l'extérieur de la classe :
- Un constructeur par défaut ayant pour marque
"Peugeot", modèle "208", année 2018 et couleur
"rouge".
- Un constructeur qui prend des paramètres.
- Une méthode `getMarque` qui affiche la marque
de la voiture.
- Une méthode `setCouleur` pour changer la
couleur de la voiture.
- Une méthode `infoVoiture` qui affiche toutes les
informations sur la voiture.
Correction
#include <iostream>
#include <string>
using namespace std;
class Voiture {
private:
string marque;
string modele;
int annee;
string couleur;
public:
// Déclaration des constructeurs et méthodes
Voiture();
Voiture(string marque, string modele, int annee,
string couleur);
string getMarque();
void setCouleur(string couleur);
void infoVoiture();
};
// Constructeur par défaut
Voiture::Voiture() {
marque = "Peugeot";
modele = "208";
annee = 2018;
couleur = "rouge";
}
// Constructeur avec paramètres
Voiture::Voiture(string marque, string modele, int
annee, string couleur) {
this->marque = marque;
this->modele = modele;
this->annee = annee;
this->couleur = couleur;
}
// Méthode getMarque
string Voiture::getMarque() {
return marque;
}
// Méthode setCouleur
void Voiture::setCouleur(string couleur) {
this->couleur = couleur;
}
// Méthode infoVoiture
void Voiture::infoVoiture() {
cout << "Marque : " << marque << endl;
cout << "Modèle : " << modele << endl;
cout << "Année : " << annee << endl;
cout << "Couleur : " << couleur << endl;
}
int main() {
// Créer une voiture avec le constructeur par
défaut
Voiture voiture1;
cout << "Voiture 1 :" << endl;
voiture1.infoVoiture();
// Créer une voiture avec le constructeur avec
paramètres
Voiture voiture2("Renault", "Clio", 2020, "bleu");
cout << "\nVoiture 2 :" << endl;
voiture2.infoVoiture();
// Changer la couleur de la voiture 1
voiture1.setCouleur("noir");
cout << "\nVoiture 1 après modification :" <<
endl;
voiture1.infoVoiture();
// Afficher la marque de la voiture 2
cout << "\nMarque de la voiture 2 : " <<
voiture2.getMarque() << endl;
return 0;
}
*Exercice 2 : Classe "Personne"*
- Définir une classe `Personne` avec des attributs
privés `nom`, `prenom`, `age` et `adresse`.
- Définir à l'extérieur de la classe :
- Un constructeur par défaut ayant pour nom
"Dupont", prénom "Jean", âge 30 et adresse
"Paris".
- Un constructeur qui prend des paramètres.
- Une méthode `getNom` qui affiche le nom de la
personne.
- Une méthode `setAdresse` pour changer
l'adresse de la personne.
- Une méthode `infoPersonne` qui affiche toutes
les informations sur la personne.
Correction :
#include <iostream>
#include <string>
using namespace std;
class Personne {
private:
string nom;
string prenom;
int age;
string adresse;
public:
// Déclaration des constructeurs et méthodes
Personne();
Personne(string nom, string prenom, int age,
string adresse);
string getNom();
void setAdresse(string adresse);
void infoPersonne();
};
// Constructeur par défaut
Personne::Personne() {
nom = "Dupont";
prenom = "Jean";
age = 30;
adresse = "Paris";
}
// Constructeur avec paramètres
Personne::Personne(string nom, string prenom, int
age, string adresse) {
this->nom = nom;
this->prenom = prenom;
this->age = age;
this->adresse = adresse;
}
// Méthode getNom
string Personne::getNom() {
return nom;
}
// Méthode setAdresse
void Personne::setAdresse(string adresse) {
this->adresse = adresse;
}
// Méthode infoPersonne
void Personne::infoPersonne() {
cout << "Nom : " << nom << endl;
cout << "Prénom : " << prenom << endl;
cout << "Age : " << age << endl;
cout << "Adresse : " << adresse << endl;
}
int main() {
// Créer une personne avec le constructeur par
défaut
Personne personne1;
cout << "Personne 1 :" << endl;
personne1.infoPersonne();
// Créer une personne avec le constructeur avec
paramètres
Personne personne2("Martin", "Pierre", 25,
"Lyon");
cout << "\nPersonne 2 :" << endl;
personne2.infoPersonne();
// Changer l'adresse de la personne 1
personne1.setAdresse("Marseille");
cout << "\nPersonne 1 après modification :" <<
endl;
personne1.infoPersonne();
// Afficher le nom de la personne 2
cout << "\nNom de la personne 2 : " <<
personne2.getNom() << endl;
return 0;
}
*Exercice 3 : Classe "Livre"*
- Définir une classe `Livre` avec des attributs
privés `titre`, `auteur`, `editeur` et `annee`.
- Définir à l'extérieur de la classe :
- Un constructeur par défaut ayant pour titre "Le
Seigneur des Anneaux", auteur "J.R.R. Tolkien",
éditeur "Allen & Unwin" et année 1954.
- Un constructeur qui prend des paramètres.
- Une méthode `getTitre` qui affiche le titre du livre.
- Une méthode `setEditeur` pour changer l'éditeur
du livre.
- Une méthode `infoLivre` qui affiche toutes les
informations sur le livre.
Correction
#include <iostream>
#include <string>
using namespace std;
class Livre {
private:
string titre;
string auteur;
string editeur;
int annee;
public:
// Déclaration des constructeurs et méthodes
Livre();
Livre(string titre, string auteur, string editeur, int
annee);
string getTitre();
void setEditeur(string editeur);
void infoLivre();
};
// Constructeur par défaut
Livre::Livre() {
titre = "Le Seigneur des Anneaux";
auteur = "J.R.R. Tolkien";
editeur = "Allen & Unwin";
annee = 1954;
}
// Constructeur avec paramètres
Livre::Livre(string titre, string auteur, string editeur,
int annee) {
this->titre = titre;
this->auteur = auteur;
this->editeur = editeur;
this->annee = annee;
}
// Méthode getTitre
string Livre::getTitre() {
return titre;
}
// Méthode setEditeur
void Livre::setEditeur(string editeur) {
this->editeur = editeur;
}
// Méthode infoLivre
void Livre::infoLivre() {
cout << "Titre : " << titre << endl;
cout << "Auteur : " << auteur << endl;
cout << "Editeur : " << editeur << endl;
cout << "Année : " << annee << endl;
}
int main() {
// Créer un livre avec le constructeur par défaut
Livre livre1;
cout << "Livre 1 :" << endl;
livre1.infoLivre();
// Créer un livre avec le constructeur avec
paramètres
Livre livre2("1984", "George Orwell", "Secker &
Warburg", 1949);
cout << "\nLivre 2 :" << endl;
livre2.infoLivre();
// Changer l'éditeur du livre 1
livre1.setEditeur("Gallimard");
cout << "\nLivre 1 après modification :" << endl;
livre1.infoLivre();
// Afficher le titre du livre 2
cout << "\nTitre du livre 2 : " << livre2.getTitre()
<< endl;
return 0;
}
*Exercice 4 : Classe "Employe"*
- Définir une classe `Employe` avec des attributs
privés `nom`, `prenom`, `salaire` et `poste`.
- Définir à l'extérieur de la classe :
- Un constructeur par défaut ayant pour nom
"Martin", prénom "Pierre", salaire 3000 et poste
"Développeur".
- Un constructeur qui prend des paramètres.
- Une méthode `getNom` qui affiche le nom de
l'employé.
- Une méthode `setSalaire` pour changer le salaire
de l'employé.
- Une méthode `infoEmploye` qui affiche toutes les
informations sur l'employé.
Correction
#include <iostream>
#include <string>
using namespace std;
class Employe {
private:
string nom;
string prenom;
double salaire;
string poste;
public:
// Déclaration des constructeurs et méthodes
Employe();
Employe(string nom, string prenom, double
salaire, string poste);
string getNom();
void setSalaire(double salaire);
void infoEmploye();
};
// Constructeur par défaut
Employe::Employe() {
nom = "Martin";
prenom = "Pierre";
salaire = 3000;
poste = "Développeur";
}
// Constructeur avec paramètres
Employe::Employe(string nom, string prenom,
double salaire, string poste) {
this->nom = nom;
this->prenom = prenom;
this->salaire = salaire;
this->poste = poste;
}
// Méthode getNom
string Employe::getNom() {
return nom;
}
// Méthode setSalaire
void Employe::setSalaire(double salaire) {
if(salaire > 0) {
this->salaire = salaire;
} else {
cout << "Salaire invalide !" << endl;
}
}
// Méthode infoEmploye
void Employe::infoEmploye() {
cout << "Nom : " << nom << endl;
cout << "Prénom : " << prenom << endl;
cout << "Salaire : " << salaire << " euros" <<
endl;
cout << "Poste : " << poste << endl;
}
int main() {
// Créer un employé avec le constructeur par
défaut
Employe employe1;
cout << "Employé 1 :" << endl;
employe1.infoEmploye();
// Créer un employé avec le constructeur avec
paramètres
Employe employe2("Dupont", "Jean", 4000,
"Ingénieur");
cout << "\nEmployé 2 :" << endl;
employe2.infoEmploye();
// Changer le salaire de l'employé 1
employe1.setSalaire(3500);
cout << "\nEmployé 1 après modification :" <<
endl;
employe1.infoEmploye();
// Afficher le nom de l'employé 2
cout << "\nNom de l'employé 2 : " <<
employe2.getNom() << endl;
// Essayer de mettre un salaire invalide
employe1.setSalaire(-1000);
return 0;
}
*Exercice 5 : Classe "Etudiant"*
- Définir une classe `Etudiant` avec des attributs
privés `nom`, `prenom`, `matricule` et `note`.
- Définir à l'extérieur de la classe :
- Un constructeur par défaut ayant pour nom
"Dupont", prénom "Jean", matricule "12345" et
note 12.
- Un constructeur qui prend des paramètres.
- Une méthode `getNom` qui affiche le nom de
l'étudiant.
- Une méthode `setNote` pour changer la note de
l'étudiant.
- Une méthode `infoEtudiant` qui affiche toutes les
informations sur l'étudiant.
Correction
#include <iostream>
#include <string>
using namespace std;
class Etudiant {
private:
string nom;
string prenom;
string matricule;
double note;
public:
// Déclaration des constructeurs et méthodes
Etudiant();
Etudiant(string nom, string prenom, string
matricule, double note);
string getNom();
void setNote(double note);
void infoEtudiant();
};
// Constructeur par défaut
Etudiant::Etudiant() {
nom = "Dupont";
prenom = "Jean";
matricule = "12345";
note = 12;
}
// Constructeur avec paramètres
Etudiant::Etudiant(string nom, string prenom,
string matricule, double note) {
this->nom = nom;
this->prenom = prenom;
this->matricule = matricule;
this->note = note;
}
// Méthode getNom
string Etudiant::getNom() {
return nom;
}
// Méthode setNote
void Etudiant::setNote(double note) {
if(note >= 0 && note <= 20) {
this->note = note;
} else {
cout << "Note invalide !" << endl;
}
}
// Méthode infoEtudiant
void Etudiant::infoEtudiant() {
cout << "Nom : " << nom << endl;
cout << "Prénom : " << prenom << endl;
cout << "Matricule : " << matricule << endl;
cout << "Note : " << note << "/20" << endl;
}
int main() {
// Créer un étudiant avec le constructeur par
défaut
Etudiant etudiant1;
cout << "Etudiant 1 :" << endl;
etudiant1.infoEtudiant();
// Créer un étudiant avec le constructeur avec
paramètres
Etudiant etudiant2("Martin", "Pierre", "67890",
15);
cout << "\nEtudiant 2 :" << endl;
etudiant2.infoEtudiant();
// Changer la note de l'étudiant 1
etudiant1.setNote(14);
cout << "\nEtudiant 1 après modification :" <<
endl;
etudiant1.infoEtudiant();
// Afficher le nom de l'étudiant 2
cout << "\nNom de l'étudiant 2 : " <<
etudiant2.getNom() << endl;
// Essayer de mettre une note invalide
etudiant1.setNote(25);
return 0;
}
*Exercice 6 : Classe "CompteBancaire"*
- Définir une classe `CompteBancaire` avec des
attributs privés `numero`, `titulaire`, `solde` et
`type`.
- Définir à l'extérieur de la classe :
- Un constructeur par défaut ayant pour numéro
"123456", titulaire "Jean Dupont", solde 1000 et
type "Courant".
- Un constructeur qui prend des paramètres.
- Une méthode `getSolde` qui affiche le solde du
compte.
- Une méthode `deposer` pour déposer de l'argent
sur le compte.
- Une méthode `infoCompte` qui affiche toutes les
informations sur le compte.
Correction :
#include <iostream>
#include <string>
using namespace std;
class CompteBancaire {
private:
string numero;
string titulaire;
double solde;
string type;
public:
// Déclaration des constructeurs et méthodes
CompteBancaire();
CompteBancaire(string numero, string titulaire,
double solde, string type);
double getSolde();
void deposer(double montant);
void retirer(double montant);
void infoCompte();
};
// Constructeur par défaut
CompteBancaire::CompteBancaire() {
numero = "123456";
titulaire = "Jean Dupont";
solde = 1000;
type = "Courant";
}
// Constructeur avec paramètres
CompteBancaire::CompteBancaire(string numero,
string titulaire, double solde, string type) {
this->numero = numero;
this->titulaire = titulaire;
this->solde = solde;
this->type = type;
}
// Méthode getSolde
double CompteBancaire::getSolde() {
return solde;
}
// Méthode deposer
void CompteBancaire::deposer(double montant) {
if(montant > 0) {
solde += montant;
cout << "Dépôt effectué avec succès.
Nouveau solde : " << solde << endl;
} else {
cout << "Montant invalide !" << endl;
}
}
// Méthode retirer
void CompteBancaire::retirer(double montant) {
if(montant > 0 && montant <= solde) {
solde -= montant;
cout << "Retrait effectué avec succès.
Nouveau solde : " << solde << endl;
} else {
cout << "Montant invalide ou solde insuffisant
!" << endl;
}
}
// Méthode infoCompte
void CompteBancaire::infoCompte() {
cout << "Numéro : " << numero << endl;
cout << "Titulaire : " << titulaire << endl;
cout << "Solde : " << solde << endl;
cout << "Type : " << type << endl;
}
int main() {
// Créer un compte avec le constructeur par
défaut
CompteBancaire compte1;
cout << "Compte 1 :" << endl;
compte1.infoCompte();
// Créer un compte avec le constructeur avec
paramètres
CompteBancaire compte2("987654", "Pierre
Martin", 500, "Epargne");
cout << "\nCompte 2 :" << endl;
compte2.infoCompte();
// Déposer de l'argent sur le compte 1
compte1.deposer(500);
cout << "\nCompte 1 après dépôt :" << endl;
compte1.infoCompte();
// Afficher le solde du compte 2
cout << "\nSolde du compte 2 : " <<
compte2.getSolde() << endl;
// Retirer de l'argent du compte 1
compte1.retirer(200);
cout << "\nCompte 1 après retrait :" << endl;
compte1.infoCompte();
return 0;
}
*Exercice 7 : Classe "Vehicule"*
- Définir une classe `Vehicule` avec des attributs
privés `marque`, `modele`, `annee` et
`kilometrage`.
- Définir à l'extérieur de la classe :
- Un constructeur par défaut ayant pour marque
"Peugeot", modèle "208", année 2018 et
kilométrage 50000.
- Un constructeur qui prend des paramètres.
- Une méthode `getMarque` qui affiche la marque
du véhicule.
- Une méthode `setKilometrage` pour changer le
kilométrage du véhicule.
- Une méthode `infoVehicule` qui affiche toutes les
informations sur le véhicule.
Correction
#include <iostream>
#include <string>
using namespace std;
class Vehicule {
private:
string marque;
string modele;
int annee;
int kilometrage;
public:
// Déclaration des constructeurs et méthodes
Vehicule();
Vehicule(string marque, string modele, int
annee, int
kilometrage);
string getMarque();
void setKilometrage(int kilometrage);
void infoVehicule();
};
// Constructeur par défaut
Vehicule::Vehicule() {
marque = "Peugeot";
modele = "208";
annee = 2018;
kilometrage = 50000;
}
// Constructeur avec paramètres
Vehicule::Vehicule(string marque, string modele,
int annee, int kilometrage) {
this->marque = marque;
this->modele = modele;
this->annee = annee;
this->kilometrage = kilometrage;
}
// Méthode getMarque
string Vehicule::getMarque() {
return marque;
}
// Méthode setKilometrage
void Vehicule::setKilometrage(int kilometrage) {
if(kilometrage >= 0) {
this->kilometrage = kilometrage;
} else {
cout << "Kilométrage invalide !" << endl;
}
}
// Méthode infoVehicule
void Vehicule::infoVehicule() {
cout << "Marque : " << marque << endl;
cout << "Modèle : " << modele << endl;
cout << "Année : " << annee << endl;
cout << "Kilométrage : " << kilometrage << " km"
<< endl;
}
int main() {
// Créer un véhicule avec le constructeur par
défaut
Vehicule vehicule1;
cout << "Véhicule 1 :" << endl;
vehicule1.infoVehicule();
// Créer un véhicule avec le constructeur avec
paramètres
Vehicule vehicule2("Renault", "Clio", 2020,
20000);
cout << "\nVéhicule 2 :" << endl;
vehicule2.infoVehicule();
// Changer le kilométrage du véhicule 1
vehicule1.setKilometrage(60000);
cout << "\nVéhicule 1 après modification :" <<
endl;
vehicule1.infoVehicule();
// Afficher la marque du véhicule 2
cout << "\nMarque du véhicule 2 : " <<
vehicule2.getMarque() << endl;
// Essayer de mettre un kilométrage invalide
vehicule1.setKilometrage(-10000);
return 0;
}
*Exercice 8 : Classe "Produit"*
- Définir une classe `Produit` avec des attributs
privés `nom`, `description`, `prix` et `quantite`.
- Définir à l'extérieur de la classe :
- Un constructeur par défaut ayant pour nom
"Ordinateur", description "PC portable", prix 800 et
quantité 10.
- Un constructeur qui prend des paramètres.
- Une méthode `getNom` qui affiche le nom du
produit.
- Une méthode `setPrix` pour changer le prix du
produit.
- Une méthode `infoProduit` qui affiche toutes les
informations sur le produit.
Correction
#include <iostream>
#include <string>
using namespace std;
class Produit {
private:
string nom;
string description;
double prix;
int quantite;
public:
// Déclaration des constructeurs et méthodes
Produit();
Produit(string nom, string description, double
prix, int quantite);
string getNom();
void setPrix(double prix);
void infoProduit();
};
// Constructeur par défaut
Produit::Produit() {
nom = "Ordinateur";
description = "PC portable";
prix = 800;
quantite = 10;
}
// Constructeur avec paramètres
Produit::Produit(string nom, string description,
double prix, int quantite) {
this->nom = nom;
this->description = description;
this->prix = prix;
this->quantite = quantite;
}
// Méthode getNom
string Produit::getNom() {
return nom;
}
// Méthode setPrix
void Produit::setPrix(double prix) {
if(prix >= 0) {
this->prix = prix;
} else {
cout << "Prix invalide !" << endl;
}
}
// Méthode infoProduit
void Produit::infoProduit() {
cout << "Nom : " << nom << endl;
cout << "Description : " << description << endl;
cout << "Prix : " << prix << " euros" << endl;
cout << "Quantité : " << quantite << endl;
}
int main() {
// Créer un produit avec le constructeur par
défaut
Produit produit1;
cout << "Produit 1 :" << endl;
produit1.infoProduit();
// Créer un produit avec le constructeur avec
paramètres
Produit produit2("Smartphone", "Téléphone
mobile", 500, 20);
cout << "\nProduit 2 :" << endl;
produit2.infoProduit();
// Changer le prix du produit 1
produit1.setPrix(900);
cout << "\nProduit 1 après modification :" <<
endl;
produit1.infoProduit();
// Afficher le nom du produit 2
cout << "\nNom du produit 2 : " <<
produit2.getNom() << endl;
// Essayer de mettre un prix invalide
produit1.setPrix(-100);
return 0
