fork download 
  1. #include <string>
  2. #include <array>
  3. #include <algorithm>
  4. #include <ostream>
  5. #include <iostream>
  6.  
  7. #include <random>
  8.  
  9. namespace constants
  10. {
  11. static constexpr const size_t num_values = 13;
  12. static constexpr const size_t num_suits  = 4;
  13. static constexpr const size_t num_cards  = num_values * num_suits;
  14. }
  15.  
  16. enum class Value : int8_t
  17. {
  18.     None = -1,
  19.     Two,
  20.     Three,
  21.     Four,
  22.     Five,
  23.     Six,
  24.     Seven,
  25.     Eight,
  26.     Nine,
  27.     Ten,
  28.     Jack,
  29.     Queen,
  30.     King,
  31.     Ace
  32. };
  33.  
  34.     enum class Suit : int8_t
  35.     {
  36.         None = -1,
  37.         Heart,
  38.         Diamond,
  39.         Spade,
  40.         Club
  41.     };
  42.  
  43.  
  44.     template<typename T>
  45.     std::string to_string(const T&);
  46.  
  47.     template<>
  48.     std::string to_string<Value>(const Value& value)
  49.     {
  50.         std::string str;
  51.         switch(value)
  52.         {
  53.         case Value::None:  str = "None"; break;
  54.         case Value::Two:   str = "2"; break;
  55.         case Value::Three: str = "3"; break;
  56.         case Value::Four:  str = "4"; break;
  57.         case Value::Five:  str = "5"; break;
  58.         case Value::Six:   str = "6"; break;
  59.         case Value::Seven: str = "7"; break;
  60.         case Value::Eight: str = "8"; break;
  61.         case Value::Nine:  str = "9"; break;
  62.         case Value::Ten:   str = "T"; break;
  63.         case Value::Jack:  str = "J"; break;
  64.         case Value::Queen: str = "Q"; break;
  65.         case Value::King:  str = "K"; break;
  66.         case Value::Ace:   str = "A"; break;
  67.  
  68.         default: break;
  69.         }
  70.         return str;
  71.     }
  72.  
  73.     template<>
  74.     std::string to_string<Suit>(const Suit& suit)
  75.     {
  76.         std::string str;
  77.         switch(suit)
  78.         {
  79.         case Suit::None:    str = "None"; break;
  80.         case Suit::Heart:   str = "h"; break;
  81.         case Suit::Diamond: str = "d"; break;
  82.         case Suit::Spade:   str = "s"; break;
  83.         case Suit::Club:    str = "c"; break;
  84.         default: break;
  85.         }
  86.  
  87.         return str;
  88.     }
  89.  
  90.     class Card
  91.     {
  92.     public:
  93.  
  94.         constexpr Card() = default;
  95.         constexpr Card(Value value, Suit suit) : m_value(value), m_suit(suit) {}
  96.  
  97.         Value  value()  const noexcept { return m_value; }
  98.         Suit   suit()   const noexcept { return m_suit;  }
  99.  
  100.         Card& operator++()
  101.         {
  102.             if(m_value == Value::Ace)
  103.                 m_suit  = static_cast<Suit>((static_cast<int8_t>(m_suit) + 1) % constants::num_suits);
  104.  
  105.             m_value = static_cast<Value>((static_cast<int8_t>(m_value) + 1) % constants::num_values);
  106.             return *this;
  107.         }
  108.         Card  operator++(int)
  109.         {
  110.             Card result(*this);
  111.             ++(*this);
  112.             return result;
  113.         }
  114.  
  115.     private:
  116.         Value m_value{};
  117.         Suit  m_suit{};
  118.  
  119.     };
  120.  
  121.  
  122. std::ostream& operator<<(std::ostream& os, const Card& card)
  123. {
  124.     os << to_string(card.value()) << to_string(card.suit());
  125.     return os;
  126. }
  127.  
  128. class Deck
  129. {
  130. public:
  131.     using Type           = std::array<Card, constants::num_cards>;
  132.     using iterator       = Type::iterator;
  133.     using const_iterator = Type::const_iterator;
  134.  
  135.     iterator       begin()       noexcept { return m_deck.begin(); }
  136.     const_iterator begin() const noexcept { return m_deck.begin(); }
  137.     iterator       end()         noexcept { return m_deck.end();   }
  138.     const_iterator end()   const noexcept { return m_deck.end();   }
  139.  
  140.     void init()
  141.     {
  142.         std::iota(m_deck.begin(), m_deck.end(), Card(Value::Two, Suit::Heart));
  143.     }
  144.  
  145.     void randomInit()
  146.     {
  147.         init();
  148.         std::shuffle(m_deck.begin(), m_deck.end(), m_g);
  149.     }
  150.  
  151. private:
  152.  
  153.     Type m_deck;
  154.     std::random_device m_rd;
  155.     std::mt19937 m_g{m_rd()};
  156. };
  157.  
  158. std::ostream& operator<<(std::ostream& os, const Deck& deck)
  159. {
  160.     for(const auto& card : deck)
  161.         os << card << ' ';
  162.  
  163.     return os;
  164. }
  165.  
  166. int main(int argc, char** argv)
  167. {
  168.     Deck deck;
  169.  
  170.     deck.randomInit();
  171.     std::cout << deck << '\n';
  172.  
  173.     return 0;
  174. }
  175.  
Success #stdin #stdout 0s 15240KB
comments (?)
stdin 
Standard input is empty
stdout 
2h Qh 5s 3s 5d 8h 4s Qs Jd 7s 7h 9h 3c 8d 9c Tc 5h Ad Kd 8c 2c 4h 3h 6d 7c Td Qd 6c Th 2s 8s 2d Qc Ks Ah 9d 9s Kh 3d Ts As 7d 6h 6s 5c Kc Js Jh 4c 4d Jc Ac
https://ideone.com/lxBLh2
language:
C++14 (gcc 8.3)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!