'typeid' contro 'typeof' in C ++

Mi chiedo quale sia la differenza tra typeide typeofin C ++. Ecco quello che so:

• typeidè menzionato nella documentazione per type_info definita nel file di intestazione C ++ typeinfo .

• typeofè definito nell'estensione GCC per C e nella libreria Boost C ++ .

Inoltre, ecco il test del codice di test che ho creato dove ho scoperto che typeidnon restituisce ciò che mi aspettavo. Perché?

main.cpp

#include <iostream>  
#include <typeinfo>  //for 'typeid' to work  

class Person {  
    public:
    // ... Person members ...  
    virtual ~Person() {}  
};  

class Employee : public Person {  
    // ... Employee members ...  
};  

int main () {  
    Person person;  
    Employee employee;  
    Person *ptr = &employee;  
    int t = 3;  

    std::cout << typeid(t).name() << std::endl;  
    std::cout << typeid(person).name() << std::endl;   // Person (statically known at compile-time)  
    std::cout << typeid(employee).name() << std::endl; // Employee (statically known at compile-time)  
    std::cout << typeid(ptr).name() << std::endl;      // Person * (statically known at compile-time)  
    std::cout << typeid(*ptr).name() << std::endl;     // Employee (looked up dynamically at run-time  
                                                       // because it is the dereference of a pointer
                                                       // to a polymorphic class)  
 }  

produzione:

bash-3.2$ g++ -Wall main.cpp -o main  
bash-3.2$ ./main   
i  
6Person  
8Employee  
P6Person  
8Employee

Il linguaggio C ++ non ha nulla del genere typeof. Devi guardare alcune estensioni specifiche del compilatore. Se stai parlando di GCC typeof, una funzione simile è presente in C ++ 11 tramite la parola chiave decltype. Ancora una volta, C ++ non ha tale typeofparola chiave.

typeidè un operatore di linguaggio C ++ che restituisce informazioni di identificazione del tipo in fase di esecuzione. In pratica restituisce un type_infooggetto, che è paragonabile all'uguaglianza con altri type_infooggetti.

Si noti che l'unica proprietà definita type_infodell'oggetto restituito è la sua comparabilità di uguaglianza e non-uguaglianza, vale a dire che gli type_infooggetti che descrivono tipi diversi devono confrontare non uguali, mentre gli type_infooggetti che descrivono lo stesso tipo devono confrontare uguali. Tutto il resto è definito dall'implementazione. I metodi che restituiscono vari "nomi" non sono garantiti per restituire qualcosa di leggibile dall'uomo, e nemmeno sono garantiti per restituire nulla.

Si noti inoltre che quanto sopra probabilmente implica (sebbene lo standard non sembri menzionarlo esplicitamente) che applicazioni consecutive typeiddello stesso tipo potrebbero restituire type_infooggetti diversi (che, ovviamente, devono ancora confrontare uguali).

La differenza principale tra i due è la seguente

• typeof è un costrutto in fase di compilazione e restituisce il tipo come definito in fase di compilazione
• typeid è un costrutto di runtime e quindi fornisce informazioni sul tipo di runtime del valore.

Riferimento typeof: http://www.delorie.com/gnu/docs/gcc/gcc_36.html

Riferimento typeid: https://en.wikipedia.org/wiki/Typeid

typeidpuò funzionare in fase di runtime e restituire un oggetto che descrive il tipo di runtime dell'oggetto, che deve essere un puntatore a un oggetto di una classe con metodi virtuali per poter archiviare RTTI (informazioni sul runtime) nella classe. Può anche fornire il tipo di tempo di compilazione di un'espressione o un nome di tipo, se non viene fornito un puntatore a una classe con informazioni sul tipo di runtime.

typeofè un'estensione GNU e ti dà il tipo di qualsiasi espressione in fase di compilazione. Ciò può essere utile, ad esempio, nel dichiarare variabili temporanee nelle macro che possono essere utilizzate su più tipi. In C ++, in genere si utilizzano invece i modelli .

Rispondere alla domanda aggiuntiva:

il mio codice di test seguente per typeid non genera il nome di tipo corretto. Cosa c'è che non va?

Non c'è niente di sbagliato. Quello che vedi è la rappresentazione in forma di stringa del nome del tipo. Il C ++ standard non obbliga i compilatori ad emettere il nome esatto della classe, spetta solo all'implementatore (fornitore del compilatore) decidere quale sia adatto. In breve, i nomi dipendono dal compilatore.

Questi sono due strumenti diversi. typeofrestituisce il tipo di un'espressione, ma non è standard. In C ++ 0x c'è qualcosa chiamato decltypeche fa lo stesso lavoro AFAIK.

decltype(0xdeedbeef) number = 0; // number is of type int!
decltype(someArray[0]) element = someArray[0];

Considerando che typeidviene utilizzato con tipi polimorfici. Ad esempio, supponiamo che catderivi animal:

animal* a = new cat; // animal has to have at least one virtual function
...
if( typeid(*a) == typeid(cat) )
{
    // the object is of type cat! but the pointer is base pointer.
}

typeid fornisce il tipo di dati in fase di esecuzione, quando richiesto. Typedef è un costrutto in fase di compilazione che definisce un nuovo tipo come indicato in seguito. Non esiste un tipo di C in Output che appare come (mostrato come commento inscritto):

std::cout << typeid(t).name() << std::endl;  // i
std::cout << typeid(person).name() << std::endl;   // 6Person
std::cout << typeid(employee).name() << std::endl; // 8Employee
std::cout << typeid(ptr).name() << std::endl;      // P6Person
std::cout << typeid(*ptr).name() << std::endl;     //8Employee

Puoi usare Boost demangle per ottenere un bel nome:

#include <boost/units/detail/utility.hpp>

e qualcosa del genere

To_main_msg_evt ev("Failed to initialize cards in " + boost::units::detail::demangle(typeid(*_IO_card.get()).name()) + ".\n", true, this);