Salutations j'ai fais un mini-jeu pouvez-vous me donner vos avis, suggestions, amélioration etc...?

Cela m'aiderai à m'amélioré merci :D.

#include <iostream>
#include <boost/algorithm/string/predicate.hpp>
#include <cstdlib>
#include <sstream>
#include <iomanip>
#include <time.h>


static std::string dateFormat(int s) {
    std::stringstream ss;
    int h = 0, m = 0;
    while (s > 60 * 60) {
        h++;
        s -= 60 * 60;
    }
    while (m > 60) {
        m++;
        s -= 60;
    }
    if (h > 0)
        ss << h << " heure" << (h > 1 ? "s et " : " et ");
    if (m > 0)
        ss << m << " minute" << (m > 1 ? "s et " : " et ");
    ss << s << " seconde" << (s > 1 ? "s." : ".");
    return ss.str();
}

int main() {
    std::string again;
    do {
        system("clear");
        std::cout << "----------[ PlusOuMoins ]----------\n"
                  << "Commencement du jeu.\n"
                  << "Développé par LEVASSEUR Wesley.\n"
                  << "-----------------------------------"
                  << std::endl;
        srand(time(nullptr));
        time_t t = std::time(nullptr);
        const int r = rand() % 100;
        int tr = 0, te;
        bool find = false;
        std::cout << "debug: " << r << std::endl;
        std::cout
                << "CONSOLE » Tentez de trouver le nombre aléatoire entre 0 et 100, dans un court délai et en moins de coups possible."
                << std::endl;
        do {
            try {
                ++tr;
                std::cin >> te;
                if (std::cin.fail()) throw std::runtime_error("Input is not an integer\n");
                if (r > te)
                    std::cout << "CONSOLE » Plus!" << std::endl;
                else if (r < te)
                    std::cout << "CONSOLE » Moins!" << std::endl;
                else {
                    std::cout << "CONSOLE » GAGNEZ!" << std::endl;
                    std::cout << "CONSOLE » Vous avez mis " << dateFormat(std::difftime(time(nullptr), t)) << std::endl;
                    std::cout << "CONSOLE » En " << tr << " coup" << (tr > 1 ? "s." : ".") << std::endl;
                    find = true;
                }
            } catch (const std::runtime_error &e) {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                std::cout << "CONSOLE » Veuillez saisir un nombre entier. (Ex: 50)" << std::endl;
            }
        } while (!find);
        do {
            std::cout << "CONSOLE » Voulez-vous recommencer le jeu? (Oui / Non)" << std::endl;
            std::cin >> again;
            std::cin.ignore();
            std::cin.clear();
        } while (!boost::iequals(again, "oui") && !boost::iequals(again, "non"));
    } while (boost::iequals(again, "oui"));
    return 0;
}

Merci d'avoir lu

-
Edité par KanekiReal 18 janvier 2019 à 12:27:25

Tu sais que pour formater les dates il y a std::put_time ?

Pour les nombres aléatoires, utilise <random>

Edit : je n'avais pas vu que tu voulais afficher un temps écoulé. put_time est inadapté dans ce cas.

-
Edité par markand 18 janvier 2019 à 14:05:08

Salut, non je ne connais pas 

std::put_time

Même avec cette explication j'y comprend rien x).

Pour les nombres aléatoire, je vais avoir ça merci du renseignement.

Merci d'avoir écrit

markand a écrit:

Tu sais que pour formater les dates il y a std::put_time ?

Pour les nombres aléatoires, utilise <random>

Edit : je n'avais pas vu que tu voulais afficher un temps écoulé. put_time est inadapté dans ce cas.

-
Edité par markand il y a environ 1 heure

EDIT: Voila le nouveau code:

#include <iostream>
#include <boost/algorithm/string/predicate.hpp>
#include <sstream>
#include <iomanip>
#include <random>

static std::string dateFormat(int s) {
    std::stringstream ss;
    int h = 0, m = 0;
    while (s > 60 * 60) {
        h++;
        s -= 60 * 60;
    }
    while (s > 60) {
        m++;
        s -= 60;
    }
    if (h > 0)
        ss << h << " heure" << (h > 1 ? "s et " : " et ");
    if (m > 0)
        ss << m << " minute" << (m > 1 ? "s et " : " et ");
    ss << s << " seconde" << (s > 1 ? "s." : ".");
    return ss.str();
}

int main() {
    std::string again;
    do {
        std::cout << "----------[ PlusOuMoins ]----------\n"
                  << "Commencement du jeu.\n"
                  << "Développé par LEVASSEUR Wesley.\n"
                  << "-----------------------------------"
                  << std::endl;
        std::random_device random_device;
        std::default_random_engine random_engine(random_device());
        std::uniform_int_distribution<int> uniform_dist(1, 100);
        time_t t = std::time(nullptr);
        const int r = uniform_dist(random_engine);;
        int tr = 0, te;
        bool find = false;
        std::cout << "debug: " << r << std::endl;
        std::cout
                << "CONSOLE » Tentez de trouver le nombre aléatoire entre 0 et 100, dans un court délai et en moins de coups possible."
                << std::endl;
        do {
            try {
                ++tr;
                std::cin >> te;
                if (std::cin.fail()) throw std::runtime_error("Input is not an integer\n");
                if (r > te)
                    std::cout << "CONSOLE » Plus!" << std::endl;
                else if (r < te)
                    std::cout << "CONSOLE » Moins!" << std::endl;
                else {
                    std::cout << "CONSOLE » GAGNEZ!" << std::endl;
                    std::cout << "CONSOLE » Vous avez mis " << dateFormat(std::difftime(time(nullptr), t)) << std::endl;
                    std::cout << "CONSOLE » En " << tr << " coup" << (tr > 1 ? "s." : ".") << std::endl;
                    find = true;
                }
            } catch (const std::runtime_error &e) {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                std::cout << "CONSOLE » Veuillez saisir un nombre entier. (Ex: 50)" << std::endl;
            }
        } while (!find);
        do {
            std::cout << "CONSOLE » Voulez-vous recommencer le jeu? (Oui / Non)" << std::endl;
            std::cin >> again;
            std::cin.ignore();
            std::cin.clear();
        } while (!boost::iequals(again, "oui") && !boost::iequals(again, "non"));
    } while (boost::iequals(again, "oui"));
    return 0;
}

-
Edité par KanekiReal 18 janvier 2019 à 16:13:33

Salut,

Par respect du SRP, découpe tes fonctions en plusieurs fonctions avec chacune une (et une seule) responsabilité bien définie.

Par exemple, ta fonction dateFormat fait 2 choses (soit une de trop):
- Convertion d'un nombre de seconde en heure.
- Formattage de l'heure.

-
Edité par Deedolith 18 janvier 2019 à 16:08:25

Salut, qu'est-ce que l'SRP ?

Pour le découpage des fonctions je ne veux voir pas comment le/les faire. Peux tu m'éclairé sur le sujet?

Merci d'avoir écrit et répondu

Deedolith a écrit:

Salut,

Par respect du SRP, découpe tes fonctions en plusieurs fonctions avec chacune une (et une seule) responsabilité bien définie.

Par exemple, ta fonction dateFormat fait 2 choses (soit une de trop):
- Convertion d'un nombre de seconde en heure.
- Formattage de l'heure.

-
Edité par Deedolith il y a 5 minutes

SRP: Single Responsibility Principle.

Une fonction ou une classe doit avoir une seule responsabilité bien definie.
Ainsi elle est courte, et facile à maintenir et à debugger.

Si je reprend ta fonction dateFormat, on peut la diviser en 2:
Une fonction qui convertit le nombre de secondes en un type exploitable en terme d'heure / minutes / secondes.
Une fonction qui met cela en forme pour affichage.

struct time
{
    unsigned hour;
    unsigned minute;
    unsigned second;
};

time toTime(unsigned seconds)
{
    time temp;
    temp.hour = seconds / 3600;
    temp.minute = seconds / 60 - temp.hour * 60;
    temp.second = seconds - temp.minute * 60 - temp.hour * 3600;
    return temp;
}

std::string timeFormat(time const& temp)
{
    return std::to_string(temp.hour) + " Heures, " + std::to_string(temp.minute) + " minutes et " + std::to_string(temp.second);
}

int main()
{
    unsigned second[4275);
    time temp = toTime(second);
    std::cout << timeFormat(temp);
}

Salut, merci des informations et de l'exemple voici le code terminer avec tous vos retours.

#include <iostream>
#include <boost/algorithm/string/predicate.hpp>
#include <sstream>
#include <iomanip>
#include <random>

struct time_s {
    int h;
    int m;
    int s;
};

time_s toTime(int s) {
    time_s t1{};
    t1.h = s / 3600;
    t1.m = s / 60 - t1.h;
    t1.s = s - t1.m * 60 - t1.h * 3600;
    return t1;
}

static std::string time_sFormat(time_s t) {
    std::stringstream ss;
    if (t.h > 0)
        ss << t.h << " heure" << (t.h > 1 ? "s et " : " et ");
    if (t.m > 0)
        ss << t.m << " minute" << (t.m > 1 ? "s et " : " et ");
    ss << t.s << " seconde" << (t.s > 1 ? "s." : ".");
    return ss.str();
}

int main() {
    std::string again;
    do {
        std::cout << "----------[ PlusOuMoins ]----------\n"
                  << "Commencement du jeu.\n"
                  << "Développé par LEVASSEUR Wesley.\n"
                  << "-----------------------------------"
                  << std::endl;
        std::random_device random_device;
        std::default_random_engine random_engine(random_device());
        std::uniform_int_distribution<int> uniform_dist(1, 100);
        time_t t = std::time(nullptr);
        const int r = uniform_dist(random_engine);;
        int tr = 0, te;
        bool find = false;
        std::cout << "debug: " << r << std::endl;
        std::cout
                << "CONSOLE » Tentez de trouver le nombre aléatoire entre 0 et 100, dans un court délai et en moins de coups possible."
                << std::endl;
        do {
            try {
                ++tr;
                std::cin >> te;
                if (std::cin.fail()) throw std::runtime_error("Input is not an integer\n");
                if (r > te)
                    std::cout << "CONSOLE » Plus!" << std::endl;
                else if (r < te)
                    std::cout << "CONSOLE » Moins!" << std::endl;
                else {
                    std::cout << "CONSOLE » GAGNEZ!" << std::endl;
                    std::cout << "CONSOLE » Vous avez mis " << time_sFormat(toTime(std::difftime(time(nullptr), t))) << std::endl;
                    std::cout << "CONSOLE » En " << tr << " coup" << (tr > 1 ? "s." : ".") << std::endl;
                    find = true;
                }
            } catch (const std::runtime_error &e) {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                std::cout << "CONSOLE » Veuillez saisir un nombre entier. (Ex: 50)" << std::endl;
            }
        } while (!find);
        do {
            std::cout << "CONSOLE » Voulez-vous recommencer le jeu? (Oui / Non)" << std::endl;
            std::cin >> again;
            std::cin.ignore();
            std::cin.clear();
        } while (!boost::iequals(again, "oui") && !boost::iequals(again, "non"));
    } while (boost::iequals(again, "oui"));
    return 0;
}

Je vous remercie de toutes ses informations et aides

Deedolith a écrit:

SRP: Single Responsibility Principle.

Une fonction ou une classe doit avoir une seule responsabilité bien definie.
Ainsi elle est courte, et facile à maintenir et à debugger.

Si je reprend ta fonction dateFormat, on peut la diviser en 2:
Une fonction qui convertit le nombre de secondes en un type exploitable en terme d'heure / minutes / secondes.
Une fonction qui met cela en forme pour affichage.

struct time
{
    unsigned hour;
    unsigned minute;
    unsigned second;
};

time toTime(unsigned seconds)
{
    time temp;
    temp.hour = seconds / 3600;
    temp.minute = seconds / 60 - temp.hour * 60;
    temp.second = seconds - temp.minute * 60 - temp.hour * 3600;
    return temp;
}

std::string timeFormat(time const& temp)
{
    return std::to_string(temp.hour) + " Heures, " + std::to_string(temp.minute) + " minutes et " + std::to_string(temp.second);
}

int main()
{
    unsigned second[4275);
    time temp = toTime(second);
    std::cout << timeFormat(temp);
}

-
Edité par KanekiReal 20 janvier 2019 à 18:17:05

Recopier mon code, c'est bien, mais c'est pareil pour ta fonction main:
Elle à trop de responsabilités (a toi d'analyser lesquelles).

De plus, les erreurs de saisie ne devraient pas être gérées via des exceptions.
Une exception est quelque chose dont on ne peut se prémunir (rupture de connexion réseau par exemple).
Ce n'est pas le cas pour les saisies, tu as tout le loisir de les vérifier.

Je sais mais mon but est de le faire en une classe et si possible avec le moins de methode.

Qui nous interdit de géré les erreurs de saisie par des exceptions ?

T'en que le programme marche et qui donne le resultré voulu c'est ce qui compte le plus.

Merci de tes réponses.

Deedolith a écrit:

Recopier mon code, c'est bien, mais c'est pareil pour ta fonction main:
Elle à trop de responsabilités (a toi d'analyser lesquelles).

De plus, les erreurs de saisie ne devraient pas être gérées via des exceptions.
Une exception est quelque chose dont on ne peut se prémunir (rupture de connexion réseau par exemple).
Ce n'est pas le cas pour les saisies, tu as tout le loisir de les vérifier.

KanekiReal a écrit:

(1)Je sais mais mon but est de le faire en une classe et si possible avec le moins de methode.

(2)Qui nous interdit de géré les erreurs de saisie par des exceptions ?

(3)T'en que le programme marche et qui donne le resultré voulu c'est ce qui compte le plus.

1) Le but d'un code source n'est pas d'avoir le moins de fonctions. A ce moment, tu n'en fait qu'une seule "fourre-tout" et bon courage pour la suite.

2) Les erreurs de saisie sont contrôlables (et doivent être contrôlées), les exceptions ne sont absolument pas adaptées pour les gérer.

3) C'est une bonne chose si ca fonctionne, mais c'est encore meilleur si c'est:
a) Lisible.
B) Maintenable.
Ce qui nous ramène sur le 1er point, une fonction "fourre-tout" n'est pas lisible, ni maintenable.

Une bonne fonction fait entre 1 a 10 ligne.

Sa complexité cyclomatique ne doit pas dépasser 5.

Une bonne classe (sans sa Doc) fait moins de 100 lignes.

Si elle fait plus, alors elle dépasse très semblablement son scope.

Il y a des exceptions comme par exemple des classes oriente math.

Avec ces deux assertion j'espère que tu comprendras pourquoi tu doit faire plus de fonction, de classes.

KanekiReal a écrit:

(1) Je sais mais mon but est de le faire en une classe et si possible avec le moins de methode.

(2) Qui nous interdit de géré les erreurs de saisie par des exceptions ?

(3) T'en que le programme marche et qui donne le resultré voulu c'est ce qui compte le plus.

(1) Non. Ton but c'est d'apprendre à programmer. En l'occurrence, limiter la taille des fonctions et des classes, c'est une habitude à prendre très tôt.

(2) C'est pas une interdiction. Mais ici c'est juste overkill. Une simple conditionnelle, c'est plein de code en moins et ça donne la même chose à l'exécution. Garde ton code simple.

(3) Non. Ce qui compte le plus, et de loin, c'est que le code soit lisible. Une erreur dans un code lisible, c'est facile à corriger. L'inverse n'est pas vrai.