如何实现异构查找：最小化代码重复的C++模板类特化

针对你遇到的问题，有几种高效的方式可以避免重复编写类模板特化代码，以下是具体实现：

1. 类型萃取（Type Traits）+ 主模板复用 #

这是兼容性最好的方案（支持C++11及以上），核心是通过类型萃取模板，为不同的键类型映射对应的参数类型：

步骤1：定义类型萃取模板 #

#include <string>
#include <string_view>

// 基础版本：非字符串类型，参数为 const K&
template<typename K>
struct key_param_type {
    using type = const K&;
};

// 为各类字符串类型特化，映射到对应的string_view
template<>
struct key_param_type<std::string> {
    using type = std::string_view;
};

template<>
struct key_param_type<std::u8string> {
    using type = std::u8string_view;
};

template<>
struct key_param_type<std::u16string> {
    using type = std::u16string_view;
};

template<>
struct key_param_type<std::u32string> {
    using type = std::u32string_view;
};

// 自定义字符串类型同理
template<>
struct key_param_type<other::esotic_string> {
    using type = other::esotic_string_view;
};

// 便捷别名，简化使用
template<typename K>
using key_param_t = typename key_param_type<K>::type;

步骤2：修改主模板类 #

直接在主模板的成员函数中使用萃取得到的参数类型，无需任何特化类：

template<typename K, typename V>
class my_flat_map
{
public:
    auto find(key_param_t<K> key) { /* 统一实现逻辑 */ }
    auto contains(key_param_t<K> key) { /* 统一实现逻辑 */ }
    auto insert_or_assign(key_param_t<K> key, const V& val) { /* 统一实现逻辑 */ }
    auto insert_if_missing(key_param_t<K> key, const V& val) { /* 统一实现逻辑 */ }
    // ... 其他成员函数
};

后续新增字符串类型时，只需要添加对应的key_param_type特化即可，完全不用修改主模板或重复编写成员函数。

2. C++20 概念（Concepts）+ 重载复用 #

如果使用C++20及以上版本，可以通过概念识别字符串类型，再结合重载+私有实现函数来避免重复：

步骤1：定义字符串类型概念 #

#include <concepts>
#include <string>
#include <string_view>

// 判断类型是否为带对应view的字符串类型
template<typename T>
concept StringLike = requires {
    typename T::value_type;
    // 验证该类型可转换为对应的basic_string_view
    static_cast<std::basic_string_view<typename T::value_type>>(std::declval<T>());
};

步骤2：修改模板类，复用实现逻辑 #

template<typename K, typename V>
class my_flat_map
{
private:
    // 核心实现逻辑只写一次
    template<typename Key>
    auto find_impl(Key&& key) {
        /* 统一的查找逻辑 */
    }

    template<typename Key>
    auto contains_impl(Key&& key) {
        /* 统一的存在性检查逻辑 */
    }

    // 其他成员函数的实现同理
    template<typename Key>
    auto insert_or_assign_impl(Key&& key, const V& val) {
        /* 统一的插入或赋值逻辑 */
    }

public:
    // 字符串类型重载：接收对应的string_view
    auto find(std::basic_string_view<typename K::value_type> key) requires StringLike<K> {
        return find_impl(std::forward<decltype(key)>(key));
    }

    // 通用类型重载：接收const K&
    auto find(const K& key) requires (!StringLike<K>) {
        return find_impl(std::forward<decltype(key)>(key));
    }

    // contains函数同理
    auto contains(std::basic_string_view<typename K::value_type> key) requires StringLike<K> {
        return contains_impl(std::forward<decltype(key)>(key));
    }

    auto contains(const K& key) requires (!StringLike<K>) {
        return contains_impl(std::forward<decltype(key)>(key));
    }

    // ... 其他成员函数的重载
};

这种方式利用现代C++特性让代码更具可读性，核心实现逻辑只需要编写一次，重载仅做转发。

3. 基类模板复用 #

将所有成员函数的实现放到一个基类模板中，主模板和特化版本通过继承不同参数的基类来复用代码：

步骤1：定义基类模板 #

template<typename K, typename V, typename KeyParam>
class my_flat_map_base
{
protected:
    // 所有成员函数的实现都在这里
    auto find(KeyParam key) { /* 统一实现 */ }
    auto contains(KeyParam key) { /* 统一实现 */ }
    auto insert_or_assign(KeyParam key, const V& val) { /* 统一实现 */ }
    auto insert_if_missing(KeyParam key, const V& val) { /* 统一实现 */ }
    // ...
};

步骤2：主模板与特化版本 #

// 通用版本：非字符串类型，使用const K&作为参数类型
template<typename K, typename V>
class my_flat_map : public my_flat_map_base<K, V, const K&>
{};

// 字符串类型特化：继承对应string_view参数的基类
template<typename V>
class my_flat_map<std::string, V> : public my_flat_map_base<std::string, V, std::string_view>
{};

template<typename V>
class my_flat_map<std::u8string, V> : public my_flat_map_base<std::u8string, V, std::u8string_view>
{};

// 自定义字符串类型同理
template<typename V>
class my_flat_map<other::esotic_string, V> : public my_flat_map_base<other::esotic_string, V, other::esotic_string_view>
{};

这种方式的代码重复量极低，特化版本仅需编写继承声明，所有实现逻辑都集中在基类中。

内容的提问来源于stack exchange，提问作者MatG