Discussion :

[KindPlayer]

Voici un debut de programme simulant un jeu de carte (en vue de simuler du poker par la suite)

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
 
#include <iostream>
 
using std::cout;
using std::endl;
using std::ios;
 
#include <iomanip>
using std::setw;
using std::setiosflags;
 
#include <cstdlib>
#include <ctime>
 
typedef struct Carte{
	int couleur;
	int valeur;
} Carte;
 
void echange( Carte &, Carte & );
void brasser( Carte [] );
//void afficherJeu( Carte [], const char *[], const char *[] );
 
const int SIZE = 52;
 
int main(){
	int coul,val,card;
	Carte carte;
	const char *Couleur[ 4 ] = {"coeur", "carreau", "trèfle", "pique"};
	const char *Valeur[ 13 ] = {"As", "Deux", "Trois", "Quatre", "Cinq", "Six", "Sept", "Huit", "Neuf", "Dix", "Valet", "Dame", "Roi"};
      cout << *Valeur <<"\n";//ici tt va bien
	Carte jeu[ SIZE ] = { 0 };
	for ( coul = 0, card = 0; coul < 4; ++coul, ++card)
		for (val = 0; val < 13; ++val, ++card){
			carte.couleur = coul;
			carte.valeur = val;
			jeu[ card ] = carte;
		}
 
        cout << *Couleur << "\n"; //ici tt va bien (a tester en mettant en comm. la ligne du dessous)
	cout << *Valeur<< "\n";//Ici erreur de segmentation!!!
	brasser(jeu);
	cout << jeu[32].couleur << endl;
	for (int i = 0; i < SIZE; i++)
		cout << setw(4) << resetiosflags (ios::left) << Couleur[ jeu[ i ].couleur]<< " " ;//<< " de " << Couleur[ jeu[ i ].couleur ] <<"\n";
	cout << endl;
	return 0;
}
 
 
 
 
void echange(Carte &c1, Carte &c2){
	Carte tmp;
	tmp = c1;
	c1 = c2;
	c2 = tmp;
}	
void brasser(Carte jeu[]){
	int compteur = 0,i,j;
	srand(time(0));
	while (++compteur < 100){
		i = rand() % 52;
		j = rand() % 52;
		echange(jeu[i],jeu[j]);
	}
}

Avec le tableau de pointeur Couleur ca se passe bien et pas avec Valeur! Comment expliquer ca?

[[Hugo]]

question naïve : pourquoi pas faire un vector<string> ?

[MatRem]

A priori, tu as un problème d'accès à jeu :
tu fais 4*13 + 4 incrémentation de card ...

Un conseil, en c++ pense à utiliser la STL avec ses conteneurs trés pratique (std::vector par exemple).

[[Hugo]]

en outre, est qu'il ne faut pas que les tableaux fassent une case de plus que le nombre d'éléments, en théorie ? vagues souvenirs de C...

[Bruno Gillet]

en outre, est qu'il ne faut pas que les tableaux fassent une case de plus que le nombre d'éléments, en théorie ? vagues souvenirs de C...

Non, pas les tableaux d'éléments, juste les chaines de caratères (tableaux de char ) pour le caractère de fin ('\0')

[[Hugo]]

J'utilise jamais de tableaux de char, that's why vive la STL !

[screetch]

ton incrementation de card est fausse, car lors du dernier passage dans la boucle interne tu vas incrementer card, ne pas utiliser la valeur puisque tu atteins la fin de la boucle, et le reincrementer dans la boucle externe. donc tu as un "trou" dans les valeurs de card, tu l'incrementes trop.

c'est trop complexe de toute facon, sors le card de la boucle, tu y verras plus clair.

Code :

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

1
2
3
4
5
6
7
8
9
10
int card = 0;
for ( coul = 0; coul < 4; ++coul)
{
	for (val = 0; val < 13; ++val, ++card)
	{
		carte.couleur = coul;
		carte.valeur = val;
		jeu[ card ] = carte;
	}
}

c'est gentil de vouloir gagner en compacité en collant plein de truc dans la boucle for, mais ca fait faire des conneries.

[koala01]

Salut, et bienvenue sur le forum.

Ton code est de nature à appeler une foule considérable de remarques...

Pour te permettre d'évoluer un peu en C++, voici quelques remarques "en vrac" concernant ton code:

1. Plutôt que de prendre tant de lignes pour les
   

   Code :

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

   1
   2
   3
   4
   5
   using std::cout;
   using std::endl;
   using std::ios;
   using std::setw;
   using std::setiosflags;

   regroupe simplement tout cela en une seule et unique instruction disant d'utiliser ... l'espace de nomage std
   

   Code :

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

   using namespace std;

2. La syntaxe
   

   Code :

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

   1
   2
   3
   4
   typedef struct Carte{
   	int couleur;
   	int valeur;
   } Carte;

   est une syntaxe typiquement "C style": en C++, la définition d'une structure, d'une énumération, d'une union ou d'une classe induit automatiquement la définition du type associé.
   
   On y préférera donc la syntaxe (finalement plus simple )
   

   Code :

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

   1
   2
   3
   4
   struct Carte{
   	int couleur;
   	int valeur;
   };

3. En C++, il existe une classe qui remplace avantageusement les tableaux de caractères pour représenter une chaine de caractères: la classe string, qui est disponible dans l'espace de nommage std grâce à l'inclusion du fichier d'en-tête string...
   
   Autant que faire se peut, il est *fortement recommandé* de préférer l'usage de cette classe aux chaînes de caractères "C style" partout où c'est possible, d'autant plus qu'elle dispose d'une métode particulière (c_str() en l'occurrence) qui permet de récupérer la chaine sous la forme d'un const char* si on en a réellement besoin.
   
   Les différentes chaînes pourraient donc être déclarées sous la forme de
   

   Code :

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

   1
   2
   3
   4
   5
   6
   7
   8
   /* au début du fichier */
   #include <string>
   using namespace std; /* cf plus haut */
    
   /* dans main() */
   const string couleurs[4]={"pique","coeur","carreaux","trefle"};
   const string valeurs[13]={"as", "deux", "trois", "quatre", "cinq", "six", "sept",
                            "huit", "neuf", "dix", "valet", "dame", "roi"}

4. Un tableau d'éléments n'est sans doute pas la meilleur solution envisageable dés le moment où il faut effectuer un tirage aléatoire "sans remise" (normalement, il n'y a qu'un as de cœur dans un jeu de carte ):
   
   En effet, plus le nombre de tirages effectués augmente, plus la probabilité de tomber sur une carte déjà tirée augmente, ce qui est déjà un problème à prendre en compte lors de la conception dans le sens où il faut s'assurer que la carte sélectionnée est encore bel et bien dans le tableau, mais, en plus, cette prise en compte va faire qu'il faudra, sur la fin du paquet, plus d'essais pour trouver une carte qui n'a pas été distribuée
   
   Comme, en plus, toute carte distribuée se retrouvera, au final, avec d'autres de ses congénères, il semble opportun de préférer une liste - éventuellement doublement chaînée - et peut être circulaire à un tableau pour permettre gérer "le paquet" (qu'il s'agisse du paquet de cartes non distribuées ou de celui que le joueur a en main ) Je reviendrai sur ce point un peu plus loin
5. Le C++ est un langage orienté objet... S'il permet la programmation "purement procédurale", il faut avouer que l'optique de travailler en "orienté objet" est de nature à faciliter grandement la vie du programmeur, et il serait donc bête de s'en priver
6. L'un des principes à garder constamment en tête lorsqu'on programme quelque chose est la délégation des responsabilités:
   
   Un objet (ou une fonction) ne doit être responsable que d'une/un groupe de chose(s) bien particulière(s) mais doit s'en occuper correctement.
   
   Si un objet ou une fonction est responsable de plus d'une chose, c'est sans doute qu'il ou elle a trop de responsabilités.
   
   En anglais, on utilise l'expression KISS (Keep It Simple, Stupid)

Voici maintenant ce que je te conseillerais pour prendre toutes ces remarques en compte (le malheur veut qu'il n'y ai pas - à ma connaissance -de liste circulaire dans la bibliothèque standard)

L'élément de base, c'est la carte.

Ses "signe distinctifs" sont:

• une valeur
• une couleur
• la carte qui se trouve "avant elle" (quand elle se trouve dans un paquet)
• la carte qui se trouve "après elle" (quand elle se trouve dans un paquet)

Ses responsabilités sont:

• Indiquer sa valeur
• permettre d'accéder à la carte suivante (quand elle se trouve dans un paquet)
• permettre d'accéder à la carte précédente (quand elle se trouve dans un paquet)
• permettre de modifier la carte précédente ou suivante qui se trouve dans le paquet

Toutes les cartes on en commun:

• les termes utilisés pour représenter la couleur (valeur constante)
• les termes utilisés pour représenter la valeur (valeur constante)

On pourrait donc envisager de créer une classe "Carte" qui prendrait la forme (nécessite l'inclusion de l'en-tête string)

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
class Carte
{
    public:
        Carte(size_t color, size_t value, Carte* previous=NULL, Carte*
              next=NULL);
        ~Carte();
        size_t GetColor() const;
        size_t GetValue() const;
        const std::string ToString() const;
        Carte* Next();
        Carte* Previous();
        void SetPrevious(Carte* newprev);
        void SetNext(Carte* newnext);
    private:
        size_t col;
        size_t val;
        Carte* prev;
        Carte* next;
        static const std::string values[13];
        static const std::string colors[4];
};

L'implémentation pourrait ressembler à

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
#include "Carte.h"
const std::string Carte::values[13]={"As", "Deux", "Trois", "quatre",
                  "cinq", "six", "sept", "huit", "neuf", "dix", "valet",
                  "dame", "rois"};
const std::string Carte::colors[4]={"coeur", "carreau", "pique",
                  "trefle"};
Carte::Carte(size_t color, size_t value, Carte* previous, Carte* next):
    col(color), val(value), prev(previous), next(next)
{
 
}
 
Carte::~Carte()
{
    prev=NULL;
    next=NULL;
}
size_t Carte::GetColor() const
{
    return col;
}
size_t Carte::GetValue() const
{
    return val;
}
const std::string Carte::ToString() const
{
    std::string ret=values[val]+" "+colors[col];
    return ret;
}
Carte* Carte::Next()
{
    return next;
}
Carte* Carte::Previous()
{
    return prev;
}
void Carte::SetPrevious(Carte* newprev)
{
    prev=newprev;
}
void Carte::SetNext(Carte* newnext)
{
    next=newnext;
}

Maintenant, le fait d'avoir une carte ne sert pas à grand chose à lui seul:

• Un jeu de carte est composé de 52 carte,
• quand on joue à la bataille, au poker, au rami, on a généralement plusieurs cartes en main
• ...

Comme mon intervention prend de plus en plus l'allure d'un roman, je vais le restreindre à l'étude du jeu de cartes (même si je n'ai rien contre l'idée de t'expliquer le reste )

Les "signes distinctifs" d'un jeu de carte sont:

• La carte qui se trouve "en haut" du paquet
• La carte qui se trouve "en bas" du paquet
• le nombre de cartes qu'il contient

Ses responsabilités sont:

• Créer l'ensemble des cartes qui le composent (au début, ou sur demande)
• Mélanger les cartes
• Fournir la (ou les N) carte(s) qui se trouve(nt) en haut du paquet (en prenant en compte qu'elles sortent du paquet)
• Récupérer une (ou plusieurs) cartes et les placer en bas du paquet
• Eventuellement (pour la "vérification" du fonctionnement), afficher les valeurs des cartes dans l'ordre où elles apparaissent
• Eventuellement indiquer le nombre de cartes restantes dans le jeu
• Détruire les carte (quand le jeu est fini, ou sur demande)

Cela nous conduirait à une classe "JeuCartes" qui prendrait la forme de (nécessite l'inclusion de Carte.h )

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
class JeuCarte
{
    public:
        JeuCarte();
        ~JeuCarte();
        void CreerJeu();
        void Melanger();
        Carte* DonneCarte(size_t combien);
        void AfficheCartes() const;
        size_t Size() const;
        void DetruireJeu();
        void ChangerJeu();
        void RecupererCartes(Carte* toadd);
    private:
        Carte* first;
        Carte* last;
        size_t size;
};

qui pourrait être implémenté sous la forme de

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
#include "JeuCarte.h"
#include <iostream> /* inclu uniquement pour AfficheCarte ;) */
 
JeuCarte::JeuCarte():first(NULL),last(NULL),size(0)
{
    CreerJeu();
}
 
JeuCarte::~JeuCarte()
{
    DetruireJeu();
}
void JeuCarte::CreerJeu()
{
    /*deux boucle imbriquées pour la création du jeu */
    for(size_t color=0;color<4; color++)
    {
        for(size_t value=0;value<13;value++)
        {
            Carte* temp=new Carte(color, value,last);
            if(first==NULL)
                first=temp;
            if(last!=NULL)
                last->SetNext(temp);
            last=temp;
            size++;
        }
    }
}
void JeuCarte::Melanger()
{
    /* Par facilité, et pour une meilleure répartition, on rend la liste
     * circulaire
     */
    first->SetPrevious(last);
    last->SetNext(first);
    /* on récupère un pointeur de travail, et on part sur une liste vide */
    Carte* travail=first;
    first=NULL;
    last=NULL;
    /* on initialise le générateur aléatoire */
    srand(time(0));
    /* On sélectionne une carte jusqu'à ce qu'il n'y en ai plus qu'une
     * seule potentielle...
     *
     * On préfère utiliser une boucle non incrémentale pour le cas où on
     * souhaite faire remélanger alors que toutes les cartes ne sont pas
     * dans le paquet
     */
    while (travail->Next()!=travail)
    {
        Carte* temp=travail;
        size_t alea=rand()%52;
        for(size_t i=0;i<alea;i++)
            temp=temp->Next();
        temp->Next()->SetPrevious(temp->Previous());
        temp->Previous()->SetNext(temp->Next());
        travail=temp->Next();
        temp->SetNext(NULL);
        temp->SetPrevious(last);
        if(first==NULL)
            first=temp;
        if(last!=NULL)
            last->SetNext(temp);
        last=temp;
    }
    travail->SetNext(NULL);
    travail->SetPrevious(last);
    last->SetNext(travail);
}
Carte* JeuCarte::DonneCarte(size_t combien)
{
    /* idéalement, il faudrait s'assurer qu'il reste bien combien cartes
     * dans le jeu et qu'on demande minimum une carte:D
     */
     Carte* ret=first;
     for(size_t i=0;i<combien;i++)
        first=first->Next();
    first->Previous()->SetNext(NULL);
    first->SetPrevious(NULL);
    size-=combien;
    return ret;
}
void JeuCarte::AfficheCartes() const
{
    Carte* v=first;
    size_t i=1;
    while(v!=NULL)
    {
        std::cout<<i<<"   "<<v->ToString()<<std::endl;
        v=v->Next();
        i++;
    }
}
size_t JeuCarte::Size() const
{
    return size;
}
void JeuCarte::DetruireJeu()
{
    while(first!=NULL)
    {
        Carte* temp=first->Next();
        delete first;
        first=temp;
        size--;
    }
}
void JeuCarte::ChangerJeu()
{
    DetruireJeu();
    CreerJeu();
}
void JeuCarte::RecupererCarte(Carte* toadd)
{
    if(toadd!=NULL)
    {
        toadd->SetPrevious(last);
        if(first==NULL)
            first=toadd;
        if(last!=NULL)
            last->SetNext(toadd);
        last=toadd;
        size++;
        while(last->Next()!=NULL)
        {
            last=last->Next();
            size++;
        }
    }
}

[[Hugo]]

Merci des tes explications Koala !!!! ça intéresse les p'tits rigolos dans mon genre, aussi

[koala01]

Mais c'était avec plaisir

[acx01b]

salut

moi je n'utilise pas les vector car j'aime bien parcourir les tableaux avec des pointeurs

l'erreur est simple

for ( coul = 0, card = 0; coul < 4; ++coul)
et pas
for ( coul = 0, card = 0; coul < 4; ++coul, ++card)


en effet ton code est typiquement mal écrit (à cet endroit là!):
en C on apprend à écrire comme ça:

Code :

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

1
2
3
4
5
6
7
card = 0;
for ( coul = 0; coul < 4; ++coul)
  for (val = 0; val < 13; ++val){
    carte.couleur = coul;
    carte.valeur = val;
    jeu[ card++ ] = carte;
  }

à chaque fois qu'on met une nouvelle carte dans le tableau, on met l'index à la carte suivante (tout simplement)

a+

[koala01]

Et tu remarquera que cela devient rapidement illisible, tout cela...

Il a été démontré jusqu'à plus soif que les boucles du genre de

Code :

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

1
2
3
4
5
for(i=0,j=0;i<4;i++,j++)
{
    /*...*/
    truc[j];
}

de

Code :

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

1
2
3
4
5
6
7
8
 
j=0;
for(i=0;i<4;i++)
{
    /*...*/
    truc[j];
    j++;
}

ou même

Code :

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

1
2
3
4
5
6
for(i=0;i<4;++i)
{
    /*...*/
    truc[j];
    ++j;
}

avaient pour résultat que les compilateurs fournissaient un code assembleur identique.

Peut-être n'était-ce pas le cas à l'époque où le C et le C++ ont été écrits, mais, c'est en tout cas vrai avec les compilateurs récents...

Du coup, il apparaît tout de suite préférable d'écouter la sagesse populaire quand elle dit

Un code est plus souvent lu qu'il n'est écrit/modifié

Ceci dit, la seule différence entre un tableau et un std::vector, c'est que le std::vector est plus sécurisant au niveau de l'utilisation...

Mais il est vrai que, quand il s'agit de maintenir des valeurs constantes...