struct Element
{
string name ;
int nummer ;
Element * next ; // Zeiger auf nächstes Element
};

Ausgabe wäre dann:

/name/nummer/next/ ->

Mein Problem liegt jedoch etwas hier. Aufbau einer verketteten Liste mit zwei Elementen:

Element * anfang = new Element ; //Zeiger auf Anfangselement,warum das new? 
anfang -> name = " Peter Meier "; // Anfangselement enthält bzw. zeigt auf name
anfang -> numer = 230001; //Anfangselement enthält bzw. zeigt auf nummer
anfang -> next = NULL ; //Endet ohne auf ein anderes Element zu zeigen

Element * zweites = new Element ; //Zeiger auf Zweiteselementn warum das new? Und müsste es nicht Element2 aluten also ungleich der Name beim anfang?
zweites -> name = " Gabi Schmidt "; //Zweiteselement enthält bzw. zeigt auf name
zweites -> nummer = 231102;//Zweiteselement enthält bzw. zeigt auf nummer
anfang -> next = NULL ; //Endet ohne aiuf ein weiteres Element zu zeigen

anfang -> next = zweites ; //Verkettung 1.und 2. Element - Element 1 zeigt auf 2 Element

So ich bin mir da noch unsicher. Wieso das new ? Und warum heißen beide Elemente gleich? Besser wäre es zwei verschiedene Namen zu haben oder? So sollte es dann aussehen:

ANFANGSELEMENT ZWEITESELEMENT
/name/nummer/next-> /NAME/NUMMER/NEXT

Und der Befehl -> sagt aus welche Werte im Element sind oder nicht zu verwechseln mit next-> welches bei der Ausgabe darstellen soll, dass es auf das nächste Element zeigt?

Ich freue mich über jede Antwort!

Wieso das new ? Und warum heißen beide Elemente gleich? Besser wäre es zwei verschiedene Namen zu haben oder?

In diesem Fall kannst Du das new auch weglassen (streng genommen ist das sogar besser). Es muss dann aber das '->' durch '.' ersetzt werden.
Allgemein erzeugt man solche Objekte aber auf dem Heap (also mit new ), weil Du sie dann mit einem einzigen Pointer 'herum reichen' kannst.

Die beiden Elemente haben verschieden Namen. Das erste heißt ' anfang ' und das zweite ' zweites ' (siehe Dein Code).

ZetaGamma schrieb:

So sollte es dann aussehen:

ANFANGSELEMENT ZWEITESELEMENT
/name/nummer/next-> /NAME/NUMMER/NEXT

Ist das die Ausgabe? dann zeige mal den Code.

Es sollte in Richtung http://media.virtual-maxim.de/uploads/2010/06/liste_einfachverkettet.png gehen.

Ich denke ich habe es aber endlich fast verstanden, weil mir gerade etwas eingefallen ist was ich davor falsch interpretiert hatte. Folgende zwei Codes hängen beieinander bzw. fest zusammen oder? Es geht nämlich um den Code zu 100% zu verstehen.

struct Element
{
string name ;
int nummer ;
Element * next ; // Zeiger auf nächstes Element
};

Element * anfang = new Element
.... // Hier stehen die Daten der Liste mithilfe anfang -> Datenname
anfang -> next = NULL

Element * zweites = new Element ; 
..... // Hier stehen die Daten der Liste mithilfe zweites -> Datenname
anfang -> next = NULL ;

anfang -> next = zweites ;

// Anfang zeigt auf nächstes Element mit Namen ,,zweites"

Wie würde denn alles nun ,,zeichnerisch" als Verkette Liste aussehen, also wie bei http://media.virtual-maxim.de/uploads/2010/06/liste_einfachverkettet.png

Und jetzt könnte ich zb. eine Liste mithilfe

{
struct Person { //struct: Datenspeicher in selbstgewählter Form
string name;
int alter;

};

z.b.
Person peter;
peter.name = "peter";
peter.alter = 32;

erstellen oder?

zweites  -> next = NULL;

sein.

struct Element
{
string name ;
int nummer ;
Element * next ; // Zeiger auf nächstes Element
};

Element * anfang = new Element ;
anfang -> name = " Peter Meier ";
anfang -> numer = 230001;
anfang -> next = NULL ;

Element * zweites = new Element ;
zweites -> name = " Gabi Schmidt ";
zweites -> nummer = 231102;
anfang -> next = NULL ; // Hier muss es zweites -> next = NULL 100% lauten ?

anfang -> next = zweites ;

Das Skript wird als Stütze genutzt nicht nur als Quelle.

Es geht um C++, also heißt es zweites -> next = NULL und dort hat sich also ein Fehler unterlaufen ?

Das Skript wird als Stütze genutzt nicht nur als Quelle.

Ich sehe nicht in dem Fehler ein Problem, sondern in der Art und Weise wie eine verkettete Liste erklärt wird.

Vorher solltest Du Dich mit Konstruktor und Destruktor auskennen - das ist viel wichtiger.
Dann sähe Dein Element so aus:

struct Element
{
    Element() : name(), nummer(-1), next(NULL) {}
    Element( const std::string& n, int nr ) 
        : name(n), nummer(nr), next(NULL) 
    {}
    // Member
    std::string name;
    int nummer;
    Element* next; // Zeiger auf nächstes Element
};

und der Code wäre viel einfacher:

Element anfang( " Peter Meier ", 230001 );
    Element zwei( " Gabi Schmidt ", 231102 );
    anfang.next = &zwei;

.. oder meinetwegen auch mit Zeigern

Und last but not least - eine Liste wäre eine Liste also eine Klasse:

class Liste
{
    struct Element
    {
        Element() : name(), nummer(-1), next(NULL) {}
        Element( const std::string& n, int nr ) 
            : name(n), nummer(nr), next(NULL) 
        {}
        // Member
        std::string name;
        int nummer;
        Element* next; // Zeiger auf nächstes Element
    };
public: 
    Liste();
    // ... weitere Methoden
private:
    Element* anfang; // Zeiger auf das erste Element
};