Problème et AVC : _wfopen_s

**Laurent_B_** · 18/07/2024, 23h51

Rrr !

https://github.com/laurentbouleau/Exemple : Juillet 19 (18/07/2024)

===> std::tm tm{ -1, -1, -1, -1, -1, -1, -1, -1, -1 };

Voilà !

**Laurent_B_** · 19/07/2024, 15h52

Bonjour,

Vous ne pouvez pas lire les posts avec des listes à puces (LIST) ou vous ne pouvez pas répondre "facilement" à ces posts ?

J'ai beaucoup de mal à lire, donc j'utilise le narrateur de l'ordi. Mais pour lire les listes à puces (LIST) : le narrateur bugue !!! J'ai Windows 10. Peut-être que ça marcherait avec le narrateur de Windows 11?

Pouvez-vous résumer en quelques mots ce qu'est une structure en C ?
Quelles différences entre une structure C et une structure en C++, toujours en quelques mots ?

Je sais ce qu'est une strusture en C, mais je ne peux pas l'expliquer, à cause de mes troubles du langage (aphasie). Je vois un peu la différence entre la structure en C et en C++, mais ce n'est pas clair du tout pour moi.
J'ai appris C++ par moi-même après mon AVC, donc c'est compliqué pour moi.

Pouvez-vous expliquer ce que vous avez compris du fonctionnement actuel de votre programme ?
Je pourrais voir là où vous faites fausse route dans votre compréhension du programme.

Non, je ne peux pas l'expliquer; ce n'est pas clair pour moi. En plus, je ne peux pas écrire des phrases complètes tout seul.
Là, c'est mon orthophoniste qui écrit ce que je veux dire.

Pour moi, ce serait vraiment plus facile si vous donniez des indications peu à peu, de façon courte. Lire une très grande page d'explications est très décourageant car ça me prend des heures.

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

(Moi même !)
Mais, exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
int wmain(int argc, wchar_t* argv[])
{
...
    const std::wstring racine = t + L"Azertyuiop - qsdfghjklm.[2021-2023 Netflix].Manga";
...
    bool found = false;
    std::wregex film_pattern{ L"(.+?)(?:\\.\\((\\d{4}\\-\\d{2}\\-\\d{2}\\s)?([^\\)]*)\\))?(?:\\.(.+))?" };
    std::wsmatch match;
    if (!found && std::regex_match(nomDossier, match, film_pattern))
    {
        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);
                continue;
            }
        }
        film.Print();
        found = true;
    }
    if (!found)
    {
        std::wregex serie_pattern{ L"(.+?)(?:\\.\\[(\\d{4}\\s|\\d{4}\\-\\d{4}\\s|\\d{4}\\-\\s|\\d{4})?([^\\]]*)\\])?(?:\\.(.+))?" };
        std::wsmatch match2;
        if (!found && std::regex_match(nomDossier, match2, serie_pattern))
        {
            Serie serie(racine);
            for (const auto& entry_serie : fs::directory_iterator((serie.getRacine())))
            {
                if (entry_serie.is_regular_file())
                {
                    serie.initialiser_Fichier(entry_serie);
                    continue;
                }
                if (fs::is_directory(entry_serie))
                {
                    Saison saison(entry_serie, serie);
                    for (const auto& entry_saison : fs::directory_iterator(entry_serie))
                    {
                        if (entry_saison.is_regular_file())
                        {
                            saison.initialiser_Fichier(entry_saison);
                        }
                    }
                    serie.saisons.push_back(saison);
                }
            }
            serie.Print();
        }
    }
...
}

===>

Code :

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

 const std::wstring racine = t + L"Azertyuiop - qsdfghjklm.[2021-2023 Netflix].Manga";

Je n'y arrive pas !

Merci

**Laurent_B_** · Aujourd'hui, 03h11

Bonsoir,

Exemple serie.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
const void Serie::Print_Header()
{
...
        if (affichage_sur_actif && m_sur != L"" && m_sur != L"Disney+" && m_sur != L"Netflix")
        {
            sur_str += keyColor[0] + L" (" + keyColor[1] + L"sur " + valuesColor + m_sur + keyColor[0] + L')' + valuesColor;
        }
        if (affichage_sur_actif && (m_sur == L"Disney+" || m_sur == L"Netflix"))
        {
            sur_str += keyColor[0] + L" (" + keyColor[1] + L"sur " + valuesColor + m_sur + keyColor[1] + L" : " + valuesColor;
            // Disney+ SJ
            if (affichage_disney_sj_actif && m_disney_sj.length() != 0)
                sur_str += m_disney_sj;
            // Netflix SJ
            if (affichage_netflix_sj_actif && m_netflix_sj.length() != 0)
                sur_str += m_netflix_sj;
            sur_str += keyColor[0] + L')' + valuesColor;
        }
        else
        {
            // Disney+ SJ
            if (affichage_disney_sj_actif && m_disney_sj.length() != 0)
                sur_str += keyColor[0] + L" (" + valuesColor + L"Disney+" + keyColor[1] + L" : " + valuesColor + m_disney_sj + keyColor[0] + L')' + valuesColor;
            // Netflix SJ
            if (affichage_netflix_sj_actif && m_netflix_sj.length() != 0)
                sur_str += keyColor[0] + L" (" + valuesColor + L"Netflix" + keyColor[1] + L" : " + valuesColor + m_netflix_sj + keyColor[0] + L')' + valuesColor;
       }
...
}

Ok ! Mais, tant pis !

Et :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
InfosVisionnage::InfosVisionnage(const Saison& saison, fs::path const& m_cheminFichier) : m_saison{ saison }
{
...
    if (file_content.size() > 2)
    {
        //file_content.erase(file_content.begin());  //bof à revoir
        //file_content.erase(file_content.begin()); //bof à revoir
        file_content.erase(file_content.begin(), file_content.begin() + 1);
        m_resume = file_content;
    }
}

Merci

**bacelar** · Aujourd'hui, 20h04

Pour l'utilisation des "puces", je ne les utiliserai plus ici.
J'ai ouvert un sujet sur le forum lié aux évolutions "des forums", pour voir s'il s'agit d'un problème connu. (voir s'il y a une solution de "contournement")

Pour les longs messages, comme vous faites beaucoup de messages entre chacune de mes réponses, que les questions n'y sont pas forcément très claires et que vous ne répondez pas aux questions de mes réponses précédentes, cela fait mécaniquement augmenter la taille des réponses suivantes, pour ne pas "perdre" de sujets.
Mais comme cela part dans tous les sens. Je vais vraisemblablement "élaguer" des choses, quitte à revenir après sur le sujet.

Je vais donc répondre à mes propres questions car vous ne semblez pas pouvoir "facilement" y répondre. (Si vous ne comprenez pas la réponse indiquez le moi explicitement et ce que vous ne comprenez pas dans mon "autoréponse").
- Une structure de données en C est un regroupement d'informations/données.
- Uns structure de données en C++, c'est comme une structure en C, mais on n'y ajoute les fonctions nécessaires à l'initialisation des données (via le constructeur) et la manipulation "cohérente" de ces données (c'est une très mauvaise définition mais c'est un début et on verra plus tard comment utiliser/concevoir "correctement" une structure/classe C++).
- L'architecture du programme s'articule en 3 "étapes" :
-> initialisation de l'environnement d'exécution (lignes 440 à 470 d'Exemple.cpp)
-> création d'une arborescence d'objets contenant les informations qui nous intéressent (cf. le schéma ci-après) (lignes 476 à 530 d'Exemple.cpp)
-> affichage des informations récoltées dans la console (ligne 531 d'Exemple.cpp)

(Le découpage est assez "arbitraire" car le code est assez mal structuré, mais c'est pas très compliqué à corriger.)

Schéma de l'arborescence des objets créées pendant la 2ème étape du programme :
Pièce jointe 657493
Il y a les lignes noirs qui vont du tronc de l'arbre, ici le seul et unique objet "Serie" créé ligne 509 d'Exemple.cpp, vers les feuilles : les séquences de visionnages.
saisons -> m_liste_episodes -> m_liste_sequence_visonnages
Il y a aussi les flèches de couleurs, qui vont dans l'autre sens, des feuilles vers le tronc.
m_episode -> m_saison -> m_serie

Code :

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

1
2
3
4
5
6
void SequenceVisionnage::UneFonctionDeLaClasseSequenceVisionnage(...)
{
    ...
    auto NumeroSequenceVisionnage = m_episode.GetNumeroSequenceVisionnage(*this);
    ...
}

Code :

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

void SequenceVisionnage::UneFonctionDeLaClasseSequenceVisionnage(???)

Pouvez-vous expliquer ?

"UneFonctionDeLaClasseSequenceVisionnage", c'est juste le nom d'une fonction quelconque de la classe SequenceVisionnage, qu'elle existe déjà ou une future/nouvelle fonction.
Elle ne devrait jamais s'appeler "UneFonctionDeLaClasseSequenceVisionnage" car cela n'a pas de signification "valable".

(foireuse cette boucle, utilisez plutôt une "range-based for loop")

Oui ! Comment faire ?

Déjà expliqué :

Code :

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

1
2
3
4
5
6
7
8
9
10
const void Serie::Print_Saisons()
{
    if (affichage_saisons_actif)
    {
        for (auto saison : saisons)
        {
            Print_Saison(saison);
        }
    }
}

Les "boucles" ("range-based for loop") permettent d'aller dans toutes les "branches/feuilles" de l'arborescence (de gauche à droite sur le schéma ci-avant).

Ben, alors, ... ???

Bin, c'est vous qui devez me donner un exemple d'accès à des données qui vous bloque.

Rien compris !!!

On va le faire pas à pas.
Donnez-moi à quoi doit ressembler l'affichage des informations, SVP.

Ben, non !

Heu, bon si, c'est pas vous qui choisissez comment fonctionnent les expressions régulières, vous devez savoir comment elles fonctionnent pour pouvoir vous en servir correctement.

C'est pas forcement évident, la preuve, un mème qu'un collèque vient de m'envoyer :

https://www.topito.com/top-gif-code-developpeur

Ben, non :
Exemple :
Phrase
Ben oui !
Phrase / verber
Phrase : titre !
verbre : sous-titre !
Et :

Rien compris, en plus le code qui suit ne correspond pas aux formats et n'utilise pas d'expression régulière.

Message du "16/07/2024, 10h13":
Quel est la question ?
Quel rapport avec les pages Web.
J'ai déjà signalé que votre approche n'est pas adaptée à la récupération d'information via du "scrapping" de site Web.

Message du "16/07/2024, 22h25"

Code :

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

if (match[2].matched) // Marches pas !!!

Bin normale, "match[1]" contient l'année de départ et "match[2]" est le mois de départ, qui n'est pas renseigné, donc "match[2].matched" est 'false'.

Message du "17/07/2024, 15h22" :
Pouvez-vous utiliser le débugueur pour voir où cela ne fonctionne pas ?
Comme vous ne nous donnez pas le format des noms de fichiers mais juste des cas d'utilisation, cela complexifie inutilement l'expression régulière : quel est donc le format des noms de fichiers, SVP ?

Erreur C4716:
Rrr !!!

Vous devriez être capable de corriger vous-même cette erreur

Compliqué !
Pas-à-pas !!!

Je ne comprends pas, vous me demandez de faire du pas-à-pas sur du code que vous avez vous-même créé.

===> std::tm tm{ -1, -1, -1, -1, -1, -1, -1, -1, -1 };

Pourquoi vous emmerdez avec un std::tm, quand vous n'avez pas de "time" ???

Code :

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

const std::wstring racine = t + L"Azertyuiop - qsdfghjklm.[2021-2023 Netflix].Manga";

Je n'y arrive pas !

Ici, c'est un peu compliqué.
Vous avez 4 motifs possibles (alternatives) :
\\d{4}\\s => Année + un espace
\\d{4}\\-\\d{4}\\s => "Année1 - Année2" + un espace
\\d{4}\\-\\s => "Année-", comme dans "Tracker.[2024-]", + un espace (et c'est pour ça que cette formule échoue pour "Tracker.[2024-]"
\\d{4} => Année

Les alternatives sont évaluées dans l'ordre dans lequel elles apparaissent dans l'expression régulière.
Donc, pour ne pas avoir de problème, vous devriez commencer par les alternatives les plus longues puis les un peu plus courtes, etc... jusqu'aux plus courtes.

Pour le cas "Tracker.[2024-]", il n'y a pas d'alternavite qui accepte ce motif.
Le plus simple, c'est d'ajouter le motif "\\d{4}\\-" aux autres, mais en respectant l'ordre "du plus long au plus court".
Faites des tests avec https://regex101.com pour comprendre comment ça fonctionne. Mais commencez avec des cas simples.
Une fois que vous avez une expression régulière qui fonctionne avec le nouveau format, ajoutez l'alternative correspondante à la la capture qui est entre parenthèses "()" en respectant l'ordre "du plus long au plus court".

Pour rappel, les différentes alternatives d'une capture sont séparées par un caractère "|" (pipe).

Je suis encore en train de faire un message à rallonge pour répondre à toutes vos "interrogations" mais comme vous faites au moins 3 versions entre chacune de mes réponses et que vous modifiez énormément de code à chaque fois, sans vraiment le simplifier, ça tombe toujours à coté.

Je vous demande de poster une version, avec UNE question qui correspond à l'étape que vous voulez atteindre grâce à une réponse de ma part, et d'attendre ma réponse avant dans poster d'autres versions et d'autres questions, SVP.

Dans la (l'une des) version(s) sous Git "Juillet 20 (23/07/2024)", les "lInfoQuiMInteresse" et "Une_Fonction_De_La_Classe_SequenceVisionnage" ne devraient pas exister (à moins que c'est pour vos tests de compréhension).
Il y a quasiment systématiquement 2 versions avec le même nom dans Git, faudrait configurer votre client Git pour qu'il nomme "correctement" (de manière unique) les versions sous Git.

Dans cette même version, si vous utilisez correctement le débugueur pour faire du pas à pas, vous devriez voir que la ligne 505 d'Exemple.cpp

Code :

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

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

pose un problème avec le répertoire

Code :

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

const std::wstring racine = t + L"Star Wars- The Clone wars.[2008-2020].Animation";

Car l'expression régulière ne gère pas le fait qu'une paire d'année ne soit pas suivi par un espace.
Mais cela ne crée pas de disfonctionnement immédiat car le test "std::regex_match(nomDossier, match2, serie_pattern)" est toujours bon, même si le découpage en motif est foireux.

On a la même expression régulière un peu plus loin dans le code, ligne 1236 de serie.cpp, "std::wregex filename_pattern{ L"(.+?)(?:\\.\\[(\\d{4}\\s|\\d{4}\\-\\d{4}\\s|\\d{4}\\-\\s|\\d{4})?([^\\]]*)\\])?(?:\\.(.+))?")", qui pose le même problème mais qui entraîne ici un disfonctionnement car le découpage foireux a un impact dans la suite du code.
(Avoir la même expression régulière à 2 endroits différents du code, c'est vraiment pas terrible)

En réordonnant les alternatives de la plus longues à la plus courte et en ajoutant la nouvelle alternative (en rouge dans le code ci-après), et en corrigeant aussi l'expression régulière ligne 1248, ça donne :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
Serie::Serie(std::filesystem::path racine)
{
    this->racine = racine;
    auto nomDossier = racine.filename().wstring();
    assert(nomDossier.length() > 0 && L"Nom de dossier vide");


    std::wregex filename_pattern{ L"(.+?)(?:\\.\\[(\\d{4}\\-\\d{4}\\s|\\d{4}\\-\\d{4}|\\d{4}\\-\\s|\\d{4}\\s|\\d{4})?([^\\]]*)\\])?(?:\\.(.+))?" };
    std::wsmatch match;
    if (std::regex_match(nomDossier, match, filename_pattern))
    {
        std::wstring titres = match[1];
        m_titres = Dossier_Titres(titres);
        if (match[2].matched)
        {
            std::wstring annees_str = match[2].str();
            std::wsmatch dummy;
            if (std::regex_match(annees_str, dummy, std::wregex(L"\\d{4}\\-\\d{4}\\s?")))
            {
                m_f_anneesProduction.first = stoi(annees_str);
                m_f_anneesProduction.second = stoi(annees_str.substr(5));
            }
            else
            {
                m_f_anneesProduction.first = stoi(annees_str);
            }
        }

        m_sur = (match[3].matched) ? match[3].str() : L"";

        std::wstring sous_genre = (match[4].matched) ? match[4].str() : L"";
        m_sous_genre = sous_genre;
    }
    else
    {
        assert(false == true && "Le nom du répertoire n'est pas un nom valide.");
    }
}

Avec ce code, les champs m_f_anneesProduction.first et m_f_anneesProduction.second sont correctement *initialisés.

On peut, je pense, simplifier les expressions régulières mais vous devez nous donner le format des noms de répertoires/fichiers de manière plus synthétique.

P.S.: est-ce que des schémas comme dans ce post vous permet de mieux comprendre ?

Problème et AVC : _wfopen_s

C++

Discussions similaires

Partager

Partager