Ne Frage zu Listen

Hallo!
Ich hab ein kleines Problem:
Ich habe eine Funktion Insert, welche einer Liste ein Element dranhängt.

Structure:

#include <stdio.h>
#include <stdlib.h>

typedef struct elem *IntList;
typedef struct elem{
	int data;
	IntList next;
} elemtype;

Die Funktion Insert:

void Insert(IntList *l, int Wert)

Nun Meine Frage:
Die Funktion Insert erwrtet ja jetzt eine Adresse des ersten Listenelemnts.
ICh dachte mir folgendes:
In der Mai-Funktion definiere ich einen Zeiger, auf ein Structureelement:

IntList l;

Das l müsste doch jetzt ein Zeiger sein.
--> also wenn ich jetzt Printf("%d,l) machen würde, müsste mir doch dann die Adresse von l übergeben werden, oder??
Was passiert, wenn ich *l ausgeben lasse??

**
Warum muss ich beim Aufruf meiner Insert Funktion &l übergeben, und nicht l????
**
(l ist doch die adresse, oder?)

Wäre nett, wenn ihr mir helfen könntet.
mfg Bene

CStoll

l ist das erste Listen-Element, mit deiner printf("%d",l)-Konstruktion deutest du es als int um und gibst seinen int-Wert aus (der vermutlich dem Inhalt von l.data entspricht). Mit &l bekommst du die Adresse des Elements.

(und deine Funktion benötigt die Adresse, weil sie dieses Element verändern will - und das geht nicht mit einer lokalen Kopie)

Dank erstma!

Ich hab nur ein Problem:
Wenn ich:

int *i;

schreibe, und dann printf("%h",i);
ausgeben lasse, dann wird mir die Adresse ausgegeben...

Also ich dachte, dass ich meine Funktion nur wie folgt aufrufen müsste:
Insert(l,3);

Ich versteh immer noch nicht, warum ich hier &l angeben muss.
Hast du vielleicht ein Buch zu empfehlen??

mfg Bene

CStoll

benemaja schrieb:

Ich hab nur ein Problem:
Wenn ich:

int *i;

schreibe, und dann printf("%h",i);
ausgeben lasse, dann wird mir die Adresse ausgegeben...

Achso - wenn du meinst, daß das die Adresse ist (was du dort bekommst, ist die Hex-Interpretation der Adresse, für Pointer solltest du besser "%p" verwenden)

Also ich dachte, dass ich meine Funktion nur wie folgt aufrufen müsste:
Insert(l,3);

Ich versteh immer noch nicht, warum ich hier &l angeben muss.

Insert erwartet an der Stelle einen IntList* (Pointer auf IntList), also mußt du der Funktion auch einen entsprechenden Pointer übergeben - l ist ein "normaler" IntList, um daraus einen IntList* zu machen, mußt du ihn referenzieren - und das machst du mit &l.

Hast du vielleicht ein Buch zu empfehlen??

Nein, aber schau dich doch mal in der Foreneigenen Bücherliste um.

Danke erstma!

Was ich aber noch nicht verstehe ist, wenn ich eine Funktion habe,
wie z.B.

void add(int *Ergebnis, int a, int b)
{
	*Ergebnis = a+b;

}

Hier würde doch in main dann folgendes stehen:

int main
{
 int *e;
 add(e,2,3);
 ...
}

Hier wird ja mit e die Adresse übergeben. Hier muss ich ja auch nicht &e schreiben.

Warum muss ich dann dies bei der Liste machen??

Also ich dachte, dass ich meine Funktion nur wie folgt aufrufen müsste:
Insert(l,3);

Ich versteh immer noch nicht, warum ich hier &l angeben muss.

Wäre nett, wenn ihr mir helfen könntet.
mfg Bene

LordJaxom

benemaja schrieb:

Hier würde doch in main dann folgendes stehen:
int main
{
 int *e;
 add(e,2,3);
 ...
}
Hier wird ja mit e die Adresse übergeben. Hier muss ich ja auch nicht &e schreiben.

Und hier liegt der Hund begraben:
int *e;
definiert einen Zeiger auf eine Int-Variable, der zudem nicht initialisiert ist. Das heisst in e steht keine Zahl (int) sondern die Adresse einer Zahl. Der Ausdruck "*e" (z.B. in printf) holt die Zahl an dieser Adresse. Da der Zeiger nicht initialisiert ist, wird diese Adresse ungültig sein und Dein Programm abstürzen (wenn Du GLÜCK hast, sonst läuft es sogar weiter und macht später noch viel übleren Humbug).

Korrekt wäre:

int e; /* Definiere eine Variable vom Typ Integer (Zahl) */
add(&e, 2, 3); /* Gebe die Adresse dieser Zahl an add() damit die Zahl verändert werden kann */

Hi!
Also ich hab ja nen Problem, wenn ich ne Liste hab.
Und ne Funktion habe, wo ich den Listenanfang übergebe, damit dann neue Elemente an bestimmten Positionen hinzugefügt werden können.

#include <stdio.h>
#include <stdlib.h>

typedef struct elem *IntList;
typedef struct elem{
    int data;
    IntList next;
} elemtype;

Der Funktionskopf:

void Insert(IntList *l, int Wert)

Wenn ich jetzt in main eine Variable wie folgt deklariere:

IntList Liste;

Ist dies dann ein Zeiger auf so ein elem Structure, oder??

warum gibt dann l keine Adresse wieder, wie in dem Thread zuvor??
Ich versteh das irgendwie nich..
Warum muss ich &l der Funktion übergeben?? l müsste es doch auch tun..

Hoff ihr könnt mir weiterhelfen.
Danke!
mfg Bene

Hi!
Also ich hab ja nen Problem, wenn ich ne Liste hab.
Und ne Funktion habe, wo ich den Listenanfang übergebe, damit dann neue Elemente an bestimmten Positionen hinzugefügt werden können.

#include <stdio.h>
#include <stdlib.h>

typedef struct elem *IntList;
typedef struct elem{
    int data;
    IntList next;
} elemtype;

Der Funktionskopf:

void Insert(IntList *l, int Wert)

Wenn ich jetzt in main eine Variable wie folgt deklariere:

IntList Liste;

Ist dies dann ein Zeiger auf so ein elem Structure, oder??

warum gibt dann Liste keine Adresse wieder, wie in dem Thread zuvor??
Ich versteh das irgendwie nich..
Warum muss ich &Liste der Funktion übergeben?? Liste müsste es doch auch tun..

Hoff ihr könnt mir weiterhelfen.
Danke!
mfg Bene

CStoll

Du hast deine Funktion so deklariert, daß sie einen Pointer auf IntList erwartet - also mußt du ihr auch einen Pointer auf IntList übergeben - deine Variable 'Liste' ist aber nur eine einfache IntList (daß 'IntList' ein typedef für einen Pointer ist, steht da außer Debatte).

Hallo!
Wollt mich nur ma für die Hilfe bedanken!

Habs jetzt endlich geschnallt.

Danke!
mfg Bene