A type could opt in to this generic hashing in two ways:

• inheriting from the HashableForTiedMembers tag struct,

• or defining a constexpr template variable that enables the concept used by the std::hash<T> specialization.

This design works well in C++20 and C++23. With C++26 (and GCC 16), however, language-level reflection lets us implement the same functionality without tied(), enabling a simpler and more robust reflection-based solution.

Introduction to C++ Reflection

C++26 introduces a long‑awaited feature that changes how we do metaprogramming. Reflection lets us inspect — and in some cases manipulate — program structure at compile time, simplifying tasks such as generic hashing, serialization, and code generation.

Reflection operator

The reflection operator ^^ is used to obtain a compile-time representation of an entity. It can be applied to various constructs such as variables, functions, types, namespaces, and enumerators. The result of applying the reflection operator is a reflection-value that contains information about the entity, such as its members, member names, types, and attributes. This value can be stored in a variable of opaque type std::meta::info and can be queried at compile-time using various reflection queries - meta-functions (defined in <meta> header).

struct Data { int id; std::string name };

std::meta::info r_type = ^^Data;
std::meta::info r_id_member = ^^Data::id;

Information obtained through reflection can be used for performing compile-time checks, generating code, or implementing custom behavior based on the structure of the code. The reflection value can be used to produce grammatical elements using so-called splicers with [: reflection-value :] syntax, this allows to generate code based on the structure of the code at compile time.

Data data{42, "forty-two"};

assert(data.[: r_id_member :] == 42); // the same as: data.id == 42

Simple example

Let's see a simple example that allows us to get member values using indexes:

#include <meta>
#include <string>

struct Person {
    int id;
    std::string name;
};

consteval std::meta::info member_number(int n) {
  if (n == 0) 
    return ^^Person::id; 
  else if (n == 1) 
    return ^^Person::name; 

  std::unreachable();
}

int main() {
  Person p{42, "John Doe"};

  p.[: member_number(0) :] = 665;  // Same as: p.id = 42;
  p.[: member_number(1) :] = "John Smith"; // Same as: p.name = "John Smith";
  p.[: member_number(5) :] = "John Doe";   // Error: member_number(5) is not a constant
}

In the example above, we define a struct Person with two members: id and name. We then create a consteval function, member_number, which takes an integer n and returns the reflection of the corresponding member of Person. This enables us to associate indexes with the struct's members. The consteval keyword ensures the function is evaluated at compile time, as reflection values can only be used in compile-time contexts.

In the main function, we create an instance of Person and use the splicer syntax to assign values to the members based on their index.

There's no need to manually index struct items. We can utilize the standard library's meta-function std::meta::nonstatic_data_members_of(^^T, context). This function accepts a reflected value of a type ^^Person) and returns a std::vector of the type's reflected non-static data members, allowing easy iteration or indexing.

Simplified implementation of member_number() function can look like this:

using namespace std::meta;

consteval info member_number(int n) {
  auto ctx = access_context::current();
  return nonstatic_data_members_of(^^Person, ctx)[n];
}

Another important aspect is the use of std::meta::access_context::current() to obtain the current access context. This is crucial because the meta-function must determine which entities are visible and accessible at the reflection point. The access context provides details about the scope and visibility of entities, allowing us to accurately reflect on the members of Person. If we need to reflect on private members, we can use std::meta::access_context::unchecked().

Hashing with Reflection

After this brief introduction to C++26 reflection, let's explore how it can be used to implement hashing for our types. In C++, a hashable type is one for which a specialization of the std::hash template exists. This specialization specifies how to compute a hash value for an object of that type.

template <>
struct std::hash<Person> {
    size_t operator()(const Person& p) const {
        size_t seed = 0;
        Utility::hash_combine(seed, p.id);   // Hashing an integer
        Utility::hash_combine(seed, p.name); // Hashing a string
        return seed;
    }
};

Before C++26, we had to either write our own specialization of std::hash for each type we wanted to hash or use a generic approach that employed std::tie() (or similar methods) to combine the hash values of individual members. I discussed the latter approach in my previous article. Now, we can implement a more elegant and efficient solution using reflection.

To begin, let's define a concept called Hashable. This concept will verify if a type is hashable by determining whether a specialization of std::hash exists for that type.

template <typename T>
concept Hashable = requires {
    { std::hash<T>{}(std::declval<T>()) } -> std::convertible_to<size_t>;
};

static_assert(Hashable<int>); // int is hashable
static_assert(Hashable<std::string>); // std::string is hashable
static_assert(Hashable<Person>); // Person is hashable

Next, we can create a generic hash function that utilizes reflection to compute the hash value for any hashable type. This function will iterate over the non-static data members of the type and combine their hash values using Utility::hash_combine() or a similar function like boost::hash_combine().

template <typename T>
    requires std::is_class_v<T>
size_t calculate_hash(const T &obj, size_t seed = 0)
{
    constexpr auto ctx = std::meta::access_context::unchecked();
    
    static constexpr auto r_data_members = 
        std::define_static_array(
            std::meta::nonstatic_data_members_of( ^^T, ctx)
        );

    // iteration over non-static data members
    template for (constexpr auto r_dm : r_data_members)
    {
        const auto& member_value = obj.[: r_dm :];
        Utility::hash_combine(seed, member_value);
    }

    return seed;
}

In this implementation, we first verify if the type T is a class or struct using std::is_class_v<T> trait. We then retrieve the non-static data members of the type with std::meta::nonstatic_data_members_of( ^^T, ctx), where ctx serves as the access context. To iterate over public, protected, and private members, we use std::meta::access_context::unchecked(), which grants access to all members regardless of their access specifier. Since std::meta::nonstatic_data_members_of returns a std::vector, we define a static array, r_data_members, to store these reflected data members. This setup allows us to employ a template for loop to iterate over the members at compile time. The standard library's std::define_static_array() helps bridge compile-time and runtime by defining a static array from a compile-time sequence. Using a template for loop, we iterate over the reflected data members. For each member, we access its value for the given object obj using the splicer syntax obj.[: r_dm :], and then combine the hash value.

Hashing Base Classes

Now, we can compute the combined hash value for all non-static data members. However, there's an important aspect we must address: the base classes or structs also need to be included in the hash calculation. Thanks to reflection, this task is less daunting than it might appear.

For a given type T, we can query its base classes using the meta-function std::meta::bases_of(^^T, ctx). After defining a static array of these reflected base types, we can iterate over them. To obtain the reflected value of a type, we apply std::meta::type_of(r_base). The entire snippet appears as follows:

static constexpr auto r_base_types = std::define_static_array(std::meta::bases_of(^^T, ctx));

static constexpr auto r_base_types = 
  std::define_static_array(std::meta::bases_of(^^T, ctx));

template for (constexpr auto r_base : r_base_types)
{
  using Base = typename[:std::meta::type_of(r_base):];
  static_assert(Hashing::Hashable<Base>, "Base class must be hashable");
  Utility::hash_combine(seed, static_cast<const Base &>(obj));
}

Once again we can use splicer to define an alias for a base type. When we want to obtain a type from refected value of type we need to use typename before.

Now the whole template function looks like this:

template <typename T>
    requires std::is_class_v<T>
size_t calculate_hash(const T &obj, size_t seed = 0)
{
    constexpr auto ctx = std::meta::access_context::unchecked();

    // combine hashes of base classes
    static constexpr auto r_base_types = std::define_static_array(std::meta::bases_of(^^T, ctx));

    template for (constexpr auto r_base : r_base_types)
    {
        using Base = typename[:std::meta::type_of(r_base):];
        static_assert(Hashing::Hashable<Base>, "Base class must be hashable");
        Utility::hash_combine(seed, static_cast<const Base &>(obj));
    }

    // combine hashes of non-static data members
    static constexpr auto r_data_members = std::define_static_array(std::meta::nonstatic_data_members_of(^^T, ctx));

    template for (constexpr auto r_dm : r_data_members)
    {
        const auto& member_value = obj.[:r_dm:];
        Utility::hash_combine(seed, member_value);
    }

    return seed;
}

Enabling Hashing for Custom Types

Now it is almost complete. The final consideration is how to enable specialization of std::hash for a custom type. One approach is to optin to our hashing implementation by defining an alias, enabled_for_hashing, within a custom class. This alias activates the generation of a hash value using our implementation.

struct EnabledForHashing_t {};

template <typename T>
concept EnabledForHashing = requires {
   typename T::enabled_for_hashing;
};

// specialization for types opted-in for hashing
template <EnabledForHashing T>
struct std::hash<T>
{
    size_t operator()(const T& obj) const
    {
        return calculate_hash(obj);
    }
};

class Person
{
    using enabled_for_hashing = EnabledForHashing_t;

    //...
};

Conclusion

C++26 reflection lets us replace the boilerplate and fragility of a tied() - based hashing approach with a cleaner, more robust solution. By using the reflection operator (^^) to inspect an object's structure at compile time, we can generate consistent, maintainable hash implementations without requiring every type to expose a std::tuple of members or to opt in via tags or template variables. The result is less repetitive code, fewer user-facing APIs to learn, and a lower risk of forgetting a member when you extend a type.

That said, adoption comes with practical considerations. Reflection-based hashing improves ergonomics and enables more work at compile time (including constexpr hashing) but relies on compiler support and the current state of language/library tooling. For projects that must support older standards or compilers, keeping a fallback (the tied() pattern or explicit std::hash specializations) is reasonable. For new code targeting modern toolchains (e.g., GCC 16 and other compilers that implement C++26 reflection), the reflection approach is worth adopting.

Going forward, use reflection-based hashing to reduce maintenance burden, but: test hash behaviour for stability across builds if you depend on hash persistence, document any members you intentionally skip from hashing, and pay attention to compiler bugs and implementation details as toolchains mature. Overall, C++26 reflection is a strong step toward safer, more concise metaprogramming—and hashing is a clear, practical win.

As a next step, we can extend our implementation with features like attributes that will allow us to discard some values for calculating the hash, but I think it is a nice subject for a next post.

The example of code can be found at: https://godbolt.org/z/1covqd36r

Now we’ll explore a more complex case. Let's create a generic implementation of a hashing function for a class or structure we develop.

Repetitive hashing

To provide a hash value for our custom object, we should write a std::hash specialization for our type.

A typical code example looks like this:

struct Person
{
    std::string first_name;
    std::string last_name;
    std::uint8_t age;
};

template <>
struct std::hash<Person> 
{
    size_t operator()(const Person& p) const
    {
        std::size_t seed{};
        some_lib::hash_combine(seed, p.first_name);
        some_lib::hash_combine(seed, p.last_name);
        some_lib::hash_combine(seed, p.age);
        return seed;    
    }
};

To calculate the hash value, we need to call a function that incrementally combines the hash values of all our data members. This function often comes from an external library, like Boost - boost::hash_combine(). This task is repetitive and tedious. Let's find a better solution.

Fold expressions & hash_combine

We can start by writing a variadic version of hash_combine(). Such a function should accept any number of arguments and return combined hash for all of them. This can be done using a fold expression with the “famous” , operator:

template <typename... TValues>
auto combined_hash(const TValues&... values)
{
    size_t seed{};
    (..., some_lib::hash_combine(seed, values));

    return seed;
}

Now we can simplify hashing with the following code:

template <>
struct std::hash<Person> 
{
    size_t operator()(const Person& p) const
    {
        return combined_hash(p.first_name, p.last_name, p.age);
    }
};

It's now possible to pass data members as arguments to our function.

Hashing & std::tie

As you might recall from my previous post, std::tie() can create a view that refers to the data members of our class. We used this to simplify the implementation of comparison operators:

struct Person
{
    std::string first_name;
    std::string last_name;
    std::uint8_t age;

    auto tied() const
    {
        return std::tie(first_name, last_name, age);
    }

    bool operator==(const Person& other) const
    {
        return tied() == other.tied();
    }
};

Can we use the same trick in our hash implementation?

We can try to tie the data members together and combine their hash values like this:

template <>
struct std::hash<Person> 
{
    size_t operator()(const Person& p) const
    {
        return combined_hash(p.tied());
    }
};

Now, we are passing a tuple as an argument to our combined_hash() function. Unfortunately, std::tuple does not have a std::hash<> specialization, so the compiler will generate an error. However, if we use boost::hash_combine(), it works because Boost can hash the tuples for us.

std::apply to the rescue

Let's pause for a moment and reexamine the code.

Now, we can calculate a combined hash for any set of hashable values:

std::string first_name = "John";
std::string last_name = "Smith";
uint8_t age = 42;
size_t hashed_value = combined_hash(first_name, last_name, age);

We need to call this function for arguments that are tied in a tuple. The code should look like this:

std::tuple tpl{"John"s, "Smith"s, 42};

size_t hashed_value = combined_hash(std::get<0>(tpl), std::get<1>(tpl), std::get<2>(tpl));

It occurs that in the standard library we have std::apply(F&& f, Tuple&& t) function that allows calling any function f with elements of t passed as arguments.

void foobar(const std::string& foo, int bar) 
{
    std::cout << "foobar(" << foo << ", " << bar << ")\n";
}

std::tuple args{"Foo"s, 42};
std::apply(foobar, args); // tha same as foobar(std::get<0>(args), std::get<1>(args))

Let’s apply std::apply to our needs :)

template <>
struct std::hash<Person> 
{
    size_t operator()(const Person& p) const
    {
        return std::apply(combined_hash, p.tied());
    }
};

Unfortunately, this is not enough. The compiler will complain that it cannot deduce the template parameter F for std::apply(F&& f, Tuple&& t). This is because our combined_hash() is a template function. We can easily solve this problem by wrapping the function in a closure (also known as a lambda). The working code will be as follows:

template <>
struct std::hash<Person> 
{
    size_t operator()(const Person& p) const
    {
        auto hasher = [](const auto&... args) { return combined_hash(args...); };
        return std::apply(hasher, p.tied());
    }
};

Generic hashing solution for future classes

This solution might seem complex, but it offers us a benefit. We can create a generic specialization for any custom type that has a tied() member function. We can provide a std::hash<T> specialization for each type that chooses to use our hashing implementation.

struct HashableForTiedMembers
{ };

template <typename T>
constexpr bool hashing_for_tied_members = false; 

template <typename T>
concept HashableForTied = std::derived_from<T, HashableForTiedMembers> || hashing_for_tied_members<T>;

template <HashableForTied T>
struct std::hash<T>
{
    size_t operator()(const T& value) const
    {
        auto hasher = [](const auto&... args) {
            return combined_hash(args...);
        };
        return std::apply(hasher, value.tied());
    }
};

The creator of the class can choose from two opt-in options:

• A class can inherit from the HashableForTiedMembers struct, which serves as a tag, enabling the compiler to specialize std::hash for that type. However, this option requires our class or struct to have constructors. For aggregates that derive from empty-base classes, additional {} are needed in the argument list, changing the syntax of object initialization.

  struct HashableForTiedMembers
  { };
  
  struct Person : HashableForTiedMembers
  {
      std::string first_name;
      std::string last_name;
      std::uint8_t age;
  
      Person(std::string first_name, std::string last_name, std::uint8_t age)
          : first_name{std::move(first_name)}
          , last_name{std::move(last_name)}
          , age{age}
      {
      }
  
      auto tied() const
      {
          return std::tie(first_name, last_name, age);
      }
  };
  

• Alternatively, we can define the opt-in tag externally using template variables.

  struct AggregatePerson
  {
      std::string first_name;
      std::string last_name;
      std::uint8_t age;
  
      auto tied() const
      {
          return std::tie(first_name, last_name, age);
      }
  };
  
  // opt-in hashing for AggregatePerson
  template <>
  constexpr bool hashing_for_tied_members<AggregatePerson> = true;
  

By using the tied() member function for hashing, we can easily implement operator==, which is needed for storing objects as keys in unordered associative containers. The following class can be used as a key in an unordered_map:

class Coordinate : public HashableForTiedMembers
{
public:
    Coordinate(int x, int y) noexcept
        : x_{x}
        , y_{y}
    { }

    auto tied() const noexcept
    {
        return std::tie(x_, y_);
    }

    bool operator==(const Coordinate& other) const noexcept
    {
        return tied() == other.tied();
    }

private:
    int x_;
    int y_;
};

int main()
{
    std::unordered_map<Coordinate, std::string> coordinates;
	coordinates.emplace(Coordinate{0, 0}, "origin");
	coordinates.emplace(Coordinate{1, 0}, "right");
	coordinates.emplace(Coordinate{0, 1}, "up");
	coordinates.emplace(Coordinate{1, 1}, "up-right");
}

Summary

In this blog post, I showed a way to implement hashing for types in a generic way.

I hope you find it interesting. Let me know if you do.

The sample code can be found at https://godbolt.org/z/7767MP1zK.

The typical code might look like this:

#include <string>
#include <cassert>
#include <cstdint>

struct Person
{
    std::string first_name;
    std::string last_name;
    std::uint8_t age;

    bool operator==(const Person& other) const
    {
        return first_name == other.first_name 
               && last_name == other.last_name
               && age == other.age;
    }

    bool operator<(const Person& other) const
    {
        if (first_name == other.first_name)
        {
            if (last_name == other.last_name)
            {
                return age < other.age;
            }

            return last_name < other.last_name;
        }

        return first_name < other.last_name;
    }
};

int main()
{
    Person p1{"John", "Doe", 33};
    Person p2{"John", "Doe", 33};
    Person p3{"John", "Don", 44};

    assert(p1 == p2);
    assert(p2 < p3);
}

We can simplify such a mundane task (especially for operator <) when we use std::tie() function from C++11. The code can be rewritten to:

#include <string>
#include <tuple>
#include <cassert>
#include <cstdint>

struct Person
{
    std::string first_name;
    std::string last_name;
    std::uint8_t age;

    bool operator==(const Person& other) const
    {
        return std::tie(first_name, last_name, age) == std::tie(other.first_name, other.last_name, other.age);
    }

    bool operator<(const Person& other) const
    {
        return std::tie(first_name, last_name, age) < std::tie(other.first_name, other.last_name, other.age);
    }
};

In C++14, we can make things even simpler by reducing repetition.

struct Person
{
    std::string first_name;
    std::string last_name;
    uint8_t age;

    auto tied() const
    {
        return std::tie(first_name, last_name, age);
    }

    bool operator==(const Person& other) const
    {
        return tied() == other.tied();
    }

    bool operator<(const Person& other) const
    {
        return tied() < other.tied();
    }
};

How it works?

Tuples with references

Let's start with what are known as reference tuples. These are tuples that hold references to specific values.

std::string name = "John";
std::uint8_t age = 42;

std::tuple<std::string&, std::uint8_t&> ref_tpl(name, age);

The created tuple called ref_tpl holds references to two variables: name and age. We can access them using the std::get<Index>() function:

std::cout << std::get<0>(ref_tpl) << "\n"; // prints: "John"

std::get<1>(ref_tpl) = 33; // assigns 33 to age variable

The tuple named ref_tpl holds references to two variables: name and age. We can access these variables using the std::get<Index>() function.

ref_tpl = std::make_tuple("Adam", 24);
assert(name == "Adam");
assert(age == 33);

std::tie

Now std::tie() comes in handy. We can easily create reference tuples like this:

auto ref_tpl = std::tie(name, age); // returns: std::tuple<std::string&, std::uint8_t&>

This function determines the types of the arguments and returns a tuple that holds references to the passed lvalue arguments.

So the tied() method in our struct returns tuple that hold references to object’s members:

struct Person
{
    std::string first_name;
    std::string last_name;
    uint8_t age;

    auto tied() const
    {
        return std::tie(first_name, last_name, age);
    }
};

Comparing tuples

Tuples can be compared in lexicographic order. They perform comparisons based on their corresponding members.

std::tuple<std::string, std::uint8_t> tpl1("John", 33);
std::tuple<std::string, std::uint8_t> tpl2("John", 33);

assert(tpl1 == tpl2);
assert(tpl1 == std::make_tuple("John", 33));
assert(tpl1 < std::make_tuple("John", 44));

You can also compare reference tuples:

std::string name = "John";
std::uint8_t age = 42;

assert((std::tie(name, age) == std::tuple<std::string, std::uint8_t>("John", 42)));
assert(std::tie(name, age) < std::make_tuple("John", 45));

Putting It All Together

Now our simplified code should be easy to understand.

struct Person
{
    std::string first_name;
    std::string last_name;
    std::uint8_t age;

    auto tied() const
    {
        return std::tie(first_name, last_name, age);
    }

    bool operator==(const Person& other) const
    {
        return tied() == other.tied();
    }

    bool operator<(const Person& other) const
    {
        return tied() < other.tied();
    }
};

The tied() member function returns a tuple with references to the object's members in a specific order. This tuple works like a read-only view of the object's members and can be compared with another tuple, letting us write any comparison operator in a single line.