Bagaimanakah saya boleh menggunakan tupel sebagai kunci dalam peta tidak tersusun tanpa menulis fungsi cincang tersuai?

Menggunakan Tuple dalam Peta Tidak Tertib Tanpa Fungsi Cincang Tersuai

Anda mungkin menjangkakan std::unordered_map berfungsi dengan mudah dengan kunci tuple di luar kotak. Walau bagaimanapun, ia memerlukan penentuan fungsi cincang untuk tupel, seperti yang ditunjukkan di bawah:

template struct do_hash<tuple int>> {
    size_t operator()(std::tuple<int int> const& tt) const {...}
};</int></tuple>

Proses ini boleh menjadi membosankan, membawa kepada persoalan mengautomasikannya untuk tupel C 0x tanpa menggunakan templat variadic.

Pendekatan berikut membenarkan semua tuple C 0x yang mengandungi jenis hashable standard menjadi sebahagian daripada unordered_map dan unordered_set tanpa usaha tambahan:

#include <tuple>
namespace std {
    namespace {
        template <class t>
        inline void hash_combine(std::size_t& seed, T const& v) {
            // Modified from Boost
            seed ^= std::hash<t>()(v) + 0x9e3779b9 + (seed > 2);
        }

        // Recursive template for hashing tuples
        template <class tuple size_t index="std::tuple_size<Tuple">::value - 1>
        struct HashValueImpl {
            static void apply(size_t& seed, Tuple const& tuple) {
                HashValueImpl<tuple index>::apply(seed, tuple);
                hash_combine(seed, std::get<index>(tuple));
            }
        };

        template <class tuple>
        struct HashValueImpl<tuple> {
            static void apply(size_t& seed, Tuple const& tuple) {
                hash_combine(seed, std::get(tuple));
            }
        };
    }

    template <typename... tt>
    struct hash<:tuple>> {
        size_t
        operator()(std::tuple<tt...> const& tt) const {
            size_t seed = 0;
            HashValueImpl<:tuple>>::apply(seed, tt);
            return seed;
        }
    };
}</:tuple></tt...></:tuple></typename...></tuple></class></index></tuple></class></t></class></tuple>

Dengan meletakkan fungsi dalam ruang nama std, ia boleh diakses melalui pencarian nama bergantung kepada argumen (ADL).

Kod Pematuhan Standard

Pengkhususan objek dalam ruang nama std ialah tingkah laku yang tidak ditentukan. Oleh itu, untuk penyelesaian yang mematuhi piawaian, alihkan kod ke ruang nama yang berasingan dan tinggalkan kemudahan ADL:

namespace hash_tuple {

// Forward non-tuple types to std::hash
template <class tt>
struct hash {
    size_t
    operator()(TT const& tt) const {
        return std::hash<tt>()(tt);
    }
};

// Hash function combining values in a tuple
template <class tuple size_t index="std::tuple_size<Tuple">::value - 1>
struct HashValueImpl {
    static void apply(size_t& seed, Tuple const& tuple) {
        HashValueImpl<tuple index>::apply(seed, tuple);
        hash_combine(seed, std::get<index>(tuple));
    }
};

template <class tuple>
struct HashValueImpl<tuple> {
    static void apply(size_t& seed, Tuple const& tuple) {
        hash_combine(seed, std::get(tuple));
    }
};

// Hash function for tuples
template <typename... tt>
struct hash<:tuple>> {
    size_t
    operator()(std::tuple<tt...> const& tt) const {
        size_t seed = 0;
        HashValueImpl<:tuple>>::apply(seed, tt);
        return seed;
    }
};
} // namespace hash_tuple</:tuple></tt...></:tuple></typename...></tuple></class></index></tuple></class></tt></class>

Isytiharkan pelaksanaan cincang dalam ruang nama hash_tuple untuk memajukan semua jenis bukan tuple ke std: :hash dan ubah suai hash_combine untuk menggunakan hash_tuple::hash dan bukannya std::hash. Letakkan kod yang tinggal di dalam ruang nama hash_tuple.

Untuk menggunakan penyelesaian ini, anda mesti menyertakan kod berikut, yang mengabaikan kemudahan ADL:

unordered_set<tuple int>, hash_tuple::hash<tuple int>>> test2;</tuple></tuple>

Atas ialah kandungan terperinci Bagaimanakah saya boleh menggunakan tupel sebagai kunci dalam peta tidak tersusun tanpa menulis fungsi cincang tersuai?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!