verkettete Listen

Piesbruhder

Mitglied
Tja, ich bins mal wieder mit einer Frage zu C++ Grundlagen. Es
geht um verkettete Listen *händeÜberDemKopfZusammenschlag*.
Dank Homer habe ich jetzt schon richtig kapiert was so eine Liste
ist und wie sie vom Prinzip her funktioniert. Aber wie
deklariert (oder wie auch immer das bei Listen heißt) man die?
In meinem Buch ist natürlich ein Beispiel, aber irgendwie macht mir
das mächtige Probleme! Das liegt zum Teil daran, dass ich das
was man immer ändern kann (quasi der Name der List) und die Befehle
die immer gleich sind nicht auseinander halten kann. Also gebt, wenn ihr
was schreibt der Liste einen Namen, der ekelhaft heraus sticht.
Das wäre sehr nett. Sowas wie Brot oder so.
<hoffentlich hat das jemand verstanden was ich meine>
Hier der Beispielcode aus meinem Buch (!AchtungLang!)


// Datei: XXXLIst.h
//DEFINITIONEN///////////////////////////////////////
typedef struct xxxListItem {
void *data;
struct xxxListItem *next;
} XXXList;
#define XXX_Result int
#define XXX_OK 0
#define XXX_MEMORY_ERROR 1
#define XXX_OUT_OF_BOUNDS 2

//MAKROS/////////////////////////////////////////////
//keine

//PROTOTYPEN/////////////////////////////////////////
XXX_RESULT xxx_List_Create(XXXList **pp_list);
XXX_RESLUT xxx_List_Insert(XXXList **pp_list, void *p_data);
XXX_RESLUT xxx_List_Insert(XXXList **pp_list, int index);
int xxx_List_Length(XXXList *p_list);
void xxx_List_Show(XXXList *p_list);

-------------------------------------------------------

//Datei: XXXList.cpp
//INCLUDES////////////////////////////////////////////
//INCLUDES////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <"XXXList.h">

//GLOBALES////////////////////////////////////////////
// nichts
//FUNCTIONS///////////////////////////////////////////
//Startfunktion zu Testzwecken
//Diese Fu ktion erzeugt eine Liste, fügt ein paarchar Daten ein
//und löscht wieder ein Element.
void main (void)
{
//Erstes Element der Liste erzeugen
XXXList *pListe;

if (xxx_List_Insert(&pListe) !=XXX_OK)
printf ("Fehler bei der Initialisirung der Liste. \n");

if (xxx_List_Insert(&pListe, (void *)'e') != XXX_OK)
printf ("Fehler beim einfügen in die Liste. \n");
if (xxx_List_Insert(&pListe, (void *)'d') != XXX_OK)
printf ("Fehler beim einfügen in die Liste. \n");
if (xxx_List_Insert(&pListe, (void *)'c') != XXX_OK)
printf ("Fehler beim einfügen in die Liste. \n");
if (xxx_List_Insert(&pListe, (void *)'b') != XXX_OK)
printf ("Fehler beim einfügen in die Liste. \n");
if (xxx_List_Insert(&pListe, (void *)'a') != XXX_OK)
printf ("Fehler beim einfügen in die Liste. \n");

printf ("\n Zeige Liste:\n");

xxx_List_Show(pListe);

if (xxx_List_Delete(&pListe, 2) != XXX_OK)
printf("Fehler beim Loeschen aus der Liste:\n")
xxx_List_Show(pListe);
} // main

// Liste erzeugen mit RAM Initialisierung
XXX_RESULT xxx_List_Insert(XXXList **pp_list)
{
//siehe oben
{

// Einfügen am Anfang der Liste
XXX_RESULT xxx_List_Insert(XXXList **pp_list, void *p_data)
{
//siehe oben
}

// Löschen an angegebener Psoition, Start bei Index 0
XXX_RESULT xxx_List_Insert(XXXList **pp_list, void *p_data)
{
//siehe oben
}

//Länge der Liste
int xxx_List_Length(XXXList *p_list)
{
//siehe oben
}

//Angabe der Liste zu Testzwecken
void xxx_List_Show(XXXList *p_list)
{
//siehe oben
}

Sooo! Man verzeihe mir die vielen Tippfehler. Aber wenn das eine(r)
ausführlich erklären könnte, wäre das was für die Ewigkeit.
Wenn nicht versteh ich das. Ihr habt ja auch noch anderes zu tun.

Freu mich über jede Antwort!

Bye!
 
Zuletzt bearbeitet:
@ Piesbruhder

So also, zurück zu den verketteten Listen, ich hab mir das Programm oben nicht angeschaut, und will es auch nicht, da es etwas unverständlich ist. Aber ich füge ein eigenes Programm bei, bzw nur die .cpp und .h Dateien. Compilieren kannst du selbst *g*
Ich hab jetzt gerade fast eine Stunde gebraucht um das Programm zu kommentieren, da es keinerlei Kommentare enthielt. Also betrachte es mit Würde *g*.
Aber ich denke du wirst es danach verstanden haben.
Da du dich mit verketteten Listen befasst, denke ich mal, daß du mit den Grundlagen von C++ vertraut bist und mit Klassen und Strukturen umgehen kannst. *g* Deshalb bin ich auch beim Kommentieren nicht näher auf die Sprache C++ eingegangen sonder hab nur die Funktionalität beschrieben.
So na dann viel Spaß damit.
 

Anhänge

  • verkettete_liste.zip
    4,8 KB · Aufrufe: 1.704
Danke :| !
Vielen Dank!

Damit hast du mir echt geholfen! Das is ja eigentlich gar
nicht so schwer wenn man sich mal fünf Minuten vor dein
Programm setzt und ein bissel die Birne anstrengt. :rolleyes:

Da frag ich mich aber doch noch eins: In meinen Beispielprogramm
tauchen manchmal ** auf (zwei?). Das hat mich am meisten verwirrt. Aber im
großen und ganzen machen die Programme ja das selbe. In deinem
steht aber nicht so eine Fehlerpberprüfung wie in meinem. Aber die
ist ja optional, denk ich mal.

Und was ich auch mal fragen wollte: macht es einen unterschied ob
ich jetzt printf wie früher oder cout benutze?

Aber echt! Danke! :D

Bye!
 
printf() ist eine CRT-Funktion (d.h C).
std::cout ist ein iostream -> C++

std::cout ist außerdem universeller und einfacher.

Pointer-auf-Pointer kommen manchmal vor, allerdings hab ich selten jemanden gesehn der sie in verketteten Listen verwendet?

Um die Kritik weiterzuführen: Das Beispiel das du gegeben hast ist in C, und das ist ziemlich blöd handzuhaben, halt dich besser an das Beispiel von homer oder die STL.

Ahja... kann es sein, dass das ein Zerbst-Beispiel ist? (AFAIK verwendet niemand sonst derart sinnlose Variablen-Präfixe oder noch immer C für Listen usw. :))
 
Du hasts erfasst! Er sagt ja selber, dass er einen
eigensinnigen Stil hat. Deshalb vergleich ich auch
gerne mit anderen Beispielen(was ich ja hier gemacht hab)

---

Also kann man sagen cout ist besser, oder?
 
Hmm, wenn du C++ programmierst solltest du cout verwenden (bzw. allgemein möglichst C++-Funktionalitä C-Funktionen vorziehen),
in C printf().

Bei den meisten Implementierungen ist printf() marginal schneller, was aber im Normalfall nicht auffällt, und hat dafür keine Typ-Sicherheit od. Erweiterbarkeit.
 
Hallo Leute
Sorry, wen ich ein altes Thema neu aufwühle. Ich hab das selbe Problem wie Piesbruhder es gehabt hat... nur bräuchte ich es diesmal in C, nicht C++
Wäre froh, wenn sich noch mal jemand die Mühe machen würde, dasselbe in C zu erklären.

PS: :google: hab ich verwendet, darum bin ich auch auf dieses Thema gekommen...

Es grüsst:
dfd1 -> the only one
 
Im Beispiel oben kann ich auf Anhieb keinen C++ typischen Code erkennen, da ja auch nur Strukturen und keine Klassen verwendet werden. Eventuell funktioniert das mit den Prototypen so nicht, schreibe die richtigen Funktionen dann an die Stelle wo die Prototypen aufgelistet sind!

Ansonsten wurde neulich gerade erst über verkettete Listen gepostet (http://www.tutorials.de/tutorials111781.html)
 
Das was Piesbruhder gepostet hat, ist schon C... Kannst du es mir erklären??

Mit C++ mein ich das von Homer, welches sehr gut komentiert ist. Aber leider in C++ geschrieben.
 
Zurück