Ich habe mit C++ erst vor einigen Wochen angefangen. Um das bisherige Wissen zu vertiefen habe ich mich an das Programmieren eines "Poker-Spiels" gemacht.

Dennoch gibts da ein Problem:
(Der folgende Code ist die Funktion der eine Zufallszahl erzeugt und dann schaut ob die Zufallskarte noch im Deck ist und diese dann als return zurückgibt)

int Zufallskarte (struct S_Deck *p_Deck)
{
	int iWhileende = 0;		// Variable um die Schleife zu beenden

	do
	{
		int iZufall;	// Die Zufallsvariable	
		srand (timeGetTime ());  
		iZufall = (rand()%52);  /* Die Zahl wird von 0 bis 51 zufällig  gewählt (52 Karten) */

		for (int i=0; i < 51; i++) // Schleife die 52 mal läuft
		{
			if  (iZufall == i) // Sollte die Schleifenvariable gleich der Zufälligen sein, dann wird die Bedingung erfüllt
			{
				if (p_Deck [i].bVorhanden == true) /* Ich habe einen Array verwendet welcher 52 Struckturen in sich hat
und jede Struktur besteht aus einem Bool um festzustehlen ob die Karte im Deck ist */
				{
					p_Deck [i].bVorhanden = false;
					iWhileende = 1;
					return i;
				}

			}
		}

	} while (iWhileende == 0);

	return 0;
}

Nun Gut das Funktioniert perfekt nun habe ich innerhalb der eigentlichen Spiel-Funktion folgendes Verwendet

int iRueckgabezufall;
// Erste Karte ausgeben und als die erste Spielerkarte angeben
	iRueckgabezufall = Zufallskarte (p_Deck);
	ASpielerkarte1 [iRueckgabezufall].bVorhanden = true;

	for (int u=0; u < 51; u++)
	{
		if (ASpielerkarte1 [u].bVorhanden == true)
		{
			cout << "Das ist die " << u << " Position der ersten Spielerkarte.\n";
		}

	}
	iRueckgabezufall = 0;
	Sleep(500);

Nur das blöde ist, dass wenn ich den obrigen Code einfach Kopiere (um zum Beispiel die 2te Spielerkarte festzulegen (Jeder Spielerkarte ist ihrerseits ein 52er Array und jenachdem welche Position in diesem Array True ist weis ich welche Karte der Spieler bekommen hat). Wenn ich dann die Kopie eine neue Schleifenvariable sowie der Kopie sage das sie in den Array "ASpielerkarte 2" reinschreibt, dann ergibt sich folgendes Bild:

Das ist die 13 Position der ersten Spielerkarte
Das ist die 13 Position der zweiten Spielerkarte

Weis vllt einer warum bei jedem mal die gleiche Zufallszahl heraus kommt? Durch "gettime()" wird ja bei jedem mal wo eine neue Karte gezogen wird eine andere Zeit aus dem System geladen, also eine andere Zahl sollte herauskommen.

srand hat in einer Schleife nichts verloren.

Schreib mal an den Anfang deiner main-Funktion

srand( time(NULL) );

und schau, ob dies dein Problem löst.

edit: Zu spät...

hmm ich habe jetzt srand am anfang Verwendet nur gibt das Programm weiterhin bei beiden Karten die gleiche Zahl raus. Eigentlich doch Logisch soweit ichs weis. Ich gebe ja einmal über die Zeit der Zufallsfunktion rand (was wiederum ja nur eine Mathematische Formel ist) den gleichen Startwert. und wenn man bei beiden Zufallsausgaben den gleichen Startwert besitzt würde würde das Ergebnis der Formel ebenfalls gleich sein oder? Korrigiert mich wenn ich falsch liege^^

Aber eins weiß ich: Die Lösung hat leider nicht Funktioniert^^
Aber danke für die Bemühungen^^

mfg
_LiFeMaKeR_

hmm ich habe jetzt srand am anfang Verwendet nur gibt das Programm weiterhin bei beiden Karten die gleiche Zahl raus. Eigentlich doch Logisch soweit ichs weis. Ich gebe ja einmal über die Zeit der Zufallsfunktion rand (was wiederum ja nur eine Mathematische Formel ist) den gleichen Startwert. und wenn man bei beiden Zufallsausgaben den gleichen Startwert besitzt würde würde das Ergebnis der Formel ebenfalls gleich sein oder? Korrigiert mich wenn ich falsch liege^^

Wenn du zweimal den gleichen Startwert nimmst, dann bekommst du danach jeweils die gleiche Folge von Zufallszahlen. Aber gerade deswegen solltest du ja srand auch nur einmal setzen, wenn du das nicht haben möchtest.

Das ist die komplette Funktion für das neue Spiel vllt liegt der Fehler ja wo anders? ( Ach stört euch nicht an den übergegeben Variabeln in der Parameterliste da die jetzt noch nicht gebraucht werden tun die niemanden was^^

Nochmal zu dem System das ich mir ausgedacht hatte: Das Deck ist ein Array aus 52 Struckturen die jeweils eine bool inne haben welcher "bVorhanden" heißt. Dieser bool sagt mir ist die Karte noch im Deck? (true) oder nicht mehr (false).
Das gleicht gilt für die 2 Spielerkarten und die 2 Gegnerkarten und die 5 Mittelkarten (Doch hier heißt "True" = Spieler hat Karte und "False" = Spieler hat die Karte nicht. Jede Position innerhalb des Arrays ist eine der 52 Karten.

Nebenbei wird auch weniger Speicher verbraucht und das System ist leichter für eine beliebige Anzahl Spieler erweiterbar, aber das sind erstmal Nebeneffekte.

// Rückgabevariable für das Menü
	int iMenuerueck = 0;

	iMenuerueck = Start (pBigblind, pSmallblind, pRate, pSchwierigkeitsgrad, iMenuerueck);
	if (iMenuerueck == 1)
	{
	Neuesspiel (pBigblind, pSmallblind, pRate, pSchwierigkeitsgrad, pRunde);	
	}
	else if (iMenuerueck == 2)
	{
		system ("cls");
		cout << "Spiel wird beendet\n";
	}
	return 0;
}

Das ist die "Main" Funktion die eine "Start" funktion ausführt (Musste ich umgehen da ich nicht wusste wie ich innerhalb einer Funktion die main Funktion aufrufe.

int Start (int *pBigblind, int *pSmallblind, int *pRate, int *pSchwierigkeitsgrad, int iMenuerueck)
{

	do		
	{
	iMenuerueck = Hauptmenue (iMenuerueck, pBigblind, pSmallblind, pRate, pSchwierigkeitsgrad);	
	} while (iMenuerueck == 0);

return iMenuerueck;
}

Die Start funktion wenn ich im Hauptmenü die "1" (Das heißt so viel wie Neues Spiel) drücke wird 1 zurückgegeben. Die Schleife ist nur dafür da damit sollte man im Hauptmenü eine eingabe machen die nicht logisch ist (nur 3 Menüpunkte also man gibt 5 ein) dann gibt das Hauptmenü 0 zurück und wird neu gestartet.

Klar gibt es viel einfachere System aber erstmal soll erstmal die Zufällige Ausgabe von der Karte gehen dann kann ich das gedachte System verbessern^^

srand( time(NULL) );

Ansonsten kannst du das Programm auch wo hochladen, dass man sichs genauer anschaun kann... schaut doch etwas komplex aus :p

Diese Zeile nur einmal im Programm aufrufen, nicht fuer jedes Spiel neu. D.h hier:

int main() {
  srand (timeGetTime ());
  ..                       // dein restliches Programm
  return 0;
}

- modelliere alle möglichen Karten
- modelliere Spieler (2 slots) && Geber (5 slots)
- modelliere ein Deck
-- implementiere Deck reset
-- implementiere Deck mischen
-- implementiere eine Karte aus Deck an Spieler geben
modelliere eine Pokervariante die 1 Geber, n Spieler und 1 Deck verwaltet

Deck zB ähnlich wie
http://wiki.forum.nokia.com/index.php/CS001142_-_Shuffling_data_using_STL_random_shuffle_algorithm

#include <iostream>
#include <string>

#include <vector>
#include <algorithm>

namespace Cards {

    enum values {  Two=2,        Three,      Four,       Five,        Six,        Seven,      Eight,     Nine,     Ten,
                   Jack,        Queen,      King,       Ace
        };

    // spades (♠), hearts (♥), diamonds (♦) and clubs (♣)
    enum colors { Diamond = 1, Heart , Spade , Club };

    std::string name(int v = Cards::Two, int c = Cards::Diamond, bool shortName=false)
    {
        const std::string val[] = { "Two", "Three", "Four","Five", "Six", "Seven", "Eight", "Nine", "Ten", 
                             "Jack", "Queen", "King","Ace" };
        const std::string col[] = { "Diamond", "Heart", "Spade", "Club" };
        const std::string colS[] =  {"♦", "♥", "♠", "♣"};
        const std::string valS[] =  {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};

        // short naming
        if (shortName)
            return " "+valS[v-Cards::Two]+colS[c-Cards::Diamond];

        // long names
        return val[v-Cards::Two] + " of " + col[c-Cards::Diamond] + "s";
    }
};

class OneCard {
    bool isValid;
    int _value;
    int _color;
public:
    OneCard() : isValid(false),_value(0),_color(0) {};
    OneCard(int v, int c) :
            isValid(true), _value(v), _color(c)
    {}

    std::string name()      { if (isValid) return Cards::name(_value,_color);       else return ""; }
    std::string shortName() { if (isValid) return Cards::name(_value,_color,true);  else return ""; }

    int value() const { return _value;}
    int color() const {return _color;}
    bool valid() const {return isValid;}
};

class Deck {
    std::vector<OneCard> _deck;

public:
    Deck() : _deck(0)
    {
        _deck.reserve(52);
        for (int col = Cards::Diamond; col <= Cards::Club; ++col)
        {
            for(int val=Cards::Two val <= Cards::Ace; ++val)
            {
                _deck.push_back(OneCard(val,col));
            }
        }        

        std::cout << "Pack: " << std::endl;
        debug();
        shuffle();
        std::cout << "Shuffled: " << std::endl;

        debug();
    }

    void shuffle() { std::random_shuffle(_deck.begin(), _deck.end()); }

    void debug() {
        for (unsigned int i=0; i < _deck.size(); ++i)
            std::cout << _deck[i].shortName() << " ";

        std::cout << std::endl;
    }

    OneCard drawOne()
    {
        if (! _deck.empty())
        {
            OneCard card = _deck.back();
            _deck.pop_back();
            return card;
        } else return OneCard();  // invalid one
    }
} ;

class Player {
public:
    std::vector<OneCard> owns;
};

class Game {
    Deck deck;
    std::vector<Player> player;
    std::vector<OneCard> forAll;
public:
    Game(int playercount = 3, int cardcount = 2) : deck(Deck())
    {
        // create players
        for(int i=0; i< playercount; ++i)
        {
            Player p;
            player.push_back(p);
        }

        // deal cards
        for (int cards=0; cards < cardcount; ++cards)
            for(int i=0; i < playercount; ++i)
            {
                player[i].owns.push_back(deck.drawOne());
            }

        debug();
    }

    void debug() {
        for(unsigned int i=0; i < player.size(); ++i)
        {
            std::cout << "P: " <<  i << "\tcards:   ";

            for(unsigned int cards=0; cards < player[i].owns.size(); ++cards)
                std::cout << player[i].owns[cards].shortName() << " " ;

            std::cout << std::endl;
        }
        std::cout << "Next 5:\t";
        for (int ii=0;ii<5;++ii) std::cout << deck.drawOne().shortName() << " ";
        std::cout << std::endl;

    }
};

int main()
{
    srand(time(0));
    Game g(4,4);
}

edit: Muh³² ... sehr .... konstruktiv.

Vielleicht wäre ein etwas "c++"iger Ansatz auch nett ... ich konnte mich nie mit struct's anfreunden.

- modelliere alle möglichen Karten
- modelliere Spieler (2 slots) && Geber (5 slots)
- modelliere ein Deck
-- implementiere Deck reset
-- implementiere Deck mischen
-- implementiere eine Karte aus Deck an Spieler geben
modelliere eine Pokervariante die 1 Geber, n Spieler und 1 Deck verwaltet

Deck zB ähnlich wie
http://wiki.forum.nokia.com/index.php/CS001142_-_Shuffling_data_using_STL_random_shuffle_algorithm

blaa blubb Modelier implementier und am ende braust du am besten alles nochmal neu.

Gibt es keine 10?

Äöööhhmmm nee, ähh ja ... warn Test hab 4 Zeilen geändert, nun gibts ne 10

So hab das System hinter dem Spiel verändert gibt nur noch einen Array der die Karten verwaltet und wer sich fragt: Hey? wo ist timegettime hin? das ist im Moment am Anfang von der main-Funktion.

#include <iostream>
#include <windows.h>
#include <stdlib.h>

#pragma comment (lib, "winmm.lib")

using namespace std;

#include "Spiel.hpp"

void Neuesspiel (int *pBigblind, int *pSmallblind, int *pRate, int *pSchwierigkeitsgrad,
				 int *pRunde)
{

	// Spielarrays

	system("cls");
	int AKarten [52];										// Karten Array

		// Array Infos:
		// Wert 0	=	Karte ist im Deck
		// Wert 1	=	Karte ist Spielerkarte 1
		// Wert 2	=	Karte ist Spielerkarte 2
		// Wert 3	=	Karte ist Gegnerkarte 1
		// Wert 4	=	Karte ist Gegnerkarte 2
		// Wert 5	=	Karte ist Mittekarte 1
		// Wert 6	=	Karte ist Mittekarte 2
		// Wert 7	=	Karte ist Mittekarte 3
		// Wert 8	=	Karte ist Mittekarte 4
		// Wert 9	=	Karte ist Mittekarte 5

	int *p_Karten = &AKarten[0];						// Der Pointer des Karten Arrays

	for (int i=0; i < 51; i++)		// Schleife um jede Karte auf "0" (Ist im Deck) zu schreiben
	{
		AKarten[i] = 0;
	}

	// Variabeln
	int iRueckgabezufall;

	// Erste Karte ausgeben und als die erste Spielerkarte angeben
	iRueckgabezufall = Zufallskarte (p_Karten);
	AKarten [iRueckgabezufall] = 1;

	for (int u=0; u < 51; u++)
	{
		if (AKarten [u] == 1)
		{
			cout << "Das ist die " << u << " Position der ersten Spielerkarte.\n";
		}

	}
	iRueckgabezufall = 0;
	Sleep(500);
	// Zweite Karte ausgeben und als die Zweite Spielerkarte angeben
	iRueckgabezufall = Zufallskarte (p_Karten);
	AKarten [iRueckgabezufall] = 2;

	for (int u2=0; u2 < 51; u2++)
	{
		if (AKarten [u2] == 2)
		{
			cout << "Das ist die " << u2 << " Position der zweiten Spielerkarte.\n";
		}

	}
	iRueckgabezufall = 0;
	Sleep(500);

}

int Zufallskarte (int  *p_Karten)
{
	int iWhileende = 0;		// Variable um die Schleife zu beenden

	do
	{
		int iZufall;		

		iZufall = (rand()%52);

		for (int i=0; i < 51; i++)
		{
			if  (iZufall == i)
			{
				if (p_Karten [i] == 0)
				{
					iWhileende = 1;
					return i;
				}

			}
		}

	} while (iWhileende == 0);

	return 0;
}

Und hier nochmal die Header-Datei des Spiels:

// Headerdatei des eigentlichen Spiels

// Funktionen

void Neuesspiel (int *pBigblind, int *pSmallblind, int *pRate, int *pSchwierigkeitsgrad,
				 int *pRunde);

int Zufallskarte (int  *p_Karten);

Hmm wie ich gerade feststelle Funktioniert das Programm auf Zauberhafte Art xD auch mit mehr als 2 Karten^^ brauch nur noch eine Abfrage die das mehrfach aufkommen von Karten verhindert. ^^ Auch wenn irgendwie alles was ich Versucht habe mit eurer Hilfe nix gebracht hat und Das Programm nun Funktioniert wies soll, danke ich trotzdem vieeeeelllmals für die Hilfe von euch^^ Naja xD Programmieren ist und bleibt manchmal etwas seltsam xDDDDD

MFG _LiFeMaKeR_