Frage über Operationenüberladen

[IndigoGott]

Hallo Leute!

Ich hab ein Programm gemacht, aber weiß nicht wie es weiter geht.
Ich soll vom Program die Mengenoperationen realisieren.

Code: Alles auswählen

//Aufgabe 2 - Mengeoperationen

#include<stdio.h>

struct SMenge
{
	int *werte;
	int anzahl;
};

void print(SMenge m)
{
	int i;
	for (i=0;i<m.anzahl;i++)
		printf("%d ", m.werte);

	printf("\n");
}

int main (void)

{
	SMenge m1 = {NULL, 0};
	SMenge m2 = {NULL, 0};

	m1<<1<<3<<6;
	m2<<4<<3<<7<<6;

	print(m1);			//Ausgabe: 1 3 6
	print(m2);			//Ausgabe: 4 3 7 6

//	print(m1|m2);	//Ausgabe: 3 6
//	print(m1&m2);	//Ausgabe: 1 3 6 4 7
//	print(m1/m2);	//Ausgabe: 1

	printf("\n\n\n");
	return 0;
}

[Xin]

Dann schau Dich doch mal im Wiki um und formuliere dann Deine Frage

[IndigoGott]

Also ich hab es schon gelesen und mir fehlen die Funktionen von Operatoren <<, |, &, /, damit print von m1 und m2 darstellen kann. Irrgentwie muss ich auf meinen Struktur zugreifen und gleichzeitig die Operatorenfunktion erzeugen.
Im Wiki steht das:
ostream & operator *=( ostream & lhs, Fraction const & rhs ).

Wäre es möglich, anstatt dessen

SMenge& operator << (SMenge& m)

schreibe ich das?

[Xin]

Also ich hab es schon gelesen

Gib in Zukunft Deine vorhandenen Informationen an. Sag zum Beispiel, dass Du das Wiki schon gelesen hast und welche Information fehlt.
Also formuliere Deine Frage, damit die Fragestellung im Wiki nachgeholt werden kann.

und mir fehlen die Funktionen von Operatoren <<, |, &, /, damit print von m1 und m2 darstellen kann. Irrgentwie muss ich auf meinen Struktur zugreifen und gleichzeitig die Operatorenfunktion erzeugen.
Im Wiki steht das:
ostream & operator *=( ostream & lhs, Fraction const & rhs ).

Wäre es möglich, anstatt dessen

SMenge& operator << (SMenge& m)

schreibe ich das?

Genau, solange Du Dich innerhalb der Klasse befindest.

Code: Alles auswählen

class SMenge
{
pubilc:
  SMenge( int item );

  SMenge & operator << ( SMenge const & m )
};

ODER:

Code: Alles auswählen

SMenge & operator << ( SMenge const & m, SMenge const & m )

[IndigoGott]

um der Operator << realisieren zu koennen, hab ich diese Funktion herausgefunden.

Code: Alles auswählen

SMenge& operator << (SMenge& m, int x)
{
	m.werte=(int*)realloc(m.werte,(m.anzahl+1)*sizeof(int));	//erweitert das Speicherblock
	m.werte[m.anzahl]=x;
	m.anzahl++;

	return m;
}

Aber ich habe noch Fragen dazu:
Warum muss man eigentlich immer den Referenzoperator & eingeben? Weil wenn man ihn nicht gibt, kommt bei mir nur leere Zeilen
Dann hab ich Frage zu realloc (Hab schon im Wiki gelesen, aber es sagt nicht genau, wie es funktioniert):
wenn man realloc vereinfacht, sieht man das -> werte = (int*)realloc(werte, x*sizeof(int))
Frage: Was ist hier das x, wie kann man das im Prinzip denken?
Im Wiki steht statt dessen, ein Konstantes
numbers = (int*) realloc (numbers, count * sizeof(int));

[nufan]

Code: Alles auswählen

   print(m1);         //Ausgabe: 1 3 6
   print(m2);         //Ausgabe: 4 3 7 6

//   print(m1|m2);   //Ausgabe: 3 6
//   print(m1&m2);   //Ausgabe: 1 3 6 4 7
//   print(m1/m2);   //Ausgabe: 1

Also die Bedeutung deiner Operatoren verwirrt mich etwas. In der Logik haben & und | normalerweise genau umgekehrte Bedeutung. Was / macht ist mir ehrlich gesagt nicht klar.

Warum muss man eigentlich immer den Referenzoperator & eingeben? Weil wenn man ihn nicht gibt, kommt bei mir nur leere Zeilen

Übergibst du keine Referenz wird mit dem Copy-Konstruktor eine Kopie des Objekts erstellt. Nun erhöhst du im <<-Operator die Anzahl der Elemente in der Kopie. Am Ende des <<-Operators wird deine Kopie zerstört und du hast das ursprüngliche Objekt nicht verändert. Also bleibt dein Objekt die ganze Zeit unverändert. Eine Referenz ist wie der Name schon sagt ein Verweis, ein Verweis auf dein Objekt, das dann in der Funktion verändert wird.

Dann hab ich Frage zu realloc (Hab schon im Wiki gelesen, aber es sagt nicht genau, wie es funktioniert):
wenn man realloc vereinfacht, sieht man das -> werte = (int*)realloc(werte, x*sizeof(int))
Frage: Was ist hier das x, wie kann man das im Prinzip denken?

realloc bekommt als Parameter die neue Anzahl an Bytes. Mit dem sizeof-Operator erhältst du die Größe des Datentyps und das x steht für die Anzahl der Elemente.
Beispiel: Neuen Speicher für 5 Integer reservieren:

Code: Alles auswählen

integers = (int *) realloc (integers, 5 * sizeof (int));

Hier steht statt dem x eben 5, es könnte aber natürlich auch eine Variable oder Konstante sein. In C++ werden außerdem normalerweise new und delete verwendet.

[IndigoGott]

Code: Alles auswählen

   print(m1);         //Ausgabe: 1 3 6
   print(m2);         //Ausgabe: 4 3 7 6

print(m1|m2);   //Ausgabe: 3 6
print(m1&m2);   //Ausgabe: 1 3 6 4 7
print(m1/m2);   //Ausgabe: 1

Also die Bedeutung deiner Operatoren verwirrt mich etwas. In der Logik haben & und | normalerweise genau umgekehrte Bedeutung. Was / macht ist mir ehrlich gesagt nicht klar.

Also in diesem Fall sollte Parameter / wie folgt funktionieren: Alle was im m1 sind, aber nicht im m2, sollte auf dem Monitor dargestellt werden. In diesem Fall ist nur die Zahl 1, da die 1 im m1 ist, aber nicht im m2.

ich hab schon das komplette Programm geschaft. Ich gebe es euch mal, falls es für jemanden hilflich sein könnte. Solltet ihr Fragen habt, lass mich es einfach wissen!!
Aber immerhin hab ich diese << Funktion nicht selber gemacht, deshalb bräuchte ich auch noch ne Erklärung dazu. Vor allem würde ich euch beiden bedanken!

Code: Alles auswählen

//Aufgabe 2 - Mengeoperationen

#include<stdio.h>
#include<stdlib.h>

struct SMenge
{
	int *werte;
	int anzahl;
};

SMenge& operator << (SMenge& m, int x)
{
	m.werte=(int*)realloc(m.werte,sizeof(int)*(m.anzahl+1));	//erweitert das Speicherblock
	m.werte[m.anzahl]=x;
	m.anzahl++;

	return m;
}

void print(SMenge& m)
{
	int i;
	for (i=0;i<m.anzahl;i++)
		printf("%d ", m.werte[i]);

	printf("\n");
}

SMenge operator|(SMenge& m1, SMenge& m2)
{
	SMenge sm = {NULL, 0};
	int i, x;
	bool z;

	for(x=0;x<m2.anzahl;x++)
	{
		z = false;
		for(i=0;i<m1.anzahl;i++)
			if(m2.werte[x] == m1.werte[i])
				z = true;
		if(z == true)
			sm << m2.werte[x];
	}

	return sm;
}

SMenge operator&(SMenge& m1, SMenge& m2)
{
	SMenge sm={NULL, 0};
	int i, x;
	bool z;

	for(i=0;i<m1.anzahl;i++)
		sm << m1.werte[i];

	for(x=0;x<m2.anzahl;x++)
	{
		z=false;
		for(i=0;i<m1.anzahl;i++)
			if(m1.werte[i] == m2.werte[x])
				z=true;
		if(z == false)
			sm << m2.werte[x];
	}

	return sm;
}

SMenge operator/(SMenge m1, SMenge m2)
{
	SMenge sm={NULL, 0};
	int i, x;
	bool z;

	for(i=0;i<m1.anzahl;i++)
	{
		z=true;
		for(x=0;x<m2.anzahl;x++)
			if(m1.werte[i] != m2.werte[x])
			{
				z=true;
			}
			else
			{
				z=false;
				break;
			}
				if(z == true)
				sm << m1.werte[i];
			
	}

	return sm;
}

int main (void)

{
	SMenge m1 = {NULL, 0};
	SMenge m2 = {NULL, 0};

	m1<<1<<3<<6;
	m2<<4<<3<<7<<6;

	print(m1);			//Ausgabe: 1 3 6
	print(m2);			//Ausgabe: 4 3 7 6

	print(m1|m2);	//Ausgabe: 3 6
	print(m1&m2);	//Ausgabe: 1 3 6 4 7
	print(m1/m2);	//Ausgabe: 1

	printf("\n\n\n");
	return 0;
}

[IndigoGott]

Warum muss man eigentlich immer den Referenzoperator & eingeben? Weil wenn man ihn nicht gibt, kommt bei mir nur leere Zeilen

Übergibst du keine Referenz wird mit dem Copy-Konstruktor eine Kopie des Objekts erstellt. Nun erhöhst du im <<-Operator die Anzahl der Elemente in der Kopie. Am Ende des <<-Operators wird deine Kopie zerstört und du hast das ursprüngliche Objekt nicht verändert. Also bleibt dein Objekt die ganze Zeit unverändert. Eine Referenz ist wie der Name schon sagt ein Verweis, ein Verweis auf dein Objekt, das dann in der Funktion verändert wird.

Wie kann man wissen, wann man einen Referenzoparator & geben muss und wann nicht?

[Xin]

Dann hab ich Frage zu realloc (Hab schon im Wiki gelesen, aber es sagt nicht genau, wie es funktioniert):
wenn man realloc vereinfacht, sieht man das -> werte = (int*)realloc(werte, x*sizeof(int))
Frage: Was ist hier das x, wie kann man das im Prinzip denken?
Im Wiki steht statt dessen, ein Konstantes
numbers = (int*) realloc (numbers, count * sizeof(int));

Das x * sizeof( int ) ist die neue Größe des Arrays. Wenn Du x Integers speichern möchtest, brauchst Du entsprichend x * sizeof( int ) Bytes Speicher. Du übergibst Dein altes Array an realloc und bekommst eventuell einen neuen Zeiger zurück. Darum musst Du den Zeiger wieder neu speichern.

Da Du mit operator << mehr Speicher brauchst und weißt, dass Du m.anzahl Integers schon speicherst, brauchst Du nun eins mehr. Du vergrößerst das Array also auf die Größe, die (m.anzahl + 1) Integers benötigen.

Alle Fragen beantwortet? Bei Deinem letzten Post verstehe ich nicht ganz, ob Du noch eine andere Frage hast.

... neuer Frage gepostet:

Wie kann man wissen, wann man einen Referenzoparator & geben muss und wann nicht?

Das kommt drauf an, was Du tun möchtest.

Bei operator << möchtest Du das aktuelle Objekt zurückgeben, das Du auf der linken Seite hast, damit Du m << 1 << 2; schreiben kannst. m << 1 liefert m zurück, so dass als nächstes m << 2 ausgeführt werden kann.

Also gibst Du eine Referenz auf m zurück. Lässt Du den Referenzoperator weg, gibst Du ein Objekt zurück. Um das neue Objekt zu bekommen wird m kopiert und damit gibt es zwei gleiche, aber nicht identische Objekte. Du willst aber weiterhin Dein m-Objekt verändern und keine Kopien anfertigen.

[IndigoGott]

Danke Xin und dani93. Ich glaub das war schon alle meiner Fragen. Ich brauche noch paar Stunden, um das Verständnis zu machen
Bei weiteren Fragen, falls ich noch hätte, nehm ich mal an, dass ihr noch fit seid . Aber ich werde erstmal, so gut wie ich kann, das alles in den Kopf reinzubringen und zu verstehen:)


vielen Dank nochmals
MfG