初始化自定义类中的数组

你可能会发现这会拉伸你，但是如果可以用算法术语来描述填充数组或向量，我可能会这样做。

在这种情况下，我使用 constexpr 来生成数组，因为std::array支持constexpr构造。如果您决定使用向量，类似的方法将起作用，但您需要删除constexpr。

#include <array>
#include <iostream>
#include <utility>
#include <random>
#include <algorithm>
struct Card
{
    enum Suit_Type
    {
        Diamonds,
        Hearts,
        Spades,
        Clubs,
    } suit;
    friend std::ostream& operator<<(std::ostream& os, Suit_Type s) {
        switch (s) {
            case Card::Diamonds: return os << "Diamonds";
            case Card::Hearts: return os << "Hearts";
            case Card::Spades: return os << "Spades";
            case Card::Clubs: return os << "Clubs";
        }
    }
    enum Value_Type
    {
        Two = 2,
        Three = 3,
        Four = 4,
        Five = 5,
        Six = 6,
        Seven = 7,
        Eight = 8,
        Nine = 9,
        Ten = 10,
        Jack = 11,
        Queen = 12,
        King = 13,
        Ace = 14
    } value;
    friend std::ostream& operator<<(std::ostream& os, Value_Type s) {
        switch (s) {
            case Card::Two: return os << "Two";
            case Card::Three: return os << "Three";
            case Card::Four: return os << "Four";
            case Card::Five: return os << "Five";
            case Card::Six: return os << "Six";
            case Card::Seven: return os << "Seven";
            case Card::Eight: return os << "Eight";
            case Card::Nine: return os << "Nine";
            case Card::Ten: return os << "Ten";
            case Card::Jack: return os << "Jack";
            case Card::Queen: return os << "Queen";
            case Card::King: return os << "King";
            case Card::Ace: return os << "Ace";
        }
    }
    void printCard();
};
void Card::printCard() {
    std::cout << value << " of " << suit;
}
constexpr Card card_from_index(int index) {
    return {
        static_cast<Card::Suit_Type>(index / 13),
        static_cast<Card::Value_Type>((index % 13) + 2)
    };
}
class DeckOfCards
{
public:
    DeckOfCards();
    void printDeck();
    template<class Engine>
    void shuffle(Engine&& eng) {
        std::shuffle(std::begin(cards_), std::end(cards_),
                     std::forward<Engine>(eng));
    }
private:
    static constexpr int nof_cards = 52;
    using deck_store = std::array<Card, nof_cards>;
    template<int...Is>
    constexpr static deck_store generate_deck(std::integer_sequence<int, Is...>)
    {
        deck_store result{ card_from_index(Is)... };
        return result;
    }
private:
    deck_store cards_;
};

DeckOfCards::DeckOfCards()
: cards_ (generate_deck(std::make_integer_sequence<int, nof_cards>()))
{}

void DeckOfCards::printDeck()
{
    bool first = true;
    for (auto card : cards_)
    {
        if (!first)
        {
            std::cout << ", ";
        }
        card.printCard();
        first = false;
    }
    std::cout << "n";
}
int main()
{
    DeckOfCards deck;
    deck.printDeck();
    deck.shuffle(std::default_random_engine { std::random_device {} ()});
    std::cout << "nafter shuffling:nn";
    deck.printDeck();
}