nach intensiver Suche im Forum wende ich mich nun so an euch.
Ich probiere mich nun schon einige Zeit schon an dieser verketteten Liste und es klappt, meiner Meinung nach, auch ganz gut, nur leider schaffe ich die Ausgabe Asgabe oder Anhängefunktion nicht.

Wenn es zur Ausgabe kommt wird immer nur das erste und letzte Element ausgegeben und ich weiß einfach nicht mehr weiter.
Ich hatte in den letzten Tagen immer noch die Hoffnunf selber auf das Problem zu stoßen aber leider war dem nicht so, auch Texteingaben und das ausgeben der Speicheradressen hat mir nicht weiter geholfen.

Ich hätte die Bitte, dass mir ein Wissender helfen kann und mir sagen kann wo ich meinen Denkfehler habe.

Ich würde mich wirklich freuen
Mit besten Grüßen

saunaaa

#include <iostream>

class orttyp
{
private:
   int zahl;

public:
	orttyp *next;
	void setze_zahl(int);
	int hole_zahl(void) const;
	orttyp(int z=0):zahl(z){};
};
//----------------------------------------------------

   void orttyp::setze_zahl(int i)
   {
       zahl=i;
   };
   int orttyp::hole_zahl(void) const
   {
       return zahl;
   };
//----------------------------------------------------
   void belege (orttyp*ort)
   {
       int zahl;
  std::cout << "Zahl: ";
  std::cin >> zahl;
       ort->setze_zahl(zahl);
       ort->next=NULL;
   };

   orttyp* create (void)
   {
       orttyp* ort = new(orttyp);
       belege(ort);
	   ort->next=NULL;
       return ort;
   };

   void anhaengen(orttyp*ort)
   {
       orttyp *neu_ort = new(orttyp);
       belege(neu_ort);

       ort->next=neu_ort;
	   ort=ort->next;
   };

   void alle_ausgeben(orttyp*anker)
   {
       orttyp *tmp=anker;

       while(tmp!=NULL)
       {
           std::cout<<tmp->hole_zahl();
           tmp = tmp->next;
       };
   };

//----------------------------------------------------
int main()
{
   orttyp *ort,*anker;

   ort = anker = create();

   anhaengen(ort);
   anhaengen(ort);
   anhaengen(ort);
   anhaengen(ort);
   anhaengen(ort);
   anhaengen(ort);
   ort=anker;
   alle_ausgeben(ort);
};

Diese Mischung aus C++ und C...

Gutes Gelingen!

Du hängst immer an den selben (ersten) Knoten an.
Kannst Du nicht Teile von create() in anhaengen() benutzen?

Gutes Gelingen!

Ich dachte dadurch, dass ich ort=ort->next; schreibe, setze ich das Zeigerobjekt an das ich anhänge eins weiter.
Damit würde ich doch eigentlich nicht an das ursprüngliche, sondern an das neue Objekt anhängen, oder?

vielen Dank für deine Hilfe

void anhaengen(orttyp*ort)
   {
       orttyp *neu_ort = new(orttyp);
       belege(neu_ort);

       ort->next=neu_ort;
       ort=ort->next;
   };

Furble Wurble schrieb:

Du hängst immer an den selben (ersten) Knoten an.
Kannst Du nicht Teile von create() in anhaengen() benutzen?

Gutes Gelingen!

Ich dachte dadurch, dass ich ort=ort->next; schreibe, setze ich das Zeigerobjekt an das ich anhänge eins weiter.
Damit würde ich doch eigentlich nicht an das ursprüngliche, sondern an das neue Objekt anhängen, oder?

Du veränderst nur die lokale Kopie des Zeigers. Wenn Du das Original verändern willst, koenntest Du z.B. eine Referenz übergeben.

void anhaengen(orttyp*& ort)
   {
     orttyp *neu_ort = create();
     ort->next=neu_ort;
     ort=ort->next;
   }

Aktivier auch die Warnungen in Deinem Compiler: z.B. braucht es kein ';' hinter Funktionsdefinitionen.

orttyp* anhaengen(orttyp* ort)
{
    return ort->next = create();
}

Dann könnte man immer noch

ptr = anhaengen(ptr);

schreiben. Aber

anhaengen(ptr);

Da würde ich nie und nimmer erwarten, dass ptr verändert wird.

Edit:

orttyp *neu_ort = create(); 
     ort->next=neu_ort; 
     ort=ort->next;

ort = ort->next = create();

~Edit²: Jetzt Frage ich mich: Ist obige Zeile UB?~