Small C++ 게임 도움말

Question

나는 터미널에서 돌아 다니는 솔리테어 게임을 쓰고 있습니다. 현재 프로그램은 컴파일되어 실행되며 플레이어에게 4 개의 열에 배치 된 4 개의 카드를 제공하고 더 많은 카드를 위해 0을 눌러 열에 추가됩니다. 기둥이 커짐에 따라 출력은 벡터 (실제로는 벡터의 벡터)에 배치되어야합니다.

이상적으로, 필요한 경우 카드를 더 수집 한 후 플레이어는 1-4의 숫자를 입력하여 다른 사람과 비교할 열을 선택하십시오. 그런 다음 해당 열의 최상위 카드를 다른 최상위 카드와 비교하여 삭제할 수 있는지 확인해야합니다. 이것은 내가 문제가되는 부분입니다. 우선, 벡터의 벡터에 정확하게 카드를 입력했는지, 그리고 서로를 어떻게 비교할 지 잘 모르겠다. 나는 다음과 같은 것을 사용하려고 시도했다.

column[2].back().getSuit() 두 번째 열의 최상위 카드의 수트에 액세스 한 다음 숫자 값을주고 다른 열의 수트와 비교한다. 나는 카드의 랭크를 비교하기 위해 비슷한 일을했지만 아무런 운이 없다.

누구든지 내 코드 또는 자신의 코드를 사용하여 보여줄 수 있습니까? 각 열에있는 최상위 카드의 수트와 순위를 올바르게 비교하려면 어떻게해야합니까?

#include <iostream> 
#include <algorithm> 
#include <vector> 
#include <cstdlib> 
#include <ctime> 

using namespace std; 

enum suits 
{ 
    diamond, club, heart, spade 
}; 

class Card 
{ 
private: 
    int rank; 
    suits suit; 
public: 
    Card(); 
    Card(suits, int); 
    int getRank() { return rank; } 
    suits getSuit() { return suit; } 
    void setRank(int rankvalue) { rank = rankvalue; } 
    void setSuit(suits suitvalue) { suit = suitvalue; } 
}; 

ostream & operator<<(ostream &, Card); 

Card::Card() 
{ 
    rank = 1; 
    suit = spade; 
} 

Card::Card(suits suitvalue, int rankvalue) 
{ 
    rank = rankvalue; 
    suit = suitvalue; 
} 

ostream & operator<<(ostream & out, Card aCard) 
{ 
    switch (int rank = aCard.getRank()) 
    { 
     case 14: out << "Ace"; break; 
     case 11: out << "Jack"; break; 
     case 12: out << "Queen"; break; 
     case 13: out << "King"; break; 
     default: out << rank; 
    } 

    switch (suits suit = aCard.getSuit()) 
    { 
     case diamond: out << " of Diamonds"; break; 
     case spade: out << " of Spades"; break; 
     case heart: out << " of Hearts"; break; 
     case club: out << " of Clubs"; break; 
    } 

    return out; 
} 

class RandomInteger 
{ 
public: 
    RandomInteger(); 
    unsigned int operator() (unsigned int max); 
}; 

RandomInteger::RandomInteger() 
{ 
    srand(time(0)); 
} 

unsigned int RandomInteger::operator()(unsigned int max) 

{ 
    unsigned int rval = rand(); 
    return rval % max; 
} 

RandomInteger randomizer; 

class Deck 
{ 
    Card cards[52]; 
    int topCard; 
public: 
    Deck(); 
    void shuffle(); 
    bool isEmpty() { return topCard <= 0; } 
    Card draw(); 
}; 

extern RandomInteger randomizer; 

Deck::Deck() 
{ 
    topCard = 0; 
    for (int i = 1; i <= 13; i++) 
    { 
     Card c1(diamond, i), c2(spade, i), c3(heart, i), c4(club, i); 
     cards[topCard++] = c1; 
     cards[topCard++] = c2; 
     cards[topCard++] = c3; 
     cards[topCard++] = c4; 
    } 
} 

Card Deck::draw() 
{ 
    if (!isEmpty()) 
     return cards[--topCard]; 
    else 
    { 
     Card spadeAce(spade, 1); 
     return spadeAce; 
    } 
} 

void Deck::shuffle() 
{ 
    random_shuffle(cards, cards+52, randomizer); 
} 

class Player 
{ 
public: 
    Player(); 
    void print(); 
    Card draw(Deck &); 
    typedef vector<Card> cards; 
    vector<cards> column; 
}; 

//ostream & operator<<(ostream &, Player&); 

Player::Player() 
{ 
    column.push_back(vector<Card>()); 
    column.push_back(vector<Card>()); 
    column.push_back(vector<Card>()); 
    column.push_back(vector<Card>()); 
} 

Card Player::draw(Deck & aDeck) 
{ 
    for (int i = 0; i < 4; i++) 
     column[i].push_back(aDeck.draw()); 
} 

void Player::print() 
{ 
    cout << "Col 1 \t\t Col 2 \t\t Col 3 \t\t Col 4 \n"; 
    bool more = true; 
    for (int j = 0; more; j++) 
    { 
     more = false; 
     for (int i = 0; i < 4; i++) 
      if (j < column[i].size()) 
     { 
     cout << column[i][j] << "\t"; 
     more = true; 
     } 
      else 
      cout << "\t\t"; 
    cout << endl; 
    } 
} 

int main() 
{ 
    Deck deck; 
    deck.shuffle(); 

    Player player; 
    player.draw(deck); 
    //while (!deck.isEmpty()) 
    //{ 
    cout << "Enter a column number (0 to draw four new cards): " << endl; 
    //} 
    player.print(); 

    int input; 
    int i; 
    vector<vector<Card> > columns(4); 
    while (cin >> input) 
    if (input == 0) 
    { 
     player.draw(deck); 
     player.print(); 
     columns.push_back(vector<Card>()); 
     columns.push_back(vector<Card>()); 
    columns.push_back(vector<Card>()); 
     columns.push_back(vector<Card>()); 
    } 
     else while (cin >> input) 
      if (input == 1) 
      { 
      for (i = 0; i > 4; i++) 
       { 
         columns.push_back(vector<Card>()); 
      } 
      for (i = 0; i > 4; i++) 
        { 
        columns[0].back().getSuit(); 
       columns[1].back().getSuit(); 
       columns[2].back().getSuit(); 
       columns[3].back().getSuit(); 
      } 

      } 



} 

모든 제안은, 포인터, 팁, 중대하다, 감사 :

여기에 지금까지 내 코드입니다.

Answer 1

비교를 위해 수트를 숫자 값으로 변환 할 필요가 없습니다. 열거 형을 직접 비교할 수 있습니다. Card들에 대한 비교 연산자를 추가

시도 : 이제 당신이해야

int getRank() const { return rank; } 
suits getSuit() const { return suit; } 

이 들어

bool operator==(const Card& a, const Card& b) { 
    return a.getRank() == b.getRank() && a.getSuit() == b.getSuit(); 
} 

당신은 const와 getRank 및 getSuit 방법을 표시해야합니다, 작업 두 열의 "상단"에있는 카드를 포함하여 두 카드를 간단히 비교할 수 있습니다. 예를 들어 벡터가 비어있는 경우

if (columns[1].back() == columns[2].back()) { ... } 

주 back 것을이 작동하지 않습니다. 내가 몇 가지를 제안 생각 때문에

Answer 2

HIA, 당신은 제안 요청

내가 열거 유형을 유지하려면 우선 그냥 경우에, 함께 문자열을 반환하는 기능 내가 열거 형에 추가 이상 (admitadly이 경우 가능성)

class suits{ 
public: 
    enum type{ 
    diamond, club, heart, spade, 
    }; 

    static 
    std::string get_string(const type& t) 
    { 
    switch (t) { 
    case diamond: return"Diamonds"; 
    case spade: return"Spades"; 
    case heart: return"Hearts"; 
    case club: return"Clubs"; 
    } 
    throw("invalid suit"); //this is a bit ugly - but you get the idea 
    } 
}; 

는 그런 다음, suits::spade에 suits::get_string(suits::spade) 등 조금 명확하게 할 수있는을 참조하십시오.

내가 다음 양복과 자신의 클래스에서 수있을 것입니다, 당신은 여기에 비교를 할 수있는 그런 다음

CardSuit club(suits::club); 
    CardSuit spade(suits::spade); 

    if (club<spade) 
    std::cout<<"true"<<std::endl; 
    else 
    std::cout<<"false"<<std::endl; 

true를 반환

class CardSuit 
{ 
private: 
    suits::type m_suit; 
protected: 
    std::string get_string() const {return suits::get_string(m_suit);} 
public: 
    CardSuit(const suits::type& t) : m_suit(t) {} 
    void setSuit(const suits::type& t) { m_suit = t;} 
    const suits::type& getSuit() const {return m_suit;} 
    bool operator<(CardSuit cs) 
    { 
    return m_suit<cs.getSuit(); //You must have the enum in the suit order 
    } 
}; 

을

그런 다음 수 다음과 같이 CardSuit 클래스에서 상속합니다.

class Card : public CardSuit 
{ 
private: 
    int rank; 
public: 
    Card(); 
    Card(suits::type, int); 
    int getRank() { return rank; } 
    void setRank(int rankvalue) { rank = rankvalue; } 
    std::string get_suit() const {return CardSuit::get_string();} 

bool operator<(const Card& c) 
    { 
    if (CardSuit::operator<(c)) 
     return true; 
    if (rank<c.getRank()) 
     return true; 
    else return false; 
    } 
}; 

Card c1(suits::club, 4); 
    Card c2(suits::club, 5); 
    Card c3(suits::diamond, 5); 

    if (c2<c1) 
    std::cout<<"true"<<std::endl; 
    else 
    std::cout<<"false"<<std::endl; 

    if (c3<c1) 
    std::cout<<"true"<<std::endl; 
    else 
    std::cout<<"false"<<std::endl; 

반환 거짓과 진실은 각각

마지막 utstream 연산자 (

ostream & operator<<(ostream & out, Card aCard) 
{ 
    switch (int rank = aCard.getRank()) 
    { 
    case 14: out << "Ace"; break; 
    case 11: out << "Jack"; break; 
    case 12: out << "Queen"; break; 
    case 13: out << "King"; break; 
    default: out << rank; 
    } 

    out << " of "<< aCard.get_suit(); 

    return out; 
} 

같은 것을 나는 또한 CardSuit 클래스와 유사한 순위 클래스를 만들 것 - 그래서하는 케이스가 더 조밀하다).