Discussion :

[Laurent_B_]

https://github.com/laurentbouleau/Exemple : Octobre 04 (03/10/2024)

[bacelar]

Toujours les mêmes erreurs.
Dans la même fonction "wmain":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  const wchar_t* p{ L".\\Exemple.txt" };

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   Person p;

Prenez la peine de nommer correctement vos variables, BORDEL.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

film.set_Person(p);

De quel "p" il s'agit ?

Pourquoi faire aussi compliqué :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
if (!found && pos > 2 && pos2 > (pos + c_annee_size + c_tiret_size + c_mois_size + c_tiret_size + c_jour_size) && pos != std::wstring::npos && pos2 != std::wstring::npos && 
    std::regex_match(nomDossier, match, nomDossier_pattern))
{...}

Quand

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
if (std::regex_match(nomDossier, match, nomDossier_pattern))
{...}

fait aussi bien ?

[Laurent_B_]

Bonsoir,

https://github.com/laurentbouleau/Exemple : Octobre 04 (04/10/2024)

film.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
std::wstring SequenceVisionnage_film::Print_Dates_de_visionnage(std::vector<DateRecord>& m_DatesVisionnage, std::vector<std::wstring>&keyColor, std::wstring& valuesColor)
{
    //set_Person(person);
    m_keyColor = keyColor;
    m_valuesColor = valuesColor;
    const std::wstring date_format = L"%d" + m_keyColor[1] + L"/" + m_valuesColor + L"%m" + m_keyColor[1] + L"/" + m_valuesColor + L"%Y";
    const std::wstring between_parenthesis = m_keyColor[1] + L"(" + m_valuesColor + L"%s" + m_keyColor[1] + L")" + m_valuesColor;
    const std::wstring same_date_format = between_parenthesis;
    const std::wstring prequel_format = between_parenthesis;
    //const std::wstring streaming_format = m_keyColor[1] + L" : " + m_valuesColor + L"%s";
    const std::wstring streaming_format = m_keyColor[1] + L" :" + m_valuesColor + L"%s";
    const std::wstring step_by_step_tag = L' ' + m_keyColor[1] + L'[' + m_valuesColor + L"pas-à-pas" + m_keyColor[1] + L']' + m_valuesColor;

    std::wstring dates_de_visionnage_wstr = L"";

    std::vector<std::wstring> v_wstr;
    std::time_t last_date{ 0 };
    int same_date_counter = 0;
    for (auto dr : m_DatesVisionnage)
    {
        std::time_t time = std::mktime(&dr.date);

        if (last_date != time)
        {
            std::tm localtime = *std::localtime(&time);
            std::wstringstream target_stream;
            target_stream << std::put_time(&localtime, date_format.c_str());
            std::wstring date_str = target_stream.str();
            v_wstr.push_back(date_str);
            same_date_counter = 0;
        }
        else
        {
            same_date_counter++;
            if (same_date_counter == 1)
            {
                v_wstr.back() += wstring_format(same_date_format, L"1");
            }
            v_wstr.back() += wstring_format(same_date_format, std::to_wstring(same_date_counter + 1).c_str());
        }
        last_date = time;
    }

    for (auto i = 0; i < v_wstr.size(); i++)
    {
        if (i != 0)
            dates_de_visionnage_wstr += L", ";
        dates_de_visionnage_wstr += v_wstr[i];
    }

    if (m_DatesVisionnage.size() == 1)
    {
        if (m_DatesVisionnage[0].someFlag)
            dates_de_visionnage_wstr += wstring_format(prequel_format, L"stop ou pas !");
    }
    else
    {
        if (m_DatesVisionnage.size() > 0)
        {
            if (m_DatesVisionnage.back().someFlag)
            {
                dates_de_visionnage_wstr += wstring_format(prequel_format, L"à suivre");
            }
            dates_de_visionnage_wstr += step_by_step_tag;
        }
    }

    if (m_streaming != L"" && dates_de_visionnage_wstr.length() > 0)
        dates_de_visionnage_wstr += wstring_format(streaming_format, m_streaming.c_str());
    //
    return dates_de_visionnage_wstr;
}
...
const void Film::Print_Dates()
{
    if (affichage_visionnages_actif)
    {
        std::wstring dates_str = L"\r\n";
        for (auto visionnage : m_visionnages)
        {
            //dates_str += visionnage.Print_Dates_de_visionnage(visionnage.m_DatesVisionnage) + L"\r\n";
            dates_str += visionnage.Print_Dates_de_visionnage(visionnage.m_DatesVisionnage, m_keyColor, m_valuesColor) + L"\r\n";
        }
        dates_str += L"\r\n";
        std::wcout << dates_str;
    }
}

Pour quand :
film.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
struct SequenceVisionnage_film
{
...
    void set_Person(Person& person);
    std::wstring Print_Dates_de_visionnage(std::vector<DateRecord>& m_DatesVisionnage);
    std::wstring Print_Dates_de_visionnage(std::vector<DateRecord>& m_DatesVisionnage, std::vector<std::wstring>&keyColor, std::wstring& valuesColor);
    //std::wstring m_min = L"min";
    std::vector<std::wstring>m_keyColor;// { L"\x1b[94;1m", L"\x1b[38;2;0;255;0m" }; // keyColor[0] (bleu) et keyColor[1] (vert)
    std::wstring m_valuesColor; // { L"\x1b[38;2;255;255;255m" }; // Blanc
 ...
};

et film.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
void SequenceVisionnage_film::set_Person(Person& person)
{
    ///m_h = person.m_h;
    //m_min = person.m_min;
    m_keyColor = person.m_keyColor;
    m_valuesColor = person.m_valuesColor;
}

Marche pas !!!
Compliqué !!!

Merci d'avance

[bacelar]

Bien sûr que c'est beaucoup trop compliqué.
Toujours les mêmes mauvais reflexes.
Nommez correctement- vos fonctions/classes/variables, etc...
"Person", c'est quoi ???
Personnalisation_Affichage ???

Pourquoi la fonction "SequenceVisionnage_film:: Print_Dates_de_visionnage" devrait modifier la personnalisation de l'affichage ???
Essayez de pratiquer les principes de "SOLID":
https://fr.wikipedia.org/wiki/SOLID_(informatique)
Dans la fonction "SequenceVisionnage_film:: Print_Dates_de_visionnage", vous ne respectez pas le "S" :Responsabilité unique (Single responsibility principle). Encore une fois.
Donc, le problème ici n'est pas tant un problème de nommage de la fonction que de la conception de la fonction qui fait trop de choses différentes.
Donc, souvent, en essayant de nommer correctement les choses, on voit qu'elles sont mal conçues.
Vous avez ajouté une fonction "set_Person" à la classe "SequenceVisionnage_film". Pourquoi ne pas vous en servir plutôt que de planquer cette personnalisation dans une fonction "Print_Dates_de_visionnage" qui ne devrait avoir rien à faire avec la configuration de la "personnalisation de l'affichage" ?

Marche pas !!!

Il faut être beaucoup plus précis sur le "problème".
Cela permettrait de vous aiguiller plus directement sur une solution pérenne.
En sachant ce que vous voulez faire "à la fin", on pourrait concevoir une structure plus solide pour votre projet.
Ici, le fait qu'on ne sait pas si la "personnalisation" de l'affichage se fait au niveau du film ou de chaque instance de "SequenceVisionnage_film" ne permet pas de vous diriger vers une solution "correcte".
Si c'est au niveau du film, vous n'avez pas besoin des champs de "personnalisation" de l'affichage (m_h, m_keyColor, m_valuesColor, etc) dans la classe SequenceVisionnage_film mais les valeurs devraient être systématiquement fournies par les appels de fonctions depuis un objet "Film".
Mieux, ces fonctions d'affichages d'une "SequenceVisionnage_film" devraient être dans la classe Film.
Si c'est au niveau de chaque instance de "SequenceVisionnage_film" que la personnalisation de l'affichage change, appelez la fonction "SequenceVisionnage_film::set_Person" quand et où vous aurez les bonnes informations pour l'appeler.
Il faut toujours savoir où l'information est la plus pertinente et pas la mettre n'import où/partout, sinon vous ne savez pas d'où vient l'erreur quand ça déconne.

Généralement, on ne mélange pas les données et les fonctions qui servent à les afficher. On sépare la partie/couche DATA de la partie/couche AFFICHAGE.

Quand c'est compliqué, c'est qu'on ne se pose pas les bonnes questions. Prenez un peu de recul sur votre code, souvent, très souvent.

P.S.: Pensez à la "constcorectness" des paramètres, SVP.
Par exemple, dans la signature de la fonction "void SequenceVisionnage_film::set_Person(Person& person)", pourquoi "person" n'est pas "const Person&" ?

[Laurent_B_]

Bonsoir,

Désolé !

https://github.com/laurentbouleau/Exemple : Octobre 05 (11/10/2024)

Exemple : serie.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
...
std::wstring Serie::calcul_Titres_Affichage() const
{
    assert(m_titres.size() != 0 && L"Nom de m_titres vide");
    assert((m_titres.size() == 1 || m_titres.size() == 3) && L"Nom de m_titres est 2");
    assert(m_titres.size() < 4 && L"Nom de m_titres est 4 ou plus");
    std::wstring titres_str;
    if (affichage_titres_actif)
    {
        titres_str = m_keyColor[0] + L"Titre : " + m_valuesColor + m_titres[0];
        if (m_titres.size() > 1)
            titres_str += m_keyColor[1] + m_titres[1] + m_valuesColor + m_titres[2];
    }
    return titres_str;
}
...
void Serie::Print_Header() const
{
    if (affichage_titres_actif)
    {
        //std::wstring titres_str;
        std::wstring titres_str = calcul_Titres_Affichage();
 
        const std::wstring crochet_ouvrant_str = m_keyColor[0] + L" [" + m_valuesColor;
        std::wstring annees_str;
        std::wstring sur_str;
        const std::wstring crochet_fermant_str = m_keyColor[0] + L"]" + m_valuesColor;
        std::wstring x_sj_str;
        std::wstring sj_str;
        std::wstring duree_str;
        std::wstring note_str;
 
        //titres_str = m_keyColor[0] + L"Titre : " + m_valuesColor + m_titres[0];
        //if (m_titres.size() > 1)
        //    titres_str += m_keyColor[1] + m_titres[1] + m_valuesColor + m_titres[2];
        // Année(s)
        if (affichage_annees_actif)
        {
            annees_str = format_Annees();
...

Ok ou pas ?

Et :

• std::pair<int, int> Serie::calculer_Annees_Diffusion() const
• std::wstring Serie::calcul_Note_Affichage() const
• std::wstring Serie::calcul_Titres_Affichage() const

Pourquoi ?

Merci vraiment

[bacelar]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    assert(m_titres.size() != 0 && L"Nom de m_titres vide");
    assert((m_titres.size() == 1 || m_titres.size() == 3) && L"Nom de m_titres est 2");
    assert(m_titres.size() < 4 && L"Nom de m_titres est 4 ou plus");

Attention aux messages d'erreur faux.
C'est quoi ce "Nom" dans les messages d'erreur ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (affichage_titres_actif)

Mélangez pas tout, c'est pas à la fonction de calcul de la partie "Titre" de l'affichage qui doit vérifier cela. C'est à la fonction qui fait l'affichage de le vérifier.
(Il y a de grande chance que cette fonction ne soit pas utilisée qu'à l'affichage => elle changera de nom, je l'espère.)
Depuis le début, je trouve que vous mettez la charrue avant les bœufs avec ces booléens "d'options d'affichage".
Si vous voulez vous en servir, ça devrait être qu'à un endroit, au moment de l'affichage, point barre.
J'ai du mal à comprendre pourquoi une série ne peut avoir qu'1 titre ou 3, mais pas 2 ou plus que 3.

"crochet_ouvrant_str" et "crochet_fermant_str", vous en aurez besoin que dans la fonction "Serie:: Print_Header" ?
Sinon, pourquoi en faire des constantes "locales" ?
C'est très rare qu'une constante ne soit utilisées que dans une seule fonction.

std::pair<int, int> Serie::calculer_Annees_Diffusion() const
std::wstring Serie::calcul_Note_Affichage() const
std::wstring Serie::calcul_Titres_Affichage() const

Bin, "Serie::calculer_Annees_Diffusion" calcul la première et la dernière années de diffusion, donc nom de fonction plutôt logique, non ?
Pour "Serie::calcul_Note_Affichage()" et "Serie::calcul_Titres_Affichage", je suppose qu'elles calculent/formatent les informations "Note" et "Titre" contenues dans l'objet Serie dans un format affichable dans la console.
Donc, pourquoi cette question ? Elles ne font pas ce qu'implique leur nom ?

Pourquoi les champs membres de la classe "Person" sont préfixées avec des "s_" et pas des "m_" ?
"s_" pour "static", ok, mais les champs de la classe "Person" ne sont PAS statiques.

Dans film.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const class Person;

Pourquoi ce "const" ???

Dans film_serie.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
const class Person
{
public:

idem, pourquoi ce "const" ???

[Laurent_B_]

Bonsoir,

Pouvez-vous expliquer étape par étape ? Par exemple :

Person
if (affichage_x_sj_actif && ...)
Si la variable "dates_str" est égale à "2018-05-01 VOD Orange"
etc...

Mais : https://github.com/laurentbouleau/Exemple : Octobre 06 (14/10/2024)

seie.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
void Serie::Print_Header() const
{
    std::wstring titres_str;
    std::wstring annees_str;
    std::wstring sur_str;
    std::wstring anneesEtSur_str;
    std::wstring signaletique_jeunesse_str;
    std::wstring duree_str;
    std::wstring note_str;
    // Titres
    if (affichage_titres_actif)
        titres_str += calcul_Titres_Affichage();
    // Annees
    if (affichage_annees_actif)
        annees_str += format_Annees();
    // Sur
    if (affichage_sur_actif && m_sur != L"")
        sur_str += calcul_Sur_Affichage();
    // Années et/ou/non sur
    anneesEtSur_str = format_AnneesEtSur(annees_str, sur_str);
    // SJ
    if (affichage_sj_actif && m_sj.length() != 0)
        signaletique_jeunesse_str = calcul_signaletique_jeunesse_affichage();
    // Durée 
    if (affichage_duree_actif)
        duree_str += calcul_duree_affichage();
    // Note
    if (affichage_note_actif)
        note_str += calcul_Note_Affichage();
 
    std::wcout << titres_str << anneesEtSur_str << signaletique_jeunesse_str << duree_str << note_str << std::endl;
}

Je suis fatigué

Merci beaucoup

[bacelar]

Pouvez-vous expliquer étape par étape ?

Pouvez-vous être plus précis, SVP ?
Beaucoup du code est de votre cru, je ne peux pas trop expliquer ce que VOUS avez conçu.

-------------

Person

C'est vous qui avez introduit cette classe, je ne sais toujours pas ce que signifie "Person".
"Person"nalisation ???
Si c'est lié à votre déclaration "const class Person {...}", cela n'a pas de sens de marquer une classe "const".
Visual Studio est "gentil" et laisse passer mais d'autres compilateurs, comme GCC, considèrent que c'est une erreur.
Donc, pourquoi avoir mis "const" devant "class Person {...}" ?
Ce type d'erreur avec des "const" qui n'ont aucun sens, comme des déclaration/définition de fonction de la forme "const void NomDUneFonction", vous en avez "commis" pas mal, malgré mes remarques dessus.
En augmentant le niveau de warning à "/Wall", Visual Studio vous réprimandera sur ces "const void NomDUneFonction".
Avez-vous compris le sens de "const" ?
Si oui, pouvez-vous justifier son utilisation dans "const class Person {...}" et les fonctions "const void NomDUneFonction" ?

-------------

if (affichage_x_sj_actif && ...)

Je suppose que c'est lié à ma remarque :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (affichage_x_sj_actif && (m_sur != L"Disney+" || m_sur != L"Netflix"))

C'est la même chose que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (affichage_x_sj_actif)

Car "(m_sur != L"Disney+" || m_sur != L"Netflix")", c'est toujours vrai.

Pouvez-vous me donner une valeur pour "m_sur" où l'expression '(m_sur != L"Disney+" || m_sur != L"Netflix")' sera "fausse" ?

-------------

Si la variable "dates_str" est égale à "2018-05-01 VOD Orange"

J'ai déjà pas mal détaillé, non ? : (voir le texte dans le post original du "02/10/2024, 21h27" car la mise en page à "sauté")

C'est le constructeur de "SequenceVisionnage_film" qui est utilisé dans le dernier code du dépôt Github et plus le constructeur de "InfosVisionnage", donc les constantes ont des valeurs différentes que lors de mes précédentes remarques.
Ces constantes sont là pour savoir ce que devrait contenir chaque capture de l'expression régulière (capture = (x.x.x)).

Dans la boucle while :

La valeur de la variable "dates_format" est :
((([[:digit:]]{4})-([[:digit:]]{2})-([[:digit:]]{2})|([[:digit:]]{2})-([[:digit:]]{2})|([[:digit:]]{2}))(_?))

Si la variable "dates_str" est égale à "2018-05-01 VOD Orange" :
dates_match[0/dates_full_match_index] : c'est l'ensemble de tout ce qui est capturable => 2018-05-01 VOD Orange
dates_match[1/xxxxxxxxxxxxxxxxxxxx] : c'est ce qui est capturé par () => 2018-05-01 VOD Orange
dates_match[2/xxxxxxxxxxxxxxxxxxxx] : c'est ce qui est capturé par () => 2018-05-01 VOD Orange
dates_match[3/dates_date_year_month_day_year_index] : c'est ce qui est capturé par () => 2018
dates_match[4/dates_date_year_month_day_month_index] : c'est ce qui est capturé par () => 05
dates_match[5/dates_date_year_month_day_day_index] : c'est ce qui est capturé par () => 01
dates_match[6/dates_date_month_day_month_index] : c'est ce qui est capturé par () => (rien)
dates_match[7/dates_date_month_day_day_index] : c'est ce qui est capturé par () => (rien)
dates_match[8/dates_date_day_day_index] : c'est ce qui est capturé par () => (rien)
dates_match[9/xxxxxxxxxxxxxxxxxxxxxxx] : c'est ce qui est capturé par () => (rien)
dates_match[10/dates_someFlag_index] : aucune capture "()" ne correspond à la valeur 10 => (rien)

Vous devriez faire le ménage dans les constantes dans la fonction "SequenceVisionnage_film::SequenceVisionnage_film", il y en a partout (oui, c'est un peu de ma faute avec mes exemples qui décortiquent un peu le procédé).
Beaucoup ne correspondent à rien (cf. dates_someFlag_index) ou sont même fausses (cf. filename_stream_index ci-après).
Quand vous modifiez les expressions régulières, il faut systématiquement corriger ces constantes.
Il y a moyen de faire en sorte d'utiliser des "noms" à la place des numéros d'ordre, mais il faut que vous compreniez le concept de capture avant ça, et c'est pas encore dans le C++ "standard", je crois.
https://regex101.com/r/ZWx27Q/1 pour un exemple d'utilisation.
Mais les indices utilisés dans la boucle "while" semblent correctes, mais si vous utilisez d'autres constantes, vous aurez des "surprises".

Maintenant avec l'expression régulière "filename_format_rg" :
(((([[:digit:]]{4})-([[:digit:]]{2})-([[:digit:]]{2})|([[:digit:]]{2})-([[:digit:]]{2})|([[:digit:]]{2}))(_?))+)(\s(.+))?

Si la variable "str" est égale à "2018-05-01 VOD Orange" :
match[11/filename_stream_index] : c'est ce qui est capturé par () => "_VOD Orange"
match[12/xxxxxxxxxxxxxxxxxxxx] : c'est ce qui est capturé par () => "VOD Orange"

Votre constante "filename_stream_index" est égale à 11 donc le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if (match[filename_stream_index].matched)
{
    m_streaming = match[filename_stream_index];
}

fait que la variable "m_streaming" contient "_VOD Orange" et non "VOD Orange".
Donc, si votre constante "filename_stream_index" aurait été égale à 12, le résultat aurait été "correcte".

Je vous laisse vérifier que les autres constantes "filename_stream_xxx" sont "bonnes".
Quand vous modifiez les expressions régulières, il faut systématiquement corriger ces constantes.(bis)

En résumé, vos constantes sont fausses, il faut les corriger. Quitte à utiliser le débogueur pour comprendre où et quand elles sont fausses.

-------------

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void Serie::Print_Header() const{...}

J'avais proposé une version bien plus simple qui n'utilise pas les champs "affichage_xxx".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void Serie::Print_Header() const
{
    std::wstring titres_str = calcul_Titres_Affichage();
    std::wstring annees_str= format_Annees();
    std::wstring sur_str = calcul_Sur_Affichage();
    std::wstring anneesEtSur_str = format_AnneesEtSur(annees_str, sur_str);
    // les 3 lignes du dessus peuvent être remplacées par un truc comme "std::wstring anneesEtSur_str  = calcul_AnneesEtSur_Affichage()";
    std::wstring signaletique_jeunesse_str = calcul_signaletique_jeunesse_affichage();
   std::wstring duree_str = calcul_duree_affichage();
   std::wstring note_str = calcul_Note_Affichage();
 
   std::wcout << titres_str << anneesEtSur_str << signaletique_jeunesse_str << duree_str << note_str << std::endl;
}

Ok pour utiliser les champs "affichage_xxx" dans "Print_Header", mais alors vous ne devriez pas vous en servir dans les fonctions "calcul_xxx".
Sinon, vous allez vous prendre la tête à comprendre votre code.
Quand on peut faire les choses en ne testant une condition qu'à un seul endroit, on le fait.
Et de préférence à l'endroit le plus "logique".
Pour moi, s'aurait été dans les fonctions "calcul_xxx".
Mais dans "Print_Header", c'est OK.
Mais dans "Print_Header" et dans les fonctions "calcul_xxx", c'est PAS OK.

Pourquoi passer par des "+=" plutôt que des "=" directement ??? :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

duree_str += calcul_duree_affichage();

VS

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

duree_str = calcul_duree_affichage();

[Laurent_B_]

Presque :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void Serie::Print_Header() const
{
    std::wstring titres_str = calcul_Titres_Affichage();
    std::wstring annees_str = format_Annees();
    //std::wstring sur_str = calcul_Sur_Affichage();
    std::pair<std::wstring, std::wstring> sur_str = calcul_Sur_Affichage();
    std::wstring anneesEtSur_str = format_AnneesEtSur(annees_str, sur_str);
    std::pair<std::wstring, std::wstring> x_signaletique_jeunesse_str = calcul_x_signaletique_jeunesse_affichage(sur_str);
    std::wstring signaletique_jeunesse_str = calcul_signaletique_jeunesse_affichage();
    std::wstring duree_str = calcul_duree_affichage();
    std::wstring note_str = calcul_Note_Affichage();
    // Note
    //if (affichage_note_actif)
    //    note_str = calcul_Note_Affichage();
 
    std::wcout << titres_str << anneesEtSur_str << x_signaletique_jeunesse_str.first << signaletique_jeunesse_str << duree_str << note_str << std::endl;
}

https://github.com/laurentbouleau/Exemple : Octobre 07 (17/10/2024)

Merci

[Laurent_B_]

Bonjour,

https://github.com/laurentbouleau/Exemple : Octobre 08 (18/10/2024)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void Serie::Print_Header() const
{
    std::wstring titres_str = calcul_Titres_Affichage();
    std::wstring annees_str = format_Annees();
    std::pair<std::wstring, std::wstring> sur_str = calcul_Sur_Affichage();
    std::wstring anneesEtSur_str = format_AnneesEtSur(annees_str, sur_str);
    std::pair<std::wstring, std::wstring> x_signaletique_jeunesse_str = calcul_x_signaletique_jeunesse_affichage(sur_str);
    std::wstring signaletique_jeunesse_str = calcul_signaletique_jeunesse_affichage();
    std::wstring duree_str = calcul_duree_affichage();
    std::wstring note_str = calcul_Note_Affichage();
 
    std::wcout << titres_str << anneesEtSur_str << x_signaletique_jeunesse_str.first << signaletique_jeunesse_str << duree_str << note_str << std::endl;
}

Ok ou pas ?

Merci

[Laurent_B_]

Bonsoir,

https://github.com/laurentbouleau/Exemple : Octobre 09 (18/10/2024)

Film.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void Film::Print_Header() const
{
    std::wstring titres_str = calcul_Titres_Affichage();
    std::wstring date_str = calcul_Date_Affichage();
    std::pair<std::wstring, std::wstring> sur_str = calcul_Sur_Affichage();
    std::wstring dateEtSur_str = format_DateEtSur(date_str, sur_str);
    std::pair<std::wstring, std::wstring> x_signaletique_jeunesse_str = calcul_X_Signaletique_Jeunesse_affichage(sur_str);
    std::wstring signaletique_jeunesse_str = calcul_Signaletique_Jeunesse_affichage();
    std::wstring duree_str = calcul_Duree_affichage();
    std::wstring note_str = Print_Note();
 
    std::wcout << titres_str << dateEtSur_str << x_signaletique_jeunesse_str.first << signaletique_jeunesse_str << duree_str << note_str << std::endl;
}

Ok ou pas ?

Merci

[Laurent_B_]

https://github.com/laurentbouleau/Exemple : Octobre 10 (18/10/2024)

Exemple : film.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
std::wstring Film::calcul_Duree_affichage() const
{
    // Durée
    std::wstring duree_str;
    if (affichage_duree_actif)
        //duree_str = L' ' + std::to_wstring(m_duree / (60 * 60)) + m_keyColor[0] + L"h" + m_valuesColor + L' ' + 
        //           std::to_wstring((m_duree - ((m_duree / (60 * 60)) * 60 * 60)) / 60) + m_keyColor[0] + L"min" + m_valuesColor;
        duree_str = L' ' + std::to_wstring(m_duree / (60 * 60)) + m_keyColor[0] + m_h + m_valuesColor + L' ' +
                    std::to_wstring((m_duree - ((m_duree / (60 * 60)) * 60 * 60)) / 60) + m_keyColor[0] + m_min + m_valuesColor;
    return duree_str;
}

Voilà !

[Laurent_B_]

Bonsoir bacelar,

https://github.com/laurentbouleau/Exemple : Octobre 11 (19/10/2024)

J'ai déjà pas mal détaillé, non ? : (voir le texte dans le post original du "02/10/2024, 21h27" car la mise en page à "sauté")

Plus tard !!!

film.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class Film
{
    bool m_espace1{false};
    std::pair<std::wstring, std::wstring> m_h;
    std::pair<std::wstring, std::wstring> m_min;
    bool m_espace2{false};
    bool m_espace3{false};
    std::vector<std::wstring>m_keyColor;// { L"\x1b[94;1m", L"\x1b[38;2;0;255;0m" }; // keyColor[0] (bleu) et keyColor[1] (vert)
    std::wstring m_valuesColor;// { L"\x1b[38;2;255;255;255m" }; // Blanc
...
}

Et : film.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
std::wstring Film::calcul_Duree_affichage() const
{
    // Durée
    std::wstring duree_str;
    if (affichage_duree_actif)
        //duree_str = L' ' + std::to_wstring(m_duree / (60 * 60)) + m_keyColor[0] + L"h" + m_valuesColor + L' ' + 
        //           std::to_wstring((m_duree - ((m_duree / (60 * 60)) * 60 * 60)) / 60) + m_keyColor[0] + L"min" + m_valuesColor;
        //duree_str = L' ' + std::to_wstring(m_duree / (60 * 60)) + m_keyColor[0] + m_h + m_valuesColor + L' ' +
        //            std::to_wstring((m_duree - ((m_duree / (60 * 60)) * 60 * 60)) / 60) + m_keyColor[0] + m_min + m_valuesColor;
        duree_str = L' ' + std::to_wstring(m_duree / (60 * 60)) + m_keyColor[0] + (m_espace1 ? L" " : L"") + m_h.first + m_valuesColor + (m_espace2 ? L" " : L"") +
                    std::to_wstring((m_duree - ((m_duree / (60 * 60)) * 60 * 60)) / 60) + m_keyColor[0] + (m_espace3 ? L" " : L"") + m_min.first + m_valuesColor;
        return duree_str;
}

Comment faire ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
void Film::set_Person(const Person& person)
{
    m_espace1 = person.m_espace1;
    m_h = person.m_h;
    m_espace2 = person.m_espace2;
    m_espace3 = person.m_espace3;
    m_min = person.m_min;
    m_keyColor = person.m_keyColor;
    m_valuesColor = person.m_valuesColor;
}

Ok ou pas ?

film.serie.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
const class X_Person
{
public:
    // _ h _ _ min
    std::pair<bool, bool> m_espace1{ false, true };
    std::vector<std::pair<std::wstring, std::wstring>> m_h{ {L"h", L"h"}, {L"H", L"H"}, {L"heure", L"heures"}, {L"Heure", L"Heures"}, {L"HEURE", L"HEURES"} };
    std::pair<bool, bool> m_espace2{ false, true };
    std::pair<bool, bool> m_espace3{ false, true };
    std::vector<std::pair<std::wstring, std::wstring>> m_min{ {L"min", L"min"}, {L"Min", L"Min"}, {L"MIN", L"MIN"}, {L"minute", L"minutes"}, {L"Minute", L"Minutes"}, {L"MINUTE", L"MINUTES"} };
 
    std::vector<std::wstring> m_keyColor{ L"\x1b[94;1m", L"\x1b[38;2;0;255;0m", L"\x1b[38;2;255;0;0m", L"\x1b[38;2;255;255;0m" };
    std::wstring m_valuesColor{ L"\x1b[38;2;255;255;255m" }; // Blanc
};
 
class Person
{
public:
    //void Personnalisation_Affichage();
//private:
    // _ h _ _ min
    bool m_espace1;
    std::pair<std::wstring, std::wstring> m_h;
    bool m_espace2;
    bool m_espace3;
    std::pair<std::wstring, std::wstring> m_min;
 
    std::vector<std::wstring> m_keyColor;
    std::wstring m_valuesColor;
};

Ok ou pas ?
Mais : set_Person(...) et/ou get_Person(...) ???

Exemple : Exemple.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int wmain(int argc, wchar_t* argv[])
{
...
    X_Person x_person;
    Person person;
 
    person.m_espace1 = x_person.m_espace1.second;
    person.m_h = x_person.m_h[2];
    person.m_espace2 = x_person.m_espace2.second;
    person.m_espace3 = x_person.m_espace3.second;
    person.m_min = x_person.m_min[3];
    person.m_keyColor = x_person.m_keyColor;
    person.m_valuesColor = x_person.m_valuesColor;
...
}

Que faire ? (set_Person(...) et/ou get_Person(...))

Et :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    std::pair<std::wstring, std::wstring> m_h;
    std::pair<std::wstring, std::wstring> m_min;

0 ou 1 : heure
2 et plus :heures

Merci vairement

[Laurent_B_]

Bonsoir,

https://github.com/laurentbouleau/Exemple : Octobre 12 (20/10/2024)

film.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
SequenceVisionnage_film::SequenceVisionnage_film(fs::path const& m_cheminFichier)
{
    //
    // (((([[:digit:]]{4})-([[:digit:]]{2})-([[:digit:]]{2})|([[:digit:]]{2})-([[:digit:]]{2})|([[:digit:]]{2}))(_?))+)(\s(.+))?
    // ???
    const std::wstring date_year_month_day_format = L"([[:digit:]]{4})-([[:digit:]]{2})-([[:digit:]]{2})";
    const std::wstring date_month_day_format = L"([[:digit:]]{2})-([[:digit:]]{2})";
    const std::wstring date_day_format = L"([[:digit:]]{2})";
    const std::wstring stream_format = L"(\\s(.+))?";
    const std::wstring dates_format = L"((" + date_year_month_day_format + L"|" + date_month_day_format + L"|" + date_day_format + L")(_?))";
 
    const int dates_full_match_index = 0;
    const int dates_date_year_month_day_year_index = dates_full_match_index + 3;
    const int dates_date_year_month_day_month_index = dates_date_year_month_day_year_index + 1;
    const int dates_date_year_month_day_day_index = dates_date_year_month_day_month_index + 1;
    const int dates_date_month_day_month_index = dates_date_year_month_day_day_index + 1;
    const int dates_date_month_day_day_index = dates_date_month_day_month_index + 1;
    const int dates_date_day_day_index = dates_date_month_day_day_index + 1;
    const int dates_someFlag_index = dates_date_day_day_index + 2;
 
    const std::wregex filename_format_rg{ L"(" + dates_format + L"+)" + stream_format };
 
    const int filename_dates_index = 0;
    const int filename_date_year_month_day_year_index = filename_dates_index + 2;
    const int filename_date_year_month_day_month_index = filename_date_year_month_day_year_index + 1;
    const int filename_date_year_month_day_day_index = filename_date_year_month_day_month_index + 1;
    const int filename_date_month_day_month_index = filename_date_year_month_day_day_index + 1;
    const int filename_date_month_day_day_index = filename_date_month_day_month_index + 1;
    const int filename_date_day_day_index = filename_date_month_day_day_index + 1;
    const int filename_someFlag_index = filename_date_day_day_index + 2;
    const int filename_stream_index = filename_someFlag_index + 2;
 
    auto nomFichier = m_cheminFichier.wstring();
 
    assert(nomFichier.length() > 0 && L"Nom de fichier film vide");
 
    auto stem = m_cheminFichier.stem().wstring();
    // prefixe ???
    assert(std::regex_match(stem, filename_format_rg) && L"Le nom du fichier n'est pas valide");
 
    std::wsmatch match;
    auto str = stem;
    //Exemple assez complexe de nom de fichier
    std::regex_match(str, match, filename_format_rg);
 
    std::wsmatch dates_match;
    auto dates_str = match[filename_dates_index].str();
    while (std::regex_search(dates_str, dates_match, std::wregex{ dates_format }))
    {
        if (dates_match[dates_date_year_month_day_year_index].matched)
        {
            auto year = std::stoi(dates_match[dates_date_year_month_day_year_index]);
            auto month = std::stoi(dates_match[dates_date_year_month_day_month_index]);
            auto day = std::stoi(dates_match[dates_date_year_month_day_day_index]);
 
            assert(checkyear(year));
            assert(checkmonth(month));
            assert(checkday(month, day, year));
 
            DateRecord dr{ {0,0,0,day,month - 1,year - 1900} };
 
            m_DatesVisionnage.emplace_back(dr);
        }
        else if (dates_match[dates_date_month_day_month_index].matched)
        {
            assert(m_DatesVisionnage.size() > 0 && L"Utilisation d'un format mois-jour sans avoir d'année déduite.");
 
            auto month = std::stoi(dates_match[dates_date_month_day_month_index]);
            auto day = std::stoi(dates_match[dates_date_month_day_day_index]);
 
            auto lastDateRecord = m_DatesVisionnage.back();
            auto last_year = lastDateRecord.date.tm_year + 1900;
 
            assert(checkmonth(month));
            assert(checkday(month, day, last_year));
 
            DateRecord dr{ {0,0,0,day,month - 1,last_year - 1900} };
 
            m_DatesVisionnage.emplace_back(dr);
        }
        else if (dates_match[dates_date_day_day_index].matched)
        {
            assert(m_DatesVisionnage.size() > 0 && L"Utilisation d'un format jour sans avoir de mois et d'années déduits.");
 
            auto day = std::stoi(dates_match[dates_date_day_day_index]);
 
            auto lastDateRecord = m_DatesVisionnage.back();
            auto last_year = lastDateRecord.date.tm_year + 1900;
            auto last_month = lastDateRecord.date.tm_mon + 1;
 
            assert(checkday(last_month, day, last_year));
 
            DateRecord dr{ {0,0,0,day,last_month - 1,last_year - 1900} };
 
            m_DatesVisionnage.emplace_back(dr);
        }
        else
        {
            assert(true && L"format de date d'épisode inconnu.");
        }
 
        if (dates_match[dates_someFlag_index].matched)
        {
            m_DatesVisionnage.back().someFlag = true;
        }
 
        dates_str = dates_match.suffix().str();
    }
 
    if (match[filename_stream_index].matched)
    {
        m_streaming = match[filename_stream_index];
    }
 }

Pourquoi ? Je ne sais plus comment faire !
Pouvez-vous corriger ? Mais simple !!!

Mais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    // (((([[:digit:]]{4})-([[:digit:]]{2})-([[:digit:]]{2})|([[:digit:]]{2})-([[:digit:]]{2})|([[:digit:]]{2}))(_?))+)(\s(.+))?
    // ???

et:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

    assert(nomFichier.length() > 0 && L"Nom de fichier film vide");

Merci

[bacelar]

Post du "17/10/2024, 23h50".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
void Serie::Print_Header() const
{
...
    std::pair<std::wstring, std::wstring> sur_str = calcul_Sur_Affichage();
    std::wstring anneesEtSur_str = format_AnneesEtSur(annees_str, sur_str);
    std::pair<std::wstring, std::wstring> x_signaletique_jeunesse_str = calcul_x_signaletique_jeunesse_affichage(sur_str);
...
 
    std::wcout << titres_str << anneesEtSur_str << x_signaletique_jeunesse_str.first << signaletique_jeunesse_str << duree_str << note_str << std::endl;
}

Tout ce qui est en rouge montre que vous vous compliquez la fonction "Serie;; Print_Header" inutilement.
Elle ne devrait avoir aucune connaissance de ces détails, pour qu'elle ne change pas en fonction de la représentation interne des données, mais uniquement si le format d'affichage "général" de l'en-tête change.
Les "std::pair" sont particulièrement mauvaises car, avec plus d'une plateforme de diffusion, vous êtes obligé de changer la signature de ces fonctions et donc le code appelant.
"Serie:: Print_Header" n'a pas à connaitre ces détails. Les fonctions "xxx_affichage" ne devraient retourner que des "std::wstring".
---------------------

Post du "18/10/2024, 12h20"
Même code "nettoyé" donc mêmes remarques.
---------------------

Post du "18/10/2024, 20h12"
Mêmes erreurs que vous propagez à la classe "Film".
La définition de la fonction "Film::calcul_X_Signaletique_Jeunesse_affichage" montre aussi que vous vous servez très mal de cette structure "std::pair" car vous n'utilisez jamais sont champ "second" pour faire le travail.
En utilisant ce champ, votre code serait bien plus simple et bien plus robuste aux changements.

Pour la fonction "Film::calcul_Duree_affichage", utilisez des variables intermédiaires :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
std::wstring Film::calcul_Duree_affichage() const
{
    std::wstring duree_str;
    if (affichage_duree_actif)
        long heures = m_duree / (60 * 60);
        long minutes = (m_duree % (60 * 60)) / 60;
        long secondes = m_duree % 60; 
        duree_str = L' ' + std::to_wstring(heures) + m_keyColor[0] + L"h" + m_valuesColor + L' ' + 
                   std::to_wstring(minutes ) + m_keyColor[0] + L"min" + m_valuesColor;
    return duree_str;
}

---------------------

Post du "18/10/2024, 22h43"

Utilisation d'une classe "X_Person" pourquoi faire ?
Des noms "corrects", SVP !
Vous complexifiez énormément par rapport à la classe "Person", en ajoutant des "std::vector" pour tous les champs, pour rien.
Quels avantages par rapport à un simple "std::vector<Person>" ???

Dans la classe "Person", vous collez des "std::pair" partout, mais il n' y a que son champ "second" qui sert, vous vous prenez la tête pour rien.

Tout ça pour personnaliser des résultats de fonctions comme "Film::calcul_Duree_affichage" qui seraient bien plus lisibles avec l'utilisation de simple chaines de formatage (déjà évoquées précédemment) :
https://stackoverflow.com/questions/...g-like-sprintf
En plus, ça fait plein de champs dans les classes "Film" et "Serie" en plus de la classe "Person".
---------------------

Post du "19/10/2024, 22h29" :
Toujours en train de faire des trucs complexes, trop complexes.
Pourquoi ne pas utiliser "heure(s)", par exemple.

Si vous voulez vraiment "marquer" le pluriel:
(utilisez des types simples SVP, exemple pourquoi m_espace1 n'est pas une std::wstring ?)
(mais pensez à utiliser les primitives de formatage RAPIDEMENT !)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
std::wstring Film::calcul_Duree_affichage() const
{
    std::wstring duree_str;
    if (affichage_duree_actif)
        long heures = m_duree / (60 * 60);
        long minutes = (m_duree % (60 * 60)) / 60;
        long secondes = m_duree % 60; 
        duree_str = L' ' + std::to_wstring(heures) + m_keyColor[0] + m_espace1 + ( heures >1 ? m_h.first : m_h.second) + m_valuesColor + m_espace2 + 
                   std::to_wstring(minutes) + m_keyColor[0] +m_espace3 + ( minutes>1 ? m_min.first : m_min.second) + m_valuesColor;
        return duree_str;
}

Mais : set_Person(...) et/ou get_Person(...) ???

Vous avez un champ "Person" dans la classe "Film" ou "Serie" ?
NON
Donc, ni l'un, ni l'autre.

Soyez logique et clair.
Vous n'avez toujours pas explicité ce qu'est "Person", BORDEL !
Bon, on va dire que la classe "Person" sert à "personnaliser l'affichage".
Pourquoi faire au juste, je ne sais toujours pas.
Avoir un affichage spécifique en fonction des réglages de l'utilisateur ?

Donc un nom/signature comme "AffichagePersonnaliser(const AffichagePersonnalisation& perso)" me parait "logique".
---------------------

Post du "20/10/2024, 23h20

(((([[:digit:]]{4})-([[:digit:]]{2})-([[:digit:]]{2})|([[:digit:]]{2})-([[:digit:]]{2})|([[:digit:]]{2}))(_?))+)(\s(.+))?

Numérotez de 1 à 12, de gauche à droites, les captures dans cette expression régulière.

[Laurent_B_]

Bonsoir,

https://github.com/laurentbouleau/Exemple : Octobre 13 (21/10/2024)

void Film:: Print_Header() const : ok !
void Serie:: Print_Header() const : ok !

Les "std::pair" sont particulièrement mauvaises car, avec plus d'une plateforme de diffusion, vous êtes obligé de changer la signature de ces fonctions et donc le code appelant.
"Serie:: Print_Header" n'a pas à connaitre ces détails. Les fonctions "xxx_affichage" ne devraient retourner que des "std::wstring".
---------------------

Post du "18/10/2024, 12h20"
Même code "nettoyé" donc mêmes remarques.
---------------------

Post du "18/10/2024, 20h12"
Mêmes erreurs que vous propagez à la classe "Film".
La définition de la fonction "Film::calcul_X_Signaletique_Jeunesse_affichage" montre aussi que vous vous servez très mal de cette structure "std::pair" car vous n'utilisez jamais sont champ "second" pour faire le travail.

Ok ou pas ?

Ensuite,

Merci

[Laurent_B_]

Bonsoir,

https://github.com/laurentbouleau/Exemple : Octobre 14 (22/10/2024)

Donc un nom/signature comme "AffichagePersonnaliser(const AffichagePersonnalisation& perso)" me parait "logique".

Pas de solution !!!

Mais :
Exemple.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
...
int wmain(int argc, wchar_t* argv[])
{
...
    X_Person x_person;
    Person person;
    person.AffichagePersonnaliser(x_person);
...
        film.set_Person(person);
        film.Print();
...
}
...

film_serie.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
...
const class X_Person;
 
class Person
{
public:
    void AffichagePersonnaliser(const X_Person& perso);
    //void Personnalisation_Affichage();
//private:
    // _ h _ _ min
    std::wstring m_espace1;
    std::pair<std::wstring, std::wstring> m_h;
    std::wstring m_espace2;
    std::wstring m_espace3;
    std::pair<std::wstring, std::wstring> m_min;
 
    std::vector<std::wstring> m_keyColor;
    std::wstring m_valuesColor;
};
 
const class X_Person
{
public:
    //void AffichagePersonnalisation();
    // _ h _ _ min
    std::pair<bool, bool> m_espace1{ false, true };
    std::vector<std::pair<std::wstring, std::wstring>> m_h{ {L"h", L"h"}, {L"H", L"H"}, {L"heure", L"heures"}, {L"Heure", L"Heures"}, {L"HEURE", L"HEURES"} };
    std::pair<bool, bool> m_espace2{ false, true };
    std::pair<bool, bool> m_espace3{ false, true };
    std::vector<std::pair<std::wstring, std::wstring>> m_min{ {L"min", L"min"}, {L"Min", L"Min"}, {L"MIN", L"MIN"}, {L"minute", L"minutes"}, {L"Minute", L"Minutes"}, {L"MINUTE", L"MINUTES"} };
 
    std::vector<std::wstring> m_keyColor{ L"\x1b[94;1m", L"\x1b[38;2;0;255;0m", L"\x1b[38;2;255;0;0m", L"\x1b[38;2;255;255;0m" };
    std::wstring m_valuesColor{ L"\x1b[38;2;255;255;255m" }; // Blanc
};

film_serie.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
...
void Person::AffichagePersonnaliser(const X_Person& perso)
{
    m_espace1 = (perso.m_espace1.second ? L" " : L"");
    m_h = perso.m_h[2];
    m_espace2 = (perso.m_espace2.second ? L" " : L"");
    m_espace3 = (perso.m_espace1.second ? L" " : L"");
    m_min = perso.m_min[3];
    m_keyColor = perso.m_keyColor;
    m_valuesColor = perso.m_valuesColor;
}

film.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
...
void Film::set_Person(const Person& person)
{
    m_espace1 = person.m_espace1;
    m_h = person.m_h;
    m_espace2 = person.m_espace2;
    m_espace3 = person.m_espace3;
    m_min = person.m_min;
    m_keyColor = person.m_keyColor;
    m_valuesColor = person.m_valuesColor;
}
...

Comment faire pour AffichagePersonnaliser(const AffichagePersonnalisation& perso) ?

Et :

• m_espace1 = (perso.m_espace1.second ? L" " : L"");
  std::wstring& e_1_1 = (perso.m_espace1.second ? L" " : L""); ???
• m_h = perso.m_h[2];
  std::pair<std::wstring, std::wstring>& h_2 = perso.m_h[2]; ???

Mais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int i = 3;
int& j = i;

Ok !
Pourquoi ???

Merci d'avance

[Laurent_B_]

const class X_Person :
std::pair<bool, bool> m_espace1{ false, true }; ===> std::pair<std::wstring, std::wstring> m_espace1 = { L"", L" " };
ou
std::pair<bool, bool> m_espace1{ false, true }; ===> std::vector<std::wstring> m_espace1 = { L"", L" " };

Merci

[bacelar]

Post du "21/10/2024, 20h53"

Ok ou pas ?

Plutôt OK avec les modifications.
Ne trouvez-vous pas le code plus lisible ainsi ?

Quelques remarques :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
SequenceVisionnage_film::SequenceVisionnage_film(fs::path const& m_cheminFichier)
{
...
    assert(nomFichier.length() > 0 && L"Nom de fichier Episode vide");
...
}

Le "Episode" qui traine dans une fonction d'une classe "SequenceVisionnage_film", ça montre qu'il y a beaucoup de copier-coller de code.
Et c'est jamais très bon.
Essayez de structurer votre code pour qu'il n'y ait pas tant de copier-coller.
(fonctions communes, héritages de classe, etc...)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
std::wstring Film::calcul_Sur_Affichage() const
{
    std::wstring sur_str;
    // sur
    if (affichage_sur_actif)
    {
        if (m_sur == L"")
            return L"";
        if (m_sur == L"Disney+")
            sur_str = m_sur;
        else if (m_sur == L"Netflix")
            sur_str = m_sur;
        else
            sur_str = m_sur;
    }
    return sur_str;
}

Ayez un œil critique sur votre code pour le simplifier directement quand vous améliorez votre conception :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
std::wstring Film::calcul_Sur_Affichage() const
{
    std::wstring sur_str;
    // sur
    if (affichage_sur_actif)
    {
            sur_str = m_sur;
    }
    return sur_str;
}

---------------------

Post du "22/10/2024, 22h56"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
...
int wmain(int argc, wchar_t* argv[])
{
...
    X_Person x_person;
    Person person;
    person.AffichagePersonnaliser(x_person);
...
        film.set_Person(person);
        film.Print();
...
}
...

C'est d'une complexité démentielle ce truc!!!
Quand je parlais d'une fonction "AffichagePersonnaliser(const AffichagePersonnalisation& perso)", c'est à la place de "Film::set_Person(const Person& person)".
Car "set_Person", c'est pas logique car on n'a pas de champ "m_person" dans la classe "Film".
Si la classe "Person" sert à personnaliser un affichage, elle devrait donc plutôt s'appeler "AffichagePersonnalisation" et pas "Person".
Et "Film::set_Person(const Person& person)" ne "set" pas un champ "m_person", mais personnalise l'affichage de l'objet ; donc l'appeler "Film::AffichagePersonnaliser" me parait logique, avec les règles de codage demandant d'utiliser des verbes d'actions pour les fonctions "d'action".

Je ne comprends pas trop votre "obsession" de la personnalisation de l'affichage d'un objet, avec des ribambelles de booléens "affichage_xxx_actifs" et vos classes "Person" et "X_Person".
Vous êtes encore largement en période d'analyse et de conception. Le paramétrage d'un affichage, qui n'a pas à être générique, peut très facilement attendre la fin de la conception.
Si l'architecture n'est pas trop pourrie, cette personnalisation ne posera aucun problème plus tard.

Si l'on en croit l'extrait de "wmain", "X_Person" serait une classe de "Personnalisation" de la classe "Person", elle-même une classe de "Personnalisation" de la classe "Film" (Pourquoi pas la classe "Serie" aussi ?).
Vous comptez en empiler combien de couche de personnalisation ???
En utilisant des noms judicieux, on peut facilement comprendre qu'on fait un peu n'importe quoi.

Donc si vous voulez vraiment gérer une personnalisation de l'affichage Film à l'extérieur de la classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int wmain(int argc, wchar_t* argv[])
{
...
    AffichagePersonnalisation person = getCurrentAffichagePersonnalisation();//fonction à implémenter pour récupérer la configuration de personnalisation de l'utilisateur.
...
        film.AffichagePersonnaliser(person);
        film.Print();
...
}

Mais tous ces trucs de personnalisation d'affichage m'exaspèrent un peu car il est clair que l'affichage du contenu des classes "Film" et "Serie" n'ont rien à y foutre.
Normalement, les classes "Film" et "Serie" devraient être les mêmes, que l'affichage se fasse sur une console ou dans une interface graphique en 3D de la mort qui tue.
C'est (les classes "Film" et "Serie") des classes "Metier/Business" qui n'ont pas à dépendre de l'interphase Homme-Machine.
---------------------

Post du "23/10/2024, 03h17"

const class X_Person :
std::pair<bool, bool> m_espace1{ false, true }; ===> std::pair<std::wstring, std::wstring> m_espace1 = { L"", L" " };
ou
std::pair<bool, bool> m_espace1{ false, true }; ===> std::vector<std::wstring> m_espace1 = { L"", L" " };

Merci

Comme la classe X_Person n'a aucun sens pour moi et que je ne comprends toujours pas pourquoi les "m_espaceX" ne sont pas juste des "std::wstring" (en attendant de dégager tout ce bordel d'affichage de ces classes), je ne comprends donc pas votre question.

[Laurent_B_]

Ok ! Adent !

https://github.com/laurentbouleau/Exemple : Octobre 15 (23/10/2024)

film_serie.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
const class X_Person;
...
class Person
{
public:
    void AffichagePersonnaliser(const X_Person& perso);
    //void Personnalisation_Affichage();
//private:
    // _ h _ _ min
    std::wstring m_espace1;
    std::vector<std::wstring> m_h{};
    std::wstring m_espace2;
    std::wstring m_espace3;
    std::vector<std::wstring> m_min{};
 
    std::vector<std::wstring> m_keyColor;
    std::wstring m_valuesColor;
};
 
const class X_Person
{
public:
    //void AffichagePersonnalisation();
    // _ h _ _ min
    std::vector<std::wstring> m_espace1{L"", L" "};
    std::vector<std::wstring> m_h { L"h", L"",        // 0 et 1
                                    L"H", L"",        // 2 et 3
                                    L"heure", L"s",   // 4 et 5
                                    L"Heure", L"s",   // 6 et 7
                                    L"HEURE", L"S" }; // 8 et 9
    std::vector<std::wstring> m_espace2{ L"", L" " };
    std::vector<std::wstring> m_espace3{ L"", L" " };
    std::vector<std::wstring> m_min{ L"min", L"",      // 0 et 1
                                     L"Min", L"",      // 2 et 3
                                     L"MIN", L"",      // 4 et 5
                                     L"minute", L"s",  // 6 et 7
                                     L"Minute", L"s",  // 8 et 9
                                     L"MINUTE", L"S"}; // 10 et 11
 
    std::vector<std::wstring> m_keyColor{ L"\x1b[94;1m", L"\x1b[38;2;0;255;0m", L"\x1b[38;2;255;0;0m", L"\x1b[38;2;255;255;0m" };
    std::wstring m_valuesColor{ L"\x1b[38;2;255;255;255m" }; // Blanc
};

film_serie.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
...
void Person::AffichagePersonnaliser(const X_Person& perso)
{
    auto &e_1_0 = perso.m_espace1[0], &e_1_1 = perso.m_espace1[1];
    auto &e_2_0 = perso.m_espace2[0], &e_2_1 = perso.m_espace2[1];
    auto &e_3_0 = perso.m_espace3[0], &e_3_1 = perso.m_espace3[1];
 
    auto &h0 = perso.m_h[0], &h1 = perso.m_h[1];
    auto &h2 = perso.m_h[2], &h3 = perso.m_h[3];
    auto &h4 = perso.m_h[4], &h5 = perso.m_h[5];
    auto &h6 = perso.m_h[6], &h7 = perso.m_h[7];
    auto &h8 = perso.m_h[8], &h9 = perso.m_h[9];
 
    auto &min0 = perso.m_min[0], &min1 = perso.m_min[1];
    auto &min2 = perso.m_min[2], &min3 = perso.m_min[3];
    auto &min4 = perso.m_min[4], &min5 = perso.m_min[5];
    auto &min6 = perso.m_min[6], &min7 = perso.m_min[7];
    auto &min8 = perso.m_min[8], &min9 = perso.m_min[9];
    auto &min10 = perso.m_min[10], &min11 = perso.m_min[11];
    //
    m_espace1 = e_1_1;
 
    m_h = { h4, h5 };
    m_espace2 = e_2_1;
    m_espace3 = e_3_1;
 
    m_min = { min6, min7 };
 
    m_keyColor = perso.m_keyColor;
    m_valuesColor = perso.m_valuesColor;
}

film.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
...
class Film
{
...
    std::wstring m_espace1;
    std::vector<std::wstring> m_h{};
    std::vector<std::wstring> m_min{};
    std::wstring m_espace2;
    std::wstring m_espace3;
    std::vector<std::wstring>m_keyColor;// { L"\x1b[94;1m", L"\x1b[38;2;0;255;0m" }; // keyColor[0] (bleu) et keyColor[1] (vert)
    std::wstring m_valuesColor;// { L"\x1b[38;2;255;255;255m" }; // Blanc
 
    std::vector<std::wstring> m_resume;
...

film.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
...
std::wstring Film::calcul_Duree_affichage() const
{
    std::wstring duree_str;
    if (affichage_duree_actif)
    {
        long heures = m_duree / (60 * 60);
        long minutes = (m_duree % (60 * 60)) / 60;
        long secondes = m_duree % 60;
        duree_str = L' ' + std::to_wstring(heures) + m_keyColor[0] + m_espace1 + (heures <= 1 ? m_h[0] : m_h[0] + m_h[1]) + m_valuesColor + m_espace2 +
            std::to_wstring(minutes) + m_keyColor[0] + m_espace3 + (minutes <= 1 ? m_min[0] : m_min[0] + m_min[1]) + m_valuesColor;
    }
    return duree_str;
}
...
void Film::set_Person(const Person& person)
{
    m_espace1 = person.m_espace1;
 
    m_h = person.m_h;
 
    m_espace2 = person.m_espace2;
    m_espace3 = person.m_espace3;
 
    m_min = person.m_min;
 
    m_keyColor = person.m_keyColor;
    m_valuesColor = person.m_valuesColor;
}
...

Exemple.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
...
    X_Person x_person;
    Person person;
    person.AffichagePersonnaliser(x_person);
...
        film.set_Person(person);
        film.Print();
...

ok !

Je suis crevé ! Je dors !
Se soir ! Ok !