[C++11] Déplacer un objet incopiable

Version imprimable

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:

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:

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 ?

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:

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:

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; };

23/10/2014, 15h18
Daïmanu

C'est aussi simple que ça ?

Merci, ça marche maintenant :D.

Ç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:

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.