Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » variable Mengen in C++

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: [ 1 ] [ 2 ] [ 3 ] > 4 < [ 5 ]
030
14.07.2003, 19:37 Uhr
0xdeadbeef
Gott
(Operator)


Wenn ich ne verkettete Liste will, geht das ganz einfach so:

C++:
#include <list>


Ich finde das recht einfach...aber, ach ja, du magst die STL ja nicht
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
031
14.07.2003, 19:49 Uhr
Oliver
S2-Pixelgeneral


Wenns so einfach wäre...
Aber da kommt ja noch Code hinzu .
--
Demokratie ist die Diktatur der Mehrheit.

www.siedler25.org/ ( Siedler2 - Remake )
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
032
14.07.2003, 20:23 Uhr
~Jerome83
Gast


ich will das so machen: ein objekt der klasse menge soll aus mehreren objekten der klasse knoten betehen.

ein objekt knoten enthält die zahl im infoteil und den verweis auf das nächste objekt vom typ knoten (also der nachfolger). damit entsteht ne einfach verkettete liste!

deswegen die schachtelung...


jetzt will ich den = operator überladen um damit dann ein objekt vom typ knoten an ein objekt vom typ menge anzuhängen.

zum Beispiel:
<Menge> = <Menge> + <Knoten>
also:
menge1 = menge1 + Menge(2) //2 soll die Zahl sein die in die Menge angehängt wird.

Beispiel dazu:
alte Menge: {1,2,3}
dazu soll die 5 kommen, also resultiert dann: [1,2,3,5}

wißt ihr jetzt wie ich das meine???
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
033
15.07.2003, 09:30 Uhr
Oliver
S2-Pixelgeneral


Schön und gut, aber ich versteh nicht, warum du plötzlich ne verkettete Liste nimmst, ein Array (wie bei mir) hätte es auch getan.
Das ist doch dann alles nur noch mehr Arbeit und noch mehr Frust. Ob du nun noch 20 Klassen schreibst ist im Endeffekt auch egal.
Ich kann mich auch irren, weil verkettete Listen nicht so richtig verstehe (werd ich mir nochmal angucken müssen).

Und hast du überhaupt schon den + operator überladen?
--
Demokratie ist die Diktatur der Mehrheit.

www.siedler25.org/ ( Siedler2 - Remake )
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
034
15.07.2003, 09:46 Uhr
ao

(Operator)


@Jerome:
Wenn du bisher nicht weißt, wie verkettete Listen überhaupt funktionieren und programmiert werden, dann mach doch erst mal Schritt für Schritt die Grundfunktionen (Add, Find, Remove, CountElements), bevor du dich in geschachtelte Klassen und überladene Operatoren versteigst.

Google mal nach "verkettete Liste" oder "linked list", du wirst staunen, wie viel Material du findest.

ao
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
035
15.07.2003, 09:48 Uhr
ao

(Operator)



Zitat:
Oliver Müller postete
Schön und gut, aber ich versteh nicht, warum du plötzlich ne verkettete Liste nimmst, ein Array (wie bei mir) hätte es auch getan.


Er braucht eine Liste, wenn er zur Laufzeit neue Elemente hinzufügen will. Klar kann man auch realloc verwenden, aber das scheint wohl nicht das Ziel der Aufgabe zu sein.

ao
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
036
15.07.2003, 12:00 Uhr
0xdeadbeef
Gott
(Operator)


Wenn du schon ne verkettete Liste selbst coden willst, dann wenigstens mit Stil. Das bedeutet: Doppelt verkettete Dummy-Liste, etwa so:

C++:
class IntListNode {
friend class IntList;

private:
    int cnt;
    IntListNode *prev, *next;

    IntListNode() : prev(this), next(this), cnt(0) { }
    IntListNode(int newcnt, IntListNode *newnext) : cnt(newcnt), next(newnext) {
        if(!next || !next.prev) throw newnext;
        prev = next.prev;
        next.prev = prev.next = this;
    }
};

class IntList {
private:
    IntListNode *head_dummy, *tail_dummy;
    int size;

public:
    IntList() : head(IntListNode()), tail(IntListNode()), size(0) {
        head_dummy.next = tail_dummy; //dummys initialisieren
        tail_dummy.prev = head_dummy;
    }

    void append(int i) { IntListNode(i, tail_dummy); ++size; }
    void insert(int i, int pos) {
        IntListNode *ptr = head_dummy;
        while(pos-- > 0) ptr = ptr.next; //wenn ptr bei tail ankommt, ist ptr.next == ptr
        IntListNode(i, ptr.next);
        ++size;
    }

    //und so weiter.
};


--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 15.07.2003 um 12:00 Uhr von 0xdeadbeef editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
037
15.07.2003, 14:03 Uhr
~Jerome83
Gast


hab mich mal damit versucht eine methode zu programmieren:



C++:
#include <iostream.h>
#include <string.h>

class Menge {
  public:
    Menge ();              // leere Menge
    Menge (int);           // einelementige Menge
    Menge (const Menge &); // Kopierkonstruktor
    ~Menge ();             // Destruktor

    Menge &Menge::operator += (const Menge &menge);       // Zuweisung
    Menge   operator +   (const Menge &) const; // Vereinigung
    Menge   operator *   (const Menge &) const; // Schnitt
    
    bool Menge::add(int data);

  private:
    class Knoten {
    public:
      Knoten   ();
      Knoten   (int, Knoten *);
      ~Knoten  ();
      int      wert;
      Knoten * n;
    };
    Knoten *anfang;  // Start der verketteten Knoten
                     //... eventuelle Hilfsroutinen ...
  };


bool Menge::add(int wert)
    {
       Knoten *k, *prev = NULL;

       for(k = anfang; k != NULL && k->wert < wert; k = k->n)
       {
          prev = k;
       }
  
       if(k != NULL && k->wert == wert)
       {
          return false;
       }
      
       else
       {
          Knoten *k = new Knoten(wert, k);
          if(k == anfang)
          {
             anfang = new Knoten;
          }
          else
          {
             prev->n = new Knoten;
          }
          return true;
       }
    }

Menge &Menge::operator += (const Menge &menge) {
   for(Knoten *k = anfang; k != NULL; k = k->n) {
      add(k->wert);
   }
}    

void main (void)
{


};




aber einen fehler gibt es noch:


C++:
Knoten *k = new Knoten(wert, k);



er erstellt ein neues Objekt vom Typ Knoten. und dazu gehört ja der infoteil (wert) und der zeiger auf den nachfolger (n). WAS HAB ICH FALSCH GEMACHT???

Dieser Post wurde am 15.07.2003 um 14:19 Uhr von virtual editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
038
15.07.2003, 14:04 Uhr
~Jerome83
Gast


die blöden smilies, kann man die irgendwie ausschalten?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
039
15.07.2003, 14:19 Uhr
virtual
Sexiest Bit alive
(Operator)


@Jerome: Bei posten das Häckchen deaktivieren, welches die Smilies aktiviert.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: [ 1 ] [ 2 ] [ 3 ] > 4 < [ 5 ]     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: