proggen.org

IndigoGott hat geschrieben:Also ich hab es schon gelesen

IndigoGott hat geschrieben: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?

class SMenge
{
pubilc:
  SMenge( int item );

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

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

IndigoGott hat geschrieben:

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

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

IndigoGott hat geschrieben: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?

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

dani93 hat geschrieben:

IndigoGott hat geschrieben:

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.

//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;
}

dani93 hat geschrieben:

IndigoGott hat geschrieben: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.

IndigoGott hat geschrieben: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));

IndigoGott hat geschrieben:Wie kann man wissen, wann man einen Referenzoparator & geben muss und wann nicht?