À mon tour !

avis et conseil :)

a marqué ce sujet comme résolu.

Bonjour / bonsoir !

Suite aux nombreuses tentatives recentes sur cette exo , c'est maintenant a mon tour de m'y mettre :) J'ai fini la partie 1.1 ( aquarium / poisson / algue ).

Voici mon code , j'essaie le plus possible d'utiliser les nouveaux outils mis a notre disposition avec le c++14.

main.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
#include <iostream>
#include "Aquarium.hpp"

int main()
{
    Aquarium aq{};
    aq.ajouter_algue();
    aq.ajouter_algue();
    aq.ajouter_poisson(std::make_unique<Poisson>("Sonia", Sexe::FEMALE));
    aq.ajouter_poisson(std::make_unique<Poisson>("Michael",Sexe::MALE));

    aq.passer_temps();

    return 0;
}

Poisson.hpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#ifndef POISSON_HPP
#define POISSON_HPP

#include <string>
#include "Semantique.hpp"

enum class Sexe{MALE,FEMALE};
enum class Etat{VIVANT,MORT};

class Poisson : private no_copy
{
public:
    Poisson(const std::string & nom , Sexe sexe ) : nom_(nom),sexe_{sexe},etat_{Etat::VIVANT}{};
    ~Poisson(){};

    const std::string & nom(){return nom_;};
    std::string sexe(){return (sexe_ == Sexe::FEMALE) ? "Femelle" : "Male";};
private:
    std::string nom_;
    Sexe sexe_;
    Etat etat_;
};

#endif // POISSON_HPP

Algue.hpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
#ifndef ALGUE__HPP
#define ALGUE_HPP

#include "Semantique.hpp"

class Algue : private no_copy
{
    public:
        Algue():etat_{Etat::VIVANT}{};
        ~Algue(){};

    private:
        Etat etat_;
};

#endif // ALGUE__HPP

Aquarium.hpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#ifndef AQUARIUM_HPP
#define AQUARIUM_HPP

#include <vector>
#include <memory>
#include <iostream>

#include "Poisson.hpp"
#include "Algue.hpp"

class Aquarium : private no_copy
{
    public:
        Aquarium(){};
        ~Aquarium(){};

        void ajouter_poisson( std::unique_ptr<Poisson> p )
        {
            Poissons_.push_back( std::move(p) );
        }

        void ajouter_algue()
        {
            Algues_.push_back( std::make_unique<Algue>() );
        }

        void passer_temps()
        {
            Tour_++;

            std::cout<<"Tour #" <<tour_ <<std::endl <<std::endl;
            std::cout<<"Algues : " <<Algues_.size() <<std::endl;
            std::cout<<"Poissons : " <<Poissons_.size() <<std::endl;

            for(const auto & p : Poissons_)
                std::cout<<"- " <<p->nom() <<" : " <<p->sexe() <<std::endl;

            std::cout<<"===============================================" <<std::endl;
        }

    private:
        std::vector<std::unique_ptr<Poisson>> Poissons_;
        std::vector<std::unique_ptr<Algue>> Algues_;

        unsigned int Tour_{0};
};

Semantique.hpp ( classe non copiable )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#ifndef SEMANTIQUE_HPP
#define SEMANTIQUE_HPP

class no_copy
{
    public:
        no_copy(const no_copy &) = delete;
        no_copy & operator=(const no_copy &) = delete;

    protected:
        no_copy(){};
};

#endif // SEMANTIQUE_HPP

Merci de prendre le temps de lire :)

+0 -0

Regardes les discussions sur OpenClassRoom de Deedolith et AurelieT1 (et bientot dragonjoker). Certaines remarques s'appliquent a toi :

  • move absente de no_copy
  • utilisation de = default
  • manque de const
  • initialisation des membres lors de la declaration
  • pas besoin de pointeurs a ce stade de l'exo

Ce sont des remarques purement syntaxiques, je n'ai pas regarde la conception.

+0 -0

Regardes les discussions sur OpenClassRoom de Deedolith et AurelieT1 (et bientot dragonjoker). Certaines remarques s'appliquent a toi :

  • move absente de no_copy
  • utilisation de = default
  • manque de const
  • initialisation des membres lors de la declaration
  • pas besoin de pointeurs a ce stade de l'exo

Ce sont des remarques purement syntaxiques, je n'ai pas regarde la conception.

gbdivers

Merci de ta réponse !

move absente de no_copy : Je suis aller lire le petit tuto d'introduction a la move semantique sur ce site. Si je comprend bien je dois aussi définir la move dans ma classe de base no_copy ( all or nothing ). Mon objet n'est pas copiable mais est déplacable.

utilisation de = default : Sur les constructeur par défaut ? Ceci explicite le constructeur par défaut ?

manque de const : Ouais .. c'est un concepte que j'ai pas trop étudier .. tu peut me référer vers un article pouvant m'eclairer sur ou / pourquoi ?

initialisation des membres lors de la declaration : Noté , merci !

pas besoin de pointeurs a ce stade de l'exo : A ce stade peut-etre pas , mais ta formulation me confirme que probablement que j'aurai a en utilisé futurement en continuant l'exercice ( par exemple pour differencier les poisson carnivores et les poissons herbivore .. ) , alors pourquoi pas l'utiliser maintenant ?

Merci encore de tes remarques , je posterai bientot le code avec ces corrections + la partie 1.2

+0 -0

Voici le nouveau code .. - plus de const ( dites moi si j'en ai manqué … ) - move et =default dans no_copy

Partie 1.2 : Poissons herbivores et Poissons carnivores

main.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
#include <iostream>
#include "Aquarium.hpp"

int main()
{
    Aquarium aq{};

    aq.ajouter_poisson(std::make_unique<PoissonCarnivore>("Sonia",Poisson::Sexe::FEMALE,Poisson::Race::REQUIN));
    aq.ajouter_poisson(std::make_unique<PoissonHerbivore>("Michael",Poisson::Sexe::MALE,Poisson::Race::REQUIN));
    aq.ajouter_algue(std::make_unique<Algue>());
    aq.ajouter_algue(std::make_unique<Algue>());
    aq.ajouter_algue(std::make_unique<Algue>());

    aq.passer_temps();

    return 0;
}

Aquarium.hpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#ifndef AQUARIUM_HPP
#define AQUARIUM_HPP

#include <vector>
#include <memory>
#include <iostream>

#include "Poisson.hpp"
#include "Algue.hpp"

class Aquarium : private no_copy
{
    public:
        Aquarium(){};
        ~Aquarium(){};

        void ajouter_poisson( std::unique_ptr<Poisson>&& p )
        {
            Poissons_.push_back( std::move(p) );
        }

        void ajouter_algue( std::unique_ptr<Algue> a )
        {
            Algues_.push_back( std::move(a) );
        }

        void passer_temps()
        {
            Tour_++;

            std::cout<<"Tour #" <<Tour_ <<std::endl <<std::endl;
            std::cout<<"Algues : " <<Algues_.size() <<std::endl;
            std::cout<<"Poissons : " <<Poissons_.size() <<std::endl;

            for(const auto & p : Poissons_)
                std::cout<<"- " <<p->nom() <<" : " <<p->sexe_str() << " : " <<p->race_str() <<" : " << p->predation_str() <<std::endl;

            std::cout<<"===============================================" <<std::endl;
        }

    private:
        std::vector<std::unique_ptr<Poisson>> Poissons_;
        std::vector<std::unique_ptr<Algue>> Algues_;

        unsigned int Tour_{0};
};

#endif // AQUARIUM_HPP

Semantique.hpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
#ifndef SEMANTIQUE_HPP
#define SEMANTIQUE_HPP

class no_copy
{
    public:
        no_copy(const no_copy &) = delete;
        no_copy & operator=(const no_copy &) = delete;
        no_copy(no_copy&&) = default;
        no_copy& operator=(no_copy&&) = default;
        ~no_copy() = default;

    protected:
        no_copy(){};
};

#endif // SEMANTIQUE_HPP

Poisson.hpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#ifndef POISSON_HPP
#define POISSON_HPP

#include <string>
#include "Semantique.hpp"
#include "ChaineAlimentaire.hpp"
#include "Algue.hpp"

class Poisson : private no_copy
{
    public:
        enum class Etat {VIVANT,MORT};
        enum Race {SOLE,BAR,CARPE,MEROU,THON,POISSON_CLOWN,REQUIN,MAX};
        enum class Sexe {MALE,FEMALE};

        virtual void manger(){};

        const std::string & nom() const {return nom_;};
        const std::string sexe_str() const {return (sexe_ == Sexe::FEMALE) ? "Femelle" : "Male";};

        const std::string race_str() const {
            std::array<std::string, Poisson::Race::MAX> races{"Sole","Bar","Carpe","Merou","Thon","Poisson-Clown","Requin"};
            return races[race_];
        };

        const Predation::Niveau predation_str() const {return predation_.niveau();};

    private:
        std::string nom_{""};
        Sexe sexe_{};
        Race race_{};
        Predation predation_{};
        Etat etat_{};

    protected:
        Poisson(const std::string & nom , Sexe sexe , Race race , Predation predation )
        :   nom_(nom),
            sexe_{sexe},
            race_{race},
            predation_{predation},
            etat_{Etat::VIVANT}
        {};
};

class PoissonCarnivore : public Poisson
{
    public:
        PoissonCarnivore(const std::string & nom , Sexe sexe , Race race)
        : Poisson{nom,sexe,race,Predation::Niveau::CARNIVORE}
        {};

    private:
};

class PoissonHerbivore : public Poisson
{
    public:
        PoissonHerbivore(const std::string & nom , Sexe sexe , Race race)
        : Poisson{nom,sexe,race,Predation::Niveau::HERBIVORE}
        {};

    private:
};

#endif // POISSON_HPP

Algue.hpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#ifndef ALGUE_HPP
#define ALGUE_HPP

#include "Semantique.hpp"
#include "ChaineAlimentaire.hpp"

class Algue : private no_copy
{
    public:
        enum class Etat{VIVANT,MORT};

        Algue()
        :   predation_{Predation::Niveau::AUCUN},
            etat_{Etat::VIVANT}
        {};
        ~Algue(){};

    private:
        Predation predation_;
        Etat etat_;
};

#endif // ALGUE__HPP

ChaineAlimentaire.hpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#ifndef CHAINE_ALIMENTAIRE_HPP
#define CHAINE_ALIMENTAIRE_HPP

class ChaineAlimentaire
{
    public:
        enum Niveau{AUCUN,HERBIVORE,CARNIVORE};

        ChaineAlimentaire(Niveau niveau = Niveau::AUCUN) : niveau_{niveau}{};

        const ChaineAlimentaire::Niveau niveau() const {return niveau_;};

        bool operator >(const ChaineAlimentaire &other) const
        {
            return (niveau_ > other.niveau_);
        }

        bool operator <(const ChaineAlimentaire &other) const
        {
            return !(*this > other);
        }

        bool operator ==(const ChaineAlimentaire &other) const
        {
            return (niveau_ == other.niveau_);
        }

        bool operator !=(const ChaineAlimentaire &other) const
        {
            return !(*this == other);
        }

        bool operator <=(const ChaineAlimentaire &other) const
        {
            return (((*this) < other) || ((*this) == other));
        }

        bool operator >=(const ChaineAlimentaire &other) const
        {
            return (((*this) > other) || ((*this) == other));
        }

    private:
        Niveau niveau_{Niveau::AUCUN};
};

using Predation = ChaineAlimentaire;

/* me permet de savoir le niveau de predation d'un poisson par exemple */

const Predation PRED_AUCUN(Predation::Niveau::AUCUN);
const Predation PRED_CARNIVORE(Predation::Niveau::CARNIVORE);
const Predation PRED_HERBIVORE(Predation::Niveau::HERBIVORE);

#endif // CHAINE_ALIMENTAIRE_HPP

Pour le dernier ( ChaineAlimentaire ) je suis pas encore sur .. j'ai decider de faire une classe "comparable" pour ce qui est du niveau de predation il sera donc plus facile d'evaluer et comparer le niveau d'alimentation entre chaques especes..

Suis-je sur la bonne voie ? Pas trop d'horreur dans mes codes ? Conseils et avis sont les bienvenus.

+0 -0

La partie 1.2 est terminer ( sans se soucier des tirage aleatoire etc .. ) les carnivores mangent des poissons et les herbivores mangent des algues..

Voici les parties de code modifiées

NOTE : J'aurai a validé race vs alimentation , par exemple je peut en ce moment cree un Requin herbivore ou un Bar carnivore ..ce qui na aucun sens.

Dans poisson.hpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
class Poisson
{
    public : virtual void manger(Consommable &) = 0;
}

class PoissonCarnivore
{
    public : void manger(Consommable & poisson){
                              std::cout<<(*this).nom() <<" mange un poisson." <<std::endl;
                             };
}

class PoissonHerbivore
{
    public : void manger(Consommable & algue){ std::cout<<(*this).nom() <<" mange une algue." <<std::endl;};
}

Ma classe Consommable dans ChaineAlimentaire.hpp qui est la pour l'instant que pour les besoins

1
2
3
4
5
class Consommable
{
    public:
        int pv = 10;
};

Aquarium.hpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
void passer_temps()
        {
            Tour_++;

            std::cout<<"Tour #" <<Tour_ <<std::endl <<std::endl;
            std::cout<<"Algues : " <<Algues_.size() <<std::endl;
            std::cout<<"Poissons : " <<Poissons_.size() <<std::endl;

            for(const auto & p : Poissons_)
                std::cout<<"- " <<p->nom() <<" : " <<p->sexe_str() << " : " <<p->race_str() <<" : " << p->predation_str() <<std::endl;

            std::cout<<"===============================================" <<std::endl;

            for(const auto & p : Poissons_)
            {
                if(p->predation() == PRED_CARNIVORE)
                {
                    PoissonCarnivore pc{"Un poisson",Poisson::Sexe::MALE,Poisson::Race::BAR};
                    p->manger(pc);
                }
                if(p->predation() == PRED_HERBIVORE)
                {
                    Algue a{};
                    p->manger(a);
                }
            }
+0 -0

Voila , partie 2 terminé !

Je vous met ici la partie concernée par la partie 2 ( les poissons mangent , sauf eux-meme ).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
void passer_temps()
        {
            Tour_++;

            //enleve les poissons et algues morts
            vider_poissons();
            vider_algues();

            // affichage des infos
            std::cout<<std::endl <<std::endl <<"=================================================" <<std::endl;
            std::cout<<"Tour #" <<Tour_ <<std::endl;
            std::cout<<"Algues : " <<Algues_.size() <<"Poissons : " <<Poissons_.size() <<std::endl;

            for(const auto & p : Poissons_)
                std::cout<<p->nom() <<" : " <<p->sexe_str() << " : " <<p->race_str() <<" : " << p->predation_str() <<" : " <<p->vie_restante() <<"PV" <<std::endl;

            std::cout<<"**   **   **   **   **   **" <<std::endl;

            for(const auto & a : Algues_)
            {
                a->vieillir();
            }

            for(const auto & p : Poissons_)
            {
                p->vieillir();

                if(p->est_vivant())
                {
                    if(p->a_faim())
                    {
                       if(p->predation() == PRED_CARNIVORE)
                        {
                            int poisson_aleatoire{};
                            std::random_device random;
                            std::default_random_engine engine(random());
                            std::uniform_int_distribution<int> uniform_dist(0, Poissons_.size()-1);

                            do{
                                poisson_aleatoire = uniform_dist(engine);
                            }while(Poissons_[poisson_aleatoire] == p);

                            p->manger(*(Poissons_[poisson_aleatoire]));
                        }
                        if(p->predation() == PRED_HERBIVORE)
                        {
                            std::random_device random;
                            std::default_random_engine engine(random());
                            std::uniform_int_distribution<int> uniform_dist(0, Algues_.size()-1);

                            int algue_aleatoire = uniform_dist(engine);

                            p->manger(*(Algues_[algue_aleatoire]));
                        }
                    }
                }
            }
        }
+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte