Ermitteln des Objekttyps in C ++

Ich habe eine Klasse A und eine andere Klasse, die davon erbt, B. Ich überschreibe eine Funktion, die ein Objekt vom Typ A als Parameter akzeptiert, also muss ich ein A akzeptieren. Später rufe ich jedoch Funktionen auf, die nur B hat. Daher möchte ich false zurückgeben und nicht fortfahren, wenn das übergebene Objekt nicht vom Typ B ist.

Wie kann ich am besten herausfinden, welcher Typ das an meine Funktion übergebene Objekt ist?

dynamic_cast sollte den Trick machen

TYPE& dynamic_cast<TYPE&> (object);
TYPE* dynamic_cast<TYPE*> (object);

Das dynamic_castSchlüsselwort wandelt ein Datum von einem Zeiger oder Referenztyp in einen anderen um und führt eine Laufzeitprüfung durch, um die Gültigkeit der Umwandlung sicherzustellen.

Wenn Sie versuchen, einen Zeiger auf einen Typ zu erstellen, der kein Typ eines tatsächlichen Objekts ist, ist das Ergebnis der Umwandlung NULL. Wenn Sie versuchen, eine Umwandlung vorzunehmen, um auf einen Typ zu verweisen, der kein Typ eines tatsächlichen Objekts ist, löst die Umwandlung eine bad_castAusnahme aus.

Stellen Sie sicher, dass in der Basisklasse mindestens eine virtuelle Funktion vorhanden ist, damit dynamic_cast funktioniert.

Wikipedia-Thema Informationen zum Laufzeit-Typ

RTTI ist nur für polymorphe Klassen verfügbar, dh sie verfügen über mindestens eine virtuelle Methode. In der Praxis ist dies keine Einschränkung, da Basisklassen über einen virtuellen Destruktor verfügen müssen, damit Objekte abgeleiteter Klassen eine ordnungsgemäße Bereinigung durchführen können, wenn sie aus einem Basiszeiger gelöscht werden.

Dynamische Besetzung ist das Beste für Ihre Beschreibung des Problems, aber ich möchte nur hinzufügen, dass Sie den Klassentyp finden können mit:

#include <typeinfo>

...
string s = typeid(YourClass).name()

Dies wird als RTTI bezeichnet , aber Sie möchten Ihr Design hier mit ziemlicher Sicherheit überdenken, da das Finden des Typs und das Ausführen spezieller Dinge darauf Ihren Code spröder macht.

Um vollständig zu sein, werde ich Robocide aufbauen und darauf hinweisen, dass typeides alleine verwendet werden kann, ohne name () zu verwenden:

#include <typeinfo>
#include <iostream>

using namespace std;

class A {
public:
    virtual ~A() = default; // We're not polymorphic unless we
                            // have a virtual function.
};
class B : public A { } ;
class C : public A { } ;

int
main(int argc, char* argv[])
{
    B b;
    A& a = b;

    cout << "a is B: " << boolalpha << (typeid(a) == typeid(B)) << endl;
    cout << "a is C: " << boolalpha << (typeid(a) == typeid(C)) << endl;
    cout << "b is B: " << boolalpha << (typeid(b) == typeid(B)) << endl;
    cout << "b is A: " << boolalpha << (typeid(b) == typeid(A)) << endl;
    cout << "b is C: " << boolalpha << (typeid(b) == typeid(C)) << endl;
}

Ausgabe:

a is B: true
a is C: false
b is B: true
b is A: false
b is C: false

Betten Sie wahrscheinlich ein ID- "Tag" in Ihre Objekte ein und verwenden Sie es, um zwischen Objekten der Klasse A und Objekten der Klasse B zu unterscheiden.

Dies zeigt jedoch einen Fehler im Design. Idealerweise sollten die Methoden in B, die A nicht hat, Teil von A sein, aber leer bleiben, und B überschreibt sie. Dies beseitigt den klassenspezifischen Code und ist eher im Sinne von OOP.

Du suchst nach dynamic_cast<B*>(pointer)

Weil deine Klasse nicht polymorph ist. Versuchen:

struct BaseClas { int base; virtual ~BaseClas(){} };
class Derived1 : public BaseClas { int derived1; };

Jetzt BaseClasist polymorph. Ich habe die Klasse in struct geändert, da die Mitglieder einer struct standardmäßig öffentlich sind.

Ihre Beschreibung ist etwas verwirrend.

Obwohl einige C ++ - Implementierungen Mechanismen dafür haben, sollten Sie im Allgemeinen nicht nach dem Typ fragen. Stattdessen sollten Sie einen dynamic_cast für den Zeiger auf A ausführen. Dies führt dazu, dass zur Laufzeit der tatsächliche Inhalt des Zeigers auf A überprüft wird. Wenn Sie ein B haben, erhalten Sie Ihren Zeiger auf B. Andernfalls erhalten Sie eine Ausnahme oder Null.

Wie andere angegeben haben, können Sie dynamic_cast verwenden. Wenn Sie jedoch im Allgemeinen dynamic_cast verwenden, um den Typ der abgeleiteten Klasse herauszufinden, an der Sie arbeiten, weist dies auf ein schlechtes Design hin. Wenn Sie eine Funktion überschreiben, die den Zeiger von A als Parameter verwendet, sollte sie in der Lage sein, mit den Methoden / Daten der Klasse A selbst zu arbeiten, und sollte nicht von den Daten der Klasse B abhängen. In Ihrem Fall, anstatt sie zu überschreiben Sind Sie sicher, dass die Methode, die Sie schreiben, nur mit Klasse B funktioniert, sollten Sie eine neue Methode in Klasse B schreiben.

Verwenden Sie überladene Funktionen. Benötigt keine Unterstützung für dynamic_cast oder RTTI:

class A {};
class B : public A {};

class Foo {
public:
    void Bar(A& a) {
        // do something
    }
    void Bar(B& b) {
        Bar(static_cast<A&>(b));
        // do B specific stuff
    }
};

Wenn Sie auf die Boost-Bibliothek zugreifen können , benötigen Sie möglicherweise die Funktion type_id_with_cvr () , die den Datentyp bereitstellen kann , ohne die Modifikatoren const, volatile und &&& zu entfernen . Hier ist ein einfaches Beispiel in C ++ 11:

#include <iostream>
#include <boost/type_index.hpp>

int a;
int& ff() 
{
    return a;
}

int main() {
    ff() = 10;
    using boost::typeindex::type_id_with_cvr;
    std::cout << type_id_with_cvr<int&>().pretty_name() << std::endl;
    std::cout << type_id_with_cvr<decltype(ff())>().pretty_name() << std::endl;
    std::cout << typeid(ff()).name() << std::endl;
}

Hoffe das ist nützlich.