Член вектора всегда имеет нулевой размер при вызове функции-члена, которая использует push_back для добавления к члену вектора - PullRequest
Новая
       2

Член вектора всегда имеет нулевой размер при вызове функции-члена, которая использует push_back для добавления к члену вектора

0 голосов
/ 03 ноября 2019

Я пытаюсь добавить карты к вектору, который должен быть рукой Блэкджека, но каждый раз, когда я вхожу в функцию, которая использует push_back для добавления карты в вектор, вектор начинается пустым. Проблема в моем классе Hand в функции addCardToHand, и та же проблема присутствует в том же классе в моей функции showHand. Я сократил код настолько, насколько мог, но все еще представляю полную рабочую версию с проблемой. Я не могу понять, почему мой класс Hand рассматривает руку как совершенно новую каждый раз, когда я вызываю функцию в классе. Пожалуйста, сообщите. 

// Card.h
#ifndef CARD_H
#define CARD_H

#include <string>
#include <array>

class Card {
   private:
      int rank;
      int suit;
      int hardValue;
      int softValue;
      static const std::array<std::string,14> ranks;
      static const std::array<std::string,5> suits;
   public:
      Card();
      Card(int rank, int suit);
      int getHardValue() const;
      int getSoftValue() const;
      std::string toString() const;
};
#endif

// Card.cpp
#include "Card.h"

const std::array<std::string,14> Card::ranks {"","A","2","3","4","5","6","7","8","9","10","J","Q","K"};
const std::array<std::string,5> Card::suits {"","C","D","H","S"};

Card::Card() : rank(0), suit(0) {
   hardValue = 0;
   softValue = 0;
}

Card::Card(int rank, int suit) : rank(rank), suit(suit) {
   if (rank == 1) {
      hardValue = 1;
      softValue = 11;
   }
   else if (rank <= 10) {
      hardValue = rank;
      softValue = rank;
   }
   else {
      hardValue = 10;
      softValue = 10;
   }
}

int Card::getHardValue() const {
   return hardValue;
}

int Card::getSoftValue() const {
   return softValue;
}

std::string Card::toString() const {
   return ranks[rank] + suits[suit];
}

// Shoe.h
#ifndef SHOE_H
#define SHOE_H

#include <vector>
#include <random>
#include "Card.h"

class Shoe {
   private:
      int numDecksInShoe;
      std::vector<Card> shoe;
      static int currentCard;
      static int maxDealCard;
      static const unsigned long int seed;
      static std::mt19937 randEng;
      void renewShoe();
   public:
      Shoe();
      explicit Shoe(int numDecksInShoe);
      std::vector<Card> getShoe() const;
      int getCurrentCard() const;
      int getMaxDealCard() const;
      void shuffle();
      Card dealCard();
};
#endif

// Shoe.cpp
#include <ctime>
#include "Shoe.h"

const unsigned long int Shoe::seed = static_cast<unsigned long int>(std::time(nullptr));
std::mt19937 Shoe::randEng(seed);
int Shoe::currentCard = 0;
int Shoe::maxDealCard = 51;

Shoe::Shoe() {
}

Shoe::Shoe(int decksInShoe) {
   numDecksInShoe = decksInShoe;
   int count = 0;

   for (int i = 0; i < numDecksInShoe; i++) {
      for (int suit = 4; suit >= 1; suit--) {
         for (int rank = 1; rank <= 13; rank++) {
            Card card(rank,suit);
            shoe.push_back(card);
            count += 1;
         }
      }
   }

   currentCard = 0;
   maxDealCard = count - 1;
}

std::vector<Card> Shoe::getShoe() const {
   return shoe;
}

int Shoe::getCurrentCard() const {
   return currentCard;
}

int Shoe::getMaxDealCard() const {
   return maxDealCard;
}

void Shoe::shuffle() {
   Card temp;
   std::uniform_int_distribution<int> deckDist(0,numDecksInShoe*52-1);
   int index;

   for (int i = 0; i < numDecksInShoe*52; i++) {
      do {
         index = deckDist(randEng);
      } while (index == i);

      temp = shoe[index];
      shoe[index] = shoe[i];
      shoe[i] = temp;
   }

   std::uniform_int_distribution<int> maxDeal(10,41);
   int tempMax = (numDecksInShoe-1)*52 - 1;
   maxDealCard = tempMax + 51 - maxDeal(randEng);
}

Card Shoe::dealCard() {
   if (currentCard == maxDealCard) {
      renewShoe();
   }
   Card dealCard = shoe[currentCard];
   currentCard += 1;
   return dealCard;
}

void Shoe::renewShoe() {
   Shoe newShoe(numDecksInShoe);
   shoe = newShoe.getShoe();
   shuffle();
}

вот мой класс Hand 

// Hand.h
#ifndef HAND_H
#define HAND_H

#include <vector>
#include <string>
#include "Card.h"

class Hand {
   private:
      std::vector<Card> hand;
   public:
      Hand();
      std::vector<Card> getHand() const;
      void addCardToHand(Card card);
      void clearHand();
      Card revealBottomCard();
      std::string showHand() const;
      std::string peakHand() const;
};
#endif

// Hand.cpp
#include <iostream>
#include "Hand.h"

Hand::Hand() {
}

std::vector<Card> Hand::getHand() const {
   return hand;
}

void Hand::addCardToHand(Card card) {
   std::cout << card.toString() << std::endl;
   hand.push_back(card);
}

void Hand::clearHand() {
   hand.clear();
}

std::string Hand::showHand() const {
   std::string returnString = "";
   for (int i = hand.size()-1; i >= 1; i--) {
      returnString += hand[i].toString() + "\n";
   }
   returnString += "XX\n";

   return returnString;
}

std::string Hand::peakHand() const {
   std::string returnString = "";
   for (int i = hand.size()-1; i >= 0; i--) {
      returnString += hand[i].toString() + "\n";
   }
   return returnString;
}

вот класс Table, в котором есть код, который вызывает функции класса Hand 

// Table.h
#ifndef TABLE_H
#define TABLE_H

#include "Shoe.h"
#include "Player.h"

class Table {
   private:
      Shoe shoe;
   public:
      explicit Table(Shoe shoe);
      Shoe getShoe() const;
      void clearHand(std::vector<Player> players);
      void dealHand(std::vector<Player> players);
};
#endif

// Table.cpp
#include <iostream>
#include "Table.h"

Table::Table(Shoe shoe) : shoe(shoe) {
}

Shoe Table::getShoe() const {
   return shoe;
}

void Table::clearHand(std::vector<Player> players) {
   for (Player &player : players) {
      player.getHand().clearHand();
   }
}

void Table::dealHand(std::vector<Player> players) {
   for (int i = 0; i <= 1; i++) {
      for (Player &player : players) {
         player.getHand().addCardToHand(shoe.dealCard());
      }
   }
}

// Player.h
#ifndef PLAYER_H
#define PLAYER_H

#include "Hand.h"

class Player {
   private:
      std::string name;
      Hand hand;
      double money;
   public:
      explicit Player(std::string name, double money = 1000.0);
      std::string getName() const;
      Hand getHand() const;
      double getMoney() const;
};
#endif

// Player.cpp
#include "Player.h"

Player::Player(std::string name, double money) : name(name), money(money) {
}

std::string Player::getName() const {
   return name;
}

Hand Player::getHand() const {
   return hand;
}

double Player::getMoney() const {
   return money;
}

и, наконец, вот короткий драйвер, который запускает и отображает проблему 

// blackjack testing
#include <iostream>
#include "Player.h"
#include "Table.h"

int main() {
   std::vector<Player> players {Player("Tom",1500.0),Player("Sue"),Player("Dave")};

   Shoe shoe1(6);
   Table table1(shoe1);

   table1.dealHand(players);

   for (Player player : players) {
      std::cout << player.getName() << "'s hand\n";
      std::cout << player.getHand().showHand() << "\n\n";
   }
}

Вывод ниже. Я распечатал карты, которые были добавлены к вектору рук (а затем «забыты») и ниже, чем над XX, если все будет работать правильно, вы должны увидеть 4, 5 и 6 пик, поскольку я не перемешал колоду,ХХ должны симулировать нижнюю карту лицом вниз. 

AS
2S
3S
4S
5S
6S
Tom's hand
XX


Sue's hand
XX


Dave's hand
XX

Извините, что выложил сюда весь этот код, но я хотел предоставить полное рабочее решение, и это настолько мало, насколько я мог его получить. Спасибо за любую помощь.

Ответы [ 2 ]

1 голос
/ 03 ноября 2019 
player.getHand().addCardToHand(...);

player.getHand() возвращает временный Hand объект, который является копией player.hand. Затем вы добавляете карту к этому временному объекту. Затем этот временный объект умирает, добавляется карта и все. player.hand остается без изменений. Эта строка кода представляет собой сложную неработоспособность.

0 голосов
/ 03 ноября 2019

Чтобы добавить ответ @ Игоря, лучший способ исправить это, вероятно, вместо этого вернуть ссылку: 

const Hand& Player::getHand() const {
   return hand;
}

Я сделал это const, потому что возврат неконстантного мог (потенциально) разрешитьвам сломать const ness постоянного Player объекта. Это просто приглашение к потенциальным ошибкам.

Из-за этого вы можете также захотеть добавить неконстантную версию: 

Hand& Player::getHand() {
   return hand;
}

Теперь вы не можете изменять объект const Player, но измените его должным образом, когда вам нужно.

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.

Нет похожих вопросов

...