Discussion :

[Da�manu]

Bonjour.

Je cherche � faire un jeu de carte et j'en suis � la d�finition des classes de base.

J'ai un probl�me lorsque le jeu cherche � cr�er une Main en piochant dans le deck :

Voici une version simplifi�e de mon probl�me :

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <deque>
#include <iostream>
 
class Card {
    enum Rank {/*As à Roi*/} m_rank;
    enum Suit {/*Couleurs*/} m_suit;
 
    Card(Rank rank, Suit suit) :
	m_rank(rank), m_suit(suit) {}
 
    Card(Card &&other) :
        m_rank(std::move(other.m_rank)), suit(std::move(other.m_suit)) {}
 
    Card& operator= (Card &&other) {
        m_rank = std::move(other.m_rank);
        m_suit = std::move(other.m_suit);
        return *this;
    }
 
    Card(const Card&) = delete;
    Card& operator= (const Card&) = delete;
};
 
class Deck {
    /**
     * Creates 52 cards.
     */
    Deck();
    /**
     * @brief draw
     * Extract the front card.
     * After this function, the deck won't be full anymore.
     * @return the front card of the deck
     */
    Card &&draw() {
        auto card(std::move(m_cards.front()));
        m_cards.pop_front();
        return std::move(card);
    };
 
    std::deque< Card > m_cards;
};
 
int main(int, char**) {
    Deck d;
    auto c = d.draw();
    std::cout << c.m_rank << '\n';
    return 0;
}

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
g++ main.cpp -Wall -Wextra -std=c++11 && ./a.out 
-110905296

Le code compile mais le probl�me vient de la fonction Deck::draw() qui renvoie une carte avec des valeurs al�atoires.
Je pense que le probl�me vient de la s�mantique de mouvement que je ne ma�trise pas encore assez.

D'apr�s vous d'o� vient le probl�me ?

[Flob90]

Bonjour,

Tes op�rations par d�placement ne font rien de sp�cial, tu peux donc laisser le compilateur les �crire avec =default, de plus quand tu d�clare une op�rations par copie ou par d�placement, la g�n�ration automatique des autres est d�sactiv�, il est inutile de d�sactiver explicitement les op�rations par copies :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
struct Card
{
	enum Rank { /*stuff*/ } m_rank;
	enum Suit { /*stuff*/ } m_suit;
 
	Card(Rank rank, Suit suit) :
		m_rank(rank), m_suit(suit)
	{ }
 
	Card(Card&&) =default;
	Card& operator=(Card&&) =default;
};

Ensuite, on ne retourne jamais une r�f�rence sur un objet local, que ce soit une lref ou un rref. Ce que ta fonction draw doit retourner c'est bien un objet, pas une r�f�rence, donc tu indiques directement le type Card, c'est lors du return que cet objet doit �tre construit en d�pla�ant une ressource. Dans ton cas le return est fait sur un objet local � la fonction, ce qui implique qu'elle est automatiquement d�plac�, tu n'as m�me pas besoin d'indiquer le move :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
 
struct Deck
{
	Card draw()
	{
		auto card(std::move(m_cards.front()));
		m_cards.pop_front();
		return card;
	}
 
	std::deque<Card> m_cards;
};

[Da�manu]

C'est aussi simple que �a ?

Merci, �a marche maintenant .

[Flob90]

�a r�pond � ta question, apr�s on a pas parl� de la prise en compte des exceptions dans ton code.

Cependant tu as de la chance, toutes tes fonctions peuvent �tre qualifi�es en noexcept. On peut aussi rajouter une assertion pour v�rifier que le deck n'est pas vide lors de l'appel � draw.

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
#include<cassert>
#include<deque>
 
struct Card
{
	enum Rank {
		As
	} m_rank;
	enum Suit {
		Coeur
	} m_suit;
 
	Card(Rank rank, Suit suit) noexcept
		: m_rank(rank)
		, m_suit(suit)
	{ }
 
	Card(Card&&) noexcept
		=default;
	Card& operator=(Card&&) noexcept
		=default;
};
 
struct Deck
{
	Card draw() noexcept
	{
		assert(!m_cards.empty() && "Deck empty");
 
		auto card(std::move(m_cards.front()));
		m_cards.pop_front();
		return card;
	}
 
private:
	std::deque<Card> m_cards;
};

On pourrait rajouter des constexpr � plusieurs endroit, mais je ne suis pas convaincu de l'int�r�t ici.