# std::type_index

> C++ Atlas: `cppatlas.com/w/cpp/types/type_index` | Source: https://en.cppreference.com/w/cpp/types/type_index | Domain: Type support | Standards: C++11, C++20

The type_index class is a wrapper class around a std::type_info object, that can be used as index in associative and unordered associative containers.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <typeindex>
class type_index; // (since C++11)
```

The `type_index` class is a wrapper class around a `std::type_info` object, that can be used as index in associative and unordered associative containers. The relationship with `type_info` object is maintained through a pointer, therefore `type_index` is *CopyConstructible* and *CopyAssignable*.

### Member functions

- (constructor): constructs the object (public member function)
- (destructor) (implicitly declared): destroys the `type_index` object (public member function)
- `operator=` (implicitly declared): assigns a `type_index` object (public member function)
- `operator==`, `operator!=` (removed in C++20), `operator<`, `operator<=`, `operator>`, `operator>=`, `operator<=>` (C++20): compares the underlying `std::type_info` objects (public member function)
- `hash_code`: returns hashed code (public member function)
- `name`: returns implementation defined name of the type, associated with underlying `type_info` object (public member function)

### Helper classes

- `std::hash<std::type_index>` (C++11): hash support for `std::type_index` (class template specialization)

### Example

The following program is an example of an efficient type-value mapping.

```cpp
#include <iostream>
#include <memory>
#include <string>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>

struct A
{
    virtual ~A() {}
};

struct B : A {};
struct C : A {};

int main()
{
    std::unordered_map<std::type_index, std::string> type_names;

    type_names[std::type_index(typeid(int))] = "int";
    type_names[std::type_index(typeid(double))] = "double";
    type_names[std::type_index(typeid(A))] = "A";
    type_names[std::type_index(typeid(B))] = "B";
    type_names[std::type_index(typeid(C))] = "C";

    int i;
    double d;
    A a;

    // note that we're storing pointer to type A
    std::unique_ptr<A> b(new B);
    std::unique_ptr<A> c(new C);

    std::cout << "i is " << type_names[std::type_index(typeid(i))] << '\n';
    std::cout << "d is " << type_names[std::type_index(typeid(d))] << '\n';
    std::cout << "a is " << type_names[std::type_index(typeid(a))] << '\n';
    std::cout << "*b is " << type_names[std::type_index(typeid(*b))] << '\n';
    std::cout << "*c is " << type_names[std::type_index(typeid(*c))] << '\n';
}
```

Output:

```text
i is int
d is double
a is A
*b is B
*c is C
```

### See also

- [`type_info`](https://en.cppreference.com/w/cpp/types/type_info): contains some type’s information, the class returned by the typeid operator (class)

---
Attribution: content from https://en.cppreference.com/w/cpp/types/type_index (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.