Zufallszahl

NobbZ

Zufallszahl zwischen x und y:

float x,y,zufall;

srand(1);

zufall=x+(rand()/(RAND_MAX*y));

Zumindest sollte es so klappen wenn ich keinen Denkfehler drin habe Und man x und y entsprechende Werte zugewiesen hat

#include <conio.h>

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
int Zufallsgenerator(int max);

int main(int argc,char argv[]){
int Zufallswert;
    Zufallswert=Zufallsgenerator(1000);
    cout << Zufallswert<<endl;
    getch();
return 0;
}

int Zufallsgenerator(int max){
#ifndef _ZufallsgeneratorCalled_
#define _ZufallsgeneratorCalled_
srand(static_cast<unsigned>(time(0))); 
#endif
return rand()%max; 
}

cu max

DrGreenthumb

Master_Max schrieb:

int Zufallsgenerator(int max){
#ifndef _ZufallsgeneratorCalled_
#define _ZufallsgeneratorCalled_
srand(static_cast<unsigned>(time(0))); 
#endif
return rand()%max; 
}

Das funktioniert so nicht. Die Präcompiler-Anweisungen werden zur Compilezeit ausgewertet, und nicht wenn die Funktion aufgerufen wird.

Aha, danke.

NobbZ

Naja, Du seedest den Generator ja auch jedesmal mit einer neuen Zeit, alleine deswegen macht der schon neue Zufallszahlen... Aber durch das ewig neue seeden braucht er wesentlich mehr CPU-Zeit

Ich würde das dann eher so machen:

int Zufallsgenerator(int max){ 
    static int ZufallsgeneratorCalled

    if !(ZufallsgeneratorCalled)
    {
        srand(static_cast<unsigned>(time(0)));
        ZufallsgeneratorCalled=1;
    }

    return rand()%max;  
}

*edit* cpp-Tag geschlossen

weiß eigentlich jemand wie ein computer eine zufallszahl erstellt. die muss ja auch berechnet werden, die cpu kann sich ja nicht einfach was ausdenken, aber das ist doch dann nicht wirklich zufällig.

Jo, die wird nach irgeinder Methode berechnet. Dabei wird von einem Startwert ausgegangen und die Zahlenfolge berechnet. Deshalb muss man ja auch den Zufallsgenerator initialisieren, wenn man nicht immer die selben Zufallszahlen will.
Aber oft braucht man das, dass man eine Folge von "Zufallszahlen" rekonstruieren kann.
Wenn nicht, kann man ja die Zeit als Startwert nehmen. Es ist recht unwahrscheinlich, dass das Programm immer zur gleichen Millisekunde gestartet wird.

ja, aber es muss ja auch gewährleistet sein, damit jede zahl die gleichen chancen hat "errechnet" zu werden. ich stelle mir das schon ziemlich kompliziert vor.

Nein, ist es nicht. rand() erzeugt doch irgendeine extrem lange Zahl und mit % bleibst du im gewünschten Wertebereich. Und bekanntlich sind die verschiedenen Restwerte gleichmäßig verteilt, sie steigen ja immer um 1 an, bis zum Divisor.

EDIT: Es gibt Formeln dafür, ich hab auch mal selber einen Zufallsgenerator geschrieben, weil ich einen für die Logik und einen für die Grafik brauchte.

Walli

Ich habe mal eine Klasse auf der Basis von rand geschrieben die halbwegs korrekt Grenzen anpasst (ohne Schieflage).

// Random.hpp:
#pragma once

class Random
{
public:
	Random();
	~Random();

	static const int RandMax;

	int Next() const;
	int NextMin(int min) const;
	int NextMax(int max) const;
	int NextRange(int min, int max) const;
};

// Random.cpp:

#include <cstdlib>
#include <ctime>
#include ".\Random.hpp"

const int Random::RandMax = RAND_MAX;

Random::Random()
{
	// Nur einmal seed für alle Instanzen
	static bool seed = false;
	if(!seed)
	{
		srand(static_cast<unsigned>(time(0)));
		seed = true;
	}
}

Random::~Random()
{
}

int Random::Next() const
{
	return rand();
}

int Random::NextMin(int min) const
{
	return NextMax(RandMax - min) + min;
}

int Random::NextMax(int max) const
{
	int r, mr = RandMax - (RandMax % max);
	do {
		r = rand();
	}
	while(r >= mr);
	return r % max;
}

int Random::NextRange(int min, int max) const
{
	return NextMax(max - min) + min;
}