Hallo, ich bin gerade dabei eine verkettete Liste mit C zu realisieren. Die Funktion einfügen funktion ohne Probleme. Nur wenn ich die Funktion ausgabe ausführe stürtz mein Programm ab! Wo kann da der Fehler sein?
bei sowas würd ich sagen access violation... hzgr ->text1 = (char*)malloc(sizeof(struct telement)); hzgr ->text2 = (char*)malloc(sizeof(struct telement)); das schaut mir nicht richtig aus.. du kopierst 100bytes drüber aber telement hat sicher keine 100bytes.. probier hier mal ein malloc(strlen(a)+1) bzw malloc(strlen(b)+1) aus... sonnst endwanz das mal.. es kracht garantiert beim einhängen wenn ich das richtig sehe... 73
@Hans: beim einhängen? Meinten Sie: beim anhängen? @F.Keilbach: > ich bin gerade dabei eine verkettete Liste mit C zu realisieren. Warum hat dein Sourcefile dann die Endung .cpp? Die ist eher für C++-Programme üblich, und einige Compiler werden bei dieser Endung automatisch in den C++-Modus umschalten. > Die Funktion einfügen funktion ohne Probleme. Nur wenn ich die > Funktion ausgabe ausführe stürtz mein Programm ab! Wo kann da der > Fehler sein? Ich denke auch, daß es daran liegt, daß du für die Strings die falsche Größe allokierst. Was sollte sizeof(struct telement) mit der Länge der Strings zu tun haben? Hier noch ein paar andere Sachen, die mir aufgefallen sind: Lasse die Casts bei malloc weg. Die bringen keinen Vorteil, können aber machmal einen Fehler verdecken. Wenn dein Compiler meckert -> Als C compilieren. In loeschen wird nur der Speicher des telement-Objekts gelöscht, nicht der der beiden Strings. Warum wird in main anker->zeiger die Adresse von anker selbst zugewiesen? Dadurch wird die Liste zum Ring und damit endlos.
Ja was muss ich da tun damit die Fehlermeldung nicht auftaucht? ich bin
jetzt total verwirrt.
void einfuegen( struct telement *z, char *a, char *b )
{
struct telement *hzgr;
hzgr = (struct telement*)malloc(sizeof(struct telement));
hzgr ->text1 = (char*)malloc(strlen(hzgr ->text1));
hzgr ->text2 = (char*)malloc(strlen(hzgr ->text2));
strcpy(hzgr->text1,a);
strcpy(hzgr->text2,b);
hzgr->zeiger=z->zeiger;
z->zeiger = hzgr;
return;
}
Die Funktion habe ich jetzt mal zu abgeändert.
Du legst mit anker = (struct telement*)malloc( sizeof(struct telement)) ; anker->zeiger=anker; einen ersten Eintrag in main an. Nun wird aber nirgends anker->text1 bzw. anker->text2 auf was vernuenftiges gesetzt. Irgendwann kommt es in der ausgabe() Funktion dazu, dass printf versucht genau diese Werte auszugeben. Da die Zeiger aber ins Nirwana zeigen ... Eine Methode (und nicht die schlechteste) ist es bei solchen Sachen mitzuzeichnen. Also: Papier und Bleistift raus. Wenn Dein Program eine Variable anlegt, dann malst Du ein Rechteck aufs Papier und schreibst den Namen der Variablen links oben ueber das Rechteck. Wenn Dein Program mittels malloc etwas anlegt, dann machst Du genau das gleiche nur halt ohne Namen. Pointer werden durch Pfeile symbolisiert, die von einem Rechteck ausgehen und zu einem anderen Rechteck fuehren. Wichtig: Wenn Dein Program etwas loescht, dann darfst Du auch nur die Dinge am Papier ausfuehren, die Dein Program auch wirklich macht. Also: Das Rechteck wird zwar (mit einem Radiergummi) ausradiert, aber alle Pfeile bleiben so wie sie sind. Wann immer du auf eine Operation stoesst, die einen Pfeil benutzt der ins Leere zeigt, hast Du einen ungueltigen Pointer gefunden. Wenn Dein Programcode sir sagt, dass ein Pointer ausgewertet werden soll, aber auf Deinem Papier kein Pfeil da ist, dann hast Du einen uninitialisierten Pointer gefunden. Ansonsten schreibst Du immer alle Wert zb. bei einer Zuweisung in das zugehoerige Rechteck, bzw. im Falle eines Pointers werden ganz einfach Pfeile gezogen. (Weiterlesen im nachsten Posting)
Konkret:
Dein Program faengt in main an. Ich spar mir jetzt
das ganze Gesocks mit den Puffern und postuliere dass
die scanf durchgelaufen sind und die "Test1" und "abcd"
eingegeben hast:
anker
+--------+
| |
+--------+
puffer1
+---+---+---+---+---+---+---+--- ... ---+---+---+
| T | e | s | t | 1 | \0| | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
puffer2
+---+---+---+---+---+---+---+--- ... ---+---+---+
| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
Das ist die Ausgangssituation, hier gehts weiter
anker = (struct telement*)malloc( sizeof(struct telement)) ;
malloc erzeugt ein neues Objekt, in diesem Fall eine Struktur. Also:
anker
+--------+
| |
+--------+
+----------------+
| text1 : |
| text2 : |
| zeiger: |
+----------------+
puffer1
+---+---+---+---+---+---+---+--- ... ---+---+---+
| T | e | s | t | 1 | \0| | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
puffer2
+---+---+---+---+---+---+---+--- ... ---+---+---+
| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
... und die Zuweisung sorgt dafuer, dass die Adresse, die
von malloc zurueckgegeben wird in anker gespeichert wird.
Wir sagen auch: anker zeigt auf das neue Objekt. Auf Deinem
Papier sieht das dann so aus:
anker
+--------+
| o--------+
+--------+ |
|
|
|
| +----------------+
+>| text1 : |
| text2 : |
| zeiger: |
+----------------+
puffer1
+---+---+---+---+---+---+---+--- ... ---+---+---+
| T | e | s | t | 1 | \0| | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
puffer2
+---+---+---+---+---+---+---+--- ... ---+---+---+
| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
(Weiter im naechsten Posting)
Naechste Anweisung:
anker->zeiger=anker;
fangen wir mit der linken Seite der Zuweisung an.
anker->zeiger
Such mal das Rechteck, dass mit 'anker' bezeichnet ist.
Dann kommt der '->'. In Deiner Zeichnung muss also von
diesem Rechteck ein Pfeil ausgehen. Tut er auch. Folge
dem Pfeil.
anker->zeiger
In dem Rechteck auf das dieser Pfeil zeigt, siche das Feld
zeiger.
Hast Du's? Gut.
Soweit der linke Teil der Zuweisung. Merk Dir das Feld, das
bekommt gleich einen neuen Wert.
Welchen?
anker->zeiger=anker;
Also 'anker'. Da 'anker' ein Pointer ist, ist der neue Wert
also ein Pfeil, der auf dasselbe Objekt zeigt wie 'anker'.
Trage den in die Zeichnung ein:
anker
+--------+
| o--------+
+--------+ |
|
|
|
| +----------------+
+>| text1 : |
| text2 : |
+---->| zeiger: o-----------+
| +----------------+ |
| |
| |
+----------------------------+
puffer1
+---+---+---+---+---+---+---+--- ... ---+---+---+
| T | e | s | t | 1 | \0| | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
puffer2
+---+---+---+---+---+---+---+--- ... ---+---+---+
| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
Damit ist die Zuweisung abgeschlossen (und man sieht
auch sehr deutlich, dass text1 und text2 auf nichts
spezielles zeigen).
Naechste Anweisung:
einfuegen(anker,puffer1,puffer2);
Also ein Funktionsaufruf. Dn musst Du im Kopf machen
und Dir merken wo der Aufruf erfolgt ist (fuer den
Ruecksprung). Ansonsten ist nicht viel zu tun:
Fuer die Parameter werden neue Variablen erzeugt
und mit den Argumenten initialisiert:
void einfuegen( struct telement *z, char *a, char *b )
Es gibt also ein z, ein a und ein b, und als Werte bekommern
sie:
z - zeigt dorthin, wohin auch anker zeigt
a - zeigt auf den Anfang von puffer1
b - zeigt auf den Anfang von puffer2
anker
+--------+
| o--------+
+--------+ |
|
|
|
| +----------------+
+>| text1 : |
+----------->| text2 : |
| +---->| zeiger: o-----------+
| | +----------------+ |
| | |
| | |
| +----------------------------+
|
|
z | a b
+--|-+ +----+ +----+
| o | | o | | o |
+----+ +-|--+ +--|-+
| |
| |
+-------------+ |
| |
| +--------------------+
| |
| | puffer1
| | +---+---+---+---+---+---+---+--- ... ---+---+---+
+--|->| T | e | s | t | 1 | \0| | | | |
| +---+---+---+---+---+---+---+--- ... ---+---+---+
|
|
| puffer2
| +---+---+---+---+---+---+---+--- ... ---+---+---+
+->| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
und los gehts in einfuegen
Die erste Aktion ist wieder einfach zu machen:
struct telement *hzgr;
Eine zusaetzliche lokale Variable wird erzeugt:
anker
+--------+
| o--------+
+--------+ |
|
|
|
| +----------------+
+>| text1 : |
+----------->| text2 : |
| +---->| zeiger: o-----------+
| | +----------------+ |
| | |
| | |
| +----------------------------+
|
|
z | a b hzgr
+--|-+ +----+ +----+ +------+
| o | | o | | o | | |
+----+ +-|--+ +--|-+ +------+
| |
| |
+-------------+ |
| |
| +--------------------+
| |
| | puffer1
| | +---+---+---+---+---+---+---+--- ... ---+---+---+
+--|->| T | e | s | t | 1 | \0| | | | |
| +---+---+---+---+---+---+---+--- ... ---+---+---+
|
|
| puffer2
| +---+---+---+---+---+---+---+--- ... ---+---+---+
+->| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
Man beachte: Die Variable ist nicht initialisert worden, daher
ist das Rechteck auch leer.
(Weiter im naechsten Posting)
hzgr = (struct telement*)malloc(sizeof(struct telement));
Das ist wieder leicht. Ein neues Rechteck fuer malloc( ... ) erzeugen
und hzgr darauf zeigen lassen:
anker
+--------+
| o--------+
+--------+ | +---------------+
| +->| text1: |
| | | text2: |
| | | zeiger: |
| +----------------+ | +---------------+
+>| text1 : | +---+
+----------->| text2 : | |
| +---->| zeiger: o--------+ |
| | +----------------+ | |
| | | |
| | | |
| +-------------------------+ |
| |
| |
z | a b hzgr |
+--|-+ +----+ +----+ +----|-+
| o | | o | | o | | o |
+----+ +-|--+ +--|-+ +------+
| |
| |
+-------------+ |
| |
| +--------------------+
| |
| |
| | puffer1
| | +---+---+---+---+---+---+---+--- ... ---+---+---+
+--|->| T | e | s | t | 1 | \0| | | | |
| +---+---+---+---+---+---+---+--- ... ---+---+---+
|
|
| puffer2
| +---+---+---+---+---+---+---+--- ... ---+---+---+
+->| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
hzgr ->text1 = (char*)malloc(sizeof(struct telement));
hzgr ->text2 = (char*)malloc(sizeof(struct telement));
Die mallocs erzeugen wieder neue Rechtecke. Es muessen Pfeile
von hzgr->text1 nzw. hzgr->text2 zu diesen Rechtecken installiert
werden:
anker
+--------+
| o--------+
+--------+ | +---------------+
| +->| text1: o-------+
| | | text2: o------+|
| | | zeiger: | ||
| +----------------+ | +---------------+ ||
+>| text1 : | +---+ ||
+----------->| text2 : | | +----------+|
| +---->| zeiger: o--------+ | | |
| | +----------------+ | | | |
| | | | v |
| | | | +----------+ |
| +-------------------------+ | | text1: | |
| | | text2: | |
| | | zeiger: | |
z | a b hzgr | +----------+ |
+--|-+ +----+ +----+ +----|-+ |
| o | | o | | o | | o | +------------+
+----+ +-|--+ +--|-+ +------+ |
| | v
| | +-----------+
+-------------+ | | text1: |
| | | text2: |
| +--------------------+ | zeiger: |
| | +-----------+
| |
| | puffer1
| | +---+---+---+---+---+---+---+--- ... ---+---+---+
+--|->| T | e | s | t | 1 | \0| | | | |
| +---+---+---+---+---+---+---+--- ... ---+---+---+
|
|
| puffer2
| +---+---+---+---+---+---+---+--- ... ---+---+---+
+->| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
strcpy( hzgr->text1, a );
ok.
hzgr Suche das Feld namens 'hzgr'
hzgr-> Dort muss es einen Pfeil geben. Folge ihm
hzgr->text1 Im Rechteck in dem du gelandet bist, suche das
Feld 'text1'
a Der ist leicht. Einfach 'a' suchen.
So und jetzt kommt der strcpy. Von dem wissen wir, dass er
beide Argumente als Pointer auffasst. D.h. Im obigen mussen
beide Argumente POinter sein, d.h von ihnen muessen Pfeile
ausgehen:
hzgr->text1 passt, da geht ein Pfeil weg
a passt auch, da geht auch ein Pfeil weg.
Obwohl, so ganz passt das nicht.
a zeigt auf ein Array von Charactern. Diese sind auch '\0'
terminiert. Aber hzgr->text1 tut das nicht. Der Pfeil der
dort weggeht zeigt auf eine telement Datenstruktur und
kein Character Array. Also korrigieren wir das mal ganz schnell:
Anstatt
hzgr ->text1 = (char*)malloc(sizeof(struct telement));
hzgr ->text2 = (char*)malloc(sizeof(struct telement));
kommt:
hzgr ->text1 = malloc( strlen( a ) + 1 );
hzgr ->text2 = malloc( strlen( b ) + 1 );
So. Damit ist jeweils genuegend Speicher allokiert, damit
die Texte auch kopiert werden koennen:
anker
+--------+
| o--------+
+--------+ | +---------------+
| +->| text1: o--------+
| | | text2: o-------+|
| | | zeiger: | ||
| +----------------+ | +---------------+ ||
+>| text1 : | +---+ ||
+----------->| text2 : | | ||
| +---->| zeiger: o--------+ | +-----------+
| | +----------------+ | | | |
| | | | | |
| | | | | |
| +-------------------------+ | | |
| | | |
| | | |
z | a b hzgr | | |
+--|-+ +----+ +----+ +----|-+ | |
| o | | o | | o | | o | | |
+----+ +-|--+ +--|-+ +------+ | |
| | | |
| | +-----------------+ |
+-------------+ | | +---+---+---+---+---+---+ |
| | +>| | | | | | | |
| +--------------------+ +---+---+---+---+---+---+ |
| | +-----------------------------+
| | | +---+---+---+---+---+
| | +->| | | | | |
| | +---+---+---+---+---+
| |
| | puffer1
| | +---+---+---+---+---+---+---+--- ... ---+---+---+
+--|->| T | e | s | t | 1 | \0| | | | |
| +---+---+---+---+---+---+---+--- ... ---+---+---+
|
|
| puffer2
| +---+---+---+---+---+---+---+--- ... ---+---+---+
+->| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
Jetzt koennen die strcpy loslegen:
strcpy(hzgr->text1,a);
strcpy(hzgr->text2,b);
anker
+--------+
| o--------+
+--------+ | +---------------+
| +->| text1: o--------+
| | | text2: o-------+|
| | | zeiger: | ||
| +----------------+ | +---------------+ ||
+>| text1 : | +---+ ||
+----------->| text2 : | | ||
| +---->| zeiger: o--------+ | +-----------+
| | +----------------+ | | | |
| | | | | |
| | | | | |
| +-------------------------+ | | |
| | | |
| | | |
z | a b hzgr | | |
+--|-+ +----+ +----+ +----|-+ | |
| o | | o | | o | | o | | |
+----+ +-|--+ +--|-+ +------+ | |
| | | |
| | +-----------------+ |
+-------------+ | | +---+---+---+---+---+---+ |
| | +>| T | e | s | t | 1 | \0| |
| +--------------------+ +---+---+---+---+---+---+ |
| | +-----------------------------+
| | | +---+---+---+---+---+
| | +->| a | b | c | d | \0|
| | +---+---+---+---+---+
| |
| | puffer1
| | +---+---+---+---+---+---+---+--- ... ---+---+---+
+--|->| T | e | s | t | 1 | \0| | | | |
| +---+---+---+---+---+---+---+--- ... ---+---+---+
|
|
| puffer2
| +---+---+---+---+---+---+---+--- ... ---+---+---+
+->| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
Naechste Anweisung:
hzgr->zeiger=z->zeiger;
hzgr Suche das Feld 'hzgr'
hzgr-> folge dem Pfeil
hzgr->zeiger Im Rechteck suche das Feld 'zeiger'
Dort muss ein neuer Wert hin
z Suche das Rechteck z
z-> Folge dem Pfeil
z->zeiger und dort wieder das Feld zeiger
Arrangiere die Dinge so, dass hzgr->zeiger einen Pfeil
bekommt, der auf das gleiche zeigt wie z->zeiger:
anker
+--------+
| o--------+
+--------+ | +---------------+
| +->| text1: o--------+
| +----------------+| | text2: o-------+|
| v || | zeiger: o | ||
| +----------------+|| +---------|-----+ ||
+>| text1 : ||+---+ | ||
+----------->| text2 : |+-------------+ ||
| +---->| zeiger: o--------+ | +-----------+
| | +----------------+ | | | |
| | | | | |
| | | | | |
| +-------------------------+ | | |
| | | |
| | | |
z | a b hzgr | | |
+--|-+ +----+ +----+ +----|-+ | |
| o | | o | | o | | o | | |
+----+ +-|--+ +--|-+ +------+ | |
| | | |
| | +-----------------+ |
+-------------+ | | +---+---+---+---+---+---+ |
| | +>| T | e | s | t | 1 | \0| |
| +--------------------+ +---+---+---+---+---+---+ |
| | +-----------------------------+
| | | +---+---+---+---+---+
| | +->| a | b | c | d | \0|
| | +---+---+---+---+---+
| |
| | puffer1
| | +---+---+---+---+---+---+---+--- ... ---+---+---+
+--|->| T | e | s | t | 1 | \0| | | | |
| +---+---+---+---+---+---+---+--- ... ---+---+---+
|
|
| puffer2
| +---+---+---+---+---+---+---+--- ... ---+---+---+
+->| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
(Weiter im naechsten Posting)
z->zeiger = hzgr;
und zu guter letzt soll auch z->zeiger noch einen
neuen Pfeil bekommen: Der soll dorthin zeigen wo auch
hzgr hinzeigt:
anker
+--------+ +--------+
| o--------+ | v
+--------+ | | +---------------+
| | +->| text1: o--------+
| +-------------|--+| | text2: o-------+|
| v | || | zeiger: o | ||
| +------------+ | || +---------|-----+ ||
+>| text1 : | | |+---+ | ||
+----------->| text2 : | | +-------------+ ||
| | zeiger: o---+ | +-----------+
| +------------+ | | |
| | | |
| | | |
| | | |
| | | |
| | | |
z | a b hzgr | | |
+--|-+ +----+ +----+ +----|-+ | |
| o | | o | | o | | o | | |
+----+ +-|--+ +--|-+ +------+ | |
| | | |
| | +-----------------+ |
+-------------+ | | +---+---+---+---+---+---+ |
| | +>| T | e | s | t | 1 | \0| |
| +--------------------+ +---+---+---+---+---+---+ |
| | +-----------------------------+
| | | +---+---+---+---+---+
| | +->| a | b | c | d | \0|
| | +---+---+---+---+---+
| |
| | puffer1
| | +---+---+---+---+---+---+---+--- ... ---+---+---+
+--|->| T | e | s | t | 1 | \0| | | | |
| +---+---+---+---+---+---+---+--- ... ---+---+---+
|
|
| puffer2
| +---+---+---+---+---+---+---+--- ... ---+---+---+
+->| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
Das wars. Dir Funktion ist zuende und alle lokalen Variablen
sowie alle Argument koennen geloescht werden:
anker
+--------+ +--------+
| o--------+ | v
+--------+ | | +---------------+
| | | text1: o--------+
| +-------------|--+ | text2: o-------+|
| v | | | zeiger: o | ||
| +------------+ | | +---------|-----+ ||
+>| text1 : | | | | ||
| text2 : | | +-------------+ ||
| zeiger: o---+ +-----------+
+------------+ | |
| |
| |
| |
| |
| | |
| |
| |
| |
| |
| |
+-----------------+ |
| +---+---+---+---+---+---+ |
+>| T | e | s | t | 1 | \0| |
+---+---+---+---+---+---+ |
+-----------------------------+
| +---+---+---+---+---+
+->| a | b | c | d | \0|
+---+---+---+---+---+
puffer1
+---+---+---+---+---+---+---+--- ... ---+---+---+
| T | e | s | t | 1 | \0| | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
puffer2
+---+---+---+---+---+---+---+--- ... ---+---+---+
| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
Weiter gehts in main
ausgabe();
Also, dann rufen wir mal diese Funktion auf. Argumente gibts
keine, also koennen wir gleich mal die lokalen Variablen
anlegen:
struct telement *hzgr;
hzgr = anker;
Also: neues Rechteck anlegen und auf das gleiche Rechteck zeigen
lassen wie anker:
anker
+--------+ +--------+
| o--------+ | v
+--------+ | | +---------------+
| | | text1: o--------+
| +-------------|--+ | text2: o-------+|
| v | | | zeiger: o | ||
| +------------+ | | +---------|-----+ ||
+>| text1 : | | | | ||
+------>| text2 : | | +-------------+ ||
| | zeiger: o---+ +-----------+
| +------------+ | |
| | |
+----+ | |
| | |
hzgr | | |
+---+ | | |
| o------+ | |
+---+ | |
| |
| |
| |
+-----------------+ |
| +---+---+---+---+---+---+ |
+>| T | e | s | t | 1 | \0| |
+---+---+---+---+---+---+ |
+-----------------------------+
| +---+---+---+---+---+
+->| a | b | c | d | \0|
+---+---+---+---+---+
puffer1
+---+---+---+---+---+---+---+--- ... ---+---+---+
| T | e | s | t | 1 | \0| | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
puffer2
+---+---+---+---+---+---+---+--- ... ---+---+---+
| a | b | c | d | \0| | | | | |
+---+---+---+---+---+---+---+--- ... ---+---+---+
do
Da brauchen wir nichts mitzeichnen
printf ("Inhalt Text1: %s", hzgr->text1);
printf soll einen Text ausgeben. %s sorgt
dafuer, indem wir ihm einen Pointer (einen Pfeil)
geben, der an den Anfang des Textes zeigt.
Welches Textes?
hzgr->text1
hzgr hzgr aufsuchen
hzgr-> dem Pfeil folgen
hzgr->text1 das text1 Feld aufsuchen
In diesem letzten Feld muss ein Pfeil weggehen
(%s will ja einen). Aber da ist keiner.
K A B O O M !!!!
Da hast Du Deinen Absturz
Ja was muss ich da tun damit die Fehlermeldung nicht auftaucht? ich bin > jetzt total verwirrt. > > void einfuegen( struct telement *z, char *a, char *b ) > { > struct telement *hzgr; > hzgr = (struct telement*)malloc(sizeof(struct telement)); > hzgr ->text1 = (char*)malloc(strlen(hzgr ->text1)); > hzgr ->text2 = (char*)malloc(strlen(hzgr ->text2)); Also, wenn Dir das Schwierigkeiten macht, solltest Du die Finger von linearen Listen lassen. Du bist noch nicht soweit. Hinweis: Was gibt strlen zurueck? Wieviel Speicher braucht der String wirklich Hinweis 2: C strings sind immer mit einem '\0' terminiert.
Hi @Karl-Heinz Langeweile? Ist ja irre. Wie lange hast du denn an den Postings gearbeitet? Matthias
@F
> hzgr ->text1 = (char*)malloc(strlen(hzgr ->text1));
Und warum versuchst Du die Menge des zu allokierenden Speichers
von hzgr->text1 abzulesen. hzgr->text1 enthaelt noch keinen
String. Dafuer allokierst Du doch erst Speicher. 'a' ist
ein Pointer auf den String!
@Matthias
ne gute Stunde.
Da haettest Du erst mal meine Postings in comp.lang.c++ sehen
sollen. Das selbe, nur ausfuehrlicher und in Englisch.
Ist verstaendlich wie diese Debugmethode funktioniert? Das ganze liest sich schlimmer als es ist. Am Papier geht sowas ganz schnell. Wichtig: Bleistift verwenden und keinen Kugelschreiber. Sonst wirds nichts mit dem ausradieren bei einem free(). Buntstifte (mehrere Farben) sorgen auch schnell mal fuer Uebersicht. Damit hats eigentlich noch jeder geschafft, lineare Listen oder Baeume zu debuggen. Bei rekursiven Funktionen wirds allerdings lustig :-)
Ich finde, Karl Heinz hat den 1. Preis für ASCII-Art und anschauliches Erklären verdient :-)
Ok danke an Alle dir mir dabei helfen!
Ich habe jetzt bei mir nur noch Probleme mit der Ausgabe.
void ausgabe(void)
{
struct telement *hzgr;
int i=0;
hzgr = anker;
do
{
printf ("Inhalt Text1: %s", hzgr->text1);
hzgr = hzgr->zeiger;
}
while (hzgr != NULL);
printf("\n\n");
return;
}
Hier möchte ich die Strings am Bildschirm ausgeben.
Leider stürtzt das Programm immer ab?
gib deinem strukt einen constructor in dem du die string-pointer auf 0
setzt.. beim ausgeben machst etwas in die richtung
if(foo->bar==0)
printf ("invalid pointer")
else
printf ("string:%s",foo-bar);
ich wette noch immer gleiches problem....bzw dein malloc reserviert dir
ein byte zuwenig und du überschreibst dir dein null-byte...
damit sollte das ganze debuggen leichter gehn.. wenn z.b ein strcpy
kracht dann kannst schaun ob du überhaupt speicher in deiner
destination angelegt hast...
c ist eben eine sprache in der man sich um seinen speichern zu kümmern
hat ;) meiner erfahrung nach ist das eine der haupt-crash-gründe, dass
man speicher nicht initialisiert und pointer ins nirvana zeigen...
also immer wenn ein pointer reserviert wird auf 0 setzen (NULL ist auch
oft gebräuchlich) und wenn er freigegeben wird auch wieder 0 setzen..
das erspart arbeit beim debuggen ;)
73
> Ok danke an Alle dir mir dabei helfen! > Ich habe jetzt bei mir nur noch Probleme mit der Ausgabe. Die hast Du nicht. Die Ausgabefunktion ist voellig in Ordnung. Aber die Datenstruktur die Du da zusammenbaust ist es nicht. Merke: Das der Absturz in ausgabe() passiert heist nur das Du dort das Symptom siehst. Die Ursache ist aber ganz woanders (und schon beschrieben worden).
(Das kommt jetzt drauf an, welche Aenderungen Du bisher
gemacht hast. Aber ich riskiers mal:)
Mach mal folgendes:
int main(void)
{
anker = (struct telement*)malloc( sizeof(struct telement)) ;
anker->zeiger=anker;
ausgabe();
return 0;
}
Wenn Du Glueck hast, dann crasht dieser Code genauso (*).
Und jetzt lies nochmal durch was ich weiter oben
elendslang beschrieben habe.
Und vor allem: Benutze Deine Werkzeuge, um rauszufinden
wo genau es in der Funktion ausgabe() crasht. Dann
zieh Deine Schluesse daraus.
(*)
Glueck deshalb, da es keine Garantie dafuer gibt. Das
Program enthaelt definitv einen schweren Fehler. Wenn Du
Pech hast, dann bemerkst Du den Fehler waehrend des Entwickelns
nicht und lieferst den fehlerhaften Code an Deinen Kunden aus.
Laut Murphy, krachts dann bei dem. Und das ist wesentlich
schlechter als wenn es bei Dir kracht und Du auf den Fehler
aufmerksam wirst.
Ich verstehe nicht, warum sich Leute in C++ noch mit sowas rumplagen wo es doch die STL gibt.
Hi weil er es in C realisieren soll? Das er die Endung cpp verwendet liegt entweder daran das sein Betreuer nichts taugt oder aber das doch C++ gemeint ist. Aber es schadet niemandem sowas mal manuell zu implementieren. Nur so versteht man was da wirklich passiert und was die Vor- und Nachteile einer verketteten Liste sind. Matthias
Hi, ich muss auch mal nen Lob loswerden und hoffe jemand ist so nett und stellt es in Wiki rein. In einigen C Büchern finde ich es nicht so verstaendlich beschrieben, vielleicht liegt es auch an der Grafik. Gruß, Dirk
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.