Инициализация массива в пользовательском классе

Question

Инициализация массива в пользовательском классе

Я получаю ошибку too many initializers в моем deckofcardsclass.cpp файл класса. Я видел несколько сообщений об этом, но они не имеют прямого отношения, и то, с чем я сталкиваюсь, немного сложнее, так как я заполняю массив экземплярами другого класса. Это просто синтаксическая ошибка? Или моя логика в инициализации неверна?

Чтобы быть понятным: ошибка происходит в файле реализации при инициализации массива cards_

Заголовок класса

#pragma once
#ifndef DECKOFCARDS_H_
#define DECKOFCARDS_H_

#include <array>
#include "Card.h"
class DeckOfCards
{

public:
DeckOfCards();
void printDeck();private:
std::array<Card, 52> cards_;

};#endif // !1

Реализация класса

#include "stdafx.h"#include <iostream>
#include "DeckOfCards.h"#include "Card.h"#include <array>DeckOfCards::DeckOfCards()
:
cards_
{
{ Card::Diamonds, Card::Two },
{ Card::Diamonds, Card::Three },
{ Card::Diamonds, Card::Four },
{ Card::Diamonds, Card::Five },
{ Card::Diamonds, Card::Six },
{ Card::Diamonds, Card::Seven },
{ Card::Diamonds, Card::Eight },
{ Card::Diamonds, Card::Nine },
{ Card::Diamonds, Card::Ten },
{ Card::Diamonds, Card::Jack },
{ Card::Diamonds, Card::Queen },
{ Card::Diamonds, Card::King },
{ Card::Diamonds, Card::Ace },
{ Card::Hearts, Card::Two },
{ Card::Hearts, Card::Three },
{ Card::Hearts, Card::Four },
{ Card::Hearts, Card::Five },
{ Card::Hearts, Card::Six },
{ Card::Hearts, Card::Seven },
{ Card::Hearts, Card::Eight },
{ Card::Hearts, Card::Nine },
{ Card::Hearts, Card::Ten },
{ Card::Hearts, Card::Jack },
{ Card::Hearts, Card::Queen },
{ Card::Hearts, Card::King },
{ Card::Hearts, Card::Ace },
{ Card::Spades, Card::Two },
{ Card::Spades, Card::Three },
{ Card::Spades, Card::Four },
{ Card::Spades, Card::Five },
{ Card::Spades, Card::Six },
{ Card::Spades, Card::Seven },
{ Card::Spades, Card::Eight },
{ Card::Spades, Card::Nine },
{ Card::Spades, Card::Ten },
{ Card::Spades, Card::Jack },
{ Card::Spades, Card::Queen },
{ Card::Spades, Card::King },
{ Card::Spades, Card::Ace },
{ Card::Clubs, Card::Two },
{ Card::Clubs, Card::Three },
{ Card::Clubs, Card::Four },
{ Card::Clubs, Card::Five },
{ Card::Clubs, Card::Six },
{ Card::Clubs, Card::Seven },
{ Card::Clubs, Card::Eight },
{ Card::Clubs, Card::Nine },
{ Card::Clubs, Card::Ten },
{ Card::Clubs, Card::Jack },
{ Card::Clubs, Card::Queen },
{ Card::Clubs, Card::King },
{ Card::Clubs, Card::Ace } }
{}

void DeckOfCards::printDeck()
{

bool first = true;

for (auto card : cards_)
{
if (!first)
{

std::cout << ", ";

}
card.printCard();
first = false;
}

}

Заголовок карты

#pragma once

#ifndef CARD_H_
#define CARD_H_

struct Card
{

enum Suit_Type
{

Diamonds,
Hearts,
Spades,
Clubs,
} suit;

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;

void printCard();

};#endif // !CARD_H

_

0

arrays c++c++11 playing-cards visual-studio

Решение

Другие решения

Других решений пока нет …

Источник

Accepted Answer

Вы можете обнаружить, что это вас растягивает, но там, где заполнение массива или вектора можно описать алгоритмическими терминами, я бы, вероятно, сделал это так.

В этом случае я использовал 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:\n\n";
deck.printDeck();

}

0