10.x – Резюме к главе 10 и небольшой тест

#include <array>
#include <numeric> // std::reduce
#include <iostream>
 
// Мы хотим использовать ItemTypes для индексации массива. Используем enum, а не enum class.
enum ItemTypes
{
  item_health_potion,
  item_torch,
  item_arrow,
  max_items
};
 
using inventory_type = std::array<int, ItemTypes::max_items>;
 
int countTotalItems(const inventory_type& items)
{
  return std::reduce(items.begin(), items.end());
}
 
int main()
{
  inventory_type items{ 2, 5, 10 };
 
  std::cout << "The player has " << countTotalItems(items) << " item(s) in total.\n";
 
  // Мы можем получить доступ к отдельным элементам с помощью перечислителей:
  std::cout << "The player has " << items[ItemTypes::item_torch] << " torch(es)\n";
 
  return 0;
}

#include <algorithm> // std::sort
#include <cstddef> // std::size_t
#include <iostream>
#include <string>
#include <vector>
 
struct Student
{
  std::string name{};
  int grade{};
};
 
int getNumberOfStudents()
{
  int numberOfStudents{};
 
  do
  {
    std::cout << "How many students do you want to enter? ";
    std::cin >> numberOfStudents;
  } while (numberOfStudents <= 0);
 
  return numberOfStudents;
}
 
std::vector<Student> getStudents()
{
  using vector_type = std::vector<Student>;
 
  int numberOfStudents{ getNumberOfStudents() };
 
  // Создаем вектор с количеством элементов, равным numberOfStudents.
  vector_type students(static_cast<vector_type::size_type>(numberOfStudents));
 
  int studentNumber{ 1 };
 
  for (auto& student : students)
  {
    std::cout << "Enter name #" << studentNumber << ": ";
    std::cin >> student.name;
    std::cout << "Enter grade #" << studentNumber << ": ";
    std::cin >> student.grade;
 
    ++studentNumber;
  }
 
  return students;
}
 
// Передаем по ссылке, чтобы избежать медленного копирования.
bool compareStudents(const Student& a, const Student& b)
{
  return (a.grade > b.grade);
}
 
int main()
{
  auto students{ getStudents() };
 
  std::sort(students.begin(), students.end(), compareStudents);
 
  // Печатаем все имена
  for (const auto& student : students)
  {
    std::cout << student.name << " got a grade of " << student.grade << '\n';
  }
 
  return 0;
}

Используйте параметры-ссылки

void swap(int& a, int& b)

#include <iostream>
 
// Используем параметры-ссылки, чтобы
// мы могли изменять значения переданных аргументов
void swap(int& a, int& b)
{
  // Временно сохраняем значение a
  int temp{ a };
 
  // Помещаем значение b в a
  a = b;
  // Помещаем предыдущее значение a в b
  b = temp;
}
 
int main()
{
  int a{ 6 };
  int b{ 8 };
  swap(a, b);
 
  if (a == 8 && b == 6)
    std::cout << "It works!\n";
  else
    std::cout << "It's broken!\n";
 
  return 0;
}

const char* str{ "Hello, world!" };
std::cout << *str; // H
++str;
std::cout << *str; // e
// ...

#include <iostream>
 
// str будет указывать на первую букву строки в стиле C.
// Обратите внимание, что str указывает на const char,
// поэтому мы не можем изменить значения, на которые он указывает.
// Однако мы можем заставить str указывать на что-нибудь еще.
// Это не меняет значения аргумента.
void printCString(const char* str)
{
  // Пока мы не встретили нулевой терминатор
  while (*str != '\0')
  {
    // выводим текущий символ
    std::cout << *str;
 
    // и переводим str на следующий символ
    ++str;
  }
}
 
int main()
{
  printCString("Hello world!");
 
  std::cout << '\n';
 
  return 0;
}

В цикле допущена ошибка на единицу, и попытка получить доступ к элементу массива с индексом 4, которого не существует. Условное выражение в цикле for должно использовать < вместо <=.

ptr – указатель на const int. Вы не можете присвоить ему значение 6. Вы можете исправить это, сделав ptr неконстантным.

array распадается на указатель, когда он передается в printArray(). Циклы for на основе диапазона не могут работать с указателем на массив, потому что размер массива неизвестен. Одно из решений – добавить параметр длины к функции printArray() и использовать обычный цикл for. Лучшее решение – использовать std::array вместо встроенных фиксированных массивов.

temp – это фиксированный массив, но length не является константой времени компиляции, поэтому мы не можем использовать length для создания массива в стиле C. Переменная temp также выйдет из области видимости в конце функции, возвращаемое значение будет указывать на что-то недопустимое. temp должен использовать динамическое выделение памяти или быть std::vector.

Вы не можете заставить указатель int указывать на переменную, отличную от int. ptr должен иметь тип double*.

enum class CardSuit
{
    suit_club,
    suit_diamond,
    suit_heart,
    suit_spade,
 
    max_suits
};
 
enum class CardRank
{
    rank_2,
    rank_3,
    rank_4,
    rank_5,
    rank_6,
    rank_7,
    rank_8,
    rank_9,
    rank_10,
    rank_jack,
    rank_queen,
    rank_king,
    rank_ace,
 
    max_ranks
};

struct Card
{
  CardRank rank{};
  CardSuit suit{};
};

Используйте оператор switch.

void printCard(const Card& card)
{
    switch (card.rank)
    {
    case CardRank::rank_2:      std::cout << '2';   break;
    case CardRank::rank_3:      std::cout << '3';   break;
    case CardRank::rank_4:      std::cout << '4';   break;
    case CardRank::rank_5:      std::cout << '5';   break;
    case CardRank::rank_6:      std::cout << '6';   break;
    case CardRank::rank_7:      std::cout << '7';   break;
    case CardRank::rank_8:      std::cout << '8';   break;
    case CardRank::rank_9:      std::cout << '9';   break;
    case CardRank::rank_10:     std::cout << 'T';   break;
    case CardRank::rank_jack:   std::cout << 'J';   break;
    case CardRank::rank_queen:  std::cout << 'Q';   break;
    case CardRank::rank_king:   std::cout << 'K';   break;
    case CardRank::rank_ace:    std::cout << 'A';   break;
    default:
        std::cout << '?';
        break;
    }
 
    switch (card.suit)
    {
    case CardSuit::suit_club:       std::cout << 'C';   break;
    case CardSuit::suit_diamond:    std::cout << 'D';   break;
    case CardSuit::suit_heart:      std::cout << 'H';   break;
    case CardSuit::suit_spade:      std::cout << 'S';   break;
    default:
        std::cout << '?';
        break;
    }
}

#include <array>
 
// Нам это понадобится еще много раз, создайте псевдонимы.
using deck_type = std::array<Card, 52>;
using index_type = deck_type::size_type;
 
deck_type createDeck()
{
  deck_type deck{};
 
  // Мы могли бы инициализировать каждую карту отдельно,
  // но это было бы проблемно. Воспользуемся циклом.
 
  index_type card{ 0 };
 
  auto suits{ static_cast<int>(CardSuit::max_suits) };
  auto ranks{ static_cast<int>(CardRank::max_ranks) };
 
  for (int suit{ 0 }; suit < suits; ++suit)
  {
    for (int rank{ 0 }; rank < ranks; ++rank)
    {
      deck[card].suit = static_cast<CardSuit>(suit);
      deck[card].rank = static_cast<CardRank>(rank);
      ++card;
    }
  }
 
  return deck;
}
 
int main()
{
  auto deck{ createDeck() };
 
  return 0;
}

void printDeck(const deck_type& deck)
{
  for (const auto& card : deck)
  {
    printCard(card);
    std::cout << ' ';
  }
 
  std::cout << '\n';
}

#include <algorithm> // для std::shuffle
#include <ctime>     // для std::time
#include <random>    // для std::mt19937
 
// ...
 
void shuffleDeck(deck_type& deck)
{
  // mt статический, поэтому инициализируется только один раз.
  static std::mt19937 mt{ static_cast<std::mt19937::result_type>(std::time(nullptr)) };
 
  std::shuffle(deck.begin(), deck.end(), mt);
}
 
int main()
{
  auto deck{ createDeck() };
 
  shuffleDeck(deck);
 
  printDeck(deck);
 
  return 0;
}

int getCardValue(const Card& card)
{
  // Обрабатываем ранг от 2 до 10. Мы могли бы сделать это
  // с помощью switch, но это было бы долго.
  if (card.rank <= CardRank::rank_10)
  {
    // RANK_2 это 0 (значение 2)
    // RANK_3 это 1 (значение 3)
    // и т.д.
    return (static_cast<int>(card.rank) + 2);
  }
 
  switch (card.rank)
  {
  case CardRank::rank_jack:
  case CardRank::rank_queen:
  case CardRank::rank_king:
    return 10;
  case CardRank::rank_ace:
    return 11;
  default:
    // Не должно случиться. Если всё-таки случилось,
    // значит, в нашем коде есть ошибка.
    return 0;
  }
}

#include <algorithm> // std::shuffle
#include <array>
#include <ctime>     // std::time
#include <iostream>
#include <random>    // std::mt19937
 
enum class CardSuit
{
    suit_club,
    suit_diamond,
    suit_heart,
    suit_spade,
 
    max_suits
};
 
enum class CardRank
{
    rank_2,
    rank_3,
    rank_4,
    rank_5,
    rank_6,
    rank_7,
    rank_8,
    rank_9,
    rank_10,
    rank_jack,
    rank_queen,
    rank_king,
    rank_ace,
 
    max_ranks
};
 
struct Card
{
    CardRank rank{};
    CardSuit suit{};
};
 
struct Player
{
    int score{};
};
 
using deck_type = std::array<Card, 52>;
using index_type = deck_type::size_type;
 
// Максимальный счет до проигрыша.
constexpr int maximumScore{ 21 };
 
// Минимальный счет, который должен иметь дилер.
constexpr int minimumDealerScore{ 17 };
 
void printCard(const Card& card)
{
    switch (card.rank)
    {
    case CardRank::rank_2:      std::cout << '2';   break;
    case CardRank::rank_3:      std::cout << '3';   break;
    case CardRank::rank_4:      std::cout << '4';   break;
    case CardRank::rank_5:      std::cout << '5';   break;
    case CardRank::rank_6:      std::cout << '6';   break;
    case CardRank::rank_7:      std::cout << '7';   break;
    case CardRank::rank_8:      std::cout << '8';   break;
    case CardRank::rank_9:      std::cout << '9';   break;
    case CardRank::rank_10:     std::cout << 'T';   break;
    case CardRank::rank_jack:   std::cout << 'J';   break;
    case CardRank::rank_queen:  std::cout << 'Q';   break;
    case CardRank::rank_king:   std::cout << 'K';   break;
    case CardRank::rank_ace:    std::cout << 'A';   break;
    default:
        std::cout << '?';
        break;
    }
 
    switch (card.suit)
    {
    case CardSuit::suit_club:       std::cout << 'C';   break;
    case CardSuit::suit_diamond:    std::cout << 'D';   break;
    case CardSuit::suit_heart:      std::cout << 'H';   break;
    case CardSuit::suit_spade:      std::cout << 'S';   break;
    default:
        std::cout << '?';
        break;
    }
}
 
int getCardValue(const Card& card)
{
    // Обрабатываем ранг от 2 до 10. Мы могли бы сделать это
    // с помощью switch, но это было бы долго.
    if (card.rank <= CardRank::rank_10)
    {
        // RANK_2 это 0 (значение 2)
        // RANK_3 это 1 (значение 3)
        // и т.д.
        return (static_cast<int>(card.rank) + 2);
    }
 
    switch (card.rank)
    {
    case CardRank::rank_jack:
    case CardRank::rank_queen:
    case CardRank::rank_king:
        return 10;
    case CardRank::rank_ace:
        return 11;
    default:
        // Не должно случиться. Если всё-таки случилось,
        // значит, в нашем коде есть ошибка.
        return 0;
    }
}
 
void printDeck(const deck_type& deck)
{
    for (const auto& card : deck)
    {
        printCard(card);
        std::cout << ' ';
    }
 
    std::cout << '\n';
}
 
deck_type createDeck()
{
    deck_type deck{};
 
    // Мы могли бы инициализировать каждую карту отдельно,
    // но это было бы проблемно. Воспользуемся циклом.
 
    index_type card{ 0 };
 
    auto suits{ static_cast<int>(CardSuit::max_suits) };
    auto ranks{ static_cast<int>(CardRank::max_ranks) };
 
    for (int suit{ 0 }; suit < suits; ++suit)
    {
        for (int rank{ 0 }; rank < ranks; ++rank)
        {
            deck[card].suit = static_cast<CardSuit>(suit);
            deck[card].rank = static_cast<CardRank>(rank);
            ++card;
        }
    }
 
    return deck;
}
 
 
void shuffleDeck(deck_type& deck)
{
    static std::mt19937 mt{ static_cast<std::mt19937::result_type>(std::time(nullptr)) };
 
    std::shuffle(deck.begin(), deck.end(), mt);
}
 
// Возвращает true, если игрок хочет еще карту. В противном случае - false.
bool playerWantsHit()
{
    while (true)
    {
        // «еще» - hit (h), «достаточно» - stand (s)
        std::cout << "(h) to hit, or (s) to stand: ";
 
        char ch{};
        std::cin >> ch;
 
        switch (ch)
        {
        case 'h':
            return true;
        case 's':
            return false;
        }
    }
}
 
// Возвращает true, если у игрока «перебор». В противном случае - false.
bool playerTurn(const deck_type& deck, index_type& nextCardIndex, Player& player)
{
    while (true)
    {
        if (player.score > maximumScore)
        {
            // Это может произойти даже до того, как у игрока был выбор,
            // если он взял 2 туза.
            std::cout << "You busted!\n";
            return true;
        }
        else
        {
            if (playerWantsHit())
            {
                int cardValue { getCardValue(deck[nextCardIndex++]) };
                player.score += cardValue;
                std::cout << "You were dealt a " << cardValue 
                          << " and now have " << player.score << '\n';
            }
            else
            {
                // У игрока нет перебора
                return false;
            }
        }
    }
}
 
// Возвращает true, если у дилера «перебор». В противном случае - false.
bool dealerTurn(const deck_type& deck, index_type& nextCardIndex, Player& dealer)
{
    // Тянем карты, пока не достигнем минимального значения
    while (dealer.score < minimumDealerScore)
    {
        int cardValue{ getCardValue(deck[nextCardIndex++]) };
        dealer.score += cardValue;
        std::cout << "The dealer turned up a " << cardValue 
                  << " and now has " << dealer.score << '\n';
 
    }
 
    // Если счет дилера слишком высок, у него перебор
    if (dealer.score > maximumScore)
    {
        std::cout << "The dealer busted!\n";
        return true;
    }
    
    return false;
}
 
bool playBlackjack(const deck_type& deck)
{
    // Индекс карты, которая будет вытянута следующей.
    // Обойти массив невозможно, потому что игрок
    // проиграет до того, как будут использованы все карты.
    index_type nextCardIndex{ 0 };
 
    // Создаем дилера и даем ему 1 карту.
    Player dealer{ getCardValue(deck[nextCardIndex++]) };
 
    // Карта дилера открыта, игрок ее видит.
    std::cout << "The dealer is showing: " << dealer.score << '\n';
 
    // Создаем игрока и даем ему 2 карты.
    Player player{ getCardValue(deck[nextCardIndex]) + getCardValue(deck[nextCardIndex + 1]) };
    nextCardIndex += 2;
 
    std::cout << "You have: " << player.score << '\n';
 
    if (playerTurn(deck, nextCardIndex, player))
    {
        // У игрока перебор.
        return false;
    }
 
    if (dealerTurn(deck, nextCardIndex, dealer))
    {
        // У дилера перебор, игрок выигрывает.
        return true;
    }
 
    return (player.score > dealer.score);
}
 
int main()
{
    auto deck{ createDeck() };
 
    shuffleDeck(deck);
 
    if (playBlackjack(deck))
    {
        std::cout << "You win!\n";
    }
    else
    {
        std::cout << "You lose!\n";
    }
 
    return 0;
}

Генерация случайных чисел

Если вихрь Мерсенна будет нестатическим, он будет инициализироваться каждый раз при вызове shuffleDeck. Если shuffleDeck вызывается дважды за одну секунду, она даст точно такой же результат. Не инициализируйте генератор случайных чисел заново, если не хотите его сбросить.

void shuffleDeck(deck_type& deck)
{
  // неслучайный
  /* static */ std::mt19937 mt{ static_cast<std::mt19937::result_type>(std::time(nullptr)) }; 
  // случайный
  static std::mt19937 mt{ static_cast<std::mt19937::result_type>(std::time(nullptr)) }; 
 
  std::shuffle(deck.begin(), deck.end(), mt);
}

Магические числа

• Если ваш код содержит числа 10, 11, 17, 21 или 52 внутри тела функции, у вас есть магические числа, которые следует удалить.
• Если вы использовали 10 или 11, вероятно, вы не использовали getCardValue для получения значения карты. Кроме того, чтобы проверить, является ли карта тузом, проверяйте не ее значение, а ее ранг.
• Если вы использовали 17 или 21, они должны быть переменными constexpr, чтобы можно было быстро изменить конфигурацию игры и упростить чтение кода.
• Если вы использовали 52, вы должны использовать вместо него deck.size().

Один из способов – отслеживать, сколько тузов было сдано игроку и дилеру (в структуре Player как целое число). Если у игрока или дилера больше 21, а его счетчик тузов больше нуля, вы можете уменьшить его счет на 10 (преобразовать туз с 11 очков в 1) и «удалить» один туз из счетчика. Это можно делать сколько угодно раз, пока счетчик тузов не достигнет нуля.

playBlackjack() в настоящее время возвращает true, если выигрывает игрок, и false в противном случае. Нам нужно будет обновить эту функцию, чтобы она возвращала три возможных варианта: победа дилера, победа игрока, ничья. Лучший способ сделать это – определить перечисление для этих трех вариантов и заставить функцию возвращать соответствующий перечислитель:

enum class BlackjackResult
{
    player_win,
    dealer_win,
    tie
};
 
BlackjackResult playBlackjack(const deck_type& deck);