Pointer-Wert von einem Pointer(typ) auf den anderen schreiben?

calgonite

Hallo,

Ich brauche eine Methode, mit der man den Pointer auf einen anderen schreiben kann ohne dass der Compiler testet auf WAS der pointer zeigt. :p

Also z.B. zeigt Pointer1 auf Struct1 will aber auf einen anderen Pointer schreiben, der auf eine Struct2 zeigt, die NICHT den gleichen typ hat. (Evtl ASM? Habe ASM seit den AMIGA Zeiten nicht mehr benutzt, sind ja nur 15 Jahre )

Chris

Bashar

Sieht so aus als fragtest du nach einem Cast-Operator (explizite Typumwandlung):

Typ1 *p1 = ...;
Typ2 *p2 = reinterpret_cast<Typ2*>(p1);

Cast-Ausdrücke sind ein relativ elementares Thema, damit solltest du dich unbedingt beschäftigen.

calgonite

Okay, wird ausprobiert Danke.

Chris

calgonite

Ich hab es probiert, aber der Compiler hat Probleme, mit dem auf die einen struct definiertem Zeiger auf eine andere struct zuzugreifen:

typedef struct fx1
{
   float zahl;
   unsigned short calgon;
} axa1;

typedef struct fx2
{
	char b;
   int calgonit;

} axa2;

fx1 effect1;
fx2 effect2;
fx1 *zeiger1;
fx2 *zeiger2;
effect1.zahl = 9.2f;
effect2.b = 22;
zeiger1 = &effect1;
zeiger2 = &effect2;

zeiger1 = reinterpret_cast<fx1*>(zeiger2);

printf("zahl   %f \n \n", effect1.zahl);
//printf("zahl   %f \n \n", zeiger1->zahl);   // das geht

printf("zahl   %f \n \n", zeiger1->b);
// geht nicht, obwohl zeiger1 jetzt auf die effect2 also die fx2 struct zeigt
// der Compiler sagt: 'b' : is not a member of 'fx1'

Wie kann man das umgehen? Ich möchte, dass man den zeiger auf effect1 in einen zeiger auf effect2 umwandelt und dann auch die Elemente von effect2 ansprechen zu können.

Chris

/edit: code-tags sfds

Bashar

Hätte mir gleich spanisch vorkommen sollen, dass ich deine Anfangsfrage nicht wirklich verstanden und geraten habe was du meinst ... also: HÄ? Was willst du eigentlich machen? Wozu wandelst du den Zeiger denn erst um, wenn du doch mit dem ursprünglichen Typ arbeiten willst??

davie

du kannst den statischen typ des zeigers nicht ändern.
zeiger1 ist und bleibt immer ein zeiger, der auf objekte vom typ fx1 zeigt.

mit

zeiger1 = reinterpret_cast<fx1*>(zeiger2);

lässt du zeiger1 nur das, worauf zeiger2 zeigt, als ein objekt vom typ fx2 interpretieren.

was du genau machen willst ist allerdings mehr als unklar

//printf("zahl   %f \n \n", zeiger1->zahl);   // das geht

das geht, weil der compiler denkt, dass zeiger1 auf ein objekt fx1 zeigt und das hat einen member namens zahl

printf("zahl   %f \n \n", zeiger1->b);

das geht nicht, weil der compiler denkt, dass zeiger1 auf ein objekt fx1 zeigt und das hat keinen member namens b

Helium

Nebenbei: wofür das typedef?

struct fx1
{
   float zahl;
   unsigned short calgon;
};

Das würde reichen

// geht nicht, obwohl zeiger1 jetzt auf die effect2 also die fx2 struct zeigt
// der Compiler sagt: 'b' : is not a member of 'fx1'

C++ ist statisch typisiert! Natürlich geht das nicht. Aber mir erschließt sich auch nicht wirklich der Sinn.

calgonite

Bei der Frage nach dem Sinn:

stellt Euch vor, ihr habt viele verschiedene Structs, z.B Effect-Parameter. Erst in Runtime wird ein script ausgelesen, in dem z.B ein effect von den vielen aufgerufen wird. (und in die Liste mit den laufenden effekten eingetragen wird) Ein "Effekt" (funktion) kann auch mehrmals aufgerufen werden, braucht aber dann jeweils einen eigenen Speicherbereich (die Struct), um laufende Parameter abzuspeichern.

Als brauche ich eine verkettete Liste, deren Inhalt ein pointer auf eine (beliebige struct), Hinzu kommt noch ein wert, der besagt, auf welchen typ struct ich zeige.

Dafür brauche ich das.

Chris

Shade Of Mine

Ich kapiers zwar nicht: aber das was du machst ist verdammt unsicher.

Kann man das nicht mit Vererbung lösen??

Helium

@calgonite: Das hört sich sehr ähnlich an, wie das, was ich in meinen Audioanwendungen mache (z.B. Filter), allerdings kann man das doch viel schöner mit ordentlichen Klassen lösen. Hör auf Algorithmen von Daten zu trennen.

cof

Bashar schrieb:

Typ1 *p1 = ...;
Typ2 *p2 = reinterpret_cast<Typ2*>(p1);

müsste es nicht sowieso

Typ1 *p1 = ...;
Typ2 *p2 = reinterpret_cast<Typ2*>(&p1);

sein? oder kann man das ambersand (wie schriebt man das eigentlich) weglassen?

Helium

Nein. Bashars Code ist korrekt und deiner macht keinen Sinn. Du willst die Adresse, die der Zeiger speichert umwandeln, und nicht dei Adresse des Zeigers an sich.