Ответ 1

Если вы хотите связать аргументы с any, вы можете использовать следующую настройку. Я также сделал класс any более удобным для использования, хотя он не является технически классом any.

#include <vector>
#include <iostream>

struct any {
  enum type {Int, Float, String};
  any(int   e) { m_data.INT    = e; m_type = Int;}
  any(float e) { m_data.FLOAT  = e; m_type = Float;}
  any(char* e) { m_data.STRING = e; m_type = String;}
  type get_type() const { return m_type; }
  int get_int() const { return m_data.INT; }
  float get_float() const { return m_data.FLOAT; }
  char* get_string() const { return m_data.STRING; }
private:
  type m_type;
  union {
    int   INT;
    float FLOAT;
    char *STRING;
  } m_data;
};

template <class ...Args>
void foo_imp(const Args&... args)
{
    std::vector<any> vec = {args...};
    for (unsigned i = 0; i < vec.size(); ++i) {
        switch (vec[i].get_type()) {
            case any::Int: std::cout << vec[i].get_int() << '\n'; break;
            case any::Float: std::cout << vec[i].get_float() << '\n'; break;
            case any::String: std::cout << vec[i].get_string() << '\n'; break;
        }
    }
}

template <class ...Args>
void foo(Args... args)
{
    foo_imp(any(args)...);  //pass each arg to any constructor, and call foo_imp with resulting any objects
}

int main()
{
    char s[] = "Hello";
    foo(1, 3.4f, s);
}

Однако возможно написать функции для доступа к n-му аргументу в функции вариационного шаблона и применить функцию к каждому аргументу, что может быть лучшим способом сделать то, что вы хотите достичь.

Ответ 2

Это не то, как обычно можно использовать шаблоны Variadic, а не вообще.

Итерации по вариационному набору невозможны в соответствии с языковыми правилами, поэтому вам нужно обратиться к рекурсии.

class Stock
{
public:
  bool isInt(size_t i) { return _indexes.at(i).first == Int; }
  int getInt(size_t i) { assert(isInt(i)); return _ints.at(_indexes.at(i).second); }

  // push (a)
  template <typename... Args>
  void push(int i, Args... args) {
    _indexes.push_back(std::make_pair(Int, _ints.size()));
    _ints.push_back(i);
    this->push(args...);
  }

  // push (b)
  template <typename... Args>
  void push(float f, Args... args) {
    _indexes.push_back(std::make_pair(Float, _floats.size()));
    _floats.push_back(f);
    this->push(args...);
  }

private:
  // push (c)
  void push() {}

  enum Type { Int, Float; };
  typedef size_t Index;

  std::vector<std::pair<Type,Index>> _indexes;
  std::vector<int> _ints;
  std::vector<float> _floats;
};

Пример (в действии), предположим, что Stock stock;:

• stock.push(1, 3.2f, 4, 5, 4.2f); разрешен (a), поскольку первым аргументом является int
• this->push(args...) расширяется до this->push(3.2f, 4, 5, 4.2f);, который разрешен (b), поскольку первым аргументом является float
• this->push(args...) расширяется до this->push(4, 5, 4.2f);, который разрешен (a), поскольку первым аргументом является int
• this->push(args...) расширяется до this->push(5, 4.2f);, который разрешен (a), поскольку первым аргументом является int
• this->push(args...) расширяется до this->push(4.2f);, который разрешен (b), поскольку первым аргументом является float
• this->push(args...) расширяется до this->push();, который разрешен в (c), поскольку нет аргумента, таким образом заканчивая рекурсию

Таким образом:

• Добавление другого типа для обработки так же просто, как добавление другой перегрузки, изменение первого типа (например, std::string const&)
• Если передан совершенно другой тип (например, Foo), то перегрузка не может быть выбрана, что приведет к ошибке времени компиляции.

Одно предупреждение: автоматическое преобразование означает, что double будет выбирать перегрузку (b), а short будет выбирать перегрузку (a). Если это нежелательно, необходимо ввести SFINAE, что делает метод немного сложнее (ну, по крайней мере, их подписи), например:

template <typename T, typename... Args>
typename std::enable_if<is_int<T>::value>::type push(T i, Args... args);

Где is_int будет что-то вроде:

template <typename T> struct is_int { static bool constexpr value = false; };
template <> struct is_int<int> { static bool constexpr value = true; };

Другой альтернативой, однако, было бы рассмотреть вариант типа. Например:

typedef boost::variant<int, float, std::string> Variant;

Он уже существует со всеми утилитами, он может быть сохранен в vector, скопирован и т.д.... и, похоже, очень похож на то, что вам нужно, даже если он не использует шаблоны Variadic.

Ответ 3

Вы можете создать его контейнер, инициализируя его пакетом параметров между {}. Пока тип параметров... является однородным или, по крайней мере, преобразуется в тип элемента вашего контейнера, он будет работать. (проверено с помощью g++ 4.6.1)

#include <array>

template <class... Params>
void f(Params... params) {
    std::array<int, sizeof...(params)> list = {params...};
}

Ответ 4

Вы не можете перебирать, но можете перечислить список. Проверьте пример printf() в википедии: http://en.wikipedia.org/wiki/C++0x#Variadic_templates

Ответ 5

В настоящее время нет конкретной функции, но вы можете использовать некоторые обходные пути.

Использование списка инициализации

В одном обходном решении используется тот факт, что подвыражения списков инициализации оцениваются по порядку. int a[] = {get1(), get2()} выполнит get1 перед выполнением get2. Может быть, fold выражения пригодится для подобных методов в будущем. Чтобы вызвать do() для каждого аргумента, вы можете сделать что-то вроде этого:

template <class... Args>
void doSomething(Args... args) {
    int x[] = {args.do()...};
}

Однако это будет работать только тогда, когда do() возвращает int. Вы можете использовать оператор запятая для поддержки операций, которые не возвращают правильное значение.

template <class... Args>
void doSomething(Args... args) {
    int x[] = {(args.do(), 0)...};
}

Чтобы сделать более сложные вещи, вы можете поместить их в другую функцию:

template <class Arg>
void process(Arg arg, int &someOtherData) {
    // You can do something with arg here.
}

template <class... Args>
void doSomething(Args... args) {
    int someOtherData;
    int x[] = {(process(args, someOtherData), 0)...};
}

Обратите внимание, что с общим lambdas (С++ 14) вы можете определить функцию для этого шаблона для вас.

template <class F, class... Args>
void do_for(F f, Args... args) {
    int x[] = {(f(args), 0)...};
}

template <class... Args>
void doSomething(Args... args) {
    do_for([&](auto arg) {
        // You can do something with arg here.
    }, args...);
}

Использование рекурсии

Другая возможность - использовать рекурсию. Вот небольшой пример, который определяет аналогичную функцию do_for, как указано выше.

template <class F, class First, class... Rest>
void do_for(F f, First first, Rest... rest) {
    f(first);
    do_for(f, rest...);
}
template <class F>
void do_for(F f) {
    // Parameter pack is empty.
}

template <class... Args>
void doSomething(Args... args) {
    do_for([&](auto arg) {
        // You can do something with arg here.
    }, args...);
}

Ответ 6

Вы можете использовать несколько вариативных шаблонов, это немного грязно, но оно работает и легко понять. У вас просто есть функция с вариационным шаблоном:

template <typename ...ArgsType >
void function(ArgsType... Args){
     helperFunction(Args...);
}

И вспомогательная функция, например:

void helperFunction() {}

template <typename T, typename ...ArgsType >
void helperFunction(T t, ArgsType... Args) {

     //do what you want with t
    function(Args...);

}

Теперь, когда вы вызываете "функцию", "helperFunction" будет вызываться и изолировать первый переданный параметр от остального, эта переменная может использоваться для вызова другой функции (или чего-то еще). Затем "функция" будет вызываться снова и снова, пока осталось больше переменных. Обратите внимание, что вам может потребоваться объявить helperClass перед "функцией".

Окончательный код будет выглядеть следующим образом:

void helperFunction();

template <typename T, typename ...ArgsType >
void helperFunction(T t, ArgsType... Args);

template <typename ...ArgsType >
void function(ArgsType... Args){
     helperFunction(Args...);
}

void helperFunction() {}

template <typename T, typename ...ArgsType >
void helperFunction(T t, ArgsType... Args) {

     //do what you want with t
    function(Args...);

}

Код не проверен.