3. Zufalls Funktion

Zufalls Funktion

  • S

    Die Idee mit den vectoren durchmixen is echt clever 🙂 mal schaun ob ich das umsetze, aber was sagst du zu der Funktion?
    Dankeschön schon mal im Voraus.

    0
  • S

    Die Idee mit den vectoren durchmixen is echt clever 🙂 mal schaun ob ich das umsetze, aber was sagst du zu der Funktion?
    Dankeschön schon mal im Voraus.

    0
  • C

    Die Funktion sieht recht nett aus, nur daß du das new dort nicht unbedingt brauchst:

    long rnd(long a,long b)
{
    int Zufall=(rand() % (b-a+1)) + a;
    static int temp[10];
    static int counter=0;
    static int hv=0;
    ...
}

    Eventuell könntest du die Rekursion noch durch eine Schleife ersetzen:

    while(find(temp,temp+hv,Zufall)!=temp+hv)
  Zufall = rand()%(b-a+1) + a;
    0
  • S

    hustbaer schrieb:

    ...ist ein echt guter Generator...

    Dass Problem ist aber wohl, dass er gar keine echten Zufallszahlen will. Letztlich will Stromberg auf eine Strategie hinaus - und da ist echter Zufall nur bedingt hilfreich.
    @Stromberg: Ich würde Dir raten, "Zufallszahl" und "Strategie" komplett zu trennen - so wie Du schon damit anfängst, indem Du die Regel "Zug darf nicht innerhalb der letzten 10 Züge vorkommen" aufstellst. Werde Dir doch erstmal klar darüber, welche sonstigen Strategieregeln Du verfolgen möchtest ... das ist viel wesentlicher als die Qualität der Zufallszahl.

    Gruß,

    Simon2.

    0
  • S

    Stromberg schrieb:

    ...

    ...
    static int *counter=new int(0);
    static int *hv=new int(0);
...

    ...

    Kann es sein, dass Du von Java kommst ?
    😉

    Gruß,

    Simon2.

    0

  • Stromberg schrieb:

    Die Idee mit den vectoren durchmixen is echt clever 🙂 mal schaun ob ich das umsetze, aber was sagst du zu der Funktion?
    Dankeschön schon mal im Voraus.

    Ich würde auf jede Fall das

    static int *temp=new int[10];
    static int *counter=new int(0);
    static int *hv=new int(0);

    in das

    static int temp[10] = {};
    static int counter = 0;
    static int hv = 0;

    ändern.

    0
  • S

    Ja halt mh jetzt hab ich ein Verständnis Problem! Ich hab ja das hier gemacht:

    static int *temp=new int[10];
static int *counter=new int(0);
static int *hv=new int(0);

    Weil: Wenn ich die Variablen nicht auf dem Heap reserviere dann werden die doch nach Beendigung der Funktion wieder gelöscht. Aber ich will doch das die auch beim neuen Funktionsaufruf scon mitgezählt haben. Weil was auf dem Heap deklariert wird, da is es doch so das es erst wieder gelöscht wird wenn man die halt mit delete löscht. Und static benutze ich da ja nur, das sie nur einmal deklariert werden und nicht andauernd überschrieben werden und es dann Speicherlecks gibt!
    Oder macht static etwa etwas anderes hab ich hier irgendwas falsch verstanden.
    Bitte klärt mich auf :)! Dankeschön schon mal im Voraus.

    PS: Is mir noch aufgefallen hier is n kleiner Fehler drin. Gut das ich den selber gefunden habe is n peinlicher Fehler.

    long rnd(long a,long b)
{
    int Zufall=(rand() % (b-a+1)) + a;
    static int *temp=new int[10]; //<-- wenn das Array 10 Felder hat dann is es ja von 0-9
    static int *counter=new int(0);
    static int *hv=new int(0);

    if (*counter>10) //Dann muss es hier aber heißen if(*counter>9)
    {
        *counter=0;
    }
    if (*hv>10)  //Und hier muss es heißen is *hv>9
    {
        *hv=10;
    }

    for(int i=0;i<*hv+1;i++)
    {
        if(Zufall==temp[i])
        {
            return rnd(a,b);
        }
    }
    temp[*counter]=Zufall;
    *counter++;
    *hv++;
    return Zufall;
}
    0
  • C

    Wenn du die Variable als 'static' deklarierst, wird sie nicht auf dem Stack untergebracht und überlebt schon von sich aus das Ende der Funktion. Da ist es nicht nötig, sich noch zusätzlichen Heap-Speicher anzufordern (der übrigens nie wieder freigegeben wird).

    PS: Und den Flüchtigkeitsfehler hast du vermutlich an der falschen Stelle ausgemerzt - lass lieber das "i<*hv+1" in der for-Schleife weg.

    0
  • S

    So das wäre jetzt dei vollendete rnd Funktion. Ist doch in Ordnung oder? Einen Zeiger auf den Heap musste ich leider drin lassen.

    //c ist in welchem Abstand eine Zahl wieder kommen darf!
//Also wenn eine Zufallszahl gekommen ist darf sie erst nach c anderen
//Zufallszahlen wieder kommen.
long rnd(long a,long b,int c)
{
    int Zufall=(rand() % (b-a+1)) + a;
    static int *temp=new int[c];
    static int counter=0;
    static int hv=0;

    if (counter>c)
    {
        counter=0;
    }
    if (hv>c)
    {
        hv=c;
    }

    for(int i=0;i<hv+1;i++)
    {
        if(Zufall==temp[i])
        {
            return rnd(a,b,c);
        }
    }
    temp[counter]=Zufall;
    counter++;
    hv++;
    return Zufall;
}

    So is ja alles schön und gut jetzt, aber mir ist aufgefallen das ich die Funktion ja nur einmal einsetzen kann (Wie gesagt ich benutz die ja um bei meinem Bot durch Zufall vector strings auszulesen). Mh weil wenn ich sie dann nochmal starte dann sind ja immer noch die alten Werte drin. Versteht jemand was ich mein? Das is ja natürlich beabsichtig das er sich die Werte merkt, ja aber wenn ich dann z.B. für meinen Bot aus einem anderen vector string lese dann stehen in temp ja noch die alten Werte und so drin. Und *temp kann man nicht überschreiben da es ja static ist und wenn es nicht static wäre würde es sich aber nichts mehr merken und würde dauernd überschrieben werden --> SPEICHERLECKS! Mh äh is jetzt irgendwie so eine Zwickmühle! Kann ich die Funktion jetzt echt nur einmal auf einen vector ansetzen oder lässt sich da noch was dran drehen?
    Dankeschön schon mal im Voraus.

    0
  • C

    Du könntest deinen Zufallsgenerator als Objekt anlegen:

    class Random
{
  long min,max,count;
  std::deque<long> values;
public:
  Random(long a,long b,long c) : min(a),max(b),count(c) {}

  long getZahl()
  {
    long Zufall;
    do
      Zufall=rand()%(max-min+1)+min;
    while(find(values.begin(),values.end(),Zufall)!=values.begin());
    values.push_back(Zufall);
    if(values.size()>count) values.push_front();
    return Zufall;
  }
};
    0
  • A

    Ehm, vielleicht hat mich Java berufsmäßig schon verdorben, aber muß das nicht heißen:

    *(temp[counter])=Zufall;

    Weil sonst setzt du ja die Speicheradresse zufällig, und nicht den int-Wert.

    Und wenn du mehrere Vectoren durchlaufen willst, müsstest du nur den Counter wieder auf Null zurück setzen. Aber irgendwie ist dein Design wirklich etwas crazy. 😃 Ich würde das ganze irgendwie anders lösen. Ich würde der rnd-Funktion gleich nen vector übergeben und gleich umsortieren.

    0

  • Stromberg schrieb:

    So das wäre jetzt dei vollendete rnd Funktion. Ist doch in Ordnung oder? Einen Zeiger auf den Heap musste ich leider drin lassen.

    //c ist in welchem Abstand eine Zahl wieder kommen darf!
//Also wenn eine Zufallszahl gekommen ist darf sie erst nach c anderen
//Zufallszahlen wieder kommen.
long rnd(long a,long b,int c)
{
    int Zufall=(rand() % (b-a+1)) + a;
    static int *temp=new int[c];
    static int counter=0;
    static int hv=0;

    if (counter>c)
    {
        counter=0;
    }
    if (hv>c)
    {
        hv=c;
    }

    for(int i=0;i<hv+1;i++)
    {
        if(Zufall==temp[i])
        {
            return rnd(a,b,c);
        }
    }
    temp[counter]=Zufall;
    counter++;
    hv++;
    return Zufall;
}

    Nein, das new muss nicht drin bleiben, static ist static, da musst du nicht new bemühen.
    Weiss nicht was daran so schwer zu verstehen ist.

    0
  • S

    Ja doch new muss schon sein, weil das array temp ist doch noch ungewisse, man weiß doch nicht wie groß es wird deshalb kommt es auf den Heap?
    Meinst du etwa so?

    static int temp[c];

    Da kommt bei mir n Error:
    Compiling: C:\MinGW\Andi\C++\rnd funktion.cpp
    C:\MinGW\Andi\C++\rnd funktion.cpp: In function long int rnd(long int, long int, int)': C:\\MinGW\\Andi\\C++\\rnd funktion.cpp:23: error: storage size oftemp' isn't constant
    C:\MinGW\Andi\C++\rnd funktion.cpp:23: error: size of variable 'temp' is too large
    Process terminated with status 1 (0 minutes, 0 seconds)
    2 errors, 0 warnings

    0
  • A

    Mit new ist schon korrekt, wenn die Größe erst zur Laufzeit bekannt ist. Nur vergisst du immer am Ende deine mit new reservierten ints mit delete zu zerstören!!! ➡ Speicherleck!!!

    Und dann brauchst du es auch nicht static machen, wenn du es eh bei jedem Durchlauf neu anlegen mußt.

    0
  • S

    @CStoll
    1. Was ist den:

    std::deque<long> values;

    Is das sowas wie:

    std::vector<long> values;

    ????

    2. Was bedeutet der Befehl "find" in der while schleife, äh den kenn ich nämlich auch nicht. Kanbnst mir das auch erklären.
    3. "push_front();" <-- den Befehl kenn ich auch nicht. Ist doch son vector Befehl oder? Schaut so aus finde ich. Obwohl ich das coole Tutorial von Artchi durchgemacht habe aber, aber an push_front(); kann ich mich nicht erinnern. Kannst mir auch das erklären. Sonst hab ich alles soweit verstanden.

    @Artchi
    "*(temp[counter])=Zufall;" <-- das verstehe ich nicht, ich hätte da aber dann "*temp[counter]=Zufall;" geschrieben warum müssen den da solche "( )" hin?

    Dankeschön schon mal im Voraus.

    0
  • S

    @Artchi
    Ja wenn es jetzt aber doch heißt:

    static int *temp=new int[c];

    dann wird es doch wegen static nicht neu deklariert oder? --> keine Speicherlecks
    Und ich kann doch nicht "delete []temp;" machen, weil der sich das ja dauerhaft merken soll. Wenn ich es lösche dann is es ja weg und die letzten c Zufallszahlen weiß er ja dann nicht mehr. Mh ich sags ja Zwickmühle. Aber man muss das doch auch nicht deleten weil es läuft halt einfach bis zum Programm ende durch und wird gant zum Schluss deleted. Oder? Wer erfreut über deinen fachlichen Rat. Dankeschön schon mal im Voraus.

    0
  • A

    Stromberg! Ich will dir ja nicht zu nache treten, aber vieles was du fragst, kannst du auch selber nachlesen. Wir müssen hier doch nicht jede einzelne Funktion jeder Klasse der Standardlib erklären? Ich habe dir mind. 3 mal hier im Forum http://www.cppreference.com genannt!!! Schlag da endlich nach!!!!!!!

    push_back, push_front usw. sind dort alle erklärt! Teilweise braucht man push, back und front nur ins deutsche überseten und schon weiß man was sie machen, ohne das man das nachschlagen muß. push_back heißt nach hinten legen, push_front nach vorne legen. Und, so schwer???

    Auch std::deque (Double-ended Queues) ist in der cppreference.com erklärt.

    Und besorg dir mal ein vernünftiges C++ Buch, oder schau hier in das Magazin-Forum (weiter unten!) da sind Artikel zur C++ Standardbibliothek, wo alles erklärt wird.

    0
  • A

    Stromberg schrieb:

    @Artchi
    Ja wenn es jetzt aber doch heißt:

    static int *temp=new int[c];

    dann wird es doch wegen static nicht neu deklariert oder? --> keine Speicherlecks
    Und ich kann doch nicht "delete []temp;" machen, weil der sich das ja dauerhaft merken soll. Wenn ich es lösche dann is es ja weg und die letzten c Zufallszahlen weiß er ja dann nicht mehr. Mh ich sags ja Zwickmühle. Aber man muss das doch auch nicht deleten weil es läuft halt einfach bis zum Programm ende durch und wird gant zum Schluss deleted. Oder? Wer erfreut über deinen fachlichen Rat. Dankeschön schon mal im Voraus.

    Sorry, habe mich da selber vertan. Wird nur einmal aufgerufen das new.

    0
  • A

    Schau mal hier rein:
    http://www.c-plusplus.net/forum/viewtopic-var-t-is-143816.html

    Viele Artikel zu C++ findest du auch hier:
    http://www.c-plusplus.net/forum/viewforum-var-f-is-55.html

    0
  • K

    Mit new ist schon korrekt, wenn die Größe erst zur Laufzeit bekannt ist.

    Und wenn Du schon am nachlesen bist, schau Dir mal std::vector an. Da könntest Du dann ohne leak auskommen (das static hilft hier nicht gegen den leak) und das new sparen 🤡

    0
Anmelden zum Antworten