Discussion :

[bacelar]

Expliqué ?

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
int wmain(int argc, wchar_t* argv[])
{
...
    DWORD current_console_mode = 0;//Variable qui contiendra le "Mode" de la console de sortie sous forme d'un champ de bit
    // Le Mode d'une console est un nombre où chaque bit indique un réglage "ouvert/fermé"
    // DWORD, c'est un entier 32bits, il y a donc potentiellement 32 réglages à 2 états possibles chacun
    // pour voir la liste des champs de bits documentés, regardez la documentation à l'URL suivante :
    // https://learn.microsoft.com/fr-fr/windows/console/getconsolemode
    // on initialise cette variable à 0 pour ne pas avoir un contenu aléatoire dedans, au cas où
 
    // STD_OUTPUT_HANDLE : c'est une constante qui indique une valeur entière qui définit la sortie (OUTPUT) standard (STD) : sortie standard = console de sortie
    // sa valeur concrète est indiquée dans la documentation de GetStdHandle
    // https://learn.microsoft.com/fr-fr/windows/console/getstdhandle
 
    // GetStdHandle(STD_OUTPUT_HANDLE) permet d'avoir le HANDLE correspondant, donc ici permet d'avoir le HANDLE qui correspond à la console de sortie
 
    GetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE), &current_console_mode); //permet de remplir la variable current_console_mode avec le champ de bit correspondant aux différents réglages "actifs/inactifs" du handle passé en premier paramètre, ici, la console de sortie
    // L'ensemble de ces "modes actifs et inactifs" définit le "Mode" du handle passé en premier paramètre
 
    SetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE)
        , current_console_mode
        | ENABLE_VIRTUAL_TERMINAL_PROCESSING
        | ENABLE_PROCESSED_OUTPUT
    );// Ici c'est clairement une ligne un peu "trop" complexe.
    // GetStdHandle(STD_OUTPUT_HANDLE), c'est juste pour récupérer l'handle de la console de sortie, comme dans les lignes précédentes.
    // current_console_mode contient le champ de bit récupéré via GetConsoleMode
    // "|" est l'opérateur booléen "OU" sur les bits.
   // donc "current_console_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING | ENABLE_PROCESSED_OUTPUT", c'est juste "les mêmes réglages qu'avant mais en y activant (si nécessaire) VIRTUAL_TERMINAL_PROCESSING et PROCESSED_OUTPUT"
 
    // stdout c'est un "FILE*" indiquant la sortie standard au niveau de la librairie standard C
    // STD_OUTPUT_HANDLE est une constante utilisée par les API Win32, pas la librairie standard C
    // on peut voir le machin comme ça : Les fonctions de la librairie standard C gère un buffer dont les données à écrire sont envoyées aux buffers/consoles du système via des API Win32.
    // Dans des programmes "simples" en utilisant les fonctions de la librairie standard C, on n'a un code portable (qui fonction sur tous les Systèmes d'exploitation où existe un compilateur C)
    // Mais il manque les réglages fins que permet l'API Win32
 
    fflush(stdout);// les entrée/sortie standard (donc console) sont généralement bufferisées (des choses qui ont été envoyées à la console mais qu'elle n'a pas encore affichée)
    // en "flushant" la sortie standard, on demande à ce qu'elle vide son buffer : faire tous les traitements nécessaires à l'affiche ainsi que l'affichage
    // car on va changer les réglages de la console, et le traitement des données déjà dans le buffer, bin on ne saura pas si ça sera avec les anciens ou les nouveaux réglages.
    // en "flushant", il n'y aura pas d'ambigüité/bugs.
 
    // _setmode c'est pour changer le mode de traduction des api de la librairie standard C pour un flux particulier
    // https://learn.microsoft.com/fr-fr/cpp/c-runtime-library/reference/setmode?view=msvc-170
 
    // _fileno c'est un truc qui permet de convertir un "FILE*" en un int, cf. la documentation à l'URL ci-dessous :
    // https://learn.microsoft.com/fr-fr/cpp/c-runtime-library/reference/fileno?view=msvc-170
    // car la fonction "_setmode" veut le nombre correspondant au flux et non son "FILE*" (faut pas chercher la cohérence dans la librairie standard C "étendue")
 
    // _O_U16TEXT, c'est pour demander aux fonctions de la librairies standard C de considérer les chaines de caractère comme de l'UTF-16 et pas tenter de traduire le machin en "ASCII" via les réglages de langue de l'OS.
 
    int originalConsoleMode = _setmode(_fileno(stdout), _O_U16TEXT); // Après l'appel à "_setmode", le mode de traduction à changer mais "originalConsoleMode" contient l'ancien mode de traduction au cas où on voudrez le restaurer
 
 
    /*HANDLE*/ hOut = GetStdHandle(STD_OUTPUT_HANDLE); // pourquoi HANDLE en commentaire ??? VOUS AVEZ ENCORE CETTE COCHONERIE DE VARIABLE GLOBALE ?!?!?
    // permet d'avoir le HANDLE correspondant à la constante donnée en paramètre, donc ici permet d'avoir le HANDLE qui correspond à la console de sortie (BIS)
 
    // le code qui suit sert pour autre chose que vous n'avez pas fournit
    // avec Github on voit que cela utilisé pour appeler GetConsoleScreenBufferInfo, qui donne bien plus d'information sur la console que juste des 32bits de "GetConsoleMode"
    DWORD dwMode = 0;
    CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
...
}

???

Merci beaucoup

Voir commentaires dans le code.

P.S.: Si j'en crois la réponse de l'employé de M$ dans le rapport de bug qui suit :
https://github.com/microsoft/terminal/issues/10055
Il vaudrait mieux utiliser systématiquement "WriteConsoleW"
https://learn.microsoft.com/fr-fr/wi...e/writeconsole

[bacelar]

Bonsoir,

Exemple (le film) :

Avec et même :
Pièce jointe 645938

Code :

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

std::pair<std::vector<std::pair<std::tm, bool>>, std::wstring> date_1;

Ok ou pas ?

Merci d'avance

Ok ou pas QUOI ????

Vous nous donnez une copie d'écran avec des choses qui "fonctionnent" mais qui affichent des artefacts/défaut d'affichage, voir des traces d'exécution.
On ne sait pas ce qui est "normal" dans cette copie d'écran, de ce qui est un "bug".

On voit que la gestion des accents, c'est encore ça, mais on ne peut pas déterminer où ça déconne sans avoir votre environnement de test (arborescence de fichiers des données).

Vous nous collez une ligne de code mais dans Github, ça correspond à une ligne en commentaire (ligne 765 de film.cpp) dans une fonction "Film::afficher_Date_1" qui n'a pas été utilisée pour construire l'affichage de la copie d'écran qui vous nous avez posté.

Quel est le rapport ?

Le contenu de la copie d'écran est très vraisemblablement le résultat de l'appel de la fonction "Serie::afficher()" , qui n'appelle pas la fonction "Film::afficher_Date_1".
Donc modifier "Film::afficher_Date_1" ne changerai absolument rien à l'affichage actuel.

Si c'est pour "corriger" l'affichage de la série, "Serie::afficher()" est une fonction d'environ 353 lignes, donc largement trop grande de plusieurs 10aines de fois la taille d'une fonction "raisonnable".
Il y a tellement de chose qui ne vont pas dedans qu'il vaut mieux nous dire précisément ce qui ne vous plait pas dans l'affichage actuel, pour qu'on vous indique le minimum à faire pour vous satisfaire.
Si c'est juste demander comment fonctionne une fonction de 353 lignes, qui utilisent des globales dans tous les sens, c'est pas très raisonnable sans que vous ayez progressé dans la maitrise du C et/ou du C++.

Si ce qui vous embête c'est l'affiche de "pas-à-pas" ou de "préquel", valeurs en dur dans "Serie::afficher()", je pense qu'il faudra tester l'utilisation de WriteConsoleW à la place de "WriteFileW" dans "Console_Lire". (cf. Le P.S. de mon dernier message.)

[Laurent_B_]

Bonsoir,

J'ai oublié ! Alors, 4 jours : crevé ! Réflachir, mas pas de resultat !!!

afficher_Date_1(wstr, date, streaming);

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
int ParseYear(int y)
{
    std::wcout << L"===>Year=" << y << std::endl;
    assert(y >= 1582 && L"L'année invalide !");
    return y;
}
 
 
int ParseMonth(int m)
{
    std::wcout << L"===>Mon=" << m << std::endl;
    assert((m >= 0 && m <= 13) && L"Les mois invalide !");
    return m;
}
 
bool checkday(int& m, int& d, int& y)
{
    if (!(1 <= d && d <= 31))
        return false;
    if ((d == 31) && (m == 2 || m == 4 || m == 6 || m == 9 || m == 11))
        return false;
    if ((d == 30) && (m == 2))
        return false;
    if ((m == 2) && (d == 29) && (y % 4 != 0))
        return false;
    if ((m == 2) && (d == 29) && (y % 400 == 0))
        return true;
    if ((m == 2) && (d == 29) && (y % 100 == 0))
        return false;
    if ((m == 2) && (d == 29) && (y % 4 == 0))
        return true;
    return true;
}
 
int ParseDay(int& m, int d, int& y)
{
    std::wcout << L"===>Day=" << d << std::endl;
    if (checkday(m, d, y))
        return d;
    assert(L"Les jours invalide !");
    return 0;
}
 
wchar_t ParseTiret(wchar_t t)
{
    assert(L"Le tiret invalide !");
    return t;
}
 
wchar_t ParseSp(wchar_t s)
{
    assert(L"L'espasse invalide !");
    return s;
}
 
 
wchar_t ParseTiret_bas(wchar_t t)
{
    assert(L"Le tiret-bas invalide !");
    return t;
}
 
 
const int afficher_Date_1(std::wstring& wstr, std::vector<std::pair<std::tm, bool>>& date, std::wstring& streaming)
{
    if (wstr == L"")
    {
        return -1;
    }
    std::size_t pos;
    pos = wstr.length();
    wstr = wstr.substr(0, pos - 4); // .txt
    std::wcout << L"wstr=" << wstr << std::endl;
    std::tm tm;
 
    // std::vector<std::pair<std::tm, bool>>& date
    // 2023-01-01 TF1
    // 2023-01-02_03 Netflix
    // 2023-01-04_02-01 Netflix
    // 2023-03-01_02_03_ Netflix
    int year = 0, mon = 0, mday = 0, y = 0, m = 0, d = 0;
    int first_year = 0, first_mon = 0, first_mday = 0;
    wchar_t tiret1 = L'-', tiret2 = L'-', sp = L' ', tiret_bas = L'_';
    bool a_year = false, a_mon = false, a_mday = false, a_tiret1 = false, a_tiret2 = false, a_tiret_bas = false, a_sp = false, b_bbb = false;
    //std::size_t pos_year, pos_mon, pos_mday;
    int i = 0;
    do
    {
        std::wcout << L"Ok !!!" << std::endl;
        if (wstr[0] == std::wstring::npos || wstr[0] == sp)
            break;
        std::wcout << L"Ok qqqq!!!" << std::endl;
        //pos = 0;
        // year + mon + mday
        if (!a_year && !a_tiret1 && !a_mon && !a_tiret2 && !a_mday && 
            ParseYear(y = std::stoi(wstr.substr(0, 4))) &&
            ParseTiret(wstr[4]) &&
            ParseMonth(m = std::stoi(wstr.substr(5, 2))) &&
            ParseTiret(wstr[7]) &&
            ParseDay(m, d = std::stoi(wstr.substr(8, 2)), y) &&
            /*(wstr[11] == std::wstring::npos || wstr[11] == tiret_bas || wstr[11] == L' ') &&*/
            first_year < y
            )
        {
            std::wcout << L"year ???" << std::endl;
            a_year = true;
            //a_tiret1 = true;
            year = y;
            mon = m;
            mday = d;
            tm.tm_year = year - 1900;
            tm.tm_mon = mon - 1;
            tm.tm_mday = mday;
            wstr = wstr.substr(10);
            std::wcout << L"ttt [" << wstr[0] << L"]" << std::endl;
            if (wstr[0] == tiret_bas)
            {
                date.push_back(std::make_pair(tm, true));
                first_year = tm.tm_year;
                wstr = wstr.substr(1);
                std::wcout << L"ttt [" << wstr[0] << L"]" << std::endl;
                if (iswalpha(wstr[0]))
                    assert(L"La date ou le tiret ou le tiret bas invalide !");
                //if (wstr[0] == std::wstring::npos || (wstr[0] == sp && wstr[1] == iswalpha(wstr[1])))
                //    break;
                //wstr = wstr.substr(1);
                std::wcout << L"aaaaaaa" << std::endl;
                //continue;
            }
            else
            {
                date.push_back(std::make_pair(tm, false));
                break;
            }
        }
        // tiret1
        /*if (a_year && !a_tiret1 && !a_mon && !a_tiret2 && !a_mday && ParseTiret(wstr[0]))
        {
            a_tiret1 = true;
            std::wcout << L"Ok !!!" << std::endl;
            wstr = wstr.substr(1);
            //continue;
        }*/
        // mon + mday
        if (a_year && !a_mon && !a_mday &&
            ParseMonth(m = std::stoi(wstr.substr(0, 2))) &&
            ParseTiret(wstr[2]) &&
            ParseDay(m, d = std::stoi(wstr.substr(2, 2)), y) &&
            first_mon < m
            )
        {
            std::wcout << L"mon ???" << std::endl;
            a_mon = true;
            mon = m;
            mday = d;
            tm.tm_mon = mon - 1;
            tm.tm_mday = mday;
            wstr = wstr.substr(5);
            std::wcout << L"yyy [" << wstr[0] << L"]" << std::endl;
            if (wstr[0] == tiret_bas)
            {
                date.push_back(std::make_pair(tm, true));
                first_mon = tm.tm_mon;
                wstr = wstr.substr(1);
                if (iswalpha(wstr[0]))
                    assert(L"Le moi ou le jour ou le tiret ou le tiret bas invalide !");
                if (wstr[0] == std::wstring::npos || (wstr[0] == sp && wstr[1] == iswalpha(wstr[1])))
                    break;
                //continue;
            }
            else
            {
                date.push_back(std::make_pair(tm, false));
                break;
            }
            //continue;
        }
        // tire2
        /*if (a_year && a_tiret1 && a_mon && !a_tiret2 && !a_mday && ParseTiret(wstr[0]))
        {
            a_tiret2 = true;
            wstr = wstr.substr(1);
            //continue;
        }*/
        // mday
        std::wcout << L"bbbbb" << std::endl;
        if (a_year && a_mon && !a_mday &&
            ParseDay(m, d = std::stoi(wstr.substr(0, 2)), y) &&
            first_mday <= d
            )
        {
            std::wcout << L"mday ???" << std::endl;
            a_mday = true;
            mday = d;
            tm.tm_mday = mday;
            std::wcout << L"    tm.tm_mday=" << tm.tm_mday << std::endl;
            wstr = wstr.substr(2);
            std::wcout << L"uuu [" << wstr[0] << L"]" << std::endl;
            if (wstr[0] == tiret_bas)
            {
                date.push_back(std::make_pair(tm, true));
                first_mday = tm.tm_mday;
                wstr = wstr.substr(1);
                std::wcout << L"uuu [" << wstr[0] << L"]" << std::endl;
                if (iswalpha(wstr[0]))
                    assert(L"Le jour ou le tiret ou le tiret bas invalide !");
                //if (wstr[0] == std::wstring::npos || (wstr[0] == sp && wstr[1] == iswalpha(wstr[1])))
                //    break;
                //continue;
            }
            else
            {
                date.push_back(std::make_pair(tm, false));
                break;
            }
            //date.tm_mon = mon - 1;
            //date.tm_mday = mday;
            //continue;
        }
        std::wcout << L"wstr=[" << wstr << L"]" << std::endl;
        if (wstr[0] == sp)
        {
            std::wcout << L"L'espasse !!!" << std::endl;
            break;
        }
 
 
    } while (wstr[0] != std::wstring::npos);// || wstr[0] == sp));
    if (wstr[0] == sp)
    {
        wstr = wstr.substr(1);
        if (wstr[0] == sp)
        {
            assert(L"L'espasse invalide 2 !");
        }
    }
    if (wstr[0] == std::wstring::npos)
        streaming = L"";
    else
    {
        streaming = wstr;
    }
    std::vector<pair<std::tm, bool>>::iterator iter;
    std::wcout << L"Dates(s) :" << std::endl;
    for (iter = date.begin(); iter != date.end(); iter++)
    {
        std::wcout << L"    date=" << (*iter).first.tm_year + 1900 <<
            L"/" << (*iter).first.tm_mon + 1 <<
            L"/" << (*iter).first.tm_mday <<
            L", bool=" << (*iter).second << std::endl;
    }
    std::wcout << L"    streaming=[" << streaming << L"]" << std::endl;
    std::wcout << L"Ok : Fin" << std::endl;
    return EXIT_SUCCESS;
}

Marche pas !!!

J'en ai marre !!!

[bacelar]

afficher_Date_1(wstr, date, streaming)

Très complexe/longue comme fonction, pensez à simplifier rapidement votre code, SVP.

Ici, on voit les effets de ne pas trop bien nommer les fonctions.
"ParseYear" fait plus de la vérification que du "parsing".
Idem pour "ParseMonth"
Idem pour "ParseDay".

"checkday" a un nom qui correspond à ce qu'elle fait, c'est très bien.
Mais sa signature est piégeuse, n'utilisez pas de référence non constante pour les paramètres si la fonction ne compte pas les modifier.
Pour des types petits comme des int, utilisez un passage de paramètre par copie ; car "checkday" n'a pas à modifier ses arguments :

Code :

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

1
2
3
4
bool checkday(int m, int d, int y)
{
  ...
}

Si vous pensez d'abord ce que doit faire la fonction avant de l'implémenter, vous aurez une signature qui correspond à son besoin : type des paramètres, const ou pas, nombres de paramètre, passage par copie ou par référence, type de retour, etc...

Là, le code montre que vous ne "pensez" pas à la signature de vos fonctions, c'est important de le faire, vos copier-coller de vieux code vous embrouille le code que vous essayez de créer.

Là, vous créez plein de fonction avec des noms mal choisis, donc des utilisations dangereuses/complexes. Faites-vous un cadeau : renommez correctement vos fonctions. (puis corrigez leur signature, SVP)
Si vous n'y arrivez pas, c'est que c'est une "mauvaise" fonction (qui faut trop de chose).

Marche pas !!!

J'en ai marre !!!

Faudrait être plus précis.
Il y a tellement de chose qui ne vont pas dans ce code. Si vous ne dites pas ce qui VOUS pose problème, on va partir dans 36000 directions pour corriger tout ce qui ne va pas.

Message d'erreur qui vous bloque, SVP.

Si on analyse la signature de "afficher_Date_1", on voit déjà beaucoup de chose qui clochent.

Code :

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

const int afficher_Date_1

Pourquoi retourner un "const int" pour une fonction qui affiche quelque chose ???
Vieux réflexe du C ?
Généralement, une fonction "d'affichage" dans un stream, elle retourne le stream, pour pouvoir chainer les affichages successifs.

Code :

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

(std::wstring& wstr, std::vector<std::pair<std::tm, bool>>& date, std::wstring& streaming)

Noms de paramètres terribles !!!
Vous n'arriverez à rien si vous ne prenez pas la peine de correctement nommer vos paramètres.

"wstr", c'est, après analyses du code, le nom du fichier, alors donnez ce nom à votre paramètre : "nom_fichier", nom de dieu.

"date", c'est, après analyses du code, une liste de date tirées du nom du fichier.
Ca n'a rien à voir avec l'affichage d'une date => la fonction "afficher_Date_1" fait trop de chose, elle ne devrait qu'afficher des dates.
Vous devriez coupez en 2 votre fonction qui fait trop de chose à la fois.
Par exemple, une méthode qui extrait les informations pertinentes à partir du nom du fichier.
Puis une fonction qui affiche ces informations :
(remplacer ..... par un type correspond à l'ensemble des informations "extraillable" du nom du fichier)

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
 
std::vector<.....> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier){
    ...
}
...
void afficher_Date(HANDLE hOut, std::vector<.....>dates)
...
 
 
std::vector<.....> dates = ExtraireInfosDepuisNomDeFichier(nom_du_fichier1)
std::vector<.....> dates_suivantes = ExtraireInfosDepuisNomDeFichier(nom_du_fichier2)
...
dates.insert(dates.end(), dates_suivantes.begin(), dates_suivantes.end());
...
 
afficher_Date(hOut,dates)

Vous verrez que développer la fonction "ExtraireInfosDepuisNomDeFichier" puis "afficher_Date" sera beaucoup plus simple que de débuguer cette horreur de "afficher_Date_1".
Il faut juste récupérer de "afficher_Date_1" le code qui permettra d'implémenter "ExtraireInfosDepuisNomDeFichier" correctement (donc simplement).

"streaming", c'est, après analyses du code, ce qui est à la fin du nom du fichier, pourquoi faire en sorte que l'appelant est cette information, aucune putain d'idée.

Mais peut-être que toutes ces remarques vous indiffèrent et que vous ne voulez que "corriger" "afficher_Date_1", mais on en revient à un message d'erreur précis qui vous bloque.

Mais juste pour illustrer le fait que ne pas commencer par faire correctement les fonctions utilitaires comme "ParseYear" ou pas correctement les utiliser, ça fait un code "diabolique" :

Code :

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

1
2
3
4
5
6
7
8
9
if (!a_year && !a_tiret1 && !a_mon && !a_tiret2 && !a_mday && 
            ParseYear(y = std::stoi(wstr.substr(0, 4))) &&
            ParseTiret(wstr[4]) &&
            ParseMonth(m = std::stoi(wstr.substr(5, 2))) &&
            ParseTiret(wstr[7]) &&
            ParseDay(m, d = std::stoi(wstr.substr(8, 2)), y) &&
            /*(wstr[11] == std::wstring::npos || wstr[11] == tiret_bas || wstr[11] == L' ') &&*/
            first_year < y
            )

Ici, le parsing c'est "y = std::stoi(wstr.substr(0, 4))", "m = std::stoi(wstr.substr(5, 2))" ou encore "d = std::stoi(wstr.substr(8, 2))"
ParseYear, qui ne parse rien, renvoie un int représentant l'année, or il est dans une expression booléenne, donc le résultat sera interprété comme un booléen, pas comme un nombre.
Les variables sont initialisées dans des expressions booléens, donc les parties à droites ne seront évaluée que si la partie gauche est évalué à true, avec tous les effets de bord que cela entraine.
Ne faites pas cela, n'initialisez pas les variables comme ça, JAMAIS !!!

Des pièges dans cette fonction des enfers "afficher_Date_1", il y en n'a plein.

Pourquoi ne pas commencer par l'implémentation d'une fonction "ExtraireInfosDepuisNomDeFichier" bien propre, fait sans aucun copier-coller foireux ?

Pour le parsing de chaine de caractère, il existe un outil qu'on nomme "expression régulière" qui rendrait votre code bien plus simple, fiable et flexible, mais on l'utilisera plus tard.
Quand vous aurez supprimé toutes ces peaux de banane de "afficher_Date_1" (ou mieux, fait d'autres fonctions plus simples et plus utiles que ce machin).

[Laurent_B_]

Bonsoir,

streaming :

Netflix
TF1
...
Ou rien !

[Laurent_B_]

std::vector<std::pair<std::pair<std::tm, bool>, std::wstring>> date;

Oui ou non ?

Merci d'avance

[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
std::vector<std::pair<std::pair<std::tm, bool>, std::wstring>> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)
{
    /* 
    Ici !!!
    */
    std::vector<std::pair<std::pair<std::tm, bool>, std::wstring>> dates;
    /*
    Ici !!!
    Exemple : 
    // 2023-01-01 TF1
    // 2023-01-02_03 Netflix
    // 2023-01-04_02-01 Netflix
    // 2023-03-01_02_03_ Netflix
    */
    return dates;
}

???

[Médinoc]

Je conseillerais de créer une classe ou structure dédiée
:

Code C++ :

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 DateRecord
{
	std::tm date;
	std::bool someFlag;
	std::string name;
};
 
std::vector<DateRecord> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)
{
	std::vector<DateRecord> dates;
	/*
	Code qui extrait les infos
	*/
	return dates;
}

[bacelar]

std::vector<std::pair<std::pair<std::tm, bool>, std::wstring>> date;

Oui ou non ?

Merci d'avance

C'est pas mal, peu lisible, mais correspond presque aux informations que l'on peut extraire des noms des fichiers.

On peut extraire d'une nom de fichier une "std::pair<std::vector<std::pair<std::tm, bool>>, std::wstring>".
Il manque le fait que vous pouvez extraire plusieurs "dates+un flag lié au format d'un tiret (?)" d'un même nom, donc l'ajout d'un std::vector (cf. partie en gras dans la ligne du dessus)

Donc, s'il y a plusieurs noms de fichier, on a un "std::vector<std::pair<std::vector<std::pair<std::tm, bool>>, std::wstring>>".

Après, ces types deviennent limite au niveau compréhension à l'usage.

C'est là qu'une classe, comme l'indique @Médinoc, commence à devenir utile : cela permet de cacher la complexité d'un type avec une "API" plus simple que les types du namespace "std".

Mais attention, la classe de @Médinoc ne convient pas totalement car, je pense, il n'a pas finement analysé les informations extraillable du nom de fichier.
Particulièrement, il n'y a pas un "name" par date mais un seul par nom de fichier (le "streaming" de votre code).

Donc, je serais plus pour un code de la forme suivante (en n'ayant pas des noms tiptop parce qu'on sait pas trop à quoi cela sert :

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 DateRecord
{
	std::tm date;
	std::bool someFlag;
};
 
std::pair<std::vector<DateRecord>, std::wstring> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)
{
	std::vector<DateRecord> dates;
        std::wstring streaming;
	/*
	Code qui extrait les infos
	*/
	return std::pair<std::wstring, std::vector<DateRecord>> (streaming, dates);
}

Il y aurait un petit travail supplémentaire pour encore plus "cacher" les types du namespace "std".

Pour le code d'extraction, on peut s'inspirer du code de "afficher_Date_1" (il y a quelques erreurs à corriger 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
std::pair<std::wstring, std::vector<DateRecord>> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)
{
    std::vector<DateRecord> dates;
    std::wstring streaming;
 
    assert(nomFichier.len>0 && L"Nom de fichier vide");
 
    std::size_t pos;
    pos = nomFichier.length();
    std::wstring strRestant = nomFichier.substr(0, pos - 4);
 
    assert(strRestant.len>9 && L"Nom de fichier trop court pour avoir au moins une date");
 
    std::tm tm;
 
    do
    {
        if (strRestant[0] == sp)
            break;
 
        int y = std::stoi(wstr.substr(0, 4);
        int m = std::stoi(wstr.substr(5, 2));
        int d = std::stoi(wstr.substr(8, 2));
 
        checkyear(y);
        checkmonth(m);
        checkday(d,m,y);
 
        // year + mon + mday
        if (...//simplifiez le code SVP
...
 
    } while (strRestant.len()>0);
 
	return std::pair<std::wstring, std::vector<DateRecord>> (streaming, dates);
}

[Laurent_B_]

Bonjour,

Code :

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

std::pair<std::wstring, std::vector<DateRecord>> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)

Plutôt :

Code :

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

std::pair<std::vector<DateRecord>, std::wstring> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)

Ok ou pas ?

Merci d'avance

[Laurent_B_]

Ok !

Code :

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

std::pair<std::vector<DateRecord>, std::wstring> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)

Ok !

Code :

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

1
2
3
4
5
6
std::pair<std::vector<DateRecord>, std::wstring> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)
{
...
...
    return std::pair<std::vector<DateRecord>, std::wstring>(dates, streaming);
}

???

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

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
 
std::vector<.....> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier){
    ...
}
...
void afficher_Date(HANDLE hOut, std::vector<.....>dates)
...
 
 
std::vector<.....> dates = ExtraireInfosDepuisNomDeFichier(nom_du_fichier1)
std::vector<.....> dates_suivantes = ExtraireInfosDepuisNomDeFichier(nom_du_fichier2)
...
dates.insert(dates.end(), dates_suivantes.begin(), dates_suivantes.end());
...
 
afficher_Date(hOut,dates)

???

Merci d'avance

[bacelar]

Bonjour,

Code :

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

std::pair<std::wstring, std::vector<DateRecord>> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)

Plutôt :

Code :

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

std::pair<std::vector<DateRecord>, std::wstring> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)

Ok ou pas ?

Merci d'avance

Pour une paire, l'ordre importe peu, c'est à vous de voir en fonction de ce que vous allez en faire.
Utilisez l'ordre qui vous paraît le plus "logique".
Moi, j'ai juste pris l'ordre qui correspond à l'ordre dans le nom du fichier, bêtement.

Code :

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

1
2
3
4
5
6
7
 
std::pair<std::vector<DateRecord>, std::wstring> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)
{
...
...
    return std::pair<std::vector<DateRecord>, std::wstring>(dates, streaming);
}

???

C'est juste un squelette de code qui donne un nom de fonction possible, avec une signature (type de retour + types et noms des paramètres) logique.
J'ai spécifié la dernière ligne qui reprend le nom des variables utilisées dans cet enfer qu'est la fonction "afficher_Date_1".
Vous ne devriez mettre dans ExtraireInfosDepuisNomDeFichier, que le code de "afficher_Date_1" qui permet de remplir ces 2 variables. Le reste, on s'en cogne.

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
std::vector<.....> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier){
    ...
}
...
void afficher_Date(HANDLE hOut, std::vector<.....>dates)
...
 
 
std::vector<.....> dates = ExtraireInfosDepuisNomDeFichier(nom_du_fichier1)
std::vector<.....> dates_suivantes = ExtraireInfosDepuisNomDeFichier(nom_du_fichier2)
...
dates.insert(dates.end(), dates_suivantes.begin(), dates_suivantes.end());
...
 
afficher_Date(hOut,dates)

???

Merci d'avance

C'est juste un squelette de code qui montre à quoi ressemblerait du code qui prend la peine de séparer la partie récupération des données de la partie affichage de données.

[Laurent_B_]

Bonsoir,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
std::pair<std::vector<DateRecord>, std::wstring> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)
{
...
    return std::pair<std::vector<DateRecord>, std::wstring>(dates, streaming); // Ok ! Mais...
}
...
int wmain(int argc, wchar_t* argv[])
{
...
    std::pair<std::vector<DateRecord>, std::wstring>dates; // Ok ou pas ?
// Et :
    ??? = ExtraireInfosDepuisNomDeFichier(nomFichier);
...
}

Merci beaucoup

[Laurent_B_]

Code :

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

date = ExtraireInfosDepuisNomDeFichier(nomFichier);

Oui ! C'est vrai !

[bacelar]

C'est bon, vous n'avez plus d'interrogation ?

[Laurent_B_]

Bonjour,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
    std::vector<DateRecord> dates;
    DateRecord d{ {0}, false };
    std::tm tm;
...
            tm.tm_year = y - 1900;
            tm.tm_mon = m - 1;
            tm.tm_mday = d;
...
            // ???
            d.tm.tm_year = tm.tm_year;
...

Merci d'avance

[Médinoc]

Normalement d.tm = tm; devrait suffire, non?

[Laurent_B_]

Ben non !!!

[Laurent_B_]

Bonsoir,

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
bool checkyear(int y)
{
    if (!(1582 <= y))
        assert(y >= 1582 && L"L'année invalide !");
        //return false;
    return true;
}
 
bool checkmonth(int m)
{
    if (!(1 <= m && m <= 12))
        assert((1 <= m && m <= 12) && L"Le moi invalide !");
    //return false;
    return true;
}
 
bool checkday(int m, int d, int y)
{
    if (!(1 <= d && d <= 31))
        assert((1 <= d && d <= 31) && L"Le jour invalide !");
        //return false;
    if ((d == 31) && (m == 2 || m == 4 || m == 6 || m == 9 || m == 11))
        assert((d == 31) && (m == 2 || m == 4 || m == 6 || m == 9 || m == 11) && L"Le jour invalide !");
        //return false;
    if ((d == 30) && (m == 2))
        assert((d == 30) && (m == 2) && L"Le jour invalide !");
        //return false;
    if ((m == 2) && (d == 29) && (y % 4 != 0))
        assert((m == 2) && (d == 29) && (y % 4 != 0) && L"Le jour invalide !");
        //return false;
    if ((m == 2) && (d == 29) && (y % 400 == 0))
        return true;
    if ((m == 2) && (d == 29) && (y % 100 == 0))
        assert((m == 2) && (d == 29) && (y % 100 == 0) && L"Le jour invalide !");
        //return false;
    if ((m == 2) && (d == 29) && (y % 4 == 0))
        return true;
    return true;
}

Ok ou pas ?

Et :

Code :

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

bool checkday(int m, int d, int y)

ou

Code :

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

bool checkday(int& m, int d, int& y)

Merci d'avance

[Laurent_B_]

Bonsoir,

Que faire ?

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
bool checkyear(int y)
{
    if (!(1582 <= y))
        assert(y >= 1582 && L"L'année invalide !");
        //return false;
    return true;
}
 
bool checkmonth(int m)
{
    if (!(1 <= m && m <= 12))
        assert((1 <= m && m <= 12) && L"Le moi invalide !");
    //return false;
    return true;
}
 
bool checkday(int m, int d, int y)
{
    if (!(1 <= d && d <= 31))
        assert((1 <= d && d <= 31) && L"Le jour invalide !");
        //return false;
    if ((d == 31) && (m == 2 || m == 4 || m == 6 || m == 9 || m == 11))
        assert((d == 31) && (m == 2 || m == 4 || m == 6 || m == 9 || m == 11) && L"Le jour invalide !");
        //return false;
    if ((d == 30) && (m == 2))
        assert((d == 30) && (m == 2) && L"Le jour invalide !");
        //return false;
    if ((m == 2) && (d == 29) && (y % 4 != 0))
        assert((m == 2) && (d == 29) && (y % 4 != 0) && L"Le jour invalide !");
        //return false;
    if ((m == 2) && (d == 29) && (y % 400 == 0))
        return true;
    if ((m == 2) && (d == 29) && (y % 100 == 0))
        assert((m == 2) && (d == 29) && (y % 100 == 0) && L"Le jour invalide !");
        //return false;
    if ((m == 2) && (d == 29) && (y % 4 == 0))
        return true;
    return true;
}
 
struct DateRecord
{
    std::tm date{ 0 };
    bool someFlag{ false };
};
 
...
// ----------------
// |   Et, enfin :   |
// ----------------
std::pair<std::vector<DateRecord>, std::wstring> ExtraireInfosDepuisNomDeFichier(const std::wstring& nomFichier)
{
    assert(nomFichier.length() > 0 && L"Nom de fichier vide");
 
    std::size_t pos;
    pos = nomFichier.length();
    std::wstring strRestant = nomFichier.substr(0, pos - 4);
    assert(strRestant.length() > 9 && L"Nom de fichier trop court pour avoir au moins une date");
 
    std::vector<DateRecord> dates;
    //std::vector<DateRecord>::iterator iter;
    DateRecord date{ 0 };
 
    wchar_t sp = L' ', tiret = L'-', tiret_bas = L'_';
    int y, m, d;
    y = m = d = 0;
    int firstYear = 0, firstMon = 0, firstDay = 0;
    bool yearFlag, monFlag, dayFlag;
    yearFlag = monFlag = dayFlag = false;
    int i = 0;
    do
    {
        if (strRestant[0] == sp)
            break;
 
        //int y = std::stoi(wstr.substr(0, 4));
        //int m = std::stoi(wstr.substr(5, 2));
        //int d = std::stoi(wstr.substr(8, 2));
 
        //checkyear(y);
        //checkmonth(m);
        ///checkday(m, d, y);
 
        // year + mon + mday
        std::wcout << L"year + mon + mday" << std::endl;
        if (!yearFlag && !monFlag && !dayFlag
            && (y = stoi(strRestant.substr(0, 4))) && checkyear(y)
            && strRestant[4] == tiret
            && (m = std::stoi(strRestant.substr(5, 2))) && checkmonth(m)
            && strRestant[7] == tiret
            && (d = std::stoi(strRestant.substr(8, 2))) && checkday(m, d, y)
            && firstYear < y)
        {
            std::wcout << L"y ?" << std::endl;
            date.date.tm_year = y - 1900;
            date.date.tm_mon = m - 1;
            date.date.tm_mday = d;
            strRestant = strRestant.substr(10);
            if (strRestant[0] == tiret_bas)
            {
                date.someFlag = true;
                dates.push_back(date);
                std::wcout << L"i=" << i << std::endl;
                std::wcout << L"  dates[" << i << L"].date=" << dates[i].date.tm_year + 1900 << L'/' << dates[i].date.tm_mon + 1 << L'/' << dates[i].date.tm_mday << std::endl;
                std::wcout << L"  dates[" << i << L"].someFlag=" << dates[i].someFlag << std::endl;
                i++;
                strRestant = strRestant.substr(1);
                firstYear = y;
                m = d = 0;
                continue;
            }
            else
            {
                date.someFlag = false;
                dates.push_back(date);
                std::wcout << L"i=" << i << std::endl;
                std::wcout << L"  dates[" << i << L"].date=" << dates[i].date.tm_year + 1900 << L'/' << dates[i].date.tm_mon + 1 << L'/' << dates[i].date.tm_mday << std::endl;
                std::wcout << L"  dates[" << i << L"].someFlag=" << dates[i].someFlag << std::endl;
                i++;
                break;
            }
        }
        else
        {
            std::wcout << L"year pas ok !" << std::endl;
            assert(firstYear < y && L"aaa");
        }
        // mon + mday
        std::wcout << L"mon + mday" << std::endl;
        if (!monFlag && !dayFlag
            && firstYear != 0
            && (m = std::stoi(strRestant.substr(0, 2))) && checkmonth(m)
            && strRestant[2] == tiret
            && (d = std::stoi(strRestant.substr(3, 2))) && checkday(m, d, y)
            && firstMon < m)
        {
            std::wcout << L"m ?" << std::endl;
            date.date.tm_mon = m - 1;
            date.date.tm_mday = d;
            strRestant = strRestant.substr(5);
            if (strRestant[0] == tiret_bas)
            {
                date.someFlag = true;
                dates.push_back(date);
                std::wcout << L"i=" << i << std::endl;
                std::wcout << L"  dates[" << i << L"].date=" << dates[i].date.tm_year + 1900 << L'/' << dates[i].date.tm_mon + 1 << L'/' << dates[i].date.tm_mday << std::endl;
                std::wcout << L"  dates[" << i << L"].someFlag=" << dates[i].someFlag << std::endl;
                i++;
                strRestant = strRestant.substr(1);
                firstMon = m;
                m = d = 0;
                continue;
            }
            else
            {
                date.someFlag = false;
                dates.push_back(date);
                std::wcout << L"i=" << i << std::endl;
                std::wcout << L"  dates[" << i << L"].date=" << dates[i].date.tm_year + 1900 << L'/' << dates[i].date.tm_mon + 1 << L'/' << dates[i].date.tm_mday << std::endl;
                std::wcout << L"  dates[" << i << L"].someFlag=" << dates[i].someFlag << std::endl;
                i++;
                break;
            }
        }
        else
        {
            std::wcout << L"mon pas ok !" << std::endl;
            assert(firstMon < m && L"aaa");
        }
        // mday
        std::wcout << L"mday" << std::endl;
        if (firstYear != 0
            && (m = std::stoi(strRestant.substr(0, 2))) && checkmonth(m)
            && firstDay <= d)
        {
            std::wcout << L"d ?" << std::endl;
            date.date.tm_mday = d;
            strRestant = strRestant.substr(2);
            if (strRestant[0] == tiret_bas)
            {
                date.someFlag = true;
                dates.push_back(date);
                std::wcout << L"i=" << i << std::endl;
                std::wcout << L"  dates[" << i << L"].date=" << dates[i].date.tm_year + 1900 << L'/' << dates[i].date.tm_mon + 1 << L'/' << dates[i].date.tm_mday << std::endl;
                std::wcout << L"  dates[" << i << L"].someFlag=" << dates[i].someFlag << std::endl;
                i++;
                strRestant = strRestant.substr(1);
                firstDay = d;
                m = d = 0;
                continue;
            }
            else
            {
                date.someFlag = false;
                dates.push_back(date);
                std::wcout << L"i=" << i << std::endl;
                std::wcout << L"  dates[" << i << L"].date=" << dates[i].date.tm_year + 1900 << L'/' << dates[i].date.tm_mon + 1 << L'/' << dates[i].date.tm_mday << std::endl;
                std::wcout << L"  dates[" << i << L"].someFlag=" << dates[i].someFlag << std::endl;
                i++;
                break;
            }
        }
        else
        {
            std::wcout << L"day pas ok !" << std::endl;
            assert(firstDay < d && L"aaa");
        }
        if (!yearFlag)
            yearFlag;
        if (!monFlag)
            monFlag;
        if (!dayFlag)
            dayFlag;
 
    } while (strRestant.length() > 0);
    std::wstring streaming = L"";
    if (strRestant[0] == sp)
        strRestant = strRestant.substr(1);
    streaming = strRestant;
    return std::pair<std::vector<DateRecord>, std::wstring>(dates, streaming);
}

Merci d'avance