Dynamisch allokierte Strukturen

the_menace

Hallo,
wenn ich ein verkettete Liste definiere, und dynamisch
allokiere, was bekomme ich zurueck, wenn ich
einerseits t->next schreibe
und andererseits t.next, wobei next ein Zeiger
auf ein anderes Listenelement, dass auf die gleiche
Definition zurueckgreift, ist.
Und was ist, wenn ich eine Struktur statisch deklariere
und innerhalb der struktur ein Zeiger auf int ist, dem
ich Speicherplatz zugewiesen habe. wenn ich da jetzt den
inhalt will, greife ich da bloss mit struktur.*intelem zu?
Oder bekomme ich dann mit struktur->intelem auch den Wert
zurueck, der an der Stelle ist, wo der int-zeiger hinweist?
und bekomme ich dann mit struktur.intelem dann den zeiger
auf die Stelle zurueck?
Bisher konnte ich das nicht eindeutig herausfinden, was was macht,
auch wenn es eigentlich recht leicht zu sein scheint

Bashar

Ich weiß nicht, ob ich deine Frage richtig interpretiere (ist nicht ganz einfach, du schreibst ziemlich unkoordiniert), aber eigentlich gibts dazu nicht mehr zu wissen, also dass A->B gleichbedeutend mit (*A).B ist.

the_menace

Es ist doch so. Wenn ich, sagen wir einen int Zeiger deklariere und ihm Speicher zuweise, gibt es ja die Moeglichkeit den Wert zurueckbekommen, auf den der Zeiger zeigt, mittels *iptr, oder direkt die Adresse, die in der Variable ist, zu bekommen (einfach iptr, ohne alles). Jetzt wollte ich gerne wissen, wenn ich eine dynamisch allokierte Struktur habe, in der wiederrum ein ein Zeiger auf eine dynamische Struktur (nennen wir sie s2) ist, bekomme ich ja die dynamische Struktur selbst zurueck mittels struktur->next, oder?
Wenn ich jetzt aber bloss den zeiger auf diese struktur s2 will, schreibe ich dann
struktur.next oder wie?

Entyl_Sa

Du schreibst:

Object * struktur;
struktur->next

oder

Object struktur;
struktur.next;

und wenn next ein Zeiger ist bekommst du in beiden Faellen einen Zeiger.

Gruß

Entyl Sa

tobidope

the_menace schrieb:

Es ist doch so. Wenn ich, sagen wir einen int Zeiger deklariere und ihm Speicher zuweise, gibt es ja die Moeglichkeit den Wert zurueckbekommen, auf den der Zeiger zeigt, mittels *iptr, oder direkt die Adresse, die in der Variable ist, zu bekommen (einfach iptr, ohne alles). Jetzt wollte ich gerne wissen, wenn ich eine dynamisch allokierte Struktur habe, in der wiederrum ein ein Zeiger auf eine dynamische Struktur (nennen wir sie s2) ist, bekomme ich ja die dynamische Struktur selbst zurueck mittels struktur->next, oder?
Wenn ich jetzt aber bloss den zeiger auf diese struktur s2 will, schreibe ich dann
struktur.next oder wie?

#include <stdio.h>

struct test {
    int a;
    int b;
};

int main()
{
    struct test eins;
    struct test *p;

    eins.a = 2;
    eins.b = 0xbeef;

   p = & eins;

   if(eins.a == p->a)
       puts("Gleicher Wert bei eins.a und p->a");

    return 0;
}

Bashar

the_menace schrieb:

Jetzt wollte ich gerne wissen, wenn ich eine dynamisch allokierte Struktur habe, in der wiederrum ein ein Zeiger auf eine dynamische Struktur (nennen wir sie s2) ist, bekomme ich ja die dynamische Struktur selbst zurueck mittels struktur->next, oder?

Also so?

struct s2 { ... };
struct s1 {
  struct s2 * zeiger;
};
struct s1 * struktur = malloc(sizeof *s1);

?

Dann bekommst du mit struktur->zeiger den Wert des Zeigers, also die Adresse, auf die er zeigt. Willst du aus irgendeinem Grund den Wert, auf den der Zeiger zeigt, schreibst du, wie immer, ein * davor: *struktur->zeiger. Keine Angst, das funktioniert schon, der .Operator zieht stärker als der *Operator, das ist also gleichbedeutend mit *(struktur->zeiger)

Falls das nicht das ist, was du wissen willst, bring mal ein wenig Code ...

the_menace

#include <stdio.h>

struct node {
	int key;
	struct node *next;
};

struct node *insertafter(int v,struct node *t) {
	struct node *x;
	x=(struct node *)malloc(sizeof(struct node *)); /* speicher bereitstellen */
	x->key=v; /* wert zuweisen */
	x->next=t->next; /* kann ja mittendrin eingefuegt werden, also zeiger dem neuen element geben */
	t->next=x; /* jetzt den zeiger aufs neue element */
	return x;  /* gib aktuellen knoten zurueck */
} /* fertig ist eine weiteres anonymes Element der Liste */

int main(int argc, char *argv[]) {
	struct node *first=(struct node *)malloc(sizeof(struct node *));
	first->key=1;
	struct node *z=insertafter(2,first);
	z->next=first;
	printf(" zkey %i , firstkey %i\n",z->key,z->next->key);
	printf(" zpoint %i , znextpoint %i , firstpoint %i\n", *z->next, *(z->next)->next, *first->next);
	return 0;
}

Also, dann gibt mir *z->next die Adresse aus, an der die Adresse liegt, die auf first zeigt?
und *(z->next)->next sollte doch die Adresse zeigen, an der die Adresse zu z liegt? aber sollte dann nicht *first->next auch diese Adresse ausgeben?
denn das zweite und dritte sollte doch equivalent sein?

Vielen dank fuer die hilfe

the_menace

Könnte ich ein wenigstens ein "punktx: ja usw" oder ein "Punktx: nein" oder "geh weg" als antwort bekommen? nicht dass es zeitlich drängt, aber mir brennt diese Unsicherheitsgefühl in den Fingern