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

From cppreference.com
< cpp‎ | types‎ | type info

bool operator==( const type_info& rhs ) const; |  | (until C++11)
bool operator==( const type_info& rhs ) const noexcept; |  | (since C++11) (until C++23)
constexpr bool operator==( const type_info& rhs ) const noexcept; |  | (since C++23)
bool operator!=( const type_info& rhs ) const; |  | (until C++11)
bool operator!=( const type_info& rhs ) const noexcept; |  | (since C++11) (until C++20)

Checks if the objects refer to the same types.

The `!=` operator is synthesized from `operator==`. | (since C++20)

### Parameters

rhs | - | another type information object to compare to

### Return value

true if the comparison operation holds true, false otherwise

### Notes

Feature-test macro | Value | Std
--- | --- | ---
`__cpp_lib_constexpr_typeinfo` | 202106L | (C++23)

### Example

Run this code

    #include <iostream>
    #include <typeinfo>
    #include <string>
    #include <utility>

    class person
    {
      public:
        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 constexpr (typeid(employee) != typeid(person)) // C++23
        {
            std::cout << "class `employee` != class `person`\n";
        }
    }

Output:

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

### See also

before | checks whether the referred type precedes referred type of another `type_info` object in the implementation defined order, i.e. orders the referred types (public member function)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/types/type_info/operator_cmp&oldid=141857"