Discussion :

[gabgab]

Bonjour à tous,

Voilà je vous écris car j'ai un petit soucis de conception...

Je veux créer un plateau de jeu générique qui pourrait s'adapter à différents jeux. Celui-ci est représenté par un vecteur de type template T : vector<T>.

Petit souci : comment tester si une case de plateau est occupée ou non ? La seule idée qui me vient en tête c'est d'au lieu d'utiliser un vecteur d'objet je ferais mieux d'utiliser un vecteur de pointeur sur ces objets : vector<T*>, comme ca je pourrais tester vector<T*>.at(i)==0 ce qui signifique que la case est vide...

Mais bon je trouve ça un peu moche d'utiliser les pointeurs (ai-je tort ?) donc voilà je voulais savoir si quelqu'un voyait une autre alternative à mon problème...

Merci d'avance

[Iradrille]

Hello,

Ça dépend entièrement de la façon dont tu représentes les données.
Ça peut aller d'un vector d'enum où l'index dans le vector détermine la position

Code :

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

1
2
3
4
5
6
7
8
9
enum Piece {
    Aucune,
    Piece1,
    Piece2
};
 
std::vector<Piece> plateau;
// tester si une pièce est dans la case (4,5)
bool pieceIn4_5 = plateau[4*largeur+5] != Aucune;

A un vector de Piece contenant leur position

Code :

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

1
2
3
4
5
6
7
8
9
10
11
struct Piece {
    Position position;
    // ...
};
std::vector<Piece> pieces;
// tester si une pièce est dans la case (4,5)
using std::begin;
using std::end;
bool pieceIn4_5 = std::find_if(begin(pieces), end(pieces), [](const Piece& p)->bool {
    return p.position == Position(4,5);
}) != end(pieces);

Il est aussi possible d'avoir plusieurs représentations des données en simultané. Il faut juste bien faire attention à les garder synchronisées.

Réfléchi bien à la (ou les) façon de représenter les données la plus efficace (et simple d'utilisation).

Mais bon je trouve ça un peu moche d'utiliser les pointeurs (ai-je tort ?) donc voilà je voulais savoir si quelqu'un voyait une autre alternative à mon problème...

Avec ce genre de représentation tu sera obligé d'utiliser des pointeurs, mais ce n'est pas dérangeant.

[gabgab]

Tout d'abord merci pour ton aide.

Le truc qui me dérange dans ta réponse, c'est que j'ai l'impression que tu ne prends pas en compte les templates. En effet en suivant ton exemple j'aurais un plateau de type Piece uniquement.
Après une solution possible serait de déclarer un type pièce template...

[Ehonn]

Bonjour

Tu peux regarder du coté de boost::optional, std::optional (refusé pour C++14) ou équivalent.

[Iradrille]

Le truc qui me dérange dans ta réponse, c'est que j'ai l'impression que tu ne prends pas en compte les templates. En effet en suivant ton exemple j'aurais un plateau de type Piece uniquement.

Je donnais juste des exemples avec un type concret car c'est plus facile à relire, mais il est tout à fait possible d'avoir des templates.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template <class T>
class Plateau {
public:
    typedef T piece_type;
 
    // ...
private:
    // au choix, en fonction de la représentation des données
    // tu peux aussi avoir quelque chose de complètement différent.
    std::vector<piece_type*> m_pieces;
    std::vector<std::optional<piece_type>> m_pieces;
    std::vector<piece_type> m_pieces;
    std::vector<std::reference_wrapper<piece_type>> m_pieces;
};

Le problème n'est pas l'utilisation de templates, mais de savoir comment représenter les données pour que ce soit simple et rapide à utiliser.

[Bousk]

il n'y a rien de moche à utiliser des pointeurs et il ne faut pas avoir peur des pointeurs.

[Ehonn]

Il n'y a pas de raison d'utiliser des pointeurs bruts ici. Selon la sémantique de T (et de part le statut de std::optional), j'hésiterai entre un std::vector<???::optional<T>> et un std::vector<std::unique_ptr<T>>.

Si std::optional ou équivalent est disponible alors, j'utiliserai :
- std::vector<???::optional<T>> si T a une sémantique de copie.
- std::vector<std::unique_ptr<T>> si T a une sémantique d'entité.

L'utilisation basique reste la même : ???::optional et std::unique_ptr peuvent être utilisés tous les deux comme booléen et on peut accéder à la valeur par déréférencement.