vektörü artan sayılarla doldurmak için std :: fill kullanın

Bir vector<int>kullanarak doldurmak istiyorum std::fill, ancak bir değer yerine vektör, daha sonra artan sırada sayılar içermelidir.

Bunu, fonksiyonun üçüncü parametresini birer birer yineleyerek başarmayı denedim, ancak bu bana sadece 1 veya 2 ile dolu vektörleri ( ++operatörün konumuna bağlı olarak) verirdi .

Misal:

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

Tercihen şu şekilde kullanın 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.

Bununla birlikte, eğer herhangi bir c++11desteğiniz yoksa (hala çalıştığım yerde gerçek bir problem), şöyle kullanın 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::iotaAlgoritmayı kullanmalısınız (tanımlanmış <numeric>):

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

Çünkü std::fillsadece verilen sabit değeri verilen aralıktaki elemanlara atar [n1,n2). Ve std::iotaverilen aralığı [n1, n2), başlangıç ​​değerinden başlayıp ardından kullanarak sırayla artan değerlerle doldurur . Alternatif olarak ++valueda kullanabilirsiniz std::generate.

Bunun std::iotaC ++ 11 STL algoritması olduğunu unutmayın . Ancak birçok modern derleyici bunu destekler, örneğin GCC, Clang ve VS2012: http://msdn.microsoft.com/en-us/library/vstudio/jj651033.aspx

PS Bu işlev, ⍳APL programlama dilindeki tamsayı işlevinden sonra adlandırılır ve Yunanca bir iota harfini belirtir. Başlangıçta APL'de bu garip ismin seçildiğini çünkü “integer”(matematikte iota karmaşık bir sayının hayali kısmını belirtmek için yaygın olarak kullanılmasına rağmen) tahmin ediyorum .

İlk tercihim (C ++ 11'de bile) şöyle olacaktır boost::counting_iterator:

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

veya vektör zaten oluşturulmuşsa:

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

Boost'u kullanamıyorsanız: ya std::generate(diğer yanıtlarda önerildiği gibi) ya da counting_iteratorçeşitli yerlerde ihtiyacınız varsa kendiniz uygulayın . (Boost ile, her türden ilginç sekanslar oluşturmak için a transform_iteratorof a kullanabilirsiniz counting_iterator. Boost olmadan, bunların çoğunu, bir jeneratör nesne türü biçiminde veya bir nesneye takabileceğiniz bir şey olarak elle std::generateyapabilirsiniz. elle yazılmış sayma yineleyicisi.)

Std :: generate ile yanıtları gördüm, ancak işlevin dışında bir sayaç bildirmek veya bir generator sınıfı oluşturmak yerine lambda içindeki statik değişkenleri kullanarak bunu "geliştirebilirsiniz":

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

Onu biraz daha öz buluyorum

C ++ 11 özelliklerini kullanmak istemiyorsanız, şunları kullanabilirsiniz 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;
    }
}

Bu program 0'dan 9'a kadar yazdırır.

Algoritma başlık dosyasında bulunan oluşturma işlevini kullanabiliriz .

Kod Parçacığı:

#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 bir n, n + 1, n + 2, ... dizisiyle sınırlıdır

Peki ya bir diziyi f (0), f (1), f (2) vb. Genel bir diziyle doldurmak isterseniz? Çoğu zaman, durum izleme jeneratöründen kaçınabiliriz. Örneğin,

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

kareler dizisi üretecek

0 1 4 9 16 25 36

Ancak bu numara diğer kapsayıcılarda çalışmayacaktır.

C ++ 98 ile sıkışıp kalırsanız, aşağıdaki gibi korkunç şeyler yapabilirsiniz:

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

ve sonra

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

Ama bunu tavsiye etmem. :)

Güçlendirmeden bahsetmişken:

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

bu da işe yarar

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

Performans açısından, vektörü aşağıdaki örnekteki gibi fonksiyonlarla reserve()birleştirilmiş kullanımıyla başlatmalısınız push_back():

const int numberOfElements = 10;

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

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

Tüm std::fill, std::generatevb mevcut vektör içeriğinin dizi faaliyet gösteriyor ve bu nedenle vektör bazı veriler önceki ile doldurulmalıdır. Aşağıdakileri yapmak bile: std::vector<int> data(10);tüm öğeleri varsayılan değerine (yani 0 olması durumunda 0) ayarlanmış bir vektör oluşturur int.

Yukarıdaki kod, vektör içeriğini gerçekten istediğiniz verilerle doldurmadan önce başlatmaktan kaçınır. Bu çözümün performansı, büyük veri kümelerinde açıkça görülmektedir.

Başka bir seçenek daha var - iota kullanmadan. For_each + lambda ifadesi kullanılabilir:

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

Neden işe yaradığı iki önemli şey:

1. Lambda dış kapsamı yakalar [&] bu, ifadenin içinde mevcut olacağım anlamına gelir
2. öğe referans olarak iletildi, bu nedenle vektör içinde değiştirilebilir

Eğer varsa gerçekten kullanmak istediğiniz std::fillve C ++ 98 ile sınırlı olan aşağıdakilerden gibi bir şey kullanabilirsiniz,

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

Bunun eski bir soru olduğunu biliyorum, ancak şu anda tam olarak bu sorunu çözmek için kütüphaneyle oynuyorum . C ++ 14 gerektirir.

#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()Sayı dizileri oluşturmak için basit bir şablon işlevi yarattım . seq()İşlevsellik, R ( bağlantı ) ' daki işlevi takip eder . Bu işlevin güzel yanı, çeşitli sayı dizileri ve türleri oluşturmak için çalışmasıdı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;
}

Örnek kullanım:

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

Tek uyarı, tüm sayıların aynı türden türetilmiş olması gerektiğidir. Diğer bir deyişle, çiftler veya kayan değerler için, gösterildiği gibi tüm girdiler için ondalık sayılar ekleyin.

Güncelleme: 14 Haziran 2018

brainsandwich ve undercore_d çok iyi fikirler verdi. Doldurmak içeriği değiştirmek olduğundan, STL algoritmaları arasında en basit olan for_each () da faturayı doldurmalıdır:

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

Genelleştirilmiş yakalama [i=o], lambda ifadesine bir değişmez verir ve onu bilinen bir duruma (bu durumda 0) başlatır. anahtar kelime mutablebu durumun lambda her çağrıldığında güncellenmesine izin verir.

Bir dizi kare elde etmek için sadece küçük bir değişiklik gerekir:

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

R benzeri sekans oluşturmak artık zor değil, ancak R'de sayısal modun aslında iki katı olduğuna dikkat edin, bu nedenle türü parametreleştirmeye gerçekten gerek yoktur. Sadece duble kullanın.