C++ std::vector Initialization with Consecutive Unsigned Integers

c++initializationstdstdvectorstl

I want to use a special method to initialize a std::vector<unsigned int> which is described in a C++ book I use as a reference (the German book 'Der C++ Programmer' by Ulrich Breymann, in case that matters). In that book is a section on sequence types of the STL, referring in particular to list, vector and deque. In this section he writes that there are two special constructors of such sequence types, namely, if Xrefers to such a type,

X(n, t) // creates a sequence with n copies of t
X(i, j) // creates a sequence from the elements of the interval [i, j)

I want to use the second one for an interval of unsigned int, that is

std::vector<unsigned int> l(1U, 10U);

to get a list initialized with {1,2,...,9}. What I get, however, is a vector with one unsigned int with value 10 😐 Does the second variant exist, and if yes, how do I force that it is called?

Best Answer

there are at least three ways that you can do that. One was mentioned earlier by Brian

//method 1
generate(v.begin(), v.end(), [] { static int i {1}; return i++; });

You can also use std::iota if you are using c++11

//method 2
iota(v.begin(), v.end(), 1);

Or instead you can initialize your container with 1s and then do a partial sum on that. I don't think anybody will use this third method anyway :)

//method 3
vector<int> v(n, 1);                                                     
partial_sum(v.begin(), v.end(), v.begin());

Related Solutions

C++11 – Initializing a 2D Vector Using Initialization List

What is a correct way of doing it?

The way you showed is a possible way. You could also use:

vector<vector<int>> myvect = { {10,20,30,40},
                               {50,60,70,80} };

vector<vector<int>> myvect{ vector<int>{10,20,30,40},
                            vector<int>{50,60,70,80} };

The first one constructs a std::initializer_list<std::vector<int>> where the elements are directly initialized from the inner braced-initializer-lists. The second one explicitly constructs temporary vectors which then are moved into a std::initializer_list<std::vector<int>>. This will probably not make a difference, since that move can be elided.

In any way, the elements of the std::initializer_list<std::vector<int>> are copied back out into myvect (you cannot move out of a std::initializer_list).

And how can i iterate through it using for?

You essentially have a vector of vectors, therefore you need two loops:

for(vector<int> const& innerVec : myvect)
{
    for(int element : innerVec)
    {
        cout << element << ',';
    }
    cout << endl;
}

I refrained from using auto to explicitly show the resulting types.

And by the way what does this mean ?

This is probably a typo. As it stands, it's illegal. The declaration vector<int> myvect[5]; declares an array of 5 vector<int>. The following list-initialization therefore needs to initialize the array, but the elements of this list are not implicitly convertible to vector<int> (there's a ctor that takes a size_t, but it's explicit).

That has already been pointed out in the comments of that side.

I guess the author wanted to write std::vector<int> vArray = {3, 2, 7, 5, 8};.

Best Answer

Related Solutions

C++11 – Initializing a 2D Vector Using Initialization List

Related Question