Сжатие аргументов 'std:: tuple' и variadic

у меня есть следующий класс:

template<typename... Tkeys>
class C
{
public:
    std::tuple<std::unordered_map<Tkeys, int>... > maps;

    // Not real function:
    void foo(Tkeys... keys) {
        maps[keys] = 1;
    }
};

как бы я реализую foo так, что он присваивает каждому std::map на maps вызывается с соответствующим ключом?

например, если у меня есть

C<int, int, float, std::string> c;

и я позвонила

c.foo(1, 2, 3.3, "qwerty")

затем c.maps должно быть эквивалентно

m1 = std::map<int, int>()
m1[1] = 1;
m2 = std::map<int, int>()
m2[2] = 1;
m3 = std::map<float, int>()
m3[3.3] = 1;
m4 = std::map<std::string, int>()
m4["qwerty"] = 1;
c.maps = std::make_tuple(m1, m2, m3, m4);
10
c++ c++11 c++14 variadic-templates

3 ответов

#include <unordered_map>
#include <utility>
#include <tuple>
#include <cstddef>

template <typename... Tkeys>
class C
{
public:
    std::tuple<std::unordered_map<Tkeys, int>... > maps;

    template <typename... Args>
    void foo(Args&&... keys)
    {
        foo_impl(std::make_index_sequence<sizeof...(Args)>{}, std::forward<Args>(keys)...);
    }

private:
    template <typename... Args, std::size_t... Is>
    void foo_impl(std::index_sequence<Is...>, Args&&... keys)
    {
        using expand = int[];
        static_cast<void>(expand{ 0, (
            std::get<Is>(maps)[std::forward<Args>(keys)] = 1
        , void(), 0)... });
    }
};

демо

7

если у вас есть компилятор, который поддерживает выражения C++17 fold, то вы можете иметь следующую простую схему вариационного расширения:

template<typename... Tkeys>
class C {
    template<typename... Args, std::size_t... I>
    void foo_helper(std::index_sequence<I...>, Args&& ...args) {
      ((std::get<I>(maps)[std::forward<Args>(args)] = 1), ...);
    }
public:
    std::tuple<std::unordered_map<Tkeys, int>... > maps;

    void foo(Tkeys... keys) {
      foo_helper(std::index_sequence_for<Tkeys...>{}, std::forward<Tkeys>(keys)...);
    }
};

Live Demo

3

для текущего C++ (2014) просто используйте классический шаблон с функцией sentinel:

public:

void foo(Tkeys... keys) {
    foo_range<0>(keys...);
}

private:

template <std::size_t I, typename F, typename... N>
void foo_range(F first, N... next) {
    std::get<I>(maps)[first] = 1;
    foo_range<I + 1>(next...);
}

template <std::size_t I>
void foo_range() {
    static_assert(I == sizeof...(Tkeys), "That should be sentinel");
}
0