Discussion :

[bacelar]

Toutes mes condoléances pour votre chat.

Pour le reste, si vous êtes encore motivé, c'est de commencer à réfléchir en termes d'objets (Programmation Orientée Objet, POO).

Pour "void Episode::ajouter_SequenceVisionnage(const InfosVisionnage& info_vis)", c'est une fonction membre de la classe Episode, qui doit faire ce qu'indique son nom : ajouter une séquence de sessions de visionnages dans les données stockées dans l'objet de type Episode.
Le champ "m_liste_sequence_visionnages" de la classe Episode est là pour stocker ces informations.
Le champ "m_liste_sequence_visionnages" est de type "std::vector<SequenceVisionnage>", un "std::vector" de "SequenceVisionnage", et pour ajouter un SequenceVisionnage à la fin de ce "std::vector", il faut utiliser sa fonction "push_back".
https://cplusplus.com/reference/vect...tor/push_back/
("std::vector<SequenceVisionnage>" : c'est pas forcément le type de champ le plus adapté à votre besoin mais c'est le plus simple, tant qu'on ne sait pas ce que vous voulez en faire.)

"SequenceVisionnage(info_vis)", c'est un peu une "astuce", c'est l'appel du constructeur de la classe "SequenceVisionnage", qui prend en paramètre un "const InfosVisionnage&".
En forme non "compactée", ça ressemblerait à :

Code :

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

1
2
3
4
5
void Episode::ajouter_SequenceVisionnage(const InfosVisionnage& info_vis)
{
    SequenceVisionnage seq_vis{info_vis};
    m_liste_sequence_visionnages.push_back(seq_vis);
}

Mais en regardant vos source, je m'aperçois que ce constructeur : "SequenceVisionnage(const InfosVisionnage& info_vis)", n'existe pas encore et que le compilateur a fait des pieds et des mains (création d'un objet Episode intermédiaire, cast implicite, etc...) pour rendre ce code "compilable". Il faudra renforcer notre contrôle sur cela en utilisant des classes à la place de structure, implémenter la règle des "big five", etc ...
Moralité, c'est pas parce que cela compile que le code est "bon".

Donc, avec cette simple ligne de code,

Code :

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

m_liste_sequence_visionnages.push_back(SequenceVisionnage(info_vis));

on aurais dû faire ce qu'indique le nom de la fonction "ajouter_SequenceVisionnage".(on modifiera un peu ce code un peu plus tard)

On va donc créer le constructeur manquant :
Ajouter dans le fichier serie.h, les lignes :

Code :

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

1
2
3
4
5
    SequenceVisionnage(const Episode& episode, const InfosVisionnage& info_vis) : 
        m_episode{ episode }, m_titre{ info_vis.m_titre }, m_deux_points{ info_vis.m_deux_points }, m_streaming{ info_vis.m_streaming },
        m_sous_titre{ info_vis.m_sous_titre }, m_duree_en_seconde{ info_vis.m_duree * 60 }, m_phrases{ info_vis.m_phrases },
        m_DatesVisionnage{info_vis.m_DatesVisionnage }
    {};

Vous devriez être capable de savoir où mettre la déclaration/définition d'un constructeur dans la déclaration/définition d'une classe dans un .h, non ?
Vous avez peut-être remarqué que j'ai adapté la signature du constructeur de

Code :

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

SequenceVisionnage(const InfosVisionnage& info_vis)

à

Code :

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

SequenceVisionnage(const Episode& episode, const InfosVisionnage& info_vis)

Cela permet de correctement initialiser le champ constant m_episode de la classe SequenceVisionnage via la "liste d'initialisation".
J'en profite aussi pour initialiser tous les autres champs de la classe SequenceVisionnage depuis les informations stockées dans l'objet de type InfosVisionnage- passé en paramètre du constructeur.
On faudra donc légèrement modifier le code de la fonction "ajouter_SequenceVisionnage":

Code :

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

1
2
3
4
void Episode::ajouter_SequenceVisionnage(const InfosVisionnage& info_vis)
{
    m_liste_sequence_visionnages.push_back(SequenceVisionnage(*this,info_vis));
}

Vous pouvez aussi supprimer/mettre en commentaire les 2 autres constructeurs de SequenceVisionnage, car ils ne devraient plus être utiles (ils sont, en l'état, même "dangereux" car ils n'initialisent pas forcément correctement l'objet.).
Je pense que pas mal des champs de SequenceVisionnage n'ont rien à y faire, comme "m_titre", qui est, si je ne me trompe pas, le titre de l'épisode donc rien à voire avec la séquence de séance de visionnage.
Je rappelle que SequenceVisionnage a un champ m_episode qui référence l'épisode et que le code "m_episode.m_titre" devrait fournir le titre de l'épisode.
Si vous supprimer des champs de SequenceVisionnage, il suffira de supprimer leurs initialisations de la "liste d'initialisation" du constructeur.

Comment faire ?

Exactement comme dans le nouveau constructeur de SequenceVisionnage, en utilisant la "liste d'initialisation" (ici, l'utilisation de la "liste d'initialisation" n'est pas obligatoire pour ces champs non "références constantes" mais autant "prendre le pli".)

Code :

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

Episode(InfosVisionnage const& info_vis) :m_saison{ info_vis.m_saison }, m_numero{ info_vis.m_NumeroEpisode }, m_duree{ info_vis.m_duree }, m_phrases{ info_vis.m_phrases } { ajouter_SequenceVisionnage(info_vis); };

Vous verrez avec ces petites modifications que le contenu des différents objets ne seront pas correctes mais tout cela vient de l'implémentation du constructeur "InfosVisionnage(const Saison& saison, std::filesystem::path const& m_cheminFichier)" qui initialise pas ou très mal les champs de son objet qu'il est en train de construire. Corrigez ce constructeur et tout reviendra en ordre.

Après, les fichiers flim.h et film.cpp : moi même, tous seuls !

Attention, aucune trace de ces fichiers, ni dans Github, ni dans le projet Visual Studio.

xutility :

Attention, nous n'opteront pas les mêmes erreurs que vous, vous utilisez vraisemblablement soit un code, soit un ensemble de fichiers de données, légèrement différents de ceux sous Github.
Essayez de prendre aussi la pile d'appels dans la copie d'écran, SVP.

Les exceptions que nous subissons ne sont pas encore liées aux erreurs d'implémentation du constructeur "InfosVisionnage(const Saison& saison, std::filesystem::path const& m_cheminFichier)" mais à la présence de code type "m_titre[0] = titre[0].substr(0, pos);" (dans la fonction "Serie::initialiser_Titre(fs::path const& m_cheminFichier, std::vector<std::wstring>& m_titre)" par exemple).
Ce type d'erreur a déjà été signalé à la fin de mon post du "16/05/2024, 19h56".
Vous devriez corriger tout le code qui ressemble à ce machin "xxx[y] = ..." en utilisant correctement les std::vector (push_back, ...).

[Laurent_B_]

Bonjour,

Code :

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

1
2
3
4
5
void Episode::ajouter_SequenceVisionnage(const InfosVisionnage& info_vis)
{
    SequenceVisionnage seq_vis{info_vis};
    m_liste_sequence_visionnages.push_back(seq_vis);
}

Ok !

Ah ! Mince !

Code :

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

m_liste_sequence_visionnages.push_back(SequenceVisionnage(info_vis));

Compliqué !

Code :

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

1
2
3
4
5
SequenceVisionnage(const Episode& episode, const InfosVisionnage& info_vis) : 
        m_episode{ episode }, m_titre{ info_vis.m_titre }, m_deux_points{ info_vis.m_deux_points }, m_streaming{ info_vis.m_streaming },
        m_sous_titre{ info_vis.m_sous_titre }, m_duree_en_seconde{ info_vis.m_duree * 60 }, m_phrases{ info_vis.m_phrases },
        m_DatesVisionnage{info_vis.m_DatesVisionnage }
    {};

Alors :

Code :

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

SequenceVisionnage(const Episode& episode, const InfosVisionnage& info_vis)

Et/Ou :

Code :

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

1
2
3
4
void Episode::ajouter_SequenceVisionnage(const InfosVisionnage& info_vis)
{
    m_liste_sequence_visionnages.push_back(SequenceVisionnage(*this,info_vis));
}

Vous pouvez aussi supprimer/mettre en commentaire les 2 autres constructeurs de SequenceVisionnage, car ils ne devraient plus être utiles (ils sont, en l'état, même "dangereux" car ils n'initialisent pas forcément correctement l'objet.).
Je pense que pas mal des champs de SequenceVisionnage n'ont rien à y faire, comme "m_titre", qui est, si je ne me trompe pas, le titre de l'épisode donc rien à voire avec la séquence de séance de visionnage.
Je rappelle que SequenceVisionnage a un champ m_episode qui référence l'épisode et que le code "m_episode.m_titre" devrait fournir le titre de l'épisode.
Si vous supprimer des champs de SequenceVisionnage, il suffira de supprimer leurs initialisations de la "liste d'initialisation" du constructeur.

Compliqué !!!

Code :

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

1
2
 
Episode(InfosVisionnage const& info_vis) :m_saison{ info_vis.m_saison }, m_numero{ info_vis.m_NumeroEpisode }, m_duree{ info_vis.m_duree }, m_phrases{ info_vis.m_phrases } { ajouter_SequenceVisionnage(info_vis); };

Compliqué !!!

???

Les exceptions que nous subissons ne sont pas encore liées aux erreurs d'implémentation du constructeur "InfosVisionnage(const Saison& saison, std::filesystem::path const& m_cheminFichier)" mais à la présence de code type "m_titre[0] = titre[0].substr(0, pos);" (dans la fonction "Serie::initialiser_Titre(fs::path const& m_cheminFichier, std::vector<std::wstring>& m_titre)" par exemple).
Ce type d'erreur a déjà été signalé à la fin de mon post du "16/05/2024, 19h56".
Vous devriez corriger tout le code qui ressemble à ce machin "xxx[y] = ..." en utilisant correctement les std::vector (push_back, ...).

Ok !


https://github.com/laurentbouleau/Exemple : Mai 11 (2024/05/24)

Excuse-moi !!! Pas-à-pas !!!

Merci

[Laurent_B_]

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
void Serie::initialiser_Titre(fs::path const& m_cheminFichier, std::vector<std::wstring>& m_titre)
{ // Titre
    auto nomFichier = m_cheminFichier.wstring();
    assert(nomFichier.length() > 0 && L"Nom de fichier vide");
    std::vector<std::wstring> titre = lire_fichierTxt(m_cheminFichier.wstring(), { L"\r\n" });
    assert((titre.size() != 0));

    wregex titre_pattern{ L"(.+?)(\\s:\\s|:\\s|/|\\s-\\s)(.+)" };
    std::wsmatch match;
    if (std::regex_match(titre[0], match, titre_pattern))
    {
        m_titre.push_back(match[1]);
        if (match.length() > 2)
        {
            m_titre.push_back(match[2]);
        }
        if (match.length() > 3)
        {
            m_titre.push_back(match[3]);
        }
    }
    else
    {
        m_titre.push_back(titre[0]);
    }

    initialiser_Duree(titre[1]);
    for (auto j = 2; j < titre[1].size(); j++)
        m_phrases += titre[j];
}

Excuse-moi !!!

Merci

[Médinoc]

Il faudrait utiliser std::wregex plutôt que wregex tout court, non?

[Laurent_B_]

Ok !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
void Serie::initialiser_Titre(fs::path const& m_cheminFichier, std::vector<std::wstring>& m_titre)
{ // Titre
    auto nomFichier = m_cheminFichier.wstring();
    assert(nomFichier.length() > 0 && L"Nom de fichier vide");
    std::vector<std::wstring> titre = lire_fichierTxt(m_cheminFichier.wstring(), { L"\r\n" });
    assert((titre.size() != 0));

    std::wregex titre_pattern{ L"(.+?)(\\s:\\s|:\\s|/|\\s-\\s)(.+)" };
    std::wsmatch match;
    if (std::regex_match(titre[0], match, titre_pattern))
    {
        m_titre.push_back(match[1]);
        if (match.length() > 2)
        {
            m_titre.push_back(match[2]);
        }
        if (match.length() > 3)
        {
            m_titre.push_back(match[3]);
        }
    }
    else
    {
        m_titre.push_back(titre[0]);
    }

    initialiser_Duree(titre[1]);
    for (auto j = 2; j < titre[1].size(); j++)
        m_phrases += titre[j];
    ;
}

Ben, non !!!
???

[Laurent_B_]

Ok ! Merci

[Laurent_B_]

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
void Serie::initialiser_Duree(std::wstring& m)
{
    const std::wregex duree_format_rg{ L"([[:digit:]]+)\\s?(min|MIN|Min)" };

    std::wsmatch match;

    if (std::regex_match(m, match, duree_format_rg))
    {
        auto duree_en_minute = std::stoi(match[1]);
        m_duree = duree_en_minute * 60;
    }
    else
    {
        throw std::invalid_argument("'" + std::string{ m.begin(),m.end() } + "' n'est pas un format de durée valide.");
    }
}

void Serie::initialiser_Titre(fs::path const& m_cheminFichier, std::vector<std::wstring>& m_titre)
{ // Titre
...
    initialiser_Duree(titre[1]);
}

Alors... Ben non !

[Laurent_B_]

Code :

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

std::vector<std::wstring> titre = lire_fichierTxt(m_cheminFichier.wstring(), { L"\r\n" });

par :

Code :

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

std::vector<std::wstring> titre = lire_fichierTxt(m_cheminFichier.wstring(), { L"\n" });

Ok ! Comprends pas !!!

Merci

[Laurent_B_]

https://github.com/laurentbouleau/Exemple : Mai 12 (2024/05/24)

Code :

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

1
2
3
4
void SequenceVisionnage::Print()
{
    ; // ???
}

Code :

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

1
2
3
4
5
6
bool SequenceVisionnage::Print_Titre_chiffre_et_point_ou_pas(unsigned short int episode)
{
    if (episode == 0)
        return false;
    return true;
}

Code :

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

1
2
3
4
void Episode::ajouter_SequenceVisionnage(const InfosVisionnage& info_vis)
{
    m_liste_sequence_visionnages.push_back(SequenceVisionnage(*this, info_vis));
}

Code :

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

1
2
3
4
5
6
7
8
void Episode::Print()
{
    //Print_Data(); // ???
    for (auto vis : m_liste_sequence_visionnages)
    {
        vis.Print();
    }
}

Code :

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

1
2
3
4
void Saison::ajouter_InfosVisionnage(SequenceVisionnage const& seq_vis)
{
    //m_liste_episodes.insert({ 1, seq_vis }); // ???
}

Etc...

Je suis crevé

Merci

[Laurent_B_]

Bonjour,

Code :

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

   std::map<int, std::shared_ptr<Episode>> m_liste_episodes;

avec :

insert
emplace

Comment faire ?

Exemple :

Code :

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

1
2
3
4
void Saison::ajouter_InfosVisionnage(SequenceVisionnage const& seq_vis)
{
    ???
}

et :

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
void Saison::initialiser_Fichier(fs::path const& m_cheminFichier)
{
...
        if (std::regex_match(nomFichier, std::wregex{L"([[:digit:]]{1,2})x(.)+"}))
        {
            InfosVisionnage info_vis{ *this, m_cheminFichier };
            if (m_liste_episodes.find(info_vis.m_NumeroEpisode) != m_liste_episodes.end())
            {
                m_liste_episodes[info_vis.m_NumeroEpisode]->ajouter_SequenceVisionnage(info_vis);
            }
            else
            {
                m_liste_episodes.emplace(std::pair<const int, shared_ptr<Episode>>{ info_vis.m_NumeroEpisode, make_shared<Episode>(info_vis) });
            }
            return;
        }
...
}

Merci

[Laurent_B_]

Mais :

Code :

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

   std::map<int, std::shared_ptr<Episode>> m_liste_episodes;

Merci

[bacelar]

Dans mon post du 16/05/2024, 22h38:

...
Donc, ne confondez pas ces 2 configurations.

Je vous conseille donc d'avoir en Debug :
"Base de données du programme pour Modifier et Continuer (/ZI)" en tant que "format des informations de débogage" + "Non" pour "optimisation de l'ensemble du programme"

Et en Release :
"Base de données du programme (/Zi)" en tant que "format des informations de débogage" + "Oui (GL)" pour "optimisation de l'ensemble du programme".

Mais bon, vous ne devriez pas basculer en configuration "Release" avant d'avoir bien stabilisé votre code.

Actuellement, il y a toujours 2 anomalies dans la configuration du projet (qui ne bloque pas actuellement le développement mais c'est toujours bien de les corriger rapidement).
1 - en Debug, vous devriez avoir
"Base de données du programme pour Modifier et Continuer (/ZI)" en tant que "format des informations de débogage"
et PAS "Base de données du programme (/Zi)"

2 - en Release, vous devriez avoir
"Oui (GL)" pour "optimisation de l'ensemble du programme" et PAS "Non".

Chaque configuration doit être corrigé indépendamment, pas de "Toutes les configurations".

Compliqué !

Compliqué !!!

Pouvez-vous être plus précis car on ne voit pas clairement si cela s'applique au code/paragraphe qui est avant ou après cette remarque, SVP.

Vous avez appliqué la modification du constructeur de SequenceVisionnage mais pas celle sur le constructeur d'Episode, pourquoi ?
C'est pourtant la même mécanique, initialiser les champs de la classe à partir de paramètres du constructeur via la liste d'initialisation (et un appel à une fonction non virtuelle en plus pour le constructeur d' Episode).
En faisant cela proactivement, vous éliminez beaucoup de bugs potentiellement difficiles à déterminer.

Et/Ou :

Je ne comprend pas.

"Episode::ajouter_SequenceVisionnage(const InfosVisionnage& info_vis)" utilise "SequenceVisionnage(const Episode& episode, const InfosVisionnage& info_vis)", il vous faut donc les 2.

Vos modifications dans le code montrent que vous commencez à "simplifier" votre code mais attention au copier-coller "abusif".
Pensez à factoriser votre code.

Je suppose que vous mettez en application ma remarque :

Vous devriez corriger tout le code qui ressemble à ce machin "xxx[y] = ..." en utilisant correctement les std::vector (push_back, ...).

en utilisant mon exemple dans "initialiser_Titre_Original".

Mais vous avez ajouté à la fin du code de "Serie::initialiser_Titre" :

Code :

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

1
2
3
initialiser_Duree(titre[1]);
for (auto j = 2; j < titre[1].size(); j++)
    m_phrases += titre[j];

Ce qui semble logique avec le contenu du fichier "Titre.txt" dans le répertoire "Azertyuiop - qsdfghjklm.[2021-2023 Netflix].Manga".
("Azertyuiop - qsdfghjklm.[2021-2023 Netflix].Manga" est une "vraie" série ou est-ce un "jeu de tests" ?)
Mais "Azertyuiop - qsdfghjklm.[2021-2023 Netflix].Manga" est le répertoire racine d'une série ; et une durée pour une série, c'est pas logique (à moins d'être la somme des durées de tous les épisodes de toutes les saisons de la série). (Pensez aussi à supprimer les champs dans les classes où ils n'ont pas de sens, comme la durée dans une série).
Je pense donc que le contenu du fichier "Titre.txt" dans le répertoire "Azertyuiop - qsdfghjklm.[2021-2023 Netflix].Manga" est erroné car il reprend le format d'un fichier "Infos de visionnage d'un épisode", ce qui n'est pas "logique".
Ne mettez pas au point votre code avec du contenu de fichier erroné. Sinon votre code sera potentiellement faux, même s'il fonctionne avec le "jeu de test" erroné.
Mettez à plat le format des différents types de fichiers, sinon, vous allez tourner en rond.
Chaque format de fichier devrait avoir une fonction dédiée à ce format.

Pensez à rapidement rendre votre code plus lisible, en utilisant des noms de variable plus explicites, comme "lignes" à la place de "titre" dans la fonction "Serie::initialiser_Titre".
Arrêtez votre manie d'utiliser le préfixe "m_" dans le nom des paramètres des fonctions. "m_", c'est pour "membre", donc les champs d'une classe, par un paramètre d'une fonction. SVP.
Avec cette manie, le paramètre "m_titre" de la fonction "Serie::initialiser_Titre" cache le champ "m_titre" de la classe Serie.
"Serie::initialiser_Titre" est une fonction membre de la classe Serie et non une fonction "libre", comme "initialiser_Titre_Original".
En tant que fonction membre, elle a un accès privilégié aux champs de la classe, dont "m_titre".
Donc, simplement en supprimant le paramètre "m_titre" de la fonction, le code accèdera directement au champ de même nom dans la classe Serie => le code sera donc bien plus simple.
De plus, comme le champ "m_titre" contiendra potentiellement plusieurs titre, je renommerai ce champ "m_titres".

Je mentionne la fonction "Serie::initialiser_Titre", non pas parce que vous la mentionnez dans votre message du "24/05/2024, 16h34", mais parce que c'est là, avec le code et les données du Github Version "Mai 11 (2024/05/24)", que le programme plante.
Si vous mentionnez cette fonction parce que vous avez aussi déterminé qu'il y avait un problème dans la fonction avec le débugueur, je serai très impressionné.
Si ce n'est pas le cas, pouvez-vous faire des copies d'écran du débugueur lors du premier "plantage", pour qu'on puisse vous indiquer où regarder pour bien comprendre le problème ?
(Copie d'écran avec la pile d'appel, et en ayant correctement configuré les options de compilation (cf. le début de ce message), SVP)

Le plantage se produit à la ligne :

Code :

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

initialiser_Duree(titre[1]);

Pour comprendre le problème, il faut prendre un peu de recul.
Le code de la fonction "Serie::initialiser_Titre" considère que la fonction "lire_fichierTxt" remplit le résultat qu'elle retourne avec une ligne du fichier par élément dans le "std::vector<std::wstring>".
Mais la fonction "lire_fichierTxt" met toutes les lignes du fichier dans un seul std::wstring.
Donc le code "titre[1]" génère une erreur car "lire_fichierTxt" n'a rempli que "titre[0]" (avec tout le contenu du fichier) et "titre[1]" n'existe pas.
Il faut donc, avant tout, corriger la fonction "lire_fichierTxt" pour qu'elle remplisse correctement le "std::vector<std::wstring>" et pas juste de premier "std::wstring".
Utilisez le débugueur pour comprendre où la fonction "lire_fichierTxt" commence à déconner et donc la corriger.

Mais vous avez mis en exergue

Code :

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

wregex titre_pattern{ L"(.+?)(\\s:\\s|:\\s|/|\\s-\\s)(.+)" };

et pas toute la fonction "Serie::initialiser_Titre".
C'est donc vraisemblablement que vous voulez quelques explications sur les expressions régulières (et aussi le fait que vous avez semblé galérer à les utiliser dans le constructeur de la classe "InfosVisionnage").

Le principe des expressions régulière est de trouver un motif dans une chaine de caractère.
Mais un motif est souvent composé de "sous-motifs".
Dans le code à base d'appels à la fonction "std::string::find", que vous mettez un peu partout malheureusement, qui cherchait à déterminer les titres (originaux cf. la fonction "initialiser_Titre_Original"), j'ai déduit que la ligne contenant le ou les titres était formée de 3 parties (=> sous-motifs):
- La partie avant un éventuel séparateur formant le "1er" titre
- un séparateur ayant plusieurs forme possible : ":" (avec plus ou moins d'espaces l'entourant) ou " / " ou " - "
- L'éventuel partie après le séparateur, qui composera le "2ème" titre
Pour rendre pratique les expressions régulières dans le cadre des "sous-motifs" et en particulier la récupération des parties de la chaine de caractère constituants ces sous-motifs, on utilise des parenthèses () pour spécifier les différents sous-motifs.
Dans notre cas des lignes de titres constitués de 3 parties, ça donne :
(___)(___)(___)
(J'espère que vous n'êtes pas daltonien, sinon, l'explication qui suit ne sera pas claire )

Il faut donc remplacer mes "___" par les motifs correspondants à la sous-partie concernée.

On va commencer par (___) car c'est la plus simple.
C'est, en gros, tout ce qui est après le séparateur.
"." est un "meta caractère" qui correspond à n'importe quel caractère "standard".
"+" est un quantificateur qui signifie "au moins 1".
Donc ".+", c'est "au moins un caractère standard".
Et comme "(.+)" apparait après "(___)" (le sous-motif des séparateurs), ça "capturera" la partie de la chaine qui correspondra à tout ce qui est après le séparateur.

Pour (___), c'est un peu plus compliqué.
C'est, en gros, l'ensemble des séparateurs possibles.
"|", c'est pour indiquer une opération logique "ou".
"A|B" signifie qu'on attend un "A" ou un "B".
"\s" est un autre "meta caractère" qui correspond uniquement aux caractères d'espacement comme l'espace ou une tabulation horizontale.
En C++, comme en C, le caractère "" doit être "escapé" quand il apparaît dans une chaine de caractère, ce qui expliquera le deuxième "" plus tard.
Les caractères qui ne peuvent pas être interprétés comme un "méta caractère" (".", le "" de "\s", ..) ou un quantificateur ("+","*","{}",..) ou spécial ("^","$","()","[]',..) sont dit "littéraux" et ne correspondent qu'à "eux même".
Donc "\\s:\\s", c'est le motif qui correspond à un "2 points" précédé d'un caractère d'espacement et suivi d'un autre caractère d'espacement.
"\\s:\\s|:\\s" correspond donc à "soit un "2 points" précédé d'un caractère d'espacement et suivi d'un autre caractère d'espacement OU un "2 points" suivi d'un caractère d'espacement. (Il y a plus élégant pour gérer le caractère optionnel d'un caractère mais on va rester simple.)
Si on généralise bêtement à tous les cas qui utilisaient des "la fonction "std::string::find" en cascade, ça donne :
(\\s:\\s|:\\s|/|\\s-\\s)
Vous voyez donc qu'avec cette formule de quelques caractères on résume l'ensemble des séparateurs possibles.

Il reste (___) qui est plus simple.
C'est en gros, tout ce qui est avant un éventuel séparateur.
On pourrait être tenté par la même formule que "(.+)", mais, par défaut, le moteur des expressions régulières cherche à mettre le maximum de choses dans chaque capture de motif.
Avec cette formule, et comme ":", "/", "-" et les caractères d'espacement sont des caractères "standard", le ".+" va "mangé" toute la ligne, ne laisant plus rien pour les 2 autres captures qui suivent.
C'est ce qu'on appelle le mode "glouton".
Pour désactiver ce mode "glouton", il faut ajouter un "?" après le quantificateur.
Ainsi, si capturer un caractère supplémentaire interdit aux autres sous-motifs qui suivent de capturer quelque chose, ce caractère supplémentaire ne sera pas capturé.
Comme (___) apparait avant la partie "séparateurs", (.+?) indique donc tout ce qui est avant les séparateurs éventuels.

Pour les messages postérieurs à "24/05/2024, 16h34", je n'y répondrai pas dans ce message parce qu'ils abordent des parties qui sont inaccessibles sans avoir préalablement "corrigé" (ou contourné le problème) signalé dans la fonction "Serie::initialiser_Titre".
Je vais donc récupérer la nouvelle version avant d'y répondre.

[bacelar]

Après récupération de la version "Mai 12 (2024/05/24)", mes "craintes" se sont confirmées.

Le problème sur la fonction "lire_fichierTxt" a été involontairement contourné, mais il reste présent.

Avant de faire des modifications, vous devriez essayer de comprendre le "fond/origine" du problème.

Pour cela, vous devez utiliser intensivement le débugueur en mode pas à pas.

Vous comprendrez ainsi le "fond/origine" du problème.

Mais pour utiliser confortablement le débugueur en mode pas à pas, il faut correctement configurer votre projet, et en particulier :

Je vous conseille donc d'avoir en Debug :
"Base de données du programme pour Modifier et Continuer (/ZI)" en tant que "format des informations de débogage"

Cela fait pas mal de temps que je signale le "problème" mais vous ne l'avez toujours pas corrigé, mais maintenant, cela devient très gênant.

En regardant pas à pas l'exécution de la fonction "lire_fichierTxt" (que je trouve bien trop complexe en faisant bien trop de chose à la fois) avec le débugueur, vous verrez qu'elle fonctionne un peu moins mal quand "\n" est dans la liste des séparateurs passées dans le paramètre "separeteurs" de la fonction.
Vous avez 3 fonctions "lire_fichierTxt" différentes et je pense qu'au moins 2 sont inutiles.
Le problème est ici :

Code :

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

1
2
3
4
while (getline(fichier, ligneCourante, u8'\n'))
{
    contenuFichier += ligneCourante + u8'\n';
}

Avec ce code, vous lisez "ligne à ligne" le contenu du fichier, chaque "ligne" étant séparée par un '\n' de la suivante. Et on rajoute chaque ligne (contenu de la variable "ligneCourante"), qui n'a plus son séparateur "\n"(effet de bord de la fonction "getline"), dans la variable "contenuFichier" ; mais en lui ajoutant un "\n" à la fin, avant de l'ajouter à "contenuFichier".
Donc un truc extrêmement compliqué pour un truc qu'un simple appel à la fonction "read" de objet "istream" ferait directement:

Code :

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

1
2
3
const size_t dataSize(static_cast<size_t>(fichier.rdbuf()->in_avail()));
contenuFichier.reserve( dataSize);
fichier.read(&contenuFichier[0], dataSize);

Pour des trucs encore plus directes :
https://stackoverflow.com/questions/...-a-string-in-c
https://stackoverflow.com/questions/...stdstring-in-c

En plus, comme getline n'a pas été conçu pour lire des fichiers, le caractère '\r' dans la séquence de caractère "\r\n" a été supprimé de la ligne (comme le '\n' de cette séquence).
Comme les '\r' ont disparu avec cette boucle un peu foireuse, un appel comme "lire_fichierTxt(m_cheminFichier.wstring(), { L"\r\n" })" ne renvoie qu'un élément contenant tout le contenu de tout le fichier "m_cheminFichier" expurgé des "\r".
Donc pas ce qu'on attend d'une fonction "lire_fichierTxt", selon moi, bien que le nom de cette fonction porte à confusion => Prenez le temps de nommer correctement vos fonctions (et vos variables).
Attention :
[lire_fichierTxt(m_cheminFichier.wstring(), { L"\r\n" })], c'est différent de [lire_fichierTxt(m_cheminFichier.wstring(), { L"\r",L"\n" })]

Corrigez d'abord les fonctions de bas niveau, qui sont utilisées par beaucoup d'autres fonctions, en priorité.
Simplifier "lire_fichierTxt" qui fait beaucoup trop de choses (et de manière inutilement complexe cf. la boucle ci-avant).
Par exemple, séparez la lecture du contenu du fichier, du découpage en "std::vector<std::wstring>".

L'image de votre post du "24/05/2024, 15h17" montre que vous n'utilisez pas les mêmes sources/données que ce qu'il y a dans Girhub.
Sans ces informations à jours, on ne peut pas vous aider efficacement.

Actuellement, avec la version "Mai 12 (2024/05/24)" dans GitHub, le programme plante à la ligne 'if (m_titre_original[2] != L"")' de la fonction "Print_Titre_Original".
C'est logique car "m_titre_original" (qui est un paramètre de la fonction, malgré le préfixe "m_" ) ne contient qu'un élément.
"m_titre_original[0]" contient "Stay Close", ce qui est logique avec le contenu du fichier "Titre original.txt".
Pour que le code soit correct, il faut remplacer 'if (m_titre_original[2] != L"")' par un plus simple et robuste 'if (m_titre_original.size()>2)'.
Je ne sais pas quelle modification vous avez fait pour que le programme ne plante plus, en espérant que cette modification ne soit pas un infâme bricolage. (Code/données à jour dans GitHub, SVP.)


La remarque de @Médinoc permet de voir que vous utilisez une très mauvaise pratique.
Le code utilisant "wregex" sans "std::" devant compile chez vous car vous avez mis ligne 31 de serie.cpp :

Code :

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

using namespace std;

C'est une très mauvaise pratique et vous devriez supprimer ce genre de ligne de tous vos .cpp.
Et c'est encore pire dans les .h.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void Serie::initialiser_Duree(std::wstring& m)
{
    const std::wregex duree_format_rg{ L"([[:digit:]]+)\\s?(min|MIN|Min)" };

    std::wsmatch match;

    if (std::regex_match(m, match, duree_format_rg))
    {
        auto duree_en_minute = std::stoi(match[1]);
        m_duree = duree_en_minute * 60;
    }
    else
    {
        throw std::invalid_argument("'" + std::string{ m.begin(),m.end() } + "' n'est pas un format de durée valide.");
    }
}

void Serie::initialiser_Titre(fs::path const& m_cheminFichier, std::vector<std::wstring>& m_titre)
{ // Titre
...
    initialiser_Duree(titre[1]);
}

Alors... Ben non !

"Ben non !" QUOI !?!
La ligne de code que vous avez marqué en rouge, c'est une ligne qui lance une exception quand on ne trouve pas une chaine de caractère avec un "bon" format pour indiquer une durée.
Quel est le problème ?
Je trouve le lancement d'une exception tout à fait justifié, et le texte d'erreur essaye d'envoyer un maximum d'information avec les données dont on dispose à ce moment là.
Mais comme je l'ai déjà indiqué dans mon post du '26/05/2024, 02h43', je pense que l'appel à la fonction "Serie::initialiser_Duree" dans "Serie::initialiser_Titre" n'a aucun sens, et que même la fonction "Serie::initialiser_Duree" dans son entier n'a aucun sens. C'est quoi la durée d'une série ???

Code :

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

std::vector<std::wstring> titre = lire_fichierTxt(m_cheminFichier.wstring(), { L"\r\n" });

par :

Code :

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

std::vector<std::wstring> titre = lire_fichierTxt(m_cheminFichier.wstring(), { L"\n" });

Ok ! Comprends pas !!!

Merci

C'est "Ok !" ou "Comprends pas !!!" ???
Pour l'explication de la différence de comportement, voir mon explication au début de ce post sur les bugs dans la fonction "lire_fichierTxt".

Code :

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

1
2
3
4
void SequenceVisionnage::Print()
{
    ; // ???
}

Faut juste implémenter ce que suggère le titre de la fonction : "afficher dans la console les informations d'une séquence de séance de visionnage".
Exactement comme font les fonctions "Episode:: Print()" pour un épisode, "Saison:: Print()" pour une saison ou encore "Serie:: Print()" pour une série.
S'il manque des choses dans la classe "SequenceVisionnage" pour pouvoir afficher ce qui vous intéresse, ajoutez les champs nécessaires dans cette classe, et faites en sorte que ces champs soient correctement initialisés.

Code :

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

1
2
3
4
5
6
bool SequenceVisionnage::Print_Titre_chiffre_et_point_ou_pas(unsigned short int episode)
{
    if (episode == 0)
        return false;
    return true;
}

Je n'ai pas la moindre idée de ce que doit faire cette fonction.
Elle n'est jamais utilisée et son nom est complètement abscons pour moi.(Faites des fonctions simples et leur nom "claire" devrait être simple à trouver)
Son implémentation n'a aucun sens non plus. C'est quoi un "episode" sous forme d'un "unsigned short int" ?
Expliquez-moi à quoi elle doit servir, SVP.

Code :

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

1
2
3
4
void Episode::ajouter_SequenceVisionnage(const InfosVisionnage& info_vis)
{
    m_liste_sequence_visionnages.push_back(SequenceVisionnage(*this, info_vis));
}

Quelle est la question ?
On peut aussi l'écrire de manière moins compacte :

Code :

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

1
2
3
4
5
void Episode::ajouter_SequenceVisionnage(const InfosVisionnage& info_vis)
{
    SequenceVisionnage tmp{*this, info_vis};
    m_liste_sequence_visionnages.push_back(tmp);
}

(Je crois déjà avoir donné cette version "dépliée", non ?)
Je trouve que le nom de la fonction membre "Episode::ajouter_SequenceVisionnage" est assez explicite : elle ajoute les informations d'une séquence de séance de visionnage dans l'objet de type Episode.
Les informations de la "séquence de séance de visionnage" sont stockées dans un objet de type "InfosVisionnage" passé en paramètre. Pour rappel, un "InfosVisionnage" stocke à la fois les informations d'un épisode et d'une "séquence de séance de visionnage".
Mais bon, avec les "Titre.txt" d'une série qui stocke une durée, ce qui n'a pas de sens. Peut-être que les fichiers qui stockent à la foi des informations sur les épisodes et sur une "séquence de séance de visionnage", c'est peut-être aussi une erreur dans les données que vous nous fournissez.

Pouvez-vous expliciter l'architecture des données de votre projet : format de l'arborescence de fichiers et format de chaque type de fichier dans cette arborescence, SVP.

Code :

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

1
2
3
4
5
6
7
8
9
void Episode::Print()
{
    //Print_Data(); // ???
    for (auto vis : m_liste_sequence_visionnages)
    {
        vis.Print();
    }
}

Le rôle de la fonction "Episode:: Print()", c'est un peu le même que "SequenceVisionnage:: Print()", "afficher dans la console les informations" mais d'un épisode, et non d'une "séquence de séance de visionnage".
Votre boucle "for' n'affichera que les informations des "séquences de séances de visionnage" les unes derrière les autres mais aucune des informations spécifiques à un épisode, comme son titre ou sa durée.
Il me semble qu'une fonction "Episode:: Print_Data" est un nom assez explicite pour afficher les informations spécifiques à l'épisode, non ?
L'implémentation sera fonction de comment vous voulez afficher ces informations dans la console.

Vous nous n'avez toujours pas indiqué à quoi DEVRAIT ressembler l'affichage dans la console de la série "Azertyuiop - qsdfghjklm.[2021-2023 Netflix].Manga", Si on ne sait pas où on doit aller, on va tourner en rond longtemps !!!

Code :

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

1
2
3
4
void Saison::ajouter_InfosVisionnage(SequenceVisionnage const& seq_vis)
{
    //m_liste_episodes.insert({ 1, seq_vis }); // ???
}

Franchement, cette fonction n'a aucun sens pour moi.
Elle n'ai jamais utilisée.
Si vous ne savez pas à quoi elle sert, dégagez là.
Sinon, expliquez ce qu'elle est sensée faire, parce que là, elle fait que des conneries.

Etc...

Heu, "Etc" ???
Vous copiez-collez des bouts de codes dans tous les sens sans vraiment poser de question, donc difficile de trouver une cohérence dans tout cela et donc d'extrapoler vos problèmes.

Ce qui est clair, c'est que sans une vue claire de ce que vous voulez comme résultats (format d'affichage d'une Série, d'une Saison, d'un Episode, etc...), ET QUE VOUS NOUS LA COMMUNIQUIEZ CLAIREMENT, on va tourner en rond très très longtemps.

Et commencez par corriger les fonctions de bas niveau comme "lire_fichierTxt", ou encore le constructeur de "InfosVisionnage" qui oublie généralement d'initialiser correctement tout un tas de champs de la classe, qui entraine l'affichage complètement foireux que vous avez posté le '26/05/2024, 15h17'.
Foirage accentué par le code suivant :

Code :

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

1
2
3
4
5
6
std::size_t taille;
taille = std::size(m_liste_episodes);
for (auto i = 0; i < taille; i++)
{
    m_liste_episodes[i]->Print();
}

dans la fonction "Saison:: Print()".
Rien ne garantit que vous n'avez pas de "trous" dans les données des épisodes et avec les bugs dans le constructeur de "InfosVisionnage" vous en aurez. Et au premier trou, c'est un plantage (si vous avez de la chance).

Faites du code simple et robuste, en commençant par corriger les fonctions de "bas niveau".

Code :

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

std::map<int, std::shared_ptr<Episode>> m_liste_episodes;

avec :
insert
emplace

https://stackoverflow.com/questions/...rator-in-c-map
Mais c'est peut-être plus claire avec un std::vector, mais c'est la même logique qu'avec une std::map :
https://stackoverflow.com/questions/...lace-vs-insert
En gros, toujours prendre "emplace" pour éviter des copies.

Mais pourquoi cette question ?
Toutes les manipulations d'ajout dans le champ m_liste_episodes d'une saison sont déjà toutes dans la fonction "Saison::initialiser_Fichier".

Si vous pensez en avoir besoin ailleurs, je pense que c'est une erreur.

Code :

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

1
2
3
4
void Saison::ajouter_InfosVisionnage(SequenceVisionnage const& seq_vis)
{
    ???
}

Comme déjà indiqué avant, cette fonction est une erreur totale, je pense.

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
void Saison::initialiser_Fichier(fs::path const& m_cheminFichier)
{
...
        if (std::regex_match(nomFichier, std::wregex{L"([[:digit:]]{1,2})x(.)+"}))
        {
            InfosVisionnage info_vis{ *this, m_cheminFichier };
            if (m_liste_episodes.find(info_vis.m_NumeroEpisode) != m_liste_episodes.end())
            {
                m_liste_episodes[info_vis.m_NumeroEpisode]->ajouter_SequenceVisionnage(info_vis);
            }
            else
            {
                m_liste_episodes.emplace(std::pair<const int, shared_ptr<Episode>>{ info_vis.m_NumeroEpisode, make_shared<Episode>(info_vis) });
            }
            return;
        }
...
}

Toujours la même réponse, c'est l'implémentation de l'algorithme mentionnée depuis des semaines (message du 09/04/2024) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
<Scan des fichiers d'un Saison>
    Si fichier de la forme "numéroSaisonxNuméroEpisode.{listeDeDates}.txt" 
        alors
            Créer un "InfosVisionnage" à partir du fichier
            Si l'Episode le numéro d'épisode indiqué dans l'InfosVisionnage existe déjà dans la saison
                alors
                    Mettre à jour l'Episode avec la "SequenceVisionnage" contenu dans l'InfosVisionnage (voir aussi vérifier que les informations sur l'épisode dans l'InfosVisionnage soit les mêmes que dans l'épisode trouvé dans la Saison)
                Sinon
                    Créer un nouvel Episode en lui passant l'InfosVisionnage pour que l'épisode initialise ces champs, y compris son "m_liste_visionnages"
        Sinon
            ....
<Fin Scan des fichiers d'un Saison>

Code :

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

m_liste_episodes[info_vis.m_NumeroEpisode]

Ca récupère l'épisode de numéro "info_vis.m_NumeroEpisode" dans la std::map "m_liste_episodes", champ de la saison contenant l'ensemble des épisodes de la saison.

Code :

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

ajouter_SequenceVisionnage(info_vis)

Appelle la fonction "Episode::ajouter_SequenceVisionnage" sur l'objet Episode qui a été retrouvé via le code avant le "->" de la ligne.
Et comme l'indique le nom de la fonction, elle ajoute une "séquence de séances de visionnage" à l'épisode.

Code :

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

m_liste_episodes.emplace(std::pair<const int, shared_ptr<Episode>>{ info_vis.m_NumeroEpisode, make_shared<Episode>(info_vis) });

Code un peu complexe, c'est un peu pour ça que je vous l'ai donné un peu tout fait.

Code :

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

make_shared<Episode>(info_vis)

Code qui correspond à "Créer un nouvel Episode en lui passant l'InfosVisionnage pour que l'épisode initialise ces champs".
Le "make_shared", c'est parce que la std::map "m_liste_episodes" contient des "std::shared_ptr<Episode>" et pas des objets "Episode".
Un "std::shared_ptr", c'est comme un pointeur mais en mieux (plus "intelligent/smart").

Code :

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

m_liste_episodes.emplace(std::pair<const int, shared_ptr<Episode>>{ info_vis.m_NumeroEpisode,...}

C'est ce qui permet d'enregistrer l'objet Episode dans le champ/ la std::map "m_liste_episodes" avec le numéro d'épisode "info_vis.m_NumeroEpisode" lui correspondant.

Mais pour que ce code fonctionne bien, il faut que le constructeur d'"InfosVisionnage" fonctionne correctement, ce qui n'est pas le cas.

Encore une fois, commencez par corriger les fonctions de bas niveau.

[bacelar]

Je vous ai peut-être noyé sous les remarques ?
Commencez par corriger la fonction "lire_fichierTxt", quitte à la découper en plusieurs autres fonctions.

[Laurent_B_]

Bonsoir,

Je suis crevé !

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
const std::wstring lire_fichierTxt(std::wstring const& nomFichier)
{
    std::string contenuFichier{ u8"" };
    std::string ligneCourante{ u8"" };
 
    ifstream fichier{nomFichier};
    if (!fichier)
    {
        throw std::runtime_error("Fichier impossible à ouvrir.");
    }
    /*
    while (getline(fichier, ligneCourante, u8'\n'))
    {
        contenuFichier += ligneCourante + u8'\n';
    }*/
    const size_t dataSize(static_cast<size_t>(fichier.rdbuf()->in_avail()));
    contenuFichier.reserve(dataSize);
    fichier.read(&contenuFichier[0], dataSize);
 
    if (contenuFichier == u8"")
    {
        //return L"";
        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);
    return converti;
}

Excuse-moi ! Rien compris !!!

Code :

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

1
2
3
    const size_t dataSize(static_cast<size_t>(fichier.rdbuf()->in_avail()));
    contenuFichier.reserve(dataSize);
    fichier.read(&contenuFichier[0], dataSize);

Avant ou après ?

Merci

[Laurent_B_]

Code :

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

const std::wstring lire_fichierTxt(std::wstring const& nomFichier)

???
Pourquoi ?

[Laurent_B_]

https://github.com/laurentbouleau/Exemple : Mai 14 (2024/05/29)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
const std::vector<std::pair<std::wstring, std::wstring>>lire_paireCleValeur_depuisFichierTxt(std::wstring const& nomFichier, std::wstring separeteur)
{
    std::string contenuFichier{ u8"" };
    std::string ligneCourante{ u8"" };
    std::vector<std::pair<std::wstring, std::wstring>> clevaleurs;
 
    ifstream fichier{ nomFichier };
    if (!fichier)
    {
        throw std::runtime_error("Fichier impossible à ouvrir.");
    }
 
    /*while (getline(fichier, ligneCourante, u8'\n'))
    {
        contenuFichier += ligneCourante + u8'\n';
    }*/
    const size_t dataSize(static_cast<size_t>(fichier.rdbuf()->in_avail()));
    contenuFichier.reserve(dataSize);
    fichier.read(&contenuFichier[0], dataSize);
 
    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"\r\n";
 
    std::size_t pos = converti.length();
 
    if (pos == std::wstring::npos)
        return clevaleurs;
 
    std::size_t pos2 = 0;
    while (pos = converti.find(L"\r\n"))
    {
        if (converti[0] != converti.length())
        {
            pos2 = converti.find(L"...");
            if (pos2 != std::wstring::npos && converti[0] == L'.' && converti[1] == L'.' && converti[2] == L'.')
            {
                clevaleurs.push_back(std::make_pair(L"…", L""));
                return clevaleurs;
            }
            pos2 = converti.find(L"…");
            if (pos2 != std::wstring::npos && converti[0] == L'…')
            {
                clevaleurs.push_back(std::make_pair(L"…", L""));
                return clevaleurs;
            }
            pos2 = converti.find(L".");
            if (pos2 != std::wstring::npos && converti[0] == L'…')
            {
                clevaleurs.push_back(std::make_pair(L"…", L""));
                return clevaleurs;
            }
            pos2 = converti.find(separeteur);
            if (pos2 == std::wstring::npos && pos != std::wstring::npos)
            {
                clevaleurs.push_back(std::make_pair(converti.substr(0, pos - 1), L""));
            }
            else if (pos2 == 0)
            {
                clevaleurs.push_back(std::make_pair(L"", converti.substr(3, (pos - 1) - 2)));
            }
            else if (pos > pos2)
            {
                clevaleurs.push_back(std::make_pair(converti.substr(0, pos2), converti.substr(pos2 + 3, pos - (pos2 + 3))));
            }
            else
            {
                break;
            }
            converti = converti.substr(pos + 1);
        }
        else
            break;
    }
    return clevaleurs;
}
 
const std::vector<std::wstring> lire_fichierTxt(std::wstring const& nomFichier, std::vector<std::wstring> separeteurs)
{
    std::string contenuFichier{ u8"" };
    std::string ligneCourante{ u8"" };
    std::vector<std::wstring> retVal{};
 
    ifstream fichier{ nomFichier };
    if (!fichier)
    {
        throw std::runtime_error("Fichier impossible à ouvrir.");
    }
 
    /*while (getline(fichier, ligneCourante, u8'\n'))
    {
        contenuFichier += ligneCourante + u8'\n';
    }*/
    const size_t dataSize(static_cast<size_t>(fichier.rdbuf()->in_avail()));
    contenuFichier.reserve(dataSize);
    fichier.read(&contenuFichier[0], dataSize);
 
    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);
 
    bool found = false;
 
    do
    {
        found = false;
        size_t pos_found = std::string::npos;
        std::wstring sep_found = L"";
 
        for (auto&& sep : separeteurs)
        {
            std::size_t pos = converti.find(sep);
            if (pos != std::wstring::npos && (!found || pos_found > pos))
            {
                pos_found = pos;
                found = true;
                sep_found = sep;
            }
        }
 
        if (found)
        {
            retVal.push_back(converti.substr(0, pos_found));
            converti = converti.substr(pos_found + sep_found.length());
        }
    } while (found);
 
    if (converti.length() > 0)
    {
        rtrim(converti);
        retVal.push_back(converti);
    }
    return retVal;
}
 
const std::vector<std::wstring> lire_fichierTxt(std::wstring const& nomFichier, std::vector<std::wstring> separeteurs, bool f)
{
    std::string contenuFichier{ u8"" };
    std::string ligneCourante{ u8"" };
    std::vector<std::wstring> retVal{};
 
    ifstream fichier{ nomFichier };
    if (!fichier)
    {
        throw std::runtime_error("Fichier impossible à ouvrir.");
    }
 
    /*while (getline(fichier, ligneCourante, u8'\n'))
    {
        contenuFichier += ligneCourante + u8'\n';
    }*/
    const size_t dataSize(static_cast<size_t>(fichier.rdbuf()->in_avail()));
    contenuFichier.reserve(dataSize);
    fichier.read(&contenuFichier[0], dataSize);
    if (contenuFichier == u8"")
    {
        //throw std::runtime_error("Le fichier '" + wstr_to_u8(nomFichier) + "' est vide.");
        return {L""};
    }
 
    wstring_convert<codecvt_utf8<wchar_t>, wchar_t> convertiseur;
    std::wstring converti = convertiseur.from_bytes(contenuFichier);
    rtrim(converti);
 
    bool found = false;
 
    do
    {
        found = false;
        size_t pos_found = std::string::npos;
        std::wstring sep_found = L"";
 
        for (auto&& sep : separeteurs)
        {
            std::size_t pos = converti.find(sep);
            if (pos != std::wstring::npos && (!found || pos_found > pos))
            {
                pos_found = pos;
                found = true;
                sep_found = sep;
            }
        }
 
        if (found)
        {
            retVal.push_back(converti.substr(0, pos_found));
            converti = converti.substr(pos_found + sep_found.length());
        }
    } while (found);
 
    if (converti.length() > 0)
        retVal.push_back(converti);
    return retVal;
}
 
const std::wstring lire_fichierTxt(std::wstring const& nomFichier)
{
    std::string contenuFichier{ u8"" };
    std::string ligneCourante{ u8"" };
 
    ifstream fichier{nomFichier};
    if (!fichier)
    {
        throw std::runtime_error("Fichier impossible à ouvrir.");
    }
 
    /*while (getline(fichier, ligneCourante, u8'\n'))
    {
        contenuFichier += ligneCourante + u8"\r\n";
    }*/
    const size_t dataSize(static_cast<size_t>(fichier.rdbuf()->in_avail()));
    contenuFichier.reserve(dataSize);
    fichier.read(&contenuFichier[0], dataSize);
 
    if (contenuFichier == u8"")
    {
        //return L"";
        throw std::runtime_error("Le fichier '" + wstr_to_u8(nomFichier) + "' est vide.");
    }
 
 
    std::wstring_convert<codecvt_utf8<wchar_t>, wchar_t> convertiseur;
    std::wstring converti = convertiseur.from_bytes(contenuFichier);
    rtrim(converti);
    return converti;
}

???



Question/Réponse ?
Merci

[bacelar]

Rien compris !!!

Pouvez-vous être plus précis, SVP ?

Je vous accorde qu'on commence à aborder des choses relativement complexes, mais pouvez-vous poser des questions plus ciblées, pour éviter de partir dans tous les sens, comme actuellement ?

Avant ou après ?

Ni l'un ni l'autre, mais à la place.

Qu'est-ce qui vous manque pour essayer vous-même les solutions proposées ?
Si vous ne savez toujours pas utiliser le mode pas à pas du débugueur, il faudrait commencer par ça.

Le code proposé vient d'une simple recherche Google, qu'il faut comprendre et tester, en parallèle d'autres solutions plus simples ou mieux adaptées.
Comme vos fonctions font trop de choses à la fois, c'est difficile d'avoir une solution "bien" adaptée.
Donc, pensez à rendre vos fonctions plus simples, ça simplifierait aussi la recherche de "bonnes" solutions.
Tout ça pour vous dire, qu'après avoir testé ces 3 lignes avec génération Debug sous Visual Studio 2002 et exécution sous Windows11, ça ne fonctionne pas, vraisemblablement lié à une optimisation au niveau des entrées/sorties du programme.

Te toutes façons, ce code ne me plaisait pas trop car cela utilise des pointeurs, adresses et tableau à la C, donc pas top au niveau maintenabilité.
Donc à la place de chercher à rendre ce code opérationnel, j'ai fait des recherches Google de plus "haut niveau" (utilisation "std::filesystem" plutôt que sur les "streams").
Et je suis tombé sur un code bien plus simple et qui fonctionne bien mieux que ces 3 lignes.
https://stackoverflow.com/questions/...stdstring-in-c
et en particulier, la seconde réponse car, bien que moins performante, plus simple à lire et écrire.
https://coliru.stacked-crooked.com/a/ab16e6dd34c38b92

Il faudrait donc remplacer toute la boucle

Code :

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

1
2
3
4
while (getline(fichier, ligneCourante, u8'\n'))
{
    contenuFichier += ligneCourante + u8'\n';
}

Par une simple ligne :

Code :

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

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

Ce code fonctionne dans le même cadre de tests (génération Debug sous Visual Studio 2002 et exécution sous Windows11).
Attention, exactement comme la boucle "while", les caractères '\r' sont escamotés du résultat, vraisemblablement lié au mode d'ouverture du stream et simplifier la mise au point de code portable.
J'étais un spécialistes Windows, utilisant des API de plus bas niveau que la STL (qui n'existait pas ou qui ne couvrait pas encore les systèmes de fichiers), donc, la portabilité du code était, comment dire, accessoire.
Ces problèmes de portabilité me rappellent que le problème initial de mes premières intervention étaient liés à l'encodage des accents.
Aucune des 2 solutions (boucle "while" ou constructeur de std::string) ne solutionne le problème.
Donc, avant de faire une usine à gaz qui ne sert à rien, il est peut-être préférable de mettre ces choses à plat.
Donc, l'escamotage des '\r' est peut-être une bonne chose, mais l'utilisateur de la fonction doit en être conscient et alerté en cas de mésusage.
Donc, contrairement à ce que je pensais, il serait peut-être préférable de garder cet escamotage.
Par exemple, pour éviter que l'utilisateur de la fonction soit "piégé", on peut mettre en place une exception s'il mentionne un '\r' dans les séparateurs.
On peut aussi faire en sorte, de manière "transparente" pour l'utilisateur, que les '\r' ne soit pas pris en compte dans les séparateurs, "\r\n" et "\n" serait traités de la même manière.

La fonction "lire_fichierTxt" que vous avez postée est celle qui ne prend pas de paramètre, et donc qui ne pose pas de problèmes avec la disparition des '\r'.
Vous avez 3 versions de la fonction "lire_fichierTxt", et c'est 2 de trop, à mon avis.
Je vous conseillerai plutôt de n'avoir qu'une version de "lire_fichierTxt" qui ne prendrait pas de paramètre et renverrait une std::string (pas un std::vector<std::wstring>).
Et de mettre le système de découpage en ligne et de convertion en std::wstring dans une ou plusieurs autres fonctions.
C'est plus simple à mettre au point et à maintenir dans le temps.

[Laurent_B_]

Code :

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

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

Ok ! ça fonctionne !

Donc :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
        if (std::regex_match(nomFichier, std::wregex{L"([[:digit:]]{1,2})x(.)+"}))
        {
            InfosVisionnage info_vis{*this, m_cheminFichier};
            bool none();
            if (m_liste_episodes.find(info_vis.m_NumeroEpisode) != m_liste_episodes.end())
            {
                m_liste_episodes[info_vis.m_NumeroEpisode]->ajouter_SequenceVisionnage(info_vis);
            }
            else
            {
                m_liste_episodes.emplace(std::pair<const int, shared_ptr<Episode>>{ info_vis.m_NumeroEpisode, make_shared<Episode>(info_vis) });
            }
            return;
        }

===> InfosVisionnage info_vis{*this, m_cheminFichier} : ça fonctionne pas ! Pourquoi ?

Mais, pas-à-pas !!!

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
<Scan des fichiers d'un Saison>
    Si fichier de la forme "numéroSaisonxNuméroEpisode.{listeDeDates}.txt" 
        alors
            Créer un "InfosVisionnage" à partir du fichier // ???
            Si l'Episode le numéro d'épisode indiqué dans l'InfosVisionnage existe déjà dans la saison
                alors
                    Mettre à jour l'Episode avec la "SequenceVisionnage" contenu dans l'InfosVisionnage (voir aussi vérifier que les informations sur l'épisode dans l'InfosVisionnage soit les mêmes que dans l'épisode trouvé dans la Saison)
                Sinon
                    Créer un nouvel Episode en lui passant l'InfosVisionnage pour que l'épisode initialise ces champs, y compris son "m_liste_visionnages"
        Sinon
            ....
<Fin Scan des fichiers d'un Saison>

Pas de solution ?

Merci beaucoup

[Laurent_B_]

Bonjour,

Ici :

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
void Serie::initialiser_Titre(fs::path const& m_cheminFichier, std::vector<std::wstring>& m_titre)
{ // Titre
    auto nomFichier = m_cheminFichier.wstring();
    assert(nomFichier.length() > 0 && L"Nom de fichier vide");
    std::vector<std::wstring> titre = lire_fichierTxt(m_cheminFichier.wstring(), { L"\r\n" });
    assert((titre.size() != 0));

    std::wregex titre_pattern{ L"(.+?)(\\s:\\s|:\\s|/|\\s-\\s)(.+)" };
    std::wsmatch match;
    if (std::regex_match(titre[0], match, titre_pattern))
    {
        m_titre.push_back(match[1]);
        if (match.length() > 2)
        {
            m_titre.push_back(match[2]);
        }
        if (match.length() > 3)
        {
            m_titre.push_back(match[3]);
        }
    }
    else
    {
        m_titre.push_back(titre[0]);
    }

    initialiser_Duree(titre[1]);
    for (auto j = 2; j < titre[1].size(); j++)
        m_phrases += titre[j];
}

Pas de solution ?

Code :

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

        throw std::invalid_argument("'" + std::string{ m.begin(),m.end() } + "' n'est pas un format de durée valide.");

et :


Merci