0

我试图避免代码重复，对于以下事情：

template<class StringType, typename type1, typename type2, class MapType>
void readDatastructure(MapType<type1, type2> map, const StringType path) {
... some code
}

我有几种不同的地图类型，它们具有不同的type1和type2参数。在某些时候，我想静态检查什么是类型type1，但type2我不知道如何编译这个东西。我已经尝试了对该模板声明的几种变体，但它们似乎都不起作用。这甚至可能吗？

干杯，

4

3 回答 3

3

你想要一些类似的东西

template<class StringType, typename type1, typename type2,
         template<class, class> class MapType>
void readDatastructure(MapType<type1, type2> map, const StringType path);

但这不适用于，比如说，std::map它有两个额外的模板参数（用于比较器和分配器）。所以你要么必须做

template<class StringType, typename type1, typename type2,
         template<class...> class MapType>
void readDatastructure(MapType<type1, type2> map, const StringType path);

或添加额外的模板参数，即

template<class StringType, typename type1, typename type2, class C, class A,
         template<class, class, class, class> class MapType>
void readDatastructure(MapType<type1, type2, C, A> map, const StringType path);

第一个仍然不适用于std::map采用非默认比较器/分配器；如果您的地图没有完全四个模板类型参数，则第二个不起作用 - 例如unordered_map，它有五个。

因此，最好让您的地图类型发布这些类型。std::map，例如，将它们发布为key_type和mapped_type。通过“发布”，我的意思是将它们定义为成员 typedef。然后你可以写

template<class StringType, class MapType>
void readDatastructure(MapType map, const StringType path);

并使用例如，typename MapType::key_type代替type1.

如果您无法更改地图类型，并且它们不遵循标准协议，则可以编写一个特征类并将其专门用于您的地图类型：

template<class T>
struct map_traits {
    using key_type = typename T::key_type;
    using mapped_type = typename T::mapped_type;
};
template<class T1, class T2>
struct map_traits<MyBrokenMap<T1, T2>> {
    using key_type = T1;
    using mapped_type = T2;
};

然后你可以使用typename map_traits<MapType>::key_type等。

于 2016-05-11T17:15:22.120 回答
1

模板模板参数 

template<class StringType, typename type1, typename type2, template <typename, typename > class MapType>
于 2016-05-11T17:16:20.253 回答
1

所有 std:: 映射类型都定义了类型key_type和mapped_type.

编写 is_map 特征来约束模板函数扩展很简单。

例子：

#include <iostream>
#include <map>
#include <unordered_map>
#include <utility>
#include <typeinfo>


template<class Map> struct is_map
{
    static constexpr bool value = false;
};

template<class K, class V, class Comp, class Alloc>
struct is_map<std::map<K, V, Comp, Alloc>>
{
    static constexpr bool value = true;
};

template<class K, class V, class Comp, class Hash, class Alloc>
struct is_map<std::unordered_map<K, V, Comp, Hash, Alloc>>
{
    static constexpr bool value = true;
};

template<
class Map,
class String,
std::enable_if_t<is_map<Map>::value>* = nullptr
>
void readDataStructure(Map& map, String&& path)
{
    std::cout << "reading map with key type: " << typeid(typename Map::key_type).name() << std::endl;
    std::cout << "      and with value type: " << typeid(typename Map::mapped_type).name() << std::endl;
    std::cout << "--------------------------"  << std::endl;
}


int main()
{
    std::map<int, std::string> m1;
    std::unordered_map<int, std::wstring> m2;
    readDataStructure(m1, "foo.txt");
    readDataStructure(m2, "foo.txt");
}

示例输出：

reading map with key type: i
      and with value type: NSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE
--------------------------
reading map with key type: i
      and with value type: NSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE
--------------------------
于 2016-05-11T18:51:34.143 回答