Jeu des cartes en C++

voila la soulution
Class Carte{
.........
.............
.............};

ila mal9itounich laghiw lya f mon tel olla laghiw l 2M

dsl pour que des gens parle arabe voici le solution de votre problem:

#ifndef CARTE_H
#define CARTE_H


class Carte
{
int valeur;
int couleur;
public:
Carte(){valeur=0;couleur=0;}//constructeur par defaut
Carte(const Carte& ct)//constructeur par recopie
{
this->valeur=ct.valeur;
this->couleur=ct.couleur;
}
int compare(Carte& ct)
{
if(this->valeur > ct.valeur) return 1;//si la premier carte superieur au 2 eme
else if(this->valeur < ct.valeur) return 2;//si la premier carte inferieur au 2 eme
else return 0;//il sont egaux
}
void setvaleur(int val)//accesseur en ecriture sur valeur
{
this->valeur=val;
}
void setcouleur(int coul)//accesseur en ecriture sur couleur
{
this->couleur=coul;
}
int getvaleur()//accesseur en lecture sur valeur
{
return valeur;
}
int getcouleur()//accesseur en lecture sur valeur
{
return couleur;
}
void echange(Carte& ct)//echanger deux carte
{
Carte aide=*this;//en creer une carte aide pour enregistrer la premier carte
valeur=ct.valeur;//en affecte la valeur de 2 carte à la 1
couleur=ct.couleur;// en affecte la couleur de 2 carte à la 1
ct=aide;//en recopie la 2 carte dans la premier
}
// class destructor
~Carte(){}//c'est le compilateur qui choisie le destructeur
};

#endif // CARTE_H


#ifndef HAND_H
#define HAND_H

/*
* catte class representer une main qui ce caracterise par une liste du cartes
*/
class Hand
{
Carte listcarte[26];
int nb_carte;
public:
// constructeur par defaut
Hand()
{
this->nb_carte=26;//au debut en met le nombre carte du carte sur une main(hand) a 26
}
// constructeur par recopie
Hand(const Hand& h)
{
this ->nb_carte=h.nb_carte;
for(int i=0;i<26;i++) listcarte[i]=h.listcarte[i];
}
void setlist(Carte* t)//accesseur en ecriture sur la liste des cartes
{
for(int i=0;i<26;i++)
{
listcarte[i]=t[i];
}
}
Carte& tirer()//pour tirer une carte de la main
{
int indice = rand()%(this->nb_carte);//choisir un indice entre 0 et le nombre du carte
Carte *ct=new Carte(listcarte[indice]);//en memoirise la carte a tirer
decaler(indice,nb_carte);//decaler la liste des carte
listcarte[nb_carte-1]=*ct;//en met la carte a tirer a la fin
nb_carte--;//decrementé le nombre du carte sur la main
return listcarte[nb_carte];//retourner la carte choisie
}
/*
methode pour decaler la liste des carte
apres un tirer du carte de la main
*/
void decaler(int debut,int fin)//
{
//debut: la position du carte tirer
//fin :position du dernier carte sur la main
for(int i=debut;i<fin;i++)
{
listcarte[i]=listcarte[i+1];
}
}
int getnb_carte(){return nb_carte;}//accesseur en lecture sur le nombre du carte reste dans la main
Carte& getcarte(int pos){return listcarte[pos];}
// class destructor
~Hand(){delete[] listcarte;}//destructeur
};

#endif // HAND_H




#ifndef PAQUET_H
#define PAQUET_H
#include"carte.h"
#include"hand.h"
using namespace std;
/*
* paquet qui representer l'ensemble du cartes(le paquet)
*/
class Paquet
{
Carte carte[52];

public:
// constructeur par defaut
Paquet()
{
int i=0;
for (int coul=0; coul<4; coul++)//0 à 3 (carreau, trèfle, coeur, pique)
for (int val=0; val<13; val++)// 1 à 10 + valet,reine, roi
{
carte[i].setvaleur(val);
carte[i].setcouleur(coul);
i++;
}
}
void trier()
{
for(int i=0;i<51;i++)
{
for(int j=i+1;j<52;j++)
{
if(this->carte[i].getvaleur()>this->carte[j].getvaleur())
{
// permuter les deux carte
carte[i].echange(carte[j]);
}
}
}
}
// Melanger l'ensemble du cartes
void melanger()
{
int indice;
int pos=52;
for(int i=0;i<52;i++)
{
indice = rand()%(pos);//en prendre un indice d'une carte aux hasard
//permutation du 2 carte
carte[indice].echange(carte[pos-1]);//en remplace la carte du l'indice par le dernier carte
pos--;// en decrement la fin du paquet pour ne pas melanger la carte choisie encore une foix
}
}
// couper le paquet en deux sous paquet
void split(Hand& h1,Hand& h2)
{
Carte list1[26],list2[26];//en creer deux pointeur de list de carte
int a=0;
// en fais la distibution du paquet sur deux list
for(int i=0;i<26;i++)
{
list1[i]=carte[a];
a++;
list2[i]=carte[a];
a++;
}
h1.setlist(list1);//affectation du la list
h2.setlist(list2);//affectation du la list
}
Carte getcarte(int pos)//retourne la carte dans la position pos
{
return carte[pos];
}
// class destructor
~Paquet(){delete[] carte;}//destructeur
};

#endif // PAQUET_H



#ifndef JOUEUR_H
#define JOUEUR_H

/*
* le joueur
*/
class Joueur
{
char *prenom;
Hand hand;
int score;
public:
// constructeur par defaut
Joueur()
{
this->score=0;//en in initialise le score du joueur par 0 au debut
}
void setprenom(char *nom)//accesseur en ecriture sur le prenom
{
prenom=new char[strlen(nom)+1];//allouer le chmps prenom par un tableau du caractereau taille du argument nom
strcpy(this->prenom,nom);//copie le nom vers prenom
}

void sethand(Hand& h)//accesseur en ecriture sur hand
{
this->hand=h;
}

Hand& gethand(){return hand;}//accesseur en lecture sur hand

void increment()// incrementer le score du joueur
{
this->score++;
}

char *getprenom(){return prenom;}//accesseur en lecture sur le prenom

int getscore(){return score;}//accesseur en lecture sur le score

~Joueur(){delete [] prenom;}
};

#endif // JOUEUR_H


#ifndef BATAILLE_H
#define BATAILLE_H
#include"paquet.h"
#include"joueur.h"
#include"graphique.h"
/*
* cette class permet de gerer une partie netre deux joueur
*/
class Bataille
{
Paquet pq;
public:
// constructeur par initialisation
Bataille(Paquet& pq)
{
this->pq=pq;
}

//methode qui gere une partie entre deux joueur
void combat(Joueur& j1,Joueur& j2);

~Bataille(){}//destructeur
};

#endif // BATAILLE_H



pour voir le solution complete je vs invite a voir mon source sur cppfrance

https://codes-sources.commentcamarche.net/

n'oublier pas a laisser vs commentaire

a+