könnte mir jemand erklären wo der Fehler in diesem Programm liegt ??
Ich bekomme als Ausgabe immer nur 19 zurück.

Ich würde aber gerne mit der Methode a und b zwei neue Werte erzeugen und anschließend ausgeben.

Danke für euer bemühen.

class X {
	private: 
		short int f; 
		short int s; 

	public:
		// Konstruktoren
		X() : f(19) , s(19)   {};

		// Methoden allgemein
		short int a()  const { return f; }
		short int b() const { return s; }

		void definiere( short int af , short int as )
		{
			f = af;
			s = as;
		}

		short int a( short int af )
		{
			srand(time(NULL));
			af =  ....
			return af;
		}
		short int b( short int& as )
		{ 
			srand(time(NULL));
			as =  .....

			return as;
		}

		friend ostream& operator << ( ostream& os , X& k1 )
		{
			os << "f: " << k1.a() << "  s: " << k1.b();
			return os;
		}

};
int main ()
{
	X Y;
	cout << Y;

	cout <<endl<<endl;
    system ("pause");
    return 0;
}

srand(time(0));
rand();

 X Y;
    cout << Y;

    cout <<endl<<endl;
    system ("pause");
    return 0;
}

und poste doch mal Methode "a" und "b" vollständig, ich kann gar nicht nachvollziehen was da eigentlich genau passieren soll.

MfG
Stromberg

Hab in Methode b ein as = as + 8 eingefügt. Des geht auch nicht.

Weiß jemand Rat ????

class X {
private:
short int f;
short int s;

public:
// Konstruktoren
X() : f(19) , s(19) {};

// Methoden allgemein
short int a() const { return f; }
short int b() const { return s; }

void definiere( short int af , short int as )
{
f = af;
s = as;
}

short int a( short int af )
{
srand(time(NULL));
af = 0 + ( rand() % (40-0+1));
return af;
}
short int b( short int& as )
{
srand(time(NULL));
as = 0 + ( rand() % (50-0+1));
as = as + 8;

return as;
}

friend ostream& operator << ( ostream& os , X& k1 )
{
os << "f: " << k1.a() << " s: " << k1.b();
return os;
}

};
int main ()
{
X Y;
cout << Y;

cout <<endl<<endl;
system ("pause");
return 0;
}

dann kann die methode, die rand benutzt, bei jedem aufruf einen neuen wert kriegen.

short int b( short int& as )
{
srand(time(NULL));H
as = 0 + ( rand() % (50-0+1));
as = as + 8;

as = as + 8 zu keiner Veränderung führt.
Ich denk mir das des bestimmt an Call by Value liegt ??!! oder nicht.

H I L F E !!!

Ist das wirklich deine komplette main Funktion?

Wenn ja ... wird der Zahlengenerator nie aufgerufen und das Ergebnis 19 ist richtig.

Du hast 2 mal die Methoden int a() und int b()
Das erste mal so:

short int a()  const { return f; }
short int b() const { return s; }

Das zweite mal mit einer überladung

short int a( short int af )
{
    srand(time(NULL));
    af =  ....
    return af;
}
short int b( short int& as )
{ 
    srand(time(NULL));
    as =  .....

    return as;
}

Da ich vermute das du die Überladene Funktion in deiner Ausgabe aufrufen
willst würde ich empfehlen die ersten umzubenennen und die zweiten so
umzuschreiben das sie nichtmehr nur mit Parametern aufrufbar sind.

Wie ruf ich diese Methoden in main auf damit es klappt ?
Bin erst vor kurzem in das Thema Klasse eingestiegen und mich verwirrt noch einiges. Also bitte auf jeden Fehler aufmerksam machen. Danke

###########################
so etwa in main ??

int main ()
{
X Y;

X *p // Objektpointer erstellen
p = &Y; // jetzt sollte der Objektpointer auf das erstellte Objekt Y zeigen

p.a; // so oder wie ??

cout << Y;

##########################
++++++++++++++++++++++++++++

++++++++++++++++++++++++++++++

Hier nochmal der komplette Code

class X {
private:
short int f;
short int s;

public:
// Konstruktoren
X() : f(19) , s(19) 
{  
srand(time(NULL)); 
};

// Methoden allgemein
short int ausgabef() const { return f; }
short int ausgabes() const { return s; }

void definiere( short int af , short int as )   // die Methode definiere brauch ich dann nicht mehr oder ??
{
f = af;
s = as;
}

short int a(  )
{

return rand() %(40-0+1);
}
short int b(  )
{

return rand() % (50-0+1);
}

friend ostream& operator << ( ostream& os , X& k1 )
{
os << "f: " << k1.ausgabef() << " s: " << k1.ausgabes();
return os;
}

};
int main ()
{
X Y;
cout << Y;

cout <<endl<<endl;
system ("pause");
return 0;
}

Jetzt gibst du wieder die beiden 19er aus

Um Zufällige Zahlen auszugeben musst du jetzt entweder eine Methode schreiben
die die Variablen f und s manipuliert.

oder einfach deine operator<< überladung abändern das diese nun tatsächlich
die beiden Zufallszahlen ausgibt ... also so ...

friend ostream& operator << ( ostream& os , X& k1 )
{
    os << "f: " << k1.a() << " s: " << k1.b();
    return os;
}

Das ist allerdings noch kein sonderlich gutes Objekt Orientiertes vorgehen.
Du solltest dich als Hintergrundinformation vielleicht mal mit den
Grundsätzen von OOP Programmierung beschäftigen.

Nun ich hab eigentlich das Buch C++ Breymann. Hab aus dem Buch ungefähr das Schema übernommen. Oder soll ich mir ein anderes zulegen ?

Ich würd mal davon ausgehn das sich der Autor was dabei gedacht hat.
Ich kenn ja den Kontext nicht.

Also ruhig weiterlernen und dann aus dem eigenen Wissen heraus entscheiden.

Danke jetzt bekomm ich 2 verschieden Zahlen jedes mal.

Nun ich hab eigentlich das Buch C++ Breymann. Hab aus dem Buch ungefähr das Schema übernommen. Oder soll ich mir ein anderes zulegen ?

Beim Breymann wird der operator<< für eine Rational-Klasse überladen, und da wird alles richtig gemacht und eigentlich auch gut erklärt.