Инициализация std :: vector с помощью итеративных вызовов функций

Мир слишком велик для C ++, чтобы найти решение для всего. Тем не менее, C ++ не хочет быть огромным супермаркетом, полным готовых блюд на любой вкус. Скорее, это небольшая, хорошо оборудованная кухня, в которой вы, шеф-повар C ++ может приготовить для вас любое решение.

Вот глупый и очень грубый пример генератора последовательности:

#include <iterator>

struct sequence_iterator : std::iterator<std::input_iterator_tag, int>
{
sequence_iterator() : singular(true) { }
sequence_iterator(int a, int b) : singular(false) start(a), end(b) { }
bool singular;
int start;
int end;

int operator*() { return start; }
void operator++() { ++start; }

bool operator==(sequence_iterator const & rhs) const
{
return (start == end) == rhs.singular;
}
bool operator!=(sequence_iterator const & rhs) const
{
return !operator==(rhs);
}
};

Теперь вы можете сказать:

std::vector<int> v(sequence_iterator(1,10), sequence_iterator());

В том же духе вы можете написать более общий гаджет, который «вызывает заданный функтор определенное количество раз» и т. Д. (Например, возьмите объект функции с помощью шаблонной копии и используйте счетчики в качестве счетчиков повторения; разыменование вызывает функтор ).

Если вы используете компилятор, который поддерживает лямбды, как вы используете в своем вопросе, то шансы довольно хорошие, это также включает std::iotaчто, по крайней мере, делает подсчет немного чище:

std::vector <int> vec(10);
std::iota(begin(vec), end(vec), 0);

Для этого сценария (и многих других, я думаю) мы бы предпочли iota_n хоть:

namespace stdx {
template <class FwdIt, class T>
void iota_n(FwdIt b, size_t count, T val = T()) {
for ( ; count; --count, ++b, ++val)
*b = val;
}
}

Который, для вашего случая вы бы использовали как:

std::vector<int> vec;

stdx::iota_n(std::back_inserter(vec), 10);

Относительно того, почему это не было включено в стандартную библиотеку, я действительно даже не могу предположить. Я полагаю, это можно рассматривать как аргумент в пользу диапазонов, поэтому алгоритм будет принимать диапазон, и у нас будет простой способ создать диапазон из пары начало / конец или пара начало / счет. Я не уверен, что полностью согласен с этим — диапазоны, кажется, работают хорошо в некоторых случаях, но в других они не имеют никакого смысла. Я не уверен, что без дополнительной работы у нас есть ответ, который действительно намного лучше, чем пара итераторов.

Никто не упомянул повышение :: назначения, поэтому я представлю это здесь:

пример

#include <iostream>
#include <vector>
#include <boost/assign/std/vector.hpp>
#include <cstdlib>

int main()
{
std::vector<int> v1;
std::vector<int> v2;
boost::assign::push_back(v1).repeat_fun(9, &rand);
int cnt = 0;
boost::assign::push_back(v2).repeat_fun(10, [&cnt]()->int { return cnt++;});
for (auto i : v1)
{
std::cout << i << ' ';
}
std::cout << std::endl;
for (auto i : v2)
{
std::cout << i << ' ';
}
}

Выход

41 18467 6334 26500 19169 15724 11478 29358 26962
0 1 2 3 4 5 6 7 8 9

Вы можете использовать SFINAE для формирования таблицы:

#include <iostream>
#include <vector>

template <int n> struct coeff    { static int const value = coeff<n-1>::value + 3; };
template <>      struct coeff<0> { static int const value = 0; };

template<int... values> struct c1 {static int const value[sizeof...(values)];};
template<int... values> int const c1<values...>::value[] = {values...};

template<int n, int... values> struct c2 : c2< n-1, coeff<n-1>::value, values...> {};
template<int... values> struct c2< 0, values... > : c1<values...> {};

template<int n> struct table : c2< n > {
static std::vector< unsigned int > FormTable()
{
return std::vector< unsigned int >( & c2< n >::value[0], & c2< n >::value[n] );
}
};

int main()
{
const auto myTable = table< 20 >::FormTable();

for ( const auto & it : myTable )
{
std::cout<< it << std::endl;
}
}