C++ Supprimer une ligne d'un tableau

**gcvoiron** · 29/10/2007, 12h03

Bonjour,

Je souhaite savoir si en C++, il existe une fonction permettant de supprimer la ligne d'un tableau, comme ceci :
t[0] = A
t[1] = B
t[2] = C

Je supprime t[1], il reste :
t[0] = A
t[1] = C

Merci d'avance, Guillaume.

**Médinoc** · 29/10/2007, 12h10

Parles-tu d'un bète tableau statique/automatique (ou alloué avec new[]) ou d'un std::vector ?

**gcvoiron** · 29/10/2007, 12h12

En fait mon tableau est déclaré comme ceci :

Code :

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

int pioche[4][10][2];

**Médinoc** · 29/10/2007, 12h14

Un tableau statique ou automatique n'est pas redimensionnable.
Ce que tu peux faire par contre, c'est copier toutes les lignes suivantes vers la ligne que tu voulais supprimer, elle sera donc écrasée.

La fonction C memmove() peut servir, puisque c'est un bète tableau de int.

**gcvoiron** · 29/10/2007, 12h52

Merci pour ta réponse Médinoc.
Je programme un jeu de "Uno" en C++, et j'ai un tableau qui contient toutes les cartes, qui indique si la carte est dans la pioche, ou si un joueur l'a.
A la distribution, je tire une carte au hasard, si elle est dans la pioche, on la donne au joueur, sinon, on en tire une autre.
Et le problème, dès que l'on commence à avoir 9 joueurs, la boucle while dure très longtemps...
Je voudrai donc faire un tableau en parallèle comprenant que les cartes disponibles dans la pioche.

Aurais-tu une idée de tableau redimensionnable ?

Merci d'avance, Guillaume.

**Médinoc** · 29/10/2007, 13h00

Plus simple: Faire un shuffle sur le tableau, et lire les cartes une à une.

**gcvoiron** · 29/10/2007, 13h19

Shuffle est une fonction ?
Car ni l'aide Borland, ni Google ne la connait !

**befalimpertinent** · 29/10/2007, 13h48

Je crois qu'il s'agit plutôt de la fonction random_shuffle de la STL.
un petit conseil profite en pour utiliser les std::vector en lieu et place de tes tableaux surtout si tu es au début de ton projet.

**Médinoc** · 29/10/2007, 13h49

Non, pas une fonction.
Par contre, std::random_shuffle en est une (sans doute déclarée et définie dans <algorithm>).

En bref, tu fais un tableau de cartes, tu mélanges le tableau, et tu lis au fur et à mesure. Le temps reste totalement déterministe.

**koala01** · 29/10/2007, 15h09

Salut,

Je l'ai expliqué récemment, mais malheureusement, je ne retrouve plus la discussion d'origine, mais...

De manière générale, on peut très bien estimer que l'utilisation de tableaux ne soit vraiment pas l'optique idéale pour gérer un jeu de carte.

En effet, les cartes vont régulièrement changer de place:

de la pioche vers une main,
d'une main vers une autre
d'une main vers un tas "abandonné"
du tas "abandonné" vers une main
du tas "abandonné" vers la pioche (chaque fois que la pioche sera vide, elle récupère le tas "abandonné")

(tous les cas ne sont pas d'office présents dans tous les jeux, mais bon...)

De plus, il s'agit bien souvent de gérer le paquet de carte sous forme d'un tirage aléatoire sans remise (une carte "piochée" à un moment X ne peut pas être "repriochée" plus tard).

Dés lors, il semble intéressant d'envisager plutôt le paquet de carte sous la forme d'une structure dynamique: une liste simplement ou doublement chaînée, que l'on pourrait envisager de rendre circulaire lorsqu'il s'agit de faire appel au hasard.

L'idée générale étant de maintenir plusieurs listes "utiles":

la liste "pioche" (cartes mélangées, sur lequel les joueurs peuvent aller chercher la première carte)
une liste "abandonnées"
une liste "main" pour chaque joueur présent. (éventuellement triée, pour la facilité et dans laquelle le joueur peut sélectionner la carte qu'il préfère)
éventuellement une liste de listes (ou un tableau de listes) "déposées"

A partir de là, quel que soit l'origine d'une carte ou sa destination, il "suffira"

de retirer la carte de la liste d'origine (en veillant à "combler les trous")
de placer la carte "au sommet" de la liste de destination

L'utilisation d'une liste chaînée facilitera grandement l'ensemble de la gestion de tous les "changements de mains" que peuvent subir les différentes cartes

[EDIT]Après "moultes recherches", j'ai enfin retrouvé l'intervention dont je parlais...Elle se trouve ici

**gcvoiron** · 29/10/2007, 17h50

Merci à tous pour votre aide !
Je vais essayer la méthode koala01 !

**gcvoiron** · 29/10/2007, 23h03

Bonsoir,

J'ai lu pas mal de chose sur les listes, notamment ceci qui est plutôt bien expliqué :
http://www.up.univ-mrs.fr/wcpp/V1/Lecons/L10.pdf
J'ai donc essayé de faire une liste pour la pioche.
Voici ma classe :

Code :

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

1
2
3
4
5
6
7
8
class carte_pioche
{
	public:
	int couleur;
   int numero;
   carte_pioche * cp_suivante;
   void ajouter_carte(int, int, int);
};

Chaque carte de la pioche est définie par une couleur et un numéro.

Ensuite, pour créer la pioche :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 carte_pioche Pioche;
   Pioche.cp_suivante = NULL;
    for(Couleur=1;Couleur<NbCouleur;Couleur++)
    {
        for(Chiffre=0;Chiffre<NbChiffre;Chiffre++)
        {
            for(Exemplaire=0;Exemplaire<NbExemplaire;Exemplaire++)
            {
                    Pioche.ajouter_carte(Couleur,Chiffre,Exemplaire);
            }
        }
    }

Pour le nombre de couleur du jeu (4, RJVB), le nombre d'exemplaire de chaque carte (2), le nombre de chiffres (10, 0 à 9), on crée la pioche.

La fonction ajouter_carte :

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
void carte_pioche::ajouter_carte(int couleur, int numero, int exemplaire)
{
	carte_pioche * nouvelle_carte = new carte_pioche;
   nouvelle_carte->numero = numero;
   nouvelle_carte->couleur = couleur;
   if((couleur == 3) && (numero == 9) && (exemplaire == 1))
   {
   	nouvelle_carte->cp_suivante = NULL;
	   cp_suivante = NULL;
   }
   else
   {
   	nouvelle_carte->cp_suivante = cp_suivante;
	   cp_suivante = nouvelle_carte;
   }
}

On reçoit en paramètre le numéro, la couleur et l'exemplaire de la carte. Si c'est la dernière carte de la pioche, le pointeur suivant pointera sur NULL (fin de la liste).

Qu'en pensez-vous ?

Je pense avoir compris le principe, mais comment visualiser une carte de la liste ?

Merci d'avance, Guillaume.

**deadalnix** · 29/10/2007, 23h46

9 joueur et ca rame ????

il y a vraiement un truc qui cloche, le probleme peut pas venir de la !

Bouger 2*4*10 int *9 joueurs, ca donne 720 operation / allocation. A moins que ton PC et ta ram marchent a 700 HZ, ca doit venir d'ailleur ton probleme.

**koala01** · 30/10/2007, 00h14

Attention, le but du jeu est de n'allouer qu'une seule fois la mémoire nécessaire à chaque carte, de mélanger les cartes au début, puis de se contenter de faire passer les différentes cartes d'une liste à l'autre , en envisageant le cas échéant, de remélanger le tas "abandonné" quand il passe vers la pioche

L'*idéal* étant de se baser sur ce que j'ai écrit dans mon intervention sous référence pour la gestion du jeu de carte (les XXX cartes du jeu d'UNO), puis de réfléchir un peu, et sur les bases que j'ai fournies, à la manière de gérer les cartes tenues par les différents joueur...

**gcvoiron** · 30/10/2007, 00h24

Si j'ai bien compris, le plus simple est de faire :
- Une liste pioche
- Une liste par joueur
- Une liste cartes posées
Et de faire passer les cartes d'une liste à l'autre.

**koala01** · 30/10/2007, 00h36

Mais oui, tout simplement...

Tu "crées" les cartes (tu alloue la mémoire utilisée par chaque carte) au début de partie, tu place cela dans une liste pour la pioche et tu "mélange" cette liste, pendant le jeu, les différentes cartes se contentent de passer d'une liste à l'autre, et tu détruit l'ensemble des cartes (tu libère la mémoire allouée à chaque carte)juste avant de quitter le jeu

**gcvoiron** · 07/11/2007, 00h53

Bonsoir,

J'aurai deux questions pour avancer ma prog :

- Comment mélanger une liste ?
- Comment créer N listes ? Si il ya 6 joueurs, 6 listes... ?

Merci d'avance, Guillaume.

**koala01** · 07/11/2007, 16h01

J'ai édité ma première réponse (le post n°10) pour fournir un lien vers un code complet sur le sujet.

Effectivement, si tu as six joueurs, cela signifie que tu auras six listes, ou plutôt, même, pour être précis, chaque joueur est représenté par une liste.

Mais bon, une fois que tu as la structure d'un élément, la liste ne fait "que" maintenir:

un pointeur sur le premier élément de la liste
un pointeur sur le dernier élément de la liste
éventuellement un entier représentant le nombre d'éléments dans la liste

Ceci dit, ce n'est pas parce que tu as six liste que tu dois multiplier les éléments pour les mettre dedans:

Tu te "contente" de passer les éléments d'une liste à l'autre

C++ Supprimer une ligne d'un tableau

C++

Discussions similaires

Partager

Partager