identity Structure

std::identity (introduit en C++20) est un objet de fonction dont operator() l’argument est inchangé.

std::identity (C++20)

De nombreuses API de bibliothèque standard prennent un argument appelant tel qu’une fonction de projection ou de transformation. Si vous avez besoin de passer un appelant, mais que vous ne souhaitez pas modifier les données, transmettez std::identity. Il s’agit d’un algorithme courant dans les plages. De nombreuses <algorithm> surcharges de plages ont un paramètre de projection par défaut std::identity{}.

Syntaxe

struct identity
{
    template <class T>
    _NODISCARD constexpr T&& operator()(T&& t) const noexcept;
    using is_transparent = int;
};

Notes

Le is_transparent type de membre est une balise qui marque std::identity comme objet de fonction transparent. Sa présence indique que les algorithmes peuvent effectuer des comparaisons ou des projections sans avoir besoin de convertir les types en un formulaire commun. Cela est utile pour les conteneurs et algorithmes associatifs qui prennent en charge la recherche hétérogène, ce qui leur permet de comparer directement différents types sans construire d’objets temporaires.

Exemples

#include <algorithm>
#include <functional>
#include <iostream>
#include <ranges>
#include <vector>

int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9, 2, 6};

    // Ranges algorithms can apply a projection before comparison.
    // But if you don't want to apply a projection, i.e. you don't want to modify the data
    // before comparison, you can use std::identity to leave each element unchanged.
    // Here, std::identity{} means "project each element as itself".
    // So the comparator sees the original int values unchanged.
    std::ranges::sort(v, std::less{}, std::identity{});

    // This call is equivalent because std::identity{} is the default projection.
    // In both calls, elements are sorted directly; no field extraction or
    // value transformation happens first.
    std::ranges::sort(v);

    for (int n : v)
    {
        std::cout << n << ' ';
    }
    std::cout << '\n';
    // Output: 1 1 2 3 4 5 6 9
}

Cet exemple recherche une std::vector<std::string>std::string_view clé. Étant donné que std::identity le is_transparent membre est membre, l’algorithme sait comparer ces types directement. De cette façon, la clé n’est pas convertie en une conversion temporaire std::string uniquement pour effectuer la comparaison.

#include <algorithm>
#include <functional>
#include <iostream>
#include <ranges>
#include <string>
#include <string_view>
#include <vector>

int main()
{
    std::vector<std::string> words{"apple", "banana", "cherry", "date"};
    std::string_view key = "cherry";

    // `std::less<>` is transparent, so it can compare `std::string` and
    // `std::string_view` directly.
    // `std::identity` is also marked transparent (`is_transparent`), so the
    // projection stays type-flexible instead of forcing one fixed type.
    auto it = std::ranges::lower_bound(words, key, std::less<>{}, std::identity{});

    if (it != words.end() && *it == key)
    {
        std::cout << "Found: " << *it << '\n';
    }
}