Typecasting bei Structs

psychophoniac · **Verfasst:** 10.06.2009, 03:34

hi ich hab ne allgemeine frage, vll liegts dran, dass es vir uhr morgens ist, aber ich bin verwirrt.

also ich schreibe zur zeit an ner game engine, die event basiert ist. alles was die macht, soll durch events passieren, vom mesh laden bis zum frame rendern. warum usw ist erstmal nicht wichtig.

hierzu habe ich mir überlegt, dass ich structs verwende, die von einer grossen klasse, die von IEventReceiver geerbt hat, verschickt und ausgewertet werden.

das sieht dann so aus etwa, in einer extra datei:

Code:

struct tCustomEvent
{
 customEventType type;  //das ist ein enum, für jedes custom event gibts eins, zb frame rendern, mesh laden etc
}

struct tRenderFrameEvent : public tCustomEvent
{
 tCustomEvent::type = CET_RENDER_FRAME;
 bool useDebug;
}

soweit so gut.
benutzt wird das ganze so:

Code:

 tRenderFrameStruct rfs;
 rfs.useDebug = true;
 sendOutEvent(rfs);

wobei sendOutEvent so funktioniert:

Code:

void app::sendOutEvent(const tCustomEvent& ev)
{
    SEvent event;
    event.EventType = ::EET_USER_EVENT;
    event.UserEvent.UserData1 = ev.type;
    event.UserEvent.UserData2 = (s32)&ev;
    device->postEventFromUser(event);
};

so. das klappt wunderbar.
die events werden folgendermaßen abgefangen:

Code:

bool app::OnEvent(const SEvent& event)
{
    switch(event.EventType)
    {
        case EET_USER_EVENT:
                            {
                                switch(event.UserEvent.UserData1)
                                {
                                    case CET_CREATE_CAMERA:
                                                        {
                                                            #ifdef DEBUG
                                                                std::cout << "CREATECAMERASTRUCT RECEIVED" << std::endl;
                                                            #endif
                                                            
                                                            //in dieser zeile klappt was nicht...
                                                            tCreateCamStruct* cStruct = (tCreateCamStruct*)event.UserEvent.UserData2;
                                                            switch(cStruct->typeOfCam)
                                                                   {
                                                                        case scene::ESNT_CAMERA_FPS:
                                                                                                    {
                                                                                                        //blablabla
                                                                                                        return true;
                                                                                                    };break;
                                                                        default: return false;
                                                                   };

                                                        };break;

//...............USW

der witz ist jetzt, dass das mist ding zwar den richtigen eventTyp rausfindet, aber beim typecast verbock ichs irgendwie.
wenn zb ein core::stringc im struct war, ist der leer, oder irgend ein enum hat auf einmal völlig falsche werte.
der zeiger auf cStruct hier ist nich null, das ist das komische.
wie muss ich casten?

Scarabol · **Verfasst:** 10.06.2009, 07:55

hmm,

also bevor du jetzt irgendwie auf C++ oder den Compiler schimpfst solltest du alle Daten bzw. Eingaben von dir nochmal checken. Du solltest z.B. prüfen ob der richtige Pointer auf die Daten oder ein Pointer auf einen Pointer übergeben wird, hier empfiehlt sich vllt. auch const. Ansonsten würde mir einfallen, dass du einfach eine andere Stelle im Programm hast, z.B. ein Array was einfach in deine Daten reinschreibt also die Daten mal debuggen bevor du sie an die Funktion weitergibst...

Gruß
Scarabol

frodenius · **Verfasst:** 10.06.2009, 11:32

das simpelste wäre, nach dieser zeile:

Code:

event.UserEvent.UserData2 = (s32)&ev;

direkt den cast zu machen und die daten der dereferenzierten struct auszugeben.

Sudi · **Registriert:** 12.04.2007, 11:47 **Beiträge:** 108

Ich denke mal es liegt daran das irrlicht nicht sofort das event verarbeitet sondern erst beim nächsten irr::IrrlichtDevice::run().
Somit ist dein pointer ungültig und der speicher wahrschenlich mit neuen daten beschrieben.
Versuch mal:

Code:

tRenderFrameStruct* rfs = new tRenderFrameStruct;
rfs->useDebug = true;
sendOutEvent(rfs);

Code:

void app::sendOutEvent(const tCustomEvent* ev)
{
    SEvent event;
    event.EventType = ::EET_USER_EVENT;
    event.UserEvent.UserData1 = ev->type;
    event.UserEvent.UserData2 = (s32)ev;
    device->postEventFromUser(event);
};

Code:

bool app::OnEvent(const SEvent& event)
{
    switch(event.EventType)
    {
        case EET_USER_EVENT:
                            {
                                   tCustomEvent* eventBase = (tCustomEvent*)event.UserEvent.UserData2;
                                   //den kram hier und danach
                                   delete eventBase;
                             }
    }
}

Dabei musst du nur aufpassen das auch wirklich alle userEvents von dir sind und auch wirklich alle gelöscht werden sollen. Außerdem weiß ich grad nich wie das mit 64bit systemen ist. sind da nicht pointer 64 anstelle von 32bit. Weiß aber auch nicht wie sich da irr::s32 verhält hab kein 64bit system.

Sylence · **Verfasst:** 18.06.2009, 07:11

s32 ist immer signed und 32bit groß

psychophoniac · **Verfasst:** 08.07.2009, 17:44

hi, ich hab das genze nochmal von neu geschrieben, aber das problem bleibt das alte. das ganze läuft jetzt nur mit klassen, ist ein bisschen praktischer.
mir ist noch was eingefallen, ich hab ein 64-bit system (vista), muss ich da nicht bei dem einen typecast wo man die adresse speichert in den userData2 auch einen s64-cast machen? weil der pointer ja folglich auch 64 bit hat, und ich weiss nicht genau ob irrlicht 64-bit unterstützt oder nur virtuell und mit 32-bit pintern läuft?!
könnte es daran liegen?

edit: mir fällt gerade auf das es genau dieselbe frage ist, die sudi eben auch gestellt hat ^^
also, wie ist das?

Zerotag · **Registriert:** 16.01.2008, 12:31 **Beiträge:** 79

Auf einem 64 Bit-System solltest Du die 64 Bit Zeiger nicht in 32Bit Int-Werte konvertieren, da gehen Dir Informationen verloren.

Da SUserEvent.UserData1 und SUserEvent.UserData2 irr::s32 Werte sind und wenn ich das richtig sehe dann müsstest Du den 64 Bit Zeiger zerlegen und hinterher wieder richtig zusammen bauen.

Hatte gerade mal Langeweile und hab das mal gemacht.

Code:

#include <memory.h>

struct tBlaBlubb {
  __int32 Int32;
  __int64 Int64;
};

int main() {
  __int64 x;
  __int64 *px;
  __int64 ppx;
  __int64 ppx1;

  tBlaBlubb *t = new tBlaBlubb;
  t->Int32=4;
  t->Int64=8;

  x = 12345;
  px = &x;
  //*px = 54321;

//  ppx = (__int64)px;
  ppx = (__int64)t;

  // In Char-Array zerlegen
  unsigned char buf[8];
  memcpy(buf, &ppx, sizeof(__int64));      // Von Int nach Char-Array
 
  // Vorbereiten für das verteilen auf 32 Bit Ints
  unsigned char buf1[4];
  unsigned char buf2[4];
  for(__int32 i = 0; i < 4; i++) {
    buf1[i] = buf[i];
    buf2[i] = buf[i+4];
  }

  // Auf 32 Bit Ints verteilen
  __int32 i, j;
  memcpy(&i, buf1, sizeof(__int32));
  memcpy(&j, buf2, sizeof(__int32));

  // Hier halt alles wieder rückwärts
  unsigned char buf3[4];
  unsigned char buf4[4];
  memcpy(buf3, &i, sizeof(__int32));
  memcpy(buf4, &j, sizeof(__int32));

  unsigned char buff[8];
  for(__int32 ii = 0; ii < 4; ii++) {
    buff[ii] = buf3[ii];
    buff[ii+4] = buf4[ii];
  }

  memcpy(&ppx1, buff, sizeof(__int64));     // Von Char-Array nach Int
//  __int64 *px1 = (__int64*)ppx1;
  tBlaBlubb *t2 = (tBlaBlubb*)ppx1;


  return 0;
}

EDIT:
Nochmal geändert und direkt am Beispiel eines Structs gemacht.
Einfach am Ende *t und *t2 im Debugger angucken.

Sylence · **Verfasst:** 12.07.2009, 15:51

Warum das rumgegurkte mit dem char array ?

Code:

__int64 value64;

// Auseinander stückeln
__int32 hi32 = ( value & (0xFFFFFFFF << 32) );
__int32 lo32 = ( value & (0x00000000FFFFFFFF) );

// Und wieder zusammensetzen
value64 = ( hi32<<32 ) | lo32;

Zerotag · **Registriert:** 16.01.2008, 12:31 **Beiträge:** 79

Gute Frage.

Vermutlich weil ich gerade in C# Code zum serialisieren von Forms geschrieben habe und da konvertier ich im Prinzip alles in Byte-Arrays mit einer bestimmten Struktur, da war ich gerade drin.

desx · **Registriert:** 17.11.2007, 11:15 **Beiträge:** 19

Sylence hat geschrieben:

Warum das rumgegurkte mit dem char array ?

Code:

__int64 value64;

// Auseinander stückeln
__int32 hi32 = ( value & (0xFFFFFFFF << 32) );
__int32 lo32 = ( value & (0x00000000FFFFFFFF) );

// Und wieder zusammensetzen
value64 = ( hi32<<32 ) | lo32;

Müsste das nicht eigentlich so gehen:

Code:

__int64 value64;

// Auseinander stückeln
__int32 hi32 = ( value & (0xFFFFFFFF << 32) >> 32); //<--
__int32 lo32 = ( value & (0x00000000FFFFFFFF) );

// Und wieder zusammensetzen
value64 = ( hi32 << 32 ) | lo32;

Und warum nicht gleich so:

Code:

struct Converter
{
   union
   {
      struct
      {
         s32 Low;
         s32 High;
      };

      s64 LongLong;
   };
};

Typecasting bei Structs

Wer ist online?