listen_einfuegen

hallo,
ich erzeuge ein liste und fuege integer zahlen ein (am anfang)! diese funktion hab ich schon, jetzt moechte ich die zahlen hinten einfuegen! da komme ich nicht weiter....kann mir wer helfen!?

class Liste
{
      private:
              struct elem
              {
                     int inhalt;
                     struct elem *weiter;
              } *anfang;

      public:
             Liste();
             ~Liste();
             void einfuegen_anfang(int x);
             void einfuegen_ende(int x);
             void ausgabe();
             int suchen(int x);
             int loeschen(int x);
};

Liste::Liste()
{
   anfang = NULL;
};

Liste::~Liste()
{
   elem *hilf = anfang;
   while(anfang)
   {
      elem *hilf1 = hilf->weiter;
      free(hilf);
      hilf = hilf1;
   }
}

void Liste::einfuegen_anfang(int x)
{
   elem *hilf = (elem*)malloc(sizeof(elem));
   hilf->inhalt = x;
   hilf->weiter = anfang;
   anfang = hilf;
}

void Liste::einfuegen_ende(int x)
{
   //* hier stecke ich??
}

void Liste::ausgabe()
{
   elem *hilf = anfang;
   while(hilf)
   {
      printf("%d ", hilf->inhalt);
      hilf = hilf->weiter;
   }
}

int main(int argc, char *argv[]){

    Liste Daten;

    Daten.einfuegen_anfang(23);
    Daten.einfuegen_anfang(24);
    Daten.einfuegen_anfang(25);
    Daten.einfuegen_anfang(26);

    Daten.ausgabe();
    //* derzeitige ausgabe lautet: 26 25 24 23
    //* moechte aber diese ausgabe: 23 24 25 26 

    system("PAUSE");
    return EXIT_SUCCESS;
}

mfg

drakon

Benutzt ganz einfach std::list..

Aber zu deinem Problem.
Du fängst ganz gwöhnlich an bei dem ersten Element und iterierst einach bis zum letzten Element und füllst dann hinter das Element ein neues an. Alternativ kannst du auch einen Zeiger auf das letzte Element speichern und dann sparst du dir das raufzählen.

Was mir so beim Überfliegen aufgefallen ist:
Im Destruktor soll das doch bestimmt while(hilf) heißen, statt while(anfang).

ja hast recht soll "hilf" heißen

mit std::list hab ich noch nie gearbeitet und benuetzen darf ich es warscheinlich auch nicht!!
aber wie wuerde das funktionieren mit std::list!?

danke fuer die gedankenanstoß =)!!

mfg

habs mal probiert, aber er gibt mir mit meiner methode ausgabe nichts aus!!!

void Liste::einfuegen_e(int x)
{
   elem *hilf = anfang;
   while(hilf)
   {
      hilf = hilf->weiter;
   }
   elem *hilf2 = (elem*)malloc(sizeof(elem));
   hilf2->inhalt = x;
   hilf2->weiter = anfang;
   hilf = hilf2;     
   printf("%d " hilf2->inhalt); 
//*hier gibt er mir die zahlen ein, also er fuegt sie ein, aber dann wenn ich die methode ausgabe aufrufe gibt er mir nichts aus!?
}

Krux

Naja, deine Schleife mit hilf läuft so lange weiter, bis du hinten rausgeflogen bist, vieleicht solltest du vorher anhalten.

hilf = hilf2;

mit dieser anweisung änderst du rein garnichts in deriner Datenstruktur, du setzt blos die lokal existierende Adresse hilf auf die von hilf2. Die Adresse, die in der Liste ist wird dadurch nicht geändert.