Transparent function objects are function-like types that support heterogeneous operations. There are essentially two kinds of such types:
transparent comparators and transparent hashers. For instance, a transparent comparator for strings would support comparing a std::string
with string-like types (such as char const* or std::string_view`).
These transparent function objects are interesting for search-optimized containers such as std::set and std::map,
including their multi and unordered variants. When transparent comparators/hashers are used, the containers enable
additional overloads for many operations that support types different from their key_type.
For example, std::set<std::string> is not using transparent comparators. Invoking many member functions with a
non-std::string argument leads to, implicitly or explicitly, creating a temporary std::string object because the functions
only support an argument of the key_type.
// Given a container c with a non-transparent comparator:
std::set<std::string> c = ...;
// Calling "find" with a C-style string (char const*)
auto it = c.find("Nemo");
// is equivalent to
auto it = c.find(std::string{"Nemo"});
// Calling C++20 "contains" with a std::string_view sv
// does not compile since conversion has to be explicit:
// if (c.contains(sv)) { ... }
// It has to be rewritten like this:
if (c.contains(std::string(sv))) { ... }
Using heterogeneous comparison and hashing directly benefits the application performance since unnecessary temporaries can be avoided. An excellent
and very common example of when transparent functions objects are beneficial is when the key_type is std::string.
Starting from C++14, transparent function objects can enable additional overloads for these containers: std::set,
std::map, std::unordered_set, std::unordered_map, std::multiset, std::multimap,
std::unordered_multiset, and std::unordered_multimap.
Depending on the C++ version and the container type, the overloads are available for these operations:
- Lookup functions, such as:
find, count, lower_bound, upper_bound, equal_range,
contains.
- Mutation functions, such as:
erase, extract, insert, insert_or_assign.
For this reason, this rule detects using std::string as the key for the associative container types mentioned previously when
heterogeneous operations are disabled.
