Инициализация 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());

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

если вы используете компилятор, который поддерживает lambdas, как вы используете в своем вопросе, то шансы довольно хороши, он также включает 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);

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

никто не упомянул boost:: assign, поэтому я представлю его здесь:

пример

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