Problème et AVC : _wfopen_s

Oui, mais avec une copie d'écran, on pourra voir ce qui manque pour ce que vous puissiez utiliser un débogueur sur un projet qui compile.

Citation:

---

cinema.cpp
D:\Work\Prg\CPP\You\cinema.cpp(1263,18): error C4996: 'std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.33.31629\include\codecvt(440,1): message : voir la déclaration de 'std::codecvt_utf8_utf16'
D:\Work\Prg\CPP\You\cinema.cpp(1263,2): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.33.31629\include\xlocbuf(302,1): message : voir la déclaration de 'std::wstring_convert'
D:\Work\Prg\CPP\You\cinema.cpp(1263): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::__autoclassinit2': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
D:\Work\Prg\CPP\You\cinema.cpp(1263,56): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::wstring_convert': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
D:\Work\Prg\CPP\You\cinema.cpp(1265,19): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::from_bytes': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
erreur_ok.cpp
ok_txt.cpp
D:\Work\Prg\CPP\You\ok_txt.cpp(77,21): error C4996: 'std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.33.31629\include\codecvt(440,1): message : voir la déclaration de 'std::codecvt_utf8_utf16'
D:\Work\Prg\CPP\You\ok_txt.cpp(77,5): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.33.31629\include\xlocbuf(302,1): message : voir la déclaration de 'std::wstring_convert'
D:\Work\Prg\CPP\You\ok_txt.cpp(77): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::__autoclassinit2': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
D:\Work\Prg\CPP\You\ok_txt.cpp(77,59): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::wstring_convert': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
D:\Work\Prg\CPP\You\ok_txt.cpp(78,24): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::from_bytes': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
D:\Work\Prg\CPP\You\ok_txt.cpp(113,21): error C4996: 'std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.33.31629\include\codecvt(440,1): message : voir la déclaration de 'std::codecvt_utf8_utf16'
D:\Work\Prg\CPP\You\ok_txt.cpp(113,5): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.33.31629\include\xlocbuf(302,1): message : voir la déclaration de 'std::wstring_convert'
D:\Work\Prg\CPP\You\ok_txt.cpp(113): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::__autoclassinit2': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
D:\Work\Prg\CPP\You\ok_txt.cpp(113,59): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::wstring_convert': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
D:\Work\Prg\CPP\You\ok_txt.cpp(114,24): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::from_bytes': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
D:\Work\Prg\CPP\You\ok_txt.cpp(698,21): error C4996: 'std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.33.31629\include\codecvt(440,1): message : voir la déclaration de 'std::codecvt_utf8_utf16'
D:\Work\Prg\CPP\You\ok_txt.cpp(698,5): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.33.31629\include\xlocbuf(302,1): message : voir la déclaration de 'std::wstring_convert'
D:\Work\Prg\CPP\You\ok_txt.cpp(698): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::__autoclassinit2': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
D:\Work\Prg\CPP\You\ok_txt.cpp(698,50): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::wstring_convert': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
D:\Work\Prg\CPP\You\ok_txt.cpp(701,38): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::to_bytes': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
D:\Work\Prg\CPP\You\ok_txt.cpp(703,40): error C4996: 'std::wstring_convert<std::codecvt_utf8_utf16<wchar_t,1114111,(std::codecvt_mode)0>,wchar_t,std::allocator<wchar_t>,std::allocator<char>>::from_bytes': warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality; consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
serie.cpp
you_txt.cpp
Génération de code en cours...

---

???

Citation:

---

warning STL4017: std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. (The std::codecvt class template is NOT deprecated.) The C++ Standard doesn't provide equivalent non-deprecated functionality.

---

Oh les connards. Ils ont carrément retiré des fonctionnalités du C++ sans donner d'équivalent.

Le plus simple pour faire taire le compilo est de rajouter #define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING avant tes includes, mais j'ignore si "faire taire le compilo" est l'action appropriée ici.

Ok, ce que vous avez posté, c'est les traces de compilations, et c'est bien.
On sait que "cinema.cpp" et "ok_txt.cpp" contiennent des "warnings", potentielles erreurs mais qui ne bloquent pas la compilation (on verra ça après).
On sait que "erreur_ok.cpp", "serie.cpp" et "you_txt.cpp" compilent sans problème.

Citation:

---

Génération de code en cours...

---

Il n'a pas encore terminé la compilation ou il fait l'édition de lien.

Il n'y a pas un message après qui indique que tout c'est bien fini ?

Si toute la compilation/édition de lien c'est bien fini, cela a créé un .exe.

Je donne une copie d'écran sur un vieux Visual Studio :
Pièce jointe 626871
Cerclé en rouge, le bouton dans la bare de commande pour lancer le débogueur attaché à l'exécutable généré par le projet de démarrage actuel.
Cerclée en vert, l'entré de menu pour lancer le débogueur attaché ...
le raccourci clavier "F5", cerclé en vert dans l'entré de menu cerclée en vert du menu "Déboguer", indique que vous pouvez lancer le débogueur juste en appuyant sur la touche "F5" du clavier.

Les cercles bleu qui entourent les points rouges indiquent les points d'arrêt actifs pour que le déboguer si arrêt.
Vous pouvez cliquer dans la colonne verticale grise pour y ajouter un point d'arrêt. (cliquez sur le point rouge pour supprimer le point d'arrêt)

EDIT :

Citation:

---

Envoyé par Médinoc

Oh les connards. Ils ont carrément retiré des fonctionnalités du C++ sans donner d'équivalent.

Le plus simple pour faire taire le compilo est de rajouter #define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING avant tes includes, mais j'ignore si "faire taire le compilo" est l'action appropriée ici.

---

Ouais, bof, c'est le genre de décision qu'on prend au niveau du projet en entier :
Pièce jointe 626873

Citation:

---

Ok, ce que vous avez posté, c'est les traces de compilations, et c'est bien.
On sait que "cinema.cpp" et "ok_txt.cpp" contiennent des "warnings", potentielles erreurs mais qui ne bloquent pas la compilation (on verra ça après).
On sait que "erreur_ok.cpp", "serie.cpp" et "you_txt.cpp" compilent sans problème.

Génération de code en cours...
Il n'a pas encore terminé la compilation ou il fait l'édition de lien.

Il n'y a pas un message après qui indique que tout c'est bien fini ?

Si toute la compilation/édition de lien c'est bien fini, cela a créé un .exe.

Je donne une copie d'écran sur un vieux Visual Studio :

---

Ok, merci beaucoup ;)

Mais :

Code:

---

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

wstring utf8_to_utf16(const string& utf8) { vector<unsigned long> unicode; size_t i = 0; while (i < utf8.size()) { unsigned long uni; size_t todo; bool error = false; unsigned char ch = utf8[i++]; if (ch <= 0x7F) { uni = ch; todo = 0; } else if (ch <= 0xBF) { throw logic_error("not a UTF-8 string"); } else if (ch <= 0xDF) { uni = ch & 0x1F; todo = 1; } else if (ch <= 0xEF) { uni = ch & 0x0F; todo = 2; } else if (ch <= 0xF7) { uni = ch & 0x07; todo = 3; } else { throw logic_error("not a UTF-8 string"); } for (size_t j = 0; j < todo; ++j) { if (i == utf8.size()) throw logic_error("not a UTF-8 string"); unsigned char ch = utf8[i++]; if (ch < 0x80 || ch > 0xBF) throw logic_error("not a UTF-8 string"); uni <<= 6; uni += ch & 0x3F; } if (uni >= 0xD800 && uni <= 0xDFFF) throw logic_error("not a UTF-8 string"); if (uni > 0x10FFFF) throw logic_error("not a UTF-8 string"); unicode.push_back(uni); } wstring utf16; for (size_t i = 0; i < unicode.size(); ++i) { unsigned long uni = unicode[i]; if (uni <= 0xFFFF) { utf16 += (wchar_t)uni; } else { uni -= 0x10000; utf16 += (wchar_t)((uni >> 10) + 0xD800); utf16 += (wchar_t)((uni & 0x3FF) + 0xDC00); } } return utf16; }

---

Code:

---

1 2	wstring_convert<codecvt_utf8_utf16<wchar_t>, wchar_t> convert; wstring P = convert.from_bytes(lignes);

---

Pas évident !

Le premier code est l'implémentation d'une fonction "wstring utf8_to_utf16(const string& utf8)", qui porte pour une fois un nom correct.
C'est une fonction qui convertie une chaîne de caractère encodée en UTF-8 vers une chaîne de caractère encodé en UTF-16.

L'implémentation de la fonction me semble correcte, mais c'est le genre de code que j'essaye d'éviter et de voir si la STL la fournit "clé en main".
Et je pense que c'est ce que fait la classe "codecvt_utf8_utf16".

Donc, le second code est donc un appel à une implémentation de la STL d'un convertisseur UTF-8=>UTF-16, sans avoir à utiliser une méthode comme "wstring utf8_to_utf16(const string& utf8)".

Citation:

---

L'implémentation de la fonction me semble correcte, mais c'est le genre de code que j'essaye d'éviter et de voir si la STL la fournit "clé en main".
Et je pense que c'est ce que fait la classe "codecvt_utf8_utf16".

---

Que faire ?
Merci d'avange ;)

Ne pas se servir de "utf8_to_utf16" mais de "codecvt_utf8_utf16" à la place.

Bonjour à tous,

Goto : J'ai cherche mais pas de solution ! S'il te plait ?

Citation:

---

const int Console_Lire_txt(wstring Textes, int y1, int y2)

---

Code:

---

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) { #if Console_Lire_txt_OK_ == 1 wcout << L"const int Console_Lire_txt(" << Textes << L", " << y1 << L", " << y2 << 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() : Ok !" << endl; #endif return EXIT_SUCCESS; }

---

Merci pour tout !

Code très difficile à lire, très proche du C archaïque (variables créées beaucoup trop top, non utilisation des structures de codage récentes plus explicites (rage-loop, etc ...), utilisation de gotos, etc...)
Il est, même pour du C old-school, très mal écrit, car le nommage des variables et leur "recyclage" sont abscons. Et c'est sans compter les champs ou globales qui sont utilisés à l'arrache pour faire de l'effet de bord imbitable (Y et consort).

Comme d'habitude, le nom de la fonction ne reflète en rien ce qu'elle fait.

Cette fonction fait, vraisemblablement, de l'affichage d'un texte "formaté" dans une console "Windows" (non VTxxx).
Mais le nombre de séquence d'échappement géré est rachitique, l'implémentation, avec des noms de variable débilement courts, invérifiable, etc...

Dans cette files de messages, quelqu'un avait mis un lien vers l'infrastructure Windows qui permet d'émuler des console VTxxx, utilisez cela au lieu de ré-implémenter une ignoble roue carrée.

Donc, si vous le pouvez, n'utiliser pas cette horreur mais l'infrastructure d'émulation des VTxxx sous Windows.

Si vous voulez vraiment comment ce machin fonction, utilisez le débogueur en mode "pas à pas" pour dérouler ce que ce cauchemar fait. Mais il y a fort à parier que c'est truffé de bugs.

Merci ;)

Citation:

---

Donc, si vous le pouvez, n'utiliser pas cette horreur mais l'infrastructure d'émulation des VTxxx sous Windows.

---

Ok ! Ou est t'il ? https:\\...

Merci d'avance ;)

Citation:

---

Envoyé par Médinoc

Il me semble qu'il y a eu des améliorations de la console pour apporter le support des séquences d'échappement, mais je n'ai plus les détails.
Cette série d'articles en anglais peut aider:
https://devblogs.microsoft.com/comma...onsole-conpty/

---

Ok !

https://devblogs-microsoft-com.translate.goog/commandline/windows-command-line-introducing-the-windows-pseudo-console-conpty/?_x_tr_sl=en&_x_tr_tl=fr&_x_tr_hl=fr&_x_tr_pto=sc

Ok !

https://insider-windows-com.translat...r&_x_tr_pto=sc

Que faire ?

Merci d’avance ;)

Utiliser l'API "ConPTY" plutôt que l'API Console "de base" (wout et consort).

Si votre environnement de développement est à jour (Windows SDK, etc...), c'est juste utiliser des WriteFie à la place des wout. (après avoir appelé les primitives de l'API ConPTY pour correctement se connecter à une "vraie" console").

Ok : Noté "WriteFile" !

Mais :

Visual c++ 2022 -> Projet -> Propriétés de You -> Propriétés de configuration -> Général

et :

you /t s "e:\Séries.[]\The Midnight Club.[2022 Netflix]"

Ou est t'il ?

Merci pour tous ;)

Citation:

---

Mais :
Visual c++ 2022 -> Projet -> Propriétés de You -> Propriétés de configuration -> Général
et :
you /t s "e:\Séries.[]\The Midnight Club.[2022 Netflix]"

Ou est t'il ?

---

Ok ! Terminer !

Citation:

---

Ou est t'il ?

---

De quel "il" parle-t-on ?

Citation:

---

Mais :
Visual c++ 2022 -> Projet -> Propriétés de You -> Propriétés de configuration -> Général

---

Sur mon vieux VS2017 :
Pièce jointe 627353
De quelle option/rubrique (entourées en rouge) parle-t-on ?

Citation:

---

et :
you /t s "e:\Séries.[]\The Midnight Club.[2022 Netflix]"

---

???
Ca a la tête d'une commande pour lancer une session de débogage.

Pour configurer le débogueur avec ce type de commande, faut juste aller à côté du chemin que vous avez signalé dans votre dernier message, au lieu d'aller dans "Général", allez dans "Débogage" (cercle rouge dans l'écran suivant :
Pièce jointe 627354

Normalement, la rubrique "Commande" doit être "$(TargetPath)", ce qui doit convenir à la très grande majorité des cas.
Dans votre projet, cela doit être évalué à un truc comme le chemin vers votre exécutable "you.exe".
Pour que '/t s "e:\Séries.[]\The Midnight Club.[2022 Netflix]"' soit ajouté en tant que paramètre de lancement de votre exécutable, lors de son lancement par le débogueur, je vous conseille de l'ajouter dans la rubrique "Arguments de la commande" (entourée en vert dans l'image précédente).

Pour les ajouter, cliquez sur le menu déroulant de la rubrique (cercle rouge sur l'image de l'écran suivante), puis sur "<Modifier ...>" (cercle rouge sur l'image de l'écran suivante)
Pièce jointe 627355

Puis d'ajouter les arguments de la ligne de commande :
Pièce jointe 627357

Merci pour tous;)

Bonjour,

Code:

---

1 2 3 4 5 6 7 8 9 10 11

HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); DWORD dwMode = 0; CONSOLE_SCREEN_BUFFER_INFO csbiInfo; /* */ wchar_t str[] = L"L'example texte àçéè…\r\n"; WriteFile( hOut /*HANDLE hOut*/, str, wcslen(str), &dwMode /*dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;*/, NULL); /* <=== Attention !!! */

---

Citation:

---

Gravité Code Description Projet Fichier Ligne État de la suppression
Avertissement C4267 'argument'*: conversion de 'size_t' en 'DWORD', perte possible de données You D:\Work\Prg\CPP\You\You.cpp 980

---

et :

Citation:

---

L'example teConst int You_t(int& c, wchar_t**) :

---

Que faire ?

Merci d'avance ;)

Comme vous utilisez des API qui utilisent des chaines de caractère multi-octets (utilisation de la MACRO L, de wchar_t, de wcslen, etc...), je vous conseille d'utiliser systématiquement les versions "W" des primitives de Win32.
Donc, si possible "WriteFileW" à la place de "WriteFile".

Citation:

---

Gravité Code Description Projet Fichier Ligne État de la suppression
Avertissement C4267 'argument'*: conversion de 'size_t' en 'DWORD', perte possible de données You D:\Work\Prg\CPP\You\You.cpp 980

---

Pour les messages d'erreur, préférez prendre les messages directement dans la console de trace d'exécution de la chaîne de compilation que le résumé dans le tableau de synthèse de la compilation (moins précis).

"Avertissement C4267" : C'est un warning/Avertissement, donc, normalement, cela ne bloque pas la génération de l'exécutable, mais c'est toujours bien de les traiter le plus tôt possible.

Je pense que la ligne 980 est "wcslen(str),", et ici, c'est un peu de friction entre votre code qui est en C++ ( wcslen fait partie de la STL du C++) et l'API Win32 de Windows qui est une API C, et non C++.

L'API C "WriteFile" demande un DWORD (type spécifique aux APIs Windows, il me semble) en 3ème paramètre, or, wcslen renvoie un "size_t", type C++ qui peut potentiellement contenir des nombres plus grand que la valeur maximum de DWORD.

Ici, dans votre code, où la chaîne de caractère dans la variable "str" est petite et connue à l'avance, vous pouvez légitimement caster le résultat de wcslen :

Code:

---

1 2 3 4 5 6

WriteFile( hOut /*HANDLE hOut*/, str, (DWORD)wcslen(str), &dwMode /*dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;*/, NULL);

---

Une manière simple de résoudre "définitivement" ce type de problème, c'est de faire un "wrapper" C++ autour des APIs C, pour factoriser le code de "conversion".

Citation:

---

L'example teConst int You_t(int& c, wchar_t**) :

---

Quelle est la question ?
Sinon, on évite les pointeurs nus, "wchar_t*", mais encore plus les pointeurs de pointeurs "wchar_t**", SVP.

Bonsoir,

Citation:

---

Comme vous utilisez des API qui utilisent des chaines de caractère multi-octets (utilisation de la MACRO L, de wchar_t, de wcslen, etc...), je vous conseille d'utiliser systématiquement les versions "W" des primitives de Win32.
Donc, si possible "WriteFileW" à la place de "WriteFile".

---

Pas trouver ! Et, pas solution ! Alors...

Citation:

---

Pour les messages d'erreur, préférez prendre les messages directement dans la console de trace d'exécution de la chaîne de compilation que le résumé dans le tableau de synthèse de la compilation (moins précis).

---

Ou est-il ?

Citation:

---

Une manière simple de résoudre "définitivement" ce type de problème, c'est de faire un "wrapper" C++ autour des APIs C, pour factoriser le code de "conversion".

---

Ou est-il ?

Citation:

---

Citation:

---

L'example teConst int You_t(int& c, wchar_t**) :

---

Quelle est la question ?

---

Oui, ça vrai :

Code:

---

1 2 3 4 5

const int You_t(int& c, wchar_t ** v) { #if You_t_ == 1 B.Ok_T(L"const int You_t(int& c, wchar_t**) :"); #endif

---

Citation:

---

Envoyé par Laurent_B_

Bonsoir,


Pas trouver ! Et, pas solution ! Alors...

---

Oups, je pensais que "WriteFile" était orienté chaîne de caractère, mais c'est orienté "octet", donc pas de "WriteFileW" mais attention au comptage des octets :

Code:

---

1 2 3 4 5 6

WriteFile( hOut /*HANDLE hOut*/, str, wcslen(str)*sizeof(wchar_t), &dwMode /*dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;*/, NULL); /* <=== Attention !!! */

---

Citation:

---

Envoyé par Laurent_B_

>Pour les messages d'erreur, ...
Ou est-il ?

---

Pièce jointe 627452

Dans l'onglet "Sortie" (cercle Rouge)

Sélectionnez dans le menu déroulant (cercle vert), l'entré de menu "Build" (cercle bleu)

Citation:

---

Envoyé par Laurent_B_

>Une manière simple de résoudre "définitivement" ...
Ou est-il ?

---

C'est à vous de faire ce wrapper (à moins de trouver une bibliothèque qui le fasse déjà pour vous).

Citation:

---

Envoyé par Laurent_B_

Oui, ça vrai :

Code:

---

1 2 3 4 5

const int You_t(int& c, wchar_t ** v) { #if You_t_ == 1 B.Ok_T(L"const int You_t(int& c, wchar_t**) :"); #endif

---

---

Toujours pas de question, et cette signature de fonction est toujours aussi horrible. (nom de la fonction, types des paramètres, etc...)

Citation:

---

Oups, je pensais que "WriteFile" était orienté chaîne de caractère, mais c'est orienté "octet", donc pas de "WriteFileW" mais attention au comptage des octets

---

Ben oui !

Attention :

Code:

---

1 2 3 4 5 6 7 8

wchar_t str[] = L"L'example \x1b[38;2;0;255;0mtexte\x1b[38;2;0;255;0m àçéè…\r\n"; // <==== Attention WriteFile( hOut /*HANDLE hOut*/, str, (DWORD)wcslen(str), &dwMode /*dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;*/, NULL); wcout << L"zzzz" << endl;

---

et :

Citation:

---

L'example tezzzz

---

??? Explique-moi ?

Citation:

---

Pièce jointe 627452
Dans l'onglet "Sortie" (cercle Rouge)

---

??? Ou est-il ? (cercle Rouge)

Citation:

---

C'est à vous de faire ce wrapper (à moins de trouver une bibliothèque qui le fasse déjà pour vous).

---

J'ai oublié !!!

Citation:

---

Toujours pas de question, et cette signature de fonction est toujours aussi horrible. (nom de la fonction, types des paramètres, etc...)

---

Alors, que faire !

Bonjour à tous,

Et :

Code:

---

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

const int You_t(int& c, wchar_t ** v) { #if You_t_ == 1 B.Ok_T(L"const int You_t(int& c, wchar_t**) :"); #endif int i = 0; size_t pos = 0; static const basic_string <wchar_t>::size_type npos = -1; wstring t; if (v[3][0] == L'\0') { wcerr << L" " << L"Érreur !!! (v[3][0] == L'\0')" << endl; E.afficher_X(-3, L"v[3][0] == L'\0' érreur !!!", L"Érreur !!!"); #if You_t_ == 1 B.Ok_W(L"v[3][0] == L''\\0''"); #endif return EXIT_FAILURE; } if (v[2][0] == L'c') { if (v[3][0] != L'\0') { path c_(v[3]); #if You_t_ == 1 //wcout << L" " << L'{' << c.parent_path() << L'\\' << c.filename() << L'}' << endl; B.Ok_W(L'{' + (wstring)c_.parent_path() + L'\\' + (wstring)c_.filename() + L'}'); #endif Cinema C; i = C.Ok_C(P.C_Espace1, P.C_H, P.C_Espace2, P.C_Espace3, P.C_MIN, P.C_T, P.C_t, P.C_W, P.C_w); i = C.afficher_dossier(c_.filename()); #if You_t_ == 1 //wcout << L"-- -- -- -- -- -- -- ------------------------" << endl; B.Ok_T(L"-- -- -- -- -- -- -- ------------------------"); #endif //for (directory_iterator next(path(P_C.cs + v[3])), end; next != end; ++next) for (directory_iterator next(path(cinema.cs + v[3])), end; next != end; ++next) { //wcout << L"qqqqq" << next->path() << endl; t = next->path(); if (is_regular_file(t)) { pos = t.find(L".txt"); if (pos != wstring::npos) { pos = t.find(L"\\_"); if (pos != npos) continue; i = C.afficher_fichier(t, _TXT_); continue; } //pos = t.find(L".jpg"); //if (pos != wstring::npos) // i = C.afficher_Image(t); //pos = t.find(L".png"); //if (pos != wstring::npos) // i = C.afficher_Image(t); pos = t.find(L".jpg"); if (pos != wstring::npos) { i = C.afficher_fichier(t, _JGP_); } pos = t.find(L".png"); if (pos != wstring::npos) { i = C.afficher_fichier(t, _PNG_); } } } //wcout << L"aaa" << endl; i = C.afficher_OK(); } } else if (v[2][0] == L's') { if (v[3][0] != L'\0') { int j = 0; path s_(v[3]); wcout << L"v[3]={" << v[3] << L"}" << endl; wstring temps = v[3]; pos = temps.find_last_of(L"\\"); temps = temps.substr(pos + 1); #if You_t_ == 1 B.Ok_T(L'{' + v[3] + L'}'); B.Ok_W(L'{' + P_S.cs + L"} {" + temps + L'}'); #endif wcout << L"ffff" << endl; P_cs = P_S; //j = compare_path(/*P_cs,*/ s_, temps);   if (j == 0) ; else { wcerr << L"[s] érreur !!!" << endl; E.afficher_X(-3, L"s érreur !!!", L"s érreur !!!"); return -3;   } Serie S; i = S.Ok_S(P.S_Espace, P.S_MIN, P.S_T, P.S_t, P.S_W, P.S_w); i = S.afficher_dossier(s_.filename()); #if You_t_ == 1 //wcout << L" " << L'{' << s.parent_path() << L'\\' << s.filename() << L'}' << endl; B.Ok_W(L'{' + (wstring)s_.parent_path() + L'\\' + (wstring)s_.filename() + L'}'); #endif //for (directory_iterator next(path(serie.cs + v[3])), end; next != end; ++next) //for (directory_iterator next(path(P_S.cs + v[3])), end; next != end; ++next) for (directory_iterator next(s_), end; next != end; ++next) { //assert(P_S->cs && "L'index ne doit pas être négatif."); t = next->path(); if (is_regular_file(t)) { pos = t.find(L".txt"); if (pos != npos) { pos = t.find(L"\\_you_.txt"); //pos = t.find(L"\\_"); //pos = t.find(L"\\_"); if (pos != npos) continue; i = S.afficher_fichier(t, _TXT_); } pos = t.find(L".jpg"); if (pos != wstring::npos) { i = S.afficher_fichier(t, _JGP_); } pos = t.find(L".png"); if (pos != wstring::npos) { i = S.afficher_fichier(t, _PNG_); } } if (is_directory(t)) { path ss_(t + L'\\'); wstring t2; t2 = t + L'\\'; i = S.afficher_dossier(t2); // for (directory_iterator next(path(t + L'\\')), end; next != end; ++next) for (directory_iterator next(ss_), end; next != end; ++next) { //wcout << next->path() << endl; t2 = next->path(); if (is_regular_file(t2)) { pos = t2.find(L".txt"); if (pos != npos) { //wcout << L'\t'; if (t2 == t + L"\\_you_.txt") continue; i = S.afficher_fichier(j, t2, _TXT_); } pos = t2.find(L".jpg"); if (pos != npos) { i = S.afficher_fichier(j, t2, _JGP_); } pos = t2.find(L".png"); if (pos != wstring::npos) { i = S.afficher_fichier(j, t2, _PNG_); } } } j++; } } i = S.afficher_pas_de_OK(); i = S.afficher_OK(); } } else { wcout << L"hacnnnn" << endl; } #if You_t_ == 1 //wcout << B_T << L"const int You_t() : Ok !" << B_t << endl; B.Ok_T(L"const int You_t() : Ok !"); #endif return i; }

---

Citation:

---

Gravité Code Description Projet Fichier Ligne État de la suppression
Avertissement C6262 La fonction utilise '229120' octets de pile. Envisagez de déplacer certaines données vers le tas. You D:\Work\Prg\CPP\You\You.cpp 641

---

Citation:

---

Gravité Code Description Projet Fichier Ligne État de la suppression
Avertissement C6246 La déclaration locale de 'next' masque la déclaration du même nom dans la portée externe. Pour des informations supplémentaires, reportez-vous à la déclaration précédente à la ligne '749' de 'd:\work\prg\cpp\you\you.cpp'.: Lines: 749 You D:\Work\Prg\CPP\You\You.cpp 783

---

Citation:

---

Gravité Code Description Projet Fichier Ligne État de la suppression
Avertissement C6246 La déclaration locale de 'end' masque la déclaration du même nom dans la portée externe. Pour des informations supplémentaires, reportez-vous à la déclaration précédente à la ligne '749' de 'd:\work\prg\cpp\you\you.cpp'.: Lines: 749 You D:\Work\Prg\CPP\You\You.cpp 783

---

???

Dans votre code, vous utilisez "(DWORD)wcslen(str)," pour indiquer le nombre d'octets à lire depuis la variable "str".
Attention "wcslen" donne le nombre de caractère de la chaîne "str", pas le nombre d'octets utilisés pour la contenir.
C'est pour cela que j'avais mis en gras dans mon code la "correction" : "wcslen(str)*sizeof(wchar_t),
En gros, je multiplie le nombre de caractère de la chaîne de caractère par la taille, en octets, d'un caractère : "sizeof(wchar_t)".

Le contenu de "str" a bien évolué.

hOut est un Handle sur la console "Strandard" liée à votre exécutable, si sa définition n'a pas changé depuis le post du code où il était défini.
Avec ce handle, vous pouvez utiliser les fonctions de l'API "ConPTY" pour qu'elle gère elle-même et "correctement" les séquences d'échappement VTxxx.

Je ne sais pas quelle fonctions de l'API "ConPTY" vous avez déjà appelé pour configurer la console de votre application.
Et, en plus, je ne connais pas trop les séquences d'échappement VTxxx, donc je sais pas trop à quoi correspond "\x1b[38;2;0;255;0m".

Mais si la console a bien été configurer, que "\x1b[38;2;0;255;0m" est bien une séquence d'échappement valide et comprise par une console configurée avec "ConPTY", le résultat doit être conforme au résultat attendu (changement de couleur ? changement de position du caret ?, changement de police d'écriture ?, etc....)

En utilisant l'API "ConPTY", vous ne devriez plus vous préoccuper des séquences d'échappement, du moment qu'elles soient "valides".

Si j'en crois https://tforgione.fr/posts/ansi-escape-codes/, vos séquences sont là pour changer la couleur d'écriture de "texte" en vert, non ?

N'est-ce pas le cas ?

Le fait que seul "L'example te" et non "L'example texte" est écrit dans la console, je pense que c'est lié au fait que vous n'avez pas multiplié le nombre de caractère par la taille de chaque caractère dans le 3ème paramètre de "WriteFile". Résultat : "WriteFile" ne prend que la moitié de "str".

Le "zzzz" en vert vient du code ligne 8 "wcout << L"zzzz" << endl;".
Le fait que cela soit écrit en vert vient probablement de la séquence d'échappement envoyée via "WriteFile" ("\x1b[38;2;0;255;0m").
"wout" et "hOut" utilise la même console, donc en envoyant des séquences d'échappement via l'une, cela impacte aussi les sorties de l'autre.

Citation:

---

??? Ou est-il ? (cercle Rouge)

---

Vous localisez bien les cercles colorés dans les images des copies d'écran ? (Daltonisme, etc...)
Si oui, mais que vous n'arrivez pas à localiser l'onglet "Sortie" dans votre IDE, cet onglet est généralement au même endroit que la fenêtre "Liste d'erreurs" dont vous avez déjà posté le contenu dans cette file de message.

Si vous avez du mal à localiser l'onglet "Sortie", en utilisant le menu "Affichage -> Sortie", il devrait passer en "premier plan" ou le faire réapparaître.
Pièce jointe 627529

Citation:

---

J'ai oublié !!! (wrapper)

---

Pas de panique, on peut faire un truc aussi simple qu'une simple fonction de quelques lignes, comme ci-après, pour commencer :
(code à l'arrache à déboguer)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

void PrintStringW(HANDLE hOut, const std::wstring& str) { DWORD dwMode = 0;   _ASSERT(SUCCEEDED(WriteFile( hOut, &str[0], (DWORD)(str.size() * sizeof(wchar_t)), &dwMode /*dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;*/, NULL))); }

---

Citation:

---

Alors, que faire ! (cette signature de fonction est toujours aussi horrible)

---

C'est fonction de ce que fait vraiment la fonction "You_t".
Le nom, le type de retour et les paramètres doivent être assez parlant pour savoir ce que fait cette fonction sans aller lire la documentation.

AJOUT suite au message de Laurent_B_ à 15h48 :
Je nommerais la fonction "RechercherEtAfficherSeriesOuFilms_Et_CEstBienTropDeChoseAFaireDansUneSeuleFonction", cela décrit ce qu'elle fait mais aussi mon opinion sur ce "machin".

Comme elle fait un peu tout (trop de chose), elle n'a rien à retourner car elle cherche et affiche, donc, il reste rien à faire après son appel. Donc, "void" en type de retour de ce "machin" est le plus raisonnable.

Les types des paramètres actuels sont des pièges mortels qu'il faut absolument assainir.
("c" ne semble servir à rien, "v" semble être un tableau de chaîne de caractère totalement fourre-tout, où le 3 élément contient un "magic number" pour choisir entre Serie et Film, le 4ème un bout du chemin du système de fichier et/ou du film à chercher.)

Je propose donc (avant une refonte de ce machin) comme signature :
(avec TypeElementAChercher une énumération qui contient "Serie" et "Film")

Code:

---

void RechercherEtAfficherSeriesOuFilms_Et_CEstBienTropDeChoseAFaireDansUneSeuleFonction(TypeElementAChercher typeElementAChercher, const wstring& nomAChercher);

---

Avec cette signature, on peut toujours faire tout le bordel de cette fonction mais avec des types bien moins casse-gueule.

Il faudra utiliser toute la sémantique proposée par le C++ en terme de gestion d'erreurs en fonction du "vrai" type d'erreur.
- "alert" pour les erreurs de programmation "détectée"
- throw d'exceptions pour les cas exceptionnels
- etc...

Après séparation des fonctionnalités, vous ne devriez que rarement avoir des fonctions plus longues que 20 lignes, et c'est vraiment le cas ici. (Surtout avec tout ce code de traçage et/ou "gestion/détection" des erreurs qui est inutile, lourds, et facilement remplaçable par des choses bien plus fonctionnelles.)

Exemple à l'arrache d'un pré-refactoring :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

void RechercherEtAfficherSeriesOuFilms_Et_CEstBienTropDeChoseAFaireDansUneSeuleFonction(TypeElementAChercher typeElementAChercher, const wstring& nomAChercher) { assert(nomAChercher.size()>0);   Afficheur afficheur = FabriqueDAfficheur(typeElementAChercher); std::filesystem::path racine = RecupereRacine(typeElementAChercher);   for (directory_iterator next(std::filesystem::path(racine + nomAChercher)), end; next != end; ++next) { .... afficheur.affiche(....); .... } }

---

Citation:

---

Gravité Code Description Projet Fichier Ligne État de la suppression
Avertissement C6262 La fonction utilise '229120' octets de pile. Envisagez de déplacer certaines données vers le tas. You D:\Work\Prg\CPP\You\You.cpp 641
Gravité Code Description Projet Fichier Ligne État de la suppression
Avertissement C6246 La déclaration locale de 'next' masque la déclaration du même nom dans la portée externe. Pour des informations supplémentaires, reportez-vous à la déclaration précédente à la ligne '749' de 'd:\work\prg\cpp\you\you.cpp'.: Lines: 749 You D:\Work\Prg\CPP\You\You.cpp 783
Gravité Code Description Projet Fichier Ligne État de la suppression
Avertissement C6246 La déclaration locale de 'end' masque la déclaration du même nom dans la portée externe. Pour des informations supplémentaires, reportez-vous à la déclaration précédente à la ligne '749' de 'd:\work\prg\cpp\you\you.cpp'.: Lines: 749 You D:\Work\Prg\CPP\You\You.cpp 783

---

Ce n'est que des warning, donc l'exécutable final est quand même crée.

Faut juste faire attention.
Le premier (C6262 ...), c'est que le compilateur a détecté ligne 641 de votre fichier "You.cpp" que la fonction qui y est défini utilise beaucoup beaucoup de variable locale ( 229120 octets de variables locales, c'est colossal, donc très probablement une grosse erreur de logique (ou fonction bien trop langue et complexe pour qu'elle soit humainement maintenable))

Les 2 autres, c'est la même erreur à la même ligne (783) de votre fichier "You.cpp", car vous déclarez à cette ligne "783" 2 variables avec les noms "next" et "end", mais 2 autres variables de mêmes noms ("next" et "end") sont déclarées ligne "749" de ce même fichier.
Ca sent clairement le copier-coller d'une déclaration de boucle "for" à l'intérieur d'une autre boucle "for" avec les même noms de variables d'itération, et c'est vraiment pas bon.

Bonjour, salut Bacelar (tu ou vous ?)
Pas dormir, fatigant !

Code:

---

1 2 3 4 5 6 7

wchar_t str[] = L"L'example \x1b[38;2;0;255;0mtexte\x1b[38;2;255;255;255m àçéè…\r\n"; // <==== Attention WriteFile( hOut /*HANDLE hOut*/, str, (DWORD)wcslen(str) * sizeof(wchar_t), &dwMode /*dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;*/, NULL);

---

et :

Citation:

---

L'example texte ÓþÚÞ&

---

Pas compli !!!

Ensuite :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void PrintStringW(HANDLE hOut, const std::wstring& str) { DWORD dwMode = 0;   _ASSERT(SUCCEEDED(WriteFile( hOut, &str[0], (DWORD)(str.size() * sizeof(wchar_t)), &dwMode /*dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;*/, NULL))); }

---

Et : &str[0] ou str[0] ou &str ou str : Problèmes !!!
et :

Code:

---

1 2 3 4 5 6 7 8 9 10

wchar_t str2[] = L"Malgré sa paralysie, Jake Sully, un ancien marine immobilisé dans un fauteuil roulant, est resté un combattant au plus profond de son être." " Il est recruté pour se rendre à des années-lumière de la Terre, sur Pandora, où de puissants groupes industriels exploitent un minerai rarissime destiné à résoudre la crise énergétique sur " "Terre. Parce que l'atmosphère de Pandora est toxique pour les humains, ceux-ci ont créé le Programme Avatar, qui permet à des "" pilotes "" humains de lier leur esprit à un avatar, un corps " "biologique commandé à distance, capable de survivre dans cette atmosphère létale. Ces avatars sont des hybrides créés génétiquement en croisant l'ADN humain avec celui des Na'vi, les " "autochtones de Pandora. Sous sa forme d'avatar, Jake peut de nouveau marcher. On lui confie une mission d'infiltration auprès des Na'vi, devenus un obstacle trop conséquent à l'exploitation " "du précieux minerai.Mais tout va changer lorsque Neytiri, une très belle Na'vi, sauve la vie de Jake...\r\n"; // Film : Avatar wcout << L"zzzz" << endl; PrintStringW(hOut, str2); wcout << L"zzzz" << endl;

---

Citation:

---

zzzz
zzzz

---

Noté : https://tforgione.fr/posts/ansi-escape-codes/

Et : WriteFile de ne y1 et y2 ? (0<------->Y)

Merci beaucoup :)

You_t : Plus tard...

Citation:

---

Pas compli !!!

---

Je ne comprends pas.

Pour le code, pour moi, il "fonctionne".
La partie "L'example " de la chaîne de caractères est "correctement" affichée : les bons "glyphes" avec la couleur courante des écritures dans la console (en noir ou en blanc vraisemblablement).
"\x1b[38;2;0;255;0m" indique que la couleur courante des écritures dans la console devient le vert.
"texte" est bien écrit en vert, si je ne m'abuse ?
"\x1b[38;2;255;255;255m" indique que la couleur courante des écritures dans la console devient le blanc.

" àçéè…\r\n", là, ça se complique.
Il y a plusieurs causes possibles au fait que ce qui est affiché dans la console ne correspond pas à ce qui est affiché dans l'éditeur de texte du code source.
L'encodage (UTF-8, UTF-16, ASCII, ...) du code source a utilisé une représentation qui est fonction des réglages de l'éditeur de texte, il doit correspondre a l'encodage attendu par la console.
Et même si l'encodage est le bon, il faut vérifier les polices/fonts utilisées dans l'éditeur et dans la console pour voir si elles utilisent les mêmes "glyphes" aux mêmes endroits (indices dans leurs tables de caractères) et qu'elles sont accès "complètes" pour afficher les caractères demandés.
C'est pour tout cela que j'avais indiqué de privilégier les textes "hors code" (dans des fichiers externes).

Citation:

---

Et : &str[0] ou str[0] ou &str ou str : Problèmes !!!

---

C'est de sombres bailles pour faire "entrer" des objets C++ (ici std::wstring) dans une API C qui demande un "LPCVOID".
Je suis même pas sûr du machin, mais c'est du copier-coller du Net et cela a une tête "cohérente".
Il se peut que cela de compile pas, ou ne fonctionne pas, en fonction des implémentations des objets C++, mais ça devrait le faire.

str, c'est l'objet C++
str[0], c'est le premier caractère de la chaîne de caractère "str".
&str[0], c'est l'adresse où est stocké ce "premier caractère".
Donc, si les l'implémentation de std::wtring fait en sorte que les caractères se suivent en mémoire, l'API C est "contente".

Citation:

---

zzzz
zzzz

---

Oups, une "erreur" de débutant de ma part. Si vous compilez en "Release", _ASSERT ne fait rien.
Il vaut mieux utiliser une MACRO type "VERIFY" plutôt que _ASSERT.
Mais je vous conseille de commencer par compiler/utiliser une version "Debug" avant de passer à une version "Release".

Citation:

---

Et : WriteFile de ne y1 et y2 ? (0<------->Y)

---

Je ne suis pas sûr de comprendre.
Si c'est pour avoir une fonction "WrireFile" où vous pouvez spécifier la position en (x,y) sur l'écran où doit apparaître le texte, il suffira d'ajouter au début du texte à afficher la séquence d'échappement qui permet de déplacer le "caret".

Mais si vous commencez à fournir ce genre de fonctionnalité de "haut niveau", je vous conseille d'encapsuler ce type de fonction dans une classe, histoire que cette classe puisse un peu "gérer" un état de la console (couleur courante, position du courante du "caret", sérialiser les appels, etc...). Une spécialisation (une fonction avec le même nom mais avec des paramètres différents en nombre et/ou en type) de "PrintStringW" qui passerait d'une fonction libre à une fonction d'instance d'objet permettrait d'avoir un code simple et concis (via l'appel d'autres fonctions plus élémentaires).

Mais pour que cette fonction/classe puisse correctement fonctionner, vous devriez éviter les autres appels qui "attaquent" la console ("wcout", etc...), pour que l'objet encapsulant "PrintStringW" puisse être simple à faire et efficace.
Donc, comme déjà indiquer, je crois, supprimez les traces "à la sauvage" dans la console (comme des 'wcout << "toto"') et même ailleurs que dans la console.

Citation:

---

" àçéè…\r\n", là, ça se complique.
Il y a plusieurs causes possibles au fait que ce qui est affiché dans la console ne correspond pas à ce qui est affiché dans l'éditeur de texte du code source.
L'encodage (UTF-8, UTF-16, ASCII, ...) du code source a utilisé une représentation qui est fonction des réglages de l'éditeur de texte, il doit correspondre a l'encodage attendu par la console.
Et même si l'encodage est le bon, il faut vérifier les polices/fonts utilisées dans l'éditeur et dans la console pour voir si elles utilisent les mêmes "glyphes" aux mêmes endroits (indices dans leurs tables de caractères) et qu'elles sont accès "complètes" pour afficher les caractères demandés.
C'est pour tout cela que j'avais indiqué de privilégier les textes "hors code" (dans des fichiers externes).

---

Que faire ?

Citation:

---

C'est de sombres bailles pour faire "entrer" des objets C++ (ici std::wstring) dans une API C qui demande un "LPCVOID".
Je suis même pas sûr du machin, mais c'est du copier-coller du Net et cela a une tête "cohérente".
Il se peut que cela de compile pas, ou ne fonctionne pas, en fonction des implémentations des objets C++, mais ça devrait le faire.

---

Ah ! Pince !!!

Citation:

---

str, c'est l'objet C++
str[0], c'est le premier caractère de la chaîne de caractère "str".
&str[0], c'est l'adresse où est stocké ce "premier caractère".
Donc, si les l'implémentation de std::wtring fait en sorte que les caractères se suivent en mémoire, l'API C est "contente".

---

À Bon ! Alors...

Citation:

---

Oups, une "erreur" de débutant de ma part. Si vous compilez en "Release", _ASSERT ne fait rien.
Il vaut mieux utiliser une MACRO type "VERIFY" plutôt que _ASSERT.
Mais je vous conseille de commencer par compiler/utiliser une version "Debug" avant de passer à une version "Release".

---

Noté !

Citation:

---

Je ne suis pas sûr de comprendre.
Si c'est pour avoir une fonction "WrireFile" où vous pouvez spécifier la position en (x,y) sur l'écran où doit apparaître le texte, il suffira d'ajouter au début du texte à afficher la séquence d'échappement qui permet de déplacer le "caret".

---

Commant-faire ?

Citation:

---

Mais si vous commencez à fournir ce genre de fonctionnalité de "haut niveau", je vous conseille d'encapsuler ce type de fonction dans une classe, histoire que cette classe puisse un peu "gérer" un état de la console (couleur courante, position du courante du "caret", sérialiser les appels, etc...). Une spécialisation (une fonction avec le même nom mais avec des paramètres différents en nombre et/ou en type) de "PrintStringW" qui passerait d'une fonction libre à une fonction d'instance d'objet permettrait d'avoir un code simple et concis (via l'appel d'autres fonctions plus élémentaires).

---

Ah ! Tant pis...

Citation:

---

Mais pour que cette fonction/classe puisse correctement fonctionner, vous devriez éviter les autres appels qui "attaquent" la console ("wcout", etc...), pour que l'objet encapsulant "PrintStringW" puisse être simple à faire et efficace.
Donc, comme déjà indiquer, je crois, supprimez les traces "à la sauvage" dans la console (comme des 'wcout << "toto"') et même ailleurs que dans la console.

---

OK !

Pour l'histoire de l'encodage des chaînes de caractères "en dur" dans le code, comme je l'ai indiqué, c'est de faire en sorte que ces chaînes ne soient pas dans le code mais dans des fichiers de "ressource".
C'est la même logique que pour "internationalisation/globalisation" d'une application, en mettant toutes ces chaînes dans des fichiers "à part", il suffit de les changer juste ces fichiers pour changer la langue de l'application, sans même recompiler.

Les mettre "en dur" dans le code source interdit une "internationalisation/globalisation" facile, et en plus, les éditeurs de texte "pour le code" sont moins bien conçus pour la gestion des encodages des textes.

En fonction des bibliothèques/framework "génériques" que vous utilisez (Qt, MFC, ....), il est très probable qu'elles offrent déjà un mécanisme de lecture de ce type de fichier ressource, et ça donnerait un code proche de :

Citation:

---

wstring str = GetString(ID_SAMPLE_PROMPT_STR);

---

Avec ce type de code, vous pouvez facilement changer toutes les valeurs et leur encodage, juste avec un simple éditeur de texte qui gère "finement" l'encodage du fichier résultant.

Une fois que l'encodage des chaines de caractères en entré est "stabilisé", il restera à voir les appels à l'API "ConPTY", ou autres, pour configurer la console "correctement" (changement de font, changement d'encodage des chaines de caractère, etc...).


Pour l'histoire de l'implémentation de std::wstring qui peut poser problème avec l'API C Win32, il faut bien comprendre que le code mixte "C++/C" ne devrait être que dans une seule fonction type "PrintStringW". Une fois correctement codé, toutes les sorties dans la console fonctionneront "nickel" (il faudra juste vérifier que cela fonctionnera aussi avec d'autres implémentations de std::wstring, en cas de portage, c'est le genre de truc qu'on met dans les TUs (Tests Unitaires)).
(Peux-être que la normalisation de la la STL donnent des garanties fortes pour faire du code C++ <-> C "portable" mais c'est vraisemblablement avec d'autres classes que std:wstring, comme std::wstring_view.)

Pour la possibilité d'écrire n'importe où dans la console (x,y), après lecture des séquences d'échappement indiqués dans la page donnée en référence, c'est assez limitée en possibilité => Il faudra donc construire une classe autour de "PrintStringW" pour gérer finement le machin :

Code:

---

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

// m_ c'est un préfixe pour indiquer que c'est un membre de l'objet, ici un champ plus précisément //m_caret_x : position courante du caret de la console sur l'axe X //m_caret_y : position courante du caret de la console sur l'axe Y // m_hOut : handle de la console void Console::PrintStringW(const std::wstring& mes, unsigned int x, unsigned int y) { std::wstring str = mes; //calcul du décalage en X entre la position du caret et la position voulue pour l'affiche de la chaîne de caractères int diff_x = x - m_caret_x; //calcul du décalage en X entre la position du caret et la position voulue pour l'affiche de la chaîne de caractères int diff_y = y - m_caret_y; if(diff_y < 0) { str = L"\x1B[" + to_wstring(-diff_y) + L"A" + str; new_caret_y -= diff_y; new_caret_x = .... diff_x = x - new_caret_x; if(diff_x < 0) { ... } else if(diff_y > 0) { ... } } else { .... } if(diff_x < 0) { .... } else { .... } PrintStringW(m_hOut, str ); m_caret_x = new_caret_x; m_caret_y = new_caret_y; }

---

Juste avec les séquences d'échappement "ASCII", le code risque d'être assez verbeux. Avec des codes d'échappement VTxxx, je pense que le code serait bien plus simple, mais il faudrait configurer la console standard pour qu'elle les comprenne : cf. l'API "ConPTY".

Pour le lien sur le site de Zeste de Savoir, c'est sur les lambda en C++, un truc qui a été ajouté en 2011 avec le standard C++11.
Mais je pense que pour un profile "ancien codeur C" comme le vôtre, c'est le genre de chose que peut attendre un peu, le temps que vous montiez en compétence sur les concepts de programmation orienté objet.

/!\ Attention, la macro SUCCEEDED() ne marche pas avec WriteFile().

SUCCEEDED() est à utiliser pour les fonctions qui retournent un HRESULT (où toute valeur non-négative, y compris zéro, est un succès) alors que WriteFile retourne un BOOL (un int avec un typedef dessus, mais à utiliser sémantiquement comme un Booléen).
La doc dit que WriteFile() ne retourne que les valeurs TRUE (1) et FALSE (0), toutes les deux non-négatives, donc la macro SUCCEEDED() sera toujours vraie même si la fonction a échoué.

Bonsoir Bacelar et Médinoc,

Citation:

---

SUCCEEDED() est à utiliser pour les fonctions qui retournent un HRESULT (où toute valeur non-négative, y compris zéro, est un succès) alors que WriteFile retourne un BOOL (un int avec un typedef dessus, mais à utiliser sémantiquement comme un Booléen).
La doc dit que WriteFile() ne retourne que les valeurs TRUE (1) et FALSE (0), toutes les deux non-négatives, donc la macro SUCCEEDED() sera toujours vraie même si la fonction a échoué.

---

Ah, mince !!! Ben alors...

-- -- -- -- --

(Film : Once Upon a Time… in Hollywood.(2019-08-14))

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

// Soundtrack et Soundtrack_role if (Soundtrack_ == true && Soundtrack.size() != 0) { i = Console_Lire_txt(C_T + L"Soundtrack :" + C_t, 0, 0); // ??? Textes = L""; for (j = 0; j < Soundtrack.size(); j++) { Textes += C_W + Soundtrack[j] + L" : " + C_w; Textes += Soundtrack_role[j] + L'\n'; } i = Console_Lire_txt(Textes, 4, 0); // ??? }

---

Soundtrack :

Superviseur musical : Mary Ramos
Montage musical : Jim Schultz

Par :

Soundtrack :

Superviseur musical : Mary Ramos
Montage musical :   Jim Schultz

Explication ? L' ' * (xxx) ? (to_wstring ou ...)

Merci d'anvance ;)

Citation:

---

Ah, mince !!! Ben alors... (SUCCEEDED)

---

Pas de panique, c'est encore plus simple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void PrintStringW(HANDLE hOut, const std::wstring& str) { DWORD dwMode = 0;   _ASSERT(WriteFile( hOut, &str[0], (DWORD)(str.size() * sizeof(wchar_t)), &dwMode, NULL) ==TRUE); }

---

Pour cet horrible machin "Console_Lire_txt" :
C'est quoi la question ?

La différence entre les 2 "Soundtrack", c'est le remplacement d'un espace entre le ":" et "Jim" par une tabulation horizontale.

Si le problème est le fait que les ":" ne sont pas alignés verticalement ; sur une application console, la "solution" c'est d'utiliser une police "à chasse fixe" en plus de faire des calculs du nombre d'espace à rajouter pour faire l'alignement ; sans l'utilisation d'une police "à chasse fixe", c'est rédhibitoire. (la police utilisée dans votre dernier message sur le forum n'est pas "à chasse fixe")

Si c'est le problème du remplacement de l'espace par la tabulation horizontale, faudrait déboguer cette usine à gaz qu'est "Console_Lire_txt".

Citation:

---

Explication ? L' ' * (xxx) ? (to_wstring ou ...)

---

Explication de quoi ???
Console:: PrintStringW ?
Il y a des commentaires dans le code, mais en gros, C'est de calculer la différence entre la position actuel du caret (point d'insertion du prochain caractère dans la console, le bitoniau qui clignote) avec la position d'écriture demandée via les paramètres x et y de la fonction. Une fois cet écart calculé, on ajoute les séquences d'échappement nécessaires pour repositionner le caret à l'endroit demandé via ces paramètres x et y avant le "vrai " texte du message, passé via le paramètre "mes". Cela devrait donc afficher au bon endroit le message, quelques soit la position de départ du caret.

Les "...", c'est des bouts de code manquants mais qu'il devrait être "facile" de remplir pour ces cas de figures.

Si c'est cette usine à gaz de "Console_Lire_txt" qui se charge de bien aligner les "soundtrack"

Citation:

---

Soundtrack :
Superviseur musical : Mary Ramos
Montage musical : Jim Schultz

Par :
Soundtrack :
Superviseur musical : Mary Ramos
Montage musical :   Jim Schultz

---

Il faut juste faire une autre fonction, de plus "haut" niveau que "Console:: PrintStringW" mais qui serait bien plus lisible et fiable que ce truc de "Console_Lire_txt".

Bonsoir,

Code:

---

1 2 3 4 5 6 7 8 9

wchar_t str2[] = L"Malgré sa paralysie, Jake Sully, un ancien marine immobilisé dans un fauteuil roulant, est resté un combattant au plus profond de son être." " Il est recruté pour se rendre à des années-lumière de la Terre, sur Pandora, où de puissants groupes industriels exploitent un minerai rarissime destiné à résoudre la crise énergétique sur " "Terre. Parce que l'atmosphère de Pandora est toxique pour les humains, ceux-ci ont créé le Programme Avatar, qui permet à des "" pilotes "" humains de lier leur esprit à un avatar, un corps " "biologique commandé à distance, capable de survivre dans cette atmosphère létale. Ces avatars sont des hybrides créés génétiquement en croisant l'ADN humain avec celui des Na'vi, les " "autochtones de Pandora. Sous sa forme d'avatar, Jake peut de nouveau marcher. On lui confie une mission d'infiltration auprès des Na'vi, devenus un obstacle trop conséquent à l'exploitation " "du précieux minerai.Mais tout va changer lorsque Neytiri, une très belle Na'vi, sauve la vie de Jake...\r\n"; wcout << L"zzzz" << endl; PrintStringW(hOut, str2); wcout << L"zzzz" << endl;

---

et :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

void PrintStringW(HANDLE hOut, const wstring& str) { #if PrintStringW_ == 1 B.Ok_T(L"void PrintStringW(HANDLE hOut, const wstring& str) :"); #endif DWORD dwMode = 0;   _ASSERT(WriteFile( hOut, &str[0], (DWORD)(str.size() * sizeof(wchar_t)), &dwMode, NULL) == TRUE); #if PrintStringW_ == 1 B.Ok_T(L"void PrintStringW() : Ok !"); #endif }

---

Citation:

---

Pièce jointe 627943

---

???

-- -- -- -- --

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

// Soundtrack et Soundtrack_role if (Soundtrack_ == true && Soundtrack.size() != 0) { i = Console_Lire_txt(C_T + L"Soundtrack :" + C_t, 0, 0); // Oui, je sais ! Textes = L""; for (j = 0; j < Soundtrack.size(); j++) { Textes += C_W + Soundtrack[j] + L" : " + C_w; Textes += Soundtrack_role[j] + L'\n'; } i = Console_Lire_txt(Textes, 4, 0); }

---

Citation:

---

Pièce jointe 627944

---

Question : length, to_wstring, stoi... avec des chiffre...
Explame :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// Gense if (Gense_ == true) { Textes = C_T + L"Gense"; j = 8; if (Gense.size() > 1) { Textes += L's'; j = 9; } Textes += L" : " + C_t; i = 0; for (iter = Gense.begin(); iter != Gense.end(); iter++) { Textes += *iter; if (i < Gense.size() - 1) Textes += C_T + L", " + C_t; i++; } i = Console_Lire_txt(Textes, 0, j); }

---

et :

Citation:

---

Pièce jointe 627946

---

Voila, c'est tout !

-- -- -- -- --

"Console_Lire_txt" : Ben oui, mais bon...

J’excuse !

PrintStringW n'affiche rien car vous compilez toujours en Release et pas en Debug.
Je vous ai conseillé de commencer en Debug pour la mise au point de votre application.

Mais vous avez raison, j'aurais dû changer le code pour utiliser VERIFY à la place d'_ASSERT.

Si vous n'arrivez pas à avoir la MACRO VERIFY avec les paramètres actuels du projet VS, voici une version qui mâche le travail :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include "windows.h" #include <assert.h> #include <string>   ...   void 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); }

---

N'utilisez pas "B.Ok_T" en entré et sortie de fonction. Ca pollue le code, la sortie standard, c'est pas fiable, c'est pas assez paramétrable, et c'est beaucoup de travail pour pas grand-chose.

Si vous voulez faire des traces fonctionnelles, on verra après, avec des framework qui permettent de faire des choses bien plus facilement et de manière bien plus fiable.

Pourquoi vous emmerdez vous encore avec des tableaux à la C ?

Code:

---

1 2 3 4 5 6

const std::wstring str2{ L"Malgré sa paralysie, Jake Sully, un ancien marine immobilisé dans un fauteuil roulant, est resté un combattant au plus profond de son être." " Il est recruté pour se rendre à des années-lumière de la Terre, sur Pandora, où de puissants groupes industriels exploitent un minerai rarissime destiné à résoudre la crise énergétique sur " "Terre. Parce que l'atmosphère de Pandora est toxique pour les humains, ceux-ci ont créé le Programme Avatar, qui permet à des "" pilotes "" humains de lier leur esprit à un avatar, un corps " "biologique commandé à distance, capable de survivre dans cette atmosphère létale. Ces avatars sont des hybrides créés génétiquement en croisant l'ADN humain avec celui des Na'vi, les " "autochtones de Pandora. Sous sa forme d'avatar, Jake peut de nouveau marcher. On lui confie une mission d'infiltration auprès des Na'vi, devenus un obstacle trop conséquent à l'exploitation " "du précieux minerai.Mais tout va changer lorsque Neytiri, une très belle Na'vi, sauve la vie de Jake...\r\n" };

---

L'affichage des "Soundtracks" ne devrait pas être fait dans un coin au milieu d'un if paumé au milieu d'une fonction longue comme un jour sans pain.
Elle devrait avoir sa propre fonction (avec un vrai typage des paramètres BORDEL):

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// m_ c'est un préfixe pour indiquer que c'est un membre de l'objet, ici un champ plus précisément // m_hOut : handle de la console ... void Console::PrintSoundtracks(const std::vector<std::pair<std::wstring,std::wstring>>>& soundtraks) { /* à l'arrache, faudrait dégager ces C_x à la con et utiliser des noms de constante CORRECTES*/ if(soundtraks.size()>0) { PrintStringW(m_hOut, C_T + L"Soundtrack :" + C_t + L"\r\n"); for (auto&& [role,nom] : soundtraks) { PrintStringW(m_hOut, C_G + role + L" : " + C_g, 4); //Utilisation d'une version de PrintStringW où l'on ne spécifie que le décalage en x et les C_G/C_g pour "green" (t=>turquoise ? , w=>White?) PrintStringW(m_hOut, C_W +nom + C_w + L"\r\n"); } } }

---

"Console_Lire_txt(...)" est chelou, l'utilisateur met des séquences d'échappement comme un bourrin ("C_T +", "+ C_t", "C_W +", "+ C_w") qui ne sont même pas interprétées par "Console_Lire_txt(...)" => on fait confiance à la console pour gérer les couleurs.
Mais "Console_Lire_txt(...)" casse les couilles avec les séquences qui change la position du caret => on ne fait pas confiance à la console pour gérer les changement de position du caret.
C'est pas cohérent, soit la console gère les séquences d'échappement, donc pas de filtrage/interprétation des séquences d'échappements, soit la console ne gère pas les séquences d'échappements et il faut utiliser autre chose que ces séquences d'échappements => utilisation des API "Console" de Windows.

Citation:

---

Question : length, to_wstring, stoi... avec des chiffre...

---

Oups, "std::to_wstring" et pas "to_wstring".
Plus besoin de vous prendre la tête avec "stoi" ou "itos" et autres cochonneries venant du C.
"std::to_wstring" s'occupe de tout, même de convertir un "unsigned int" en un wstring.

Citation:

---

// Gense
if (Gense_ == true)
{

---

Pourquoi "Gense" au lieu de "Genre" ???

Code:

---

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

// Gense if (Gense_ == true)//Test à la con. "if(Gense.size() > 0){}" aurait été bien plus logique. C'est juste pour ne faire le machin entre {} que si "Gense_" est égale à true. { Textes = C_T + L"Gense"; // Ajoute l'affichage avec la couleur turquoise avec le "C_T" devant. j = 8; // calcul d'une variable à la con parce que Console_Lire_txt est mal conçu et qu'on doit lui mâcher le travail // "j" est la valeur à passer en 3ème paramètre de Console_Lire_txt, qui semble ne pas être la position en y (vertical) de la chaîne à afficher mais la position en x de la 2ème partie de la chaîne. C'est foireux comme tout Console_Lire_txt. if (Gense.size() > 1) // test pour ajouter un "s" à la fin de la chaîne "Gense", s'il y a plusieurs valeurs dans la variable "Gense". { Textes += L's'; j = 9; // Toujours le calcul de la valeur à passer en 3ème paramètre de Console_Lire_txt, c'est toujours foireux. } Textes += L" : " + C_t; // On ajoute " : " à la fin de la chaîne et, vraisemblablement, la chaîne d'échappement pour que le reste ne s'affiche plus en turquoise i = 0; // réutilisation foireuse d'une variable for (iter = Gense.begin(); iter != Gense.end(); iter++) //On boucle sur la liste des genres contenus dans la variable "Gense" { Textes += *iter; // On ajoute au texte à afficher la valeur trouvée dans Gense{i] if (i < Gense.size() - 1) // Si l'on pas arrivé au dernier élément : Textes += C_T + L", " + C_t; // On ajoute une virgule en turquoise i++; // réutilisation foireuse de la variable i mais nécessaire pour que le if 2 lignes au-dessus "fonctionne". } // l'usage de i pour l'ajout de la virgule, c'est bien foireux, il y a beaucoup plus simple // il y a dans la stl des algorithms qui doivent faire cela de manière bien plus élégantes // dans la fonction "Console::PrintGenres" plus loin dans le post, je montre une méthode peu élégante mais bien plus simple que l'utilisation de ce PUTAIN de i i = Console_Lire_txt(Textes, 0, j); // réutilisation de de PUTAIN de i pour un truc qui n'a plus rien à voir avec la choucroute // i semble récupérer la valeur de retour de "Console_Lire_txt" mais n'en fait rien => La gestion des erreurs, c'est pas pour les chiens // utilisation de la variable "j" pour un usage plutôt 'douteux' }

---

Et idem que pour les soundtracks, ça mérite sa propre fonction (avec un refactoring à prévoir pour fusionner les points communs à ces 2 fonctions) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

void Console::PrintGenres(const std::vector<std::wstring>& genres) { /* à l'arrache, faudrait dégager ces C_x à la con et utiliser des noms de constante CORRECTES*/ if(genres.size()>0) { std::wstring genre_str = C_T + L"Genre" + ((Genre.size()>1) ? L"s" : L"") + " : " + C_t;   bool first = true; for (auto&& genre : genres) { if(!first) { genre_str += C_T + L", " + C_t; } genre_str += C_W + genre + C_w; first = false; } genre_str += L"\r\n";   PrintStringW(m_hOut, genre_str, 0); } }

---

Citation:

---

"Console_Lire_txt" : Ben oui, mais bon...

---

Franchement, je pense qu'il y aura moins d'effort à refaire des méthodes faciles à utiliser que de comprendre comment fonctionne cette abomination.
"Console:: PrintStringW" me semble bien plus simple à utiliser et l'implémentation finale bien plus fiable.

Salut,

@bacelar,
À continuer comme ça à vous battre avec la console windows, le principal intéressé n'apprendra rien et l'année prochaine il en sera toujours au même point.
Comme tu disposes de visual studio (et moi pas), je te suggère de lui fournir une demo (zip) avec les 2 libs qui suivent. Rassure-toi, elles couvriront aux moins 98% du besoin en code. Le reste se limitant à faire une interface.
Techniquement, toi ça te coûtera 10 ou 20 lignes de codes et certainement beaucoup moins de temps qu'il ne t'en a fallu pour rédiger un seul de tes précédents messages, et lui ça le mettra sur les rails et il pourra enfin commencer à réapprendre le C++ et sa bibliothèque.

Alors, les 2 libs:

Nowide (la déclinaison autonome de boost.nowide), c'est la partie windows i/o en utf-8.
https://www.boost.org/doc/libs/maste...tml/index.html
https://github.com/boostorg/nowide
https://github.com/boostorg/nowide/archive/master.zip

yaml-cpp, moteur pour la sérialisation/désérialisation de données au format YAML.
https://yaml.org/
https://github.com/jbeder/yaml-cpp
https://github.com/jbeder/yaml-cpp/wiki/Tutorial

Pour l'activation de la couleur, voici un "snippet" éventuellement à élaborer...
Le code source devra être enregistré en utf-8, sans bom, et si besoin signalé au compilateur, (/source-charset:utf-8)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// enabling console virtual terminal support DWORD current_console_mode= 0; GetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE), &current_console_mode); SetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE) , current_console_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING | ENABLE_PROCESSED_OUTPUT );   // setting colors // https://en.wikipedia.org/wiki/ANSI_escape_code#Colors // https://learn.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences const std::string esc= "\033"; const std::string use_red_color_text= esc+"[31m"; const std::string use_green_color_text= esc+"[32m"; const std::string use_default_color_text= esc+"[0m";   namespace nw= nowide; nw::cout<< use_red_color_text<< "ééééé"<< use_default_color_text;

---

Si tu as des questions, j'essaierai d'y répondre à mon prochain passage.

@kaitlyn, merci pour les infos.

Mais je crois que @Laurent_B_ essaye de comprendre ce qu'il a programmé précédemment.

Moi, avec mes gros souliers, je lui indique que son code est assez "bordélique" et qu'il va prendre beaucoup de temps à le comprendre, tout du moins sur des fonctions mal fichues comme "Console_Lire_txt", sans réelle valeur ajoutée.
Je lui vends les avantages du C++ moderne par rapport à son code très "C" pour qu'il voit/se remémore les différences entre le C (qu'il semble encore assez bien maîtriser les bases) et le C++, et lui donnant des exemples de refactorisations de son code "avantageuses" à long terme.

Mais vous avez peut-être raison et qu'il cherche à repartir de zéro, sur de bonnes bases, et clairement, vos librairies ont tout leur intérêt.

@Laurent_B_, si vous voulez faire table raz, donnez-nous la version de Visual Studio que vous utilisez (et la version de la chaîne de compilation, si ce n'est pas celle fournie avec VS) . On pourra rapidement vous fournir une solution VS avec le code initial pour gérer des affichages en couleur sur la console.

Bonjour/Salut,

Citation:

---

Oups, "std::to_wstring" et pas "to_wstring".

---

C'est noté !

===> L'aphasie ! Alors... Gense ---> Genre ! J'ai oublié tous !

Sinon :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

const class C_S { friend Cinema; friend Serie; public: C_S(void); ~C_S(); const int afficher_AD(wstring a, wstring& ad, wstring _T); ...   protected: wstring AD = L""; bool AD_ = false;   private: };

---

Code:

---

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

const class Cinema { public: Cinema(void); ~Cinema();   const int afficher_dossier(wstring const& t); const int afficher_fichier(wstring const& t, int const& _T_); const int afficher_Date(wstring d, wstring _T); const int afficher_De(wstring& d, wstring const& _T); const int afficher_Distributeur(wstring& d, wstring const& _T); const int afficher_Image(wstring); const int afficher_Par(wstring p, wstring _T); const int afficher_Note(wstring, wstring);// , int&, bool&); const int afficher_Soundtrack(wstring& s, wstring const& _T); const int afficher_Titre(wstring t, wstring _T); const int afficher_pas_de_OK() const; const int afficher_OK(void); const int Ok_C(bool C_Espace1, wchar_t C_H, bool C_Espace2, bool C_Espace3, wstring C_MIN, wstring C_T, wstring C_t, wstring C_W, wstring C_w);   private: const int afficher_Date_1(wstring d, wstring _T); const wstring afficher_Temps_OK();   //void PrintSoundtracks(const std::vector<std::pair<std::wstring, std::wstring>> & soundtraks);   //wstring B_T = L"\x1b[38;2;200;200;0m"; //wstring B_t = L"\x1b[38;2;255;255;255m";   wstring Ok = L""; wstring Titre__;   bool C_Espace1; wchar_t C_H; bool C_Espace2; bool C_Espace3; wstring C_MIN; wstring C_T; wstring C_t; wstring C_W; wstring C_w;   vector<wstring> Titre{}; vector<wstring> Titre_Original{}; wstring Distributeur; wstring Chaine; vector<wstring> Compositeur; vector<wstring> Soundtrack, Soundtrack_role; tm Date{ 0 }, Date_de_reprise{ 0 }, Date_de_sortie{ 0 }, Temps{ 0 }; vector<wstring> Genre{}; vector<wstring> De; vector<wstring> Par; vector<wstring> Avec; vector<wstring> Avec_role; vector<wstring> Nationalite; wstring Sur = L""; wstring Sous_Genre; wstring Netflix_SJ; wstring SJ;   wstring AD;   int Note; vector<wstring> Image;   bool Titre_ = false; bool Titre_Original_ = false; bool Distributeur_ = false; bool Chaine_ = 0; bool Compositeur_ = false; bool Date_ = false, Date_de_reprise_ = false, Date_de_sortie_ = false, Temps_ = false; bool Genre_ = false; bool De_ = false; bool Par_ = false; bool Avec_ = false; bool Nationalite_ = false; bool Sur_ = false; bool Sous_Genre_ = false; bool Netflix_ = false; bool Netflix_SJ_ = false; bool SJ_ = false; bool Soundtrack_ = false;   bool AD_ = false;   bool Note_ = false; bool Image_ = false;   wstring Titre_1 = L""; bool Titre_1_ = false;   tm Date_1[_X_][_X_]; wstring Date_1_t[_X_];   wstring D[_X_]; wstring D_t[_X_][_X_] = { L"" }; int D_I = 0; int D_J[_X_] = { 0 }; bool D_1_[_X_] = { false }; wstring X[_X_]; wstring X_T[_X_]; };

---

Code:

---

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

const class Serie { public: Serie(void); ~Serie();   const int afficher_dossier(wstring const& t); const int afficher_fichier(wstring const& t, int const& _T_); const int afficher_fichier(int I, wstring const& t, int const& _T_); const int afficher_Avec_2(int I, wstring& a, wstring const& _T);   const vector<wstring> afficher_Chaine(wstring& c, wstring const&_T); const int afficher_Chaine(int I, wstring c, wstring _T); const int afficher_Creee_par(wstring& c, wstring const& _T); const int afficher_Date(wstring d); const int afficher_Diffusee(int& I, wstring const& d); const int afficher_En_relation_avec(wstring& e, wstring const& _T); const int afficher_Image(wstring const&); const int afficher_Image(int&, wstring const&); const int afficher_Note(wstring&, wstring const&, int&, bool&); const int afficher_t123_temps(vector<wstring>&, wstring&, wstring&, wstring&); const int afficher_Titre(wstring& t, wstring const& _T);   const int afficher_pas_de_OK() const; const int afficher_OK(void); const int Ok_S(bool S_Espace, wstring S_MIN, wstring S_T, wstring S_t, wstring S_W, wstring S_w); protected:   private: const int afficher_Titre_2(int I, wstring t, wstring _T); const int afficher_Titre_3(int I, wstring t, wstring _T); const int afficher_X_x(int I, int J, wstring const& _T, wstring& t);   const wstring afficher_OK_Note(); const int afficher_OK_T(vector <wstring>&, wstring&, int y0, int y1, int y2); const wstring afficher_OK_Temps(wstring& v, wstring& S, wstring& s); const wstring afficher_OK_Temps(tm& t, wstring &S, wstring &s);   wstring Ok = L""; wstring Titre__;// = L"";   bool S_Espace; // = false ou true; wstring S_MIN; // = L"min"; wstring S_T; wstring S_t; wstring S_W; wstring S_w;   vector<wstring> Titre{}; vector<wstring> Titre_Original{}; vector<wstring> Chaine{}; tm Temps{ 0 }; vector<wstring> Genre; vector<wstring> Creee_par; vector<wstring> Avec; vector<wstring> Avec_role; //int Avec_i = 0; vector<wstring> Nationalite; wstring Sur = L""; wstring Sous_Genre; wstring Netflix_SJ; wstring SJ;   wstring AD = L"";   wstring En_relation_avec = L""; float Note = 0.0; vector<wstring> Image;   bool Titre_ = false; bool Titre_Original_ = false; bool Chaine_ = false; bool Date_ = false, Temps_ = false; bool Genre_ = false; bool Creee_par_ = false; bool Avec_ = false; bool Nationalite_ = false; bool Sur_ = false; bool Sous_Genre_ = false; bool Netflix_ = false; bool Netflix_SJ_ = false; bool SJ_ = false;   bool AD_ = false;   bool En_relation_avec_ = false; bool Note_ = false; bool Date_Diffusee_a_partir_de_[_X2_] = { false }; bool X_ = false; bool Image_ = false;   wstring Titre_1 = L""; bool Titre_1_ = false;   tm Date_X[_X2_][_X_ * 4][_x_] = { 0 }; tm Date_Diffusee_a_partir_de[_X2_] = { 0 };   wstring D[_X2_] = { L"" }; wstring D_Titre[_X2_] = { L"" }; vector<wstring> D_titre[_X2_];// = { L"" }; vector<wstring> D_t[_X2_][_X_ * 4];// = { L"" }; //wstring D_s[_X2_][_X_ * 4] = { L"" }; vector<wstring> D_Avec_role[_X2_];// = { L"" }; wstring D_Chaine[_X2_] = { L"" }; vector<wstring> D_Image[_X2_]; int D_Note[_X2_] = { -1 };   int D_I = { 0 }; int D_J[_X2_] = { 0 }; int D_K[_X2_][_X_ * 4] = { -1 }; //wchar_t D_K_[_X2_][_X_ * 4] = { L' ' }; bool D_K_[_X2_][_X_ * 4] = { false }; int D_K_d[_X2_][_X_ * 4] = { 0 };   //bool D_Netflix[_X2_] = { false }; bool D_DVD[_X2_] = { false }; bool D_Chaine_[_X2_] = { false }; bool D_Image_[_X2_] = { false }; bool D_Note_[_X2_] = { false }; bool D_Titre_[_X2_] = { false }; };

---

Mais :

• c_s.h et c_s.cpp
• cinema.h et cinema.cpp
• serie.h et serie.cpp

.h et/ou .cpp ? Oui ou non ?

--

void Console:: PrintGenres(const std::vector<std::wstring>& genres)
et
void Console:: PrintSoundtracks(const std::vector<std::pair<std::wstring,std::wstring>>>& soundtraks)
Ok !
Mais :

Citation:

---

void Console:: PrintStringW(const std::wstring& mes, unsigned int x, unsigned int y)
et/ou
void Console:: PrintStringW(const std::wstring& mes, unsigned int x)
et/ou
void Console:: PrintStringW(const std::wstring& mes, unsigned int x1, unsigned int x2)

---

const int afficher_Genre(...) et const int afficher_Soundtrack(...)
???

J'ai oublié...

--

https://stacklima.com/convention-de-nommage-en-c/

--

Citation:

---

Comme tu disposes de visual studio (et moi pas), je te suggère de lui fournir une demo (zip) avec les 2 libs qui suivent. Rassure-toi, elles couvriront aux moins 98% du besoin en code. Le reste se limitant à faire une interface.

---

Interface ???

Citation:

---

Nowide (la déclinaison autonome de boost.nowide), c'est la partie windows i/o en utf-8.
https://www.boost.org/doc/libs/maste...tml/index.html
https://github.com/boostorg/nowide
https://github.com/boostorg/nowide/archive/master.zip

yaml-cpp, moteur pour la sérialisation/désérialisation de données au format YAML.
https://yaml.org/
https://github.com/jbeder/yaml-cpp
https://github.com/jbeder/yaml-cpp/wiki/Tutorial

---

???

Citation:

---

Pour l'activation de la couleur, voici un "snippet" éventuellement à élaborer...
Le code source devra être enregistré en utf-8, sans bom, et si besoin signalé au compilateur, (/source-charset:utf-8)

---

Ok ! Mais pas wstring ?
https://learn.microsoft.com/fr-fr/cp...?view=msvc-170
???
--

Merci pour tous : bacelar, kaitlyn, Médinoc

Citation:

---

Microsoft Visual Studio Community*2022
Version 17.3.6
VisualStudio.17.Release/17.3.6+32929.385
Microsoft .NET Framework
Version 4.8.04084

Version installée : Community

Visual C++*2022 00482-90000-00000-AA289
Microsoft Visual C++*2022

Adaptateur de test pour Boost.Test 1.0
Permet d'utiliser les outils de test de Visual Studio avec des tests unitaires écrits pour Boost.Test. Les conditions d'utilisation et les mentions tierces sont disponibles dans le répertoire d'installation de l'extension.

Adaptateur de test pour Google Test 1.0
Active l'utilisation des outils de test de Visual Studio avec les tests unitaires écrits pour Google Test. Les conditions d'utilisation et les notifications tierces sont disponibles dans le répertoire d'installation de l'extension.

ASP.NET and Web Tools 17.3.376.3011
ASP.NET and Web Tools

Gestionnaire de package NuGet 6.3.0
Gestionnaire de package NuGet dans Visual Studio. Pour plus d'informations sur NuGet, visitez https://docs.nuget.org/

Microsoft JVM Debugger 1.0
Provides support for connecting the Visual Studio debugger to JDWP compatible Java Virtual Machines

Outils Azure App Service*v3.0.0 17.3.376.3011
Outils Azure App Service*v3.0.0

Outils C# 4.3.0-3.22470.13+80a8ce8d5fdb9ceda4101e2acb8e8eb7be4ebcea
Composants C# utilisés dans l'IDE. Selon votre type de projet et vos paramètres, une version différente du compilateur peut être utilisée.

Outils TypeScript 17.0.10701.2001
Outils TypeScript pour Microsoft Visual Studio

Outils Visual Basic 4.3.0-3.22470.13+80a8ce8d5fdb9ceda4101e2acb8e8eb7be4ebcea
Composants Visual Basic utilisés dans l'IDE. Selon votre type de projet et vos paramètres, une version différente du compilateur peut être utilisée.

Syntax Visualizer 1.0
An extension for visualizing Roslyn SyntaxTrees.

Visual Studio IntelliCode 2.2
Développement assisté par intelligence artificielle pour Visual Studio.

---

Ok, vous semblez maîtriser les bases des classes en C++ (si les codes que vous postez ont été faits récemment).

Même un peu plus que les bases (utilisation de "friend").

Prenez un peu de temps pour utiliser des noms "parlant", quitte à renommer les classes/fonctions/variables plus tard. Visual Studio et les autres IDE modernes rendent ce type de renommage très facile.
Parce que "C_S", c'est moyennement explicatif de l'usage de cette classe.

Quelques trucs perfectible comme utiliser systématiquement l'espace de nom "std::"dans les fichiers d'en-tête et pas "using namespace", déclaration de plusieurs champs en 1 ligne, beaucoup de champs me semblant inutiles en utilisant les "bons" types, répartition des fonctions qui ne semble pas suivre les principes SOLID, etc...
Mais rien de rédhibitoire.

Citation:

---

Envoyé par Laurent_B_

Mais :
c_s.h et c_s.cpp
cinema.h et cinema.cpp
serie.h et serie.cpp

.h et/ou .cpp ? Oui ou non ?

---

Je comprends pas trop la question.
Vous nous avez posté les .h. Chacune des 3 classes contiennent au moins la déclaration d'une fonction, il faudrait donc un .cpp par classe, contenant les définitions des fonctions de chaque classe.
"c_s.cpp" devrait contenir la définition de la fonction "const int C_S::afficher_AD(wstring a, wstring& ad, wstring _T)" et du constructeur sans paramètre de cette classe : "C_S::C_S()".
"cinema.cpp" contiendra la bonne dizaine de fonctions et son constructeur sans paramètre de la classe Cinema.
"serie.cpp" contiendra sa bonne vingtaine de fonctions et son constructeur sans paramètre de la classe Serie.

Attention, dans les classes Cinema et Serie, il y a beaucoup de tableau à la "C" qu'il vaudrait mieux remplacer par des "std::vector" du "C++".

Citation:

---

Envoyé par Laurent_B_

Citation:

---

void Console:: PrintStringW(const std::wstring& mes, unsigned int x, unsigned int y)
et/ou
void Console:: PrintStringW(const std::wstring& mes, unsigned int x)
et/ou
void Console:: PrintStringW(const std::wstring& mes, unsigned int x1, unsigned int x2)

---

---

Le C++ permet d'avoir des fonctions qui portent le même nom, du moment qu'elles aient des signatures (types des paramètres) différentes.
Donc pour "void Console:: PrintStringW(const std::wstring& mes, unsigned int x, unsigned int y)" et "void Console:: PrintStringW(const std::wstring& mes, unsigned int x)" en même temps, cela ne pose pas de problème.
Avec la 3ème fonction, il y a conflit avec la première car elles ont la même signature (le nom des paramètres ne sont pas pris en compte).
"PrintStringW" est sensé afficher un texte "formaté" dans la console.
La première "PrintStringW" permet de fournir des cordonnées (x,y) dans la console où sera afficher le "message" (mes).
La seconde "PrintStringW" ne prend que la valeur x, permettant de positionner le message à la position "x" horizontalement, et utilisant la position verticale courante de la console (le caret).
La 3ème "PrintStringW" est une variation dans le cas les paramètres de cette cochonnerie de "Console_Lire_txt" n'interprète pas ses paramètres comme des positions en (x,y) mais en taille d'indentation entre 2 "colonnes" d'affichage de message type "xxxxx : yyyyy".
C'est pour cela que le nom des paramètres ne sont pas les même : (x,y) VS (x1,x2).

Mais vous avez raison, les signatures 1 et 3 ne peuvent coexister ensemble.
Si la 3ème signature est vraiment "utile", il faut changer la signature de la première pour qu'elle soit plus "explicite" pour son usage:

Code:

---

void Console:: PrintStringW(const std::wstring& mes, std::pair<unsigned int,unsigned int> xy)

---

Cette propriété du C++ s'appelle la surcharge (overloading en anglais) des fonctions.

Citation:

---

Envoyé par Laurent_B_

const int afficher_Genre(...) et const int afficher_Soundtrack(...)
???

J'ai oublié...

---

C'est des fonctions que vous avez déclarées dans les fichiers d'en-tête que vous avez posté (au moins pour afficher_Soundtrack).
Leurs définitions doivent être dans les .cpp correspondant à leur classe.

Si le nom de ces méthodes sont "correctes", elles doivent faire ce qui est indiqué dans leur nom, afficher des machins, vraisemblablement dans la console.

Les fonctions que je vous ai proposé : "void Console:: Print...(...)" déporte la responsabilité de l'affichage à la console plutôt que laisser chaque classe faire sa tambouille.
Mais on peut "travailler" sur vos implémentations "const int afficher_Genre(...)" et "const int afficher_Soundtrack(...)".

Citation:

---

https://stacklima.com/convention-de-nommage-en-c/

---

Convention de nommage assez classique, mais plutôt adapté pour du développement sous Unix.
Des formules/tournures de phrase de temps en temps ambiguës, je pense lié à la traduction.
Mais l'essentiel est là.
Une convention de nommage n'est pas "unique" mais c'est bien de s'en inspirer pour la "votre".
Et essayez de bien analyser le "comment du pourquoi" de chaque règle et de faire en sorte que la "votre" réponde aux mêmes impératifs.
Il est souvent possible d'avoir des conventions de nommage légèrement différentes en fonction des outils que vous utilisez mais aussi dans différentes parties d'un très gros projet pour "distinguer" ces parties et donc savoir quand on mélange des codes qui n'ont pas à être "ensemble".

Il faudra donc tendre à homogénéisé votre code selon VOTRE convention de nommage.

Citation:

---

Interface ???

---

Une interface entre l'utilisateur et le programme : une IHM Interface_Homme_Machine

Pour votre cas, cette interface passe par la console.

Les librairies que mentionne @kaitlyn sont des "outils" supplémentaires pour "facilement" faire des projets qui affichent dans une console du texte "évolué".

Citation:

---

Ok ! Mais pas wstring ?
https://learn.microsoft.com/fr-fr/cp...?view=msvc-170
???

---

@kaitlyn utilise un mode d'encodage du code source assez classique car fonctionnant avec beaucoup d'environnement de compilation.
Il ne faut pas confondre l'encode du code source, et l'encodage utilisé dans les variables du programme en cours d'exécution.
"wstring" indique l'encodage utilisé dans la variable en cours d'exécution.
La manière dont on l'initialise depuis notre code source peut devenir assez complexe, cf. la référence sur le site M$ que vous avez donné.

C'est pour cela que je vous avait conseillé de ne pas mettre ces chaînes de caractère dans le code source mais dans un fichier "à part".
Mais cela peut être assez lourd.

Si vous voulez toujours utiliser des littéraux, il faudra trouver la bonne configuration de votre éditeur de code et des options de compilation pour que le résultat dans la console soit "correcte".
Si vous utilisez toujours les mêmes réglages des outils et que vous spécifiez ces littéraux toujours de la même manière et dans toujours le même type de variables C++, alors le résultat sera "cohérent".

@Laurent_B_, vous utilisez la dernière version de Visual Studio, et c'est très bien.
Je n'ai pas cette version sous la main, malheureusement.
Mais voulez-vous vraiment reprendre de zéro ou comprendre votre code ?

Bonjour bacelar,

Citation:

---

Ok, vous semblez maîtriser les bases des classes en C++ (si les codes que vous postez ont été faits récemment).

Même un peu plus que les bases (utilisation de "friend").

Prenez un peu de temps pour utiliser des noms "parlant", quitte à renommer les classes/fonctions/variables plus tard. Visual Studio et les autres IDE modernes rendent ce type de renommage très facile.

---

Ben oui !

Citation:

---

Parce que "C_S", c'est moyennement explicatif de l'usage de cette classe.

---

const class Titre (La sœur !!! (c'est tout !))

const class Titre;
const class Cinema;
et
const class Serie;

Citation:

---

Quelques trucs perfectible comme utiliser systématiquement l'espace de nom "std::"dans les fichiers d'en-tête et pas "using namespace", déclaration de plusieurs champs en 1 ligne, beaucoup de champs me semblant inutiles en utilisant les "bons" types, répartition des fonctions qui ne semble pas suivre les principes SOLID, etc...
Mais rien de rédhibitoire.

---

Ok ! En cour !!!

Citation:

---

Je comprends pas trop la question.
Vous nous avez posté les .h. Chacune des 3 classes contiennent au moins la déclaration d'une fonction, il faudrait donc un .cpp par classe, contenant les définitions des fonctions de chaque classe.
"c_s.cpp" devrait contenir la définition de la fonction "const int C_S::afficher_AD(wstring a, wstring& ad, wstring _T)" et du constructeur sans paramètre de cette classe : "C_S::C_S()".
"cinema.cpp" contiendra la bonne dizaine de fonctions et son constructeur sans paramètre de la classe Cinema.
"serie.cpp" contiendra sa bonne vingtaine de fonctions et son constructeur sans paramètre de la classe Serie.

---

const class Titre; (c_s.h et c_s.cpp) : ok !
const class Cinema; (cinema.h et cinema.cpp) : ok !
const class Serie; (serie.h et serie.cpp) : ok !
Mais :

Code:

---

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

class Cinema; class Serie; const class Titre { friend class Cinema; friend Serie; public: Titre(void); ~Titre(); const int afficher_AD(std::wstring& a, std::wstring& ad, std::wstring const& _T); ... protected: std::wstring ad = L""; bool ad_ = false; ... private: ... };   const class Cinema { ... };   const class Serie { ... };

---

Ou

Code:

---

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

const class Titre { public: Titre(void); ~Titre(); const int afficher_AD(std::wstring& a, std::wstring& ad, std::wstring const& _T); ... protected: std::wstring ad = L""; bool ad_ = false; ... private: ... };   const class Titre; const class Cinema { friend class Titre; ... };   const class Titre; const class Serie { friend class Titre; ... };

---

J'ai oublié !!!

Citation:

---

Attention, dans les classes Cinema et Serie, il y a beaucoup de tableau à la "C" qu'il vaudrait mieux remplacer par des "std::vector" du "C++".

---

Oui, je sais ! std:: !

Citation:

---

Le C++ permet d'avoir des fonctions qui portent le même nom, du moment qu'elles aient des signatures (types des paramètres) différentes.
Donc pour "void Console:: PrintStringW(const std::wstring& mes, unsigned int x, unsigned int y)" et "void Console:: PrintStringW(const std::wstring& mes, unsigned int x)" en même temps, cela ne pose pas de problème.

---

Ok !

Citation:

---

.
Avec la 3ème fonction, il y a conflit avec la première car elles ont la même signature (le nom des paramètres ne sont pas pris en compte).
"PrintStringW" est sensé afficher un texte "formaté" dans la console.
La première "PrintStringW" permet de fournir des cordonnées (x,y) dans la console où sera afficher le "message" (mes).
La seconde "PrintStringW" ne prend que la valeur x, permettant de positionner le message à la position "x" horizontalement, et utilisant la position verticale courante de la console (le caret).

---

Ok ! Par contre : Console:: ! Comment faire ???

Citation:

---

La 3ème "PrintStringW" est une variation dans le cas les paramètres de cette cochonnerie de "Console_Lire_txt" n'interprète pas ses paramètres comme des positions en (x,y) mais en taille d'indentation entre 2 "colonnes" d'affichage de message type "xxxxx : yyyyy".
C'est pour cela que le nom des paramètres ne sont pas les même : (x,y) VS (x1,x2).

---

Ok !

Citation:

---

Mais vous avez raison, les signatures 1 et 3 ne peuvent coexister ensemble.
Si la 3ème signature est vraiment "utile", il faut changer la signature de la première pour qu'elle soit plus "explicite" pour son usage:
Code : Sélectionner tout - Visualiser dans une fenêtre à part

void Console:: PrintStringW(const std::wstring& mes, std::pair<unsigned int,unsigned int> xy)

Cette propriété du C++ s'appelle la surcharge (overloading en anglais) des fonctions.

Citation Envoyé par Laurent_B_ Voir le message
const int afficher_Genre(...) et const int afficher_Soundtrack(...)
???

J'ai oublié...
C'est des fonctions que vous avez déclarées dans les fichiers d'en-tête que vous avez posté (au moins pour afficher_Soundtrack).
Leurs définitions doivent être dans les .cpp correspondant à leur classe.

Si le nom de ces méthodes sont "correctes", elles doivent faire ce qui est indiqué dans leur nom, afficher des machins, vraisemblablement dans la console.

Les fonctions que je vous ai proposé : "void Console:: Print...(...)" déporte la responsabilité de l'affichage à la console plutôt que laisser chaque classe faire sa tambouille.

---

Ok ! Mince !

Citation:

---

Mais on peut "travailler" sur vos implémentations "const int afficher_Genre(...)"

---

Moi :

Code:

---

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

const int afficher_Genre(std::wstring& g, std::wstring const& _T, std::vector<std::wstring>& G, const std::vector<std::wstring>& GG) { // Genre std::size_t pos; static const basic_string <wchar_t>::size_type npos = -1; pos = g.find(L".txt"); if (pos == npos) { B.Ok_T(L"Erreur !!!"); E.afficher_X(-1, _T, g + L" erreur (" + g + L") !!!"); return EXIT_FAILURE; } std::wstring wstr = g.substr(0, pos); std::vector<std::wstring>gg; try { gg = afficher_fichier_lire(_T, L", ", false); } catch (runtime_error const& exception) { std::wcout << L"Erreur : " << exception.what() << std::endl; } // Ok ! std::vector <std::wstring>::iterator iter; for (iter = gg.begin(); iter != gg.end(); iter++) { if (std::find(GG.begin(), GG.end(), *iter) != GG.end()) G.push_back(*iter); else { B.Ok_T(L"const int afficher_Genre() : Attention !!!"); return EXIT_FAILURE; } } #if afficher_Genre_ == true int i = 0; for (iter = G.begin(); iter != G.end(); iter++) { wstr += *iter; i++; if (i != G.size()) wstr += L", "; } B.Ok_W(wstr + L'}'); // Plus tard !!! //B.Ok_T(L"const int afficher_Genre() : Ok !"); #endif return EXIT_SUCCESS; }

---

Citation:

---

et "const int afficher_Soundtrack(...)".

---

Oui : exemple ?

Citation:

---

Convention de nommage assez classique, mais plutôt adapté pour du développement sous Unix.
Des formules/tournures de phrase de temps en temps ambiguës, je pense lié à la traduction.
Mais l'essentiel est là.
Une convention de nommage n'est pas "unique" mais c'est bien de s'en inspirer pour la "votre".
Et essayez de bien analyser le "comment du pourquoi" de chaque règle et de faire en sorte que la "votre" réponde aux mêmes impératifs.
Il est souvent possible d'avoir des conventions de nommage légèrement différentes en fonction des outils que vous utilisez mais aussi dans différentes parties d'un très gros projet pour "distinguer" ces parties et donc savoir quand on mélange des codes qui n'ont pas à être "ensemble".

Il faudra donc tendre à homogénéisé votre code selon VOTRE convention de nommage.

---

Ok !

Citation:

---

Une interface entre l'utilisateur et le programme : une IHM Interface_Homme_Machine

Pour votre cas, cette interface passe par la console.

Les librairies que mentionne @kaitlyn sont des "outils" supplémentaires pour "facilement" faire des projets qui affichent dans une console du texte "évolué".

---

Ok ! Exemple ?

Citation:

---

@kaitlyn utilise un mode d'encodage du code source assez classique car fonctionnant avec beaucoup d'environnement de compilation.
Il ne faut pas confondre l'encode du code source, et l'encodage utilisé dans les variables du programme en cours d'exécution.
"wstring" indique l'encodage utilisé dans la variable en cours d'exécution.
La manière dont on l'initialise depuis notre code source peut devenir assez complexe, cf. la référence sur le site M$ que vous avez donné.

C'est pour cela que je vous avait conseillé de ne pas mettre ces chaînes de caractère dans le code source mais dans un fichier "à part".
Mais cela peut être assez lourd.

Si vous voulez toujours utiliser des littéraux, il faudra trouver la bonne configuration de votre éditeur de code et des options de compilation pour que le résultat dans la console soit "correcte".
Si vous utilisez toujours les mêmes réglages des outils et que vous spécifiez ces littéraux toujours de la même manière et dans toujours le même type de variables C++, alors le résultat sera "cohérent".

---

Ah oui !

Mais :

Citation:

---

you /t s "e:\Séries.[]\+++\B\Barbares.[2020-2022 Netflix]\2020-10-23\Avec.txt"

---

Citation:

---

Laurence Rupp : Arminius
Jeanne Goursaud : Thusnelda
David Schütter : Folkwin Wolfspeer
Bernhard Schütz : Segestes
Gaetano Aronica : Varus
Jeremy Miliker : Ansgar
…

---

u8"…" ===> L"." ou L"..." : Problème ???

Merci beaucoup ;)