Discussion :

[PilloBuenaGente]

Bonjour,



Essayant de comprendre et digérer la conception en c++, j'ai voulu partir sur de bonnes bases et me suis donc lancé dans la programmation d'un jeu simple: le Morpion.zip

Je me suis inspiré de (voire plagié) certaines parties du code du livre Coder efficacement - Bonnes pratiques et erreurs à éviter (en C++).(Tant de réponses à tant de questions, merci )
J'avoue ne pas avoir encore tout saisit, d'autres lectures seront sans doute nécessaires. (non pas que ce soit mal expliqué, je ne suis pas des plus vifs..).

Je vous décris rapidement le fonctionnement:

Le programme est séparé en deux grandes parties. Game et ses composants, et le system d'entrée/sortie, en l'occurrence; Console.

Main lance game.

Game contient
--board les cases
--players les joueurs
--rules les rêgles
--interface<system>

Interface est générique et sert à charger une interface héritant des abstractions View et Controler, selon le system d'entrée/sortie définit.

View a deux fonction virtuelles pures:
--virtual void display(const Game& game) = 0;
--virtual const Input read() = 0;
Controler a une fonction viruelle pure:
--virtual void work(const Input& input, Game& game) = 0;

Console spécialise View et Controler selon le system ConsoleTag et définit le type d'interface.
ConsoleMain, ConsoleOptions et ConsoleWin sont les interfaces concrètes de Console.

ConsoleParser traite la std::string du retour clavier
ConsoleEntry stocke les choix possibles et interprète la réponse via le ConsoleParser
ConsoleWriter met en forme et affiche les informations reçues sur la console.

• Je suis conscient ne pas respecter certains aspects de SOLID notamment les contrats, mais suis-je en bonne voie ?

• Je n'arrive pas à faire d'abstraction pour ma classe Input, selon le système, on peut avoir des entrées différentes!..(peut-être en faisant des vectors de toutes sortes pour la rendre plus générique, mais c'est pas beau)

• Je ne connais pas la limite de l'over-engineering, j'ai déjà pas mal de classe pour un tout petit projet, mais le concept de single responsability aurait pu être mieux respecté avec quelques classes supplémentaire.

Suggestion et critiques sont les biens venues!

Merci d'avance!

[CodeurPlusPlus]

Décidément la toute puissance du paradigme objet engendre des horreurs. N'est-ce pas un peu compliqué pour un simple jeu de morpion ?

[PilloBuenaGente]

A ce point !?
En effet, mais si je veux garder de la flexiblilité, n'y suis-je pas contraint ?

[ternel]

Ta classe Input est peut-être trop générique, par son nom, au moins.
Une fonction par donnée attendue est raisonnable.
Position askPosition() const;
std::string askPlayerName(int number) const;
(au passage, askPlayerName pourrait demander le symbole à utiliser pour la représentation).

Concernant le nombre de classes, je ne vois rien de très anormal.

Voici comment je m'y prendrai. Ce n'est pas forcément le mieux, mais ça peut te donner un point de comparaison.

un jeu de morpion est une grille de quelques cases, où deux joueurs placent chacun leur tour un jeton, dans le but de former une ligne.

rien que pour la modélisation, tu as déjà deux ou trois classes:
la grille, le joueur, le jeton (éventuellement réductible à un identifiant de joueur dans la grille: il faudra un typedef)
Et deux fonctions déjà identifiée: placer un jeton (avec vérification) et détecter une ligne

Pour la représentation visuelle, une classe de base et une console, c'est bien.
En général, je la construit pour supporter plusieurs parties d'affilée:

• une fonction bool askNewGame()
• une fonction void start(Game*) en mentionnant que la game est une référence extérieure (éventuellement un smart pointer bien choisi)
• std::string askPlayerName(int playerId)
• une série de fonctions liées au jeu implémenté, ici Position askNextTurn(int playerId);

Libre ensuite d'implémenter une vue dans une classe séparée, mais globalement, la classe Console est un contrôleur concret (et Interface le contrôleur abstrait)

Le main devient alors :

Code :

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

1
2
3
4
5
6
7
8
//tout en pseudo code
instanciation du controleur qui va bien.
tant que controleur.askNewGame()
    game jeu ...
    controleur.start(&jeu)
    tant que jeu n'est pas fini
         jeu.act(controleur.askNextTurn(jeu.joueurCourant))
controleur.merci()

Je n'ai pas encore vu le code en détail, mais j'imagine qu'il est plutôt bien écrit, vu comment tu le décris.

[Luc Hermitte]

J'ai un vocabulaire légèrement différent de Philippe pour ce qui est des jeux (ce qui est important pour moi, c'est où est prise la décision, et non le type d'input). Et à termes, je suis persuadé que les ECS sont une meilleure solution que l'abus d'objets -- quasi inhérent à l'approche OO dans le contexte des jeux. Après je ne gère pas 50 sorties possibles, et encore moins des pièces qui ont toutes un comportement différent. A la place, j'ai 2 IA.

Bref, voici une "vieille" (i.e. sans ECS) solution à bibi: https://github.com/LucHermitte/tictactoe

[Kaamui]

Bonjour à tous,

Personnellement je trouve vos codes vraiment compliqués pour un morpion. J'ai un vieil exemple à fournir également, fait avec la SFML plutôt qu'en console. Je ne dis pas que c'est mieux ou bien codé, je le trouve déjà pas très bien conçu et encore un peu compliqué pour rien, mais c'est déjà plus simple :

Morpion.hpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
#include <vector>
#include <SFML/Graphics.hpp>
using namespace std;
 
class Morpion
{
    enum {VIDE, CROIX, ROND} Contenu;
    vector<vector<Morpion::Contenu>> grille;
 
    sf::Texture* tGrille;
    sf::Sprite* sGrille;
 
    sf::Texture* tCroix;
    sf::Sprite* sCroix;
 
    sf::Texture* tRond;
    sf::Sprite* sRond;
 
    sf::RenderWindow* fenetre;
 
    int compteurCoups;
    bool partieTerminee;
    bool aGagne;
 
  public :
 
    Morpion();
    ~Morpion();
    void Jouer();
    void DessinerContenuGrille();
    bool ModifierGrille(Morpion::Contenu contenu, int i, int j);
    bool PartieTerminee();
    void Init();
 
    bool IA();
    std::pair<int,int> EvaluerColonnes(Morpion::Contenu c);
    std::pair<int,int> EvaluerLignes(Morpion::Contenu c);
    std::pair<int,int> EvaluerDiagonales(Morpion::Contenu c);
 
    int GetCompteurCoups() {return compteurCoups;}
    bool AGagne() {return aGagne;}
    sf::RenderWindow* GetFenetre() {return fenetre;}
 
};

Morpion.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
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
 
#include "morpion.hpp"
#include <iostream>
#include <ctime>
 
Morpion::Morpion() :
grille(3, vector<Morpion::Contenu>(3)),
tGrille(new sf::Texture()),
sGrille(new sf::Sprite()),
tCroix(new sf::Texture()),
sCroix(new sf::Sprite()),
tRond(new sf::Texture()),
sRond(new sf::Sprite()),
fenetre(new sf::RenderWindow(sf::VideoMode(300,300,32), "Titre inutile...", sf::Style::None)),
compteurCoups(9),
partieTerminee(false),
aGagne(false)
{
    grille = {{VIDE, VIDE, VIDE},{VIDE, VIDE, VIDE},{VIDE, VIDE, VIDE}};
 
    tGrille->loadFromFile("grille.png");
    sGrille->setTexture(*tGrille);
 
    tCroix->loadFromFile("croix.png");
    sCroix->setTexture(*tCroix);
 
    tRond->loadFromFile("rond.png");
    sRond->setTexture(*tRond);
 
    fenetre->setFramerateLimit(60);
    srand(time(NULL)); // initialisation de rand
 
}
 
Morpion::~Morpion()
{
    delete tGrille;
    delete tCroix;
    delete tRond;
 
    delete sGrille;
    delete sCroix;
    delete sRond;
 
    delete fenetre;
}
 
void Morpion::Jouer()
{
    while (fenetre->isOpen() && compteurCoups!= 0 && !partieTerminee)
     {
         sf::Event event;
         while (fenetre->pollEvent(event))
         {
             if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Q)
                 fenetre->close();
             if (event.type == sf::Event::MouseButtonPressed)
             {
                 if (ModifierGrille(Contenu::CROIX, event.mouseButton.x/100, event.mouseButton.y/100))
                 {
                     compteurCoups--;
                     partieTerminee = PartieTerminee();
                     if (compteurCoups > 0 && !partieTerminee)
                     {
                        compteurCoups--;
                        partieTerminee = IA();
                     }
                 }
             }
         }
 
         fenetre->clear();
 
         DessinerContenuGrille();
 
         fenetre->display();
     }
}
 
 
 
void Morpion::DessinerContenuGrille()
{
    for (int i=0; i < 3; i++)
    {
        for (int j=0; j < 3; j++)
        {
            if (grille[i].at(j) == Contenu::CROIX)
            {
                sCroix->setPosition(i*100, j*100);
                fenetre->draw(*sCroix);
            }
            else if (grille[i].at(j) == Contenu::ROND)
            {
                sRond->setPosition(i*100, j*100);
                fenetre->draw(*sRond);
            }
        }
    }
    fenetre->draw(*sGrille);
}
 
 
bool Morpion::ModifierGrille(Morpion::Contenu contenu, int i, int j)
{
    if (  i >= 0 && i <= 3 && j >= 0 && j<= 3 && grille[i].at(j) == Contenu::VIDE )
    {
        grille[i].at(j) = contenu;
        return true;
    }
    else return false;
}
 
 
bool Morpion::IA()
{
    std::pair<int,int> RAS = std::pair<int,int>(-1,-1);
    std::pair<int,int> coupAJouer = std::pair<int,int>(-1,-1);
 
    //IA teste d'abord ses chances
    if ((coupAJouer = EvaluerColonnes(Contenu::ROND)) != RAS)
    {
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
        return true;//IA a gagné
    }
    else if ((coupAJouer = EvaluerLignes(Contenu::ROND)) != RAS)
    {
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
        return true;//IA a gagné
    }
    else if ((coupAJouer = EvaluerDiagonales(Contenu::ROND)) != RAS)
    {
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
        return true;//IA a gagné
    }
    //IA teste ensuite les dangers
    else if ((coupAJouer = EvaluerColonnes(Contenu::CROIX)) != RAS)
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
    else if ((coupAJouer = EvaluerLignes(Contenu::CROIX)) != RAS)
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
    else if ((coupAJouer = EvaluerDiagonales(Contenu::CROIX)) != RAS)
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
    //Si toujours RAS, bah... on joue où y'a de la place, comme si il y avait une stratégie xD
    else
    {
        do
        {
            coupAJouer.first = rand()%3;
            coupAJouer.second = rand()%3;
        }while (grille[coupAJouer.first].at(coupAJouer.second) != Contenu::VIDE);
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
    }
    return false;
}
 
std::pair<int,int> Morpion::EvaluerColonnes(Morpion::Contenu c)
{
    //colonne 1
    if (grille[0].at(0) == c && grille[0].at(1) == c && grille[0].at(2) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(0,2);
    }
    else if (grille[0].at(0) == c && grille[0].at(2) == c && grille[0].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,1);
    }
    else if (grille[0].at(1) == c && grille[0].at(2) == c && grille[0].at(0) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,0);
    }
    //colonne 2
    else if (grille[1].at(0) == c && grille[1].at(1) == c && grille[1].at(2) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(1,2);
    }
    else if (grille[1].at(0) == c && grille[1].at(2) == c && grille[1].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,1);
    }
    else if (grille[1].at(1) == c && grille[1].at(2) == c && grille[1].at(0) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,0);
    }
    //colonne 3
    else if (grille[2].at(0) == c && grille[2].at(1) == c && grille[2].at(2) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,2);
    }
    else if (grille[2].at(0) == c && grille[2].at(2) == c && grille[2].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(2,1);
    }
    else if (grille[2].at(1) == c && grille[2].at(2) == c && grille[2].at(0) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(2,0);
    }
    else
        return std::pair<int,int>(-1,-1);
}
 
std::pair<int,int> Morpion::EvaluerLignes(Morpion::Contenu c)
{
    //ligne 1
    if (grille[0].at(0) == c && grille[1].at(0) == c && grille[2].at(0) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,0);
    }
    else if (grille[0].at(0) == c && grille[2].at(0) == c && grille[1].at(0) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,0);
    }
    else if (grille[1].at(0) == c && grille[2].at(0) == c && grille[0].at(0) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,0);
    }
    //colonne 2
    else if (grille[0].at(1) == c && grille[1].at(1) == c && grille[2].at(1) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,1);
    }
    else if (grille[0].at(1) == c && grille[2].at(1) == c && grille[1].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,1);
    }
    else if (grille[1].at(1) == c && grille[2].at(1) == c && grille[0].at(1) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,1);
    }
    //colonne 3
    else if (grille[0].at(2) == c && grille[1].at(2) == c && grille[2].at(2) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,2);
    }
    else if (grille[0].at(2) == c && grille[2].at(2) == c && grille[1].at(2) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,2);
    }
    else if (grille[1].at(2) == c && grille[2].at(2) == c && grille[0].at(2) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,2);
    }
    else
        return std::pair<int,int>(-1,-1);
}
 
std::pair<int,int> Morpion::EvaluerDiagonales(Morpion::Contenu c)
{
    //Diagonale 1
    if (grille[0].at(0) == c && grille[1].at(1) == c && grille[2].at(2) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,2);
    }
    else if (grille[0].at(0) == c && grille[2].at(2) == c && grille[1].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,1);
    }
    else if (grille[1].at(1) == c && grille[2].at(2) == c && grille[0].at(0) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,0);
    }
    //Diagonale 2
    else if (grille[0].at(2) == c && grille[1].at(1) == c && grille[2].at(0) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,0);
    }
    else if (grille[0].at(2) == c && grille[2].at(0) == c && grille[1].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,1);
    }
    else if (grille[1].at(1) == c && grille[2].at(0) == c && grille[0].at(2) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,2);
    }
    else
       return std::pair<int,int>(-1,-1);
}
 
bool Morpion::PartieTerminee()
{
    //on vérifie en colonne en en ligne si on a pas gagné...
    for (int i = 0; i < 3; i++)
    {
        if ( grille[i].at(0) == Contenu::CROIX && grille[i].at(1) == Contenu::CROIX && grille[i].at(2) == Contenu::CROIX )
            return (aGagne = true);
 
 
        if ( grille[0].at(i) == Contenu::CROIX && grille[1].at(i) == Contenu::CROIX && grille[2].at(i) == Contenu::CROIX )
            return (aGagne = true);
    }
    //...puis les diagonales
    if ( grille[0].at(0) == Contenu::CROIX && grille[1].at(1) == Contenu::CROIX && grille[2].at(2) == Contenu::CROIX )
        return (aGagne = true);
    if ( grille[0].at(2) == Contenu::CROIX && grille[1].at(1) == Contenu::CROIX && grille[2].at(0) == Contenu::CROIX )
        return (aGagne = true);
 
    return false;
}
 
 
void Morpion::Init()
{
    grille = {{VIDE, VIDE, VIDE},{VIDE, VIDE, VIDE},{VIDE, VIDE, VIDE}};
    partieTerminee = false;
    aGagne = false;
    compteurCoups = 9;
 
}

Lanceur.hpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
#include "morpion.hpp"
 
class Lanceur
{
    sf::Texture* tGagne;
    sf::Sprite* sGagne;
 
    sf::Texture* tPerdu;
    sf::Sprite* sPerdu;
 
    sf::Texture* tNul;
    sf::Sprite* sNul;
 
    sf::Texture* tRejouer;
    sf::Sprite* sRejouer;
 
    bool rejouer;
    bool choixFait;
 
    Morpion* m;
 
  public :
        Lanceur();
        void GererPartie();
 
 
};

Lanceur.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
#include "lanceur.hpp"
 
 
Lanceur::Lanceur() :
tGagne(new sf::Texture()),
sGagne(new sf::Sprite()),
tPerdu(new sf::Texture()),
sPerdu(new sf::Sprite()),
tNul(new sf::Texture()),
sNul(new sf::Sprite()),
tRejouer(new sf::Texture()),
sRejouer(new sf::Sprite()),
rejouer(true),
choixFait(false),
m(new Morpion())
{
    tGagne->loadFromFile("Gagne.png");
    sGagne->setTexture(*tGagne);
 
    tPerdu->loadFromFile("Perdu.png");
    sPerdu->setTexture(*tPerdu);
 
    tNul->loadFromFile("Egalite.png");
    sNul->setTexture(*tNul);
 
    tRejouer->loadFromFile("Rejouer.png");
    sRejouer->setTexture(*tRejouer);
 
}
 
 
 
void Lanceur::GererPartie()
{
    while(rejouer)
    {
        rejouer = false;//on remet rejouer à false maintenant qu'on est entré dans la boucle
        m->Jouer();
 
        //partie terminée...
        m->GetFenetre()->clear();
        m->DessinerContenuGrille();
 
        if (m->GetCompteurCoups() == 0)
            m->GetFenetre()->draw(*sNul);
        else if (m->AGagne())
            m->GetFenetre()->draw(*sGagne);
        else
            m->GetFenetre()->draw(*sPerdu);
 
        m->GetFenetre()->display();
 
 
        sf::Time t = sf::seconds(2);
        sf::sleep(t);
 
 
         while (m->GetFenetre()->isOpen() && !choixFait)
         {
             sf::Event event;
             while (m->GetFenetre()->pollEvent(event))
             {
                 if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Q)
                     m->GetFenetre()->close();
                 if (event.type == sf::Event::MouseButtonPressed && event.mouseButton.button == sf::Mouse::Button::Left)
                 {
                     if ((event.mouseButton.x <= 150) && (event.mouseButton.y > 150))
                     {
                        //on veut rejouer
                        rejouer = true;
                        choixFait = true;
                     }
                     else if ((event.mouseButton.x > 150) && (event.mouseButton.y > 150))
                     {
                         //on ne veut pas rejouer
                         rejouer = false;
                         choixFait = true;
                     }
                 }
                 m->GetFenetre()->clear();
                 m->DessinerContenuGrille();
                 m->GetFenetre()->draw(*sRejouer);
                 m->GetFenetre()->display();
             }
         }
        if (rejouer)
        {
            m->Init();
            choixFait = false;
            t = sf::milliseconds(500);
            sf::sleep(t);
 
        }
        //byebye...
    }
}

main.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include "lanceur.hpp"
 
using namespace std;
 
int main()
{
    Lanceur morpion;
    morpion.GererPartie();
    return 0;
}

[Luc Hermitte]

Tu ne veux pas utiliser at(). At(), c'est quand on ne sait pas ce que l'on fait
Tu ne veux pas de vecteur de vecteur. Pas efficace, et puis si tu te forces à rester en 3x3, les tableaux statiques sont très bien.
Tu ne veux pas de pointeurs bruts/nus non plus.
(et le code n'est pas const-correct)

[Kaamui]

J'ai précisé que c'était vieux et mal foutu (j'ai commencé le C++ en 2010, ce code doit dater de 2012 (et avait été fait en 5h dans une espèce de "gamejam" avec des potes), je ne savais effectivement pas ce que je faisais).

T'es-tu senti agressé par mes propos (moi oui mais peut-être ai-je tort) ? Où sommes-nous là pour faire un concours futile ? Parce que pour ce qui est d'aider l'OP dans l’appréhension du C++, je penses que ton code qui est surement parfait^^ est néanmoins illisible et incompréhensible. Je ne sais peut-être pas ce que je fait, mais je sais ce que j'essaie de faire : aider l'OP. Avant toute autre chose...