Discussion :

[bacelar]

"end" est censé être initialisé à quoi ?

Ok, la classe directory_iterator semble (j'ai pas accès au code source de la classe mais juste aux exemples dans MSDN) gère automatiquement les fin de liste d'une manière assez spéciale.

Quel faire ???

Si je comprend bien, vous ne comprenez pas pourquoi le répertoire "E:\Séries.[]\+++++\Umbrella Academy.[2019- Netflix]" n'est pas affiché en réponse à la commande

Code :

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

you /R s "U"

.
C'est cela ?

Alors, si c'est cela, c'est pace que ce répertoire n'est pas lui-même contenu dans un sous-répertoire de nom "U".
Pour qu'il s'affiche, il devrait être "E:\Séries.[]\+++++\U\Umbrella Academy.[2019- Netflix]"

Le fait que seul les répertoires contenus dans un sous-répertoire "U" vient de l'initialisation de la variable "r_r" ligne 20 de votre code et de son utilisation aux lignes 50 à 56 de votre code.

[bacelar]

Pour le débogueur, oui c'est comme cela qu'on lance une session de débogage : lancement de votre programme sous le contrôle d'un autre programme : le débogueur.

Avec ce contrôle, il est possible de faire exécuter le programme que vous avez construit ligne par ligne et voir l'état des variables étape par étape et de voir par où et quand votre programme passe par une ligne x ou y.

Avant de lancer une session de débogage, pensez à mettre des point d'arrêt sur des lignes qui vous intéresses, via la touche F9 si vous êtes sous Visual Studio.

[Laurent_B_]

Ok !

Code :

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

1
2
3
Ok : you -R s "S"
[you -R s "S"]
Ok :

You : you.exe
-R : rechercher
s : séries
"R" : exemple

???

has_extension : Retourne !extension().empty().
has_filename : Retourne !filename().empty().
has_parent_path : Retourne !parent_path().empty().
has_relative_path : Retourne !relative_path().empty().
has_root_directory : Retourne !root_directory().empty().
has_root_name : Retourne !root_name().empty().
has_root_path : Retourne !root_path().empty().
has_stem : Retourne !stem().empty().
is_absolute : Pour Windows, la fonction retourne has_root_name() && has_root_directory(). Pour POSIX, la fonction retourne has_root_directory().
is_relative : Retourne !is_absolute().

Que faire ?

Merci beaucoup ;-)

[bacelar]

Code :

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

1
2
3
Ok : you -R s "S"
[you -R s "S"]
Ok :

Je ne suis pas sûr de comprendre.
J'ai l'impression que les "Ok :" est un prompt de console. Mais dans aucune partie du code que vous avez posté récemment vous affichez la commande + arguments entre "[]", donc je ne vois pas à quoi correspond la seconde ligne de la citation précédente.

You : you.exe
-R : rechercher
s : séries
"R" : exemple

Là aussi, je ne suis pas sûr de comprendre.
J'ai l'impression que c'est un "écran d'usage" du programme.
Souvent, quand on crée un programme console qui demande des valeurs supplémentaires dans la ligne de commande et qu'il est lancé sans ces valeurs, le programme affiche un ensemble de renseignement sur comment/quoi donner comme paramètres supplémentaires au programme, c'est ce qu'on nomme un "écran d'usage".

Pour la dernière quote, je suppose que c'est un extrait de la documentation Microsoft :
https://docs.microsoft.com/fr-fr/cpp...?view=msvc-170

Ce que vous avez donné est une partie de la documentation spécifiant une liste de fonction membre de la classe "path".
La classe "path" est une classe fournie dans le fichier d'en-tête "<filesystem>" (qui est assez récent : C++17).
Voici l'equivalent plus digeste (mais en anglais) de la documentation de cette classe :
https://en.cppreference.com/w/cpp/filesystem/path
C'est une classe qui simplifie la manipulation des chemins vers des fichiers ou des répertoires (path = chemin en anglais) dans le système de fichiers de l'ordinateur.

Par exemple la fonction "has_extension", qui veut dire "a une extension", retourne "true" si le chemin "contenu/représenté" par l'instance de type classe "path" d'où on l'appelle, a une partie que l'on peut interpréter comme l'extension du nom de fichier.
par exemple, si l'objet "path" contient le chemin :

e:\Séries.[]\\+++\U\Unorthodox.[2020- Netflix]

Si "U" est un dossier/répertoire/folder et que "Unorthodox.[2020- Netflix]" est un fichier, la fonction "has_extension" renverra "true" et la fonction "extension" (https://en.cppreference.com/w/cpp/fi...path/extension) renverra la chaîne de caractère ".[2020- Netflix]".

Ce qu'il y a dans la documentation Microsoft n'est que l'implémentation de la fonction, pas vraiment ce qu'elle est sensée faire.

[Laurent_B_]

Je ne suis pas sûr de comprendre.
J'ai l'impression que les "Ok :" est un prompt de console. Mais dans aucune partie du code que vous avez posté récemment vous affichez la commande + arguments entre "[]", donc je ne vois pas à quoi correspond la seconde ligne de la citation précédente.

Oui, ok !

Là aussi, je ne suis pas sûr de comprendre.
J'ai l'impression que c'est un "écran d'usage" du programme.
Souvent, quand on crée un programme console qui demande des valeurs supplémentaires dans la ligne de commande et qu'il est lancé sans ces valeurs, le programme affiche un ensemble de renseignement sur comment/quoi donner comme paramètres supplémentaires au programme, c'est ce qu'on nomme un "écran d'usage".

Oui, c'est vrai ! Après, plus tard (c++, Windows, Bureau, Console et Bibliothèque) !

Code :

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

int wmain(int argc, wchar_t* argv[])

Oui ;-)

Ce que vous avez donné est une partie de la documentation spécifiant une liste de fonction membre de la classe "path".
La classe "path" est une classe fournie dans le fichier d'en-tête "<filesystem>" (qui est assez récent : C++17).
Voici l'equivalent plus digeste (mais en anglais) de la documentation de cette classe :
https://en.cppreference.com/w/cpp/filesystem/path
C'est une classe qui simplifie la manipulation des chemins vers des fichiers ou des répertoires (path = chemin en anglais) dans le système de fichiers de l'ordinateur.

Windows 10 ---> Paramètres ---> Options d'ergonomie ---> Narrateur ---> Activer le Narrateur !!!
Oui, lire (ok !), parler (moyen), mais écrire (difficile) !

Par exemple la fonction "has_extension", qui veut dire "a une extension", retourne "true" si le chemin "contenu/représenté" par l'instance de type classe "path" d'où on l'appelle, a une partie que l'on peut interpréter comme l'extension du nom de fichier.
par exemple, si l'objet "path" contient le chemin :
e:\Séries.[]\\+++\U\Unorthodox.[2020- Netflix]
Si "U" est un dossier/répertoire/folder et que "Unorthodox.[2020- Netflix]" est un fichier, la fonction "has_extension" renverra "true" et la fonction "extension" (https://en.cppreference.com/w/cpp/fi...path/extension) renverra la chaîne de caractère ".[2020- Netflix]".

Ce qu'il y a dans la documentation Microsoft n'est que l'implémentation de la fonction, pas vraiment ce qu'elle est sensée faire.

Ah ! Ok ! Mince !!!

[Laurent_B_]

Bonjour,

L'exemple répertoire :

Séries /-/, /+/, /++/, /+++/, /++++/ et /+++++/ :

/#/
/A/
/B/
/C/
…
/Z/

# : # ou 0 ou 1… 9 ? comment faire ?

Merci a tous ;-)

[Laurent_B_]

Mince !

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
const int afficher_Note(wstring n, wstring _T, int& note, bool& note_)
{ // 0...100 ou -100
    wstring N = ::afficher_fichier_lire(n, _T);
    size_t pos = N.length();
#if	afficher_Note_ == 1
    wcout << L"::afficher_Note(" << N << L", , )" << endl;
#endif
    if (N == L"")
    {
        note = -100;
#if	afficher_Note_ == 1
        wcout << L"::afficher_Note(, , " << note << L") : Ok !" << endl;
#endif
        return 0;
    }
    if (pos != 1 && pos != 3)
    {
        E.afficher_X(-1, N, L"Pas de [a-z] et/ou [0-9] et/ou etc...");
        return -1;
    }
    if (!iswdigit(N[0]))
    {
        E.afficher_X(-1, N, L"Pas de [a-z] et/ou etc...");
        return -1;
    }
    if (!(N[0] == L'0' || N[0] == L'1' || N[0] == L'2' || N[0] == L'3' || N[0] == L'4' || N[0] == L'5'))
    {
        E.afficher_X(-1, N, L"Pas de [0-5]");
        return -1;
    }
    if (pos == 1)
        note = 20 * stoi(N);
    else
    {
        if ((N[1] == L',' || N[1] == L'.') && iswdigit(N[2]) && pos == 3)
        {
            N[1] = L',';
            float f = stof(N, 0);
#if	afficher_Note_ == 1
            wcout << L"    " << L"f=" << f << endl;
#endif
            //note = /*(int)*/(f * 20);
            note = static_cast<int>(f * 20);
#if	afficher_Note_ == 1
            wcout << L"    " << L"note : " << note << endl;
#endif
        }
        else
        {
            E.afficher_X(-1, N, L"Pas de...");
            return -1;
        }
    }
#if	afficher_Note_ == 1
    wcout << L"::afficher_Note(, , " << note << L") : Ok !" << endl;
#endif
    note_ = true;
    return 0;
}

::afficher_Note(4.7, , ) :
f=4.7
note : 93
::afficher_Note(, , 93) : Ok !

4.7 * 20 = 94 pas 93 ???

Merci beaucoup ;-)

[Laurent_B_]

Bonjour,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
        if ((N[1] == L',' || N[1] == L'.') && iswdigit(N[2]) && pos == 3)
        {
            N[1] = L',';
            float f = stof(N, 0);
#if	afficher_Note_ == 1
            wcout << L"    " << L"f=" << f << endl;
#endif
            //note = floor(f * 20.0);
            note = floor(f * 20);
#if	afficher_Note_ == 1
            wcout << L"    " << L"note : " << note << endl;
#endif
        }

::afficher_Note(4.7, , ) :
f=4.7
note : 94
::afficher_Note(, , 94) : Ok !

Mais :

Code :

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

1
2
3
4
5
            note = floor(f * 20.0);
            //note = floor(f * 20);
#if	afficher_Note_ == 1
            wcout << L"    " << L"note : " << note << endl;
#endif

::afficher_Note(4.7, , ) :
f=4.7
note : 93
::afficher_Note(, , 93) : Ok !

Bizarre !!!

[Laurent_B_]

Bonsoir,

Code :

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

note = (int)floor(f * 20);

Merci à tous

[bacelar]

Il s'agit de "problèmes" très fréquents quand on utilise des nombres à virgule flottante (float et double principalement).
Les nombres directement dans le code (les littéraux) ont un type qui est fonction de comment ils sont écrits et des réglages de compilation.

20 -> cela peut être un signed int, un signed long int ou un signed long long int
20u -> cela peut être un unsigned int, un unsigned long int ou un unsigned long long int
20l -> cela peut être un signed long int, un unsigned long int ou un signed long long int

20.0 -> cela peut être un float ou un double
20.0f -> c'est un float
20.0d -> c'est un double

Les variables de type double sont plus grandes en mémoire que les variables de type float, donc, généralement, moins sujette à des "erreurs d'arrondi".

Quand des opérations arithmétiques à 2 opérandes (+,-,*,/) sont appliquées à des variables/littéraux de types différents, le compilateur convertie l'opérande ayant le type le plus "étroit" vers le type le plus large.

Du type (commun) le plus étroit au plus large :
short < int < long int < long long int < .... < float < double

Donc, dans le code "f * 20", f étant un float (donc déjà une approximation de 4.7 car 4.7 n'est pas directement "encodable" en float, f contient un nombre "proche" de 4.7), 20 est converti en un float avec une valeur proche de 20.0, car 20.0 n'est lui aussi pas directement "encodable" en float.

On n'a donc 2 nombres "approximatifs" qu'on multiplie entre eux, donc avec un résultat encore plus approximatif.

Code :

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

note = (int)floor(f * 20);

floor : https://en.cppreference.com/w/cpp/numeric/math/floor
Comme indiqué, le type de retour de floor est un float, donc une approximation de l'entier inférieur ou égale à la valeur de son argument (ici le résultat de "f * 20" qui est un float résultat "approximatif" du calcul).

"(int)..." est un cast à la C, donc très très déconseillé en C++ car très très peu fiable.
On préfère les cast explicites à la C++, comme "static_cast<int>(...)", qui ne peuvent pas être confondus avec d'autres concepts du langage (normalement).

Avec ce cast, vous demandez au compilateur de se débrouiller pour que le résultat du calcul rentrer dans la case mémoire réservé à la variable "note", qui est de la taille d'un int (2, 4, ou 8 octets en fonction du type de plateforme et des options de compilation) et avec un encodage d'entier et non en virgule flottante. Le pauvre compilateur doit donc utiliser ce qu'il peut (une instruction directement du CPU qui peut faire des types d'arrondi fonction de tout et n'importe quoi, une instruction dans un coprocesseur X ou Y qui fait des types d'arrondi aussi mindfuck que sur le CPU, ou encore des fonctions "intrinsics" toute aussi foireuses).

En résumé, votre "note = (int)floor(f * 20);" donne le résultat que vous attendiez bien plus par un heureux hasard que par un calcul précis et "correct".

La gestion des erreurs d'arrondi est le domaine d'étude principale de toute une discipline de l'informatique : l'analyse numérique.

La différence de comportement entre "note = floor(f * 20);" et "note = floor(f * 20.0);" est vraisemblablement que dans le premier cas "20" est converti en float et les calculs faits en float; et que dans le second cas, "f" est converti en double, les calculs faits en double.

[Laurent_B_]

« c » : oui : je sais (année 1998) !

« c ++ » : j'ai oublié !

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
if ((N[1] == L',' || N[1] == L'.') && iswdigit(N[2]) && pos == 3)
        {
            N[1] = L',';
            float f = stof(N, 0);
#if	Serie_afficher_Note_ == 1
            B.Ok_W(L"f=" + to_wstring(f));
#endif
            // Ok !!!
            //note = (int)floor(f * 20.0);
            //note = (int)floor(f * 20);
            note = static_cast<int>(f * 20.0f);
#if	Serie_afficher_Note_ == 1
            B.Ok_W(L"note=" + to_wstring(note));
#endif
        }

Merci beaucoup

[bacelar]

J'ai du mal à comprendre la question.

Le code que vous donnez est un bloc qui vérifie (maladroitement et incomplètement) que le tableau "N" contient une chaine de caractère de composé par un chiffre entre 0 et 9 (en fait entre 0 et 5 si on utilise les extraits de code antérieurs au dernier) suivi une virgule ou un point ( interprété comme séparateur entre la partie entière et la partie décimale ) puis d'un autre chiffre entre 0 et 9.

C'est donc un bout de code qui fonctionne dans un cadre assez particulier.

Le seul effet "permanent' de ce bloc est de mettre dans la variable "note" à partir d'une note entre "0.0" et "5.9" une valeur entre 0.00000..... et ~118.
(mais je pense que c'est plus 5.0 la valeur maximale que 5.9 mais rien ne le vérifie dans le code)

[Laurent_B_]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
const int Serie::afficher_Note(wstring n, wstring _T, int& note, bool& note_)
{ // 0...100 ou -100
    wstring N = ::afficher_fichier_lire(n, _T);
    size_t pos = N.length();
#if	Serie_afficher_Note_ == 1
    B.Ok_T(L"const int Serie::afficher_Note(" + n + L", " + _T + L", int& note, bool& note_) :");
#endif
    if (N == L"")
    {
        note = -100;
#if	Serie_afficher_Note_ == 1
        B.Ok_T(L"const int Serie::afficher_Note() : Ok !");
#endif
        return EXIT_SUCCESS;
    }
    if (pos != 1 && pos != 3)
    {
        E.afficher_X(-1, N, L"Pas de [a-z] et/ou [0-9] et/ou etc…");
        return EXIT_FAILURE;
    }
    if (!iswdigit(N[0]))
    {
        E.afficher_X(-1, N, L"Pas de [a-z] et/ou etc…");
        return EXIT_FAILURE;
    }
    if (!(N[0] == L'0' || N[0] == L'1' || N[0] == L'2' || N[0] == L'3' || N[0] == L'4' || N[0] == L'5'))
    {
        E.afficher_X(-1, N, L"Pas de [0-5]");
        return EXIT_FAILURE;
    }
    if (pos == 1)
    {
        note = 20 * stoi(N);
#if	Serie_afficher_Note_ == 1
        B.Ok_W(L"note=" + to_wstring(note));
#endif
    }
    else
    {
        if ((N[1] == L',' || N[1] == L'.') && iswdigit(N[2]) && pos == 3)
        {
            N[1] = L',';
            float f = stof(N, 0);
#if	Serie_afficher_Note_ == 1
            B.Ok_W(L"f=" + to_wstring(f));
#endif
            // Ok !!!
            //note = (int)floor(f * 20.0);
            //note = (int)floor(f * 20);
            note = static_cast<int>(f * 20.0f);
#if	Serie_afficher_Note_ == 1
            B.Ok_W(L"note=" + to_wstring(note));
#endif
        }
        else
        {
            E.afficher_X(-1, N, L"Pas de…");
        }
    }
#if	Serie_afficher_Note_ == 1
    B.Ok_T(L"const int Serie::afficher_Note() : Ok !");
#endif
    note_ = true;
    return EXIT_SUCCESS;
}

[bacelar]

Il s'agit d'une fonction "afficher_Note" de la classe "Serie".
Elle est sensée faire ce qu'indique son nom, mais bon, c'est pas vraiment le cas.
Elle semble faire bien plus, malheureusement.
C'est un concept de base de faire une seule chose dans une fonction.

En C++, une définition de fonction est en 2 parties :
- sa "signature" : const int Serie::afficher_Note(wstring n, wstring _T, int& note, bool& note_)
- son "corps" : ce qui est entre la première et la dernière accolade.

Sa signature indique, en plus de son nom : "afficher_Note" ; et la classe la contenant "Serie", son type de retour "const int" et les paramètres qu'elle utilise : n, _T, note et note_ ; avec le type de chacun de ces paramètres.

Son corps est la définition des actions faites par la fonction lors de son appel avec les arguments qui lui sont passés.

Une fonction, c'est un peu comme le concept de fonction en mathématique.

le type de retour, c'est le domaine de sortie de la fonction, c'est donc des entiers (int), qui n'est pas modifiable (const).
Mais c'est un peu foireux, en fait, comme typage (c'est un peu à la manière du langage C, et non du C++.
En fait, la fonction renvoie "EXIT_FAILURE" quand la fonction "pense" ne pas pouvoir gérer les valeurs passées en paramètre et "EXIT_SUCCESS" dans le cas contraire.
"Pense" car elle a pas mal de bugs latents.

Les paramètres devraient avoir des noms plus explicites que ceux utilisés.
Mais leurs utilisations indiquent plus ou moins leurs "utilités".

"n" et "_T" sont les paramètres passées à la fonction "::afficher_fichier_lire" qui renvoie une chaine de caractère (wstring) en retour.

La chaine de caractère renvoyée par la fonction "::afficher_fichier_lire" : "N" est ensuite analysée (maladroitement) pour soit :
-mettre -100 dans le paramètre "note" si la chaine de caractère "N" est vide.
-mettre un nombre entre 0 et 100 dans le paramètre "note" correspondant à 20 fois la valeur "contenue" dans "N".

[Laurent_B_]

Oh, merci beaucoup

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const int Serie::afficher_Note(wstring n, wstring _T, int& note, bool& note_)
{ // 0...100 ou -100
    wstring N = ::afficher_fichier_lire(n, _T);
    size_t pos = N.length();
#if	Serie_afficher_Note_ == 1
    B.Ok_T(L"const int Serie::afficher_Note(" + n + L", " + _T + L", int& note, bool& note_) :");
#endif
[...]
#if	Serie_afficher_Note_ == 1
    B.Ok_T(L"const int Serie::afficher_Note() : Ok !");
#endif
    note_ = true;
    return EXIT_SUCCESS;
}

Ok !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
const wstring afficher_fichier_lire(wstring t, wstring _T)
{
    wchar_t const* t_ = _T.c_str();
    FILE* fichier = NULL;
    if ((fichier = _wfopen(t_, L"r")) == NULL) // C4996
    { // Note: fopen is deprecated; consider using fopen_s instead
#if afficher_fichier_lire_ == 1
        wcerr << L"Le fichier '" << t_ << L"' n'a pas été ouvert !\n" << endl;
#endif
        //afficher_X(0, _T, L"Le fichier n'a pas été ouvert !");
        return L"";
    }
    string p = u8"";
    char phrase[254] = { u8"" };
    while (!feof(fichier))
    {
        if (fgets(phrase, 254, fichier) == NULL)
            break;
        else
            p = p + phrase;
    }
    fclose(fichier);
    //assert(p == u8"");
    if (p == u8"")
        return L"";
    assert(p != u8"");
    wstring_convert<codecvt_utf8_utf16<wchar_t>, wchar_t> convert;
    wstring P = convert.from_bytes(p);
    size_t pos = P.length();
    while (P[pos - 1] == L'\n' || P[pos - 1] == L'\t' || P[pos - 1] == L' ')
    {
        P = P.substr(0, pos - 1);
        pos--;
    }
#if afficher_fichier_lire_ == 1
    wcout << L"P=[" << P << L"]" << endl;
#endif
    return P;
}

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
const int Console_Lire_txt(wstring Textes, int y1, int y2, int Y)
{
#if Console_Lire_txt_OK_ == 1
    wcout << L"const int Console_Lire_txt(" << Textes << L", " << y1 << L", " << y2 << L", " << Y << L") : " << endl;
#endif
 
    if (Textes == L"" && Y == 0)
        return 0;
    rtrim(Textes);
    //
    bool ligne_vide = false;
    bool retrait = false;
    wchar_t entree = L'\n';
 
    int I, y;
    int i, j, k, n = 0;
    int l, m;
    basic_string <int>::size_type N;
    // // // //  //
    Textes += entree;
    // // // //  //
    int p = 0;
    vector<wstring> P;
    vector<int> PP;
    wstring o;
    int oo = 0;
    N = Textes.length();
    i = 0;
    while(i < N)
    {
        if (Textes[i] == L'\x1b')
        {
            j = i;
            o = L'\x1b';
            j++;
            while (Textes[j] != L'm' || j >= N)
            {
                o += Textes[j];
                j++;
            }
            if (j >= N)
            {
                E.afficher_X(-1, L"::Console_Lire_txt()", L"j >= N !!!");
                return -1;
            }
            o += L'm';
            P.push_back(o);
            PP.push_back(i);
            Textes = Textes.replace(i, o.length(), L"");
            p++;
            N = Textes.length();
        }
        i++;
    }
    vector <wstring>::iterator iter;
    wstring wstr;
    y = y1;
    I = Y - y;
    j = 0;
    if (I < N)
        n = I;
    else
        n = (int)N;
    vector <int>::iterator iter2;
    iter = P.begin();
    iter2 = PP.begin();
    oo = 0;
    while (j < N)
    {
        // Ok
        if (Textes[j] == entree && retrait == true)
        {
            ligne_vide = true;
            retrait = true;
            goto _ok_;
        }
        // Ok
        for (i = 0; i < y; i++)
#if Console_Lire_txt_ == 1
            wcout << L'_';
#else
            wcout << L' ';
#endif
        // Ok
        while (Textes[j] == L' ')
        {
            j++;
            n++;
            if (n > N)
                n = (int)N;
        }
        // Ok
        k = j;
        for (j = k; k < n; k++)
        {
            if (Textes[k] == entree)
            {
                break;
            }
        }
        if (k != n)
        {
            retrait = true;
            n = k;
        }
        else
        { // ???
            ligne_vide = false;
            retrait = false;
            while (Textes[n] != L' ')
            {
                n--;
            }
        }
        // Ok
        k = j;
        l = 0;
        for(j = k; k < n; k++)
        {
            if (p != 0 && k == *iter2)
            {
                o = *iter;
                wcout << o;
                wstr = o;
                iter++;
                iter2++;
                oo++;
            }
            wcout << Textes[k];
            l++;
        }
        // Ok
        j = k;
        m = Y - (y + l);
        for (i = 0; i < m; i++)
        {
#if Console_Lire_txt_ == 1
            wcout << L'*';
#else
            wcout << L' ';
#endif
        }
        // Ok
    _ok_:
    if (ligne_vide == true && retrait == true)
        {
            ligne_vide = false;
            j++;
            n++;
            if (n > N)
                n = (int)N;
            y = y1;
            continue;
        }
        else if (ligne_vide == false && retrait == true)
        {
            retrait = false;
            y = y1;
        }
        else
        {
            ligne_vide = false;
            retrait = false;
            y = y2;
        }
        j = n;
        if (p != 0 && j == *iter2)
        {
            o = *iter;
            wcout << o;
            wstr = o;
            iter++;
            iter2++;
            oo++;
        }
        j++;
        // y ?
        n += (Y - y);
        if (n > N)
        {
            n = (int)N;
        }
    }
    if (p != 0 && PP.back() <= N/*iter == wstr*/ /* && N != *iter2*/)
    {
        wcout << P.back() << endl;
        wstr = P.back();
    }
#if Console_Lire_txt_OK_ == 1
    wcout << L"const int Console_Lire_txt(" << Textes << L", " << y1 << L", " << y2 << L", " << Y << L") : Ok !" << endl;
#endif
    return EXIT_SUCCESS;
}

Alors ? Explique-moi ?

Merci énormément !!!

[Laurent_B_]

Ah :
https://fr.wikipedia.org/wiki/Const

J'ai oublié !!!
Merci

[Laurent_B_]

Alors ? Explique-moi ?

Merci énormément !!!

[Laurent_B_]

Avant 1996 :

ARBRE.H :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
class Element
	{
	friend class Arbre;
	Elt() {mot=0;nb_occur=0;fils_gauche=0;fils_droit=0;prem_occ=0;};
	char *mot;
	int nb_occur;
	Elt *fils_gauche;
	Elt *fils_droit;
	Occurrence *prem_occ;
	};
 
// ************************************
// *                                  *
// *           CLASSE ARBRE           *
// *                                  *
// ************************************
//
class Arbre
	{
	friend class Index;
	Arbre() {racine=0;}
	Booleen chercher(char *mot);
	void ajouter(Mot& mot);
	void ajouter(Mot& mot,char *fichier,char *ligne);
	void afficher(char mode) {parcours(racine,mode);};
	void parcours(Arbre *ou,char mode);
	Element *racine;
	Element *courant;
	};
 
 
 
Booleen Arbre::chercher(char *m)
	{
	int test;
	if(!racine)
		return faux;
	courant=racine;
	while(courant)
		{
		test=strcmp(m,courant->mot);
		if(test==0)
			return vrai;
		if(test<0)
			{
			if(courant->fils_gauche)
				courant=courant->fils_gauche;
			else
				return faux;
			}
		if(test>0)
			{
			if(courant->fils_droit)
				courant=courant->fils_droit;
			else
				return faux;
			}
		}
	}
 
//========== Ajout d'un mot
void Arbre::ajouter(Mot& mot)
	{
	int test;
	Elt *nouveau;
	if(racine->mot==0)
		{
		racine->mot=new char[mot.longueur];
		strcpy(racine->mot,mot.adresse());
		return;
		}
	test=strcmp(courant->mot,mot.adresse());
	nouveau->mot=new char[mot.longueur];
	strcpy(nouveau->mot,mot.adresse());
	if(test<0)
		courant->fils_gauche=nouveau;
	else
		courant->fils_droit=nouveau;
	}
 
//========== Ajout d'un mot avec son emplacement
void Arbre::ajouter(Mot& mot,char *fichier,char *ligne)
	{
	Occurrence *occ;
	courant->nb_occ++;
	// Premiere occurrence
	if(!courant->prem_occ)
		{
		prem_occ=new Occurrence;
		prem_occ->ligne=ligne;
		prem_occ->fichier=fichier;
		return;
		}
	// Ajout d'une occurrence
	occ=prem_occ;
	while(occ->occ_suiv)
		occ=occ->occ_suiv;
	if(occ->ligne!=ligne || occ->fichier!=fichier)
		{
		occ->occ_suiv=new Occurrence;
		occ->occ_suiv->ligne=ligne;
		occ->occ_suiv->fichier=fichier;
		}
	}
 
//========== Affichage de l'arbre
void Arbre::parcours(Arbre *ou,char mode)
	{
	if(ou->fils_gauche)
		parcours(ou->fils_gauche,mode);
	cout<<ou->mot<<","<<ou->nb_occur;
	if(mode=='f')
		cout<<";";
	else
		cout<<"\n";
	ou->prem_occ->afficher(ou->prem_occ,mode);
	if(ou->fils_droit)
		parcours(ou->fils_droit,mode);
	}

INDEX2.CPP :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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
// *******************************************************************
// *                                                                 *
// *                            INDEX.CPP                            *
// *                                                                 *
// *                                                 --------------- *
// *                                                 Laurent BOULEAU *
// *******************************************************************
//
 
#include <iostream.h>
#include "index2.h"
 
void usage()
	{
	cout<<"INDEX {-f fichier [... fichier_n] | -i fichier [... fichier_n]}\n";
	cout<<"      {[-a \"chaine\"] | [-s \"chaine\"]}\n";
	cout<<"      [-l fichier]\n";
	cout<<"\n";
	cout<<"\t-f : fichier(s) a indexer.\n";
	cout<<"\t-i : fichier(s) a indexer, affichage ligne par ligne.\n";
	cout<<"\t-a : caractere(s) etendu(s) possible(s) d'un mot.\n";
	cout<<"\t-s : seul(s) caractere(s) possible(s) d'un mot.\n";
	cout<<"\t-l : fichier texte de reference a l'indexeur.\n";
	}
 
int main(char argc,char *argv[])
	{
	int nb_fichier=faux;
	char *fichier[nb_fichier_max];
	Booleen option_f=faux;
	Booleen option_i=faux;
	Booleen option_a=faux;
	Booleen option_s=faux;
	char *extension_caractere=faux;
	char *fichier_l=faux;
	Index<Mot> index;
	int i;
	// Recuperation des parametres
	if(argc==1)
		{
		usage();
		return faux;
		}
	i=1;
	while(i<argc)
		{
		if(argv[i][0]=='-')
			{
			switch(argv[i][1])
				{
				case 'f':
					{
					option_f=vrai;
					i++;
					while(i<argc
						  && argv[i][0]!='-'
						  && nb_fichier<nb_fichier_max)
						fichier[nb_fichier++]=argv[i++];
					if(!nb_fichier)
						{
						cerr<<"Erreur : -f, pas de fichier(s) specifie(s).\n";
						usage();
						return faux;
						}
					break;
					}
				case 'i':
					{
					option_i=vrai;
					i++;
					while(i<argc
						  && argv[i][0]!='-'
						  && nb_fichier<nb_fichier_max)
						fichier[nb_fichier++]=argv[i++];
					if(!nb_fichier)
						{
						cerr<<"Erreur : -i, pas de fichier(s) specifie(s).\n";
						usage();
						return faux;
						}
					break;
					}
				case 'a':
					{
					option_a=vrai;
					if(i+1<argc)
						{
						extension_caractere=argv[i+1];
						i+=2;
						}
					else
						{
						cerr<<"Erreur : -a, specification de caractere(s) etendu(s) de mots manquante.\n";
						usage();
						return faux;
						}
					break;
					}
				case 's':
					{
					option_s=vrai;
					if(i+1<argc)
						{
						extension_caractere=argv[i+1];
						i+=2;
						}
					else
						{
						cerr<<"Erreur : -s, specification de caractŠre(s) manquante.\n";
						usage();
						return faux;
						}
					break;
					}
				case 'l':
					{
					if(i+1<argc)
						{
						fichier_l=argv[i+1];
						i+=2;
						}
					else
						{
						cerr<<"Erreur : -l, fichier de reference manquant.\n";
						usage();
						return faux;
						}
					break;
					}
				default:
					{
					cerr<<"Erreur dans les arguments.\n";
					usage();
					return faux;
					}
				}
			}
		else
			{
			cerr<<"Erreur dans les arguments.\n";
			usage();
			return faux;
			}
		}
	// Verification des parametres
	if(option_f && option_i)
		{
		cerr<<"Erreur : -f et -i, utilisation simultanee des deux parametres impossible.\n";
		usage();
		return faux;
		}
	if(!(option_f || option_i))
		{
		cerr<<"Erreur : -f ou -i, specification de fichier a indexer manquante.\n";
		usage();
		return faux;
		}
	if(option_a && option_s)
		{
		cerr<<"Erreur : -a et -s, utilisation simultanee des deux parametres impossible.\n";
		usage();
		return faux;
		}
	// Initialisation de l'indexeur
	if(option_a || option_s)
		{
		if(!index.initialiser(fichier,nb_fichier,(option_f?'f':'i'),fichier_l,(option_a?'a':'s'),extension_caractere))
			{
			cerr<<"Erreur : initialisation de l'indexeur impossible.";
			return faux;
			}
		}
	else
		{
		if(!index.initialiser(fichier,nb_fichier,(option_f?'f':'i'),fichier_l,faux,faux))
			{
			cerr<<"Erreur : initialisation de l'indexeur impossible.";
			return faux;
			}
		}
	// Indexation et affichage
	index.construire();
	cout<<index;
	return vrai;
	}

INDEX2.H :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
// *******************************************************************
// *                                                                 *
// *                             INDEX.H                             *
// *                                                                 *
// *                                                ---------------- *
// *                                                 Laurent BOULEAU *
// *                                                Gilles CCANTAREL *
// *******************************************************************
//
// Ce fichier contient les structures de donnees et methodes utilisees
// pour la creation de l'index.
//
 
#include <string.h>
#include <assert.h>
#include <iostream.h>
#include <fstream.h>
 
// ************************************
// *                                  *
// *        VARIABLES GLOBALES        *
// *                                  *
// ************************************
//
enum Booleen {faux=0,vrai};
const int nb_fichier_max=10;  // Nbre de fichiers maximum a indexer
const int taille_Mot_max=256; // Taille maximum d'un mot
 
char affichage='f';           // Mode d'affichage
char *fichier[nb_fichier_max];// Fichiers a traiter
char nb_fichier;              // Nbre de fichiers a traiter
char *fichier_l=faux;         // Fichier de reference
char fichier_courant=0;       // Indice du fichier en cours
int ligne=1;				  // Ligne en cours
Booleen referencer;           // Utilisation d'un fichier reference
 
// Liste des classes
class Mot;
template <class T> class Occurrence;
template <class T> class Sous_Occurence;
template <class T> class Noeud;
template <class T> class Arbre;
template <class T> class Index;
template <class T> class Analyseur;
 
// ************************************
// *                                  *
// *            CLASSE MOT            *
// *                                  *
// ************************************
//
// C'est la classe instanciee par le compilateur pour les autres
// classes. Elle contient les methodes necessaires aux traitements
// possibles sur les mots alphabetiques.
//
class Mot
	{
	public:
	friend ostream& operator<<(ostream&,Mot&);
	Mot() {mot=0;};
	Booleen existe() {return(strlen(mot)?vrai:faux);}
	Booleen valide(char lettre) const;
	void vider();
	Mot& operator=(Mot &m);
	Mot& operator+=(char lettre);
	Booleen operator==(Mot &m)
		const {return((strcmp(mot,m.mot)==0?vrai:faux));}
	Booleen operator<(Mot &m)
		const {return((strcmp(mot,m.mot)<0?vrai:faux));}
	Booleen operator>(Mot &m)
		const {return((strcmp(mot,m.mot)>0?vrai:faux));}
	private:
	char *mot;
	};
 
//========== Caracteres possibles dans un mot
Booleen Mot::valide(register char lettre)
	const
	{
	if((lettre>='A' && lettre<='Z') || (lettre>='a' && lettre<='z'))
		return vrai;
	else
		return faux;
	}
 
//========== Affectation d'un mot
Mot& Mot::operator=(Mot& m)
	{
	mot=new char[strlen(m.mot)+1];
	assert(mot!=0);
	strcpy(mot,m.mot);
	return *this;
	}
 
//========== Ajout d'une lettre a un mot
Mot& Mot::operator+=(char lettre)
	{
	if(!mot)
		{
		mot=new char[taille_Mot_max];
		assert(mot!=0);
		for(register int i=0;i<taille_Mot_max;mot[i++]=0);
		}
	mot[strlen(mot)]=lettre;
	return *this;
	}
 
//========== Effacement d'un mot
void Mot::vider()
	{
	int l=strlen(mot);
	for(register int i=0;i<l;i++)
		mot[i]=0;
	}
 
//========== Affichage d'un mot
ostream& operator<<(ostream& os,Mot& m)
	{
	cout<<m.mot;
	return os;
	}
 
// ************************************
// *                                  *
// *  CLASSE SOUS_OCCURRENCE (ligne)  *
// *                                  *
// ************************************
//
// Ce sont les elements d'une liste chainee contenant les occurrences
// de T par lignes.
//
template <class T>
class Sous_Occurrence
	{
	friend class Occurrence<T>;
	friend ostream& operator<<(ostream&,Sous_Occurrence<T> *);
	Sous_Occurrence() {ligne=::ligne;lig_suiv=0;}
	int ligne;
	Sous_Occurrence *lig_suiv;
	}
 
//========== Affichage des occurrences de lignes
//========== (version iterative)
template <class T>
ostream& operator<<(ostream& os,Sous_Occurrence<T> *s_o)
	{
	while(s_o)
		{
		cout<<s_o->ligne;
		if(s_o->lig_suiv)
			cout<<',';
		s_o=s_o->lig_suiv;
		}
	return os;
	}
 
//========== Affichage des occurrences de lignes
//========== (Version recursive)
//template <class T>
//ostream& operator<<(ostream& os,Sous_Occurrence<T> *s_o)
//	{
//	if(s_o)
//		{
//		cout<<s_o->ligne;
//		if(s_o->lig_suiv)
//			cout<<',';
//		cout<<s_o->lig_suiv; // Appel r‚cursif implicite
//		}
//	return os;
//	}
 
// ************************************
// *                                  *
// *    CLASSE OCCURRENCE (fichier)   *
// *                                  *
// ************************************
//
// Ce sont les elements d'une liste chainee contenant les occurrences
// de T par fichiers.
//
template <class T>
class Occurrence
	{
	friend class Noeud<T>;
	friend class Arbre<T>;
	friend ostream& operator<<(ostream&,Occurrence<T> *);
	Occurrence();
	void ajouter();
	char *fichier;
	Sous_Occurrence<T> *prem_lig;
	Occurrence *fic_suiv;
	};
 
//========== Constructeur d'occurrences avec creation de
//========== sous-occurrence
template <class T>
Occurrence<T>::Occurrence()
	{
	fichier=::fichier[::fichier_courant];
	fic_suiv=0;
	prem_lig=new Sous_Occurrence<T>;
	assert(prem_lig!=0);
	}
 
//========== Ajout d'une occurrence de ligne
template <class T>
void Occurrence<T>::ajouter()
	{
	Sous_Occurrence<T> *courant;
	if(prem_lig->ligne==::ligne)
		return;
	courant=prem_lig;
	while(courant->lig_suiv)
		courant=courant->lig_suiv;
	if(courant->ligne==::ligne)
		return;
	courant->lig_suiv=new Sous_Occurrence<T>;
	assert(courant->lig_suiv!=0);
	}
 
//========== Affichage des occurrences de fichiers
//========== (Version iterative)
template <class T>
ostream& operator<<(ostream& os,Occurrence<T> *o)
	{
	while(o)
		{
		if(::affichage!='f')
			cout<<'\t';
		cout<<o->fichier
			<<(::affichage=='f'?',':':')
			<<o->prem_lig;
		if(o->fic_suiv)
			cout<<(::affichage=='f'?';':'\n');
		o=o->fic_suiv;
		}
	return os;
	}
 
//========== Affichage des occurrences de fichiers
//========== (Version recursive)
//template <class T>
//ostream& operator<<(ostream& os,Occurrence<T> *o)
//	{
//	if(o)
//		{
//		if(::affichage!='f')
//			cout<<'\t';
//		cout<<o->fichier
//			<<(::affichage=='f'?',':':')
//			<<o->prem_lig;
//		if(o->fic_suiv)
//			cout<<(::affichage=='f'?';':'\n');
//		cout<<o->fic_suiv;	// Appel r‚cursif implicite
//		}
//	return os;
//	}
 
// ************************************
// *                                  *
// *           CLASSE NOEUD           *
// *                                  *
// ************************************
//
// Cette classe contient les instanciations des mots de type T
// correspondant a des noeuds ou feuilles de l'arbre binaire de
// recherche.
//
template <class T>
class Noeud
	{
	friend class Arbre<T>;
	friend ostream& operator<<(ostream&,Noeud<T> *);
	Noeud(T& mot);
	void ajouter();
	T element;
	int nb_occur;
	Noeud *fils_gauche;
	Noeud *fils_droit;
	Occurrence<T> *prem_fic;
	};
 
//========== Constructeur de noeud avec affectation de mot
template <class T>
Noeud<T>::Noeud(T &mot)
	{
	element=mot;
	nb_occur=0;
	fils_gauche=0;
	fils_droit=0;
	prem_fic=0;
	}
 
//========== Ajout d'une occurrence fichier
template <class T>
void Noeud<T>::ajouter()
	{
	Occurrence<T> *courant;
	nb_occur++;
	if(!prem_fic)
		{
		prem_fic=new Occurrence<T>;
		assert(prem_fic!=0);
		}
	else
		{
		courant=prem_fic;
		while(courant->fic_suiv && courant->fichier!=::fichier[::fichier_courant])
			courant=courant->fic_suiv;
		if(courant->fichier==fichier[::fichier_courant])
			// Ajout d'une occurrence de ligne
			courant->ajouter();
		else
			// Ajout d'une occurrence de fichier + ligne
			courant->fic_suiv=new Occurrence<T>;
		}
	}
 
//========== Affichage recursif des noeuds
template <class T>
ostream& operator<<(ostream& os,Noeud<T> *n)
	{
	if(n->fils_gauche)
		cout<<n->fils_gauche;
	cout<<n->element<<','<<n->nb_occur
		<<(::affichage=='f'?';':'\n')
		<<n->prem_fic
		<<'\n';
	if(n->fils_droit)
		cout<<n->fils_droit;
	return os;
	}
 
// ************************************
// *                                  *
// *           CLASSE ARBRE           *
// *                                  *
// ************************************
//
// Arbre binaire de stockage de mots de type T
//
template <class T>
class Arbre
	{
	friend class Index<T>;
	friend ostream& operator<<(ostream&,const Arbre<T>&);
	Arbre() {racine=0;}
	Arbre& operator+=(T& mot);
	Booleen trouver(T& mot);
	void ajouter(T& mot);
	Noeud<T> *racine;
	Noeud<T> *courant;
	};
 
//========== Ajout d'un mot dans l'arbre
template <class T>
Arbre<T>& Arbre<T>::operator+=(T& mot)
	{
	if(!::referencer)
		{
		if(!trouver(mot))
			{
			ajouter(mot);
			courant->ajouter();
			}
		else
			courant->ajouter();
		}
	else
		{
		if(::fichier_courant==-1)
			{
			if(!trouver(mot))
				ajouter(mot);
			}
		else
			{
			if(trouver(mot))
				courant->ajouter();
			}
		}
	return *this;
	}
 
//========== Recherche d'un mot
template <class T>
Booleen Arbre<T>::trouver(T& mot)
	{
	if(!racine)
		return faux;
	courant=racine;
	while(1)
		{
		if(mot==courant->element)
			return vrai;
		if(mot<courant->element)
			{
			if(courant->fils_gauche)
				courant=courant->fils_gauche;
			else
				return faux;
			}
		else
			{
			if(courant->fils_droit)
				courant=courant->fils_droit;
			else
				return faux;
			}
		}
	}
 
//========== Ajout d'un noeud
template <class T>
void Arbre<T>::ajouter(T& mot)
	{
	Noeud<T> *nouveau;
	if(!racine)
		{
		racine=new Noeud<T>(mot);
		assert(racine!=0);
		courant=racine;
		return;
		}
	nouveau=new Noeud<T>(mot);
	assert(nouveau!=0);
	if(mot<courant->element)
		courant->fils_gauche=nouveau;
	else
		courant->fils_droit=nouveau;
	courant=nouveau;
	}
 
//========== Affichage de l'arbre
template <class T>
ostream& operator<<(ostream& os,const Arbre<T>& a)
	{
	cout<<a.racine;
	return os;
	}
 
// ************************************
// *                                  *
// *           CLASSE INDEX           *
// *                                  *
// ************************************
//
// Cette classe gere le travail global de l'indexeur.
//
template <class T>
class Index
	{
	friend ostream& operator<<(ostream&,const Index<T>&);
	public:
	Index() {}
	Booleen initialiser(char *fic[],char nb_fic,char aff,
						char *fic_ref,char sep,char *car_sep);
	void construire(void);
	private:
	Arbre<T> arbre;
	Analyseur<T> analyseur;
	};
 
//========== Initialisation de l'indexeur
template <class T>
Booleen Index<T>::initialiser(char *fic[],char nb_fic=0,char aff=faux,
							  char *fic_ref=0,char sep=0,char *car_sep=0)
	{
	int i;
	if(!nb_fic)
		return faux;
	for(i=0;i<nb_fic;i++)
		::fichier[i]=fic[i];
	::nb_fichier=nb_fic;
	if(aff!='f' && aff!='i')
		return faux;
	::affichage=aff;
	if(fic_ref)
		{
		ifstream file(fic_ref,ios::in);
		if(!file)
			{
			cerr<<"Erreur : "<<fic_ref<<", fichier non valide.\n";
			return faux;
			}
		file.close();
		::fichier_l=fic_ref;
		::referencer=vrai;
		}
	for(i=0;i<nb_fic;i++)
		{
		ifstream file(fic[i],ios::in);
		if(!file)
			{
			cerr<<"Erreur : "<<fic[i]<<", fichier non valide.\n";
			return faux;
			}
		file.close();
		}
	if(car_sep && (sep!='a' && sep!='s'))
		return faux;
	analyseur.initialise((fichier_l?vrai:faux),car_sep,sep);
	return vrai;
	}
 
//========== Lancement de l'indexationConstruction de l'index
template <class T>
void Index<T>::construire()
	{
	T mot;
	while(analyseur.analyser(&mot))
		arbre+=mot;
	}
 
//========== Affichage de l'index
template <class T>
ostream& operator<<(ostream& os,const Index<T>& i)
	{
	cout<<i.arbre;
	return os;
	}
 
// ************************************
// *                                  *
// *         CLASSE ANALYSEUR         *
// *                                  *
// ************************************
//
// Un objet de cette classe se charge de reperer les mots dans les
// divers fichiers et de les confiers a l'indexeur.
//
template <class T>
class Analyseur
	{
	friend class Index<T>;
	Analyseur() {en_cours=faux;fic_ref=faux;}
	void initialise(Booleen fic,char *car_sep,char sep)
		{
		fic_ref=fic;
		separateur=car_sep;
		separation=sep;
		}
	Booleen analyser(T *mot);
	Booleen separer(T *mot,char c);
	Booleen en_cours;
	Booleen fic_ref;
	char *separateur;
	char separation;
	};
 
//========== Reperage des mots : analyse lexicale
template <class T>
Booleen Analyseur<T>::analyser(T *mot)
	{
	static char c;
	static ifstream file;
	if(!fic_ref && mot->existe() && c=='\n')
		::ligne++;
	mot->vider();
	if(fic_ref)
		{
		if(!en_cours)
			{
			::fichier_courant=-1;
			en_cours=vrai;
			file.open(::fichier_l,ios::in);
			}
		c=file.get();
		do
			{
			if(separer(mot,c))
				{
				if(mot->existe())
					return vrai;
				}
			else
				*mot+=c;
			}while((c=file.get())!=EOF);
		file.close();
		en_cours=faux;
		fic_ref=faux;
		::fichier_courant=0;
		}
	while(::fichier_courant<::nb_fichier)
		{
		if(!en_cours)
			{
			file.open(::fichier[::fichier_courant],ios::in);
			en_cours=vrai;
			}
		c=file.get();
		do
			{
			if(separer(mot,c))
				{
				if(mot->existe())
					return vrai;
				if(c=='\n')
					::ligne++;
				}
			else
				*mot+=c;
			}while((c=file.get())!=EOF);
		file.close();
		en_cours=faux;
		::fichier_courant++;
		::ligne=1;
		}
	return faux;
	}
 
//========== Identifieur de separateurs de mots
template <class T>
Booleen Analyseur<T>::separer(T *t,register char c)
	{
	if(separation!='s')
		{
		if(t->valide(c) || (separateur?strchr(separateur,(int)c):faux))
			return faux;
		else
			return vrai;
		}
	else
		{
		if(strchr(separateur,(int)c))
			return faux;
		else
			return vrai;
		}
	}

J'ai oublié parce que l'A.V.C ! https://www.b-lolo.fr/avc/
Avant : beaucoup d'amis !
Après : zéro ami ! Rien !
Voila !

Que faire !

Alors ? Explique-moi ?

Merci énormément !!!

[Médinoc]

Quelle est la question ici? Que faut-il expliquer exactement?

[bacelar]

J'ai, et je pense que mes "collègues" aussi, du mal à suivre votre démarche.

Prendre du code et demander à le comprendre, c'est une étape qu'il faut, je pense, faire après avoir relu un cours sur le développement informatique et le C++, histoire de remettre les idées en place.

Juste le réapprentissage d'un langage aussi complexe et changeant que le C++ est un challenge loin d'être évident.

Il serait peut-être plus efficace qu'on vous accompagne dans cet apprentissage plutôt que de faire l'exégèse des fragments de code que vous nous proposez.

Peut-être que vous voulez une petite explication de ces codes pour vous motiver ?

C'est pas forcement la méthode la plus efficace pour maintenir la motivation, non ?

Une rapide explication des codes que vous avez posté :

Le code de la fonction const wstring afficher_fichier_lire(wstring t, wstring _T) est bien ce que je pensais (malgré son nom "trompeur").
C'est une fonction qui lit le contenu d'un fichier, dont le nom est donné par le paramètre _T.
Le paramètre t ne sert à rien, pas utilisé.
Soit le fichier n'est pas trouvé (voir il n'existe pas), soit il est vide, et la fonction retourne une chaîne de caractères vide ("").
Soit le fichier n'est pas vide et on renvoie le contenu du fichier en ayant supprimer les caractères '\n', '\t' et ' ' qui se trouverait potentiellement à la fin de ce contenu. (C'est fait de manière bien trop complexe pour ce que c'est)

Si on reprend cela dans le contexte de son appel ( de la fonction afficher_fichier_lire ) dans la fonction const int Serie::afficher_Note(wstring n, wstring _T, int& note, bool& note_), le paramètre n ne sert à rien, le paramètre _T (qui correspond au paramètre _T de afficher_fichier_lire) indique le nom du fichier où aller chercher la "note" (de la série ?), le paramètre note devrait contenir une valeur -100 (si afficher_fichier_lire retourne un chaîne vide) ou une valeur entre 0 et 100 (en croyant les commentaire et pas le code qui contient des bugs). Le paramètre note_ est assigné à la valeur true (vrai en anglais) si le code de afficher_Note a "correctement" décodé la valeur retourné par afficher_fichier_lire.

La fonction const int Console_Lire_txt(wstring Textes, int y1, int y2, int Y) a, comme d'hab, un nom qui n'a rien à voir avec ce qu'elle fait vraiment.
Cette fonction essaye d'afficher dans la console le texte contenu dans le paramètre Textes, en le positionnant à une colonne précisée dans le paramètre y1, sans dépasser la colonne numérotée avec la valeur du paramètre Y, tout en gérant un retrait si c'est pas la première ligne affichée bla, bla ... c'est super mal fait et confus.

Clairement, ces 3 fonctions sont très très mal écrites et vous ne devriez pas apprendre le C++ avec ce type de code en tête.

Le code dans les classes Element et Arbre, et dans INDEX2(.H|.CPP) sont bien plus propres, bien qu'avec un style d'écriture un peu daté. (normal pour du 1996)
C'est juste du code qui permet d'indexer le contenu d'un ou plusieurs fichiers.
Vous donnez un ou plusieurs noms de fichier, le programme lit le contenu de ce(s) fichiers, découpe le contenu en mots et stocke le nom du fichier et le numéro de ligne dans le fichier où ce mot est apparu.
A la fin, il affiche la liste des mots avec les fichiers et les lignes où ils se trouvent, comme l'INDEX à la fin d'un livre;

Donc, le code des classes Element et Arbre, et dans INDEX2(.H|.CPP) est bien plus formateur que les codes précédents.