Trovare il tipo di un oggetto in C ++

Ho una classe A e un'altra classe che eredita da essa, B. Sto sostituendo una funzione che accetta un oggetto di tipo A come parametro, quindi devo accettare un A. Tuttavia, in seguito chiamo funzioni che solo B ha, quindi voglio restituire false e non procedere se l'oggetto passato non è di tipo B.

Qual è il modo migliore per scoprire quale tipo di oggetto è passato alla mia funzione?

dynamic_cast dovrebbe fare il trucco

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

Il dynamic_cast parola chiave esegue il cast di un dato da un puntatore o tipo di riferimento a un altro, eseguendo un controllo di runtime per garantire la validità del cast.

Se si tenta di eseguire il cast al puntatore a un tipo che non è un tipo di oggetto reale, il risultato del cast sarà NULL. Se si tenta di eseguire il cast per fare riferimento a un tipo che non è un tipo di oggetto reale, il cast genererà bad_castun'eccezione.

Assicurarsi che vi sia almeno una funzione virtuale nella classe Base per far funzionare dynamic_cast.

Argomento di Wikipedia Informazioni sul tipo di runtime

RTTI è disponibile solo per le classi polimorfiche, il che significa che hanno almeno un metodo virtuale. In pratica, questo non è un limite perché le classi base devono avere un distruttore virtuale per consentire agli oggetti delle classi derivate di eseguire una corretta pulizia se vengono eliminati da un puntatore base.

Il cast dinamico è il migliore per la tua descrizione del problema, ma voglio solo aggiungere che puoi trovare il tipo di classe con:

#include <typeinfo>

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

Questo si chiama RTTI , ma quasi sicuramente vuoi riconsiderare il tuo progetto qui, perché trovare il tipo e fare cose speciali basate su di esso rende il tuo codice più fragile.

Per essere completo, costruirò il build-off di Robocide e farò notare che typeidpuò essere usato da solo senza usare name ():

#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;
}

Produzione:

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

Probabilmente incorporare nei tuoi oggetti un "tag" ID e usarlo per distinguere tra oggetti di classe A e oggetti di classe B.

Questo tuttavia mostra un difetto nel design. Idealmente quei metodi in B che A non ha, dovrebbero essere parte di A ma lasciati vuoti e B li sovrascrive. Questo elimina il codice specifico della classe ed è più nello spirito di OOP.

Stai cercando dynamic_cast<B*>(pointer)

Perché la tua classe non è polimorfica. Provare:

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

Ora BaseClasè polimorfico. Ho cambiato classe in struct perché i membri di una struct sono pubblici per impostazione predefinita.

La tua descrizione è un po 'confusa.

In generale, anche se alcune implementazioni in C ++ hanno meccanismi per questo, non dovresti chiedere del tipo. Invece, dovresti fare un Dynamic_cast sul puntatore ad A. Ciò che farà è che in fase di esecuzione, verrà verificato il contenuto effettivo del puntatore ad A. Se hai una B, otterrai il puntatore su B. In caso contrario, otterrai un'eccezione o null.

Come altri hanno indicato, puoi usare dynamic_cast. Ma generalmente usare dynamic_cast per scoprire il tipo di classe derivata su cui stai lavorando indica la cattiva progettazione. Se si esegue l'override di una funzione che accetta il puntatore di A come parametro, dovrebbe essere in grado di lavorare con i metodi / i dati della stessa classe A e non dovrebbe dipendere dai dati della classe B. Nel proprio caso invece di sovrascrivere se si sei sicuro che il metodo che stai scrivendo funzionerà solo con la classe B, quindi dovresti scrivere un nuovo metodo nella classe B.

Utilizzare funzioni sovraccaricate. Non richiede dynamic_cast o nemmeno il supporto 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
    }
};

Se puoi accedere alla libreria boost, forse la funzione type_id_with_cvr () è ciò di cui hai bisogno, che può fornire il tipo di dati senza rimuovere i modificatori const, volatile e & & && . Ecco un semplice esempio 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;
}

Spero che sia utile