c＃在构造函数中设置的Struct Array


c# Struct Array set in Constructor

我有一个小结构-

1
2
3
4
struct Card {
        public string suit;
        public string value;
}

然后我用它初始化一组卡片

1
Card[] deck = new Card[52];

在我的主()中，我调用

1
Deck myDeck = new Deck();

与构造函数相关的

1
2
3
4
5
6
7
8
9
10
11
12
13
public Deck() {        
            int cardNum = 0;
            for (int i = 0; i < numSuits; i++) {
                for (int a = 0; a < numValues; a++) {
                    deck[cardNum].suit = suits[i];
                    deck[cardNum].value = values[a];
                    Console.WriteLine("The card at position" + (cardNum + 1) +" is the" + deck[cardNum].value +" of" + deck[cardNum].suit);
                    cardNum++;

                }
            }

        }

…因此，创建一个包含52张卡片的卡片组，正如我的console.writeline()所确认的那样，正确填充卡片组。

我的问题是我还有另外两个方法，public void shuffle()和public string deal()，正如他们的名字所暗示的，它们分别洗牌和处理顶牌，但是我不知道如何将deck.suit和deck.value值传递到这些方法中。

我尝试在构造函数内初始化card[]数组。所有这些函数都在同一名称空间和类下。

我还希望在代码中保留构造函数和两个方法，并且不使用任何其他方法，尽管我确信还有许多其他的、可能更简单的方法可以做到这一点。

事先谢谢！

相关讨论

玩这个：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
void Main()
{
    var deck = new Deck();
    deck.Shuffle();
    var cards = deck.Deal(1);
    foreach (var card in cards)
    {
        Console.WriteLine($"{card.Value} of {card.Suit}");
    }
}

public struct Card
{
    public Card(string suit, string value)
    {
        this.Suit = suit;
        this.Value = value;
    }
    public readonly string Suit;
    public readonly string Value;
}

public class Deck
{
    private const int _numSuits = 4;
    private const int _numValues = 13;

    private string[] _suits = new [] {"Clubs","Diamonds","Hearts","Spades", };
    private string[] _values = new []
    {
       "Ace","2","3","4","5","6","7","8","9","10","Jack","Queen","King",
    };

    private Card[] _deck = new Card[52];

    public Deck()
    {
        _deck =
            _suits
                .SelectMany(s => _values, (s, v) => new Card(s, v))
                .ToArray();
    }

    private Random _random = new Random();
    public void Shuffle()
    {
        _deck = _deck.OrderBy(_ => _random.Next()).ToArray();
    }

    public Card[] Deal(int take)
    {
        var cards = _deck.Take(take).ToArray();
        _deck = _deck.Skip(take).ToArray();
        return cards;
    }
}
相关讨论

不幸的是，我还不能评论：

1
2
3
Random rnd=new Random();
Card[] randomOrder = deck.OrderBy(x => rnd.Next()).ToArray();    
//TODO: you could iterate over the random order and fill your Stack

它会随机地改变你的阵列。交易应该很简单，你可以选择一个随机的数组索引并返回卡片。如果该卡在发完后应该被删除，或者使用列表或者更好的方法，当你洗牌时，你可以填充创建一个StackT>并填充它，那么每次你调用Deal函数时，你就可以将下一张卡删除。

@神秘性打败了我，他的解决方案允许一次拿多张牌。问题是，如何更好地使用堆栈并慢慢清空它，或者使用.Take和新数组？-

相关讨论

卡片有点通用。它们不仅用于甲板。它们也在手上使用。有些游戏甚至在另一个我不知道名字的结构中也有开放的牌(对不起，我只知道来自星际迷航TNG的扑克)。

根据个人经验，我知道很难为"手"或"甲板"安排一个合适的班级。最后，两个似乎都比一张卡片的容器多一点。所以使用卡片可能更好/更容易。还有一堆静态函数，它们初始化一整副卡片，洗牌，从一副卡片中抽出，并把一张卡片作为参数或返回卡片实例之一。请记住，数组本身是通过引用来传递的，在这里它确实有帮助。

至于抽随机牌的行为，我个人称之为"抽奖问题"。我编写了这个示例代码来处理它：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//Create an array. Fill it with Sequential Numbers.
int[] input = new int[20];

for(int i = 0; i < numbers.lenght; i++)
  input[i] = i;

/*Initialise the instances you will need*/
//Use the array to create a list
List<int> DrawableNumbers = new List<int>(input);
List<int> DrawnNumbers = new List<int>();

//Generate a Random Number Generator
Random rng = new Random();

/*Draw 6 from the group*/
while(DrawnNumbers.Count < 6){
  //Get a random Index to move from DrawableNumbers to DrawnNumbers
  int temp = Random.NextInt(DrawableNumbers.Count);
  DrawnNumbers.Add(DrawableNumbers[i]);
  DrawableNumbers.Remove(temp);
}

洗牌的唯一区别是，在牌用完之前，你不会停下来。

相关讨论