Problème et AVC : _wfopen_s

**bacelar** · 30/11/2022, 16h00

Ok, il semble que le "std::codecvt..." aient été supprimé de la norme C++20, sans méthode de remplacement, parce que le traitement effectué ne serait pas 100% "exacte".
En attendant une solution "fiable" dans la norme C++23 (espérons) et parce que cette fonctionnalité est importante pour votre projet et que vous n'utilisez pas les fonctionnalité de C++20, et que j'ai pas de librairies pour faire le taf sous la main, je vous conseille de "downgrader" votre projet en C++17 (voir les propriétés du projet VS pour cibler la norme C++17).
Avec cela, vous devriez "revoir" les fonctions qui posent problème.

Mais un truc me turlupine, pour faire du std::wtring to utf8, c'est pas plutôt "to_bytes" que "from_bytes" qu'il faut appeler ?

Si c'est le cas, c'est peut-être ça le problème et pas la version de la norme C++ cible.

**bacelar** · 30/11/2022, 16h28

Envoyé par Laurent_B_

Bonjour,

Code :

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

1
2
3
4
std::string wstr_to_u8(std::wstring uneWString)
{
    return std::wstring_convert<std::codecvt_utf8<wchar_t>>().from_bytes(uneWString);
}

???

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

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void afficher_Genre(std::wstring& genre_filename, std::wstring const& nomFichier, std::vector<std::wstring>& genres_renvoyes, const std::vector<std::wstring>& genres_valides)
{ // Genre
    std::size_t pos_txt = genre_filename.find(L".txt");
    assert((pos_txt != std::wstring::npos) && L"Erreur !!!");
    std::wstring radical = genre_filename.substr(0, pos_txt);
    std::vector<std::wstring>g;
    g = lire_fichierTxt(nomFichier, { L"\n", L", " });
    for (auto&& genre : g)
    {
        if (std::find(genres_valides.begin(), genres_valides.end(), genre) != genres_valides.end())
            genres_renvoyes.push_back(genre);
        else
        {
            assert((false) && "Attention genre non valide !!!");
        }
    }
// Ici :
    if(...)
        E.afficher_X(-1, genres_renvoyes, L"Pas de genre…");

}

Oui ou non ???

Merci à tous

Dans le code de la fonction "afficher_Genre", les lignes 3 à 5, elles servent à quoi ?
Pour moi, à rien, sauf rendre le code plus compliqué à maintenir, on dégage.

Pour la structure générale de la fonction : pourquoi un if ligne 18 ?

C'est quoi "E" ?
Ca veut dire quoi le X dans "afficher_X" ?
Le "-1", il sert à quoi ?

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
void afficher_Genre(std::wstring& genre_filename, std::wstring const& nomFichier, std::vector<std::wstring>& genres_renvoyes, const std::vector<std::wstring>& genres_valides)
{ // Genre
    std::vector<std::wstring>g = lire_fichierTxt(nomFichier, { L"\n", L", " });
    for (auto&& genre : g)
    {
        if (std::find(genres_valides.begin(), genres_valides.end(), genre) != genres_valides.end())
            genres_renvoyes.push_back(genre);
        else
        {
            assert((false) && "Attention genre non valide !!!");
        }
    }
 
    Console.afficherListeSurUneLigne(
        L", " /*séparateur entre les valeurs à afficher*/,
        L"\x1b[38;2;255;255;255m" /*textes en blanc*/,
        L"\x1b[38;2;0;0;255m" /*séparateurs en bleu*/,
        genres_renvoyes,
        L"Pas de genre…");
}

P.S.:
Utiliser la fenêtre "sortie" pour avoir les messages d'erreur, cf. Mon message posté le "18/10/2022, 13h07" sur ce même sujet de forum.

**Laurent_B_** · 30/11/2022, 20h51

Ok, il semble que le "std::codecvt..." aient été supprimé de la norme C++20, sans méthode de remplacement, parce que le traitement effectué ne serait pas 100% "exacte".
En attendant une solution "fiable" dans la norme C++23 (espérons) et parce que cette fonctionnalité est importante pour votre projet et que vous n'utilisez pas les fonctionnalité de C++20, et que j'ai pas de librairies pour faire le taf sous la main, je vous conseille de "downgrader" votre projet en C++17 (voir les propriétés du projet VS pour cibler la norme C++17).
Avec cela, vous devriez "revoir" les fonctions qui posent problème.

Norme ISO C++17 (/std:c++17) : c'est le cas !!!

Mais un truc me turlupine, pour faire du std::wtring to utf8, c'est pas plutôt "to_bytes" que "from_bytes" qu'il faut appeler ?

Comment faire ?

Si c'est le cas, c'est peut-être ça le problème et pas la version de la norme C++ cible.

???

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

Pour :
Nom : Capture d’écran 2022-11-30 165451.png
Affichages : 401
Taille : 5,6 Ko

et :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Erreur
{
public:
	Erreur(void);
	~Erreur();
	/*const */void afficher_X(int i, std::wstring x, std::wstring t);
	/*const */void afficher_X(int i, std::wstring x, std::wstring t, std::wstring w);
	/*const */int Ok(void);
	/*const */int Erreur_Ok(bool);
 
private:
	int OK = 0; // 8;
	bool OK_ = false;
	const std::wstring E_T = L"\x1b[38;2;255;0;0m";
	const std::wstring E_t = L"\x1b[38;2;255;255;255m";
	const std::wstring E_W = L"\x1b[38;2;0;200;200m";
	const std::wstring E_w = L"\x1b[38;2;255;255;255m";
	const int y1 = 0;
	const int y2 = 4;
	const int y3 = 4;
	const int y4 = 8;
 
	std::vector<int> X_i;
	std::vector<std::wstring> X_X;
	std::vector<std::wstring> X_T;
	std::vector<std::wstring> X_W;
	std::size_t X_I = -1;
 
	int I = 0;
	std::vector<int> XX_i = { 0 };
	std::vector<std::wstring> XX_X;
	std::vector<std::wstring> XX_T;
	std::vector<std::wstring> XX_W;
	std::size_t XX_I = -1;
};

et :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
void Erreur::afficher_X(int i, std::wstring x, std::wstring t) //const{}
{
#if Erreur_afficher_X_ == 1
    //wcerr << E_T << L"void Erreur::afficher_X(" << i << L", " << x << L", " << t << L") :" << E_t << endl;
    int j = Console_Lire_txt(E_T + L"void Erreur::afficher_X(" + E_t + std::to_wstring(i) + E_T + L", " + E_t + x + E_T + L", " + E_t + t + E_T + L") :" + E_t, y1, y2);
#endif
    X_i.push_back(i);
    X_X.push_back(x);
    X_T.push_back(t);
    X_W.push_back(L"");
    //
    X_I++;
#if Erreur_afficher_X_ == 1
    //wcerr << E_T << L"void Erreur::afficher_X() : Ok !" << E_t << endl;
    j = Console_Lire_txt(E_W + x + E_w + E_T + L" : " + E_t + E_W + t + E_w, y3, y4);
    j = Console_Lire_txt(E_T + L"void Erreur::afficher_X() : Ok !" + E_t, y1, y2);
#endif
    return;
}
...
int Erreur::Ok()
{
    int j;
#if Erreur_Ok_ == 1
    if (X_I != -1)
        j = Console_Lire_txt(E_T + L"int Erreur::Ok() :" + E_t, y1, y2);
#endif
    std::wstring wstr;
    std::vector<int>::iterator iter_X_i;
    std::vector<std::wstring>::iterator iter_X, iter_T, iter_W;
    int y;
    int i = 0;
    for (iter_X_i = X_i.begin(), iter_X = X_X.begin(), iter_T = X_T.begin(), iter_W = X_W.begin(); i++, iter_X_i != X_i.end(); iter_X_i++, iter_X++, iter_T++, iter_W++)
    {
        //wstr = L"";
        if (*iter_X_i <= OK)
        {
            if (*iter_X_i >= 0)
                //wcerr.width(8);
                y = y1 + 1;
            else
                //wcerr.width(7);
                y = y1;
            wstr = E_T + to_wstring(*iter_X_i) + L" : " + E_t + *iter_X + E_T + L" : " + E_t + *iter_T;
            j = Console_Lire_txt(wstr, y, y2);
            if (*iter_W != L"")
            {
 
                j = Console_Lire_txt(*iter_W, y3, y4);
 
            }
        }
        XX_i.push_back(*iter_X_i);
        XX_X.push_back(*iter_X);
        XX_T.push_back(*iter_T);
        XX_W.push_back(*iter_W);
    }
#if Erreur_Ok_ == 1
    if (X_I != -1)
        //wcerr << E_T << L"Erreur::Ok() : Fin !" << E_t << endl;
        j = Console_Lire_txt(E_T + L"int Erreur::Ok() : Ok !" + E_t, y1, y2);
#endif
    if (X_I != -1)
        Console_Lire_txt(L"---------- ");
    X_i.clear();
    X_X.clear();
    X_T.clear();
    X_W.clear();
    X_I = -1;
    return OK;
}

Voila !

Console ===> Plus tard !

Merci beaucoup : Patience

**Laurent_B_** · 30/11/2022, 21h03

Ensuite (série) :

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_fichier(std::wstring const& nomFichier, int const& nomImage = TXT_)
{	
...
    std::wstring t = nomFichier.substr(pos);
...
            // Genre
            if (t == L"Genre.txt")
            {
                afficher_Genre(t, nomFichier, genre, ::Genre);
                return EXIT_SUCCESS;
            }
 
...
}

Ok ou pas ?

**bacelar** · 01/12/2022, 18h26

Norme ISO C++17 (/std:c++17) : c'est le cas !!!

COOL !!!

Mais un truc me turlupine, pour faire du std::wtring to utf8, c'est pas plutôt "to_bytes" que "from_bytes" qu'il faut appeler ?

Comment faire ?

Juste changer la fonction appelée dans "wstr_to_u8"

Code :

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

1
2
3
4
std::string wstr_to_u8(std::wstring uneWString)
{
    return std::wstring_convert<std::codecvt_utf8<wchar_t>>().to_bytes(uneWString);
}

Et si vous suivez nos conseils en terme de transmission des messages d'erreur, ça serait plus explicite pour nous.
Voici le message d'erreur dans la fenêtre "Sortie" quand je reconstruis la fonction "wstr_to_u8" dans un projet de test:
1>c:\users\...consoleapplication.cpp(15): error C2664: 'std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> std::wstring_convert<std::codecvt_utf8<wchar_t,1114111,0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::from_bytes(const char *,const char *)'*: impossible de convertir l'argument 1 de 'std::wstring' en 'char'

C'est quand même bien plus explicite (Cf. la partie en rouge).

Votre classe "Erreur" est une hérésie complète. Elle n'a aucun putain de sens en terme de Conception/Programmation Orientée Objet, même si ça compile et que "cela fait le job" pour l'instant. C'est un maintenable à long terme.
Vous pouvez la virez immédiatement et tout ce qui ne compile plus, le remplacer par du code bien plus simple et maintenable.

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
class Console
{
public:
	//static void afficher_X(std::wstring t); c'est naze
       static void affiche_CleValeur(std::wstring cle, std::wstring valeur); // c'est beaucoup plus logique, voir ci-après
 
protected:
	static const std::wstring Text_Color = L"\x1b[38;2;255;0;0m";
	static const std::wstring Default_Color = L"\x1b[38;2;255;255;255m";
	static const std::wstring Ponctuation_Color = L"\x1b[38;2;0;200;200m";
        static const std::wstring End_Ln = L"\r\n";
 
private:
        static HANDLE getInstance();//le code d'implémentation, c'est pour après.
        static HANDLE inst= NULL;
};

N'utilisez pas la console pour faire des traces, bordel.
La console est votre interface utilisateur, donc, ne la polluez pas avec des "Console_Lire_txt" (encore un nom à chier) protégé avec des "#if ... == 1" complètement OSEF.
A la rigueur, et encore, si vous voulez faire du code de qualité "militaire", utilisez "OutputDebugString".
https://learn.microsoft.com/en-us/wi...utdebugstringw

"X", ça veut dire quoi ?

Moi, je vois qu'on a un système assez complexe de sauvegarde de valeurs dans beaucoup trop de listes de valeurs abscons que la fonction "Erreur::Ok" déroule pour un avantage que je ne vois pas.
Moi, je fais plus simple, tant que je vois pas l'intérêt de faire compliqué.
Donc affiche_X on dégage.
Comme on affiche un texte "clé" suivie par ' : ' puis un texte "valeur".
Je renomme affiche_X en affiche_CleValeur.
Comme le premier paramètre : "i", n'a qu'un intérêt "tout relatif", on dégage.
Et on nomme correctement les paramètres:

Code :

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

1
2
3
4
5
void Console::affiche_CleValeur(std::wstring cle, std::wstring valeur) 
{
    PrintStringW(getInstance(), Text_Color + cle + Default_Color +  L" : " + Text_Color + valeur + Default_Color + End_Ln);
    return;
}

J'utilise la fonction PrintStringW qu'on a déjà mentionnée avant (le code c'est quelques lignes, si on l'a pas déjà donné).
"getInstance", c'est pour implémenter le Design Pattern "Singleton".
C'est pas top comme Design Pattern, mais pour un début, ça le fera.
Cela permet de toujours n'avoir qu'une instance de Console (en gros, ici, c'est un peu déformé pour que ça fonctionne plus directement avec l'API Console de Windows).
J'utilise les constantes "Text_Color" et "Default_Color" pour maîtriser la couleur du texte affiché mais avec des choses plus parlantes que "E_T" ou "E_W".

La fonction "Erreur::Ok" est bien trop complexe pour ce qu'elle fait.

Je pense qu'il faut supprimer toutes les fonctions qui utilisent directement ou indirectement les liste "X_i", "X_X", ... "XX_i" ...
C'est bien trop mal fait et illisible pour être utilisable.
En enrichissant la classe Console et/ou les fonctions PrintStringW, on fera mieux et plus simple.

Et virez moi cette horrible fonction "Console_Lire_txt", qui portent très mal son nom.

Pour la fonction "Serie::afficher_fichier", c'est KO.

"afficher_fichier" est, à la vue de son nom, une fonction "généraliste", utilisable par d'autres fonction, mais votre code la rend complètement couplé à "afficher_Genre" qui est une fonction plus spécifique.
Normalement, c'est l'inverse qui doit se produire, les fonctions spécifiques utilisent les fonctions généralistes pour faire le travail.

Code :

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

1
2
3
4
5
const int Serie::afficher_Genre()
{
    afficher_fichier(m_directory / fs::path("Genre.txt"));
}
{

Mais si c'est la classe "Serie" qui doit maîtriser la mise en forme :

Code :

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

1
2
3
4
5
6
7
const int Serie::afficher_Genre()
{
    std::vector<wstring> genres = lire_fichierTxt(m_directory / fs::path("Genre.txt"),{L"\n", L", "});
    genres  = check_genres(genres);
    afficher_contenu_formate((genres.size()>1 ? L"genres" :  L"genre"), genres);
}
{

**Laurent_B_** · 04/12/2022, 22h32

Bonsoir à tous,

void Console:: PrintSoundtracks(const std::vector<std::pair<std::wstring,std::wstring>>>& soundtraks) : Ok !
Mais afficher_Soundtrack(...) : Pas de répond !

Un autre :
void Console:: PrintAvec(...)

Avec.txt
-------------
Jenna Ortega : Wednesday Addams
Catherine Zeta-Jones : Morticia Addams
Luis Guzmán : Gomez Addams
Riki Lindhome : Dr. Valerie Kinbott
Jamie McShane : Sheriff Donovan Galpin
Gwendoline Christie : Larissa Weems
Hunter Doohan : Tyler Galpin
Christina Ricci
Georgie Farmer : Ajax Petropolus
Percy Hynes-White : Xavier Thorpe
George Burcea : Lurch
Isaac Ordonez : Pugsley Addams
Victor Dorobantu : La chose
Moosa Mostafa : Eugune Otinger
Naomi J. Ogawa : Yoko Tanaka
Emmy Myers : Enid Sinclair
Joy Sunday : Bianca Barclay
Tommie Earl Jenkins : Mayor Walker
Iman Marson : Lucas Walker
William Houston : Joseph Crackstone
Luyanda Unati Lewis-Nyawo
Luyanda Unati Lewis-Nyawo
Rôle : Deputy Santiago
Oliver Watson : Kent
Calum Ross (II) : Rowan
Johnna Dias Watson : Divina
…

Christina Ricci
… : etc...
Avec et Soundtrack !!!

Merci beaucoup

**bacelar** · 05/12/2022, 12h10

Mais afficher_Soundtrack(...) : Pas de répond !

Vous nous avez toujours pas donné le code source de cette fonction.

Mais il y a de grande chance qu'elle soit facilement "convertible" en un code qui utilise "Console:: PrintSoundtracks" après avoir récupérer les informations à afficher depuis un fichier txt.
Il faut peut-être créer une fonction en charge de lire des paires de valeurs dans un fichier pour retourner un "std::vector<std::pair<std::wstring,std::wstring>>" plutôt qu'un simple std::vector<wstring> de la fonction "lire_fichierTxt", mais c'est pas très compliqué.

Code :

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

1
2
3
4
std::vector<std::pair<std::wstring,std::wstring>> lire_paireCleValeur_depuisFichierTxt(std::wstring const& nomFichier, std::wstring const& separateurCleValeur = L": ", std::wstring const& separateurPair = L"\n")
{
....
}

Le code de lire_paireCleValeur_depuisFichierTxt sera très proche de celui de lire_fichierTxt (avec même possibilité de fusion de partie de code entre les 2 fonctions).

void Console:: PrintAvec(...)

Le code sera très proche de "Console:: PrintSoundtracks", voir quasiment identique.
Montrez-nous l'écran qui affiche "Avec", et l'on fera en sorte que "Console:: PrintAvec" partage une grande partie de "Console:: PrintSoundtracks", c'est du refactoring pour mettre en commun du code entre ces 2 fonctions.

Christina Ricci

Je pense que c'est une "typo" car "Christina Ricci" est une actrice d'un des film de la famille Adams mais que le reste du fichier semble être la distribution d'une Série de la famille Adams.
Peut-être à supprimer de "Avec.txt".

Montrez-nous le code "complet" de l'affichage d'une série ainsi qu'une copie d'écran correspondante.

**Laurent_B_** · 05/12/2022, 15h33

Bonjour,

Ok, avant : Soundtrack

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
const int Cinema::afficher_Soundtrack(std::wstring& s, std::wstring const& nomFichier)
{
#if Cinema_afficher_Soundtrack_ == 1
	B.Ok_T(L"const int afficher_Soundtrack(" + s + L", " + nomFichier + L") :");
#endif
	std::size_t pos, pos2;
	pos = s.length();
	std::vector <wstring>::iterator iter, iter2;
	if (s == L"Soundtrack.txt")
	{
		try
		{
			s = lire_fichierTxt(nomFichier);
		}
		catch (runtime_error const& exception)
		{
			std::wcout << L"Erreur : " << exception.what() << std::endl;
		}
		if (!s.empty())
		{
			//if (pos = s.find(L", "))
			//	a = replace_all(a, L", ", L"\n");
			s += L"\n";
			while (pos = s.find(L"\n"))
			{
				if (s[0] != s.length())
				{
					pos2 = s.find(L" : ");
                    if (pos > pos2)
						// Soundtrack et Soundtrack_role
					{
						if (std::find(Soundtrack.begin(), Soundtrack.end(), s.substr(0, pos2)) != Soundtrack.end())
						{
							B.Ok_W(L"Soundtrack={" + s.substr(0, pos2) + L"}, Soundtrack_role={" + s.substr(pos2 + 3, pos - (pos2 + 3)) + L'}');
							Soundtrack.push_back(s.substr(0, pos2));
							Soundtrack_role.push_back(s.substr(pos2 + 3, pos - (pos2 + 3)));
							//G.push_back(g.substr(0, pos));
							//g = g.substr(pos + 1);
						}
						else
						{
							B.Ok_T(L"const int afficher_Soundtrack() : Attention !!!");
							return EXIT_FAILURE;
						}
					}
					else
					{
						// Rrrrrrrr !!! Pas de solution
						B.Ok_W(L"Soundtrack={" + s.substr(0, pos - 1) + L"}");
						return EXIT_FAILURE;
					}
					//
					s = s.substr(pos + 1);
				}
				else
					break;
			}
#if Cinema_afficher_Soundtrack_ == 1
			B.Ok_W(L"-- -- -- -- --");
			std::wstring wstr = L"Soundtrack et Soundtrack_role={";
			std::wstring& soundtrack = Soundtrack.back();
			for (int i = 0; i < Soundtrack.size(); i++)
			{
				wstr += Soundtrack[i] + L' ';
				wstr += L'(' + Soundtrack_role[i] + L')';
				if (Soundtrack[i] != soundtrack)
					wstr += L", ";
				else
					wstr += L'.';
			}
			B.Ok_W(wstr + L'}');
#endif
		}
		else
		{
#if Cinema_afficher_Soundtrack_ == 1
			B.Ok_W(L"Soundtrack={} nomFichier");
#endif
			return EXIT_SUCCESS;
		}
	}
	else
	{
#if Cinema_afficher_Soundtrack_ == 1
		B.Ok_W(L"Soundtrack={}, Pas de repons !!!");
#endif
		E.afficher_X(-1, L"Soundtrack={}", L"Pas de reponse !!!");
		return EXIT_FAILURE;
	}
#if Cinema_afficher_Soundtrack_ == 1
	B.Ok_T(L"const int afficher_Soundtrack() : Ok !");
#endif
	Soundtrack_ = true;
	return EXIT_SUCCESS;
}

et Avec (série et film)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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
const int afficher_Avec(std::wstring& a, std::wstring const& nomFichier, std::vector<std::wstring>& Avec, std::vector<std::wstring>& Avec_role)
{
#if afficher_Avec_ == 1
    B.Ok_T(L"const int afficher_Avec(" + a + L", " + nomFichier + L", std::vector<std::wstring>&Avec, std::vector<std::wstring>&Avec_role) :");
#endif
    std::size_t pos, pos2;
    pos = a.length();
    std::vector<std::wstring>::iterator iter, iter2;
    if (a == L"Avec.txt")
    {
        try
        {
            a = lire_fichierTxt(nomFichier);
        }
        catch (runtime_error const& exception)
        {
            std::wcout << L"Erreur : " << exception.what() << std::endl;
        }
        a = replace_all(a, L",", L" -");
        a = replace_all(a, L"(", L"[");
        a = replace_all(a, L")", L"]");
        if (!a.empty())
        {
            if (pos = a.find(L", "))
                a = replace_all(a, L", ", L"\n");
            a += L"\n";
            while (pos = a.find(L"\n"))
            {
                if (a[0] != a.length())
                {
                    pos2 = a.find(L"…");
                    if (pos2 != std::wstring::npos && a[0] == L'…')
                        // Avec={L'…'}
                    {
                        B.Ok_W(L"Avec={L'…'}");
                        Avec.push_back(L"…");
                        Avec_role.push_back(L"");
                        break;
                    }
                    pos2 = a.find(L" : ");
                    if (pos2 == std::wstring::npos && pos != std::wstring::npos)
                        // Avec={XXX} et Avec_role={}
                    {
                        B.Ok_W(L"Avec={" + a.substr(0, pos - 1) + L"}, Avec_role={}");
                        Avec.push_back(a.substr(0, pos - 1));
                        Avec_role.push_back(L"");
                    }
                    else if (pos2 == 0)
                        // Avec={} et Avec_role={XXX}
                    {
                        B.Ok_W(L"Avec={}, Avec_role={" + a.substr(3, (pos - 1) - 2) + L'}');
                        Avec.push_back(L"");
                        Avec_role.push_back(a.substr(3, (pos - 1) - 2));
                    }
                    else if (pos > pos2)
                        // Avec et Avec_role
                    {
                        B.Ok_W(L"Avec={" + a.substr(0, pos2) + L"}, Avec_role={" + a.substr(pos2 + 3, pos - (pos2 + 3)) + L'}');
                        Avec.push_back(a.substr(0, pos2));
                        Avec_role.push_back(a.substr(pos2 + 3, pos - (pos2 + 3)));
                    }
                    else
                    {
                        // Rrrrrrrr !!! Pas de solution
                        B.Ok_W(L"Avec={" + a.substr(0, pos - 1) + L"}, Avec_role={}");
                        Avec.push_back(a.substr(0, pos - 1));
                        Avec_role.push_back(L"");
                    }
                    //
                    a = a.substr(pos + 1);
                }
                else
                    break;
            }
#if afficher_Avec_ == 1
            B.Ok_W(L"-- -- -- -- --");
            std::wstring wstr = L"Avec et Avec_role={";
            std::wstring& avec = Avec.back();
            for (int i = 0; i < Avec.size(); i++)
            {
                if (Avec[i] == L"")
                    wstr += L"Pas de Avec ";
                else
                    wstr += Avec[i] + L' ';
                wstr += L'(' + Avec_role[i] + L')';
                if (Avec[i] != avec)
                {
                    wstr += L", ";
                }
                else
                {
                    wstr += L'.';
                }
            }
            B.Ok_W(wstr + L'}');
#endif
            B.Ok_T(L"const int afficher_Avec() : Ok !");
            return EXIT_SUCCESS;
        }
        else
            return EXIT_SUCCESS;
    }
    // Ok ou pas ?
    //a = afficher_fichier_lire(a, _T);
    try
    {
        a = lire_fichierTxt(nomFichier);
    }
    catch (runtime_error const& exception)
    {
        std::wcout << L"Erreur : " << exception.what() << std::endl;
    }
    a = replace_all(a, L",", L" -");
    a = replace_all(a, L"(", L"[");
    a = replace_all(a, L")", L"]");
    if (!a.empty())
    {
        a = a + L"\n";
        while (pos = a.find(L"\n"))
        {
            if (a[0] != a.length())
            {
                Avec_role.push_back(a.substr(0, pos));
                a = a.substr(pos + 1);
            }
            else
                break;
        }
#if afficher_Avec_ == 1
        std::wstring wstr = L"Avec_role={";
        /*for (iter = Avec_role.begin(), i = 0; iter != Avec_role.end(); iter++, i++)
        {
            wstr += *iter;
            if (i != Avec_role.size() - 1)
                wstr += L", ";
        }*/
        B.Ok_W(wstr + L'}');
#endif
    }
#if afficher_Avec_ == 1
    B.Ok_T(L"const int afficher_Avec() : Ok !");
#endif
    return EXIT_SUCCESS;
}

Alors...

**Laurent_B_** · 05/12/2022, 20h55

Nom : Capture1.PNG
Affichages : 374
Taille : 90,2 Ko

Nom : Capture d’écran 2022-12-05 204834.png
Affichages : 370
Taille : 30,8 Ko

Nom : Capture2.PNG
Affichages : 366
Taille : 25,8 Ko

Merci beaucoup

**Laurent_B_** · 06/12/2022, 15h04

Bonjour bacelar,

Je ne sais pas quoi mettre là où j'ai écrit "ici" !!!

Code :

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

1
2
3
4
void afficher_Soundtrack(/* Ici */)
{
/*ici */
}

Exemple :

Avec.txt
-----------
Jenna Ortega : Wednesday Addams
Catherine Zeta-Jones : Morticia Addams
Luis Guzmán : Gomez Addams
Riki Lindhome : Dr. Valerie Kinbott
Jamie McShane : Sheriff Donovan Galpin
Gwendoline Christie : Larissa Weems
Hunter Doohan : Tyler Galpin
Christina Ricci :
Georgie Farmer : Ajax Petropolus
Percy Hynes-White : Xavier Thorpe
George Burcea : Lurch
Isaac Ordonez : Pugsley Addams
Victor Dorobantu : La chose
Moosa Mostafa : Eugune Otinger
Naomi J. Ogawa : Yoko Tanaka
Emmy Myers : Enid Sinclair
Joy Sunday : Bianca Barclay
Tommie Earl Jenkins : Mayor Walker
Iman Marson : Lucas Walker
William Houston : Joseph Crackstone
Luyanda Unati Lewis-Nyawo
Luyanda Unati Lewis-Nyawo
Rôle : Deputy Santiago
Oliver Watson : Kent
Calum Ross (II) : Rowan
Johnna Dias Watson : Divina
…

C'est normal qu'il n'y ait rien en face de Christina Ricci. Et les ... à la fin, on les laisse comme ça.

**Laurent_B_** · 06/12/2022, 23h53

Bonsoir,

Avec.txt
-------------
Prénom Nom : Role
Prénom Nom2 :
Prénom Nom3
: Role2
…

Voila !

Merci beaucoup

**bacelar** · 09/12/2022, 19h33

Code :

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

1
2
const int Cinema::afficher_Soundtrack(std::wstring& s, std::wstring const& nomFichier)
{

Pour que afficher_Soundtrack soit une fonction d'une classe et pas une fonction "libre" (fonction n'appartenant à aucune classe), c'est, normalement, que vous prévoyez que l'affichage d'un "Soundtrack" soit différent en fonction du type d'élément que vous voulez afficher.
Je suis pas sûr que vous voulez vraiment faire un affichage "variable", différent entre "Serie" et "Cinema", mais si c'est le cas, en faire une fonction d'une classe est pertinent.

Donc, on va dire que c'est pertinent.

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
 
// const int /*pas de valeur de retour car exceptions en C++ suffise => void*/
// Cinema::afficher_Soundtrack(
/*std::wstring& s, ce paramètre ne sert à rien sauf envoyer une erreur si c'est pas égale à "Soundtrack.txt" donc on dégage et on utilise une valeur en dur, qu'on rendra paramétrable plus tard, après refactoring*/
/*std::wstring const& nomFichier fait doublon avec le paramètre "s", on dégage)*/
 
void Cinema::afficher_Soundtrack(){
 
    // utiliser les fonctions plus générique ("de plus bas niveau") pour avoir un code simple pour les fonction de plus "haut" niveau
    // Il y a peut-être un peu de customisation pour gérer les "rôles" mais rien d'insurmontable
    std::vector<std::pair<std::wstring,std::wstring>> clevaleurs = lire_paireCleValeur_depuisFichierTxt(L"Soundtrack.txt");
 
    Console::PrintStringW(Console::Ponctuation_Color + L"Soundtrack :" + Console::End_Ln );
 
    for (const auto& [cle,valeur] : clevaleurs ) {
        Console::affiche_CleValeur(L"\t" + cle, valeur) ;
   }
}
{

Pour "afficher_Avec", c'est une fonction libre => pas de customisation en fonction du type ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void afficher_Avec()
{
    std::vector<std::pair<std::wstring,std::wstring>> clevaleurs = lire_paireCleValeur_depuisFichierTxt(L"Avec.txt");
 
    Console::PrintStringW(Console::Ponctuation_Color + L"Avec :" + Console::End_Ln );
 
    bool first = true;
 
    for (const auto& [cle,valeur] : clevaleurs ) {
        if(!first)
        {
            Console::PrintStringW(Console::Ponctuation_Color + L", ") ;
        }
        Console::PrintStringW(Console::Default_Color + cle + Console::Text_Color + L" ( " + Console::Default_Color + valeur + Console::Text_Color + L" )") ;
        first = false;
    }
    Console::PrintStringW(Console::End_Ln + Console::Default_Color);
}

C'est normal qu'il n'y ait rien en face de Christina Ricci. Et les ... à la fin, on les laisse comme ça.

Le format du fichier a changé entre votre premier message et le dernier, avant , il n'y avait pas de " :" sur la même ligne.
Il faut avoir un format bien spécifié pour que le code de lecture reste simple.
Si vous spécifié correctement le format et qu'il reste assez commun à plein de fichiers, vous pourrez utiliser peu de code pour gérer tous les cas.

Avec.txt
-------------
Prénom Nom : Role
Prénom Nom2 :
Prénom Nom3
: Role2
…

Si je comprend bien, on peut avoir un "Prénom Nom" sans valeur après le ":", donc sans rôle (ligne 2) et on peut avoir les clé/valeur sur 2 lignes différentes (ligne3 et 4).

C'est juste quelques ligne à ajouter à la fonction "lire_paireCleValeur_depuisFichierTxt" pour gérer ces cas pour tous les fichiers qui seront lus via cette fonction.

Le but général, c'est de construire un ensemble assez restreint de fonction de bas niveau qui soient assez polyvalents pour s'adapter à différent besoins : le cas des fonctions "lire_xxxxFichier" ou "Console:

rintStringW", par exemple.
Puis, de ce servir ces fonctions simples polyvalentes pour construire simplement les fonctions de plus haut niveau : affiche_xxxx.

Pouvez-vous essayer d'implémenter "lire_paireCleValeur_depuisFichierTxt" qui s'adapte au format du dernier "Avec.txt" que vous avez posté ?

**Laurent_B_** · 12/12/2022, 14h22

Bonjour bacelar,

Comment faire : exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
const int Serie::afficher_OK()
{ // OK !
/* Blablabla */
 
/* Ici :
    PrintCreee_par(creee_par);
ou
    Console:: PrintCreee_par(creee_par);
*/
 
/* Blablabla */
}

Merci beaucoup

**bacelar** · 12/12/2022, 15h29

Comme je vous l'ai déjà dit, commencez par nommer "correctement" vos fonctions.

"afficher_OK" n'affiche pas "OK" et vous ne voulez pas afficher "OK".

Vous voulez vraisemblablement afficher dans le console les informations sur la série.
On va dire qu'il n'y aura des affichages que sur la console, donc, la fonction devrait se nommer "afficher".
(Dans l'absolu, on n'aime pas associer des objets "métier" à la manière de les exposer à l'utilisateur, histoire de na pas avoir à tout refaire quand on passe d'une application console à une application graphique ou d'une librairie graphique à une autre, mais là, on va faire "sale").

En se basant sur la copie d'écran du message "05/12/2022, 20h55" :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
const int Serie::afficher()
{
    afficher_Titres();
    afficher_ChaineOrigine();
    afficher_Genres();
    afficher_Creee_par();
    afficher_Distribution();
    afficher_Nationalite();
    afficher_Image();
    afficher_Synopsis();
    afficher_AvecRoles();
    afficher_Saisons();
}

**Laurent_B_** · 13/12/2022, 17h11

Bonjour,

Ici : Pièce jointe 630662
Trop difficile !

Merci d'avance !

**Laurent_B_** · 14/12/2022, 15h26

Bonjour,

Pas-ça-pas ! Ok ?

Exemple : AD.txt ===> Audiodescription

/* ou ici */afficher_AD(/* ou ici */)
/* ou ici */PrintAD(/* ou ici */)
std::wstring ad;

Ok ou pas ?

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
class Titre
{
public:
	Titre(void);
	~Titre();
        /* ou ici */
protected:
       /* ou ici */
private:
      /* ou ici */
};
 
class Titre;
class Serie
{
	friend class Titre;
public:
	Serie(void);
	~Serie();
        /* ou ici */
protected:
        /* ou ici */
private:
        /* ou ici */
};
 
class Titre;
class Cinema
{
	friend class Titre;
public:
	Cinema(void);
	~Cinema();
        /* ou ici */
protected:
        /* ou ici */
private:
        /* ou ici */
};

Mais :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
const void afficher_AD(std::wstring& a_filename, std::wstring const& nomFichier, std::wstring& ad)
{
    assert((a_filename == createdBy_filename) && L"Erreur !!! AD... !");
    std::wstring a = lire_fichierTxt(nomFichier);
    std::size_t pos;
    pos = a.find(L"Audiodescription");
    if (pos == std::wstring::npos)
        ;
    else
        a = a.substr(0, pos - 3);
    if (std::find(::AD.begin(), ::AD.end(), a) != ::AD.end())
        ad = a;
    assert((ad.size() != 0));
}
/* --- */
void PrintAD(const std::wstring& ad, std::wstring& titre_T, std::wstring& titre_t)
{
    if (ad.size() > 0)
    {
        std::wstring ad_str = titre_T + L"AD : " + titre_t + ad + L"\r\n";
        //PrintStringW(m_hOut, creee_par_str, 0);
        //PrintStringW(HANDLE hOut, creee_par_str);
        int i = Console_Lire_txt(ad_str, 0, 0);
    }
}

Merci d'avance

**Laurent_B_** · 16/12/2022, 21h10

Bonsoir,

Moi : pas-à-pas, petit-à-petit !
Vous : problème et solution ?

Console : Plus tard !

Merci beaucoup

**Laurent_B_** · 19/12/2022, 19h44

Bonsoir Bacelar,

Comment faire ?

(console.h et console.cpp : 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
const void Console::PrintCreee_par(const std::vector<std::wstring>& creee_par, std::wstring titre_T, std::wstring titre_t, bool cree_par_)
{
    if (cree_par_ == true && creee_par.size() > 0)
    {
        std::wstring creee_par_str = titre_T + L"Créée" + ((creee_par.size() > 1) ? L"s" : L"") + L" par : " + titre_t;
        bool first = true;
        for (auto&& c : creee_par)
        {
            if (!first)
            {
                creee_par_str += titre_T + L", " + titre_t;
            }
            creee_par_str += c;
            first = false;
        }
        creee_par_str += L"\r\n";
 
        PrintStringW(m_hOut, creee_par_str);
    }
}
 
void Console::PrintStringW(HANDLE hOut, const std::wstring& str)
{
    DWORD dwMode = 0;
 
    BOOL res = WriteFile(
        hOut,
        &str[0],
        (DWORD)(str.size() * sizeof(wchar_t)),
        &dwMode,
        NULL);
    assert(res == TRUE);
}

Merci pour l''aide

**bacelar** · 23/12/2022, 00h08

Désolé pour le délai de réponse,

Je n'ai pas la chaîne de compilation MSVC en version 143 sous la main et j'ai pas réussi à trouver un endroit où facilement l'installer.

Ce n'est pas que je ne veux pas faire un refactoring complet de votre code mais c'est plus un problème de "logistique".

Mais faire les choses pas à pas, c'est peut-être plus "formateur" pour vous.

Mais avec toutes les sources, ça sera plus simple pour vous aiguiller.

Pas-ça-pas ! Ok ?

Ok pour moi.

Avant tout refactoring, il faut que le programme compile.
C'est OK ?

Est-ce que le programme fonctionne dans le cas "nominal" ("normal", pas encore de gestion d'erreur) ?
C'est OK ?
Sinon, c'est quoi les problèmes "bloquant" dans le cas "nominal" ?
S'il y a des problèmes non-bloquant, en faire une liste exhaustive, cela permet d'axer le refactoring pour les résoudre ou simplifier leur résolution.

La gestion des cas "non nominaux", ça sera pour les refactoring suivants.

Une fois qu'on a un résumé du point de départ (compilable ? listes problèmes bloquants sur scénario nominal ? listes des problèmes non-bloquants sur scénario nominal ?):
On commence par faire "à l'arrache" les corrections pour :
- rendre le machin compilable
- "résoudre" les problèmes bloquants sur scénario nominal

Je dis bien "à l'arrache", le plus vite et court possible.

Si on n'en est pas encore là, faut arrêter le refactoring et "corriger" ces problèmes AVANT.

Après, on jette un coup d’œil au machin dans son ensemble.

Là, avec le code que vous nous avez fourni, je trouve qu'il y a beaucoup beaucoup de code pour ce que cela doit faire.

Il y a "beaucoup" de classes donc l'utilité n'est pas évidente juste avec leur nom, et le nom des fichiers doivent, dans la mesure du possible, correspondre aux classes qu'ils "contiennent/définissent".
La classe Erreur est définie dans les fichiers "erreur_ok.h/.cpp", pourquoi pas dans les fichiers "Erreur.h/.cpp" ?
Renommer des fichiers, c'est assez facile de maintenir le projet compilable et fonctionnel, Visual Studio devrait faire la majorité du travail (modification des fichiers solution et projet ainsi que des #include des fichiers renommés).

C'est quoi l'utilité (fonctionnalités implémentées) d'une classe comme "Bug" ou "Erreur" ? (Le nom d'une classe, c'est très important)
Quand on s'essaye à la programmation objet, il est assez formateur d'essayer de faire un diagramme de classes sur son projet.

En voici un fait à l'arrache sur ce que j'ai compris de objectif de votre projet :
Pièce jointe 631235

Nom : Pour AVC9.png
Affichages : 264
Taille : 25,6 Ko

Nom : Pour AVC9.png
Affichages : 264
Taille : 25,6 Ko

Pouvez-vous en faire autant avec les classes de votre projet actuel ?
J'ai pas l'impression que vos classes aient des rôles clairs.
C'est l'objectif d'un diagramme de classes d'expliciter le rôle de chaque classe l'une par rapport aux autres.

Comme je l'ai déjà indiqué, je pense que tout ce qui est dans les classes "Bug" et "Erreur" ne servent à rien.
Comme le dit l'adage "moins de code, moins de bug", il ne faut pas garder du code qui ne sert à rien.
Ce que je comprends de ces classes, c'est pour afficher des messages d'erreurs sur la console, ce que vous ne devez pas faire, car la console est l'interface utilisateur de votre programme. Elle ne doit pas être polluée par des traces d'exécution.

Je ne vois aucune utilisation de la classe Erreur.

L'utilisation que je vois de la classe Bug, c'est dans du code du type :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#if	Cinema_afficher_Note_ == 1
	//wcout << B_T << L"const int Cinema::afficher_Note(" << N << L", wstring _T) :" << B_t << endl;
	B.Ok_T(L"const int Cinema::afficher_Note(" + n + L", " + nomFichier + L") :");
#endif
	if (n == L"")
	{
		note = -100;
#if	Cinema_afficher_Note_ == 1
		B.Ok_W(L"Note={" + std::to_wstring(note) + L'}');
		//wcout << B_T << L"const int Cinema::afficher_Note(" << N << L", wstring _T) : Ok !" << B_t << endl;
#endif

C'est clairement du "code de trace".
Ce code est, pour moi, totalement inutile et rend le "vrai" code beaucoup moins lisible.

A votre place, je supprimerai tout le code de ce type et donc les classes Bug et Erreur.
Si vous n'êtes pas confiant, vous pouvez mettre ce type de code en commentaire pour voir qu'il ne sert qu'à obscurcir le code.

Même si les fichiers Bug.h/.cpp et erreur_ok.h/.cpp devrait disparaître, on peut faire des remarques dessus, car je pense qu'elles s'appliqueront aux autres fichiers.

Vous incluez beaucoup beaucoup trop de .h dans "Bug.h" et "erreur_ok.h". On inclut dans le .h que les fichiers nécessaire à la compréhension par le compilateur que ce qui est nécessaire à la déclaration de la classe, pas à son implémentation.
La palanqué de #define dans ces fichiers ne sera plus nécessaire car elles ne sont là que pour allumer/éteindre des traces, totalement inutile.

On n'utilise JAMAIS de "using namespace" dans un .h, à l'extérieur de la déclaration de la classe.
Et c'est rarement le cas ailleurs.

le '#include "pch.h"', ce n'est à faire que dans le .cpp, pas dans le .h.
Il vaut mieux inclure le "<windows.h>" avant les autres #include (à l'exception de "pch.h" dans le .cpp).

Code :

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

externe int Y;

On dégage ce genre de cochonnerie, c'est une variable globale.
Si ça fait péter la "compilation/édition de lien" du code de supprimer cette horreur, c'est que c'est du code bogué, à changer dans les plus brefs délais.

Code :

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

extern const int Console_Lire_txt(std::wstring, int, int);

"Console_Lire_txt" putain de fonction avec un nom qui n'a rien à voir avec ce qu'elle fait vraiment.
Pourquoi faire une déclaration anticipée de cette cochonnerie ?
Et encore plus, pourquoi la déclarer "extern" ???
ON DÉGAGE !!!

Dans le "Bug.cpp", le nombre d'include dans un .cpp est très souvent plus important que dans un .h, mais vérifiez que vous avez vraiment besoin de tout cela pour l'implémentation de la classe.
Idem pour "externe int Y;", "extern const int Console_Lire_txt(std::wstring, int, int);" et "extern const void Console_Lire_txt(std::wstring);", ON DÉGAGE !!!
"Erreur E;", idem, on dégage les variables globales !!!

Dans vos .h et vos .cpp, vous incluez un peu tout et n'importe quoi.
Si vous regardez mon diagramme de classes, j'ai séparé le diagramme en 2 couches : Couche Technique et Couche métier.
La couche métier utilise les services de la couche technique (sauf la cas de la classe de Création des Machin, mais c'est un peu spécial, on reviendra après).
Donc, les fichiers de la couche peuvent inclurent des fichiers de la couche technique mais les fichiers de la couche technique ne devraient pas inclurent de fichier de la couche métier.
Bug et Error, si c'est des classes qui devraient exister, ça serait des classes techniques, donc n’incluant pas "Cinema.h" ou "Serie.h".

Vous devriez appliquer les mêmes actions sur les autres fichiers (suppression des #define de traces, les variables globales, etc...).

Je ne vois pas les services offerts par la classe "Titre", elle sert à quoi cette classe.

Juste avec ces actions, le code serait largement plus clair.

Exemple : AD.txt ===> Audiodescription

/* ou ici */afficher_AD(/* ou ici */)
/* ou ici */PrintAD(/* ou ici */)
std::wstring ad;

Ok ou pas ?

"AD" pour Audiodescription ?
Vous devriez prendre la peine d'écrire "AudioDescription" ou "AudioDesc" dans le code, à la place de "AD", pour la lisibilité.

Vous avez tendance à mettre un peu tout et n'importe quoi dans Titre.h/.cpp.
Il y a plein de fonctions libres (non associées à une classe) qui n'ont rien a voir avec la classe Titre.
Je vous conseille de migrer ces fonctions libres qui n'ont aucun rapport avec la classe Titre vers une paire de fichier "Utils.h/.cpp" comme fourre-tout (qu'on remaniera après).

Dans Titre.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
// ######################################################################################################################################################
// #                                                                                                                                                    #
// # PrintAD                                                                                                                                            #
// # const void PrintAD(const std::vector<std::wstring>&creee_par)                                                                        #
// #                                                                                                                                                    #
// ######################################################################################################################################################

void PrintAD(const std::wstring& ad, std::wstring& titre_T, std::wstring& titre_t)
{
    if (ad.size() > 0)
    {
        std::wstring ad_str = titre_T + L"AD : " + titre_t + ad + L"\r\n";
        //PrintStringW(m_hOut, creee_par_str, 0);
        //PrintStringW(HANDLE hOut, creee_par_str);
        int i = Console_Lire_txt(ad_str, 0, 0);
    }
}

C'est une fonction libre qui n'a aucun rapport, il me semble avec la classe Titre, donc à transférer dans Utils.h/.cpp.

En rouge les traces d'un copier-coller mal fait.
Si faites des cartouches (blocs de commentaire avant la fonction), maintenez le à jour.
Mais, franchement, avec les IDE actuels, c'est une perte de temps tant que vous n'utilisez pas d'outils de génération automatique de documentation (on n'y est pas encore).

Elle utilise "Console_Lire_txt" qui fait à peu pré tout sauf ce qui est indiqué par son nom.
Évitez de vous en servir et utiliser un truc beaucoup plus simple pour commencer :
(à mettre dans Utils.h/Utils.cpp par exemple)

Code :

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

1
2
3
4
void PrintTmp(const std::wstring& text)
{
   std::wcout << text;
}

Vous verrez que vous pourrez facilement remplacer cette cochonnerie de "Console_Lire_txt" par quelques fonctions à peu plus compliquées que "PrintTmp".
"PrintTmp" ne gère pas encore les problèmes d'encodage, etc... mais on pourra le faire sans faire une usine à gaz comme "Console_Lire_txt".

"PrintTmp" est là pour court-circuiter le plus possible "Console_Lire_txt".

"PrintAD" est appelé depuis "Serie::afficher_OK" et "Cinema::afficher_OK" avec du code proche de :

Code :

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

1
2
3
4
5
6
7
const int Cinema::afficher_OK()
{ // OK !
...
	// Audiodescription
	if (ad_ == true)
		PrintAD(ad, C_T, C_t);
.....

Quand on voit l'appel et le code de "PrintAD", on se rend compte que c'est juste l'affichage d'une paire de valeurs (key : value) dans potentiellement 2 couleurs différentes.

Au lieu d'avoir une fonction "PrintAD" avec des types et des noms de paramètre complètement contre-intuitif, et potentiellement avec un code qui sera identique à plein de bout de code, il est plus avantageux de créer une fonction "utilitaire" capable d'afficher une paire de valeur (key : value), qu'on mettra aussi, pour l'instant, dans Utils.h/.cpp.

Code :

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

1
2
3
4
void PrintKeyValue(const std::wstring& keyColor, const std::wstring& keyText, const std::wstring& valueColor, const std::wstring& valueText, const std::wstring& separator = L" : ")
{
   PrintTmp(keyColor + keyText + separator + valueColor + valueText);
}

Juste avec ces 2 fonctions utilitaires "PrintKeyValue" et "PrintTmp", le reste du code sera beaucoup beaucoup plus simple.
Le fait que le type des paramètre "keyColor" et "valueColor" soit "const std::wstring&", c'est pas top mais on corrigera plus tard.

Si la manière d'afficher l'audio description ne change pas entre "Cinema" et "Serie", vous pouvez faire de "PrintAD" (=> "PrintAudioDesc") aussi une fonction libre utilitaire à mettre dans Utils.h/.cpp.

Mais il semble que vous avez décidé de changer la couleur des affichages en fonction du type de Media (un bon nom à la place de "Machin" dans mon diagramme de classe).
Il serait donc plus judicieux de faire 2 fonctions "PrintAudioDesc" différentes, l'une dans la classe "Cinema" l'autre dans la classe "Serie". (Il serait facile de les fusionner mais cela sera pour plus tard.)

Dans Cinema.cpp (je vous laisse essayer de deviner les petites modifications dans Cinema.h):

Code :

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

1
2
3
4
5
6
7
8
 
void Cinema::PrintAudioDesc()
{
    if (m_AudioDesc.size() > 0)
    {
        PrintKeyValue (c_keyColor, "AD", c_valueColor, m_AudioDesc);
    }
}

idem pour Serie

Code :

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

1
2
3
4
5
6
7
8
 
void Serie::PrintAudioDesc()
{
    if (m_AudioDesc.size() > 0)
    {
        PrintKeyValue (c_keyColor, "AD", c_valueColor, m_AudioDesc);
    }
}

Vous voyez qu'au lieu de passer des valeurs via les paramètres, on utilise des champs (membres) de la classe pour simplifier le code : m_AudioDesc, ainsi que des constantes : c_keyColor et c_valueColor.
Il faut juste correctement initialiser les champs de l'objet au moment de sa construction.

Il faudra remplacer le code "PrintAD(ad, C_T, C_t);" dans la fonction "afficher_OK" par "PrintAudioDesc();"

Faudrait quand même renommer les fonctions "afficher_OK" en quelque-chose de plus "logique".
Si ça affiche, pourquoi ne pas la nommer "afficher" ?

Pour les fonctions "afficher_AD", il y en a 2, une fonction libre, l'autre fonction membre de la classe Titre.
Quel rapport entre un Titre et l'Audio Description ?
Pour moi, il n'y en n'a pas, donc cela n'a pas à être une fonction membre de Titre mais de Cinema ou de Serie, voire une fonction libre en lui donnant plus de paramètre pour compenser le manque de champs d'une fonction libre.
Mais bon, juste avant, on n'a déjà créé des fonctions membre "PrintAudioDesc" qui font le travail en 3 lignes.

En plus le code de "Titre::afficher_AD" n'affiche absolument rien de pertinent. C'est plus une fonction de lecture de fichier et pas une fonction d'affichage.
A la rigueur, vous pouvez convertir "Titre::afficher_AD" en une fonction libre dans Utils.h/.cpp avec un nom type "LoadDataFromFile".
Vous pouvez facilement supprimer tout lien avec "AudioDescription" et en faire une fonction utile pour le chargement de donner (initialisation des champs des classes Cinema et Serie).
C'est le même problème avec la version fonction libre de afficher_AD.

Un exemple d'implémentation de LoadDataFromFile

Code :

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

1
2
3
4
5
6
7
8
9
10
11
std::wstring LoadDataFromFile(std::wstring const& nomFichier, std::wstring const& tag)
{
    std::wstring data = lire_fichierTxt(nomFichier);
 
    std::size_t pos;
    pos = data.find(tag);
    if (pos != std::wstring::npos)
        data = data .substr(0, pos - 3);
 
   return data;
}

Pour récupérer les données comme le ferait "Titre::afficher_AD", il suffit de faire l'appel suivant:

Code :

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

1
2
 
std::wstring data = LoadDataFromFile(L"AD.txt",L"Audiodescription");

Il faudrait bien séparer 2 étapes.
La première, lors de la construction des objetsde type Cinema et Serie, où leur constructeur seront en charge d'appeler "LoadDataFromFile" sur les différents fichiers contenant les informations, pour initialiser les champs de ces objets.
Le seconde "étape", c'est qu'une fois construits, ces objets peuvent s'afficher dans la console avec uniquement les données stockées dans leur champs, sans faire appel à aucun fichier.

Bonsoir Bacelar,

Comment faire ?

(console.h et console.cpp : ok !)

Pour l'instant, une fonction comme "PrintTmp" expliquée plus haut, devrait faire le taf dans la très grande majorité des cas.

**Laurent_B_** · 24/12/2022, 14h08

Avant tout refactoring, il faut que le programme compile.
C'est OK ?

Oui : Microsoft Visual Studio Community*2022 (Version 17.4.3) ===> Analyser

Est-ce que le programme fonctionne dans le cas "nominal" ("normal", pas encore de gestion d'erreur) ?
C'est OK ?

Oui, ok !

Il y a "beaucoup" de classes donc l'utilité n'est pas évidente juste avec leur nom, et le nom des fichiers doivent, dans la mesure du possible, correspondre aux classes qu'ils "contiennent/définissent".
La classe Erreur est définie dans les fichiers "erreur_ok.h/.cpp", pourquoi pas dans les fichiers "Erreur.h/.cpp" ?
Renommer des fichiers, c'est assez facile de maintenir le projet compilable et fonctionnel, Visual Studio devrait faire la majorité du travail (modification des fichiers solution et projet ainsi que des #include des fichiers renommés).

Ok !

On n'utilise JAMAIS de "using namespace" dans un .h, à l'extérieur de la déclaration de la classe.
Et c'est rarement le cas ailleurs.

le '#include "pch.h"', ce n'est à faire que dans le .cpp, pas dans le .h.
Il vaut mieux inclure le "<windows.h>" avant les autres #include (à l'exception de "pch.h" dans le .cpp).

Ok !

Ok ou pas ?
"AD" pour Audiodescription ?
Vous devriez prendre la peine d'écrire "AudioDescription" ou "AudioDesc" dans le code, à la place de "AD", pour la lisibilité.

Vous avez tendance à mettre un peu tout et n'importe quoi dans Titre.h/.cpp.
Il y a plein de fonctions libres (non associées à une classe) qui n'ont rien a voir avec la classe Titre.
Je vous conseille de migrer ces fonctions libres qui n'ont aucun rapport avec la classe Titre vers une paire de fichier "Utils.h/.cpp" comme fourre-tout (qu'on remaniera après).

Ok !

Fatigué !!!

Merci d'avance

Problème et AVC : _wfopen_s

C++

Discussions similaires

Partager

Partager