Início / coding / Perguntas / 77671590
Accepted
MatG
Asked: 2023-12-17 00:00:46 +0800 CST

Como implementar pesquisa heterogênea, também conhecida como especializar uma classe de modelo, minimizando a repetição de código

  • 772

Considere uma classe como esta (omitindo detalhes):

template<typename K, typename V>
class my_flat_map
{
    // A lot of member functions taking a const ref to key
    auto find(K const& key) { /*...*/ }
    auto contains(K const& key) { /*...*/ }
    auto insert_or_assign(K const& key, V const& val) { /*...*/ }
    auto insert_if_missing(K const& key, V const& val) { /*...*/ }
    // ...
};

Ao instanciar o modelo com um tipo de chave semelhante a uma string, gostaria que todas as funções-membro aceitassem apenas o string_view correspondente em vez de uma referência const ao tipo de chave real. Eu sei que posso obter isso com uma especialização parcial para cada classe de string possível:

template<typename V>
class my_flat_map<std::u32string,V>
{
    auto find(std::u32string_view key) { /*...*/ }
    // ...
};

template<typename V>
class my_flat_map<std::u16string,V>
{
    auto find(std::u16string_view key) { /*...*/ }
    // ...
};

template<typename V>
class my_flat_map<std::u8string,V>
{
    auto find(std::u8string_view key) { /*...*/ }
    // ...
};

template<typename V>
class my_flat_map<other::esotic_string,V>
{
    auto find(other::esotic_string_view key) { /*...*/ }
    // ...
};

// ...

Os órgãos de todas as funções membro são exatamente os mesmos, a única alteração é a assinatura. Existe um mecanismo para expressar isso sem repetir todo o código?

c++

3 respostas

  1. Best Answer

    Abordagem A

    Você pode adicionar um alias à sua classe:

    #include <string>
#include <string_view>

// for all non-string types, we fall back to const T&
template <typename T>
struct key_view { using type = const T&; };

// For any specialization of std::basic_string, we use the
// corresponding std::basic_string_view.
// For example, key_view<std::string>::type = std::string_view
template <typename Char, typename Traits, typename Alloc>
struct key_view<std::basic_string<Char, Traits, Alloc>> {
    using type = std::basic_string_view<Char, Traits>;
};

// If the key is already a std::basic_string_view, we just use that as the type.
template <typename Char, typename Traits>
struct key_view<std::basic_string_view<Char, Traits>> {
    using type = std::basic_string_view<Char, Traits>;
};

template<typename K, typename V>
struct my_flat_map
{
    // No major change to the flat_map needed, we just use this alias
    using key_view = key_view<K>::type;

    auto find(key_view key) { /*...*/ }
    auto contains(key_view key) { /*...*/ }
    auto insert_or_assign(key_view key, V const& val) { /*...*/ }
    auto insert_if_missing(key_view key, V const& val) { /*...*/ }
    // ...
};

    Sem mais alterações my_flat_map, você pode adicionar mais especializações parciais key_viewpara lidar com mais tipos semelhantes a strings (talvez Qt ou boost strings).

    Notas Adicionais

    Observe também que usar funções key_viewin insert_não faz sentido. Ao inserir, a biblioteca padrão geralmente usa duas sobrecargas para K&&e const K&. Você não pode inserir uma visualização de qualquer maneira, então mantenha-a:

    auto insert_or_assign(K const& key, V const& val) { /*...*/ }
auto insert_or_assign(K && key, V const& val) { /*...*/ }
auto insert_or_assign(K const& key, V && val) { /*...*/ }
auto insert_or_assign(K && key, V && val) { /*...*/ }

    Para evitar repetições, você pode usar um modelo de função. Procure std::map::try_emplaceinspiração no design:

    template <typename Key, typename... Args>
auto try_emplace_or_assign(K && key, Args && ...args) { /*...*/ }

    Abordagem B

    Você pode simplesmente transformar algumas operações em modelos para suportar pesquisas heterogêneas de maneira geral, não apenas em casos especiais como std::string_view:

    #include <concepts>

template <typename T, typename U>
concept equality_with_impl = requires (const T& a, const U& b) {
    { a == b } -> std::convertible_to<bool>;
};

template <typename T, typename U>
concept equality_with = equality_with_impl<T, U> && equality_with_impl<U, T>;

template<typename K, typename V>
struct my_flat_map
{
    template <equality_with<K> T, typename Equal = std::ranges::equal_to>
    auto find(const T& key, Equal equal = {}) { /*...*/ }
    // ...
};

    Agora, se o usuário ligar my_flat_map<std::string, ...>::findcom const char*, std::string, ou std::string_view, sempre funcionaria porque std::stringtem uma ==operadora para estes.

    O usuário também pode fornecer um Equalobjeto de função personalizado caso não haja nenhum arquivo ==.

    Nota: se você está se perguntando por que ambos equality_withe equality_with_implsão necessários, consulte: Por que o conceito same_as verifica a igualdade de tipo duas vezes?

    • 3

  2. Se você deseja mapear um tipo, Kpara outro, o argumento para find, você pode escrever uma característica e especializá-la:

    template <typename K>
struct find_arg;

template <typename K>
using find_arg_t = typename find_arg::type;

// specialize for each type:
template <> struct find_arg<std::u16string> {
     using type = std::u16string_view;
};
// ...

    No entanto, std::u16stringé apenas um alias, std::basic_string<char16_t>assim como std::u16string_viewé um alias para std::basic_string_view<char16_t>. Além disso, std::basic_string::CharTé o tipo de caractere da string. Portanto, você pode salvar todos os padrões acima e usar o arquivo std::basic_string_view< typename K::CharT>. E se other::esotic_stringnão tiver CharT(deveria), você pode recorrer ao acima que usa CharTquando disponível e à sua especialização personalizada caso contrário.

    • 1

  3. Você especializa a classe verificando se ela basic_string_viewpode ser construída com o objeto do tipo const K:

    template<typename K, typename V>
class my_flat_map
{
  // A lot of member functions taking a const ref to key
  auto find(K const& key) { /*...*/ }
  auto contains(K const& key) { /*...*/ }
  auto insert_or_assign(K const& key, V const& val) { /*...*/ }
  auto insert_if_missing(K const& key, V const& val) { /*...*/ }
  // ...
};

template<typename K, typename V>
  requires requires (const K& key) { 
    std::basic_string_view{key}; 
  }
class my_flat_map<K, V>
{
  using string_view_type = decltype(
    std::basic_string_view{std::declval<const K&>()}
  );
  auto find(string_view_type key) { /*...*/ }
  // ...
};

    que abrange outros tipos semelhantes a strings, como const char*ou std::span<char8_t>.

    • 1

relate perguntas