IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

Problème et AVC : _wfopen_s


Sujet :

C++

  1. #1021
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785
    Par défaut
    Bonjour,

    https://github.com/laurentbouleau/Exemple : Décembre 05 (10/12/2024)

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    Episode::Episode(const InfosVisionnage& info_vis) :m_saison{ info_vis.m_saison }, m_numero{ info_vis.m_NumeroEpisode }
    {
        m_saison.m_numero = info_vis.m_NumeroSaison;
    
        ajouter_SequenceVisionnage(info_vis);
    }

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    void Saison::Print_Header()
    {
        std::wstring saison_str = m_keyColor[0];
        if(!m_hors_saison)
            saison_str += L"Saison " + m_keyColor[1] + std::to_wstring(m_numero) + m_keyColor[0] + L" :" + m_valuesColor;
        else
            saison_str += L"Hors saison : " + m_valuesColor;
        saison_str += L"\r\n";
    ...
    et : serie.h
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    struct Saison
    {
    public:
        const Serie& m_serie;
        Saison(std::filesystem::path const& cheminFichier, const Serie& serie);
    ...
        std::map<int, std::shared_ptr<Episode>> m_liste_episodes;
    
        //int m_numero{ -1 };
        mutable int m_numero{-1};
    ...
    };
    Comment faire ?

    Merci

  2. #1022
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785
    Par défaut
    Bonsoir,

    https://github.com/laurentbouleau/Exemple : Décembre 06 (10/12/2024)
    Avec :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    ...
    void SequenceVisionnage::Print(std::vector<std::wstring>&titres, int numero_sequence) const
    ...
    void Episode::Print()
    ...
    numero_sequence et m_titres ou titre !!!

    Merci

  3. #1023
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785
    Par défaut
    https://github.com/laurentbouleau/Exemple : Décembre 07 (11/12/2024)

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    void Saison::Print_Header()
    {
    ...
        std::wstring numero_str = m_keyColor[1] + L" (" + m_valuesColor + std::to_wstring(m_numero) + m_keyColor[1] + L')' + m_valuesColor;
     
        std::wcout << saison_str << date_str << dossier_str << m_keyColor[1] + L" : " + m_valuesColor << titre_str << resume_str << numero_str << L"\r\n";
    }
    Ok ou pas ?

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    InfosVisionnage::InfosVisionnage(const Saison& saison, fs::path const& m_cheminFichier) : m_saison{ saison }
    {
    ...
        m_NumeroSaison = std::stoi(stem);
    ...
    }
    Ou y est ?
    Exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    void SequenceVisionnage::Print(std::vector<std::wstring>&titres, int numero_sequence) const
    {
        std::wstring wstr;
        std::wstring chiffre_str{};
        std::wstring duree_str;
        long chiffre = Print_Titre_chiffre(numero_sequence);
    
        if(numero_sequence >= 1)
            chiffre_str = std::to_wstring(m_episode.m_saison.m_numero) + m_keyColor[1] + L'x' + m_valuesColor + std::to_wstring(m_episode.m_numero) + m_keyColor[1] + L" : " + m_valuesColor;
    ...
    }
    Ben non !

    Je suis fatigué !!!

    Merci

  4. #1024
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 458
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 458
    Par défaut
    Je ne comprends pas vos "questions", vous ne suivez pas mes "recommandations" et vous ne dites pas pourquoi.
    Dans ces conditions, on va pas aller très loin.

    Pouvez-vous expliciter vos questions ?
    Pouvez-vous expliciter ce que vous ne comprenez pas ?

    Moi, pour l'instant, avec le pauvre jeu de test que vous choisissez via cette ligne dans Exemple.cpp :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    if (racine == racines[1])
    Je vous ai déjà indiquer qu'il fallait mieux "passer" toutes les "racines", quitte à modifier l'ordre des racines.
    Je vous ai donné le code qui les énumères toutes mais vous avez ajouté cette ligne de code pour brider tout ça. Pourquoi ???


    Je ne vois qu'une anomalies (j'en ai vu d'autres, mais votre "rustine" les cache.), c'est le numéro de la saison.
    Et comme je l'ai déjà indiqué, le code suivant, dans la fonction "Saison::initialiser_Fichier", écrase le numéro de saison avec une valeur dont je ne comprend pas la logique :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
            if (int j = std::stoi(nomFichier))
            {
                m_numero = j;
                initialiser_Resume(cheminFichier);
                return;
            }
    Quel est l'intérêt de la ligne de code en rouge ? ( à part "casser" le code avec un bon gros bug ? )

  5. #1025
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 458
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 458
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    void Saison::Print_Header()
    {
    ...
        std::wstring numero_str = m_keyColor[1] + L" (" + m_valuesColor + std::to_wstring(m_numero) + m_keyColor[1] + L')' + m_valuesColor;
     
        std::wcout << saison_str << date_str << dossier_str << m_keyColor[1] + L" : " + m_valuesColor << titre_str << resume_str << numero_str << L"\r\n";
    }
    Ok ou pas ?
    PAS Ok !!!
    Pourquoi afficher le numéro de la saison APRES le résumé de la saison ????

    Le code actuel fait le taf, et gère même les "hors-saisons" :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    void Saison::Print_Header()
    {
        std::wstring saison_str = m_keyColor[0];
        if(!m_hors_saison)
            saison_str += L"Saison " + m_keyColor[1] + std::to_wstring(m_numero) + m_keyColor[0] + L" :" + m_valuesColor;
        else
            saison_str += L"Hors saison : " + m_valuesColor;
        saison_str += L"\r\n";
    ...
    }
    Pourquoi tout casser pour faire un affichage "tout pourri" ???

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    InfosVisionnage::InfosVisionnage(const Saison& saison, fs::path const& m_cheminFichier) : m_saison{ saison }
    {
    ...
        m_NumeroSaison = std::stoi(stem);
    ...
    }
    Ou y est ?
    Bof, ça fait le taf tant que le format du fichier commence par des nombres.
    Mais ça fonctionne correctement pour l'instant.

    Le code suivant est bien plus robuste au changement de spécification/format :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
        //Exemple assez complexe de nom de fichier
        //str = L"1x01.2024-02-01_2024-02-02_02-03_0405 Netflix";
        std::regex_match(str, match, filename_format_rg);
    
        if(match[filename_numero_saison_index].matched)
            m_NumeroSaison = std::stoi(match[filename_numero_saison_index]);
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    void SequenceVisionnage::Print(std::vector<std::wstring>&titres, int numero_sequence) const
    {
        std::wstring wstr;
        std::wstring chiffre_str{};
        std::wstring duree_str;
        long chiffre = Print_Titre_chiffre(numero_sequence);
     
        if(numero_sequence >= 1)
            chiffre_str = std::to_wstring(m_episode.m_saison.m_numero) + m_keyColor[1] + L'x' + m_valuesColor + std::to_wstring(m_episode.m_numero) + m_keyColor[1] + L" : " + m_valuesColor;
    ...
    }
    Ben non !
    Pas bon parce que la ligne "m_numero = j;" signalé dans mon précédent post, fout le bordel.
    Le problème n'est pas dans cette partie du code mais dans l'autre => utilisez le débugueur.

    EDIT :
    Pourquoi il y a encore tous ces "if(numero_sequence >= 1)" qui servent à rien ???

  6. #1026
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785
    Par défaut
    bacelar : #1024

    https://github.com/laurentbouleau/Exemple : Décembre 07 (12/12/2024)

  7. #1027
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 458
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 458
    Par défaut
    Maintenant, même plus de questions ???

    Je suppose que c'est l'affichage du numéro de saison lors de l'affichage d'une séquence de session de visionnage, non ?

    Saison 1 :
    05/07/2019 : Lorsqu'ils se réveillent dans un monde où l'humanité a été pétrifiée, le génie de la science Senku et son ami tout en muscles Taiju allient leurs talents pour recréer la civilisation. (1)
    -572662307x1 : Stone World (24min) : 31/05/2024
    Alors qu'une catastrophe a pétrifié l'humanité, Taiju maintient son esprit en vie grâce à l'amour. Il se réveille des années plus tard et découvre qu'il n'est pas seul.
    Vous remarquez que ce numéro de saison est correct quand vous le cherchez depuis l'objet Episode mais qu'il est "faux" quand vous le cherchez depuis une "SequenceVisionnage".

    Une "SequenceVisionnage" a un champ "m_episode" qui référence l'objet Episode correspondant à l'épisode vu durant la séquence de visionnage.

    Quand vous les construisez, toutes ces références sont correctes.

    Le problème survient quand un nouvel épisode est ajouté à la liste des épisodes d'une saison : le champ "Saison::m_liste_episodes" ou quand on ajoute une Saison à la liste des saisons d'une série : "Serie::saisons".
    Il s'agit de conteneurs implémentées par la STL (std:xx) qui gèrent automatiquement l'insertion et la suppression des éléments qui y sont stockés par la croissance ou la réduction de la mémoire occupée.
    Quand un élément est ajouté mais qu'il n'y a plus de place en mémoire dans le conteneur, le conteneur va allouer un nouveau bloc plus grand et va transférer (via "clonage") les objets de l'ancien bloc de mémoire vers le nouveau, puis y ajouter le nouvel élément.

    Le problème ici, c'est que le clonage, par défaut, fait une copie "mémoire" de l'objet. Donc quand l'objet "Episode" se déplace, les "SequenceVisionnage" qu"il contient ont leur membre "SequenceVisionnage::m_episode" qui pointe sur l'ancienne position de l'épisode.
    Il faut donc corriger le "clonage" en définissant ce qu'on appelle le constructeur de déplacement de la classe.
    Par exemple, le constructeur de déplacement d'un épisode se déclare ainsi :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Episode(Episode&& src);
    Essayer d'implémenter ce "constructeur de déplacement".
    (Il faudra aussi le constructeur de déplacement pour les saisons.)

  8. #1028
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785
    Par défaut
    Bonsoir,

    Je suis crevé !

    Mais :
    https://github.com/laurentbouleau/Exemple : Décembre 08 (13/12/2024)

    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
    struct Episode
    {
        const Saison& m_saison;
        Episode(const InfosVisionnage& info_vis);
        Episode(Episode&& src) : this(std::move(src.this)) // the expression "arg.member" is lvalue
        {
        };
        // Simple move assignment operator
        Episode& operator=(Episode&& src)
        {
            this = std::move(src.this);
            return *this;
        };
    ...
    };
    Et :
    Nom : Capture d’écran 2024-12-13 225430.png
Affichages : 83
Taille : 60,6 Ko
    Ben, non !!! Comment faire ?
    Merci

  9. #1029
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785
    Par défaut
    Bonjour,

    https://github.com/laurentbouleau/Exemple : Décembre 09 (14/12/2024)

    Nom : Capture d’écran 2024-12-14 122335.png
Affichages : 89
Taille : 40,4 Ko
    Pas compris !!!

    https://www.developpez.net/forums/d1...-constructeur/ ???

    Merci d'avance

  10. #1030
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785

  11. #1031
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 458
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 458
    Par défaut
    Normalement, vous devriez être capable de corriger les erreurs de compilation que vous signalez.
    L'utilisation de champ de type référence rend la définition des constructeurs "plus contraints".

    Les références que vous donnez qui datent d'avant le C++11 (en l'an de grâce 2011) sont forcément erronées. (On ne code plus "ainsi").

    Référence plus à jour mais vous devez regarder l'ensemble de la ressource et pas uniquement la page que vous avez postée.

    On va faire simple, je vous donne une proposition de "solution" qui ne modifie que "serie.h".
    Essayez de comprendre le problème et la démarche suivie pour le résoudre, SVP.

    Désolé pour la mise en forme, c'est le résultat brut, il y a donc beaucoup de code qui n'a pas changé, utilisez un comparateur de fichier pour le avant-après :
    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
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    425
    426
    427
    428
    429
    430
    431
    432
    433
    434
    435
    436
    437
    438
    439
    440
    441
    442
    443
    444
    445
    446
    447
    448
    449
    450
    451
    452
    453
    #pragma once
    #define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
    #define _CRT_SECURE_NO_WARNINGS
     
    // C :
    #include <io.h>
    #include <fcntl.h>
    #include <stdio.h>
    // C++
    #include <windows.h>
    #include <cassert>
    //#include <cstddef>
    #include <iostream>
    #include <fstream>
    #include <string>
    #include <vector>
    #include <map>
    //#include <stdio.h>
    #include <locale>
    #include <algorithm>
    #include <codecvt>
    #include <sstream>
    //#include <tuple>
    #include <regex>
    #include <numeric>
    #include <string_view>
    #include <optional>
     
    #include <filesystem> // C++17 standard header file name
     
    extern const std::vector<std::wstring> Genre;
    extern const std::vector<std::wstring> Sur;
    extern const std::vector<std::wstring> Sous_Genre;
    extern const std::vector<std::wstring> Nationalite;
     
    struct DateRecord;
    struct InfosVisionnage;
    struct SequenceVisionnage;
    struct Episode;
    struct Saison;
    class Serie;
     
    struct InfosVisionnage
    {
        const Saison& m_saison;
     
        InfosVisionnage(const Saison& saison, std::filesystem::path const& m_cheminFichier);
     
        std::filesystem::path m_cheminFichier;
     
        void Une_Fonction_De_La_Classe_InfosVisionnage(...);
     
        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
     
        //unsigned short int m_NumeroSaison{};
        //unsigned short int m_NumeroEpisode{};
        long m_NumeroSaison{};
        long m_NumeroEpisode{};
        std::vector<DateRecord> m_DatesVisionnage{ 0 };
        std::wstring m_streaming{ L"" };
        std::vector<std::wstring> m_titres;
    //    unsigned short int m_numero{ 1 };
     
        int m_numero{ -1 };
        //long m_duree{ -1 };
        //long m_duree{ 0 };
        long m_duree_en_seconde{ 0 };
        std::vector<std::wstring> m_resume;
     
    private:
        void initialiser_Duree(std::wstring& m);
    };
     
    struct SequenceVisionnage
    {
        SequenceVisionnage(const Episode& episode, const InfosVisionnage& info_vis) :
            m_episode{ episode }, m_titres{ info_vis.m_titres }, m_streaming{ info_vis.m_streaming },
            m_duree_en_seconde{ info_vis.m_duree_en_seconde }, m_resume{ info_vis.m_resume },
            m_DatesVisionnage{ info_vis.m_DatesVisionnage }
        {};
     
        SequenceVisionnage(const Episode& episode, const SequenceVisionnage& src) :
            m_episode{ episode }, m_titres{ src.m_titres }, m_streaming{ src.m_streaming },
            m_duree_en_seconde{ src.m_duree_en_seconde }, m_resume{ src.m_resume },
            m_DatesVisionnage{ src.m_DatesVisionnage }
        {};
     
        boolean operator==(const SequenceVisionnage& rhs) const { return this == &rhs; };
     
        std::wstring calcul_Duree_affichage(int numero_sequence) const;
     
        // uneFonctionQuiAfficheLaSequenceDeVisionnage
        //std::wstring uneFonctionQuiAfficheLaSequenceDeVisionnage(bool) const;
        //void uneFonctionQuiAfficheLaSequenceDeVisionnage(bool) const;
     
        void Une_Fonction_De_La_Classe_SequenceVisionnage(...);
     
        const void AffichagePersonnaliser(AffichagePersonnalisation perso);
     
        //void Print(int numero_sequence) const;
        void Print(std::vector<std::wstring>&titres, int numero_sequence) const;
        std::wstring Print_Dates_de_visionnage() const;
        long Print_Titre_chiffre(long episode) const;
     
        std::wstring m_espace1;
        std::wstring m_labelHeureSingulier;
        std::wstring m_labelHeurePluriel;
        std::wstring m_espace2;
        std::wstring m_espace3;
        std::wstring m_labelMinuteSingulier;
        std::wstring m_labelMinutePluriel;
        std::vector<std::wstring>m_keyColor;
        std::wstring m_valuesColor;
     
        //long m_NumeroSaison{1};
        //long m_NumeroEpisode{1};
     
        std::wstring m_streaming{ L"" };
        std::vector<std::wstring> m_titres;
        long m_duree_en_seconde{ -1 };
        std::vector<std::wstring> m_resume{};
        std::vector<DateRecord> m_DatesVisionnage{};
     
        int m_numero{ -1 };
        long m_duree { -1 };
     
        bool affichage_duree_actif = true;// false;
     
    private:
        const Episode& m_episode;
    };
     
    struct Episode
    {
        const Saison& m_saison;
        Episode(const InfosVisionnage& info_vis);
        Episode(const Episode& src) :m_saison{ src.m_saison }
        {
            operator=(src);
        }
        Episode(Episode&& src) noexcept :m_saison { src.m_saison }// the expression "arg.member" is lvalue
        {
            operator=(std::move(src));
        }
        Episode(const Saison& saison, Episode&& src) :m_saison{ saison }{
            operator=(std::move(src));
        };
        // Simple move assignment operator
    private:
        Episode& operator=(Episode&& src) noexcept
        {
            operator=(src);
            return *this;
        }
        Episode& operator=(const Episode& src)
        {
            if (&src != this)
            {
                for (auto const& seq : src.m_liste_sequence_visionnages_ordonnee_chronologiquement)
                {
                    m_liste_sequence_visionnages_ordonnee_chronologiquement.emplace_back(SequenceVisionnage{*this, seq });
                }
     
                m_espace1 = src.m_espace1;
                m_labelHeureSingulier = src.m_labelHeureSingulier;
                m_labelHeurePluriel = src.m_labelHeurePluriel;
                m_espace2 = src.m_espace2;
                m_espace3 = src.m_espace3;
                m_labelMinuteSingulier = src.m_labelMinuteSingulier;
                m_labelMinutePluriel = src.m_labelMinutePluriel;
                m_keyColor = src.m_keyColor;
                m_valuesColor = src.m_valuesColor;
     
                m_episode = src.m_episode;
     
                m_numero = src.m_numero;
                m_duree = src.m_duree;
                m_resume = src.m_resume;
     
                lInfoQuiMInteresse = src.lInfoQuiMInteresse;
            }
     
            return *this;
        }
    public:
        void ajouter_SequenceVisionnage(const InfosVisionnage& info_vis);
     
        const void AffichagePersonnaliser(AffichagePersonnalisation perso);
     
        long long GetNumeroSequenceVisionnage(const SequenceVisionnage& sev_vis) const;
     
        void Une_Fonction_De_La_Classe_SequenceVisionnage_xxx(...);
     
        void Print();
     
        std::wstring m_espace1;
        std::wstring m_labelHeureSingulier;
        std::wstring m_labelHeurePluriel;
        std::wstring m_espace2;
        std::wstring m_espace3;
        std::wstring m_labelMinuteSingulier;
        std::wstring m_labelMinutePluriel;
        std::vector<std::wstring>m_keyColor;
        std::wstring m_valuesColor;
     
        long m_episode{};
        std::vector<SequenceVisionnage> m_liste_sequence_visionnages_ordonnee_chronologiquement{};
     
        int m_numero{ -1 };
        long m_duree{ -1 };
        std::vector<std::wstring> m_resume;
     
        int lInfoQuiMInteresse;
     
        //long m_NumeroEpisode{1};
    };
     
    struct Saison
    {
    public:
        const Serie& m_serie;
        Saison(std::filesystem::path const& cheminFichier, const Serie& serie);
        Saison(Saison&& src) noexcept : m_serie{ std::move(src.m_serie) }// the expression "arg.member" is lvalue
        {
            operator=(std::move(src));
        }
        // Simple move assignment operator
    private:
        Saison& operator=(Saison&& src) noexcept
        {
            if (&src != this)
            {
                for (auto const& [key, ep] : src.m_liste_episodes)
                {
                    Episode tmp(*this, std::move(*ep));
                    m_liste_episodes.emplace( key, std::make_shared<Episode>(tmp) );
                }
     
                m_min = std::move(src.m_min);
                m_espace1 = std::move(src.m_espace1);
                m_labelHeureSingulier = std::move(src.m_labelHeureSingulier);
                m_labelHeurePluriel = std::move(src.m_labelHeurePluriel);
                m_espace2 = std::move(src.m_espace2);
                m_espace3 = std::move(src.m_espace3);
                m_labelMinuteSingulier = std::move(src.m_labelMinuteSingulier);
                m_labelMinutePluriel = std::move(src.m_labelMinutePluriel);
                m_keyColor = std::move(src.m_keyColor);
                m_valuesColor = std::move(src.m_valuesColor);
     
                m_audiodescription = std::move(src.m_audiodescription);
                m_avec = std::move(src.m_avec);
                m_date_diffusee_a_partir_de = std::move(src.m_date_diffusee_a_partir_de);
                m_disney = std::move(src.m_disney);
                m_f_anneesDiffusion = std::move(src.m_f_anneesDiffusion);
                m_chaine = std::move(src.m_chaine);
                m_hors_saison = std::move(src.m_hors_saison);
     
                m_image = std::move(src.m_image);
                m_netflix = std::move(src.m_netflix);
                m_note = std::move(src.m_note);
     
                m_titres = std::move(src.m_titres);
                m_resume = std::move(src.m_resume);
     
                m_numero = std::move(src.m_numero);
                lInfoQuiMInteresse = std::move(src.lInfoQuiMInteresse);
     
                affichage_audiodescription_actif = std::move(src.affichage_audiodescription_actif);
                affichage_avec_actif = std::move(src.affichage_avec_actif);
                affichage_chaine_actif = std::move(src.affichage_chaine_actif);
                affichage_date_etc_actif = std::move(src.affichage_date_etc_actif);
                affichage_image_actif = std::move(src.affichage_image_actif);
                affichage_netflix_actif = std::move(src.affichage_netflix_actif);
                affichage_note_actif = std::move(src.affichage_note_actif);
            }
            return *this;
        }
    public:
        //void ajouter_InfosVisionnage(SequenceVisionnage const& seq_vis);
     
        void initialiser_Fichier(std::filesystem::path const& cheminFichier);
     
        void initialiser_Chaine(std::filesystem::path const& cheminFichier);
        void initialiser_Hors_Saison(std::filesystem::path const& cheminFichier);
        void initialiser_Netflix(std::filesystem::path const& cheminFichier);
        void initialiser_Note(std::filesystem::path const& cheminFichier);
        void initialiser_Resume(std::filesystem::path const& cheminFichier);
        void initialiser_Titre(std::filesystem::path const& cheminFichier);
     
        const void AffichagePersonnaliser(AffichagePersonnalisation perso);
     
        void Print();
        void Print_Avec();
        void Print_Chaine();
        const void Print_Date_etc();
        void Print_Header();
        void Print_Images();
        void Print_Netflix();
        void Print_Note();
     
        std::wstring m_min = L"min";
        std::wstring m_espace1;
        std::wstring m_labelHeureSingulier;
        std::wstring m_labelHeurePluriel;
        std::wstring m_espace2;
        std::wstring m_espace3;
        std::wstring m_labelMinuteSingulier;
        std::wstring m_labelMinutePluriel;
        std::vector<std::wstring>m_keyColor;
        std::wstring m_valuesColor;
     
        std::wstring m_audiodescription;
        std::vector<std::pair<std::wstring, std::wstring>> m_avec;
        std::pair<std::tm, std::wstring>m_date_diffusee_a_partir_de;
        bool m_disney{ false };
        int m_f_anneesDiffusion{ 0 };
        //std::pair<std::tm, std::wstring>m_dossier;
        //std::vector<Episode> episodes;
        //std::vector<InfosVisionnage>infosvisionnages;
        std::wstring m_chaine;
        bool m_hors_saison{ false };
        //long m_hors_saison_duree{ -1 };
        //std::vector<std::wstring> m_hors_saison_resume;
     
        std::vector<std::wstring> m_image;
        bool m_netflix{ false };
        double m_note{ -1.0 };
     
        //std::pair<unsigned short int, std::vector<std::wstring>>saison;
        std::vector<std::wstring> m_titres;
        std::vector<std::wstring> m_resume;
     
        std::map<int, std::shared_ptr<Episode>> m_liste_episodes;
        mutable int m_numero{ -1 };
        int lInfoQuiMInteresse{};
     
        bool affichage_audiodescription_actif = true;
        bool affichage_avec_actif = true;
        bool affichage_chaine_actif = true;
        bool affichage_date_etc_actif = true;
        bool affichage_image_actif = true;
        bool affichage_netflix_actif = true;
        bool affichage_note_actif = true;
    };
     
    class Serie
    {
    public:
        Serie(std::filesystem::path racine);
     
        void initialiser_Fichier(std::filesystem::path const& cheminFichier);
        void initialiser_Chaine(std::filesystem::path const& cheminFichier);
        void initialiser_Creee_par(std::filesystem::path const& cheminFichier);
        void initialiser_En_relation_avec(std::filesystem::path const& cheminFichier);
        void initialiser_Titre(std::filesystem::path const& cheminFichier);
     
        const void AffichagePersonnaliser(AffichagePersonnalisation perso);
     
        const void Print();
     
        std::vector<Saison>saisons{};
        std::filesystem::path getRacine() { return racine; };
        std::filesystem::path getFileName() { return racine.filename(); };
     
        std::vector<std::wstring> m_resume;
     
        int lInfoQuiMInteresse{};
     
    private:
        std::pair<int, int> calculer_Annees_Diffusion() const;
        std::wstring calcul_Duree_affichage() const;
        std::wstring calcul_Note_Affichage() const;
        std::wstring calcul_Signaletique_Jeunesse_affichage() const;
        std::wstring calcul_Sur_Affichage() const;
        std::wstring calcul_Titres_Affichage() const;
        std::wstring calcul_X_Signaletique_Jeunesse_affichage(std::wstring& sur_str) const;
        const void corriger_Annee_Debut();// const;
        const void corriger_Annee_Fin();
     
        std::wstring format_Annees() const;
        std::wstring format_AnneesEtSur(std::wstring& annees_str, std::wstring& sur_str) const;
        std::pair<std::optional<int>, std::optional<int>> m_f_anneesProduction;
     
        const void Print_Saison(Saison saison);
        void Print_Saisons();
     
        void Print_Avec_etc();
        const void Print_Chaine();
        const void Print_Creee_par();
        const void Print_En_relation_avec();
        void Print_Header() const;
     
        std::filesystem::path racine;
     
        std::wstring m_espace1;
        std::wstring m_labelHeureSingulier;
        std::wstring m_labelHeurePluriel;
        std::wstring m_espace2;
        std::wstring m_espace3;
        std::wstring m_labelMinuteSingulier;
        std::wstring m_labelMinutePluriel;
        std::vector<std::wstring>m_keyColor;
        std::wstring m_valuesColor;
     
        int m_annees{};
        std::wstring m_audiodescription;
        std::vector<std::wstring> m_catalogue;
        std::wstring m_chaine;
        std::vector<std::wstring> m_creee_par;
        std::wstring m_disney_sj;
        std::wstring m_en_relation_avec;
        std::vector<std::wstring> m_genre;
        std::vector<std::wstring> m_image;
        std::vector<std::wstring> m_nationalite;
        std::wstring m_netflix_sj;
        double m_note{ 0.0 };
        std::wstring m_sj;
        std::wstring m_sous_genre;
        std::wstring m_sur;
     
        std::vector<std::wstring> m_titres;
        long m_duree{ -1 };
        std::vector<std::wstring> m_titres_originaux;
     
        bool affichage_annees_actif = true;
        bool affichage_audiodescription_actif = true;
        bool affichage_avec_actif = true;
        bool affichage_avec_etc_actif = true;
        bool affichage_chaine_actif = true;
        bool affichage_catalogue_actif = true;
        bool affichage_creee_par_actif = true;
        bool affichage_disney_sj_actif = true;
        bool affichage_duree_actif = true;// false;
        bool affichage_episode_titre_actif = true;
        bool affichage_en_relation_avec_actif = true;
        bool affichage_image_actif = true;
        bool affichage_genres_actif = true;
        bool affichage_nationalite_actif = true;
        bool affichage_netflix_sj_actif = true;
        bool affichage_note_actif = true;// false;
        bool affichage_resume_actif = true;
        //bool affichage_saison_actif = true;
        bool affichage_saison_date_etc_actif = true;
        bool affichage_saisons_actif = true;
        bool affichage_serie_actif = true;
        bool affichage_sj_actif = true;
        bool affichage_sous_genre_actif = true;
        bool affichage_sur_actif = true; // 
        bool affichage_titres_actif = true;
        bool affichage_titres_originaux_actif = true;
        bool affichage_x_sj_actif = true;
    };

  12. #1032
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785
    Par défaut
    https://github.com/laurentbouleau/Exemple : Décembre 10 (16/12/2024)

    Je suis crevé !!!

    Merci

  13. #1033
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 458
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 458
    Par défaut
    Ok, vous avez compris comment "corriger" les erreurs de compilation.
    C'est cool.
    Mais vous n'avez peut-être pas complètement compris la notion de constructeur de mouvement. (move constructor)

    Si vous ne définissez pas de "move constructor", le compilateur en crée un pour vous, comme pour le constructeur de copie.

    Dans notre cas où les objets conservent des références "arrières" vers d'autres objets, le "move constructor" par défaut fait mal le job.

    Il faut donc le redéfinir pour qu'il le fasse correctement.

    Vous devez réimplémenter tout le travail fait dans le "move constructor" par défaut en plus de corriger ce qu'il fait mal.

    Cela implique donc un travail sur TOUS les champs de la nouvelle instance.

    Le code que j'ai posté ce matin, fait ce travail de correction des références "arrières" vers les autres objets, mais aussi de synchronisation des autres champs.

    Cela montre aussi que mettre tout une ménagerie de champs qui ne servent à rien (j'ai signalé depuis des mois que l'affichage n'a rien à foutre dans ce type de classe métier), c'est généré beaucoup de boulot pour rien.

  14. #1034
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785
    Par défaut
    Cela montre aussi que mettre tout une ménagerie de champs qui ne servent à rien (j'ai signalé depuis des mois que l'affichage n'a rien à foutre dans ce type de classe métier), c'est généré beaucoup de boulot pour rien.
    utils.h/cpp ???

    Exemple : film.h et serie.h :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    struct SequenceVisionnage_film
    {
    ...
    };
     
    class Film
    {
    ...
    };
    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
    struct InfosVisionnage
    {
    ...
    };
    ...
    struct SequenceVisionnage
    {
    ...
    };
    ...
    struct Episode
    {
    ...
    };
    ...
    struct Saison
    {
    ...
    };
    ...
    class Serie
    {
    ...
    };
    utils.h ou un autre ???

    Merci

  15. #1035
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 458
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 458
    Par défaut
    Le "problème" n'est pas où sont les classes.
    Ca serait plus "propre" de mettre chaque classe dans sa propre paire de fichiers ".hpp/.cpp", mais vos classes sont tellement intriquées que les regrouper présente un avantage plutôt qu'un inconvénient, pour l'instant.
    Donc non, déplacer les classes n'arrangera rien.

    Avec tous ces champs, dans la classe Saison par exemple, on n'a un assignateur de mouvement sans fin :
    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
    Saison& operator=(Saison&& src) noexcept
        {
            if (&src != this)
            {
                for (auto const& [key, ep] : src.m_liste_episodes)
                {
                    Episode tmp(*this, std::move(*ep));
                    m_liste_episodes.emplace( key, std::make_shared<Episode>(tmp) );
                }
     
                m_min = std::move(src.m_min);
                m_espace1 = std::move(src.m_espace1);
                m_labelHeureSingulier = std::move(src.m_labelHeureSingulier);
                m_labelHeurePluriel = std::move(src.m_labelHeurePluriel);
                m_espace2 = std::move(src.m_espace2);
                m_espace3 = std::move(src.m_espace3);
                m_labelMinuteSingulier = std::move(src.m_labelMinuteSingulier);
                m_labelMinutePluriel = std::move(src.m_labelMinutePluriel);
                m_keyColor = std::move(src.m_keyColor);
                m_valuesColor = std::move(src.m_valuesColor);
     
                m_audiodescription = std::move(src.m_audiodescription);
                m_avec = std::move(src.m_avec);
                m_date_diffusee_a_partir_de = std::move(src.m_date_diffusee_a_partir_de);
                m_disney = std::move(src.m_disney);
                m_f_anneesDiffusion = std::move(src.m_f_anneesDiffusion);
                m_chaine = std::move(src.m_chaine);
                m_hors_saison = std::move(src.m_hors_saison);
     
                m_image = std::move(src.m_image);
                m_netflix = std::move(src.m_netflix);
                m_note = std::move(src.m_note);
     
                m_titres = std::move(src.m_titres);
                m_resume = std::move(src.m_resume);
     
                m_numero = std::move(src.m_numero);
                lInfoQuiMInteresse = std::move(src.lInfoQuiMInteresse);
     
                affichage_audiodescription_actif = std::move(src.affichage_audiodescription_actif);
                affichage_avec_actif = std::move(src.affichage_avec_actif);
                affichage_chaine_actif = std::move(src.affichage_chaine_actif);
                affichage_date_etc_actif = std::move(src.affichage_date_etc_actif);
                affichage_image_actif = std::move(src.affichage_image_actif);
                affichage_netflix_actif = std::move(src.affichage_netflix_actif);
                affichage_note_actif = std::move(src.affichage_note_actif);
            }
            return *this;
        }
    (J'image même pas le bordel avec la classe Serie, quand on gèrera plusieurs séries à la fois.)

    Si l'affichage n'est plus dans la classe, cela changerait l'assignateur de mouvement de Saison à :

    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
    Saison& operator=(Saison&& src) noexcept
        {
            if (&src != this)
            {
                for (auto const& [key, ep] : src.m_liste_episodes)
                {
                    Episode tmp(*this, std::move(*ep));
                    m_liste_episodes.emplace( key, std::make_shared<Episode>(tmp) );
                }
     
                m_audiodescription = std::move(src.m_audiodescription);
                m_avec = std::move(src.m_avec);
                m_date_diffusee_a_partir_de = std::move(src.m_date_diffusee_a_partir_de);
                m_disney = std::move(src.m_disney);
                m_f_anneesDiffusion = std::move(src.m_f_anneesDiffusion);
                m_chaine = std::move(src.m_chaine);
                m_hors_saison = std::move(src.m_hors_saison);
     
                m_image = std::move(src.m_image);
                m_netflix = std::move(src.m_netflix);
                m_note = std::move(src.m_note);
     
                m_titres = std::move(src.m_titres);
                m_resume = std::move(src.m_resume);
     
                m_numero = std::move(src.m_numero);
            }
            return *this;
        }
    Et il suffirait de créer une fonction "AfficherDansConsole(const Serie& serie)" (dans "utils.hpp/cpp" par exemple, pour l'instant), pour pouvoir supprimer tous ces champs liés à l'affichage dans toutes ces classes liées à Serie.
    Et une fonction "AfficherDansConsole(const Film& film)" pour toutes les classes liées à Film.

    En utilisant des Design Pattern de création un peu plus complexes, on devrait pouvoir aussi ne plus avoir à réimplémenter les "constructeurs/assignateurs" de "copie/mouvement".

  16. #1036
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785
    Par défaut
    Bonsoir,

    https://github.com/laurentbouleau/Exemple : Décembre 11 (19/12/2024)

    Ok : pas de bool affichage_

    Mais :
    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
    struct Episode
    {
        const Saison& m_saison;
        Episode(const InfosVisionnage& info_vis);
        Episode& operator=(Episode&& src) noexcept
        {
            if (&src != this)
            {
                for (auto const& [key, lsvoc] : src.m_liste_sequence_visionnages_ordonnee_chronologiquement)
                {
                    SequenceVisionnage tmp(*this, std::move(*lsvoc));
                    m_liste_sequence_visionnages_ordonnee_chronologiquement.emplace(key, std::make_shared<SequenceVisionnage>(tmp));
                }
                m_resume = std::move(src.m_resume);
                m_duree = std::move(src.m_duree);
                m_numero = std::move(src.m_numero);
            }
            return *this;
        }
    ...
    };
    ...
    struct Saison
    {
    public:
        const Serie& m_serie;
        Saison(std::filesystem::path const& cheminFichier, const Serie& serie);
        Saison& operator=(Saison&& src) noexcept
        {
            if (&src != this)
            {
                for (auto const& [key, ep] : src.m_liste_episodes)
                {
                    Episode tmp(*this, std::move(*ep));
                    m_liste_episodes.emplace(key, std::make_shared<Episode>(tmp));
                }
                m_audiodescription = std::move(src.m_audiodescription);
    ...
    Que faire ?

    Beaucoup des :
    Nom : Capture d’écran 2024-12-19 214908.png
Affichages : 58
Taille : 149,6 Ko
    J'en ai marre !!!
    Rien compris et je suis fatigué !

  17. #1037
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 458
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 458
    Par défaut
    Ok, c'est bien, vous ne copiez-collez pas bêtement le code que je poste.

    Que vous ayez du mal à comprendre, c'est tout à fait logique, ici, on est dans l'un des trucs les plus "perchés" venu avec le C++11.

    En plus, ici, les erreurs du compilateur ne sont pas très explicites.

    ATTENTION, vous avez commencé à implémenter les opérateurs d'affectation en les laissant dans la partie "public" de vos classes.
    Il ne faut absolument pas que ces opérateurs soient publics, car ils ne sont pas utilisables correctement depuis l'extérieur de la classe.
    Ici, ils servent à simplifier/factoriser l'écriture des constructeurs, pas à être utilisable par d'autres fonctions.


    Pour comprendre ce bordel, il faut que vous ayez une vue assez claire de la différence entre "Class& var" et "Class&& var".
    "Class& var" est une référence "classique" ( ou left reference, voir explication si après ).
    "Class&& var" est une référence "temporaire" ( ou right reference, voir explication si après ).
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    uneFonctionQuiRetourneUnObjetDeTypeClass();
    Class& leftReference = uneFonctionQuiRetourneUnObjetDeTypeClass();
    la fonction "uneFonctionQuiRetourneUnObjetDeTypeClass" crée donc un objet "Class" qui est "temporaire/transitoire".
    Dans la première ligne du code ci-avant, cet objet disparait "sans laisser de traces".
    Dans la deuxième ligne de code, cet objet est "fixé" par l'affectation et n'est plus "temporaire/transitoire". Tant que la variable "leftReference" existe, l'objet est pérenne (sauf utilisation de std::move ).
    Donc le "Right" ou "Left" dans le nom des types de référence vient de ce type d'affectation "Toto& v = exp1 + exp2 + ...;" ou la référence "pérenne" est à gauche et l'objet transitoire est à droite.
    Si cela reste flou, regardez un peu la littérature sur "l'ownership" d'une variable en C++.

    Donc, avec ce nouveau concept de "right reference" en C++, la règle des 3 c'est transformé en règle des 5 : https://en.wikipedia.org/wiki/Rule_o...B_programming)

    Donc, comme on est obligé de customiser les constructeurs, je vous enjoins à respecter "bêtement" cette règle. Sinon, les messages d'erreur du compilateur vont affluer.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
                for (auto const& [key, lsvoc] : src.m_liste_sequence_visionnages_ordonnee_chronologiquement)
                {
                    SequenceVisionnage tmp(*this, std::move(*lsvoc));
                    m_liste_sequence_visionnages_ordonnee_chronologiquement.emplace(key, std::make_shared<SequenceVisionnage>(tmp));
                }
    Ce code qui a été inspiré par "Saison& operator=(Saison&& src) noexcept" ne fonctionne pas parce que "m_liste_sequence_visionnages_ordonnee_chronologiquement" n'est pas une "std::map<int, std::shared_ptr<xxx>>" mais un "std::vector<xxx>".
    Pour un "std::vector<xxx>", c'est beaucoup plus simple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    for (auto const& lsvoc : src.m_liste_sequence_visionnages_ordonnee_chronologiquement)
    {
        m_liste_sequence_visionnages_ordonnee_chronologiquement.emplace_back(SequenceVisionnage{ *this, lsvoc });
    }
    Mais pour que cela fonctionne, il faut le constructeur de "SequenceVisionnage" suivant :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
        SequenceVisionnage(const Episode& episode, const SequenceVisionnage& src) :
            m_episode{ episode }, m_titres{ src.m_titres }, m_streaming{ src.m_streaming },
            m_duree_en_seconde{ src.m_duree_en_seconde }, m_resume{ src.m_resume },
            m_DatesVisionnage{ src.m_DatesVisionnage }
        {};
    C'est le constructeur qui clone un "SequenceVisionnage", mais qui "change" la valeur du champ m_episode "au passage".

    Après, vous avez des messages d'erreurs cryptiques car vous n'avez pas respecté la règle des 5.

    Donc en ajoutant un constructeur de déplacement de la classe Saison :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    Saison(Saison&& src) noexcept : m_serie{ std::move(src.m_serie) }// the expression "arg.member" is lvalue
    {
        operator=(std::move(src));
    }
    En réorganisant un peu les constructeurs et les opérateurs d'affectation pour ne pas avoir à copier-coller du code :
    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
    ...
    Episode(const InfosVisionnage& info_vis);
    Episode(const Episode& src) :m_saison{ src.m_saison }
    {
        operator=(src);
    }
    Episode(const Saison& saison, Episode&& src) :m_saison{ saison } {
        operator=(std::move(src));
    };
    Episode& operator=(const Episode& src)
    {
        if (&src != this)
        {
            for (auto const& lsvoc : src.m_liste_sequence_visionnages_ordonnee_chronologiquement)
            {
                m_liste_sequence_visionnages_ordonnee_chronologiquement.emplace_back(SequenceVisionnage{ *this, lsvoc });
            }
            m_resume = src.m_resume;
            m_duree = src.m_duree;
            m_numero = src.m_numero;
        }
        return *this;
    }
    Episode& operator=(Episode&& src) noexcept
    {
        operator=(src);
        return *this;
    }
    ...
    Vous obtiendrez un code qui compile et un exécutable qui "marchouille".

  18. #1038
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785
    Par défaut
    9h00 : Les travaux !

    https://github.com/laurentbouleau/Exemple : Décembre 12 (20/12/2024)

    ATTENTION, vous avez commencé à implémenter les opérateurs d'affectation en les laissant dans la partie "public" de vos classes.
    Il ne faut absolument pas que ces opérateurs soient publics, car ils ne sont pas utilisables correctement depuis l'extérieur de la classe.
    Ici, ils servent à simplifier/factoriser l'écriture des constructeurs, pas à être utilisable par d'autres fonctions.
    Ok !

    Mais :
    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_ordonnee_chronologiquement.push_back(SequenceVisionnage info_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
    19
    void Saison::initialiser_Fichier(fs::path const& cheminFichier)
    {
    ...
            if (std::regex_match(nomFichier, std::wregex{L"([[:digit:]]{1,2})x(.)+"}))
            {
                InfosVisionnage info_vis{ *this, cheminFichier };
                //if (m_liste_episodes.find(info_vis.m_NumeroEpisode) != m_liste_episodes.end())
                if (m_liste_episodes.begin() != m_liste_episodes.end())
                {
                    m_liste_episodes[info_vis.m_NumeroEpisode].ajouter_SequenceVisionnage(info_vis);
                }
                else
                {
                    m_liste_episodes.emplace_back(Episode{ info_vis.m_NumeroEpisode, Episode(info_vis) });
                }
                return;
            }
    ...
    }
    Nom : Capture d’écran 2024-12-20 132137.png
Affichages : 57
Taille : 83,9 Ko

    Voilà !!!

  19. #1039
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 458
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 458
    Par défaut
    Attention, vous avez mis les opérateurs d'assignation en privé, c'est bien, mais aussi des constructeurs, malheureusement.
    Les constructeurs sont eux opérationnels pour être utilisés de l'extérieur de la classe.
    Donc, pour l'instant, tous les "operator=(...)" en privé et tous les constructeurs en public.
    On pourra raffiner quels constructeurs mettre en public et quels autres mettre en privé, mais pour l'instant, tous les constructeurs en public.
    Sans ça, vous aurez des erreurs cryptiques lors de la compilation. (règle des 5)

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    for (auto const& ep : src.m_liste_episodes)
    {
        m_liste_episodes.emplace_back(Episode{ *this, ep });
    }
    Ici, même en rendant publique les constructeurs, il y aura un problème car vous n'avez pas de constructeur qui prend en paramètre un "const Saison&" et un "const Episode&" en paramètre, et c'est "normal", car vous n'en avez pas (encore) besoin.
    Vous avez un constructeur "Episode(const Saison& saison, Episode&& src)" qui fait déjà le travail :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    Episode(const Saison& saison, Episode&& src) :m_saison{ saison } {
        operator=(std::move(src));
    };
    Il faut juste faire en sorte que c'est ce constructeur qui soit appelé :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    for (auto& ep : src.m_liste_episodes)
    {
        m_liste_episodes.emplace_back(Episode{ *this, std::move(ep) });
    }
    "std::move" permet d'abandonner l'ownership de l'objet, ce qui est très bien dans un opérateur d'assignation de mouvement.
    Le paramètre "Saison&& saison" est censé disparaitre à la fin de l'opération.
    Donc que les éléments du champ "src.m_liste_episodes" deviennent temporaires/transitoires car plus personne n'a l'ownership sur ces Episodes de "Saison&& saison", ça les rend éligibles comme deuxième paramètre du constructeur "Episode(const Saison& saison, Episode&& src)".

    Vous tentez de "simplifier" les choses, c'est bien, mais il faut être conscient des impactes de ces "simplifications".
    Ici, vous avez transformé le champ "m_liste_episodes" de la classe Saison d'une "std::map<int, std::shared_ptr<Episode>>" en un "std::vector<Episode>".
    Cela pourrait vous semblez plus simple et plus logique.
    Le numéro de l'épisode est une donnée intrinsèque à l'épisode d'où le fait que la classe Episode a un champ "m_numero".
    Mais il peut être pratique dans le code de la classe "Saison" de savoir si un numéro d'épisode a déjà été utilisé, sans avoir à "scanner" l'ensemble des épisodes.
    Ici, il n'y a pas de bonne ou de mauvaise manière dans l'absolu.
    J'avais choisi une "std::map<int, std::shared_ptr<Episode>>" pour avoir un code qui resterait simple dans la classe "Saison", quitte à avoir un mécanisme de création d'un épisode un peu plus complexe.
    C'est vous qui voyez.

    Mais si vous faites ce changement, il faut corriger "correctement" le code :
    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
    void Saison::initialiser_Fichier(fs::path const& cheminFichier)
    {
    ...
            if (std::regex_match(nomFichier, std::wregex{L"([[:digit:]]{1,2})x(.)+"}))
            {
                InfosVisionnage info_vis{ *this, cheminFichier };
                //if (m_liste_episodes.find(info_vis.m_NumeroEpisode) != m_liste_episodes.end())
                if (m_liste_episodes.begin() != m_liste_episodes.end())
                {
                    m_liste_episodes[info_vis.m_NumeroEpisode].ajouter_SequenceVisionnage(info_vis);
                }
                else
                {
                    m_liste_episodes.emplace_back(Episode{ info_vis.m_NumeroEpisode, Episode(info_vis) });
                }
                return;
            }
    ...
    }
    "m_liste_episodes.begin() != m_liste_episodes.end()", c'est toujours vrai, ça n'a donc aucun sens.
    => plantage à l'exécution.

    "Episode{ info_vis.m_NumeroEpisode, Episode(info_vis) }", c'est sensé appeler quel constructeur de la classe Episode ???
    Appelez le constructeur "Episode(const InfosVisionnage& info_vis)", ça me parait plus "logique", non ?
    =>
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    m_liste_episodes.emplace_back(Episode{ info_vis });
    Avec le champ m_liste_episodes de type "std::map<int, std::shared_ptr<Episode>>", il était facile de savoir si un épisode d'un certain numéro était déjà présent : on utilisant la fonction "find" de "std::map".
    https://en.cppreference.com/w/cpp/container/map/find
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    if (m_liste_episodes.find(info_vis.m_NumeroEpisode) != m_liste_episodes.end())
    Avec le champ m_liste_episodes de type "std::vector<Episode>", vous ne pouvez plus utiliser cette fonction "find".
    Vous devez boucler sur la liste pour voir si l'un des éléments porte déjà le numéro recherché, ici le numéro contenu dans "info_vis.m_NumeroEpisode".
    Vous pouvez implémenter ce scan de "m_liste_episodes" pour trouver le possible épisode avec le numéro recherché avec une simple boucle :
    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
    <PseudoCode>
    bool found = false;
     
    for(auto& ep : m_liste_episodes)
    {
        if(ep.m_numero == info_vis.m_NumeroEpisode)
        {
            ...
        }
    }
     
    if(!found)
    {
    ...
    }</PseudoCode>
    Moi, je préfère utiliser la fonction "std::find_if" pour avoir un code moins verbeux.
    https://en.cppreference.com/w/cpp/algorithm/find
    Mais cela demande de maitriser les lambda expressions, aussi perchées les "right reference". (Mais je vous avais "donné" une std::map pour éviter ça )
    https://en.cppreference.com/w/cpp/language/lambda

    En résumé :
    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
    void Saison::initialiser_Fichier(fs::path const& cheminFichier)
    {
    ...
        if (std::regex_match(nomFichier, std::wregex{L"([[:digit:]]{1,2})x(.)+"}))
        {
            InfosVisionnage info_vis{ *this, cheminFichier };
            auto it = std::find_if(m_liste_episodes.begin(), m_liste_episodes.end(), [&info_vis](const auto& x) { return x.m_numero == info_vis.m_NumeroEpisode;});
            if (it != m_liste_episodes.end())
            {
                (*it).ajouter_SequenceVisionnage(info_vis);
            }
            else
            {
                m_liste_episodes.emplace_back(Episode{ info_vis });
            }
            return;
        }
    ...
    }
    Après, il reste à corriger 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_ordonnee_chronologiquement.push_back(SequenceVisionnage info_vis);
    }
    Ça veut rien dire, comme l'indique le compilateur.
    Dans "ajouter_SequenceVisionnage" on doit juste ajouter une SequenceVisionnage à m_liste_sequence_visionnages_ordonnee_chronologiquement.
    Vous avez supprimé le constructeur "SequenceVisionnage(const Episode& episode, const InfosVisionnage& info_vis) ", Pourquoi ???
    Il fallait ajouter le constructeur "SequenceVisionnage(const Episode& episode, const SequenceVisionnage& src)", pas remplacer l'existant.
    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_titres{ info_vis.m_titres }, m_streaming{ info_vis.m_streaming },
        m_duree_en_seconde{ info_vis.m_duree_en_seconde }, m_resume{ info_vis.m_resume },
        m_DatesVisionnage{ info_vis.m_DatesVisionnage }
    {};
    Donc en utilisant le "vieux" constructeur :
    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_ordonnee_chronologiquement.push_back(SequenceVisionnage{ *this, info_vis });
    }

  20. #1040
    Membre éclairé Avatar de Laurent_B_
    Homme Profil pro
    Ingénieur de déploiement réseaux
    Inscrit en
    Avril 2021
    Messages
    785
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Ingénieur de déploiement réseaux
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Avril 2021
    Messages : 785
    Par défaut
    Bonjour,

    Ok !

    https://github.com/laurentbouleau/Exemple : Décembre 13 (21/12/2024)

    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
    const void Saison::AffichagePersonnaliser(AffichagePersonnalisation perso)
    {
        m_espace1 = perso.m_espace1;
        m_espace2 = perso.m_espace2;
        m_espace3 = perso.m_espace3;
        m_labelHeureSingulier = perso.m_labelsHeure.first;
        m_labelHeurePluriel = perso.m_labelsHeure.second;
        m_labelMinuteSingulier = perso.m_labelsMinute.first;
        m_labelMinutePluriel = perso.m_labelsMinute.second;
     
        m_keyColor = perso.m_keyColor;
        m_valuesColor = perso.m_valuesColor;
     
        for (auto& episode : m_liste_episodes)
        {
            //episode.second->AffichagePersonnaliser(perso);
            episode.AffichagePersonnaliser(perso);   }
    }
    Ok !
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    void Saison::Print()
    {
        Print_Header();
    
        for (auto& episode : m_liste_episodes)
        {
            //episode.second->Print();
            episode.Print();
        }
    ...
    }
    Ok !

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    struct SequenceVisionnage
    {
    ...
    };
    et
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
                for (auto const& lsvoc : src.m_liste_sequence_visionnages_ordonnee_chronologiquement)
                {
                    m_liste_sequence_visionnages_ordonnee_chronologiquement.emplace_back(SequenceVisionnage{ *this, lsvoc });
                }
    Quel que chose ?

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Probléme avc la formclosing
    Par dv-2008 dans le forum VB.NET
    Réponses: 2
    Dernier message: 23/03/2008, 16h33
  2. probléme avc console.readline()
    Par dv-2008 dans le forum VB.NET
    Réponses: 7
    Dernier message: 10/03/2008, 00h33
  3. j'ai un probléme avc un code vb.net aider moi svp
    Par dv-2008 dans le forum VB.NET
    Réponses: 12
    Dernier message: 29/01/2008, 09h20
  4. Problème avc une requête
    Par Raiga dans le forum Requêtes et SQL.
    Réponses: 3
    Dernier message: 30/06/2007, 18h36
  5. Toujours problème de lien avce la lib Cblas
    Par Kirou dans le forum Autres éditeurs
    Réponses: 1
    Dernier message: 19/06/2007, 14h50

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo