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.
Version imprimable
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.
Parles-tu d'un bète tableau statique/automatique (ou alloué avec new[]) ou d'un std::vector ?
En fait mon tableau est déclaré comme ceci :
Code:int pioche[4][10][2];
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.
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.
Plus simple: Faire un shuffle sur le tableau, et lire les cartes une à une.
Shuffle est une fonction ?
Car ni l'aide Borland, ni Google ne la connait !
:salut:
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.
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.
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 ;):D
[EDIT]Après "moultes recherches", j'ai enfin retrouvé l'intervention dont je parlais...Elle se trouve ici
Merci à tous pour votre aide !
Je vais essayer la méthode koala01 !
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 :
Chaque carte de la pioche est définie par une couleur et un numéro.Code:
2
3
4
5
6
7
8
Ensuite, pour créer la pioche :
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.Code:
2
3
4
5
6
7
8
9
10
11
12
La fonction ajouter_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).Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Qu'en pensez-vous ?
Je pense avoir compris le principe, mais comment visualiser une carte de la liste ?
Merci d'avance, Guillaume.
9 joueur et ca rame ????8O8O
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.
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 :D
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...
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.
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 ;)
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.
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 :D