Question

我有一个constexpr键值映射，大致有这个定义：

// map with `pos` remaining entries
template<typename K, typename V, size_t pos>
class Map {
public:
    template<class Head, class... Tail>
    constexpr Map(Head head, Tail... tail)
        :
        value{head},
        tail{tail...} {}

    Element<K, V> value;
    const Map<K, V, pos - 1> tail;

    // members etc
};

// map end element.
template<typename K, typename V>
class Map<K, V, 0> {
public:
    constexpr Map() {}

    // end element specifics.
};

要在编译时初始化键值映射，我有一个实用程序函数来转发元素：

template<typename K, typename V, typename... Entries>
constexpr Map<K, V, sizeof...(Entries)> create_const_map(Entries&&... entry) {
    return Map<K, V, sizeof...(entry)>(Entry<K, V>{std::forward<Entries>(entry)}...);
}

Element定义为：

template<class K, class V>
class Entry {
public:
    constexpr Entry(const K &key, const V &value)
        :
        key{key},
        value{value} {}

    constexpr Entry(std::pair<K, V> pair)
        :
        key{pair.first},
        value{pair.second} {}

    const K key;
    const V value;
};

要实际创建地图，我可以成功使用std::make_pair：

constexpr auto cmap = create_const_map<int, int>(
    std::make_pair(0, 0),
    std::make_pair(13, 37),
    std::make_pair(42, 9001)
);

我现在想要的是取消对std::make_pair的调用并改为使用大括号：

constexpr auto cmap = create_const_map<int, int>(
    {0, 0},
    {13, 37},
    {42, 9001}
);

但这会导致编译失败，因为{}不会被推断为对的构造：

/home/jj/devel/openage/libopenage/datastructure/tests.cpp:191:24: error: no matching function for call to 'create_const_map'
        constexpr auto cmap = create_const_map<int, int>(
                              ^~~~~~~~~~~~~~~~~~~~~~~~~~
/home/jj/devel/openage/libopenage/datastructure/constexpr_map.h:286:46: note: candidate function not viable: requires 0 arguments, but 3 were provided
constexpr Map<K, V, sizeof...(Entries)> create_const_map(Entries&&... entry) {
                                        ^

我可以做些什么才能使用{a, b}代替std::make_pair(a, b)？

Answer 1

这是不容易实现的，因为正如@Rostislav所说，如果参数是一个大括号初始化列表，编译器就无法推断出它的类型。

我通过手动创建足够多的重载函数来解决这个问题。在下文中，重载是函数调用操作符（operator()），而create_map是该函数对象的变量模板。您将创建的重载次数传递给Overload。我的C ++很粗糙，所以也许这不太理想，但似乎有效。

template<typename D, int N, typename ...E>
struct OverloadImpl;

template<typename D, int N, typename E, typename ...Es>
struct OverloadImpl<D, N, E, Es...> : OverloadImpl<D, N-1, E, E, Es...> {
    decltype(auto) operator()(const E& e, const Es&... es) {
       return static_cast<D&>(*this).exec(e, es...);
    }
    using OverloadImpl<D, N-1, E, E, Es...>::operator();
};

template<typename D, typename E, typename ...Es>
struct OverloadImpl<D, 0, E, Es...> { 
    decltype(auto) operator()() { 
       return static_cast<D&>(*this).exec();   
    }    
};

template<typename D, typename E, int N>
struct Overload : OverloadImpl<D, N, E>
{ };

要将上述内容应用于您的案例，您可以从Overload派生并提供exec功能。

template<typename K, typename V, int C>
struct M {
   template<typename ...T>
   M(T&&...) { }
};

template<typename K, typename V>
struct Entry {
   Entry(K, V) { }    
};

template<typename K, typename V>
struct CreateMapImpl : Overload<CreateMapImpl<K, V>, Entry<K, V>, 10> {
    template<typename ...T>
    M<K, V, sizeof...(T)> exec(const T&... t) {
       return { t... };   
    }
};

template<typename K, typename V>
CreateMapImpl<K, V> create_map{};

int main() {
   create_map<int, std::string>({1, "one"}, {2, "two"}, {3, "three"});   
}

Answer 2

在我看来，你不可能做你需要的事情。编译器必须推导出Entries参数包的类型。但是，要传入的支撑初始值设定项没有类型。来自cppreference，备注部分：

braced-init-list不是表达式，因此没有类型，例如decltype({1,2})格式不正确。没有类型意味着模板类型推导不能推断出与braced-init-list匹配的类型，因此在声明template<class T> void f(T);的情况下，表达式f({1,2,3})是不正确的。

这就是为什么gcc（根据cpp.sh）说Entries = {}：

63：1：错误：函数参数太多constexpr Map create_const_map（Entries＆amp;＆amp; ...）[K = int; V = int;条目= {}]＆＃39;

我想如果您想要一种更简洁的方式来初始化地图，您需要为std::make_pair制作简写符号。

可变参数模板构造中的隐式std :: pair构造

2 个答案: