Ich moechte pruefen, ob ein Pointer von einem bestimmten Typ ist. Folgendes habe ich dazu gemacht:

void Test::update(void *sender)
{
  if ( (MyObject*) sender != 0) )
  {
    //DoSomething
  }
}

Ich moechte in diesem Fall also pruefen, ob sender vom Typ "MyObject" ist.
Egal von welchem Typ das uebergebene Objekt bei "update" ist, die if-Bedingung ist immer true. Warum ist das so? Was mache ich falsch ?

Dankeschoen fuer die Hilfe!
Andy

3 Dinge:
1.) dynamic_cast<> kann das prinzipiell aber
2.) die "eingebaute" Laufzeitpolymorphie ist unendlich viel besser als "manuell gebastelte" .
3.) Falls Du daran denkst, C++-Objekte "binär zu transportieren" (über die Leitung oder ein File): Lieber nicht.

Gruß,

Simon2.

Abhilfe für dein Problem würde ein Interface (abstrakte Klasse) mit der Update Methode machen.

Simon

2.) die "eingebaute" Laufzeitpolymorphie ist unendlich viel besser als "manuell gebastelte" .

Danke fuer die Antwort, aber das verstehe ich nicht ganz... Welche eingebaute Laufzeitpolymorphie meinst du?

//interface
struct Updatable
{
    virtual void update() = 0;
};

//irgendwas, das geupdated werden kann
class SenderType_A : public Updatable
{
public:
    //...
    void update()
    {
        std::cout << "Update A\n";
        //...
    }
private:
    //...
};

//irgendwas anderes, das geupdated werden kann
class SenderType_B : public Updatable
{
public:
    //...
    void update()
    {
        std::cout << "Update B\n";
        //...
    }
private:
    //...
};

//eine Funktion die updated
void test(Updatable& objectToUpdate)
{
    //...
    objectToUpdate.update();
    //...
}

int main()
{   
    //ein updatebares Objekt
    SenderType_A sender_A;
    //ein anderes updatebares Objekt
    SenderType_B sender_B;

    //beide updaten
    test(sender_A);
    test(sender_B);
}

struct MyObject { // ist einfach eine "public-class" (bin faul)
   virtual void DoSomething() = 0; // MUSS für Benutzung überschrieben werden
   virtual ~MyObject() {} // Dtor sollte bei "abzuleitenden Klassen" virtual sein.
};

struct MySpecialObject1 : MyObject {
   void DoSomething() { cout << "mache dies\n"; }
};

struct MySpecialObject2 : MyObject {
   void DoSomething() { cout << "mache das\n"; }
};

struct Test {
   void update(MyObject *sender) {   sender->DoSomething();  }
};

int main() {
   Test t;
   MySpecialObject1 mo1;
   MySpecialObject2 mo2;

   t.update(&mo1); // => "mache dies"
   t.update(&mo2); // => "mache das"
...

Gruß,

Simon2.

[...]

Sollten die "SpecialObjects" nicht von MyObject erben?

Simon2 schrieb:

[...]

Sollten die "SpecialObjects" nicht von MyObject erben?

Das Testament wird momentan noch von "Test" angefochten.

Simon2 schrieb:

[...]

Sollten die "SpecialObjects" nicht von MyObject erben?

Natürlich!

Danke,

Simon2.