C++纸牌游戏，运动带班

Question

我写了一个小的代码来获得一些C++ exerice ...

代码工作...但它有一个小问题...如果你想解决的问题继续阅读，如果你不想评论编程风格，我需要它来提高自己。

游戏被称为“在camisa压力”， 是我在意大利的区域纸牌游戏...

游戏是一个非常简单的运气的游戏，我打它，当我是4 ...规则很简单：

分布所有52张法国甲板两个玩家之间，

每个球员在一排丢弃在桌子中央的手顶部的卡，

如果一张卡少于三张，则为

其他球员必须给的卡报卡上的号码对应的号码......

如果其他球员扔在一排卡，无需卡小于3，其他球员获取桌子中央的所有牌。

失去了谁手中没有任何卡。

例

“冷杉转”

 player 1: 
     King of Spades 
     player 2: 
     Queen of Clubs 
     player 1: 
     3 of Diamond (>now player2 has to discard 3 cards) 
     player 2: 
     Jack of Hearts 
     8 of Clubs 
     6 of Diamond 

播放器1韩元，采取：

 King of Spades 
     Queen of Clubs 
     3 of Diamond 
     Jack of Hearts 
     8 of Clubs 
     6 of Diamond 

“第二转”

 player 2: 
     2 of Clubs (> player 1 has to throw 2 cards) 
     player 1: 
     King of Clubs (> 1st card) 
     2 of Diamond (> 2nd card is less then 3 so player 2 has to throw 2 card) 
     player 2: 
     5 of Hearts (> 1st card) 
     Jack of Diamond (> 2nd card) 

播放一个whon再次，和需要：

 2 of Clubs 
     King of Clubs 
     2 of Diamond 
     5 of Hearts 
     Jack of Diamond 

要 我定义的函数来检查，如果卡被抛出的代码是< 3，并使对方球员扔卡这样相应的数字：

 void check(Card card, Hand &g1, Hand &g2, Hand &Deck_c){ 

    cout << endl; 
    int a = card.get_number(); 
    if (card.get_number() <= 3) { 
     cout << g2.get_name() << " discard: " << endl; 
     while (a > 0) { 

      if (g2.void_hand()) { 
       return; 
      } 
      Card discarded_card = g2.discard(0); 
      cout << " "; 
      cout << discarded_card; 
      Deck_c.append_card(discarded_card); 
      check(discarded_card, g2,g1, Deck_c); 
      a--; 
     } 
     int size_Deck_c = Deck_c.size_cards(); 
     for (int i = 0; i < size_Deck_c; i++) { 
      g1.feed_from_back(Deck_c.discard(0)); 
     } 
     return; 

    } 

    return; 
} 

它

Giovanni discard: 
2 of Heart 
Pietro discard: 
    8 of Clubs 
    7 of Heart 

，但现在的问题是：如果在玩的少只有一个网卡，然后3工作正常

Pietro discard: 
3 of Heart 
Giovanni discard: 
    2 of Spades 
Pietro discard: 
    Queen of Spades 
    5 of Spades (>should pass the turn but continue to throw cards) 
    5 of Diamond 
    9 of Diamond 

彼得应该抛弃2卡，然后通过转....

功能是递归函数，其中检查是否卡是小于3每卡被抛出

如果它超过3它回到正常的游戏，

否则它再次调用切换球员的功能......

的问题是在迭代器“诠释了” ......

这是源代码，如果你想看看：

#include <iostream> 
#include <string> 
#include <vector> 
#include <stdlib.h> 

using namespace std; 



int array_numbers[] = {1,2,3,4,5,6,7,8,9,10,11,12,13}; 
string array_suit[] = {"Heart","Clubs","Spades","Diamond"}; 

class Card{ 
private: 
    int Number; 
    string Suit; 
public: 
    Card(); 
    Card(int,string); 
    int get_number(); 
    string get_suit(); 
    void assign_values(int,string); 
    friend ostream &operator<<(ostream&, const Card&); 
}; 

Card::Card(){ 
    Number = 0; 
    Suit = "void"; 
} 
Card::Card(int number, string suit){ 
    Number = number; 
    Suit = suit; 
} 

int Card::get_number(){ 
    return Number; 
} 

string Card::get_suit(){ 
    return Suit; 
} 

void Card::assign_values(int i, string suit){ 
    Number = i; 
    Suit = suit; 
} 

ostream &operator<<(ostream& os, const Card& card){ 
    if (card.Number == 1) { 
     os << "Ace of " << card.Suit; 
    } 
    else if(card.Number == 11){ 
     os << "Jack of " << card.Suit; 
    } 
    else if(card.Number == 12){ 
     os << "Queen of " << card.Suit; 
    } 
    else if(card.Number == 13){ 
     os << "King of " << card.Suit; 
    } 
    else{ 
     os << card.Number << " of " << card.Suit; 
    } 
    return os; 
} 

class Deck { 
private: 
    int x; 
    Card cards[52]; 
public: 
    Deck(); 
    void print_card(int); 
    void print_Deck(); 
    void shuffle(); 
    Card get_card(int); 

}; 

Deck::Deck(){ 
    for (int n = 0; n < 13; n++) { 
     for (int seme = 0; seme < 4; seme++) { 
      cards[n*4+seme].assign_values(array_numbers[n], array_suit[seme]); 
     } 
    } 
} 

void Deck::print_card(int i){ 
    cout << cards[i]; 
} 

void Deck::print_Deck(){ 
    for (int i = 0; i<52; i++) { 
     for (int a = 0; a < i; a++) { 
      cout << " "; 
     }  
     print_card(i); 
     cout << endl; 
    } 
} 
void Deck::shuffle(){ 
    srand (time(NULL)); 
    for (int i = 0; i<500; i++) { 
     int x = rand()%51; 
     int y = rand()%51; 
     Card cpy; 
     cpy.assign_values(cards[x].get_number(),cards[x].get_suit()); 
     cards[x] = cards[y]; 
     cards[y] = cpy; 
    } 
} 

Card Deck::get_card(int i){ 
    return cards[i]; 
} 

class Hand { 
private: 
    vector <Card> cards; 
    string name; 
public: 
    Hand(); 
    Hand(string); 
    string get_name(); 
    void append_card(Card); 
    void print_hand(); 
    Card discard(int); 
    bool operator==(Hand); 
    bool void_hand(); 
    void feed_from_back(Card); 
    int size_cards(); 
}; 

int Hand::size_cards(){ 
    return cards.size(); 
} 

void Hand::append_card(Card card){ 
    cards.insert(cards.begin(),card); 

} 

Hand::Hand(){ 
    name = "void"; 
} 

Hand::Hand(string x){ 
    name = x; 
} 

string Hand::get_name(){ 
    return name; 
} 

void Hand::print_hand(){ 
    int a= 0; 
    vector <Card> ::iterator i; 
    for (i = cards.begin(); i != cards.end(); i++) { 
     a++; 
     for (int c = 0; c < a; c++) { 
      cout << " "; 
     } 
     cout << *i << endl; 
    } 
} 



Card Hand::discard(int a){ 
    Card c_return; 
    vector <Card>::iterator i; 
    i = cards.begin(); 
    for (int f = 0; f < a; f++) { 
     i++; 
    } 
    c_return = *i; 
    cards.erase(i); 
    return c_return; 
} 


bool Hand::operator==(Hand other_hand){ 
    if (name == other_hand.get_name()) { 
     return 1; 
    } 
    else { 
     return 0; 
    } 
} 

bool Hand::void_hand(){ 
    if (cards.size()== 0) { 
     return 1; 
    } 
    else { 
     return 0; 
    } 
} 

void Hand::feed_from_back(Card x){ 
    cards.insert(cards.end(),x); 
} 



void check(Card card, Hand &g1, Hand &g2, Hand &Deck_c){ 

    cout << endl; 
    int a = card.get_number(); 
    if (card.get_number() <= 3) { 
     cout << g2.get_name() << " discard: " << endl; 
     while (a > 0) { 

      if (g2.void_hand()) { 
       return; 
      } 
      Card discarded_card = g2.discard(0); 
      cout << " "; 
      cout << discarded_card; 
      Deck_c.append_card(discarded_card); 
      check(discarded_card, g2,g1, Deck_c); 
      a--; 
     } 
     int size_Deck_c = Deck_c.size_cards(); 
     for (int i = 0; i < size_Deck_c; i++) { 
      g1.feed_from_back(Deck_c.discard(0)); 
     } 
     return; 

    } 

    return; 
} 


void turn(Hand &g1, Hand &g2, Hand &Deck_c){ 
    if (g1.void_hand()) { 
     return; 
    } 
    Card discarded_card = g1.discard(0); 
    cout << g1.get_name() << " discard:" << endl << " "; 
    cout << discarded_card; 
    Deck_c.append_card(discarded_card); 
    check(discarded_card, g1, g2, Deck_c); 
    turn(g2,g1,Deck_c); 

} 

int main (int argc, char * const argv[]) { 
    // inizializzo il mazzo 
    Deck Deck1; 
    Deck1.shuffle(); 


    Hand hand1("Giovanni"); 
    Hand hand2("Pietro"); 
    Hand central_deck; 

    // inizializzo le mani 
    for (int i = 0; i < 52/2; i++) { 
     hand1.append_card(Deck1.get_card(i)); 
    } 
    for (int i = 52/2; i < 52; i++) { 
     hand2.append_card(Deck1.get_card(i)); 
    } 

    turn(hand1, hand2, central_deck); 
    //turn(mano1, mano2, mazzo_centrale); 
    cout << "mazzo" << endl; 
    central_deck.print_hand(); 

    cout << "mano 1" << endl; 
    hand1.print_hand(); 
    cout << "mano 2" << endl; 
    hand2.print_hand(); 




    std::cout << "Hello, World!\n"; 
    return 0; 
} 

Answer 1

这是一个良好的开端到C++的职业生涯。这些类都经过深思熟虑，算法很简单。我唯一的风格批评是你的成员有一个不一致的命名约定。变量通常有一个小写的第一个字母。有那么多不同风格的休息即骆驼套管，M_前缀，等等...

我会改变：

class Card{ 
private: 
    int Number; 
    string Suit; 
public: 
    Card(); 
    Card(int,string); 
    int get_number(); 
    string get_suit(); 
    void assign_values(int,string); 
    friend ostream &operator<<(ostream&, const Card&); 
}; 

要

class Card{ 
private: 
    int number; 
    string suit; 
public: 
    Card(); 
    Card(int,string); 
    int get_number(); 
    string get_suit(); 
    void assign_values(int,string); 
    friend ostream &operator<<(ostream&, const Card&); 
}; 

我看到你这样做在别人身上，所以只要一致。无论如何，这是一些写得很好的代码。另外，如果我打算使用多个文件，我通常会避免使用像瘟疫这样的指令。