Meine Klasse für die Karten sieht folgendermaßen aus:

namespace card 
{
	enum type  { Ass, King, Queen, Jack, Ten, Nine, Eight, Seven, Six, Five, Four, Three, Two };
	enum color { Clubs, Spade, Heart, Diamonds };

	class Card
	{

	public:
		Card(type t, color c);
		~Card();

		void  setType(type t);
		void  setColor(color c);
		type  getType() const;
		color getColor() const;

	private:
		type  card_type;
		color card_color;

		Card(const Card&);
		Card& operator=(const Card&);
	};
}

Jetzt geht es darum zu Beginn ein Kartendeck zu intialisieren. Und hier bin ich hängengeblieben. Ich habe noch eine Klasse MauMau , in dessen Konstruktor ich das erledigen möchte.

#include "Card.h"
#include <vector>

class MauMau
{
public:
	MauMau(int players);
	~MauMau();

	void shuffle();

private:

	static const int card_amount;

	std::vector<card::Card> cards;

	MauMau(const MauMau&);
	MauMau& operator=(const MauMau&);
};

Nur wie mache ich das am besten? Ich muss dazu ja einmal über meine enums iterieren und gleichzeitig über meinen Vektor. Kann man das irgendwie eleganter lösen als durch zich ineinander verschachtelte Schleifen?

Grüße

#ifndef CARD_H
#define CARD_H

#include <string>

class Card
{
public:
    Card(std::string name, std::string color);
    std::string getCardname();
    std::string getCardcolor();
private:
    std::string cardname;
    std::string cardcolor;
};

#endif // CARD_H

#ifndef DECK_H
#define DECK_H

#include "card.h"
#include <vector>

class Deck
{
public:
    Deck();
    void shuffelDeck();
    Card deal();
private:
    std::vector<Card> cards;
    int card;
};

#endif // DECK_H

Zum mischen habe ich random_shuffle genutzt.

Ich habe die Klassen Karten, Kartendeck, Spieler und in der Klasse Game führe ich das alles zusammen. Mal schauen, ob ich das vernünftig hinkriege.

Nur wie mache ich das am besten? Ich muss dazu ja einmal über meine enums iterieren und gleichzeitig über meinen Vektor. Kann man das irgendwie eleganter lösen als durch zich ineinander verschachtelte Schleifen?

Je nach Geschmack sind das entweder eine oder zwei Schleifen. Wo ist das Problem?

for (int c = 0; c < color_count; ++c)
{
	for (int t = 0; t < type_count; ++t)
	{
		cards.push_back(Card(
			static_cast<type>(t),
			static_cast<color>(c)));
	}
}

std::random_shuffle(cards.begin(), cards.end());

Warum ist Card eigentlich nicht kopierbar und wozu der Destruktor?