Namespaces
Variants

std::type_info:: operator==, std::type_info:: operator!=

From cppreference.net
C++
Utilities library
Type support
std::type_info
Member functions
type_info::operator== type_info::operator!=
(until C++20)
(C++11)
bool operator == ( const type_info & rhs ) const ;
(1) (noexcept desde C++11)
(constexpr desde C++23)
bool operator ! = ( const type_info & rhs ) const ;
(2) (noexcept desde C++11)
(hasta C++20)

Comprueba si los objetos se refieren a los mismos tipos.

El operador != es sintetizado a partir de operator== .

(since C++20)

Contenidos

Parámetros

rhs - otro objeto de información de tipo para comparar

Valor de retorno

true si la operación de comparación es verdadera, false en caso contrario.

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_constexpr_typeinfo 202106L (C++23) Constexpr para std::type_info::operator==

Ejemplo

Ejecutar este código 
#include <iostream>
#include <string>
#include <typeinfo>
#include <utility>
class person
{
public:
    explicit person(std::string n) : name_(std::move(n)) {}
    virtual const std::string& name() const { return name_; }
private:
    std::string name_;
};
class employee : public person
{
public:
    employee(std::string n, std::string p)
        : person(std::move(n)), profession_(std::move(p)) {}
    const std::string& profession() const { return profession_; }
private:
    std::string profession_;
};
void print_info(const person& p)
{
    if (typeid(person) == typeid(p))
        std::cout << p.name() << " is not an employee\n";
    else if (typeid(employee) == typeid(p))
    {
        std::cout << p.name() << " is an employee ";
        auto& emp = dynamic_cast<const employee&>(p);
        std::cout << "who works in " << emp.profession() << '\n';
    }
}
int main()
{
    print_info(employee{"Paul","Economics"});
    print_info(person{"Kate"});
#if __cpp_lib_constexpr_typeinfo
    if constexpr (typeid(employee) != typeid(person)) // C++23
        std::cout << "class `employee` != class `person`\n";
#endif
}

Salida posible: 

Paul is an employee who works in Economics
Kate is not an employee
class `employee` != class `person`

Véase también

verifica si el tipo referido precede al tipo referido de otro type_info
objeto en el orden definido por la implementación, es decir, ordena los tipos referidos
(función miembro pública)