BlackJack Création de Deck dynamique C OOP

Question

Mon professeur Nous a assigné ce devoir, mais je ne peux pas donner de sens sur la façon de faire le premier pas. Je ne demande pas à quiconque de faire les devoirs, juste vous plaît quelqu'un me aider à la première question

1. Créer une plate-forme dynamique

Cette question repose sur deux fichiers (qu'il provieded)

"card.h"

//********************************************************* 
// CLASS DECLARATION 
//********************************************************* 
class Card 
{ 
    //***************************************************** 
    // Public Members   
    //***************************************************** 
    public: 
    // Exception classes 
    class NotInitalized {}; 

    // Enumeration for Suit 
    enum Suit { Clubs, Diamonds, Hearts, Spades, 
       UNKNOWN }; 

    // Enumeration for Card Name 
     enum CardName { Ace, Two, Three, Four, Five, Six, 
        Seven, Eight, Nine, Ten, Jack, 
        Queen, King, UNKNOWN }; 

    // constructors 
//***************************************************** 
// Card 
// 
// Create uninitialized card. Must be initialized with 
// 'setCard()' before use. 
//***************************************************** 
    Card(); // card is not initialized 
//***************************************************** 
// Card 
// 
// Create a card based its ordinal position. 
//  cards are ordered by suit first in the order 
//  Clubs, Diamonds, Hearts and Spades, and within 
//  the suit they are ordered Act thru King. 
//****************************************************** 
    Card(int); // number between 1-52 

//****************************************************** 
// Card 
// 
// Create a card with the given name and suit. 
//******************************************************* 
     Card(Suit, CardName); 

    // methods 
    //******************************************************* 
    // setCard 
    // 
    // Set the Suit and Name of the card 
    //******************************************************* 
     void setCard(Suit, CardName); 

    //******************************************************* 
    // getSuit 
    // 
    // returns the element of the Suit enumeration 
    // representing the suit of the card 
    //******************************************************* 
    int  getSuit(); 

    //******************************************************* 
    // getCardName 
    // 
    // returns the element of the CardName enumeration 
    // representing the card 
    //******************************************************* 
    int getCardName(); 

    //******************************************************* 
    // getCardValue 
    // 
    // returns face value of card. For Ace -1 is the value. 
    //******************************************************* 
    int   getCardValue(); 

    //***************************************************** 
    // toString 
    // 
    // return the string representation of the card. 
    // e.g.,"Ace of Spades" 
    //***************************************************** 
     string  toString(); 

//************************************************ 
// Private Members  
//************************************************ 
private: 
    // the Card’s suit (uses Suit enum) 
    Suit  suit = Suit::UNKNOWN; 

    // the Card’s name (uses CardName enum) 
    CardName name = CardName::UNKNOWN; 
}; 

la deuxième classe est la classe de plate-forme. Cette classe représente les 52 cartes dans un jeu de poker standard. En interne, les cartes du jeu doivent être conservées dans un tableau d'objets Carte. Il devrait également y avoir un tableau parallèle de pointeurs de cartes où l'ordre des cartes après chaque brassage peut être stocké. Quand un objet Deck est créé, il crée les 52 cartes et les mélange. Si le deck manque de cartes avant d'être remanié, la méthode dealCard() devrait lancer une exception DeckEmpty. Étant donné que cette classe crée des objets de carte, un destructeur doit être supprimé pour supprimer tous les objets de carte associés lors de la suppression de la plate-forme.

Voici la déclaration de classe pour la classe Deck.

//********************************************************* 
// CLASS DECLARATION 
//********************************************************* 
#include “Card.h” 
class Deck 
{ 
//***************************************************** 
// Public Members   
//***************************************************** 
public: 
    // Exception classes 
    class DeckEmpty {}; 

    // Constructors/Destructors 
    Deck(); // creates the cards and sorts them 
    ~Deck(); // frees all the cards 

    // Methods 
    //**************************************************** 
    // dealCard 
    // 
    // return the next available card in the shuffled deck 
    //**************************************************** 
    Card  dealCard(); 

    //**************************************************** 
    // shuffle 
    // 
    // shuffle the cards 
    //**************************************************** 
    Void  shuffle();  // shuffle the deck 


    //**************************************************** 
    // getCardCount 
    // 
    // return the number of unused cards in the shuffled 
    //  deck 
    //**************************************************** 
     int  getCardCount(); // how many cards left 

    //**************************************************** 
    // toString 
    // 
    // return a newline (\n) delimited list of the shuffled 
    // cards 
    //***************************************************** 
    string toString(); 

//***************************************************** 
// Private Members  
//***************************************************** 
private: 
    // array to hold unshuffled cards 
     Card  cards[DECK_SIZE]; 

    // array to hold shuffled cards 
    Card*  shuffledCards[DECK_SIZE]; 

    // index of next card to deal from shuffled cards 
     int  nextCardIndex;  
}; 

Answer 1

Cela n'a vraiment aucun sens pour moi non plus. En particulier, le bit sur le tableau parallèle des cartes mélangées n'est pas clair. Et l'affirmation selon laquelle il a besoin d'un destructeur parce qu'il crée des objets Carte est tout simplement incorrecte. Peut-être veut-il dire qu'il crée dynamiquement des objets Carte, mais d'abord ce n'est pas ce qu'il a dit, et deuxièmement je n'en vois pas le besoin. Je pense que tu devrais parler avec ton professeur.

Cependant, la première étape est très facile.

'1. Créer une plate-forme dynamiquement '

Deck *my_deck = new Deck; 

Résolu. Pourquoi créer un deck dynamiquement est une autre question, mais c'est ce qu'il vous a demandé de faire.

Je ne suis pas du tout sûr que votre professeur sache de quoi il parle.

Answer 2

Mon professeur nous a confié ce travail à domicile, mais je ne peux pas donner un sens sur la façon de faire la première étape. Je ne demande pas à quiconque de faire les devoirs, juste s'il vous plaît quelqu'un me aider à la première question

1. Créer une plate-forme dynamique

Voici la réponse:

Deck* obj = new Deck(); 

Qu'est-ce que vous pouvez voir ci-dessus est une nouvelle expression. http://en.cppreference.com/w/cpp/language/new Avec cette expression, de nouveaux objets sont créés dynamiquement.