sử dụng std :: điền để điền vectơ với số lượng ngày càng tăng

Tôi muốn điền vector<int>bằng cách sử dụng std::fill, nhưng thay vì một giá trị, vectơ phải chứa các số theo thứ tự tăng dần sau.

Tôi đã cố gắng đạt được điều này bằng cách lặp lại từng tham số thứ ba của hàm, nhưng điều này sẽ chỉ cung cấp cho tôi một trong hai vectơ được lấp đầy bởi 1 hoặc 2 (tùy thuộc vào vị trí của ++toán tử).

Thí dụ:

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

Tốt hơn là sử dụng std::iotanhư thế này:

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

Điều đó nói rằng, nếu bạn không có bất kỳ c++11hỗ trợ nào (vẫn là một vấn đề thực sự ở nơi tôi làm việc), hãy sử dụng std::generatenhư sau:

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.

Bạn nên sử dụng std::iotathuật toán (được định nghĩa trong <numeric>):

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

Vì std::fillchỉ cần gán giá trị cố định đã cho cho các phần tử trong dãy đã cho [n1,n2). Và std::iotađiền vào phạm vi đã cho [n1, n2)với các giá trị tăng dần, bắt đầu với giá trị ban đầu và sau đó sử dụng ++value. Bạn cũng có thể sử dụng std::generatethay thế.

Đừng quên đó std::iotalà thuật toán C ++ 11 STL. Nhưng rất nhiều trình biên dịch hiện đại hỗ trợ nó, ví dụ như GCC, Clang và VS2012: http://msdn.microsoft.com/en-us/library/vstudio/jj651033.aspx

PS Hàm này được đặt tên theo hàm số nguyên ⍳từ ngôn ngữ lập trình APL và ký hiệu một chữ cái Hy Lạp iota. Tôi suy đoán rằng ban đầu trong APL cái tên kỳ lạ này được chọn vì nó giống với một “integer”(mặc dù trong toán học iota được sử dụng rộng rãi để biểu thị phần ảo của một số phức).

Lựa chọn đầu tiên của tôi (ngay cả trong C ++ 11) sẽ là boost::counting_iterator:

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

hoặc nếu vectơ đã được tạo:

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

Nếu bạn không thể sử dụng Boost: hoặc std::generate(như được đề xuất trong các câu trả lời khác) hoặc counting_iteratortự triển khai , nếu bạn cần nó ở nhiều nơi khác nhau. (Với Boost, bạn có thể sử dụng một transform_iteratorcủa một counting_iteratorđể tạo ra tất cả các loại chuỗi thú vị. Nếu không có Boost, bạn có thể làm được rất nhiều điều này bằng tay, hoặc trong các hình thức của một loại đối tượng phát cho std::generate, hoặc là một cái gì đó bạn có thể cắm vào một trình lặp đếm viết tay.)

Tôi đã xem các câu trả lời với std :: create nhưng bạn cũng có thể "cải thiện" điều đó bằng cách sử dụng các biến tĩnh bên trong lambda, thay vì khai báo một bộ đếm bên ngoài hàm hoặc tạo một lớp trình tạo:

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

Tôi thấy nó ngắn gọn hơn một chút

Nếu bạn không muốn sử dụng các tính năng của C ++ 11, bạn có thể sử dụng 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;
    }
}

Chương trình này in từ 0 đến 9.

Chúng ta có thể sử dụng hàm tạo tồn tại trong tệp tiêu đề thuật toán.

Đoạn mã:

#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 được giới hạn trong dãy n, n + 1, n + 2, ...

Nhưng nếu bạn muốn điền vào một mảng với một chuỗi chung f (0), f (1), f (2), v.v.? Thông thường, chúng ta có thể tránh một trình tạo theo dõi trạng thái. Ví dụ,

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

sẽ tạo ra chuỗi các ô vuông

0 1 4 9 16 25 36

Tuy nhiên, thủ thuật này sẽ không hoạt động với các vùng chứa khác.

Nếu bạn bị mắc kẹt với C ++ 98, bạn có thể làm những điều khủng khiếp như:

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

và sau đó

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

Nhưng tôi sẽ không giới thiệu nó. :)

cái này cũng hoạt động

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

Về mặt hiệu suất, bạn nên khởi tạo vector bằng cách sử dụng reserve()kết hợp với các push_back()hàm như trong ví dụ dưới đây:

const int numberOfElements = 10;

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

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

Tất cả các std::fill, std::generatevv đang hoạt động trên phạm vi nội dung vector hiện có, và, do đó các vectơ phải được lấp đầy với một số dữ liệu trước đó. Ngay cả khi làm như sau: std::vector<int> data(10);tạo một vectơ với tất cả các phần tử được đặt thành giá trị mặc định của nó (tức là 0 trong trường hợp của int).

Đoạn mã trên tránh khởi tạo nội dung vectơ trước khi điền vào nó với dữ liệu bạn thực sự muốn. Hiệu suất của giải pháp này có thể nhìn thấy rõ trên các tập dữ liệu lớn.

Có một tùy chọn khác - mà không cần sử dụng iota. Biểu thức for_each + lambda có thể được sử dụng:

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

Hai điều quan trọng tại sao nó hoạt động:

1. Lambda nắm bắt phạm vi bên ngoài [&] có nghĩa là tôi sẽ có sẵn biểu thức bên trong
2. mục được truyền dưới dạng tham chiếu, do đó, nó có thể thay đổi bên trong vectơ

Nếu bạn thực sự muốn sử dụng std::fillvà bị giới hạn trong C ++ 98, bạn có thể sử dụng một cái gì đó như sau,

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

Nói về tăng:

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

Tôi biết đây là câu hỏi cũ, nhưng tôi hiện đang sử dụng thư viện để xử lý chính xác vấn đề này. Nó yêu cầu 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, ...

Tôi đã tạo một hàm mẫu đơn giản Sequence(), để tạo chuỗi số. Chức năng theo sau seq()chức năng trong R ( liên kết ). Điều thú vị về chức năng này là nó hoạt động để tạo ra nhiều loại và chuỗi số.

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

Ví dụ sử dụng:

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

Điều lưu ý duy nhất là tất cả các số phải thuộc cùng một kiểu suy luận. Nói cách khác, đối với số đôi hoặc số nổi, hãy bao gồm số thập phân cho tất cả các đầu vào, như được minh họa.

Cập nhật: 14/06/2018

brainsandwich và underscore_d đã đưa ra những ý kiến ​​rất hay. Vì việc điền là thay đổi nội dung, for_each (), thuật toán đơn giản nhất trong số các thuật toán STL, cũng sẽ điền vào hóa đơn:

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

Việc nắm bắt tổng quát [i=o]truyền tải biểu thức lambda với một bất biến và khởi tạo nó ở trạng thái đã biết (trong trường hợp này là 0). từ khóa mutablecho phép trạng thái này được cập nhật mỗi khi lambda được gọi.

Chỉ cần một chút sửa đổi để có một chuỗi các ô vuông:

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

Để tạo ra seq giống R không khó hơn, nhưng lưu ý rằng trong R, chế độ số thực sự gấp đôi, vì vậy thực sự không cần thiết phải tham số hóa kiểu. Chỉ cần sử dụng gấp đôi.