Operatoren Überladen in Ringverketteter Liste

[Mr. Blonde]

Hallo, ich hab da ein Problem mit dem Überladen von Operatoren in einer Ringverketteten Liste ...

Und zwar entsteht eine Endlosschleife, wenn ich Listen vereinen möchte ...

dekl.h

#include <iostream>
#include <conio.h>

class Kset
{
private:
        struct Knoten
        {
         Knoten *pNext;
         int Inhalt;
        };

        Knoten *pFirst;
        int Anzahl;

public:
        Kset();
        Kset(const Kset & obj);
        Kset(const int *obj, const int Array);
        Kset &Kset::verein(const Kset &obj );
        ~Kset();

        void insert_front(int obj);
        Kset& operator =(const Kset& alt);
        friend Kset & operator + (Kset& x, Kset& y);
};

impl:

//Konstruktor///////////////////////////////////////////////////////////////////

Kset::Kset()
{
 Anzahl = 0;
 pFirst = NULL;
}

//Dekonstruktor/////////////////////////////////////////////////////////////////

Kset::~Kset()
{
 Knoten *ptemp = pFirst;
 for(; Anzahl>0;)
 {
  pFirst = pFirst->pNext;
  delete ptemp;
  ptemp = pFirst;
  Anzahl--;
 }
}

//Kopierkonstruktor/////////////////////////////////////////////////////////////

Kset::Kset(const Kset &obj)
{
 this->Anzahl = 0;
 this->pFirst = NULL;
 Knoten *pTemp = obj.pFirst;
 for(int anz = obj.Anzahl; anz != 0; anz--)
  {
   this->insert_front(pTemp->Inhalt);
   pTemp = pTemp->pNext;
  }
}

//Kopierkonstruktor für Feld in statische Groeße////////////////////////////////

Kset::Kset(const int *obj, const int Array)
{
 this->Anzahl = 0;
 this->pFirst = NULL;

 this->push_array(obj, Array);
}

//Vereinigung zweier Mengen/////////////////////////////////////////////////////

Kset &Kset::verein( const Kset &obj )
{
    Knoten *ptemp = obj.pFirst;

    for ( ; ptemp; ptemp = ptemp->pNext )
        insert_front( ptemp->Inhalt ); //*this wird geändert

    return *this; // Referenz auf this zurückgeben
}

//Insert Front//////////////////////////////////////////////////////////////////

void Kset::insert_front(int obj)
{
 if(Anzahl == 0)
 {
  pFirst = new Knoten;
  pFirst->Inhalt = obj;
  pFirst->pNext = pFirst;
 }
 else
 {
  Knoten *pNew = new Knoten;
  Knoten *pTemp = pFirst;
  pNew->Inhalt = obj;
  pNew->pNext = pFirst;
  while(pTemp->pNext != pFirst)
  {
   pTemp = pTemp->pNext;
  }
  pTemp->pNext = pNew;
  pFirst = pNew;
 }
Anzahl++;
}

//+ Operator überladen um Mengen zu vereinen////////////////////////////////////

Kset& operator + (Kset& x, Kset& y)
{
 return x.verein(y);
} 

//= Operator überladen /////////////////////////////////////////////////////////

Kset &Kset::operator=(const Kset& alt)
{
 if(&alt == this) return *this;
 else
 {
  for(Knoten* pTemp=alt.pFirst; pTemp != pFirst; pTemp=pTemp->pNext)
  {
   (*this).insert_back(pTemp->Inhalt);
  }
 }
return *this;
}

main

#include "deklh.h"

#pragma hdrstop

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

#pragma argsused
int main(int argc, char* argv[])
{
        Kset k;

        k.insert_front(1);
        k.insert_front(2);
        k.insert_front(3);
        k.insert_front(4);

        Kset k1;

        k1.insert_front(99);

        Kset k3;

        k1=k;

        getch();
        return 0;
}
//---------------------------------------------------------------------------

Woran liegt das?

[camper]

solche tippfehler sind leicht zu übersehen:

for(Knoten* pTemp=alt.pFirst; pTemp != [b]alt.[/b]pFirst; pTemp=pTemp->pNext)

ob das so eine gute idee ist, operator= für diesen zweck zu (miss-)brauchen?

ein kleiner hinweis: eine friend deklaration führt dkeinen namen in den umliegenden namespace ein. ein aufruf des + operators wird diesen nicht finden - dazu muss dieser zusätzlich noch ausserhalb der klasse deklariert werden.

[Mr. Blonde]

danke

hab das jetzt abgeändert ... aber klappen will es nicht...

wenn ich k3 = k schreibe, bleibt k3 trotzdem leer ...

[camper]

Mr. Blonde schrieb:

danke

hab das jetzt abgeändert ... aber klappen will es nicht...

wenn ich k3 = k schreibe, bleibt k3 trotzdem leer ...

mein vorschlag war war ja auch unsinn. ist ja klar, dass die schleife nie ausgeführt werden kann. du könntest anzahl ins spiel bringen:

int anzahl = alt.Anzahl;
for(Knoten* pTemp=alt.pFirst; anzahl--; pTemp=pTemp->pNext)

dein problem ist, dass deine ringverkette liste nicht grundsätzlich wenigstens ein element enthält. damit geht der vorteil im grunde verloren. der algorithmus wäre einfacher, wenn das letzte element einfach auf nichts verweisen würde (also Next == 0)

[Mr. Blonde]

okay ... *brettvormkopfentfernt* ^^

danke