// set.h
// Julian Skorka, FH KN
// 14.03.07

#ifndef SET_H
#define SET_H
#include <string>

class Set
{
 public:

  
   //Set(const Set& Mengex);	// Kopierkonstruktor
   ~Set();
   Set& operator=(const Set& Mengex); // &#65533;erladener Zuw.Op.
   std::string isElement(int Element);
   std::string isSubset(const Set& Mengex);
   void insert(int Element);
   void makeUnion(Set& Mengex);
   void intersect(Set& Mengex);
   void print();
   //Set();
private:
  
   void resize(int anzahl); 
   int* Menge;
   int  anzelemente;
   int  Feldgr;
};
#endif

//-----------------------------------------------------------------------

// set.cpp
// Julian Skorka, FH KN
// 14.03.07

#include "set.h"
#include <iostream.h>



/*Set::Set()
{
   anzelemente=0;
   Menge=0;
   Feldgr=0;
}

/*Set::Set(const Set& Mengex)
{
   // nichts
}*/

Set::~Set()
{
   delete [] Menge;
}

Set& Set:: operator=(const Set& Mengex) // zu Kopiren von Mengen
{
   if (this != &Mengex) 	// Selbstzuweisung v = v; vermeiden
   {
      delete [] Menge;
      anzelemente = Mengex.anzelemente;
      Feldgr      = Mengex.Feldgr;   
      Menge = new int[Feldgr];
      
      for (int i = 0; i < Feldgr; i++)
      Menge[i] = Mengex.Menge[i];
   }
   return *this;
}



std::string Set::isElement(int Element) // ob es Element in der Menge gibt
{
  for(int i=0;i < Feldgr;++i)
   {
    if(Menge[i]==Element) return "ja" ;
   }  
  return "nein";    
}



std::string Set::isSubset(const Set& Mengex) // Ob mengex teilemenge ist 
{
 for(int i=0; i < Mengex.Feldgr ; ++i)
   {
     int nicht=0;
     for(int j=0; j< Feldgr; ++j)
       {
         if(Mengex.Menge[i]!=Menge[j])
          {
            ++nicht;
          }  
        }  
     if(nicht == Feldgr)
      {
       return "Keine Teilemenge";
       }
    }
 return "ist Teilmenge";
}    



     
void Set::insert(int Element)
{
  if(Feldgr==anzelemente or Menge==0)
  {
  this->resize(1);
  }
  Menge[Feldgr-1]=Element;
  ++anzelemente;
  
}




void Set::makeUnion(Set& Mengex) 
{
 this->resize(Mengex.anzelemente);
 anzelemente = Feldgr;
  for(int i=0;i<Mengex.Feldgr;++i)
    {
     this->insert(Mengex.Menge[i]);
     }
 
 }

 
 
 
void Set::intersect(Set& Mengex)
{
 Set Help;
 for(int i=0;i<Feldgr;++i)
   {
    for(int j=0;j<Mengex.Feldgr;++j)
      {
       if(Menge[i]==Mengex.Menge[j])
        {
	  Help.insert(Menge[i]);
	}
       }
     }
  delete[] Menge;
  Feldgr=0;
  anzelemente=0;
  Menge = new int[1];
    for(int i = 0 ; i <Help.Feldgr; ++i)
    {
     this->insert(Help.Menge[i]);
    } 
}




void Set::print()
{
 cout << endl;
 for(int i=0 ; i<Feldgr ; ++i)
  {
  cout << Menge[i] <<" ";
  }
}

//private   
void Set::resize(int anzahl)
{
  Feldgr =  Feldgr + anzahl;
  int *hilfmenge= new int[Feldgr];
  for(int i = 0 ; i < (Feldgr-anzahl); ++i)
    {
     hilfmenge[i]=Menge[i];
    }
  delete []Menge;
  Menge=hilfmenge ;
  
 }
 
 
//-----------------------------------------------------------------------

// mainAufgabe1.cpp
// Hauptprogramm zu Aufgabe1
//
// O.Bittel; 21.9.04
//

// HINWEIS:
// Die Reihenfolge der Elemente zwischen Soll- und Ist-Ausgabe
// darf selbstverst&#65533;dlich unterschiedlich sein.
// Beispielsweise w&#65533;e folgende Ausgabe korrekt:
// Soll: {   1,   2,   3}
// Ist:  {   3,   1,   2}


#include <iostream>
#include "set.h"

using namespace std;

int main()
{
	// Menge m1:
	Set m1;
	m1.insert(1);
	m1.insert(2);
	m1.insert(3);
	cout << "Soll: {   1,   2,   3}" << endl;
	cout << "Ist:  "; m1.print();
	cout << endl;


	// Menge m2:
	Set m2;
	m2.insert(2);
	m2.insert(4);
	m2.insert(2);
	cout << "Soll: {   2,   4}" << endl;
	cout << "Ist:  "; m2.print();
	cout << endl;


	// Menge m3:
	Set m3=m2;
	m3.insert(3);
	cout << "Soll: {   2,   3,   4}" << endl;
	cout << "Ist:  "; m3.print();
	cout << endl;


	// Menge m4:
	Set m4;
        m4.insert(2);
	m4.insert(3);
	m4.insert(7);
	cout << "Soll: {   2,   3,   7}" << endl;
	cout << "Ist:  "; m4.print();
	cout << endl;


	// isElement:

//--------------------------------------------------------------------------------

# File: Makefile fuer Aufgabe1
# Author: Oliver Bittel
# Date: 6.2.2003

# Definitions:
CC = g++ -g   # -g wird nur fuer Debugger benoetigt!
OBJ =set.o mainAufgabe1.o 
BIN = aufg1

# Rules:
$(BIN): $(OBJ)
	$(CC) -o $(BIN) $(OBJ)

	set.o: set.cpp set.h
	$(CC) -c set.cpp	
	
mainAufgabe1.o: mainAufgabe1.cpp set.h
	$(CC) -c mainAufgabe1.cpp