Forum du club des d�veloppeurs et IT Pro - C++

Mod pour MAME

deedolith — Tue, 14 Apr 2026 08:02:00 GMT

Bonjour,

Je souhaite ajouter une fonctionnalit� � MAME:
Lorsque un jeux de tuiles est affich� (touche F4), ajouter la possibilit� de le sauvegarder dans un fichier PNG via la touche F12) tout en gardant les informations de transparence.

J'ai repris le code source de Steve Moody (https://eab.abime.net/showthread.php?t=41610&page=3) pour l'int�grer au code source,
voir la classe gfx_writer sur mon github (https://github.com/Deedolith/mame-gf...ontend/mame/ui).

Cela fonctionne bien, par contre je n'ai pas compris comment d�tecter les pixels transparents.
La documentation de MAME indique comment g�rer la transparence, mais d'apr�s ce que j'ai compris, cela concerne l'affichage sur un �cran, aucune id�e si cela peut �tre adapt� pour un bitmap:
https://wiki.mamedev.org/index.php?t...tilemap_system

Avis sur vieux livres C++ offerts

Quami — Sun, 15 Mar 2026 14:34:00 GMT

Bonjour � tous,
Un voisin qui d�m�nage m'a offert sa collection de livres d'informatiques. Comme j'ai un projet personnel en C++ cette ann�e, je souhaite votre avis sur la pertinence des ces ouvrages pas particuli�rement r�cents :

C++ en action de D. Ryan Stephens (2006)
Professional Multicore Programming: Design and Implementation for C++ Developers (2008)
C++ Template Metaprogramming de David Abrahams (2004)
Beyond the C++ Standard Library: An Introduction to Boost (2005)
undle of Algorithms in C++, Parts 1-5: Fundamentals, Data Structures, Sorting, Searching, and Graph Algorithms (2002)
Modern C++ Design: Generic Programming and Design Patterns Applied (2001)
Secure Programming Cookbook for C and C++ (2003)
The Boost Graph Library: User Guide and Reference Manual (2002)
La programmation orient�e de Hugues Bersini (2008)
Standards de programmation en C++ de Herb SUTTER et Andrei ALEXANDRESCU

J'ai un peu �tudi� le C++ il y a longtemps, je ne sais pas si les librairies, et la pratique du C++ ont tellement �volu�es que ces livres sont p�rim�s ou � �viter. Par contre pour mon projet j'aurai � travailler sur des graphes.
Votre avis ?

Incompr�hension erreur "invalid conversion from 'DWORD' {aka 'long unsigned int'} to 'DWORD* (*)()"

jmblib — Sat, 20 Dec 2025 15:35:37 GMT

Bonjour j'ai un probl�me de compilation.

J'ai isol� mon probl�me avec le petit source suivant :

Code:

1
2
3
4
5
6
7
8
9
10
#include 
 
void ToCallVoid(DWORD errno) { }
 
int Caller(DWORD errno) {
	ToCallVoid(errno);
	return 0;
}
 
int wmain (int argc, wchar_t **argv, wchar_t **envp) { return 0; }

J'ai l'erreur suivante :

.\src\testp.cpp:6:20: error: invalid conversion from 'DWORD' {aka 'long unsigned int'} to 'DWORD* (*)()' {aka 'long unsigned int* (*)()'} [-fpermissive]
    6 |         ToCallVoid(errno);
      |                    ^~~~~
      |                    |
      |                    DWORD {aka long unsigned int}
.\src\testp.cpp:3:23: note: initializing argument 1 of 'void ToCallVoid(DWORD* (*)())'
    3 | void ToCallVoid(DWORD errno) { }
      |                       ^

J'utilise : c++.exe (MinGW-W64 x86_64-ucrt-posix-seh, built by Brecht Sanders, r3) 15.2.0

J'ai essay� diff�rentes options de compilation mais toujours le m�me r�sultat.
Le plus simple : c++.exe -o .\src\testp.cpp.obj -c .\src\testp.cpp
donne bien la m�me erreur.

Quelqu'un a-t-il une explication ?

Probl�me SDL_ttf et Code Blocks

slmh1 — Wed, 03 Dec 2025 10:08:11 GMT

Bonjour,
J'utilise Code Blocks 20.03 (compilateur GNU GCC compiler) avec la librairie graphique SDL2 (SDL-devel-2.0.3-mingw). Je veux faire de l'affichage de texte et utilise SDL2_ttf-devel-2.0.18-mingw.
Mes 3 premi�res lignes sont #include #include ou #include et #include .
Quand je click sur Build pour v�rifier mon programme j'ai "fatal erreur: SDL.h : No such file or directory" que cela soit dans la prog main.cpp ou SDL_ttf.h alors que ce dernier fichier est dans : Project - Build options - Projet Texte -linker settings (dans plusieurs endroits) comme le montre le fichier Projet Texte linker settings.jpg.
J'ai aussi mes 3 fichiers comme le montre Projet Texte Search dir.jpg que cela sur linker avec lib ou compiler avec include et mon fichier SDL2.dll est mis dans le r�pertoire de mon projet.
Est-ce que je pourrais avoir une solution pour r�soudre ce probl�me?
Merci.

Images attach�es

sstream et saisie cin

emmesse — Fri, 28 Nov 2025 00:26:33 GMT

Bonjour,

pourquoi b est toujours � 0 ?

une id�e ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include 
#include 
#include 
 
int main(){
  std::cout<<"a= ";
  int a;
  std::string saisie;
  std::stringstream geek;
  std::cin>>saisie;
  geek<>a;
  geek.flush();
  std::cout<<"b= ";
  int b;
  std::cin>>saisie;
  geek<>b;
  std::cout<' '<}

Code:

1
2
3
4
$ ./a.out 
a= 56
b= 12
56 0

boucle infinie presque r�solu

emmesse — Thu, 09 Oct 2025 11:45:54 GMT

Bonjour,

Lorsque je rentre un caractere non num�rique quand cin demande un chiffre, j'ai une boucle infinie.
avec cin.clear et cin ignore, �a va mieux. Mais si je rentre quoi que ce soit, le programme ne va pas plus loin:

Code:

1
2
3
4
5
6
  do{
    std::cout<<"minimum 2, maximum "<" :";
    std::cin.ignore(std::numeric_limits::max(),'\n');
    std::cin.clear();
    std::cin>>nbjoueurs;
  }while(nbjoueurs<2 || nbjoueurs>max_joueurs);

Code:

1
2
$ ./a.out 
combien de joueur ? minimum 2, maximum 6 :2

une id�e?

GCC 16 am�liore les diagnostics avec des erreurs C++ plus claires et une sortie HTML

Jade Emy — Wed, 08 Oct 2025 08:29:40 GMT

GCC 16 introduit des am�liorations en mati�re de diagnostic, notamment des messages d'erreur C++ plus clairs, une sortie HTML exp�rimentale pour les rapports interactifs et une analyse statique am�lior�e

GCC 16 introduit des am�liorations majeures en mati�re de diagnostic, notamment des messages d'erreur C++ plus clairs, une sortie HTML exp�rimentale pour les rapports interactifs, le passage au format SARIF et une analyse statique am�lior�e pour la d�tection des erreurs d'ex�cution. Pr�sent�es par David Malcolm de Red Hat, ces mises � jour visent � rationaliser le d�bogage et � stimuler la productivit� des d�veloppeurs dans le cadre de projets complexes.

La GNU Compiler Collection (GCC) est une collection de compilateurs du projet GNU qui prend en charge divers langages de programmation, architectures mat�rielles et syst�mes d'exploitation. La Free Software Foundation (FSF) distribue GCC en tant que logiciel libre sous licence GNU General Public License (GNU GPL). GCC est un composant cl� de la cha�ne d'outils GNU qui est utilis�e pour la plupart des projets li�s � GNU et au noyau Linux. Avec environ 15 millions de lignes de code en 2019, GCC est l'un des plus grands programmes libres existants. Il a jou� un r�le important dans la croissance des logiciels libres, � la fois comme outil et comme exemple.

Dans le monde en constante �volution du d�veloppement logiciel, la GNU Compiler Collection (GCC) continue de repousser les limites, avec sa prochaine version 16 qui devrait introduire des am�liorations significatives aux outils de diagnostic qui pourraient remodeler la fa�on dont les d�veloppeurs d�boguent et optimisent le code. Selon un rapport r�cent, ces mises � jour s'appuient sur des ann�es d'am�liorations it�ratives, en mettant l'accent sur des messages d'erreur et d'avertissement plus clairs et plus exploitables. Au c�ur de ces progr�s se trouve David Malcolm, un ing�nieur de Red Hat r�put� pour ses contributions au cadre de diagnostic de GCC, qui a d�voil� les d�tails lors de sa pr�sentation au GNU Tools Cauldron 2025 � Porto, au Portugal.

Les am�liorations ciblent des domaines cl�s tels que les diagnostics C++, o� GCC 16 vise � fournir des commentaires plus pr�cis sur les structures de code complexes, r�duisant ainsi la frustration souvent associ�e � la programmation intensive en mod�les. Il ne s'agit pas seulement de changements cosm�tiques, mais aussi de doter les d�veloppeurs d'outils qui acc�l�rent le d�pannage dans les projets � grande �chelle, des applications d'entreprise aux noyaux open source.

Sortie HTML : une r�volution pour l'analyse visuelle

L'une des fonctionnalit�s remarquables de GCC 16 est la prise en charge exp�rimentale de la sortie des diagnostics au format HTML, une initiative qui promet de rendre l'analyse des erreurs plus interactive et plus conviviale. Cette option permet aux compilateurs de g�n�rer des rapports richement format�s, avec des hyperliens, des surlignages cod�s par couleur et des extraits de code int�gr�s, ce qui permet aux d�veloppeurs de naviguer parmi les probl�mes aussi facilement que sur une page web. Activ�e via un indicateur sp�cifique, cette sortie HTML se positionne comme une alternative sup�rieure pour la r�vision post-compilation, en particulier dans les environnements d'�quipe o� le partage des donn�es de diagnostic est crucial.

En compl�ment, GCC 16 abandonne progressivement son ancienne sortie JSON pour les diagnostics au profit de la norme SARIF (Static Analysis Results Interchange Format), qui offre une meilleure interop�rabilit� avec les outils modernes d'analyse de code. Comme l'a expliqu� Malcolm dans son expos�, cette �volution refl�te une tendance plus large de l'industrie vers des formats standardis�s et lisibles par machine qui s'int�grent de mani�re transparente aux pipelines d'int�gration continue.

Am�liorations de l'analyse statique et au-del�

En approfondissant la question, les mises � jour s'�tendent � l'option -fanalyzer, qui alimente les capacit�s d'analyse statique de GCC. Les am�liorations en cours dans ce domaine comprennent une meilleure d�tection des erreurs d'ex�cution potentielles, telles que les d�r�f�rencements de pointeurs nuls ou les d�bordements de tampon, avec des diagnostics qui int�grent d�sormais davantage d'informations contextuelles comme les chemins d'ex�cution. Ces am�liorations sont particuli�rement importantes pour les logiciels critiques pour la s�curit� dans des secteurs tels que l'a�rospatiale et l'automobile, o� la d�tection pr�coce des bogues peut �viter des pannes co�teuses.

De plus, libdiagnostics, la biblioth�que sous-jacente qui g�re le rendu des sorties de GCC, b�n�ficie de mises � niveau qui am�liorent sa flexibilit�. Les d�veloppeurs peuvent s'attendre � des comportements de diagnostic plus personnalisables, permettant des flux de travail sur mesure qui s'alignent sur les besoins sp�cifiques des projets, qu'il s'agisse de syst�mes embarqu�s ou de calcul haute performance.

Implications pour l'�cosyst�me des d�veloppeurs

Pour les initi�s du secteur, ces changements t�moignent de la volont� de GCC de rester comp�titif face � des compilateurs tels que Clang. En privil�giant la facilit� d'utilisation, gr�ce � des fonctionnalit�s telles que les sorties HTML et le traitement raffin� du C++, GCC 16 pourrait r�duire les obstacles pour les nouveaux venus tout en permettant aux v�t�rans de s'attaquer � des bases de code de plus en plus complexes. Le travail de Malcolm met en �vidence l'investissement de Red Hat dans les outils open source, ce qui pourrait influencer l'�volution des diagnostics dans d'autres compilateurs.

� l'avenir, la sortie compl�te de GCC 16 l'ann�e prochaine devrait stimuler son adoption dans les distributions Linux et au-del�, favorisant ainsi un �cosyst�me plus robuste. Bien que des d�fis subsistent, tels que la garantie de la r�trocompatibilit�, ces r�visions diagnostiques positionnent GCC comme un pilier avant-gardiste dans le domaine du g�nie logiciel.

Source : David Malcolm au GNU Tools Cauldron 2025

Et vous ?

:fleche: Pensez-vous que cette am�lioration est cr�dible ou pertinente ?
:fleche: Quel est votre avis sur le sujet ?

Voir aussi :

:fleche: La version 15.1 de GCC est disponible avec un compilateur COBOL, un meilleur support pour les langages de programmation C, C++ et Rust, ainsi que de nombreuses autres am�liorations

:fleche: Le projet Safe C++, visant � doter le langage d'un mod�le de s�curit� inspir� de Rust, est mis de c�t� pour donner la priorit� aux � Profils �. Une alternative controvers�e propos�e par le cr�ateur du langage

:fleche: GCC 15 arrive : COBOL et Itanium sont int�gr�s, tandis qu'ALGOL-68 est jug� inadapt� � l'�re moderne. Les langages modernes doivent allier solidit� technique et r�ponse aux besoins concrets

Images attach�es

Array d'un struct

soa — Fri, 03 Oct 2025 10:47:49 GMT

Bonjour

Alors voil�, je code un programme pour un ESP32-P4 (MCU), et je suis face � une erreur de d�butant que je n'arrive pas � corriger.

Dans mon driver:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
typedef struct rex_device_struct{
  bool detected = false;
  char type[10];
};
 
 
rex_device_struct* RexDriver::rexDetected(){
  rex_device_struct *devices_struct = (rex_device_struct *)ps_malloc(sizeof(rex_device_struct*) * REX_MAX_DEVICES_SUPPORTED);
 
  for (uint8_t i; i < REX_MAX_DEVICES_SUPPORTED; i++){
    devices_struct[i].detected = false;
    strcpy(devices_struct[i].type, "");    
  }
 
  devices_struct[0].detected = true;
  strcpy(devices_struct[0].type, "REX12D");
 
  return (rex_device_struct*)devices_struct;
}

Quand je fait appel � cette fonction, je me retrouve avec des donn�es fauss�es, respectivement le champ "detected" est mal �valu� (il ne devrait afficher que le Rex device 1).
Pire quand j'appelle la commande free pour lib�rer la m�moire, le MCU plante (HEAP corrompu).

Code:

1
2
3
4
5
6
7
8
9
10
 
rex_device_struct *devices_struct = rex.rexDetected();
 
for (uint8_t i = 0; i < REX_MAX_DEVICES_SUPPORTED; i++){
        if (devices_struct[i].detected){
          Serial.printf("Rex device: %u: %s\n", i, devices_struct[i].type);
        }       
      }
      Serial.println((String)"Memory available in PSRAM : " +ESP.getFreePsram()+"/"+ESP.getPsramSize());
      //free(devices_struct);

R�sultat:

Citation:

Rex device: 0: REX12D
Rex device: 1: ��⪪�
Rex device: 3: ��맪�Z<��
Rex device: 5: ��ϫ��xV
Rex device: 9: ꪮ�=��
Rex device: 11: ��*�
Rex device: 13: �ꨪ��
Rex device: 15: ��=��

Bref, comme vous l'aurez deviner je d�bute en C++, et je m'arrache les cheveux.

Quelqu'un saurait m'aider � corriger l'erreur?

Merci!

je ne ma�trise pas tres bien les tuples

emmesse — Tue, 30 Sep 2025 19:34:29 GMT

Bonjour

je voudrai faire une liste dont les �l�ment soient des std::tuple.
Mais apr�s j'ai du mal � acc�der � ce int:

Code:

1
2
3
4
5
revenus.cpp: In function ‘int main()’:
revenus.cpp:17:34: error: no match for ‘operator[]’ (operand types are ‘__gnu_cxx::__alloc_traitsint> >, std::tupleint> >::value_type’ {aka ‘std::tupleint>’} and ‘int’)
   17 |   std::cout<[0][0][1]<

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include 
#include 
#include 
 
enum bien_immobilier{maison,appartement};
 
typedef std::tupleint>ligne_revenus;
 
int main(){
  std::vectorrevenus;
  std::array,6>revenus_joueur;
  ligne_revenus un_revenu=std::make_tuple(maison,250);
  ligne_revenus un_autre=std::make_tuple(appartement,150);
  revenus.push_back(un_revenu);
  revenus.push_back(un_autre);
  revenus_joueur[0]=revenus;
  std::cout<[0][0][1]<}

Cannot find bounds of current function

emmesse — Sun, 28 Sep 2025 17:28:52 GMT

Bonjour,

tout � la fin de l'�x�cution de mon programme (l'accolade fermante de main()), �a m'indique segmentation fault et le deboggeur gdb me dit Cannot find bounds of current function
serait-ce � cause de ce code?

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
#include 
#include 
#include 
#include 
 
#include "cashflow.hpp"
 
char jeu::getch() {
  char buf = 0;
  struct termios old = {0};
  if (tcgetattr(0, &old) < 0)
    perror("tcsetattr()");
  old.c_lflag &= ~ICANON;
  old.c_lflag &= ~ECHO;
  old.c_cc[VMIN] = 1;
  old.c_cc[VTIME] = 0;
  if (tcsetattr(0, TCSANOW, &old) < 0)
    perror("tcsetattr ICANON");
  if (read(0, &buf, 1) < 0)
    perror ("read()");
  old.c_lflag |= ICANON;
  old.c_lflag |= ECHO;
  if (tcsetattr(0, TCSADRAIN, &old) < 0)
    perror ("tcsetattr ~ICANON");
  return (buf);
}

sinon, les autres fichiers:
main.cpp

Code:

1
2
3
4
5
6
#include "cashflow.hpp"
 
int main() {
  jeu partie;
  partie.boucle_de_jeu();
}

cashflow.hpp

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
#ifndef CASHFLOW_HPP
#define CASHFLOW_HPP
 
#include 
#include 
#include 
 
enum bien_immobilier{
  maison_2chambres_1sdb,
  appartement_2chambres_1sdb,
  immeuble,
  maison_3chambres_2sdb,
  appartement_3chambre_2sdb
};
 
enum symbole_action{
  MYT4U
};
 
class jeu{
public:
  jeu();
  void boucle_de_jeu();
private:
  char getch();
  void tour();
  void avancer(short int participant,short int combien,bool &paye);
  void tour_voie_rapide(short int numparticipant);//à completer
  void carte_metier(short int joueur,short int metier);
  void affiche_perso(short int joueur);
  void init_imprevus();
  void empreinter(short int joueur);//à completer
  void calcul_cashflow(short int joueur);
  void choix_marche(short int joueur);//à completer
  void choix_opportunite(short int joueur);
  void choix_petite_opportunite(short int joueur);
  void choix_grosse_opportunite(short int joueur);
  void choix_imprevus(short int joueur);
  void pas_chomage(int joueur);
  void cas_multiniveau(short int joueur);
  void cas_charite(short int joueur);
  void vendre_bien_immo(short int joueur,bien_immobilier,int cout,int apport,int hypotheque,short int cashflow);//à completer
  void vendre_carte_bien(short int joueur,bien_immobilier,int cout,int apport,int hypotheque,short int cashflow);//à completer
  bool personne_gagne();
  void vendre_actions(short int joueur,symbole_action symbole,short int prix_du_jour);//à completer
  void acheter_actions(short int joueur,symbole_action symbole,short int prix_du_jour);//à completer
  std::string participant[6];
  short int nbjoueurs;
  std::string nomjoueur[6];
  short int numtour;
  short int case_courante[6];
  short int case_derniere[6];
  std::string profession[6];
  short int multiniveau[6];
  long int caisse[6];
  int revenu_passif[6];
  int revenus[6];
  int depenses[6];
  int cashflow[6];
  int salaire[6];
  int impots[6];
  int remboursement_hypotheque[6];
  int remboursement_pret_etudiant[6];
  int remboursement_pret_vehicule[6];
  int remboursement_par_carte_de_credit[6];
  int autre_depenses[6];
  int remboursement_pret_bancaire[6];
  int depenses_par_enfant[6];
  short int nb_enfants[6];
  int hypotheque[6];
  int pret_etudiant[6];
  int pret_vehicule[6];
  int carte_de_credit[6];
  int pret_bancaire[6];
  short int pieces_or[6];
  short int nb_bebe[6];
  bool voie_rapide[6];
  short int au_chomage[6];
  short int en_charite[6];
  short int petite_opportunite[3];//38
  short int grosse_opportunite[36];
  short int imprevus[42];
  std::string imprevus_objet[42]={
    "Nouveaux vêtements de sport","Adhésion au club de golf","Rendez-vous galant: dîner, concert et dessert","Nouvelles jantes de voiture","Nouvelle boule de booling",
    "Remplacement du système de climatisation de votre voiture","Nouveau fauteuil","Jet ski","Bijoux fantaisie","Nouvel ordinateur","Week-end dans une région viticole",
    "Visite au casino","Console de jeux nouvelle génération","Nouvelle montre","Nouvelle autoradio","Construction d'une salle de sport à la maison",
    "Achat d'une toile d'un peintre local","Rénovation de la cuisine","carte d'abonnement","Nouveaux vêtements","Tickets de concert","Bateau de pêche",
    "Nouvelle paire de lunettes de soleil","TV écran géant","Achat du tout dernier télépĥone","Participer au financement du mariage de votre enfant",
    "Première voiture de votre enfant","Nouveaux clubs de golf","Nouveau costume sur mesure","Robot ménager","Dîner entre amis","Pneus neufs",
    "Nouvelle raquette de tenis","Machine à café","Votre enfant a besoin d'un appareil dentaire","Fête d'anniversaire de votre enfant",
    "Cours particuliers pour vos enfants","Réunion de parents d'élèves","Repeindre la maison","Rendez-vous chez le dentiste","Vacances en famille",
    "Nouveau système audio"
  };
  short int imprevus_prix[42]={
    300,2000,500,2000,100,700,500,3000,400,1800,1000,800,600,200,700,3000,800,7500,1500,1000,200,5000,200,2500,300,2000,5000,800,1000,200,200,600,200,300,4000,500,500,500,600,700,2500,1500
  };
  short int index_imprevus;
  short int index_marche;
  short int index_petite;
  short int index_grosse;
  short int marche[5];
  short int metiers[12];
  bool gagne[6];  
};
#endif

cashflow.cpp

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
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
#include 
#include 
#include 
#include 
 
#include "cashflow.hpp"
 
std::string type_case[24]={
  "Opportunités",
  "Imprévus",
  "Opportunités",
  "Charité",
  "Opportunités",
  "Jour de paye",
  "Opportunités",
  "Marché",
  "Opportunités",
  "Imprévus",
  "Opportunités",
  "Réduction de personnel",
  "Opportunités",
  "Jour de paye",
  "Opportunités",
  "Marché",
  "Opportunités",
  "Imprévus",
  "Opportunités",
  "Bébé",
  "Opportunités",
  "Jour de paye",
  "Opportunités",
  "Marché"  
};
 
jeu::jeu():numtour(1),index_imprevus(0),index_marche(0),index_petite(0),index_grosse(0){
  std::random_device rd;
  std::default_random_engine eng(rd());
  std::uniform_int_distribution<short int> carte_imprevus(0,41);
  std::uniform_int_distribution<short int> carte_marche(0,39);
  std::uniform_int_distribution<short int> alea_metier(0,11);
  std::uniform_int_distribution<short int> carte_petite_opportunité(0,37);
  for(int i=0;i<42;i++)
    imprevus[i]=i;
  for(int i=0;i<41;i++){
    short int choix;
    do
      choix=carte_imprevus(eng);
    while(choix<=i);
    short int temp=imprevus[i];
    imprevus[i]=imprevus[choix];
    imprevus[choix]=temp;
  }
  for(int i=0;i<5;i++)
    marche[i]=i;
  for(int i=0;i<39;i++){
    short int choix;
    do
      choix=carte_marche(eng);
    while(choix<=i);
    short temp=marche[choix];
    marche[choix]=marche[i];
    marche[i]=temp;
  }
  for(int i=0;i<12;i++)
    metiers[i]=i;
  for(short int i=0;i<11;i++){
    short int choix;
    do
      choix=alea_metier(eng);
    while(choix<=i);
    short int temp=metiers[choix];
    metiers[choix]=metiers[i];
    metiers[i]=temp;
  }
  /*  for(int i=0;i<3;i++)//38
    petite_opportunite[i]=i;
  for(int i=0;i<2;i++){//37
    short int choix;
    do
      choix=carte_petite_opportunite(eng);
    while(choix<=i);
    short int temp=petite_opporunite[i];
    petite_opporunite[i]=petite_opporunite[choix];
    petite_opporunite[choix]=temp;
    }*/
  std::cout<<"combien de joueur ? ";
  do{
    std::cout<<"(max 6) :";
    std::cin>>nbjoueurs;
  }while(nbjoueurs<1 || nbjoueurs>6);
  short int nbmetiers=12;
  for(int joueur=0;joueur){
    case_courante[joueur]=0;
    en_charite[joueur]=0;
    au_chomage[joueur]=0;
    multiniveau[joueur]=0;
    gagne[joueur]=false;
    voie_rapide[joueur]=false;
    std::cout<<"\nNom du joueur n° "<1<<" : ";
    std::cin>>nomjoueur[joueur];
    short int choix;
    do{
      std::cout<<"choisissez une carte métier entre 1 et "<" : ";
      std::cin>>choix;
    }while(choix<1 || choix>nbmetiers);
    carte_metier(joueur,choix-1);
    for(int i=choix-1;i){
      metiers[i]=metiers[i+1];
    }
    nbmetiers--;
  }
}
 
void jeu::affiche_perso(short int joueur){
  std::cout<<"\nVotre profession est "<[joueur]<<"."<"Votre salaire est "<[joueur]<<" €."<"Vos impôts sont de "<[joueur]<<" €."<"Vos mensualités d'hypothèque sont de "<[joueur]<<" €."<"Vos remboursements mensuels du prêt étudiant sont de "<[joueur]<<" €."<"Vos remboursements mensuels du prêt véhicule sont de "<[joueur]<<" €."<"Vos remboursements par carte de crédit sont de "<[joueur]<<" €."<"Vos autres dépenses sont de "<[joueur]<<" €."<"Vos remboursements de prêts bancaires sont de "<[joueur]<<" €."<"Vos dépenses par enfant sont de "<[joueur]<<" €."<"Vous avez "<[joueur]<<" enfants."<"Vos revenus pasifs sont de "<[joueur]<<" €."<"Vos revenus sont de "<[joueur]<<" €."<"Vos dépenses sont de "<[joueur]<<" €."<"\nVotre cashflow est de "<[joueur]<<" €.\n"<"Vous avez "<[joueur]<<" € en caisse."<"Votre hypothèque est de "<[joueur]<<" €."<"Votre prêt étudian est de "<[joueur]<<" €."<"Votre prêt véhicule est de "<[joueur]<<" €."<"Vos crédits de carte de crédit sont de "<[joueur]<<" €."<"Vos prêts bancaires s'élèvent à "<[joueur]<<" €."<}  
 
void jeu::carte_metier(short int joueur,short int metier){
  switch(metiers[metier]){
  case 0:
    profession[joueur]="infirmière";
    salaire[joueur]=3100;
    impots[joueur]=600;
    remboursement_hypotheque[joueur]=400;
    remboursement_pret_etudiant[joueur]=100;
    remboursement_pret_vehicule[joueur]=100;
    remboursement_par_carte_de_credit[joueur]=200;
    autre_depenses[joueur]=600;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=200;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=3100;
    depenses[joueur]=2000;
    cashflow[joueur]=1100;
    caisse[joueur]=500;
    hypotheque[joueur]=47000;
    pret_etudiant[joueur]=6000;
    pret_vehicule[joueur]=5000;
    carte_de_credit[joueur]=4000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;
  case 1:
    profession[joueur]="mécanicien";
    salaire[joueur]=2000;
    impots[joueur]=400;
    remboursement_hypotheque[joueur]=300;
    remboursement_pret_etudiant[joueur]=0;
    remboursement_pret_vehicule[joueur]=100;
    remboursement_par_carte_de_credit[joueur]=100;
    autre_depenses[joueur]=400;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=100;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=2000;
    depenses[joueur]=1300;
    cashflow[joueur]=700;
    caisse[joueur]=700;
    hypotheque[joueur]=31000;
    pret_etudiant[joueur]=0;
    pret_vehicule[joueur]=3000;
    carte_de_credit[joueur]=3000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;
  case 2:
    profession[joueur]="avocat";
    salaire[joueur]=7500;
    impots[joueur]=1800;
    remboursement_hypotheque[joueur]=1100;
    remboursement_pret_etudiant[joueur]=300;
    remboursement_pret_vehicule[joueur]=200;
    remboursement_par_carte_de_credit[joueur]=200;
    autre_depenses[joueur]=1500;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=400;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=7500;
    depenses[joueur]=5100;
    cashflow[joueur]=2400;
    caisse[joueur]=2000;
    hypotheque[joueur]=115000;
    pret_etudiant[joueur]=7800;
    pret_vehicule[joueur]=11000;
    carte_de_credit[joueur]=7000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;
  case 3:
    profession[joueur]="concierge";
    salaire[joueur]=1600;
    impots[joueur]=300;
    remboursement_hypotheque[joueur]=200;
    remboursement_pret_etudiant[joueur]=0;
    remboursement_pret_vehicule[joueur]=100;
    remboursement_par_carte_de_credit[joueur]=100;
    autre_depenses[joueur]=300;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=100;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=1600;
    depenses[joueur]=1000;
    cashflow[joueur]=600;
    caisse[joueur]=600;
    hypotheque[joueur]=20000;
    pret_etudiant[joueur]=0;
    pret_vehicule[joueur]=4000;
    carte_de_credit[joueur]=3000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;
  case 4:
    profession[joueur]="médecin";
    salaire[joueur]=13200;
    impots[joueur]=3200;
    remboursement_hypotheque[joueur]=1900;
    remboursement_pret_etudiant[joueur]=700;
    remboursement_pret_vehicule[joueur]=300;
    remboursement_par_carte_de_credit[joueur]=200;
    autre_depenses[joueur]=2000;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=700;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=13200;
    depenses[joueur]=8300;
    cashflow[joueur]=4900;
    caisse[joueur]=3500;
    hypotheque[joueur]=202000;
    pret_etudiant[joueur]=150000;
    pret_vehicule[joueur]=19000;
    carte_de_credit[joueur]=10000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;
  case 5:
    profession[joueur]="gérante d'entreprise";
    salaire[joueur]=4600;
    impots[joueur]=900;
    remboursement_hypotheque[joueur]=700;
    remboursement_pret_etudiant[joueur]=100;
    remboursement_pret_vehicule[joueur]=100;
    remboursement_par_carte_de_credit[joueur]=200;
    autre_depenses[joueur]=1000;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=300;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=4600;
    depenses[joueur]=3000;
    cashflow[joueur]=1600;
    caisse[joueur]=400;
    hypotheque[joueur]=75000;
    pret_etudiant[joueur]=12000;
    pret_vehicule[joueur]=6000;
    carte_de_credit[joueur]=4000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;
  case 6:
    profession[joueur]="pilote de ligne";
    salaire[joueur]=9500;
    impots[joueur]=2000;
    remboursement_hypotheque[joueur]=1000;
    remboursement_pret_etudiant[joueur]=0;
    remboursement_pret_vehicule[joueur]=300;
    remboursement_par_carte_de_credit[joueur]=700;
    autre_depenses[joueur]=2000;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=400;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=9500;
    depenses[joueur]=6000;
    cashflow[joueur]=3500;
    caisse[joueur]=2500;
    hypotheque[joueur]=90000;
    pret_etudiant[joueur]=0;
    pret_vehicule[joueur]=15000;
    carte_de_credit[joueur]=22000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;
  case 7:
    profession[joueur]="chauffeur routier";
    salaire[joueur]=2500;
    impots[joueur]=500;
    remboursement_hypotheque[joueur]=400;
    remboursement_pret_etudiant[joueur]=0;
    remboursement_pret_vehicule[joueur]=100;
    remboursement_par_carte_de_credit[joueur]=100;
    autre_depenses[joueur]=600;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=200;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=2500;
    depenses[joueur]=1700;
    cashflow[joueur]=1100;
    caisse[joueur]=800;
    hypotheque[joueur]=38000;
    pret_etudiant[joueur]=0;
    pret_vehicule[joueur]=4000;
    carte_de_credit[joueur]=3000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;
  case 8:
    profession[joueur]="officier de police";
    salaire[joueur]=3000;
    impots[joueur]=600;
    remboursement_hypotheque[joueur]=400;
    remboursement_pret_etudiant[joueur]=0;
    remboursement_pret_vehicule[joueur]=100;
    remboursement_par_carte_de_credit[joueur]=100;
    autre_depenses[joueur]=700;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=200;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=3000;
    depenses[joueur]=1900;
    cashflow[joueur]=1100;
    caisse[joueur]=500;
    hypotheque[joueur]=46000;
    pret_etudiant[joueur]=0;
    pret_vehicule[joueur]=5000;
    carte_de_credit[joueur]=3000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;
  case 9:
    profession[joueur]="secretaire";
    salaire[joueur]=3100;
    impots[joueur]=500;
    remboursement_hypotheque[joueur]=400;
    remboursement_pret_etudiant[joueur]=0;
    remboursement_pret_vehicule[joueur]=100;
    remboursement_par_carte_de_credit[joueur]=100;
    autre_depenses[joueur]=600;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=100;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=2500;
    depenses[joueur]=1700;
    cashflow[joueur]=800;
    caisse[joueur]=700;
    hypotheque[joueur]=38000;
    pret_etudiant[joueur]=0;
    pret_vehicule[joueur]=4000;
    carte_de_credit[joueur]=3000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;
  case 10:
    profession[joueur]="ingénieur";
    salaire[joueur]=4900;
    impots[joueur]=1000;
    remboursement_hypotheque[joueur]=700;
    remboursement_pret_etudiant[joueur]=100;
    remboursement_pret_vehicule[joueur]=200;
    remboursement_par_carte_de_credit[joueur]=200;
    autre_depenses[joueur]=1000;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=200;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=4900;
    depenses[joueur]=3200;
    cashflow[joueur]=1700;
    caisse[joueur]=400;
    hypotheque[joueur]=75000;
    pret_etudiant[joueur]=12000;
    pret_vehicule[joueur]=7000;
    carte_de_credit[joueur]=5000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;
  case 11:
    profession[joueur]="enseignante";
    salaire[joueur]=3300;
    impots[joueur]=500;
    remboursement_hypotheque[joueur]=500;
    remboursement_pret_etudiant[joueur]=100;
    remboursement_pret_vehicule[joueur]=100;
    remboursement_par_carte_de_credit[joueur]=200;
    autre_depenses[joueur]=700;
    remboursement_pret_bancaire[joueur]=0;
    depenses_par_enfant[joueur]=200;
    nb_enfants[joueur]=0;
    revenu_passif[joueur]=0;
    revenus[joueur]=3300;
    depenses[joueur]=2100;
    cashflow[joueur]=1200;
    caisse[joueur]=400;
    hypotheque[joueur]=50000;
    pret_etudiant[joueur]=12000;
    pret_vehicule[joueur]=5000;
    carte_de_credit[joueur]=4000;
    pret_bancaire[joueur]=0;
    affiche_perso(joueur);
    break;    
  }
}
 
void jeu::boucle_de_jeu(){
  char encore;
  do{
    tour();
    std::cout<<"appuyez sur 'o' pour le tour suivant, ou 'n' pour quitter"<while( (encore=getch())!='o' && encore!='O' && encore!='n' && encore!='N')
    if(encore=='o' || encore=='O'){
      std::cout<<"êtes-vous sur de vouloir arrêter le jeu? (appuyez sur 'o' sortir du jeu, ou 'n' pour continuer le jeu)."<char confirme;
      while((confirme=getch())!='o' && confirme!='O' && confirme!='n' && confirme!='N')
	;
      if(confirme=='n' || confirme=='N')
	encore='o';
    }
  }while(personne_gagne() && (encore=='o' || encore=='O'));
}
 
 
bool jeu::personne_gagne(){
  bool retour=true;
  for(int joueur=0;joueur)
    if(gagne[joueur])
      retour=false;
  return retour;
}
 
void jeu::avancer(short int joueur,short int combien_case,bool &paye){
  paye=false;
  case_derniere[joueur]=case_courante[joueur];
  case_courante[joueur]+=combien_case;
  case_courante[joueur]%=24;
  paye= ( case_courante[joueur]>3 && case_courante[joueur]<11 && (case_derniere[joueur]>19 && case_derniere[joueur]<=23 || case_derniere[joueur]>=0 &&case_derniere[joueur]<3 ) )
    ||(case_courante[joueur]>11 && case_courante[joueur]<19 && case_derniere[joueur]>3 && case_derniere[joueur]<11)
    ||( ( case_courante[joueur]>19 && case_courante[joueur]<=23 || case_courante[joueur]>=0 && case_courante[joueur]<3) && case_derniere[joueur]>11 && case_derniere[joueur]<19)
    ||case_courante[joueur]==3
    ||case_courante[joueur]==11
    ||case_courante[joueur]==19;
}
 
void jeu::empreinter(short int joueur){
  long int pret;
  do{
    std::cout<<"Montant du prêt (doit être un multiple de 1000): ";
    std::cin>>pret;
  }while(pret % 1000 != 0);
  int interets=pret/10;
  std::cout<<"les intérêts pour ce prêt sont de "<" €."<[joueur]+=pret;
  caisse[joueur]+=pret;
  remboursement_pret_bancaire[joueur]+=interets;
  std::cout<<"les intérêts de tous vos crédits sont de "<[joueur]<<" €."<(joueur);
}
 
void jeu::calcul_cashflow(short int joueur){
  depenses[joueur]=impots[joueur]+remboursement_hypotheque[joueur]+remboursement_pret_etudiant[joueur]+remboursement_pret_vehicule[joueur]
    +remboursement_par_carte_de_credit[joueur]+autre_depenses[joueur]+remboursement_pret_bancaire[joueur]+depenses_par_enfant[joueur]*nb_enfants[joueur];
  /*calcul revenu passif*/
  revenus[joueur]=salaire[joueur]+revenu_passif[joueur];
  cashflow[joueur]=revenus[joueur]-depenses[joueur];
}
 
void jeu::tour(){
  std::random_device rd;
  std::default_random_engine eng(rd());
  std::uniform_int_distribution<short int> de6(1,6);
  for(int joueur=0;joueur){
    std::cout<<"\nTour n° "<" de "<[joueur]<if(voie_rapide[joueur])
      tour_voie_rapide(joueur);
    else{
      std::cout<<"Voulez-vous voir vos détails avant de jouer votre tour?"<char rep;
      while( (rep=getch())!='o' && rep!='O' && rep!='n' && rep!='N')
	;
      if(rep=='o'||rep=='O')
	affiche_perso(joueur);
      if(au_chomage[joueur]>0){
	std::cout<<"Vous êtes au chomage, vous sautez un tour."<[joueur]-=depenses[joueur];
	std::cout<<"votre caisse est de "<[joueur]<<" €."<[joueur]--;
      }
      else{
	bool paye1;
	bool paye2;
	short int de1=de6(eng);
	avancer(joueur,de1,paye1);
	short int de2=0;
	if(en_charite[joueur]>0){
	  std::cout<<"voulez-vous utiliser votre deuxième dé ? ";
	  char reponse;
	  while( (reponse=getch())!='o' && reponse!='O' && reponse!='n' && reponse!='N')
	    ;
	  if(reponse=='o'||reponse=='O'){
	    de2=de6(eng);
	    avancer(joueur,de2,paye2);
	    std::cout<<"case n° "<[joueur]<}
	  en_charite[joueur]--;
	}
	else
	  paye2=false;
	std::cout<<"\npremier dé : "<", deuxième dé : "<" : "<< type_case[case_courante[joueur]];
	if(paye1||paye2){
	  std::cout<<" : Vous êtes passé par la case jour de cashflow";
	}
	caisse[joueur]+=cashflow[joueur];
	if(paye1 && paye2){
	  std::cout<<" deux fois.";
	  caisse[joueur]+=cashflow[joueur];
	}
	else
	  std::cout<<'.';
	if(paye1||paye2){
	  std::cout<"Votre cashflow est de "<[joueur]<<" €."<(joueur);
	}
	std::cout<<"\nVotre caisse s'élève à "<[joueur]<if(type_case[case_courante[joueur]]=="Charité")
	  cas_charite(joueur);
	else if(type_case[case_courante[joueur]]=="Bébé" && nb_bebe[joueur]<3)
	  nb_bebe[joueur]++;
	else if(type_case[case_courante[joueur]]=="Réduction de personnel"){
	  au_chomage[joueur]=1;
	  en_charite[joueur]=0;
	}
	else if(type_case[case_courante[joueur]]=="Imprévus")
	  choix_imprevus(joueur);
	else if(type_case[case_courante[joueur]]=="Marché")
	  choix_marche(joueur);
	else if(type_case[case_courante[joueur]]== "Opportunités")
	  choix_opportunite(joueur);
      }
    }
  }
  numtour++;
}
 
void jeu::choix_imprevus(short int joueur){
  std::cout<<"\nVous êtes sur une case imprévus."<"\n"<[imprevus[index_imprevus]]<<" : "<[imprevus[index_imprevus]]<<" €"<if(nb_bebe[joueur]!=0
     || ( index_imprevus!=26 && index_imprevus!=27 && index_imprevus!=35 && index_imprevus!=36 && index_imprevus!=37 && index_imprevus!=38
	  && index_imprevus!=27) ){
    while( imprevus_prix[imprevus[index_imprevus]] > caisse[joueur] ){
      std::cout<<"Vous n'avez pas assez de liquidités, vous devez empreinter"<(joueur);
      std::cout<<"Votre caisse est de "<[joueur]<<" €."<}
    caisse[joueur]-=imprevus_prix[imprevus[index_imprevus]];
    index_imprevus++;
    std::cout<<"Votre caisse après l'imprévus est de "<[joueur]<<" €."<}
  else
    std::cout<<"Mais vous n'avez pas d'enfants"<}
 
void jeu::cas_multiniveau(short int joueur){
  std::random_device rd;
  std::default_random_engine eng(rd());
  std::uniform_int_distribution<short int> de6(1,6);
  if(multiniveau[joueur]==1 || multiniveau[joueur]==2){
    std::cout<<"Votre carte de marché multiniveau vous permet de lancer un dé."<short int de=de6(eng);
    std::cout<<"Le lancé du dé donne "<'.'<if(de>=4){
      std::cout<<"Le lancé du dé est de 4, 5 ou 6,votre carte de système de vente multiniveau vous rapporte donc 500€."<}
  }
  if(multiniveau[joueur]==2){
    std::cout<<"Votre deuxième carte de marché multiniveau vous permet de lancer un deuxième dé."<short int de=de6(eng);
    std::cout<<"Le lancé du dé donne "<'.'<if(de>=4)
      std::cout<<"Le lancé du dé a donné 4, 5 ou 6. Votre deuxième carte de système de vente multiniveau vous rapporte donc 500€ supplémentaire."<}
}
 
void jeu::cas_charite(short int joueur){
  std::cout<<"Vous êtes sur une case charité, voulez-vous faire la charité (10% de votre revenu total) pour utiliser deux dé les trois prochains tours?(o/n)";
  std::string reponse;
  std::cin>>reponse;
  if(reponse.at(0)=='o' || reponse.at(0)=='O'){
    int charite=(long int)caisse[joueur]/10;
    caisse[joueur]=(long int)(caisse[joueur]-caisse[joueur]/10);
    en_charite[joueur]=3;
    std::cout<<"Cette charité vous a coûté "<" €."<"Votre caisse est de "<[joueur]<<" €."<}
}
 
void jeu::choix_marche(short int joueur)  { }
 
void jeu::choix_opportunite(short int joueur){
  char reponse;
  std::cout<<"appuyez sur 'p' pour une petite opportuninté, et sur 'g' pour une grosse"<while( (reponse=getch())!='p' && reponse!='P' && reponse!='g' && reponse!='G' )
    ;
  switch(reponse){
  case 'p':case 'P':
    choix_petite_opportunite(joueur);
    break;
  case 'g':case 'G':
    choix_grosse_opportunite(joueur);
    break;
  }
}
 
void jeu::choix_petite_opportunite(short int joueur){
  std::cout<<"Vous avez choisi une petite opportunité."<"Votre livre de caisse est de "<[joueur]<<" €."<switch(index_petite){
  case 0:
    std::cout<<"Vous avez trouvé une super affaire ! \n\nMaison ancienne de deux chambres et une salle de bain, saisie par un organisme gouvernemental. Elle est prête à être vendue avec financement du gouvernement et un locataire. ";
    std::cout<<"Faites un prêt s'il le faut, mais ACHETEZ-LA !"<"\nUtilisez cette carte ou vendez-la à un autre joueur.\n"<"Coût : 35 000 €       Hypoyhèque : 33 000 €"<"Apport : 2000 €          Cash Flow : +220 €\n"<"Voulez-vous acheter ce bien en payant un apport de 2000 ?(appuyez sur 'a'),vendre cette carte (appuyez sur 'v'), ou passer votre tour (appuyez sur 'p') ?"<char reponse;
    do reponse=getch() ; while(reponse !='a' && reponse !='A' && reponse !='v' && reponse !='V' && reponse !='p' && reponse!='P');
    switch(reponse){
    case 'a':case 'A':
      vendre_bien_immo(joueur,maison_2chambres_1sdb,35000,2000,33000,220);
      break;
    case 'v':case 'V':
      vendre_carte_bien(joueur,maison_2chambres_1sdb,35000,2000,33000,220);
    case 'p':case'P':
      ;//passer le tour
    }
    std::cout<<"Voulez-vous voir vos détails? (o/n)"<char rep;
    while( (rep=getch())!='o' && rep!='O' && rep!='n' && rep!='N')
      ;
    if(rep=='o' || rep=='O')
      affiche_perso(joueur);
    break;
  case 1:
    std::cout<<"Appartement de deux chambre et une salle de bain à vendre\n"<"Des parents vendent un appartement de deux chambres et une salle de bain que leur fils a habité pendant ses années à l'université. Il y a beaucoup de demandes de location dans cette zone."
	     <"\nUtilisez cette carte ou vendez-la à un autre joueur.\n"<"Coût : 40 000 €       Hypoyhèque : 36 000 €"<"Apport : 4000 €          Cash Flow : +140 €\n"<break;
  case 2:
    std::cout<<"Action - MYT4U Electroninics Co.\n"<"Les taux d'intérêts record génère un prix inférieur à la norme pour les actions de ce vendeur de produits électroniques.\n"<"Vous seul pouvez acheter à ce prix autant d'actions que vous voulez.\nTout le monde peut vendre à ce prix.\n"<"Symbole : MYT4U                         Prix du jour : 5€"<"          Fourchette de variation : 10 € - 30 €\n"<"Voulez-vous acheter ces actions? (o/n)"<while( (rep=getch())!='o' && rep!='O' && rep!='n' && rep!='N')
      ;
    if(rep=='o' || rep=='O')
      acheter_actions(joueur,MYT4U,5);
    break;
  }
  index_petite++;
  if(index_petite==3)
    index_petite=0;
}
 
void jeu::choix_grosse_opportunite(short int joueur){}
 
void jeu::vendre_bien_immo(short int joueur,bien_immobilier,int cout,int apport,int hypotheque,short int cashflow){}
 
void jeu::vendre_carte_bien(short int joueur,bien_immobilier,int cout,int apport,int hypotheque,short int cashflow){}
 
void jeu::acheter_actions(short int joueur,symbole_action symbole,short int prix_du_jour) { }
 
void jeu::tour_voie_rapide(short int joueur) {}

une id�e?

C++26 : Concept et templates variables comme param�tre template, par Sandor Dargo

Sandor Dargo — Tue, 23 Sep 2025 12:05:11 GMT

C++26 : Concept et templates variables comme param�tre template, par Sandor Dargo

La semaine derni�re, nous avons discut� des raisons pour lesquelles il est parfois n�cessaire d'utiliser remove_cvref_t sur nos param�tres template avant de leur appliquer des concepts. Nous avons �galement vu que cette solution n'est pas tr�s lisible, car elle nous prive de la syntaxe concise et abr�g�e.

Si seulement nous pouvions utiliser les concepts comme param�tres template !

Heureusement, P2841R7 vient � notre secours, et il a r�cemment �t� accept� dans le cadre de C++26.

� premi�re vue, la proposition peut sembler intimidante, car elle compte pr�s de 40 pages. Mais ne vous inqui�tez pas. Tout d'abord, il s'agit d'un document tr�s lisible, rempli d'explications claires et d�taill�es. Ensuite, environ la moiti� consiste en des modifications de formulation.

Plongeons-nous dans le vif du sujet.

Les concepts en tant que template de param�tres template

Le C++ permet d�j� de passer des templates en tant que param�tres template, mais uniquement s'il s'agit de template de classe. Une raison courante pour cela est de permettre des abstractions de plus haut niveau. Par exemple, vous pouvez vouloir passer un template de conteneur comme std::vector, sans sp�cifier le type qu'il contient.

Jason Turner explique bien cela dans C++ Weekly - Ep 368 - The Power of template-template Parameters: A Basic Guide.

Mais voici son exemple pour r�f�rence rapide :

Code:

1
2
3
4
5
6
7
8
9
10
11
template<template <typename Contained, typename Alloc = std::allocator>
		 typename ResultType>
auto get_data() {
	ResultType<double> result;
	// ...
	return result;
}
 
int main() {
	auto data = get_data();
}

Avec une signature plus simple comme template<typename ResultType> auto get_data(), nous ne pouvions pas passer std::vector, car ce n'est pas un type complet, mais un template. Gr�ce aux templates de param�tres template, nous pouvons passer un template de classe � un autre template.

Malheureusement, jusqu'� pr�sent, cette technique ne fonctionnait pas avec les templates variables ou les concepts. Pourtant, la motivation pour passer un concept comme argument de template est similaire � celle qui nous pousse � passer des templates de classe : permettre des constructions expressives de haut niveau.

La semaine derni�re, nous avions ce template de fonction :

Code:

1
2
3
template<typename Q>
 requires Quantity>
void foo(Q&& q);

Avec un template de concept des param�tres template, nous pouvons introduire un concept d'aide, en d'autres termes un adaptateur de concept, afin d'am�liorer la lisibilit� :

Code:

1
2
3
template <typename T,
		 <template <typename> concept C>
concept decays_to = C>;

Cela nous permet de r��crire notre fonction de mani�re plus claire :

Code:

1
2
template  Q>
void foo(Q&& q);

La proposition comprend plusieurs autres exemples qui pourraient s'av�rer utiles.

Template variables - param�tre template

� partir de C++23, nous ne pouvons pas avoir de template variables param�tre template. Bien qu'il existe des solutions de contournement, telles que l'encapsulation de variables dans des structures avec un membre de valeur pour les utiliser comme type de Template variables - param�tre template de param�tres template, celles-ci sont verbeuses, difficiles � lire et peuvent avoir un impact n�gatif sur les performances.

En fait, la plupart des traits de type standard sont d�finis � la fois comme des types et des variables _v. Selon les benchmarks de performance de la proposition, l'utilisation de templates variables peut pr�senter des avantages significatifs en termes de performance de compilation et d'utilisation de la m�moire.

La diff�rence dans l'exemple de code pr�sent� dans le document est minime :

Code:

1
2
3
4
5
6
// Before
template <template <typename> typename p, typename... Ts>
constexpr std::size_t count_if_v = (... + p::value);
// After 
template <template <typename> auto p, typename... Ts>
constexpr std::size_t count_if_v = (... + p);

En �liminant ::value, nous �vitons la surcharge li�e � l'instanciation d'un template de classe pour chaque Ts � un changement apparemment mineur, mais qui a un impact significatif.

Les d�tails syntaxiques

La raison pour laquelle le concept et les templates variables de param�tres template apparaissent ensemble dans cette proposition n'est pas fortuite. Bien qu'ils aient �t� propos�s s�par�ment auparavant, ils sont tous deux essentiels pour prendre en charge les param�tres template universels, propos�s dans P1985R3.

La proposition dont il est question ici (P2841R7) est en fait un sous-ensemble de P1985R3. Pour qu'un � param�tre template universel � soit � la hauteur de son nom, il doit prendre en charge un large �ventail de formes d'arguments de template possibles, notamment les types, les templates de classe, les concepts et les templates variables.

Voici comment nous sp�cifions habituellement un param�tre de mod�le de mod�le de classe uniquement :

Code:

1
2
3
template<
	template <typename T> typename TT
>

Avec la nouvelle proposition, nous pouvons d�sormais inclure des concepts et des templates variables en utilisant respectivement les mots-cl�s concept et auto :

Code:

1
2
3
4
5
template<
	template <typename T> typename TT,
	template <typename T> concept C,
	template <typename T> auto VT
>

Il existe de nombreux autres aspects int�ressants, comme la subsomption, mais je les aborderai dans un autre article afin que celui-ci reste concis et facile � comprendre.

Conclusion

L'acceptation de P2841R7 dans C++26 est l'une de ces am�liorations discr�tes mais puissantes. Elle nous permet d'�crire des mod�les plus propres, plus flexibles et plus faciles � lire en autorisant � la fois les concepts et les templates variables comme param�tres template.

Cela peut sembler �tre une fonctionnalit� de niche, mais si vous avez d�j� �t� confront� � une syntaxe de template maladroite ou � des wrappers standardis�s juste pour faire passer des concepts ou des traits, vous appr�cierez ce que cela vous apporte. Cela nous rapproche un peu plus de l'�criture d'un C++ expressif et de haut niveau qui semble plus naturel, sans sacrifier les performances.

C'est un grand pas en avant pour tous ceux qui appr�cient le C++ moderne et souhaitent disposer d'outils plus �l�gants pour la m�taprogrammation. Et soyons honn�tes, moins de ::value clutter n'a jamais fait de mal � personne.

Cet article est publi� sous licence CC BY 4.0 par l'auteur.

Source : "C++26: Concept and variable-template template-parameters"

Et vous ?

:fleche: Quel est votre avis sur le sujet ?

Voir aussi :

:fleche: La norme C++23 supprime la prise en charge du Garbage Collection, par Sandor Dargo, d�veloppeur C++

:fleche: Le C++ doit �tre du C++ : Une opinion qui est le fruit de 23 ann�es d'exp�rience en C++, par David Sankel

:fleche: C++ sous st�ro�des : Bjarne Stroustrup pr�sente des � profils � renforc�s par des lignes directrices pour la s�curit� des ressources et des types, afin de garantir que le code est contemporain et s�r

Probl�me de centrage de bo�te de dialogue ComDlg32 : aucun flag ad hoc dans la structure de controle

Orohena — Wed, 21 May 2025 22:26:08 GMT

D�sol� si le sujet a d�j� �t� abord�, mais je n'arrive pas � avoir de r�ponse de la faq c++.
Merci

Mamadou Babaei : � C++ n�a pas besoin d�une nounou comme le v�rificateur d'emprunts de Rust �

St�phane le calme — Mon, 12 May 2025 06:45:16 GMT

Mamadou Babaei : � C++ n�a pas besoin d�une nounou comme le v�rificateur d'emprunts de Rust �,
faut-il vraiment changer de langage, ou simplement mieux ma�triser les outils existants ?

Alors que Rust s�impose comme le champion de la s�curit� m�moire gr�ce � son syst�me de v�rification � la compilation, certains d�veloppeurs C++ refusent de se laisser rel�guer au rang de programmeurs imprudents. Avec un ton provocateur, le d�veloppeur professionnel de jeu Mamadou Babaei d�fend la capacit� du C++ � d�tecter et corriger les fuites m�moire sans avoir besoin d�un � gardien de m�moire � comme Rust. � travers une d�monstration concr�te avec _CrtDumpMemoryLeaks, il relance le d�bat : faut-il vraiment changer de langage, ou simplement mieux ma�triser les outils existants ?

Rust : un langage trop protecteur ?

Rust a �t� acclam� ces derni�res ann�es comme l�un des langages les plus s�curis�s pour le d�veloppement syst�me. Sa principale innovation ? Le borrow checker (litt�ralement v�rificateur d'emprunts), ce m�canisme de v�rification � la compilation qui emp�che les erreurs de m�moire comme les acc�s concurrents non s�curis�s ou les use-after-free.

Le v�rificateur d'emprunts est une fonctionnalit� essentielle du langage Rust et fait partie de ce qui rend Rust Rust. Il vous aide (ou vous oblige) � g�rer la propri�t�. Comme le dit le chapitre 4 de � The Rust Programming Language �, � La propri�t� est la caract�ristique la plus unique de Rust, et elle permet � Rust de garantir la s�curit� de la m�moire sans avoir besoin d'un collecteur m�moire �.

Le v�rificateur d'emprunt est un composant du compilateur Rust dont le r�le est de v�rifier � la compilation que l�usage de la m�moire est s�r, sans fuite ni corruption potentielle, sans ex�cution du programme. Il repose sur trois concepts cl�s :

Propri�t� (ownership) : chaque valeur a un propri�taire unique.
Emprunts (borrowing) : on peut pr�ter une valeur de mani�re mutable ou non mutable, mais pas les deux en m�me temps.
Dur�e de vie (lifetimes) : chaque r�f�rence a une dur�e de vie clairement d�finie et v�rifi�e.

Le borrow checker interdit � la compilation :

Les acc�s concurrents � une m�me valeur mutable (race conditions �vit�es).
Les r�f�rences � des valeurs qui ont �t� lib�r�es (dangling pointers).
La modification de donn�es pendant qu'elles sont emprunt�es de fa�on immuable.
L�utilisation apr�s d�placement (move), pour �viter la double lib�ration.

Mais pour certains d�veloppeurs C++, ce syst�me ressemble davantage � une � nounou � : une surprotection qui entrave la libert� de coder rapidement et efficacement. Selon eux, les d�veloppeurs exp�riment�s n�ont pas besoin d�un langage qui leur interdit de faire certaines choses � ils veulent juste des outils qui les aident � le faire mieux, sans �tre brid�s.

Un faux proc�s fait au C++ ?

Depuis l�essor de Rust dans les milieux de la s�curit� et du d�veloppement syst�me, une id�e re�ue semble s�installer : le C++ serait intrins�quement dangereux. Ses critiques mettent en avant la complexit� de sa gestion manuelle de la m�moire, source suppos�e d�erreurs fr�quentes et de vuln�rabilit�s critiques.

Mais ce discours occulte une r�alit� plus nuanc�e : le C++ n�est pas dangereux par nature, il est exigeant. Comme le rappelle Babaei, les fuites m�moire et les erreurs d�allocation ne sont pas une fatalit� si les d�veloppeurs exploitent les outils disponibles dans l��cosyst�me du langage.

Ainsi, plut�t que de d�nigrer le C++ pour son absence de m�canismes de s�curit� int�gr�s � la Rust, il conviendrait de promouvoir les bonnes pratiques de d�veloppement, les outils de d�bogage avanc�s et les biblioth�ques modernes comme RAII, unique_ptr, shared_ptr, ou encore Valgrind.

Dans sa vid�o intitul�e � Rust Devs Think We�re Hopeless; Let�s Prove Them Wrong (with C++ Memory Leaks)! �, Mamadou Babaei d�fend avec humour et technicit� la capacit� des d�veloppeurs C++ � g�rer efficacement la m�moire, sans recourir aux m�canismes de s�curit� stricts de Rust. Il d�montre comment d�tecter les fuites m�moire en C++ en utilisant l'outil _CrtDumpMemoryLeaks fourni par la biblioth�que d'ex�cution C (CRT) de Microsoft.

Et d'indiquer :

� Lorsque les d�veloppeurs Rust pensent � nous, les gens du C++, ils imaginent une lign�e maudite - un traumatisme g�n�rationnel transmis de malloc � free. Pour eux, chaque ligne de C++ que nous �crivons est comme jouer � la roulette russe - sauf que les six chambres sont charg�es de comportements non d�finis.

� Ils nous regardent comme si nous �tions sans espoir. Comme si nous �tions � deux doigts d'une th�rapie. Mais vous savez quoi ? Nous n'avons pas besoin d'une nounou pour le compilateur. Pas de v�rificateur d'emprunts. Pas de dur�e de vie. Pas de mod�les de propri�t�. Pas de magie noire. M�me Valgrind n'est pas n�cessaire. Juste des pointeurs bruts, de la d�termination brute, et un peu de sant� mentale douteuse.

� Dans cette vid�o, je vais donc vous montrer comment traquer les fuites de m�moire comme si vous �tiez n� avec un pointeur dans une main et un d�bogueur dans l'autre �.

_CrtDumpMemoryLeaks : Un outil � (re)d�couvrir

La d�monstration de Babaei repose sur un outil m�connu mais redoutablement efficace : la fonction _CrtDumpMemoryLeaks, int�gr�e � la CRT (C Run-Time Library) de Microsoft. Elle permet, d�s la compilation en mode debug, de d�tecter automatiquement les blocs de m�moire non lib�r�s avant la fin de l�ex�cution.

En couplant cet outil � des macros de suivi (_CRTDBG_MAP_ALLOC, new red�fini avec tra�abilit�), il devient possible de cartographier pr�cis�ment l'origine d'une fuite m�moire. Cette d�marche, bien que n�cessitant une configuration sp�cifique, prouve que le C++ n�est pas d�pourvu de garde-fous � il demande juste qu�on les active.

D�monstration : d�tection de fuites m�moire avec _CrtDumpMemoryLeaks

Babaei pr�sente un exemple de programme C++ qui g�n�re intentionnellement une fuite m�moire en allouant de la m�moire sans la lib�rer. Pour d�tecter cette fuite, il utilise les fonctions de d�bogage de la CRT.

D�monstration d'une fuite de m�moire en C++ simple et intentionnelle

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
/**
* Une fuite de mémoire en C++ simple et intentionnelle
*/
 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
static constexpr int32_t PASSWORD_LENGTH = 1024 * 1024;
static constexpr std::chrono::milliseconds INTERVAL_MILLISECONDS{1};
 
std::string GeneratePassword(std::size_t length) {
    const std::string charset{
        "0123456789"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz"
    };
 
    const std::size_t maxIndex = charset.size();
    std::string result(length, '\0');
 
    for (std::size_t i = 0; i < length; ++i) {
        result[i] = charset[rand() % maxIndex];
    }
 
    return result;
}
 
int32_t main() {
    std::srand(static_cast<uint32_t>(std::time(nullptr)));
    std::atomic<bool> stop{false};
 
    std::thread inputThread([&stop]() {
        std::cin.get();
        stop = true;
        });
 
    while (!stop) {
        std::string* password{new std::string(GeneratePassword(PASSWORD_LENGTH))};
 
        std::cout
            << "Generated password:"
            << "\n"
            << *password
            << "\n\n"
            << "Press the 'Enter' key to interrupt!"
            << std::endl;
 
        std::this_thread::sleep_for(INTERVAL_MILLISECONDS);
    }
 
    inputThread.join();
    std::cout << "'Enter' key detected! Will stop!" << std::endl;
 
    return 0;
}

Une d�monstration de _CrtDumpMemoryLeaks

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
/**
* Une démonstration de _CrtDumpMemoryLeaks
*/
#define MEMORY_LEAK_TRACKER 1
 
#if MEMORY_LEAK_TRACKER
#define _CRTDBG_MAP_ALLOC
#include 
 
#define DEBUG_NEW new (_NORMAL_BLOCK, __FILE__, __LINE__)
#define new DEBUG_NEW
#endif  /* MEMORY_LEAK_TRACKER */
 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
static constexpr int32_t PASSWORD_LENGTH = 64;
static constexpr std::chrono::milliseconds INTERVAL_MILLISECONDS{1000};
 
std::string GeneratePassword(std::size_t length) {
    const std::string charset{
        "0123456789"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz"
    };
 
    const std::size_t maxIndex = charset.size();
    std::string result(length, '\0');
 
    for (std::size_t i = 0; i < length; ++i) {
        result[i] = charset[rand() % maxIndex];
    }
 
    return result;
}
 
int32_t main() {
#if MEMORY_LEAK_TRACKER
    int dbgFlags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
    dbgFlags |= _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF;
    _CrtSetDbgFlag(dbgFlags);
 
    // Only track one allocation per run!
    // e.g. allocation number that causes leaks:
    //_CrtSetBreakAlloc(162);
#endif  /* MEMORY_LEAK_TRACKER */
 
    std::srand(static_cast<uint32_t>(std::time(nullptr)));
    std::atomic<bool> stop{false};
 
    std::thread inputThread([&stop]() {
        std::cin.get();
        stop = true;
        });
 
    while (!stop) {
        std::string* password{new std::string(GeneratePassword(PASSWORD_LENGTH))};
 
        std::cout
            << "Generated password:"
            << "\n"
            << *password
            << "\n\n"
            << "Press the 'Enter' key to interrupt!"
            << std::endl;
 
        std::this_thread::sleep_for(INTERVAL_MILLISECONDS);
    }
 
    inputThread.join();
    std::cout << "'Enter' key detected! Will stop!" << std::endl;
 
#if MEMORY_LEAK_TRACKER
    _CrtDumpMemoryLeaks();
#endif  /* MEMORY_LEAK_TRACKER */
 
    return 0;
}

Explication

Code:

1
2
3
4
5
6
7
8
9
#define MEMORY_LEAK_TRACKER 1
 
#if MEMORY_LEAK_TRACKER
#define _CRTDBG_MAP_ALLOC
#include 
 
#define DEBUG_NEW new (_NORMAL_BLOCK, __FILE__, __LINE__)
#define new DEBUG_NEW
#endif  /* MEMORY_LEAK_TRACKER */

Citation:

Imaginons que nous construisions des maisons en LEGO et que nous oublions parfois de nettoyer les briques apr�s la construction. Ce code dit : � H�, activons un traqueur de briques LEGO ! �.

Il ajoute une cam�ra magique () qui surveille l'endroit o� nous laissons tomber les briques. Et lorsque nous utilisons de nouvelles briques pour construire quelque chose, il ajoute secr�tement qui l'a construit et o� dans le code. Ainsi, si nous oublions de nettoyer, nous saurons exactement qui a fait le d�sordre et o�.

Explication technique :

_CrtSetDbgFlag(...) : D�finit les drapeaux d'ex�cution pour activer le suivi des fuites de m�moire et le signalement automatique des fuites � la sortie du programme.
DBG_ALLOC_MEM_DF : Indique au tas de d�bogage de garder une trace des allocations de m�moire.
DBG_LEAK_CHECK_DF : Appelle automatiquement _CrtDumpMemoryLeaks() � la sortie de main().
_CrtSetBreakAlloc(162) : Fixe un point d'arr�t � la 162e allocation (telle qu'elle est compt�e en interne par le tas CRT). Lorsqu'il est atteint, Visual Studio interrompt l'ex�cution afin que vous puissiez inspecter l'allocation � l'origine du probl�me. Vous pouvez commenter cette ligne sauf si vous essayez d'isoler une fuite sp�cifique dans un gros programme.

tl;dr ; _CrtSetDbgFlag(...) permet le suivi du tas au moment de l'ex�cution et les rapports de fuite ; _CrtSetBreakAlloc(N) vous permet de casser sur un num�ro d'allocation sp�cifique.

Code:

1
2
3
4
5
6
#if MEMORY_LEAK_TRACKER
    _CrtDumpMemoryLeaks();
#endif  /* MEMORY_LEAK_TRACKER */
 
    return 0;
}

Citation:

� la toute fin, nous disons � la cam�ra : � Ok, montre-moi tout ce qu'on a oubli� de nettoyer. �

Elle envoie un rapport disant : � H� ! Vous avez laiss� une brique � la ligne 42 ! Et une autre � la ligne 57 ! �

Explication technique :

D�clenche manuellement un rapport de fuite juste avant l'arr�t du programme.
C'est optionnel si vous avez d�j� activ� _CRTDBG_LEAK_CHECK_DF - le CRT va automatiquement faire le dumping des fuites.
Mais l'appeler manuellement vous donne le contr�le sur le moment o� le rapport de fuite se produit (par exemple, avant la destruction globale/statique).

tl;dr ; _CrtDumpMemoryLeaks() imprime manuellement les informations sur les fuites avec le pointeur et la taille.

Et si le probl�me �tait culturel, pas technique ?

Le d�bat entre Rust et C++ r�v�le autant une opposition technique qu�une diff�rence d�approche philosophique. Rust adopte une logique � z�ro confiance �, o� le compilateur est con�u pour interdire les erreurs d�s la phase de d�veloppement. Le d�veloppeur est contraint par le syst�me de type, le borrow checker et les r�gles strictes de propri�t�.

� l�inverse, C++ s�inscrit dans une tradition o� le d�veloppeur est empowered : il est ma�tre de la m�moire, du cycle de vie des objets, et libre d�enfreindre les r�gles � pour le meilleur ou pour le pire. Cette libert� est pr�cieuse pour les experts, mais redoutable pour les d�butants.

Peut-on alors parler d�un clivage g�n�rationnel ? Les jeunes d�veloppeurs, form�s dans un univers DevOps/API-first, privil�gient souvent les langages s�rs par d�faut, comme Rust, Go ou Python. Les v�t�rans du C++, eux, continuent de valoriser la performance brute, le contr�le total et la compatibilit� avec des milliards de lignes de code existantes.

C++ moderne : un langage en pleine mutation

Il serait injuste de juger le C++ d�aujourd�hui � l�aune de sa version des ann�es 90. Depuis C++11, le langage a largement �volu� : gestion automatique de la m�moire avec std::unique_ptr, initialisation uniforme, constexpr, concepts, modules... Autant de fonctionnalit�s qui rapprochent la rigueur du C++ moderne des promesses de s�curit� de Rust, sans sacrifier sa puissance.

De plus, l��cosyst�me C++ s�est enrichi d�outils de d�tection de fuites multiplateformes (Valgrind, AddressSanitizer), d�environnements de test avanc�s (Catch2, GoogleTest), et de pratiques DevOps plus s�res (analyse statique, CI/CD int�grant des outils m�moire).

Un choix plus id�ologique que technique ?

Ce d�bat d�passe la simple pr�f�rence syntaxique. Il refl�te une vision du m�tier : �crire du code rapide, flexible et risqu� ou privil�gier la s�ret�, la rigueur et la pr�visibilit�. La � nounou � Rust ne s�adresse peut-�tre pas aux v�t�rans du C++, mais elle forme une nouvelle g�n�ration de d�veloppeurs conscients que la fiabilit� est souvent plus cruciale que la vitesse brute.

Quoiqu'il en soit, il serait r�ducteur d�opposer frontalement Rust et C++. Les deux ont leur place dans l��cosyst�me logiciel. Certains projets, o� la performance brute et l�acc�s natif au mat�riel priment, continueront de pr�f�rer le C++. D�autres, o� la s�curit� et la maintenabilit� sont critiques, miseront sur Rust.

Des initiatives hybrides apparaissent d�ailleurs, o� Rust et C++ coexistent dans les m�mes projets. Mozilla, Dropbox, ou Android OS int�grent progressivement des composants Rust dans des bases C++ existantes. Et inversement, des d�veloppeurs Rust utilisent des bindings vers du code C++ pour profiter d�APIs �prouv�es.

Deux visions, une compl�mentarit� possible ?

La vid�o de Babaei ne cherche pas � nier les atouts de Rust, mais � r�habiliter la comp�tence et la responsabilit� dans le d�veloppement C++. Oui, Rust permet de s�curiser des projets critiques avec un excellent niveau de garantie. Mais non, les d�veloppeurs C++ ne sont pas condamn�s � produire du code truff� de bogues m�moire.

Au contraire, la coexistence des deux langages pourrait s�av�rer b�n�fique : C++ pour les couches ultra-performantes et interop�rables, Rust pour les modules sensibles o� la s�curit� m�moire est vitale. Certaines entreprises comme Microsoft, Mozilla ou AWS ont d�j� commenc� cette hybridation pragmatique.

Sources : vid�o dans le texte, documentation Rust, Microsoft

Et vous ?

:fleche: Faut-il vraiment changer de langage, ou simplement mieux ma�triser les outils existants ?

:fleche: Le borrow checker de Rust est-il un mal n�cessaire ou une entrave � la cr�ativit� ?

:fleche: Peut-on vraiment comparer deux langages � des stades aussi diff�rents de maturit� ?

:fleche: Les outils de d�tection de fuites m�moire en C++ sont-ils suffisants pour garantir une gestion s�re de la m�moire dans des projets complexes ?

:fleche: La complexit� du syst�me de propri�t� de Rust justifie-t-elle son adoption face � la flexibilit� de C++ ?

:fleche: Dans quels contextes la performance brute de C++ prime-t-elle sur les garanties de s�curit� de Rust, et vice versa ?

:fleche: L'int�gration d'outils de d�tection de fuites m�moire dans le processus de d�veloppement C++ est-elle devenue une norme incontournable ?

:fleche: Rust est-il adapt� aux d�butants ou r�serv� aux ing�nieurs syst�mes exp�riment�s ?

:fleche: Peut-on raisonnablement int�grer Rust dans des �quipes historiquement C++ sans ralentir les projets ? L��cosyst�me de Rust est-il suffisamment mature pour rivaliser avec les biblioth�ques et outils C++ ?

Images attach�es

utilisation d'une DLL C++ depuis un serveur

OKI DOKI — Thu, 08 May 2025 14:54:21 GMT

Bonjour,
J'ai un fichier .dll qui exporte des fonctions que j'appelle depuis un script C++. J'aimerais utiliser ce script C++ depuis une page web, donc potentiellement cr�er une API REST. Cependant, j'ai lu que les fichiers .dll ne sont utilisables que sous Windows.
Selon vous, comment pourrais-je faire pour atteindre mon objectif : exploiter les fonctions de la DLL depuis une page web ?
Merci.

Code C++ Mount partiton Cryptsetup

Oscar02 — Sat, 19 Apr 2025 16:59:50 GMT

Bonjour � tous,

J'aurais besoin d'un coup de pouce en C++ pour monter une partition Crypter avec Cryptsetup sur un Raspberry.

L'objectif serait que mon appli C++ puissent monter la Partition au d�marrage du Rasp. Pour le moment, je souhaite faire des essais avec la paraphrase dans l'appli C++. Apr�s, je la g�rerai autrement pour des raisons de s�curit�.

Quelqu'un aurait-il un peu de temps pour m'aider, SVP ? J'ai regard� du cot� de l'API CryptSetup, mais je ne sait pas comment l'utiliser.

J'utilise Netbeans pour compiler mes projets sur mon Raspberry en C++.

Je suis amateur, comme vous pouvez le comprendre.

J'ai juste besoin de faire le montage de la partition avec cette appli, SVP.
Pour info j'ai d�j� crypt� puis mont� la partition en ligne de commande. Cela fonctionne correctement.
j'utilise un Raspberry PI5 avec la derni�re version de RASPERRY PI OS

Merci d'avance pour votre aide.

Les liens que j'ai regard� mais je ne sais pas par o� commencer.
https://mbroz.fedorapeople.org/libcr...html#cactivate
https://stackoverflow.com/questions/...pted-partition

Oscar.