From 0ef3e40f726f35b86d79426104234d815cea2bb9 Mon Sep 17 00:00:00 2001 From: Benjamin Chausse Date: Tue, 10 Jan 2023 10:28:41 -0500 Subject: Start working on shapes --- rectangle.cpp | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 rectangle.cpp (limited to 'rectangle.cpp') diff --git a/rectangle.cpp b/rectangle.cpp new file mode 100644 index 0000000..f719ff9 --- /dev/null +++ b/rectangle.cpp @@ -0,0 +1,52 @@ +#include "forme.h" + +class Rectangle:Forme{ + private: + int Largeur; + int Hauteur; + + public: + + Rectangle(int x, int y, int l, int h):Forme(x,y),Largeur(l),Hauteur(h){ + Coordonnee t = {x,y}; + setAncrage(t); + SetHauteur(h); + SetLargeur(l); + }; + + int GetLargeur(){return Largeur;}; + int GetHauteur(){return Hauteur;}; + void SetLargeur(int l){Largeur=l;}; + void SetHauteur(int h){Hauteur=h;}; + double aire(){return Largeur*Hauteur;}; + void afficher(ostream &s); +}; + +void Rectangle::afficher(ostream &s){ + // Resultat: "Rectangle (x=2, y=3, h=4, l=5, aire=5)" + s << "Rectangle (x=" << getAncrage().x + << ", y=" << getAncrage().y + << ", h=" << GetHauteur() + << ", l=" << GetLargeur() + << ", aire=" << aire() + << ")\n"; + /* << ")" << endl; */ +}; + +class Carre:Rectangle{ + public: + + Carre(int x, int y, int c):Rectangle(x,y,c,c){}; + + void afficher(ostream &s); +}; + +Carre::afficher(osstream &s){ + // Resultat: "Carre (x=2, y=3, c=4, aire=5)" + s << "Carre (x=" << getAncrage().x + << ", y=" << getAncrage().y + << ", c=" << GetHauteur() + << ", aire=" << aire() + << ")\n"; + /* << ")" << endl; */ +}; -- cgit v1.2.3 From b4f16386c70bfeab700e7cc129f2f04295aa0059 Mon Sep 17 00:00:00 2001 From: Benjamin Chausse Date: Thu, 12 Jan 2023 23:40:59 -0500 Subject: vecteur est fomrmes sont finis --- carre.cpp | 15 ++++++++++++ carre.h | 8 +++++++ cercle.cpp | 43 +++++++++++++++++++--------------- cercle.h | 14 ++++++++++++ config.mk | 11 +++++++++ graphicus-01.cpp | 18 --------------- graphicus-02.cpp | 18 +++++++++++++++ makefile | 46 +++++++++++++++++++++++++++++-------- rectangle.cpp | 68 ++++++++++++++++++++++++------------------------------ rectangle.h | 17 ++++++++++++++ vecteur.cpp | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ vecteur.h | 39 +++++++++++++++++++++++++++++++ 12 files changed, 284 insertions(+), 83 deletions(-) create mode 100644 carre.cpp create mode 100644 carre.h create mode 100644 cercle.h create mode 100644 config.mk delete mode 100644 graphicus-01.cpp create mode 100644 graphicus-02.cpp create mode 100644 rectangle.h create mode 100644 vecteur.cpp create mode 100644 vecteur.h (limited to 'rectangle.cpp') diff --git a/carre.cpp b/carre.cpp new file mode 100644 index 0000000..1d0ad44 --- /dev/null +++ b/carre.cpp @@ -0,0 +1,15 @@ +#include "carre.h" + +Carre::Carre(int x, int y, int cote) : Rectangle(x, y, cote, cote) { +}; + +Carre::~Carre() { +}; + +void Carre::afficher(ostream &s) { + s << "Carre(x=" << getAncrage().x + << ", y=" << getAncrage().y + << ", c=" << getLargeur() + << ", a=" << getAire() + << ")\n"; +}; diff --git a/carre.h b/carre.h new file mode 100644 index 0000000..80b9d57 --- /dev/null +++ b/carre.h @@ -0,0 +1,8 @@ +#include "rectangle.h" + +class Carre : public Rectangle { +public: + Carre(int x, int y, int cote); + ~Carre(); + void afficher(ostream &s); +}; diff --git a/cercle.cpp b/cercle.cpp index 100291b..4747258 100644 --- a/cercle.cpp +++ b/cercle.cpp @@ -1,27 +1,34 @@ -#include -#include "forme.h" +#include "cercle.h" +#include -class Cercle:Forme { - private: - int Rayon; - public: +Cercle::Cercle(int x, int y, int r):Forme(x,y) { + Coordonnee xy = {x,y}; + setAncrage(xy); + setRayon(r); +}; + +Cercle::~Cercle() { +}; - Cercle(int x, int y, int r):Forme(x,y),Rayon(r) { - Coordonnee t = {x,y}; - setAncrage(t); - SetRayon(r); +void Cercle::setRayon(int r) { + rayon = r; +}; - }; +int Cercle::getRayon() { + return rayon; +}; + +double Cercle::getAire() { + return M_PI*pow(rayon,2); +}; - void afficher(ostream & s); - int GetRayon(){return Rayon;}; - void SetRayon(int r){Rayon=r;}; - double aire(){return M_PI*Rayon*Rayon;}; - double perimetre(){return 2*M_PI*Rayon;}; +double Cercle::getPerimetre() { + return 2*M_PI*rayon; }; void Cercle::afficher(ostream & s) { s << "Cercle (x=" << getAncrage().x - << ", y=" << getAncrage().y - << ", r=" << GetRayon() << ", aire=" << aire() << ")"; + << ", y=" << getAncrage().y + << ", r=" << getRayon() + << ", aire=" << getAire() << ")\n"; }; diff --git a/cercle.h b/cercle.h new file mode 100644 index 0000000..d3eca66 --- /dev/null +++ b/cercle.h @@ -0,0 +1,14 @@ +#include "forme.h" + +class Cercle:Forme { + private: + int rayon; + public: + Cercle(int x, int y, int r); + ~Cercle(); + void setRayon(int r); + int getRayon(); + double getAire(); + double getPerimetre(); + void afficher(ostream & s); +}; diff --git a/config.mk b/config.mk new file mode 100644 index 0000000..adcbe37 --- /dev/null +++ b/config.mk @@ -0,0 +1,11 @@ + +SHELL = /bin/bash + +# c++ compiler flags that are used for all targets: +# they make binaries faster and smaller +# -s : strips the binary +# -O3 : optimizes the binary +# -Ofast : optimizes the binary +# -march=native : optimizes the binary for the current CPU +# -flto : link time optimization +CFLAGS = -Ofast -march=native -flto -s diff --git a/graphicus-01.cpp b/graphicus-01.cpp deleted file mode 100644 index b544cc8..0000000 --- a/graphicus-01.cpp +++ /dev/null @@ -1,18 +0,0 @@ -/******** - * Fichier: graphicus-01.cpp - * Auteurs: C.-A. Brunet - * Date: 08 janvier 2018 (creation) - * Description: gestionnaire de tests pour l'application Graphicus. Ce - * fichier fait partie de la distribution de Graphicus. -********/ -#include "tests.h" - -using namespace std; - -int main() { - Tests tests; - - tests.tests_application(); - return 0; -} - diff --git a/graphicus-02.cpp b/graphicus-02.cpp new file mode 100644 index 0000000..b01b3a9 --- /dev/null +++ b/graphicus-02.cpp @@ -0,0 +1,18 @@ +/******** + * Fichier: graphicus-02.cpp + * Auteurs: C.-A. Brunet + * Date: 08 janvier 2018 (creation) + * Description: gestionnaire de tests pour l'application Graphicus. Ce + * fichier fait partie de la distribution de Graphicus. +********/ +#include "tests.h" + +using namespace std; + +int main() { + Tests tests; + + tests.tests_application(); + return 0; +} + diff --git a/makefile b/makefile index 86bcbe2..db6d4eb 100644 --- a/makefile +++ b/makefile @@ -1,27 +1,55 @@ # # Auteur: C.-A. Brunet # Date: 08 janvier 2018 -# Description: compilation de graphicus-01. Ce fichier fait partie de +# Description: compilation de graphicus-02. Ce fichier fait partie de # la distribution de Graphicus. # -graphicus-01: graphicus-01.o tests.o canevas.o couche.o forme.o - g++ -o graphicus-01 graphicus-01.o tests.o canevas.o couche.o forme.o +ALL := graphicus-02.o tests.o canevas.o couche.o forme.o vecteur.o cercle.o rectangle.o carre.o + + +include config.mk + +graphicus-02: $(ALL) + g++ ${CFLAGS} -o $@ $^ && strip $@ $^ + +# graphicus-02: $(ALL) +# g++ ${CFLAGS} -o $@ $^ -graphicus-01.o: graphicus-01.cpp canevas.h couche.h forme.h - g++ -c graphicus-01.cpp tests.o: tests.cpp tests.h canevas.h couche.h forme.h - g++ -c tests.cpp + g++ ${CFLAGS} -c tests.cpp canevas.o: canevas.cpp canevas.h couche.h forme.h - g++ -c canevas.cpp + g++ ${CFLAGS} -c canevas.cpp couche.o: couche.cpp couche.h forme.h - g++ -c couche.cpp + g++ ${CFLAGS} -c couche.cpp forme.o: forme.cpp forme.h - g++ -c forme.cpp + g++ ${CFLAGS} -c forme.cpp + +vecteur.o: vecteur.cpp vecteur.h coordonnee.h + g++ ${CFLAGS} -c vecteur.cpp + +rectangle.o: rectangle.cpp rectangle.h forme.h + g++ ${CFLAGS} -c rectangle.cpp + +carre.o: carre.cpp carre.h rectangle.h forme.h + g++ ${CFLAGS} -c carre.cpp + +cercle.o: cercle.cpp cercle.h forme.h + g++ ${CFLAGS} -c cercle.cpp + +graphicus-02.o: graphicus-02.cpp canevas.h couche.h forme.h + g++ ${CFLAGS} -c graphicus-02.cpp clean: rm -f *.o + +options: + @echo "Option de compilation de GRAPHICUS:" + @echo " graphicus-02: Construction de l'executable dans sa totalité" + @echo " clean: Nettoyage des fichiers temporaires '.o'" + @echo " *.o: Construction des fichiers objets" + diff --git a/rectangle.cpp b/rectangle.cpp index f719ff9..239ea81 100644 --- a/rectangle.cpp +++ b/rectangle.cpp @@ -1,52 +1,44 @@ -#include "forme.h" +#include "rectangle.h" -class Rectangle:Forme{ - private: - int Largeur; - int Hauteur; +Rectangle::Rectangle(int x, int y, int w, int h){ + Coordonnee xy = {x, y}; + setAncrage(xy); + setLargeur(w); + setHauteur(h); +}; - public: +Rectangle::~Rectangle(){ +}; - Rectangle(int x, int y, int l, int h):Forme(x,y),Largeur(l),Hauteur(h){ - Coordonnee t = {x,y}; - setAncrage(t); - SetHauteur(h); - SetLargeur(l); - }; +int Rectangle::getLargeur(){ + return largeur; +}; - int GetLargeur(){return Largeur;}; - int GetHauteur(){return Hauteur;}; - void SetLargeur(int l){Largeur=l;}; - void SetHauteur(int h){Hauteur=h;}; - double aire(){return Largeur*Hauteur;}; - void afficher(ostream &s); +int Rectangle::getHauteur(){ + return hauteur; }; -void Rectangle::afficher(ostream &s){ - // Resultat: "Rectangle (x=2, y=3, h=4, l=5, aire=5)" - s << "Rectangle (x=" << getAncrage().x - << ", y=" << getAncrage().y - << ", h=" << GetHauteur() - << ", l=" << GetLargeur() - << ", aire=" << aire() - << ")\n"; - /* << ")" << endl; */ +Coordonnee Rectangle::getAncrageForme(){ + return getAncrage(); }; -class Carre:Rectangle{ - public: +void Rectangle::setLargeur(int l){ + largeur=l; +}; - Carre(int x, int y, int c):Rectangle(x,y,c,c){}; +void Rectangle::setHauteur(int h){ + hauteur=h; +}; - void afficher(ostream &s); +double Rectangle::getAire(){ + return largeur*hauteur; }; -Carre::afficher(osstream &s){ - // Resultat: "Carre (x=2, y=3, c=4, aire=5)" - s << "Carre (x=" << getAncrage().x - << ", y=" << getAncrage().y - << ", c=" << GetHauteur() - << ", aire=" << aire() +void Rectangle::afficher(ostream &s){ + s << "Rectangle:(x=" << getAncrageForme().x + << ", y=" << getAncrageForme().y + << ", l=" << getLargeur() + << ", h=" << getHauteur() + << ", aire=" << getAire() << ")\n"; - /* << ")" << endl; */ }; diff --git a/rectangle.h b/rectangle.h new file mode 100644 index 0000000..3bdc8a1 --- /dev/null +++ b/rectangle.h @@ -0,0 +1,17 @@ +#include "forme.h" + +class Rectangle:public Forme{ + private: + int largeur; + int hauteur; + public: + Rectangle(int x, int y, int l, int h); + ~Rectangle(); + int getLargeur(); + int getHauteur(); + Coordonnee getAncrageForme(); + void setLargeur(int l); + void setHauteur(int h); + double getAire(); + void afficher(ostream &s); +}; diff --git a/vecteur.cpp b/vecteur.cpp new file mode 100644 index 0000000..d9a560c --- /dev/null +++ b/vecteur.cpp @@ -0,0 +1,70 @@ +#include "vecteur.h" + +Vecteur::Vecteur(){ + capacite = 1; + taille = 0; + formes = new Forme*[capacite]; +} + +Vecteur::~Vecteur(){ + vider(); + delete[] formes; +} + +bool Vecteur::estVide(){ + return (taille == 0); +}; + +Forme *Vecteur::getForme(int index){ + return (index < 0 || index >= taille) ? NULL : formes[index]; +}; + +int Vecteur::getTaille(){ + return taille; +}; + +void Vecteur::afficher(ostream &s){ + for (int i = 0; i < taille; i++) { + formes[i]->afficher(s); + } +}; + +bool Vecteur::ajouterForme(Forme *f) { + if (taille == capacite) { + // Double the size of the array + int newCapacite = capacite * 2; + Forme **newFormes = new (nothrow) Forme*[newCapacite]; + if(newFormes==nullptr) return false; + for (int i = 0; i < taille; i++) { + newFormes[i] = formes[i]; + } + capacite = newCapacite; + delete[] formes; + formes = newFormes; + } + formes[taille] = f; + taille++; + return true; +}; + +Forme *Vecteur::supprimerForme(int index) { + Forme *f = formes[index]; + while (index < taille) { + formes[index] = formes[index + 1]; + index++; + } + formes[taille] = NULL; + taille--; + return f; +}; + +void Vecteur::vider() { + for (int i = 0; i < taille; i++) { + delete formes[i]; + } + capacite = 1; + taille = 0; + Forme **newFormes = new Forme*[capacite]; + delete[] formes; + formes = newFormes; +} diff --git a/vecteur.h b/vecteur.h new file mode 100644 index 0000000..58843f7 --- /dev/null +++ b/vecteur.h @@ -0,0 +1,39 @@ +#include +#include "forme.h" + +using namespace std; + +// - [x] Items stockés sont des pointeurs de Forme +// - [ ] Items toujours contigus en mémoire +// - [ ] connaître la capacité maximale du vecteur +// - [ ] connaître la taille courante du vecteur +// - [ ] Lorsqu'il manque d'espace pour ajouter une forme, +// le vecteur double sa capacité +// - [ ] vider le vecteur en un seul appel +// - [ ] lorsque le vecteur est vidé, détruire ses formes +// - [ ] savoir si le vecteur est vide (bool) +// - [ ] ajouter une forme à la fin du vecteur (true si ok) +// - [ ] supprimer une forme à un index (retourne la forme) NULL on error +// - [ ] récupérer une forme à un index (retourne la forme) NULL on error +// - [ ] afficher le vecteur en utilisant Forme::afficher() + +class Vecteur { + private: + int capacite; // capacité maximale actuelle du vecteur + int taille; + // dynamic array of pointers to Forme + Forme **formes; + public: + Vecteur(); + ~Vecteur(); + // Informations + bool estVide(); + Forme *getForme(int index); + int getTaille(); + void afficher(ostream &s); + // Manipulations + bool ajouterForme(Forme *f); + Forme *supprimerForme(int index); + void vider(); +}; + -- cgit v1.2.3 From 3fb8effa3603e9a9b96d263009fc1397433436ba Mon Sep 17 00:00:00 2001 From: Benjamin Chausse Date: Fri, 13 Jan 2023 02:34:01 -0500 Subject: Tout sauf les tests --- .gitignore | 1 + canevas.cpp | 76 ++++++++++++++++++++++++++++++++++++++++++++++++----------- canevas.h | 4 ++-- carre.cpp | 2 +- carre.h | 5 ++++ cercle.cpp | 4 ++-- cercle.h | 7 +++++- couche.cpp | 70 +++++++++++++++++++++++++++++++++++++++++++++++++++++- couche.h | 30 ++++++++++++++++++++--- rectangle.cpp | 4 ++-- rectangle.h | 7 +++++- tests.h | 5 ++++ vecteur.cpp | 50 +++++++++++++++++++-------------------- vecteur.h | 18 ++++---------- 14 files changed, 217 insertions(+), 66 deletions(-) (limited to 'rectangle.cpp') diff --git a/.gitignore b/.gitignore index 7aa28f5..41dc0ab 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,7 @@ *.out *.o *.obj +graphicus-* # Ctags: tags diff --git a/canevas.cpp b/canevas.cpp index bc7a0e5..1010ea6 100644 --- a/canevas.cpp +++ b/canevas.cpp @@ -9,38 +9,86 @@ #include "canevas.h" Canevas::Canevas() { + Couche couches[MAX_COUCHES]; + for (int i = 0; i < MAX_COUCHES; i++) { + couches[i] = Couche(); + }; + couches[0].changerEtat(STATE_ACTIVE); } Canevas::~Canevas() { + reinitialiser(); } bool Canevas::reinitialiser() { - return true; + for (int i = 0; i < MAX_COUCHES; i++) { + if (!couches[i].reinitialiser()) { + return false; + } + } + return true; } bool Canevas::activerCouche(int index) { - return true; -} + if (index < 0 || index >= MAX_COUCHES) + return false; + for (int i = 0; i < MAX_COUCHES; i++) { + if (couches[i].getEtat() == STATE_ACTIVE) { + couches[i].changerEtat(STATE_INACTIVE); + }; + }; + return couches[index].changerEtat(STATE_ACTIVE); +}; bool Canevas::cacherCouche(int index) { - return true; -} + if (index < 0 || index >= MAX_COUCHES) + return false; + couches[index].changerEtat(STATE_INACTIVE); + return true; +}; bool Canevas::ajouterForme(Forme *p_forme) { - return true; -} + int active = -1; + for (int i = 0; i < MAX_COUCHES; i++) + active = (couches[i].getEtat() == STATE_ACTIVE) ? i : active; + if (active == -1) + return false; + return couches[active].ajouterForme(p_forme); +}; bool Canevas::retirerForme(int index) { - return true; -} + int active = -1; + for (int i = 0; i < MAX_COUCHES; i++) + active = (couches[i].getEtat() == STATE_ACTIVE) ? i : active; + if (active == -1) + return false; + if (couches[active].supprimerForme(index)==NULL) + return false; + return true; +}; double Canevas::aire() { - return 0.0; -} + double aire = 0; + for (int i = 0; i < MAX_COUCHES; i++) { + if (couches[i].getEtat() == STATE_ACTIVE) { + aire += couches[i].aire(); + }; + }; + return aire; +}; bool Canevas::translater(int deltaX, int deltaY) { - return true; -} + int active = -1; + for (int i = 0; i < MAX_COUCHES; i++) + active = (couches[i].getEtat() == STATE_ACTIVE) ? i : active; + if (active == -1) + return false; + return couches[active].translater(deltaX, deltaY); +}; void Canevas::afficher(ostream & s) { -} + for (int i = 0; i < MAX_COUCHES; i++) { + s << "----- Couche " << i << "\n"; + couches[i].afficher(s); + }; +}; diff --git a/canevas.h b/canevas.h index 21ed457..1833e52 100644 --- a/canevas.h +++ b/canevas.h @@ -7,8 +7,8 @@ * Ce fichier fait partie de la distribution de Graphicus. ********/ -#ifndef DESSIN_H -#define DESSIN_H +#ifndef __DESSIN_H__ +#define __DESSIN_H__ #include #include "forme.h" diff --git a/carre.cpp b/carre.cpp index 1d0ad44..627eb91 100644 --- a/carre.cpp +++ b/carre.cpp @@ -10,6 +10,6 @@ void Carre::afficher(ostream &s) { s << "Carre(x=" << getAncrage().x << ", y=" << getAncrage().y << ", c=" << getLargeur() - << ", a=" << getAire() + << ", a=" << aire() << ")\n"; }; diff --git a/carre.h b/carre.h index 80b9d57..d986f7f 100644 --- a/carre.h +++ b/carre.h @@ -1,3 +1,6 @@ +#ifndef __CARRE_H__ +#define __CARRE_H__ + #include "rectangle.h" class Carre : public Rectangle { @@ -6,3 +9,5 @@ public: ~Carre(); void afficher(ostream &s); }; + +#endif diff --git a/cercle.cpp b/cercle.cpp index 4747258..d2e7f61 100644 --- a/cercle.cpp +++ b/cercle.cpp @@ -18,7 +18,7 @@ int Cercle::getRayon() { return rayon; }; -double Cercle::getAire() { +double Cercle::aire() { return M_PI*pow(rayon,2); }; @@ -30,5 +30,5 @@ void Cercle::afficher(ostream & s) { s << "Cercle (x=" << getAncrage().x << ", y=" << getAncrage().y << ", r=" << getRayon() - << ", aire=" << getAire() << ")\n"; + << ", aire=" << aire() << ")\n"; }; diff --git a/cercle.h b/cercle.h index d3eca66..c4a5923 100644 --- a/cercle.h +++ b/cercle.h @@ -1,3 +1,6 @@ +#ifndef __CERCLE_H__ +#define __CERCLE_H__ + #include "forme.h" class Cercle:Forme { @@ -8,7 +11,9 @@ class Cercle:Forme { ~Cercle(); void setRayon(int r); int getRayon(); - double getAire(); + double aire(); double getPerimetre(); void afficher(ostream & s); }; + +#endif diff --git a/couche.cpp b/couche.cpp index 07c4418..9273031 100644 --- a/couche.cpp +++ b/couche.cpp @@ -8,4 +8,72 @@ #include "couche.h" -// Implementation a faire... +Couche::Couche() { + state = STATE_INIT; + vecteur = Vecteur(); +}; + +Couche::~Couche() { + vecteur.vider(); +}; + +int Couche::getEtat() { + return state; +}; + +Forme *Couche::getForme(int index) { + return vecteur.getForme(index); +}; + +double Couche::aire() { + double aire = 0; + for (int i = 0; i < vecteur.getTaille(); i++) { + aire += vecteur.getForme(i)->aire(); + }; + return aire; +}; + +void Couche::afficher(ostream &s) { + if (state == STATE_INIT) { + s << "Couche initialisée\n"; + } else { + vecteur.afficher(s); + }; +}; + +bool Couche::changerEtat(int newState) { + if (state == STATE_INIT) return false; + state = newState; + return true; +}; + +bool Couche::translater(int deltaX, int deltaY) { + if (state != STATE_ACTIVE) return false; + for (int i = 0; i < vecteur.getTaille(); i++) + vecteur.getForme(i)->translater(deltaX, deltaY); + return true; +}; + +bool Couche::ajouterForme(Forme *f) { + int initialState = getEtat(); + if (initialState == STATE_INACTIVE) return false; + bool success = vecteur.ajouterForme(f); + if (success) { + changerEtat(STATE_ACTIVE); + }; + return success; +}; + +Forme *Couche::supprimerForme(int index) { + if (state != STATE_ACTIVE) return NULL; + return vecteur.supprimerForme(index); +}; + +bool Couche::reinitialiser() { + if (state == STATE_INIT) return false; + state = STATE_INIT; + vecteur.vider(); + return true; +}; + + diff --git a/couche.h b/couche.h index 32cba2f..dc82e01 100644 --- a/couche.h +++ b/couche.h @@ -8,11 +8,35 @@ * Ce fichier fait partie de la distribution de Graphicus. ********/ -#ifndef COUCHE_H -#define COUCHE_H +#ifndef __COUCHE_H__ +#define __COUCHE_H__ + +#define STATE_INIT 0 // Couche initialisee mais vide +#define STATE_ACTIVE 1 // Couche active (peut-etre modifiee) +#define STATE_INACTIVE 2 // Couche inactive (non modifiable) + +#include "vecteur.h" class Couche { - // Classe a completer + private: + int state; + Vecteur vecteur; + public: + // Initialisation + Couche(); + ~Couche(); + // Informations + int getEtat(); + Forme *getForme(int index); + double aire(); + void afficher(ostream &s); + // Modifications + bool changerEtat(int newState); + bool translater(int deltaX, int deltaY); + bool ajouterForme(Forme *f); + Forme *supprimerForme(int index); + bool reinitialiser(); + }; #endif diff --git a/rectangle.cpp b/rectangle.cpp index 239ea81..f1d23da 100644 --- a/rectangle.cpp +++ b/rectangle.cpp @@ -30,7 +30,7 @@ void Rectangle::setHauteur(int h){ hauteur=h; }; -double Rectangle::getAire(){ +double Rectangle::aire(){ return largeur*hauteur; }; @@ -39,6 +39,6 @@ void Rectangle::afficher(ostream &s){ << ", y=" << getAncrageForme().y << ", l=" << getLargeur() << ", h=" << getHauteur() - << ", aire=" << getAire() + << ", aire=" << aire() << ")\n"; }; diff --git a/rectangle.h b/rectangle.h index 3bdc8a1..0c85119 100644 --- a/rectangle.h +++ b/rectangle.h @@ -1,3 +1,6 @@ +#ifndef __RECTANGLE_H__ +#define __RECTANGLE_H__ + #include "forme.h" class Rectangle:public Forme{ @@ -12,6 +15,8 @@ class Rectangle:public Forme{ Coordonnee getAncrageForme(); void setLargeur(int l); void setHauteur(int h); - double getAire(); + double aire(); void afficher(ostream &s); }; + +#endif diff --git a/tests.h b/tests.h index 3397fb9..aefc8d0 100644 --- a/tests.h +++ b/tests.h @@ -7,6 +7,9 @@ * fait partie de la distribution de Graphicus. ********/ +#ifndef __TESTS_H__ +#define __TESTS_H__ + #include #include "canevas.h" @@ -26,3 +29,5 @@ public: void tests_application_cas_02(); void tests_application(); // Appel de tous les tests applicatifs }; + +#endif diff --git a/vecteur.cpp b/vecteur.cpp index d9a560c..2fd3589 100644 --- a/vecteur.cpp +++ b/vecteur.cpp @@ -24,38 +24,38 @@ int Vecteur::getTaille(){ }; void Vecteur::afficher(ostream &s){ - for (int i = 0; i < taille; i++) { - formes[i]->afficher(s); - } + for (int i = 0; i < taille; i++) { + formes[i]->afficher(s); + } }; bool Vecteur::ajouterForme(Forme *f) { - if (taille == capacite) { - // Double the size of the array - int newCapacite = capacite * 2; - Forme **newFormes = new (nothrow) Forme*[newCapacite]; - if(newFormes==nullptr) return false; - for (int i = 0; i < taille; i++) { - newFormes[i] = formes[i]; - } - capacite = newCapacite; - delete[] formes; - formes = newFormes; + if (taille == capacite) { + // Double the size of the array + int newCapacite = capacite * 2; + Forme **newFormes = new (nothrow) Forme*[newCapacite]; + if(newFormes==nullptr) return false; + for (int i = 0; i < taille; i++) { + newFormes[i] = formes[i]; } - formes[taille] = f; - taille++; - return true; + capacite = newCapacite; + delete[] formes; + formes = newFormes; + } + formes[taille] = f; + taille++; + return true; }; Forme *Vecteur::supprimerForme(int index) { - Forme *f = formes[index]; - while (index < taille) { - formes[index] = formes[index + 1]; - index++; - } - formes[taille] = NULL; - taille--; - return f; + Forme *f = formes[index]; + while (index < taille) { + formes[index] = formes[index + 1]; + index++; + } + formes[taille] = NULL; + taille--; + return f; }; void Vecteur::vider() { diff --git a/vecteur.h b/vecteur.h index 58843f7..e451974 100644 --- a/vecteur.h +++ b/vecteur.h @@ -1,22 +1,11 @@ +#ifndef __VECTEUR_H__ +#define __VECTEUR_H__ + #include #include "forme.h" using namespace std; -// - [x] Items stockés sont des pointeurs de Forme -// - [ ] Items toujours contigus en mémoire -// - [ ] connaître la capacité maximale du vecteur -// - [ ] connaître la taille courante du vecteur -// - [ ] Lorsqu'il manque d'espace pour ajouter une forme, -// le vecteur double sa capacité -// - [ ] vider le vecteur en un seul appel -// - [ ] lorsque le vecteur est vidé, détruire ses formes -// - [ ] savoir si le vecteur est vide (bool) -// - [ ] ajouter une forme à la fin du vecteur (true si ok) -// - [ ] supprimer une forme à un index (retourne la forme) NULL on error -// - [ ] récupérer une forme à un index (retourne la forme) NULL on error -// - [ ] afficher le vecteur en utilisant Forme::afficher() - class Vecteur { private: int capacite; // capacité maximale actuelle du vecteur @@ -37,3 +26,4 @@ class Vecteur { void vider(); }; +#endif -- cgit v1.2.3 From d0bde3c60fa911ac0bb0f71ce2a6a963c874392e Mon Sep 17 00:00:00 2001 From: Benjamin Chausse Date: Fri, 13 Jan 2023 14:52:41 -0500 Subject: Everything works before validation --- canevas.cpp | 15 ++- canevas.h | 1 + carre.h | 2 +- cercle.cpp | 2 - cercle.h | 4 +- config.mk | 11 -- couche.cpp | 25 ++--- couche.h | 7 ++ graphicus-02.cpp | 8 +- makefile | 33 +++--- rectangle.cpp | 4 +- rectangle.h | 2 +- tests.cpp | 317 ++++++++++++++++++++++++++++++++++++++++++++++++++----- tests.h | 4 + vecteur.cpp | 4 + vecteur.h | 1 + 16 files changed, 359 insertions(+), 81 deletions(-) delete mode 100644 config.mk (limited to 'rectangle.cpp') diff --git a/canevas.cpp b/canevas.cpp index 1010ea6..0c203fc 100644 --- a/canevas.cpp +++ b/canevas.cpp @@ -10,9 +10,9 @@ Canevas::Canevas() { Couche couches[MAX_COUCHES]; - for (int i = 0; i < MAX_COUCHES; i++) { - couches[i] = Couche(); - }; + /* for (int i = 0; i < MAX_COUCHES; i++) { */ + /* couches[i] = Couche(); */ + /* }; */ couches[0].changerEtat(STATE_ACTIVE); } @@ -70,9 +70,7 @@ bool Canevas::retirerForme(int index) { double Canevas::aire() { double aire = 0; for (int i = 0; i < MAX_COUCHES; i++) { - if (couches[i].getEtat() == STATE_ACTIVE) { aire += couches[i].aire(); - }; }; return aire; }; @@ -92,3 +90,10 @@ void Canevas::afficher(ostream & s) { couches[i].afficher(s); }; }; + +bool Canevas::reinitialiserCouche(int index) { + if (index < 0 || index >= MAX_COUCHES){ + return false; + }; + return couches[index].reinitialiser(); +}; diff --git a/canevas.h b/canevas.h index 1833e52..64b833a 100644 --- a/canevas.h +++ b/canevas.h @@ -34,6 +34,7 @@ public: double aire(); bool translater(int deltaX, int deltaY); void afficher(ostream & s); + bool reinitialiserCouche(int index); private: Couche couches[MAX_COUCHES]; diff --git a/carre.h b/carre.h index d986f7f..bf1cc84 100644 --- a/carre.h +++ b/carre.h @@ -5,7 +5,7 @@ class Carre : public Rectangle { public: - Carre(int x, int y, int cote); + Carre(int x=0, int y=0, int cote=1); ~Carre(); void afficher(ostream &s); }; diff --git a/cercle.cpp b/cercle.cpp index d2e7f61..bd3c876 100644 --- a/cercle.cpp +++ b/cercle.cpp @@ -2,8 +2,6 @@ #include Cercle::Cercle(int x, int y, int r):Forme(x,y) { - Coordonnee xy = {x,y}; - setAncrage(xy); setRayon(r); }; diff --git a/cercle.h b/cercle.h index c4a5923..1254193 100644 --- a/cercle.h +++ b/cercle.h @@ -3,11 +3,11 @@ #include "forme.h" -class Cercle:Forme { +class Cercle:public Forme { private: int rayon; public: - Cercle(int x, int y, int r); + Cercle(int x=0, int y=0, int r=1); ~Cercle(); void setRayon(int r); int getRayon(); diff --git a/config.mk b/config.mk deleted file mode 100644 index adcbe37..0000000 --- a/config.mk +++ /dev/null @@ -1,11 +0,0 @@ - -SHELL = /bin/bash - -# c++ compiler flags that are used for all targets: -# they make binaries faster and smaller -# -s : strips the binary -# -O3 : optimizes the binary -# -Ofast : optimizes the binary -# -march=native : optimizes the binary for the current CPU -# -flto : link time optimization -CFLAGS = -Ofast -march=native -flto -s diff --git a/couche.cpp b/couche.cpp index 9273031..b84cc73 100644 --- a/couche.cpp +++ b/couche.cpp @@ -10,7 +10,7 @@ Couche::Couche() { state = STATE_INIT; - vecteur = Vecteur(); + Vecteur vecteur; }; Couche::~Couche() { @@ -42,9 +42,11 @@ void Couche::afficher(ostream &s) { }; bool Couche::changerEtat(int newState) { - if (state == STATE_INIT) return false; - state = newState; - return true; + if ( newState>=STATE_INIT && newState<=STATE_INACTIVE ) { + state = newState; + return true; + }; + return false; }; bool Couche::translater(int deltaX, int deltaY) { @@ -55,17 +57,16 @@ bool Couche::translater(int deltaX, int deltaY) { }; bool Couche::ajouterForme(Forme *f) { - int initialState = getEtat(); - if (initialState == STATE_INACTIVE) return false; - bool success = vecteur.ajouterForme(f); - if (success) { - changerEtat(STATE_ACTIVE); - }; - return success; + if (state != STATE_ACTIVE) return false; + return vecteur.ajouterForme(f); }; Forme *Couche::supprimerForme(int index) { - if (state != STATE_ACTIVE) return NULL; + if (state != STATE_ACTIVE) { + return NULL; + } else { + return vecteur.supprimerForme(index); + }; return vecteur.supprimerForme(index); }; diff --git a/couche.h b/couche.h index dc82e01..4ef44a2 100644 --- a/couche.h +++ b/couche.h @@ -39,4 +39,11 @@ class Couche { }; +static const char* const STATES[] = { + "initialisee", + "actif", + "inactif" +}; + + #endif diff --git a/graphicus-02.cpp b/graphicus-02.cpp index b01b3a9..d42dd8f 100644 --- a/graphicus-02.cpp +++ b/graphicus-02.cpp @@ -10,9 +10,11 @@ using namespace std; int main() { - Tests tests; + Tests tests; - tests.tests_application(); - return 0; + /* tests.tests_unitaires(); */ + tests.tests_application_cas_01(); + + return 0; } diff --git a/makefile b/makefile index db6d4eb..5b05003 100644 --- a/makefile +++ b/makefile @@ -7,49 +7,48 @@ ALL := graphicus-02.o tests.o canevas.o couche.o forme.o vecteur.o cercle.o rectangle.o carre.o +CFLAGS := -flto -Ofast -march=native -include config.mk +# graphicus-02: $(ALL) +# g++ $(CFLAGS) -o $@ $^ && strip $@ $^ graphicus-02: $(ALL) - g++ ${CFLAGS} -o $@ $^ && strip $@ $^ - -# graphicus-02: $(ALL) -# g++ ${CFLAGS} -o $@ $^ + g++ $(CFLAGS) -o $@ $^ tests.o: tests.cpp tests.h canevas.h couche.h forme.h - g++ ${CFLAGS} -c tests.cpp + g++ $(CFLAGS) -c tests.cpp canevas.o: canevas.cpp canevas.h couche.h forme.h - g++ ${CFLAGS} -c canevas.cpp + g++ $(CFLAGS) -c canevas.cpp couche.o: couche.cpp couche.h forme.h - g++ ${CFLAGS} -c couche.cpp + g++ $(CFLAGS) -c couche.cpp forme.o: forme.cpp forme.h - g++ ${CFLAGS} -c forme.cpp + g++ $(CFLAGS) -c forme.cpp vecteur.o: vecteur.cpp vecteur.h coordonnee.h - g++ ${CFLAGS} -c vecteur.cpp + g++ $(CFLAGS) -c vecteur.cpp rectangle.o: rectangle.cpp rectangle.h forme.h - g++ ${CFLAGS} -c rectangle.cpp + g++ $(CFLAGS) -c rectangle.cpp carre.o: carre.cpp carre.h rectangle.h forme.h - g++ ${CFLAGS} -c carre.cpp + g++ $(CFLAGS) -c carre.cpp cercle.o: cercle.cpp cercle.h forme.h - g++ ${CFLAGS} -c cercle.cpp + g++ $(CFLAGS) -c cercle.cpp graphicus-02.o: graphicus-02.cpp canevas.h couche.h forme.h - g++ ${CFLAGS} -c graphicus-02.cpp + g++ $(CFLAGS) -c graphicus-02.cpp clean: rm -f *.o options: @echo "Option de compilation de GRAPHICUS:" - @echo " graphicus-02: Construction de l'executable dans sa totalité" - @echo " clean: Nettoyage des fichiers temporaires '.o'" - @echo " *.o: Construction des fichiers objets" + @echo " graphicus-02: Construction de l'executable dans sa totalité" + @echo " clean: Nettoyage des fichiers temporaires '.o'" + @echo " *.o: Construction des fichiers objets" diff --git a/rectangle.cpp b/rectangle.cpp index f1d23da..a70bfe4 100644 --- a/rectangle.cpp +++ b/rectangle.cpp @@ -1,8 +1,6 @@ #include "rectangle.h" -Rectangle::Rectangle(int x, int y, int w, int h){ - Coordonnee xy = {x, y}; - setAncrage(xy); +Rectangle::Rectangle(int x, int y, int w, int h):Forme(x, y){ setLargeur(w); setHauteur(h); }; diff --git a/rectangle.h b/rectangle.h index 0c85119..59b990b 100644 --- a/rectangle.h +++ b/rectangle.h @@ -8,7 +8,7 @@ class Rectangle:public Forme{ int largeur; int hauteur; public: - Rectangle(int x, int y, int l, int h); + Rectangle(int x=0, int y=0, int l=1, int h=1); ~Rectangle(); int getLargeur(); int getHauteur(); diff --git a/tests.cpp b/tests.cpp index 83bce1c..ffb37c7 100644 --- a/tests.cpp +++ b/tests.cpp @@ -9,42 +9,311 @@ #include "tests.h" +// Tests sur les formes geometriques void Tests::tests_unitaires_formes() { - // Tests sur les formes geometriques -} + cout << "----- Tests des formes geometriques -----\n"; + cout << "\n--- Tests sur le rectangle ---\n"; + + cout << "Initialisation rectangle 3x4 en (1,2): \n\t"; + Rectangle r1(1, 2, 3, 4); + r1.afficher(cout); + + cout << "Translation de (-1,2) pour arriver à (0,4): \n\t"; + r1.translater(-1, 2); + r1.afficher(cout); + + cout << "Initialisation rectangle par defaut (1x1 en (0,0)): \n\t"; + Rectangle r2; + r2.afficher(cout); + cout << "\n"; + + cout << "\n--- Tests sur le carre ---\n"; + + cout << "Initialisation carre de cote=12 en (-2,-2): \n\t"; + Carre cr1(-2, -2, 12); + cr1.afficher(cout); + + cout << "Initialisation carre par defaut (1x1 en (0,0)): \n\t"; + Carre cr2; + cr2.afficher(cout); + cout << "\n"; + + + cout << "\n--- Tests sur le cercle ---\n"; + cout << "Initialisation cercle de rayon 5 en (0,0): \n\t"; + Cercle cc1(0, 0, 5); + cc1.afficher(cout); + + cout << "Initialisation cercle par defaut (rayon=1 en (0,0)): \n\t"; + Cercle cc2; + cc2.afficher(cout); + cout << "\n"; +}; + +// Tests sur la classe Vecteur void Tests::tests_unitaires_vecteur() { - // Tests sur la classe Vecteur -} + cout << "----- Tests de la classe Vecteur -----\n\n"; + + cout << "--- Initialisation d\'un vecteur vide ---"; + Vecteur v1; + cout << "\nVide: " << ((v1.estVide())? "Oui" : "Non") + << "\nTaille: " << v1.getTaille() + << "\nCapacite: " << v1.getCapacite() + << "\nAffichage: {\n"; + v1.afficher(cout); + cout << "}\n\n"; + + cout << "--- Ajout d'une forme (sans redimensionnement) ---"; + v1.ajouterForme(new Rectangle() ); // a=1 + cout << "\nVide: " << ((v1.estVide())? "Oui" : "Non") + << "\nTaille: " << v1.getTaille() + << "\nCapacite: " << v1.getCapacite() + << "\nAffichage: {\n"; + v1.afficher(cout); + cout << "}\n\n"; + + cout << "--- Ajout des autres formes (redimensionnement necessaire) ---"; + v1.ajouterForme( new Rectangle(1, 2, 8, 3) ); + v1.ajouterForme( new Carre(5, 6, 5) ); + v1.ajouterForme( new Cercle(0, 0, 1) ); + v1.ajouterForme( new Rectangle(-1,-1,95,10) ); + cout << "\nTaille: " << v1.getTaille() + << "\nCapacite: " << v1.getCapacite() + << "\nAffichage: {\n"; + v1.afficher(cout); + cout << "}\n\n"; + cout << "--- Suppression de la forme 4 (sans deplacement) ---"; + Forme* f1 = v1.supprimerForme(4); + cout << "\nForme supprimee: "; + f1->afficher(cout); + cout << "Taille: " << v1.getTaille() + << "\nCapacite: " << v1.getCapacite() + << "\nAffichage: {\n"; + v1.afficher(cout); + cout << "}\n"; + + cout << "--- Suppression de la forme 1 (avec deplacement) ---"; + cout << "\nForme supprimee: "; + delete f1; + f1 = v1.supprimerForme(1); + f1->afficher(cout); + cout << "Taille: " << v1.getTaille() + << "\nCapacite: " << v1.getCapacite() + << "\nAffichage: {\n"; + v1.afficher(cout); + cout << "}\n"; + delete f1; + + cout << "--- Reinitialisation du vecteur ---"; + v1.vider(); + cout << "\nVide: " << ((v1.estVide())? "Oui" : "Non") + << "\nTaille: " << v1.getTaille() + << "\nCapacite: " << v1.getCapacite() + << "\nAffichage: {\n"; + v1.afficher(cout); + cout << "}\n"; +}; + +// Tests sur la classe Couche void Tests::tests_unitaires_couche() { - // Tests sur la classe Couche -} + cout << "----- Tests de la classe Couche -----\n"; + + cout << "\n--- Initialisation d'une couche ---"; + Couche c1; + cout << "\nEtat: " << c1.getEtat() + << "\nAffichage: {\n"; + c1.afficher(cout); + cout << "}\n\n"; + + cout << "--- Ajout d'une forme dans une couche initialisée ---"; + cout << "\nReussite: " << ( (c1.ajouterForme(new Carre()))? "Oui":"Non") + << "\nEtat: " << STATES[c1.getEtat()] + << "\nAffichage: {\n"; + c1.afficher(cout); + cout << "}\n\n"; + + + cout << "--- Changement de l\'etat de la couche (inactif) ---"; + cout << "\nReussite: " << (c1.changerEtat(STATE_INACTIVE)?"Oui":"Non") + << "\nEtat: " << STATES[c1.getEtat()] + << "\nAffichage: {\n"; + c1.afficher(cout); + cout << "}\n\n"; + + cout << "--- Ajout d'une forme dans une couche active ---"; + c1.changerEtat(STATE_ACTIVE); + cout << "\nReussite: " << (c1.ajouterForme(new Carre())? "Oui":"Non") + << "\nEtat: " << STATES[c1.getEtat()] + << "\nAffichage: {\n"; + c1.afficher(cout); + cout << "}\n\n"; + + cout << "--- Changement pour un etat invalide (ex: 3) ---"; + cout << "\nReussite: " << (c1.changerEtat(STATE_INACTIVE+1)?"Oui":"Non") + << "\nEtat: " << STATES[c1.getEtat()] + << "\nAffichage: {\n"; + c1.afficher(cout); + cout << "}\n\n"; + + cout << "--- Suppression d'une forme dans une couche inactive ---"; + c1.changerEtat(STATE_INACTIVE); + cout << "\nReussite: " << ((c1.supprimerForme(0) != NULL)? "Oui":"Non") + << "\nEtat: " << STATES[c1.getEtat()] + << "\nAffichage: {\n"; + c1.afficher(cout); + cout << "}\n\n"; + + cout << "--- Translation d'une couche inactive (1,2) ---"; + cout << "\nReussite: " << (c1.translater(1, 2)?"Oui":"Non") + << "\nEtat: " << STATES[c1.getEtat()] + << "\nAffichage: {\n"; + c1.afficher(cout); + cout << "}\n\n"; + + cout << "--- Translation d'une couche active (1,2) ---"; + c1.changerEtat(STATE_ACTIVE); + cout << "\nReussite: " << (c1.translater(1, 2)?"Oui":"Non") + << "\nEtat: " << STATES[c1.getEtat()] + << "\nAffichage: {\n"; + c1.afficher(cout); + cout << "}\n\n"; + cout << "--- Suppression d'une forme dans une couche active ---"; + cout << "\nReussite: " << ((c1.supprimerForme(0) != NULL)? "Oui":"Non") + << "\nEtat: " << STATES[c1.getEtat()] + << "\nAffichage: {\n"; + c1.afficher(cout); + cout << "}\n\n"; + + cout << "--- Reinitialisation de la couche ---"; + c1.reinitialiser(); + cout << "\nEtat: " << STATES[c1.getEtat()] + << "\nAffichage: {\n"; + c1.afficher(cout); + cout << "}\n\n"; + + + +}; + +// Tests sur la classe Canevas void Tests::tests_unitaires_canevas() { - // Tests sur la classe Canevas -} +}; void Tests::tests_unitaires() { - // Fait tous les tests unitaires - tests_unitaires_formes(); - tests_unitaires_vecteur(); - tests_unitaires_couche(); - tests_unitaires_canevas(); -} + // Fait tous les tests unitaires + tests_unitaires_formes(); + tests_unitaires_vecteur(); + tests_unitaires_couche(); + tests_unitaires_canevas(); +}; void Tests::tests_application() { - // Fait tous les tests applicatifs - tests_application_cas_01(); - tests_application_cas_02(); -} + // Fait tous les tests applicatifs + tests_application_cas_01(); + tests_application_cas_02(); +}; void Tests::tests_application_cas_01() { - cout << "TESTS APPLICATION (CAS 01)" << endl; - // Il faut ajouter les operations realisant ce scenario de test. -} + // Mise en place + int etape = 1; + Canevas c; + + cout << "TESTS APPLICATION (CAS 01)" << endl; + // Il faut ajouter les operations realisant ce scenario de test. + // + cout << "Etape " << etape++ + << ": Activation de la couche 1" << endl; + c.activerCouche(1); + + cout << "Etape " << etape++ + << ": Ajout des trois formes géométriques suivantes" << endl; + cout << "\t* Un rectangle (x=0, y=0, largeur=2, hauteur=3)" << endl; + c.ajouterForme(new Rectangle(0,0,2,3)); + cout << "\t* Un carré (x=2, y=3, cote=4)" << endl; + c.ajouterForme(new Carre(2,3,4)); + cout << "\t* Un cercle (x=7, y=8, rayon=6)" << endl; + c.ajouterForme(new Cercle(7,8,6)); + + cout << "Etape " << etape++ + << ": Activer la couche 2" << endl; + c.activerCouche(2); + + cout << "Etape " << etape++ + << ": Ajouter la forme géométrique suivante" << endl; + cout << "\t* Un rectangle (x=0, y=0, largeur=4, hauteur=5)" << endl; + c.ajouterForme(new Rectangle(0,0,4,5)); + + cout << "Etape " << etape++ + << ": Afficher le canevas" << endl; + c.afficher(cout); + + cout << "Etape " << etape++ + << ": Afficher l'aire du canevas" << endl; + cout << "\t* Aire du canevas: " << c.aire() << endl; + + cout << "Etape " << etape++ + << ": Activer la couche 0" << endl; + c.activerCouche(0); + + cout << "Etape " << etape++ + << ": Ajouter les trois formes géométriques suivantes" << endl; + cout << "\t* Un rectangle (x=0, y=0, largeur=1, hauteur=1)" << endl; + c.ajouterForme(new Rectangle()); + cout << "\t* Un carré (x=0, y=0, cote=1)" << endl; + c.ajouterForme(new Carre()); + cout << "\t* Un cercle (x=0, y=0, rayon=1)" << endl; + c.ajouterForme(new Cercle()); + + cout << "Etape " << etape++ + << ": Couche 2 - initialisée" << endl; + c.reinitialiserCouche(2); + + cout << "Etape " << etape++ + << ": Couche 3 - initialisée" << endl; + c.reinitialiserCouche(3); + + cout << "Etape " << etape++ + << ": Couche 4 - initialisée" << endl; + c.reinitialiserCouche(4); + + cout << "Etape " << etape++ + << ": Afficher le canevas" << endl; + c.afficher(cout); + + cout << "Etape " << etape++ + << ": Afficher l'aire du canevas" << endl; + + cout << "Etape " << etape++ + << ": Retirer la première forme de la couche 1" << endl; + c.activerCouche(1); + c.retirerForme(0); + + cout << "Etape " << etape++ + << ": Afficher le canevas" << endl; + c.afficher(cout); + + cout << "Etape " << etape++ + << ": Afficher l'aire du canevas" << endl; + cout << "\t* Aire du canevas: " << c.aire() << endl; + + cout << "Etape " << etape++ + << ": Réinitialiser le canevas" << endl; + c.reinitialiser(); + + cout << "Etape " << etape++ + << ": Afficher le canevas" << endl; + c.afficher(cout); + + cout << "Etape " << etape++ + << ": Afficher l'aire du canevas" << endl; + cout << "\t* Aire du canevas: " << c.aire() << endl; + +}; void Tests::tests_application_cas_02() { - cout << "TESTS APPLICATION (CAS 02)" << endl; - // Il faut ajouter les operations realisant ce scenario de test. -} + cout << "TESTS APPLICATION (CAS 02)" << endl; + // Il faut ajouter les operations realisant ce scenario de test. +}; diff --git a/tests.h b/tests.h index aefc8d0..73aaaad 100644 --- a/tests.h +++ b/tests.h @@ -12,6 +12,10 @@ #include #include "canevas.h" +#include "forme.h" +#include "rectangle.h" +#include "carre.h" +#include "cercle.h" using namespace std; diff --git a/vecteur.cpp b/vecteur.cpp index 2fd3589..56b59ed 100644 --- a/vecteur.cpp +++ b/vecteur.cpp @@ -23,6 +23,10 @@ int Vecteur::getTaille(){ return taille; }; +int Vecteur::getCapacite(){ + return capacite; +}; + void Vecteur::afficher(ostream &s){ for (int i = 0; i < taille; i++) { formes[i]->afficher(s); diff --git a/vecteur.h b/vecteur.h index e451974..de5e163 100644 --- a/vecteur.h +++ b/vecteur.h @@ -19,6 +19,7 @@ class Vecteur { bool estVide(); Forme *getForme(int index); int getTaille(); + int getCapacite(); void afficher(ostream &s); // Manipulations bool ajouterForme(Forme *f); -- cgit v1.2.3