Problème et AVC : _wfopen_s

Version imprimable

Voir 40 message(s) de cette discussion en une page

https://learn.microsoft.com/fr-fr/cp...?view=msvc-170 : Expressions régulières (C++)
Je suis fatigué ! Je suis crevé !!!

Exemple : Avec.txt

Citation:

azertyuiop : qsdfghjklm
azertyuiop :
azertyuiop
...

Code:

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
const std::vector<std::pair<std::wstring, std::wstring>>lire_paireCleValeur_depuisFichierTxt(std::wstring const& nomFichier, std::wstring separeteur)
{
    std::string contenuFichier{ u8"" };
    std::vector<std::pair<std::wstring, std::wstring>> clevaleurs;

    ifstream fichier{ nomFichier };
    if (!fichier)
    {
        throw std::runtime_error("Fichier impossible à ouvrir.");
    }

    contenuFichier = std::string(istreambuf_iterator<char>{fichier}, {});

    if (contenuFichier == u8"")
    {
        throw std::runtime_error("Le fichier '" + wstr_to_u8(nomFichier) + "' est vide.");
    }

    wstring_convert<codecvt_utf8<wchar_t>, wchar_t> convertiseur;
    std::wstring converti = convertiseur.from_bytes(contenuFichier);
    rtrim(converti);
    converti += L'\n';/*L"\r\n"*/;

    ???

    return clevaleurs;
}

Pouvez-vous expliquer ?

https://regex101.com/r/sEbxUp/1

Merci vraiment:aie::aie::aie:

Bonsoir,

https://github.com/laurentbouleau/Exemple : Septembre 10 (22/09/2024)

film_serie.cpp :

Code:

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
void Print_Catalogue(const std::wstring m_sur, std::vector<std::wstring>& m_catalogue, bool affichage_catalogue_actif, std::wstring& keyColor, std::wstring& m_valuesColor)
{
    // Sur == m_sur ???
    std::wstring sur = L"";
    if (affichage_catalogue_actif)
    {
        for (auto/*&*/ c : m_catalogue)
        {
            if (m_sur == c)
            {
                sur = m_sur;
                break;
            }
        }
        std::wstring sur_str;
        for (auto c : m_catalogue)
        {
            if (c == sur)
            {
                continue;
            }
            else
            {
                sur_str += keyColor + c + L" : " + m_valuesColor + L"Oui" + keyColor + L" !" + m_valuesColor + L"\r\n";
            }
        }
        std::wcout << sur_str;
    }
}

Ok ou pas ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const std::vector<std::wstring> Sur
{
    L"Amazon Prime Video",
    L"Arte",
    L"Apple TV+",
    L"Canal+",
    L"Crunchyroll",
    L"Disney+",
    L"DVD",
    L"Max",
    L"Netflix",
    L"Paramount+",
    L"SⱯLTO",
    L"TF1+",
    L"VOD"
};

Code:

1
2
3
4
5
6
7
8
9
10
std::wstring recuperer_Max_SJ(fs::path const& cheminFichier, std::vector<std::wstring>& m_catalogue)
{ // Max SJ
    auto nomFichier = cheminFichier.wstring();
    std::wstring content = lire_fichierTxt(nomFichier);
 
    auto stem = cheminFichier.stem().wstring();
    m_catalogue.push_back(stem);
 
    return filter_values(content, { L"\\-12" });
}

Pourquoi ???

Mais : avec.txt
https://regex101.com/r/sEbxUp/1 ???

Je suis crevé !!!

Merci:aie::aie::aie:

Réponse au message du "19/09/2024, 23h16" :

Citation:

Code:

const std::vector<std::pair<std::wstring, std::wstring>>lire_paireCleValeur_depuisFichierTxt(std::wstring const& nomFichier, std::wstring separeteur)...

"Ok" avec les modifications.
Votre code est quand même assujetti à comment les retours à la lignes sont encodés par une "fonction/constructeur" de la librairie standard : "ifstream fichier{ nomFichier };".
Vérifiez que cet encodage est "normalisé" en regardant documentation officielle à ce sujet.
De plus, vous utilisez des "-1", des "-2" et autres "+3" dans votre code qui ne sont corrects que si les retours chariots sont en un caractère (\r OU \n) et que le séparateur soit composé de 3 caractères.
Le séparateur est un paramètre de la fonction.
Si votre code ne fonctionne qu'avec un seul séparateur possible, autant ne pas le passer en paramètre.

Avec un séparateur " : " en dur et en utilisant des expressions régulières :
https://regex101.com/r/uvW5k5/1
(format un peu alambiqué pour coller à tous les cas possibles de votre code actuel, mais je pense que cela est simplifiable)

En ne passant plus en paramètre le séparateur mais une expression régulière qui match avec les séparateurs possibles comme :

Code:

m_soundtrack = lire_paireCleValeur_depuisFichierTxt(nomFichier, L"[[:blank:]]\\:[[:blank:]]" );

Le code de la fonction "lire_paireCleValeur_depuisFichierTxt" serait :
Code:

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 const std::vector<std::pair<std::wstring, std::wstring>>lire_paireCleValeur_depuisFichierTxt(std::wstring const& nomFichier, std::wstring separeteur_pattern) { std::string contenuFichier{ u8"" }; std::vector<std::pair<std::wstring, std::wstring>> clevaleurs; ifstream fichier{ nomFichier }; if (!fichier) { throw std::runtime_error("Fichier impossible à ouvrir."); } contenuFichier = std::string(istreambuf_iterator<char>{fichier}, {}); if (contenuFichier == u8"") { throw std::runtime_error("Le fichier '" + wstr_to_u8(nomFichier) + "' est vide."); } wstring_convert<codecvt_utf8<wchar_t>, wchar_t> convertiseur; std::wstring converti = convertiseur.from_bytes(contenuFichier); rtrim(converti); converti += L'\n'; std::size_t pos = converti.length(); if (pos == std::wstring::npos) return clevaleurs; const std::wregex line_format_rg{ L"^(.+?)?((" + separeteur_pattern + L")(.*))|(…|\\.\\.\\.)|(.+)$" }; for (std::wsregex_iterator it{ converti.begin(), converti.end(), line_format_rg }, end{}; it != end; ++it) { auto entry = *it; if (entry[5].matched) { clevaleurs.push_back(std::make_pair(L"…", L"")); } else if (entry[1].matched) { if (entry[4].matched) { clevaleurs.push_back(std::make_pair(entry[1].str(), entry[4].str())); } else { clevaleurs.push_back(std::make_pair(entry[1].str(), L"")); } } else { if (entry[4].matched) { clevaleurs.push_back(std::make_pair(L"", entry[4].str())); } else { if (entry[6].matched) { clevaleurs.push_back(std::make_pair(entry[6].str(), L"")); } } } } return clevaleurs; }
-------------------

Réponse au message du "20/09/2024, 10h02"

Les espaces devant "VOD Orange" viennent des lignes :
Code:

1 2 3 4 if (match[filename_stream_index].matched) { m_streaming = match[filename_stream_index]; }
dans la fonction/constructeur "InfosVisionnage_film::InfosVisionnage_film".
"filename_stream_index" devrait être égale à 12, pas à 11.
Vérifiez votre code.

Vous avez supprimé la structure "SequenceVisionnage_film" et enrichi la structure "InfosVisionnage_film".
Pour être "logique", vous devriez renommer votre structure "InfosVisionnage_film" en "SequenceVisionnage_film" car elle ne contient que des informations sur les séquences de visionnages, contrairement à "InfosVisionnage" des séries.

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

Réponse au message du "20/09/2024, 20h46".

Arrêtez vos bricolages, réglez le "problème" à la source. (cf. début de la réponse au message du "20/09/2024, 10h02")

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

Réponse au message du "20/09/2024, 22h24"

cf. ma réponse au message du "19/09/2024, 23h16".

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

Réponse au message du "22/09/2024, 22h47"

Citation:

film_serie.cpp :
...
Ok ou pas ?

PAS OK => KO

Pourquoi ces "m_" en préfixe des noms de paramètre, BORDEL. :evilred:

Pourquoi faire si compliqué ???
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void Print_Catalogue(const std::wstring <s>m_</s>sur, std::vector<std::wstring>& <s>m_</s>catalogue, bool affichage_catalogue_actif, std::wstring& keyColor, std::wstring& <s>m_</s>valuesColor) { std::wstring sur_str; for (auto c : catalogue) { if (c != sur) { sur_str += keyColor + c + L" : " + valuesColor + L"Oui" + keyColor + L" !" + valuesColor + L"\r\n"; } } std::wcout << sur_str; }
Citation:

Code:

std::wstring recuperer_Max_SJ(fs::path const& cheminFichier, std::vector<std::wstring>& m_catalogue)

Votre fonction fait 2 choses qui n'ont rien à voir l'une avec l'autre.
Séparez-les en 2 fonctions distinctes.

Bonsoir,

https://regex101.com/r/x0Ymmb/2 : marche pas !

Code:

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
const std::vector<std::pair<std::wstring, std::wstring>>lire_paireCleValeur_depuisFichierTxt2(std::wstring const& nomFichier, std::wstring separeteur)
{
    std::string contenuFichier{ u8"" };
    std::vector<std::pair<std::wstring, std::wstring>> clevaleurs;

    ifstream fichier{ nomFichier };
    if (!fichier)
    {
        throw std::runtime_error("Fichier impossible à ouvrir.");
    }

    contenuFichier = std::string(istreambuf_iterator<char>{fichier}, {});

    if (contenuFichier == u8"")
    {
        throw std::runtime_error("Le fichier '" + wstr_to_u8(nomFichier) + "' est vide.");
    }

    wstring_convert<codecvt_utf8<wchar_t>, wchar_t> convertiseur;
    std::wstring converti = convertiseur.from_bytes(contenuFichier);
    rtrim(converti);
    converti += L'\n';/*L"\r\n"*/;

    std::size_t pos = converti.length();

    if (pos == std::wstring::npos)
        return clevaleurs;

    
//    std::wregex filename_pattern{ L"(.+?)(?:\\.\\((?:(\\d{4})\\-(\\d{2})\\-(\\d{2})\\s*([^\\)]*))\\))?(?:\\.(.+))?$" };
    std::wregex filename_pattern{ L"^((.+[ ][:][ ].+)|(.+[ ][:][ ])|([ ][:][ ].+)|(.+))$" }; 
    std::wstring nom = L"", role = L"";
    std::wsmatch match;

    std::regex_match(converti, match, filename_pattern);

    while (pos = converti.find(L"\n"/*L"\r\n"*/))
    {
        if (converti[0] != converti.length())
        {
            nom = (match[0].matched) ? match[0].str() : L"";
//            separeteur = (match[1].matched) ? match[1].str() : L"";
            role = (match[2].matched) ? match[2].str() : L"";
            clevaleurs.push_back(std::make_pair(nom, role));
            nom = L"";
            role = L"";
        }
        else
            break;
    }
    return clevaleurs;
}

nom et role : marche pas !

Problème ?

Merci d'avance:aie::aie::aie:

27/09/2024, 11h48
bacelar
Vous devez faire attention à la partie "MATCH INFORMATION" à droite de l'interface.
Vous n'utilisez pas les bons indices et vous avez oublié de capturer les informations dont vous avez besoin.
Mais vous avez pris la peine de "simplifier" l'expression régulière, c'est bien.
Vous ne "gérez" pas les cas "..." et "…" avec votre expression régulière.
Votre expression régulière est simple mais cela rend l'utilisation des résultats plus verbeux.

https://regex101.com/r/bFH1LN/1

Votre boucle "while" est complètement aux fraises. (pas de gestion des passage à la ligne suivante, etc...).

Utilisez la boucle for que j'ai donné
Code:

1 2 3 4 for (std::wsregex_iterator it{ converti.begin(), converti.end(), line_format_rg }, end{}; it != end; ++it) { ... }
ET FAITES GAFFE AUX NOMS DES VARIABLES, BORDEL. :aie:

Bonsoir,

https://github.com/laurentbouleau/Exemple : Septembre 12 (27/09/2024)

film_serie.cpp :

Code:

1
2
3
4
5
6
7
void initialiser_Avec(fs::path const& cheminFichier, std::vector<std::pair<std::wstring, std::wstring>>& m_avec)
{
    auto nomFichier = cheminFichier.filename().wstring();
    assert(nomFichier.length() > 0 && L"Nom de fichier vide");
    m_avec = lire_paireCleValeur_depuisFichierTxt2(cheminFichier.wstring(), L" : ");
    assert((m_avec.size() != 0));
}

utils.cpp :

Code:

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
const std::vector<std::pair<std::wstring, std::wstring>>lire_paireCleValeur_depuisFichierTxt2(std::wstring const& nomFichier, std::wstring separeteur)
{
    std::string contenuFichier{ u8"" };
    std::vector<std::pair<std::wstring, std::wstring>> clevaleurs;
 
    ifstream fichier{ nomFichier };
    if (!fichier)
    {
        throw std::runtime_error("Fichier impossible à ouvrir.");
    }
 
    contenuFichier = std::string(istreambuf_iterator<char>{fichier}, {});
 
    if (contenuFichier == u8"")
    {
        throw std::runtime_error("Le fichier '" + wstr_to_u8(nomFichier) + "' est vide.");
    }
 
    wstring_convert<codecvt_utf8<wchar_t>, wchar_t> convertiseur;
    std::wstring converti = convertiseur.from_bytes(contenuFichier);
    rtrim(converti);
    converti += L'\n';/*L"\r\n"*/;
 
    std::size_t pos = converti.length();
 
    if (pos == std::wstring::npos)
        return clevaleurs;
 
    std::wregex line_format_rg{ L"^(?:(?:(.+?) : (.+))|(?:(.+?) : )|(?: : (.+))|(.+))$" };
    for (std::wsregex_iterator it{ converti.begin(), converti.end(), line_format_rg }, end{}; it != end; ++it)
    {
        if(converti[0] != converti.length())
        {
            if (converti[0] == L'.' && converti[1] == L'.' && converti[2] == L'.')
            {
                clevaleurs.push_back(std::make_pair(L"…", L""));
                return clevaleurs;
            }
            if (converti[0] == L'…')
            {
                clevaleurs.push_back(std::make_pair(L"…", L""));
                return clevaleurs;
            }
            if (converti[0] == L'…')
            {
                clevaleurs.push_back(std::make_pair(L"…", L""));
                return clevaleurs;
            }
            if (converti.size() != 0)
            {
                std::wsmatch match = *it;
                std::wstring nom = match[1].str();
                std::wstring role = match[2].str();
                clevaleurs.push_back(std::make_pair(nom, role));
            }
            else
            {
                break;
            }
        }
    }
    return clevaleurs;
}

et :

Andor.[2022- Disney+]

... ???

Je suis fatigué !!! (Le sport)

Merci beaucoup:aie::aie::aie:

"..." et "…", c'est des motifs, il est donc plus logique de les mettre dans l'expression régulière plutôt que de "fabriquer" un bout de code pour les trouvez "à la main".
(Attention à l'ordre des motifs dans l'expression régulière, cela pilote l'ordre d'évaluation des sous-expressions => les priorités)

Vous avez, semble-t-il, bien regardé la partie "MATCH INFORMATION", mais que la partie "Match 1" ; mais pas les parties "Match 2" et suivantes, sinon, vous auriez vu que l'indice de la capture qui vous intéresse change en fonction du "motif" trouvé.
C'est en cela que votre expression régulière "simple"

Citation:

Citation:

rend l'utilisation des résultats plus verbeux.

Pourquoi les lignes 39 à 43 dans le code de votre dernier post sont dupliquées avec les lignes 44 à 48 ?

C'est quoi ces "return" en plein milieu d'une boucle, sachant qu'il à le même effet que le "break" ???
Pourquoi sortir "instantanément" de la fonction quand on trouve un "…" au lieu de vérifier que c'est bien la dernière ligne du fichier ???
Tous vos tests sont sur la variable "converti", qui ne change pas durant toute la durée de la boucle. Ils sont donc tous totalement faux.

Citation:

Code:

if(converti[0] != converti.length())

Ce test a encore moins de sens que les autres.
Quel rapport entre la longueur de la chaine et le "code" du premier caractère de la chaine ???

Votre code alambiqué vous colle une paire {"",""} à la fin de votre variable "clevaleurs" parce que vos tests sont complètement foireux.

Pourquoi ne pas vous être inspiré du code que j'ai posté le "25/09/2024, 13h17' qui est, me semble-t-il, bien plus simple ???
Code:

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 const std::vector<std::pair<std::wstring, std::wstring>>lire_paireCleValeur_depuisFichierTxt2(std::wstring const& nomFichier) { std::string contenuFichier{ u8"" }; std::vector<std::pair<std::wstring, std::wstring>> clevaleurs; ifstream fichier{ nomFichier }; if (!fichier) { throw std::runtime_error("Fichier impossible à ouvrir."); } contenuFichier = std::string(istreambuf_iterator<char>{fichier}, {}); if (contenuFichier == u8"") { throw std::runtime_error("Le fichier '" + wstr_to_u8(nomFichier) + "' est vide."); } wstring_convert<codecvt_utf8<wchar_t>, wchar_t> convertiseur; std::wstring converti = convertiseur.from_bytes(contenuFichier); rtrim(converti); std::wregex line_format_rg{ L"^(?:(?:(.+?) : (.+))|(?:(.+?) : )|(?: : (.+))|(\\.\\.\\.|…)|(.+))$" }; for (std::wsregex_iterator it{ converti.begin(), converti.end(), line_format_rg }, end{}; it != end; ++it) { auto entry = *it; if (entry[5].matched) { clevaleurs.push_back(std::make_pair(L"…", L"")); break; } else if (entry[1].matched) { std::wstring nom = entry[1].str(); std::wstring role = entry[2].str(); clevaleurs.push_back(std::make_pair(nom, role)); } else if (entry[3].matched) { std::wstring nom = entry[3].str(); clevaleurs.push_back(std::make_pair(nom, L"")); } else if (entry[4].matched) { std::wstring role = entry[4].str(); clevaleurs.push_back(std::make_pair(L"", role)); } else if (entry[6].matched) { std::wstring nom = entry[6].str(); clevaleurs.push_back(std::make_pair(nom, L"")); } } return clevaleurs; }
(Le paramètre "separeteur" ne sert à rien ici, car vous ne l'avez pas utilisé pour construire l'expression régulière, contrairement à mon exemple.)

P.S.: Quand vous testez du nouveau code, arrangez-vous pour que les données en entré correspondent à tous les cas à gérer.
".\Andor.[2022- Disney+]\2022-09-21\Avec.txt" ne contient pas les types de ligne gérées par la partie "(?:_(.+?) : )|(?: : (.+))" de l'expression régulière.

Bonjour bacelar,

https://github.com/laurentbouleau/Exemple : Septembre 13 (28/09/2024)
Avant : L"..." : ok !

utils.cpp :

Code:

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
const std::vector<std::pair<std::wstring, std::wstring>>lire_paireCleValeur_depuisFichierTxt2(std::wstring const& nomFichier, std::wstring separeteur)
{
    std::string contenuFichier{ u8"" };
    std::vector<std::pair<std::wstring, std::wstring>> clevaleurs;
 
    ifstream fichier{ nomFichier };
    if (!fichier)
    {
        throw std::runtime_error("Fichier impossible à ouvrir.");
    }
 
    contenuFichier = std::string(istreambuf_iterator<char>{fichier}, {});
 
    if (contenuFichier == u8"")
    {
        throw std::runtime_error("Le fichier '" + wstr_to_u8(nomFichier) + "' est vide.");
    }
 
    wstring_convert<codecvt_utf8<wchar_t>, wchar_t> convertiseur;
    std::wstring converti = convertiseur.from_bytes(contenuFichier);
    rtrim(converti);
    converti += L'\n';/*L"\r\n"*/;
 
    std::size_t pos = converti.length();
 
    if (pos == std::wstring::npos)
        return clevaleurs;
 
    std::wregex line_format_rg{ L"^(?:(?:(.+?) : (.+))|(?:(.+?) : )|(?: : (.+))|(.+))$" };
    for (std::wsregex_iterator it{ converti.begin(), converti.end(), line_format_rg }, end{}; it != end; ++it)
    {
        if(converti[0] != converti.length())
        {
            std::wsmatch match = *it;
            if (match[0] == L"...")
            {
                clevaleurs.push_back(std::make_pair(L"…", L""));
                return clevaleurs;
            }
            if (match[0] == L'…')
            {
                clevaleurs.push_back(std::make_pair(L"…", L""));
                return clevaleurs;
            }
            if (match[0] == match[1])
            {
                std::wstring nom = match[1].str();
                clevaleurs.push_back(std::make_pair(nom, L""));
            }
            if (converti.size() != 0)
            {
                std::wstring nom = match[1].str();
                std::wstring role = match[2].str();
                clevaleurs.push_back(std::make_pair(nom, role));
            }
            else
            {
                break;
            }
        }
    }
    return clevaleurs;
}

Merci:oops:

https://github.com/laurentbouleau/Exemple : Septembre 14 (28/09/2024)

utils.cpp :

Code:

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
const std::vector<std::pair<std::wstring, std::wstring>>lire_paireCleValeur_depuisFichierTxt(std::wstring const& nomFichier)
{
    std::string contenuFichier{ u8"" };
    std::vector<std::pair<std::wstring, std::wstring>> clevaleurs;

    ifstream fichier{ nomFichier };
    if (!fichier)
    {
        throw std::runtime_error("Fichier impossible à ouvrir.");
    }

    contenuFichier = std::string(istreambuf_iterator<char>{fichier}, {});

    if (contenuFichier == u8"")
    {
        throw std::runtime_error("Le fichier '" + wstr_to_u8(nomFichier) + "' est vide.");
    }

    wstring_convert<codecvt_utf8<wchar_t>, wchar_t> convertiseur;
    std::wstring converti = convertiseur.from_bytes(contenuFichier);
    rtrim(converti);

    std::wregex line_format_rg{ L"^(?:(?:(.+?) : (.+))|(?:(.+?) : )|(?: : (.+))|(\\.\\.\\.|…)|(.+))$" };
    const auto etc = L"…";
    const auto x_zero = L"";
    for (std::wsregex_iterator it{ converti.begin(), converti.end(), line_format_rg }, end{}; it != end; ++it) 
    {
        auto entry = *it;
        if (entry[5].matched)
        {
            clevaleurs.push_back(std::make_pair(etc, x_zero));
            break;
        }
        else if (entry[1].matched)
        {
            std::wstring nom = entry[1].str();
            std::wstring role = entry[2].str();
            clevaleurs.push_back(std::make_pair(nom, role));
        }
        else if (entry[3].matched)
        {
            std::wstring nom = entry[3].str();
            clevaleurs.push_back(std::make_pair(nom, x_zero));
        }
        else if (entry[4].matched)
        {
            std::wstring role = entry[4].str();
            clevaleurs.push_back(std::make_pair(x_zero, role));
        }
        else if (entry[6].matched)
        {
            std::wstring nom = entry[6].str();
            clevaleurs.push_back(std::make_pair(nom, x_zero));
        }
    }
    return clevaleurs;
}

Problème : x_zero = L"";

Merci beaucoup :aie::roll:

Bonsoir,

https://github.com/laurentbouleau/Exemple : Septembre 15 (28/09/2024)

film.cpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
const void Film::Print_Avec_etc()
{
    if (affichage_avec_etc_actif && m_avec.size())
    {
        std::wstring avec_str = m_keyColor[0] + L"Avec : " + m_valuesColor;
        int i = 0;
        for (auto&& [nom, role] : m_avec)
        {
            if (nom == L"…" || nom == L"...")
                break;
            if (i < m_avec.size() && nom != L"")
                avec_str += nom;
            i++;
            if (i > 2)
                break;
            avec_str += m_keyColor[0] + L", " + m_valuesColor;
        }
        avec_str += L"\r\n";
        std::wcout << avec_str;
    }
}

Ok ou pas ?

Merci:?

https://github.com/laurentbouleau/Exemple : Septembre 16 (28/09/2024)

serie.cpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
const void Serie::Print_Avec_etc()
{
    if (affichage_avec_etc_actif && saisons.back().m_avec.size())
    {
        std::wstring avec_str = m_keyColor[0] + L"Avec : " + m_valuesColor;
        int i = 0;
        for (auto&& [nom, role] : saisons.back().m_avec)
        {
            if (nom == L"…" || nom == L"...")
                break;
            if (i < saisons.back().m_avec.size() && nom != L"")
                avec_str += nom;
            i++;
            if (i > 2)
                break;
            avec_str += m_keyColor[0] + L", " + m_valuesColor;
        }
        avec_str += L"\r\n";
        std::wcout << avec_str;
    }
}

Ok ou pas ?

Merci:aie:

Citation:

x_zero = L"";

Ça veut dire quoi ???
Si c'est une chaine vide, "empty_string" serait plus logique.

Vous définissez des constantes dans la fonction "lire_paireCleValeur_depuisFichierTxt" mais vous devez vous en servir dans la fonction "Film::Print_Avec_etc".
Vous devriez la définir à un endroit "accessible" à ces 2 fonctions.

Citation:

Code:

const void Film::Print_Avec_etc()

C'est quoi ce "const" ???
Pourquoi faire une nouvelle fonction à la place de "void Film:: Print_Avec" ?

Citation:

Code:

if (nom == L"…" || nom == L"...")

Pourquoi "..." ??? Vous avez factorisé le traitement des différentes manières d'encoder une fin de liste dans "lire_paireCleValeur_depuisFichierTxt", pourquoi vous compliquez la vie ?

Citation:

Code:

if (affichage_avec_etc_actif && saisons.back().m_avec.size())

"saisons" peut être vide.
"m_avec.size()" n'est pas un booléen.

Citation:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
        int i = 0;
        for (auto&& [nom, role] : m_avec)
        {
            if (nom == L"…" || nom == L"...")
                break;
            if (i < m_avec.size() && nom != L"")
                avec_str += nom;
            i++;
            if (i > 2)
                break;
            avec_str += m_keyColor[0] + L", " + m_valuesColor;
        }

Eviter de tripatouiller l'indice de boucle au milieu de la boucle.

Code:

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 Film::Print_Avec_etc()
{
    if (affichage_avec_etc_actif && m_avec.size()>0)
    {
        std::wstring avec_str = m_keyColor[0] + L"Avec : " + m_valuesColor;
        int item_count = 0;
        for (auto&& [nom, role] : m_avec)
        {
            if (nom == L"…")
                break;
            if (nom != L"")
            {
                if (item_count>0)
                {
                    avec_str += m_keyColor[0] + L", " + m_valuesColor;
                }
                avec_str += nom;
                item_count++;
                if (item_count > 2)
                    break;
            }
        }
        avec_str += L"\r\n";
        std::wcout << avec_str;
    }
}

Code:

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
void Serie::Print_Avec_etc()
{
    if (affichage_avec_etc_actif && saisons.size()>0 && saisons.back().m_avec.size()>0)
    {
        std::wstring avec_str = m_keyColor[0] + L"Avec : " + m_valuesColor;
 
        int item_count = 0;
        for (auto&& [nom, role] : saisons.back().m_avec)
        {
            if (nom == L"…")
                break;
            if (nom != L"")
            {
                if (item_count > 0)
                {
                    avec_str += m_keyColor[0] + L", " + m_valuesColor;
                }
                avec_str += nom;
                item_count++;
                if (item_count > 2)
                    break;
            }
        }
        avec_str += L"\r\n";
        std::wcout << avec_str;
    }
}

30/09/2024, 12h59
Laurent_B_
Bonjour,

https://github.com/laurentbouleau/Exemple : Septembre 17 (30/09/2024)

Ok, merci beaucoup !!!

Par contre : exemple.cpp :
Code:

1 2 3 4 5 6 7 8 9 int wmain(int argc, wchar_t* argv[]) { ... Person p; ... film.get_Pernson(Person p); film.Print(); ... }
Problème !!!
Comprendre pas !!!

Bonsoir,
Code:

1 2 3 4 5 6 7 Avec un séparateur " : " en dur et en utilisant des expressions régulières : https://regex101.com/r/uvW5k5/1 (format un peu alambiqué pour coller à tous les cas possibles de votre code actuel, mais je pense que cela est simplifiable) En ne passant plus en paramètre le séparateur mais une expression régulière qui match avec les séparateurs possibles comme : ... Le code de la fonction "lire_paireCleValeur_depuisFichierTxt" serait :
Ok !!!

InfosVisionnage_film ===> SequenceVisionnage_film
Ok !

Citation:

Les espaces devant "VOD Orange" viennent des lignes :
...
dans la fonction/constructeur "InfosVisionnage_film::InfosVisionnage_film".
"filename_stream_index" devrait être égale à 12, pas à 11.
Vérifiez votre code.
Code:

1 2 const int filename_someFlag_index = filename_date_day_day_index + 2; const int filename_stream_index = filename_someFlag_index + 2;
Pas compris ?

Citation:

Pourquoi ces "m_" en préfixe des noms de paramètre, BORDEL.

Ok !

Citation:

Pourquoi faire si compliqué ???

Marche pas !!!

Citation:

Votre fonction fait 2 choses qui n'ont rien à voir l'une avec l'autre.
Séparez-les en 2 fonctions distinctes.

???

Je suis crevé !

https://github.com/laurentbouleau/Exemple : Septembre 18 (30/09/2024)

Merci:aie::aie::aie:

02/10/2024, 11h24
Laurent_B_

Bonjour bacelar,

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

Citation:

Pourquoi ces "m_" en préfixe des noms de paramètre, BORDEL.

Pourquoi faire si compliqué ???
...
Votre fonction fait 2 choses qui n'ont rien à voir l'une avec l'autre.
Séparez-les en 2 fonctions distinctes.

et

Citation:

void Print_Catalogue(const std::wstring sur, std::vector<std::wstring>& catalogue, bool affichage_catalogue_actif, std::wstring& keyColor, std::wstring& valuesColor)

Ok !

Merci beaucoup;)

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

serie.cpp :

Code:

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
void Serie::Print_Header() const
{
    if (affichage_titres_actif)
    {
        std::wstring titres_str;
        std::wstring crochet_ouvrant_str = m_keyColor[0] + L" [" + m_valuesColor;
        std::wstring annees_str;
        std::wstring sur_str;
        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();
            // sur
            if (affichage_sur_actif)
            {
                if (m_sur == L"Disney+" || m_sur == L"Netflix" || m_sur.size() != 0)
                {
                    sur_str += m_keyColor[0] + L' ' + m_valuesColor + m_keyColor[1] + L"sur" + m_valuesColor;
                    if (m_sur == L"Disney+")
                    {
                        sur_str += L" Disney+ " + m_keyColor[1] + L": " + m_valuesColor + m_disney_sj;
                    }
                    else if (m_sur == L"Netflix")
                    {
                        sur_str += L" Netflix " + m_keyColor[1] + L": " + m_valuesColor + m_netflix_sj;
                    }
                    else
                    {
                        sur_str += L' ' + m_sur;
                    }
                }
            }
        }
        // x signalétique jeunesse
        if (affichage_x_sj_actif && (m_sur != L"Disney+" || m_sur != L"Netflix"))
        {
            // Disney+ SJ
            if (affichage_disney_sj_actif && m_disney_sj.length() != 0)
                x_sj_str += m_keyColor[0] + L" (" + m_valuesColor + L"Disney+" + m_keyColor[1] + L" : " + m_valuesColor + m_disney_sj + m_keyColor[0] + L')' + m_valuesColor;
            // Netflix SJ
            if (affichage_netflix_sj_actif && m_netflix_sj.length() != 0)
                x_sj_str += m_keyColor[0] + L" (" + m_valuesColor + L"Netflix" + m_keyColor[1] + L" : " + m_valuesColor + m_netflix_sj + m_keyColor[0] + L')' + m_valuesColor;
        }
        // La signalétique jeunesse
        if (affichage_sj_actif && m_sj.length() != 0)
            sj_str += m_keyColor[0] + L" (" + m_valuesColor + L"SJ" + m_keyColor[1] + L" : " + m_valuesColor + m_sj + m_keyColor[0] + L')' + m_valuesColor;
        // Durée
        if (affichage_duree_actif)
        {
            duree_str = L' ' + std::to_wstring(m_duree/60) + m_keyColor[0] + L"min " + m_valuesColor;
        }
        // Note
        if (affichage_note_actif)
            note_str += calcul_Note_Affichage();
 
        std::wcout << titres_str << crochet_ouvrant_str << annees_str << sur_str << crochet_fermant_str << x_sj_str << sj_str << duree_str << note_str << std::endl;
    }
}

Ok !

Citation:

Code:

get_Pernson

get_Pernson ???
C'est pas plutôt "get_Person", non ?

C'est quoi une "Person" ?
Un Acteur ? Un réalisateur ? un Role ? etc...

Citation:

Code:

film.get_Pernson(Person p);

Quand on appelle une fonction, on donne que le nom de la variable, pas le type.

Code:

film.get_Pernson(p);

Mais pour une fonction qui est un "accesseur", c'est plus une signature de la forme :

Code:

const Person& Film::get_Pernson() const

On met "const" devant si on considère que le code appelant n'a pas à modifier le comportement de l'objet film via la valeur retournée par la fonction, qui est une référence sur un objet interne à l'instance (donc pas une variable locale à une fonction).
On met "const" derrière si on considère que la fonction n'a pas le droit de modifier l'état interne (les champs de l'objet) de l'instance.

Mais l'implémentation de la fonction "Film::get_Pernson(Person p)", c'est plus un "setteur" qu'un getteur. :

Code:

void Film::set_Pernson(const Person& p)
Citation:
Citation:

Les espaces devant "VOD Orange" viennent des lignes :
...
dans la fonction/constructeur "InfosVisionnage_film::InfosVisionnage_film".
"filename_stream_index" devrait être égale à 12, pas à 11.
Vérifiez votre code.
Code:

1 2 const int filename_someFlag_index = filename_date_day_day_index + 2; const int filename_stream_index = filename_someFlag_index + 2;
Pas compris ?
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:

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". :aie:
Quand vous modifiez les expressions régulières, il faut systématiquement corriger ces constantes.(bis)

Citation:

Citation:

Pourquoi faire si compliqué ???

Marche pas !!!

Pour rappel, il s'agit de la fonction "Print_Catalogue".
Je viens de tester le code sur la version "Septembre 18 (30/09/2024)" et cela fonctionne "parfaitement".
Pouvez-vous me donner un exemple où cela ne "marche" pas ?
Pour moi, si cela ne "marche" pas, le code original non plus.

Citation:

Citation:

Votre fonction fait 2 choses qui n'ont rien à voir l'une avec l'autre.
Séparez-les en 2 fonctions distinctes.

???

C'est lié à la fonction "recuperer_Max_SJ".
Pourquoi une personne qui lirait un code qui appelle cette fonction "recuperer_Max_SJ" devrait être conscient que cela modifie le paramètre "m_catalogue" ???
Utilisez 2 fonctions différentes, une pour récupérer le "Max_SJ" et une autre pour ajouter votre "bidule" à votre liste de "machin".
Citation:
Code:

1 2 3 4 void Serie::Print_Header() const { ... }
Attention aux accès hors limites dans les std::vector, SVP :
Citation:
Code:

1 2 3 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];
Il se passe quoi si "m_titres.size()" est égale à 0.
m_titres[0] =>BOUM
Il se passe quoi si "m_titres.size()" est égale à 2.
m_titres[2] =>BOUM

"crochet_ouvrant_str" et "crochet_fermant_str", pourquoi c'est des variables locales et pas une constantes (statique de la classe Serie, par exemple) ?
Le nom des variables locales, c'est vraiment pas top.

Votre code est extrêmement complexe, peu lisible (on ne "voit" pas le format des chaines de caractères qui seront affichées dans la console).
Beaucoup trop de chaines de caractère en dur.S'il y a une nouvelle plateforme de streaming en plus de "Disney+" et "Netflix", ça sera l'enfer. (Quid de "Max", etc...)
Beaucoup trop de copier-coller.
Elle devrait être découpée en plusieurs parties.
Des conditions qui n'ont aucun sens :

Citation:

Code:

if (m_sur == L"Disney+" || m_sur == L"Netflix" || m_sur.size() != 0)

C'est la même chose que

Code:

if (m_sur.size() != 0)

Citation:

Code:

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

C'est la même chose que

Code:

if (affichage_x_sj_actif)

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

Vous avez plein de champs différents comme "m_disney_sj", "m_netflix_sj", etc... qui rendent le code casse-gueule.
Si vous devez stocker des informations spécifiques à chaque plateforme de streaming, utilisez plutôt un champ dans la classe Serie de type :
std::map<std::wstring,ClasseDeStockageDesInformationsDeLaPlateformeDeStreaming> m_streamingInfos;
Avec "ClasseDeStockageDesInformationsDeLaPlateformeDeStreaming" une classe permettant de stocker les informations spécifiques à la plateforme de streaming, comme son "SJ".
Et le "std::wstring", le type de la clé de la map, le nom de la plateforme de streaming.
Si, pour l'instant, vous ne stockez que le "SJ" d'une plateforme, "ClasseDeStockageDesInformationsDeLaPlateformeDeStreaming" pourrait être remplacé par un simple "std::wstring".

Pourquoi "affichage_sur_actif" ne fonctionne que si "affichage_annees_actif" est vrai ???
Pourquoi "affichage_sur_actif" et "affichage_annees_actif" ne fonctionnent que si "affichage_titres_actif" est vrai ???
etc...
Pourquoi c'est si complexe ????

Pourquoi pas juste :
Code:

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; }

1 pièce(s) jointe(s)

Bonjour,

Exemple.h :

Code:

1
2
3
4
5
6
7
8
struct Person
{
    std::wstring m_h = L"h";
    std::wstring m_min = L"min";
    //                                    (bleu)         (vert)                 (rouge)                (jaune)
    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
};

Exemple.cpp :

Code:

1
2
3
4
5
6
7
8
9
10
int wmain(int argc, wchar_t* argv[])
{
...
    Person p;
...
        film.set_Person(p);
        film.Print();
    }
...
}

film.h :

Code:

1
2
3
4
5
6
7
8
struct Person;
...
class Film
{
...
    void set_Person(Person& p);
...
};

film.cpp :

Code:

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

Pièce jointe 660054
Comment faire ???

Merci beaucoup:aie::aie::aie:

03/10/2024, 17h20
bacelar

En modifiant le code à partir de la version "Octobre 03 (02/10/2024)" du dépôt GitHub, je n'ai aucun problème de compilation (à l'exécution, le code n'utilise pas ces lignes avec le jeu de données utilisées)

C'est donc d'autres modification qui pose problèmes.
C'est quoi vos ligne 113 et 143 de votre "Exemple.cpp" SVP ? (Ou les lignes correspondant aux messages d'erreur)

Code:

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
    Person p;

    bool found = false;

    std::size_t pos, pos2;
    const std::wstring d_p1 = L".(";
    pos = nomDossier.find(d_p1);
    const std::wstring d_p2 = L")";
    pos2 = nomDossier.find(d_p2);
    const std::size_t c_annee_size = 4;
    const std::size_t c_mois_size = 2;
    const std::size_t c_jour_size = 2;
    const std::size_t c_tiret_size = 1;

    std::wregex nomDossier_pattern{ L"(.+?)(?:\\.\\((?:(\\d{4})\\-(\\d{2})\\-(\\d{2})\\s*([^\\)]*))\\))?(?:\\.(.+))?$" };

    std::wsmatch match;
    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))
    {
        static Film film(racine);
        found = true;
        for (const auto& entry_film : fs::directory_iterator((film.getRacine())))
        {
            if (entry_film.is_regular_file())
            {
                film.initialiser_Fichier(entry_film);
            }
        }
        //film.set_Person(const Person& p);
        film.set_Person(p);
        film.Print();
    }

Citation:

C'est quoi vos ligne 113 et 143 de votre "Exemple.cpp" SVP ? (Ou les lignes correspondant aux messages d'erreur)

Voilà !!!

03/10/2024, 21h06
Laurent_B_

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

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

Code:

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

Code:

Person p;

Prenez la peine de nommer correctement vos variables, BORDEL.

Code:

film.set_Person(p);

De quel "p" il s'agit ?

Pourquoi faire aussi compliqué :
Code:

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:

1 2 if (std::regex_match(nomDossier, match, nomDossier_pattern)) {...}
fait aussi bien ?

Bonsoir,

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

film.cpp :

Code:

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:

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:

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:aie::aie::aie:

05/10/2024, 03h01
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" ?

Citation:

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&" ?

Bonsoir,

Désolé !

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

Exemple : serie.cpp :

Code:

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:aie::aie::aie:

Citation:
Code:

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 ?

Citation:

Code:

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.

Citation:

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

Citation:

Code:

const class Person;

Pourquoi ce "const" ???

Dans film_serie.h :
Citation:
Code:

1 2 3 const class Person { public:
idem, pourquoi ce "const" ???

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:

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é:aie:

Merci beaucoup:aie::aie::aie:

Citation:

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.

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

Citation:

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" ?

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

Citation:

if (affichage_x_sj_actif && ...)

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

Citation:

Citation:

Code:

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

C'est la même chose que

Code:

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" ?

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

Citation:

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é")
Citation:
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:

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.

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

Citation:

Code:

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

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

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 ??? :

Citation:

Code:

duree_str += calcul_duree_affichage();

VS

Code:

duree_str = calcul_duree_affichage();

Presque :

Code:

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:aie::aie::aie:

Bonjour,

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

Code:

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:?

Bonsoir,

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

Film.cpp :

Code:

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:roll:

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

Exemple : film.cpp :

Code:

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à !

1 pièce(s) jointe(s)

Bonsoir bacelar,

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

Citation:

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 !!!:oops:

film.h :

Code:

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:

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 ?
Pièce jointe 660761

Code:

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:

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:

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:

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:aie::aie::aie:

Bonsoir,

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

film.cpp :

Code:

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:

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

et:

Code:

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

Merci:aie::aie::aie:

Post du "17/10/2024, 23h50".
Citation:
Code:

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:

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:

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; }
Citation:

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

Citation:

(((([[: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.

21/10/2024, 20h53
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 !

Citation:

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;)

Bonsoir,

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

Citation:

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

Pas de solution !!!

Mais :
Exemple.cpp :

Code:

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:

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:

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:

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:

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

Ok !
Pourquoi ???

Merci d'avance:aie::aie::aie:

23/10/2024, 03h17
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:aie:

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

Citation:

Ok ou pas ?

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

Quelques remarques :
Citation:
Code:

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...)
Citation:
Code:

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:

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"
Citation:
Code:

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. :aie:

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

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"

Citation:

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. :aie:

Ok ! Adent !

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

film_serie.h :

Code:

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:

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:

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:

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:

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 !

Voir 40 message(s) de cette discussion en une page

Fuseau horaire GMT +2. Il est actuellement 04h15.