Закрепление `std:: tuple` и вариационных аргументов

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

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);

Ответ 1

#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)... });
    }
};

DEMO

Ответ 2

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

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

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

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");
}