Forum: C-Programmieren

Gibt es eine Möglichkeit, den void-Zeiger dauerhaft zu casten?
Ein union-struct möchte ich nicht verwenden.

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


struct __node__
{
 void            *data;
 struct __node__ *prev;
 struct __node__ *next;
} typedef Node;


static void
die ( const char* const errorstring )
{
 fprintf(stderr, "%s\n", errorstring);
 exit(EXIT_FAILURE);
}


int main ()
{
 Node *foo = malloc(sizeof(Node));
 if (NULL == foo) die("E1");
 if (NULL == (foo->data=malloc(sizeof(Node)))) die("E2");

 // Ab hier wird es unuebersichtlich.
 if (NULL == (((Node *) (foo->data))->data=malloc(sizeof(Node)))) die("E3");
 if (NULL == (((Node *) ((Node *) (foo->data))->data)->data=malloc(sizeof(Node)))) die("E4");

 puts("Ende");
 return EXIT_SUCCESS;
}

Gruß und schönes Wochenende,
Patrick-Oliver

--
To follow the path: look to the master, follow the master, walk with the master, see through the master, become the master.

 

Hallo Patrick,

Zitat:
Gibt es eine Möglichkeit, den void-Zeiger dauerhaft zu casten?

Ich glaub ich versteh den Hintergrund der Frage nicht ganz ... ?
Bitte erklär genauer auf welches Szenario die Frage abzielt.

Warum ist in deiner Struktur überhaupt ein void-Zeiger? Und warum werden dem void-Zeiger dann Knoten zugewiesen?

mfg, Wolfgang

--
Hex, Bugs and Rock 'n Roll

 

Hallo Patrick-Oliver,

Hmm... wenn Du das Ding unbedingt von Hand füllen willst, warum verwendest Du nicht temporäre Pointer?

Node *tmp = foo->data;
if (NULL == (tmp->data=malloc(sizeof(Node))) die("E3"); 

tmp = tmp->data;
if (NULL == (tmp->data=malloc(sizeof(Node))) die("E4"); 

tmp = tmp->data;
if (NULL == (tmp->data=malloc(sizeof(Node))) die("E5"); 

tmp = tmp->data;
if (NULL == (tmp->data=malloc(sizeof(Node))) die("E6"); 

tmp = tmp->data;
if (NULL == (tmp->data=malloc(sizeof(Node))) die("E7"); 

Jetzt sind alle Blöcke gleich (bis auf die Ausgabe im Fehlerfall), und man könnte auf die Idee kommen, den Kram in eine Funktion auszulagern, die man dann ein paar Mal mit ihrem eigenen Rückgabewert als Argument nochmal aufruft.


Was soll das eigentlich für eine abgefahrene Datenstruktur sein. "Mehrdimensionale Liste"? Warum speicherst Du in einer Liste Listen, die Listen speichern, die Listen speichern, ...?

Und noch ein Hinweis: Bezeichner, die mit einem Unterstrich beginnen, sind für die libc reserviert. Bezeichner, die mit zwei Unterstrichen beginnen, sind für den Compiler reserviert. Es ist zwar verlockend, aber Bezeichner sollten nie mit einem Unterstrich beginnen.

Den Unterstrich kannst Du Dir leicht sparen, indem Du den typedef vor der Typdefinition machst:

typedef struct node node;

struct node {
	node *prev;
	node *next;
	void *data;
};

Gruss,
Philip

--
The C Programming Quiz - bitte Fragen einreichen :)

 

Oha, da habe ich wohl für etwas Verwirrung gesorgt, der o.g. Code ist nämlich nur ein Beispiel.
Es soll aufzeigen, wie schwer ich es mir derzeit mache, wenn ich auf solche Datenstrukturen zugreife.

@Wolfgang:
In Wirklichkeit wird dem Void-Zeiger kein Knoten zugewiesen.
Zumindest habe ich derzeit keine Aufgabe vorliegen, die soetwas benötigt.
Es werden Dinge zugewiesen wie z.B. Strukturen die einen Server oder Clienten beschreiben, oder Zeiger auf Funktionen usw.
Ich betrachte die Struktur __node__ also als generisch und mein Anliegen ist, Schreibweisen wie (((Node *) (foo->data))->data zu vereinfachen.

@Philip
Das mit dem temporären Zeiger funktioniert, danke.
Ausgelagert werden muss da aber nichts, da es nur ein Beispiel war, beim nächsten Mal gebe ich mir etwas mehr Mühe

Zitat:
Was soll das eigentlich für eine abgefahrene Datenstruktur sein.

Wie immer dreht sich auch bei mir alles um die Weltherrschaft, hrhr.
Spass bei Seite, in deinem Code-Schnipsel-Thread habe ich geschrieben, dass ich an Ähnlichem gearbeitet habe.
Bei mir war es von Anfang an aber eine doppelt verkettete Liste und es gibt bei mir nur die Funktionen unshift_node und delete_node.
Wie bereits oben geschrieben, werden hier i.d.R. "normale" Dinge abgelegt.

Zitat:
Und noch ein Hinweis: Bezeichner, die mit einem Unterstrich beginnen...

Hatten wir auch schon. Ich mag es so, weil es recht schnell ins Auge springt.
Unschön wird es imho erst, wenn mit mehreren Leuten am Code gearbeitet wird und da ich überwiegend Eigenbrödler bin, habe ich das "vergessen".
Ich versuche das in Zukunft zu ändern

Danke sehr,
Patrick-Oliver

--
To follow the path: look to the master, follow the master, walk with the master, see through the master, become the master.

 

Oha, da habe ich wohl für etwas Verwirrung gesorgt, der o.g. Code ist nämlich nur ein Beispiel.
Es soll aufzeigen, wie schwer ich es mir derzeit mache, wenn ich auf solche Datenstrukturen zugreife.

@Wolfgang:
In Wirklichkeit wird dem Void-Zeiger kein Knoten zugewiesen.
Zumindest habe ich derzeit keine Aufgabe vorliegen, die soetwas benötigt.
Es werden Dinge zugewiesen wie z.B. Strukturen die einen Server oder Clienten beschreiben, oder Zeiger auf Funktionen usw.
Ich betrachte die Struktur __node__ also als generisch und mein Anliegen ist, Schreibweisen wie (((Node *) (foo->data))->data zu vereinfachen.

@Philip
Das mit dem temporären Zeiger funktioniert, danke.
Ausgelagert werden muss da aber nichts, da es nur ein Beispiel war, beim nächsten Mal gebe ich mir etwas mehr Mühe

Zitat:
Was soll das eigentlich für eine abgefahrene Datenstruktur sein.

Wie immer dreht sich auch bei mir alles um die Weltherrschaft, hrhr.
Spass bei Seite, in deinem Code-Schnipsel-Thread habe ich geschrieben, dass ich an Ähnlichem gearbeitet habe.
Bei mir war es von Anfang an aber eine doppelt verkettete Liste und es gibt bei mir nur die Funktionen unshift_node und delete_node.
Wie bereits oben geschrieben, werden hier i.d.R. "normale" Dinge abgelegt.

Zitat:
Und noch ein Hinweis: Bezeichner, die mit einem Unterstrich beginnen...

Hatten wir auch schon. Ich mag es so, weil es recht schnell ins Auge springt.
Unschön wird es imho erst, wenn mit mehreren Leuten am Code gearbeitet wird und da ich überwiegend Eigenbrödler bin, habe ich das "vergessen".
Ich versuche das in Zukunft zu ändern

Danke sehr,
Patrick-Oliver

--
To follow the path: look to the master, follow the master, walk with the master, see through the master, become the master.