Die Klasse:

class RndColor
{
private:
	int Color;
	int HValue;
	int LValue;

public:
	RndColor(void);
	int RandomColor(int HighValue,int LowValue);
};

Die Methoden:

RndColor::RndColor(void)
{
	int Color = 0;
	int HValue = 0;
	int LValue = 0;
}
int RndColor::RandomColor(int HighValue,int LowValue)
{
	srand(timeGetTime());
	HValue = HighValue;
	LValue = LowValue;
	Color = (int)(rand()%HValue);
	while(Color << LValue)
	{
		Color = (int)(rand()%HValue);
	}
	return Color;
}

Wenn ich jetzt zum Beispiel sage

BColor.RandomColor(255,200)

dann will ich dass diese Methode eine Zahl zwischen 200 und 255 zurückgibt.
Komischerweise gibt er aber immer 0 zurück! Oo
Weiß jemand,was ich da falsch gemacht habe?

Nur ein '<'

Edit: Übrigens kannst du die Schleife relativ leicht vermeiden.

Color = ((int)(rand() % (HValue - LValue))) + LValue;

mfg Kenrik

Probier mal dies, ist noch nicht getestet.

Ich danke dir jetzt klappts auf einmal.

Dieser billige fehler den Bitoperator mit dem Vergleichoperator zu verwechseln passiert mir immer wieder. ^^

Ich scheine dadurch eine Endlosschleife gemacht zu haben und dadurch kam es nie zum return oder warum gab die Funktion immer den Wert 0 zurück?

Ich scheine dadurch eine Endlosschleife gemacht zu haben und dadurch kam es nie zum return oder warum gab die Funktion immer den Wert 0 zurück?

Naja, es war keine komplette Endlosschleife, sonst wärst du gar nicht mehr rausgekommen. Aber die Endebedingung deiner Schleife ist "Color==0" - das dürfte den Rückgabewert erklären.

btw solltest du den srand() Aufruf lieber in den Konstruktor verlagern.

Was das srand betrifft: Noch besser, als es in den Konstruktor zu schreiben, wäre übrigens, es nur einmal im gesamten Programm zu benutzen. Also entweder einmal am Anfang in der main oder eine andere Idee:

class RndColor
{
private:
    int Color;
    int HValue;
    int LValue;

    static bool srandIsSet;

public:
    RndColor(void);
    int RandomColor(int HighValue,int LowValue);
};

bool RndColor::srandIsSet=false;

RndColor::RndColor ():
    Color (0), HValue (0), LValue (0)
{
    if (!srandIsSet)
    {
        srand ((unsigned) time (NULL));
      /*Oder nach C++-Manier:
        srand (static_cast<unsigned> (time (NULL)));*/

        srandIsSet=true;
    }
}

warum +1 hier? dh wenn ich für highvalue: 20 und für LowValue: 10 übergebe...habe ich ja (rand()%11)+10...
ist da srand(timeGetTime()); ...reicht ein srand(NULL); am anfang nicht?

#include <limits>
#include <ctime>
#include <cstdlib>

template< typename T >
class random {

    private:

        T min;
        T max;

    public:

        random( ) : min( numeric_limits< T >::min( ) ), max( numeric_limits< T >::max( ) )
        {
            srand( time( 0 ) );
        }

        random( T pmin, T pmax ) : min( pmin ), max( pmax )
        {
        }

        ~random( ) { };

        T get( )
        {

         /* In Numerical Recipes in C: The Art of Scientific Computing
            (William  H.  Press, Brian P. Flannery, Saul A. Teukolsky,
            William T.  Vetterling;  New  York:  Cambridge  University
            Press,  1990 (1st ed, p. 207)), the following comments are
            made:

              "If you want to generate a random integer between 1 and
               10, you should always do it by

	       j = 1 + (int)( 10.0 * rand( ) / ( RAND_MAX + 1 . 0 ) );

	       and never by anything resembling

               j = 1 + ( (int) ( 1000000.0 * rand( ) ) % 10 );

               which uses lower-order bits."
         */

            return static_cast< T >( min + ( ( max + 1.0 ) * rand( ) / RAND_MAX ) );
        }
};

Greetz, Swordfish

NES-Spieler schrieb:

bool RndColor::srandIsSet=false;

RndColor::RndColor ():
    Color (0), HValue (0), LValue (0)
{
    if (!srandIsSet)
    {
        srand ((unsigned) time (NULL));
      /*Oder nach C++-Manier:
        srand (static_cast<unsigned> (time (NULL)));*/

        srandIsSet=true;
    }
}

Wie wär's mit

struct rand_initialisatorenklasse //;)
{
	rand_initialisatorenklasse() { srand (static_cast<unsigned> (time (NULL))); }
};

RndColor::RndColor ():
    Color (0), HValue (0), LValue (0)
{
	static rand_initialisatorenklasse initialisiere_die_zufaellerei;
}

?

warum die 1?

Als Modulo-Ergebnis kann 0 rauskommen, dies ist nach der Aufgabenstellung nicht erwünscht.
rand()%10 nicht wie du schreibst 11 , die 1 wird später hinzuaddiert.

Wie wäre es mit boost::random, bevor ihr hier versucht was halbes selber zu backen.