використовуйте std :: fill для заповнення вектора зі збільшенням чисел

Я хотів би заповнити vector<int>використання std::fill, але замість одного значення вектор повинен містити цифри у зростаючому порядку після.

Я спробував досягти цього, повторивши третій параметр функції на одиницю, але це дало б мені лише вектори, заповнені 1 або 2 (залежно від положення ++оператора).

Приклад:

vector<int> ivec;
int i = 0;
std::fill(ivec.begin(), ivec.end(), i++); // elements are set to 1
std::fill(ivec.begin(), ivec.end(), ++i); // elements are set to 2

Переважно використовувати std::iotaтак:

std::vector<int> v(100) ; // vector with 100 ints.
std::iota (std::begin(v), std::end(v), 0); // Fill with 0, 1, ..., 99.

Тим не менш, якщо у вас немає c++11підтримки (все ще є справжньою проблемою, коли я працюю), використовуйте std::generateнаступне:

struct IncGenerator {
    int current_;
    IncGenerator (int start) : current_(start) {}
    int operator() () { return current_++; }
};

// ...

std::vector<int> v(100) ; // vector with 100 ints.
IncGenerator g (0);
std::generate( v.begin(), v.end(), g); // Fill with the result of calling g() repeatedly.

Ви повинні використовувати std::iotaалгоритм (визначений у <numeric>):

  std::vector<int> ivec(100);
  std::iota(ivec.begin(), ivec.end(), 0); // ivec will become: [0..99]

Тому що std::fillпросто присвоює задане фіксоване значення елементам у заданому діапазоні [n1,n2). І std::iotaзаповнює заданий діапазон [n1, n2)послідовно зростаючими значеннями, починаючи з початкового значення, а потім використовуючи. ++valueВи також можете використовувати std::generateяк альтернативу.

Не забувайте, що std::iotaце алгоритм C ++ 11 STL. Але багато сучасних компіляторів підтримують це, наприклад, GCC, Clang та VS2012: http://msdn.microsoft.com/en-us/library/vstudio/jj651033.aspx

PS Ця функція названа на честь цілочисельної функції ⍳з мови програмування APL і означає грецьку букву йота. Я припускаю, що спочатку в APL цю дивну назву було обрано, оскільки вона нагадує “integer”(хоча в математиці йота широко використовується для позначення уявної частини комплексного числа).

Моїм першим вибором (навіть у C ++ 11) буде boost::counting_iterator:

std::vector<int> ivec( boost::counting_iterator<int>( 0 ),
                       boost::counting_iterator<int>( n ) );

або якщо вектор вже побудований:

std::copy( boost::counting_iterator<int>( 0 ),
           boost::counting_iterator<int>( ivec.size() ),
           ivec.begin() );

Якщо ви не можете використовувати Boost: або std::generate(як пропонується в інших відповідях), або реалізуйте counting_iteratorсамостійно, якщо вам це потрібно в різних місцях. (З Boost, ви можете використовувати transform_iteratorв counting_iteratorстворювати всі види цікавих послідовностей. Без Boost, ви можете зробити багато це вручну, або у вигляді об'єктного типу генератора для std::generate, або як то , що ви можете підключити до а рукописний ітератор підрахунку.)

Я бачив відповіді за допомогою std :: generate, але ви також можете "вдосконалити" це, використовуючи статичні змінні всередині лямбда-сигналу, замість того, щоб оголошувати лічильник поза функцією або створювати клас генератора:

std::vector<int> vec;
std::generate(vec.begin(), vec.end(), [] {
    static int i = 0;
    return i++;
});

Я вважаю це трохи більш лаконічним

Якщо ви не хочете використовувати функції C ++ 11, ви можете використовувати std::generate:

#include <algorithm>
#include <iostream>
#include <vector>

struct Generator {
    Generator() : m_value( 0 ) { }
    int operator()() { return m_value++; }
    int m_value;
};

int main()
{
    std::vector<int> ivec( 10 );

    std::generate( ivec.begin(), ivec.end(), Generator() );

    std::vector<int>::const_iterator it, end = ivec.end();
    for ( it = ivec.begin(); it != end; ++it ) {
        std::cout << *it << std::endl;
    }
}

Ця програма друкує від 0 до 9.

Ми можемо використовувати згенерувати функцію яка існує у файлі заголовка алгоритму.

Фрагмент коду:

#include<bits/stdc++.h>
using namespace std;


int main()
{
    ios::sync_with_stdio(false);

    vector<int>v(10);

    int n=0;

    generate(v.begin(), v.end(), [&n] { return n++;});

    for(auto item : v)
    {
      cout<<item<<" ";
    }
    cout<<endl;

    return 0;
}

std :: iota обмежується послідовністю n, n + 1, n + 2, ...

Але що, якщо ви хочете заповнити масив загальною послідовністю f (0), f (1), f (2) тощо? Часто ми можемо уникнути генератора відстеження стану. Наприклад,

int a[7];
auto f = [](int x) { return x*x; };
transform(a, a+7, a, [a, f](int &x) {return f(&x - a);});

створить послідовність квадратів

0 1 4 9 16 25 36

Однак цей трюк не спрацює з іншими контейнерами.

Якщо ви застрягли в C ++ 98, ви можете робити такі жахливі речі, як:

int f(int &x) { int y = (int) (long) &x / sizeof(int); return y*y; }

і потім

int a[7];
transform((int *) 0, ((int *) 0) + 7, a, f);

Але я б не рекомендував. :)

Якщо говорити про підсилення:

auto ivec = boost::copy_range<std::vector<int>>(boost::irange(5, 10));

це також працює

j=0;
for(std::vector<int>::iterator it = myvector.begin() ; it != myvector.end(); ++it){
    *it = j++;
}

Що стосується продуктивності, вам слід ініціалізувати вектор за допомогою reserve()комбінованих push_back()функцій, як у прикладі нижче:

const int numberOfElements = 10;

std::vector<int> data;
data.reserve(numberOfElements);

for(int i = 0; i < numberOfElements; i++)
    data.push_back(i);

Все std::fill, std::generateі т.д. працює на діапазоні існуючого векторних вмісту, і, отже, вектор повинен бути заповнений деякими даними раніше. Навіть роблячи наступне: std::vector<int> data(10);створює вектор із усіма елементами, встановленими за значенням за замовчуванням (тобто 0 у випадку int).

Наведений вище код дозволяє уникнути ініціалізації векторного вмісту, перш ніж заповнити його даними, які ви дійсно хочете. Ефективність цього рішення добре видно на великих наборах даних.

Є й інший варіант - без використання йоти. Можна використовувати вираз For_each + лямбда:

vector<int> ivec(10); // the vector of size 10
int i = 0;            // incrementor
for_each(ivec.begin(), ivec.end(), [&](int& item) { ++i; item += i;});

Дві важливі речі, чому це працює:

1. Лямбда фіксує зовнішню область [&], що означає, що я буду доступний всередині виразу
2. елемент, переданий як посилання, отже, він може змінюватися всередині вектора

Якщо ви дійсно хочете використовувати std::fillі обмежуєтесь C ++ 98, ви можете використовувати щось на зразок наступного,

#include <algorithm>
#include <iterator>
#include <iostream>
#include <vector>

struct increasing {
    increasing(int start) : x(start) {}
    operator int () const { return x++; }
    mutable int x;
};

int main(int argc, char* argv[])
{
    using namespace std;

    vector<int> v(10);
    fill(v.begin(), v.end(), increasing(0));
    copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));
    cout << endl;
    return 0;
}

Я знаю, що це старе запитання, але наразі я граюся з бібліотекою, щоб вирішити саме цю проблему. Для цього потрібен c ++ 14.

#include "htl.hpp"

htl::Token _;

std::vector<int> vec = _[0, _, 100];
// or
for (auto const e: _[0, _, 100]) { ... }

// supports also custom steps
// _[0, _%3, 100] == 0, 4, 7, 10, ...

Я створив просту шаблонну функцію Sequence()для генерації послідовностей чисел. Функціонал відповідає seq()функції в R ( посилання ). Приємна річ цієї функції полягає в тому, що вона працює для генерації різноманітних числових послідовностей і типів.

#include <iostream>
#include <vector>

template <typename T>
std::vector<T> Sequence(T min, T max, T by) {
  size_t n_elements = ((max - min) / by) + 1;
  std::vector<T> vec(n_elements);
  min -= by;
  for (size_t i = 0; i < vec.size(); ++i) {
    min += by;
    vec[i] = min;
  }
  return vec;
}

Приклад використання:

int main()
{
    auto vec = Sequence(0., 10., 0.5);
    for(auto &v : vec) {
        std::cout << v << std::endl;
    }
}

Єдине застереження полягає в тому, що всі цифри повинні мати один і той же висновок. Іншими словами, для парних чи плаваючих знаків включайте десяткові цифри для всіх входів, як показано.

Оновлено: 14 червня 2018 р

brainsandwich та underscore_d дали дуже хороші ідеї. Оскільки заповнення - це зміна вмісту, for_each (), найпростіший серед алгоритмів STL, також повинен заповнити рахунок:

std::vector<int> v(10);
std::for_each(v.begin(), v.end(), [i=0] (int& x) mutable {x = i++;});    

Узагальнений захоплення [i=o] надає лямбда-виразу інваріант і ініціалізує його до відомого стану (в даному випадку 0). ключове словоmutable дозволяє оновити цей стан кожного разу, коли викликається лямбда.

Потрібна лише невелика модифікація, щоб отримати послідовність квадратів:

std::vector<int> v(10);
std::for_each(v.begin(), v.end(), [i=0] (int& x) mutable {x = i*i; i++;});

Згенерувати R-подібні послідовності не складніше, але зауважте, що в R числовий режим насправді подвійний, тому насправді немає потреби в параметризації типу. Просто використовуйте подвійний.