Version imprimable
Bonjour je débute en programation C++ et je suis actuelement sur un petit programme mais je coince. J'aurai aimé savoir si il était possible de créer des map de ce genre la std::map<Etat,Position> avec Etat<std::string,std::string> et Position<int,int> ?
Si oui merci de m'expliquer comment faire car j'ai deja tester et le compilateur me ressort Etat, Position non déclarer (ce qui est logique mais je voit pas comment faire :( ). J'éspère avoir été assez claire lol
Merci d'avance
tu peut declarer une map de pair
par exemple :
ainsi tu peut ajouter des pair par simple operation d affectationCode:
2
3
4typedef pair<string,string> etat; typedef pair<int,int> position; map<etat,position> p;
voir fonctions membres de map
salut,
la déclaration d'une std::map<cle,valeur> nécessite le type de la clé et le type de la valeur enre le < et le >...
Tu peux donc, si cela correspond à ce que tu veux faire, utiliser std::map<int, int> voir std::map<std::string, std::string>, où le premier pourrait etre considéré comme "etat" et l'autre comme "position"...
Une solution alternative serait de déclarer une énumération pour les états envisagé
la map deviendrait std::map<eetats,int>Code:
2
3
4
5
6
7
8
9
10
Mais, quelle que soit la solution envisagée, il faut garder en tete que tu as une contrainte d'unicité sur la clé d'une std::map que tu n'a pas sur la valeur...
Si donc il est envisageable d'avoir, à un moment donné, deux éléments avec l'etat efini, il faudra utiliser plutot une multimap, voir, envisager d'utiliser "position" en tant que cle, si elle est consédérée comme unique ;)
Merci a vous deux Ocean24 je vais essayer ton truc mais il mesemble que j'avait deja tester et que sa avait planter je vais retester on verra
Sinon Koala01 ba j'ai pas trop compris tu truc :oops: mais merci d'avoir repondu
Bon apres avoir teste la solution a ocean24 ba j'ai les erreur suivante
les std::pair faut les mettre dans la fonction ou ce situe ma map ou dans la classe ? (il y a les meme erreur dans les deux cas)Citation:
1>e:\Partie.cpp(46) : error C2923: 'std::map'*: 'Etat' n'est pas un argument de type modèle valide pour le paramètre '_Kty'
1> e:\Partie.cpp(44)*: voir la déclaration de 'Etat'
1>e:\Partie.cpp(46) : error C2923: 'std::map'*: 'Position' n'est pas un argument de type modèle valide pour le paramètre '_Ty'
Bah, mon explication est simple, meme si elle n'est pas tres claire ;)
Une machine à état, c'est une valeur qui est modifiée en fonction de ce qui a été fait et/ou de la prochaine étape à effectuer...
En cela, une énumération est idéale parce que, plutot que d'avoir une valeur 1, 2 ou 3, on peut disposer d'un terme qui explique qu'elle vaut ('EnAttente", "ACommencer", "EnCours", "DevenuInutile"... ou, si tu préferes de manière plus générique Etat1, Etat2, Etat3)
L'avantage suplémentaire de l'énumération, c'est que, en C++, quand tu définis une énumération, tu définis également un type qui peut etre utilisé pour tout, comme si c'était un type tout ce qu'il y a de plus classique, que ce soit pour déclarer une variable, ou comme parametre fournit à un conteneur de la STL...
D'un autre coté, il y a la "position"...
Soit, c'est la position, dans le sens "position dans la file d'attente", et, à ce moment là, un entier ou une chaine peut suffir avec des valeurs de l'ordre de 1, 2, 3, 4... ou "premier", "deuxième", "troisième" ...
Soit c'est une position dans le sens "coordonées", à deux ou à trois dimentions, et il faudra donc créer une structure permettant de contenir les valeurs à représenter, ou utiliser un tableau qui puisse les contenir.
Au niveau de la std::map, c'est un conteneur "associatif" "trié"
C'est à dire qu'il permet de créer une relation entre les valeurs représentée par deux types différents (la clé d'un coté et la valeur de l'autre), en effectuant un tri sur la clé afin de pouvoir la retrouver plus rapidement...
La clé tout autant que la valeur doivent représenter des types connus par le compilateur, qu'il s'agisse de types "de base" (char, int, long...) ou des types "définis par l'utilisateur" (énumération, std::string, classe quelconque)
L'astuce, pour la "cle", c'est que, en plus, il faut pouvoir mettre un test de l'ordre de cle1 < cle2 < cle3 ET que chaque clé ne peut apparaitre qu'une seule fois:
représnente une std::map correcte, car aucune clé n'est identique à une autre (et ce, bien que les valeurs puissent etre identiques)Code:
2
3
4
5
6
7
Par contre,
n'est pas possible, du fait qu'on a deux fois la meme clé: le 1...Code:
2
3
4
5
6
Si tu veux pouvoir mettre deux fois la meme clé, il faut alors te tourner vers la std::multimap qui permet, justement, d'avoir des clé "dupliquées" (plusieurs fois la meme valeur),et qui acceptera le deuxième exemple ;)
Donc, pour créer ta map dont la clé est l'état et la valeur la position, il s'agit de la déclarer sous la forme de
Et, bien sur, si tu prévois que plusieurs éléments puissent etre à un meme état à un moment donné, il faudra utiliser la std::multimap, sinon, cela ne fonctionnera pas ;)Code:
2
3
4
5
6
7
8
9
10
As tu compris mes explications :question:
oui merci j'ai beaucoup mieux compris :D
En faite ce que je veux faire c'est une bataille navale (c'est un projet pour mon école et je suis pas tres douer en prog ^^) et je veut enregistrer les coordonnée des bateaux (choisit pas le joueur les coordonnees) donc j'ai creer ma fonction PlacementBateaux et je veux donc les enregistrer dans une map du style std::multimap<Etat,Position>
Etat correspondra <TypeBateau, Touche ou NON> donc deux string
Position <CoordX, CoordY> donc deux int
Mais en faite je ne suis pas sur d'avoir choisit le bon conteneur pour ce genre de truc :? Vous en pencez quoi ?
ps: je vais réfléchir a ton idee sur les enumération merci
J'ai l'impression que tu pars sur de tres mauvaises bases...
Car, à bien y réfléchir, l'état est "simplement" le nombre de cases qui restent au navire avant de couler, et la posiition est la coordonée sur la grille à laquelle se trouve, par exemple, la proue du navire...
Mais il te manque, aussi, l'orientation du navire (la direction vers laquelle il faut aller pour trouver la poupe: en haut, en bas, à gauche ou à droite ;))
Et, toutes ces informations font partie du navire en lui-meme, et doivent donc faire partie du "type de base" dont chaque navire est une représentation ;)
D'un autre coté, la "grille" sur laquelle on place les navires, qui doit etre composée d'une matrice de cases (n lignes sur m colones), dont chaque case indique si elle est
- non testée et libre (pas de partie du navire dessus)
- testée et libre
- non testée et non libre (une parite d'un navire se trouve dessus)
- testée et non libre (la partie du navire qui était dessus a été touchée)
- non testée et contenant la "proue" du navire
- testée et contenant la "proue" du navire (qui a été touchée :D)
Restera à créer les algorithmes qui permettent de retrouver la proue du navire, et de créer une intelligence artificielle qui tente de trouver les navires :D
merci de ton aide je vais donc recommencer ...
Mais donc pour faire les matrice en C++ c'est avec vector ( pas vu sa en cours :?) ??? oui la je suis couler mdr
merci encore de ton aide
En tant normal, je conseillerais l'utilisation d'un std::vector, mais, étant donné qu'ici, on connait parfaitement le nombre de lignes et le nombre de colones, cela ne me choquerait absolument pas de voir la grille sous la forme d'un tableau deux dimentions "à la C"...
[EDIT]j'entend par là une grille déclarée sous la forme de
Code:
2
aaa ok je vien de comprendre je pence ... en faite par exemple je fait un tableau de int que j'initialise 0 par exemple pour dire que aucun bateau ce situe sur cette case et apres je modifie le int suivant si il y a un bateau etc ... j'espère que j'ai bien compris ^^. merci de ton aide
Salut,
si je peux te donner un conseil, avant de chercher quel conteneur sera bon pour telle ou telle chose de ton jeux, prends un peu de temps pour réfléchir à sa conception, et essaie de le modéliser ...
Comment représenter un bateau ?
Comment représenter une grille de jeu ?
Quels sont les intervenants du jeu (joueurs, arbitre) ?
Quelles sont les relation entre eux ?
Et au fur et à mesure les choix de "types" t'apparaitront plus clairement ...
Là, tu risques d'en faire, et puis de les remettre en cause trop souvent.
@+