I have 2 questions

1. Is enumeration constant of int datatype?
2. For class Card, do I create two data member of enum type Face and Suit and then initialize it via the constructor?

Background:

9.23 (Card Shuffling and Dealing) Create a program to shuffle and deal a deck of cards. The program should consist of class Card, class DeckOfCards and a driver program. Class Card should provide:

• a) Data members face and suit—use enumerations to represent the faces and suits.
• b) A constructor that receives two enumeration constants representing the face and suit and uses them to initialize the data members.
• c) Two static arrays of strings representing the faces and suits.
• d) A toString function that returns the Card as a string in the form “face of suit.” You can use the operator to concatenate strings.

Class DeckOfCards should contain:

• a) An array of Cards named deck to store the Cards.
• b) An integer currentCard representing the next card to deal.
• c) A default constructor that initializes the Cards in the deck.
• d) A shuffle function that shuffles the Cards in the deck. The shuffle algorithm should iterate through the array of Cards. For each Card, randomly select another Card in the deck and swap the two Cards.
• e) A dealCard function that returns the next Card object from the deck.
• f) A moreCards function that returns a bool value indicating whether there are more Cards to deal.

This is from c how to program by deitel.

sorry, I am quite confused because I have never initialized scoped enum in class constructor before.

CodePudding user response：

An enumeration constant presumably is of an enum type: https://en.cppreference.com/w/cpp/language/enum .

Yes, depending on the kind enumeration, it can be converted to integers, sometimes the conversion makes sense (e.g. for the face value) but in some cases you want to stay away from it (e.g. for the suit value). For the later enum class helps.

And yes, it seems that the exercise is pushing you into designing the Card class like that.

enum Suit { spades, clubs, hearts, diamonds };
enum Face { ace, two, three, ...};

class Card {
 public:
  Suit s;
  Face f;
};

Note that this is where books go out their way to make you think that a certain thing should implemented in a certain way just because you have learned a new feature of the language. This is not the only way to implement a Card class or more importantly a Card game application.

It depends a lot what you do with them later. Specially what kind of "collections" you tolerate for the Cards class. (A card in isolation is kind of meaningless.)

Think also if Cards should be copyable?, movable?, swappable? (or even mutable!?). What about special values, is there a "blank card"? is there a "jack"? How to ensure in the logic of the program that there are no duplicated flying around? These are the real questions in the design of a class, IMO.