How can I pass a part of a vector as a function argument?

Question

I'm using a vector in a C++ program and I need to pass a part of that vector to a function.

If it was C, I would need to do the following (with arrays):

int arr[5] = {1, 2, 3, 4, 5};
func(arr+2);  // Pass the part of the array {3, 4, 5}

Is there any other way than creating a new vector with the last part?

Answer 1

A common approach is to pass iterator ranges. This will work with all types of ranges, including those belonging to standard library containers and plain arrays:

template <typename Iterator>
void func(Iterator start, Iterator end) 
{
  for (Iterator it = start; it !=end; ++it)
  {
     // do something
  } 
}

then

std::vector<int> v = ...;
func(v.begin()+2, v.end());

int arr[5] = {1, 2, 3, 4, 5};
func(arr+2, arr+5);

Note: Although the function works for all kinds of ranges, not all iterator types support the increment via operator+ used in v.begin()+2. For alternatives, have a look at std::advance and std::next.

Answer 2

The latest (C++20) approach is to use std::span. Create a std::span that views a part of std::vector and pass it to functions. Note: the elements must be continuous in memory to use std::span on a container, and std::vector is continuous in memory.

#include <span>

std::vector<int> int_vector = {1, 2, 3, 4, 5};
std::span<int> a_span(int_vector.data() + 2, int_vector.size() - 2);
for(const int a : a_span);
for(const int& a : a_span);
function(a_span);

Answer 3

Generically you could send iterators.

static const int n[] = {1,2,3,4,5};
vector <int> vec;
copy (n, n + (sizeof (n) / sizeof (n[0])), back_inserter (vec));

vector <int>::iterator itStart = vec.begin();
++itStart; // points to `2`
vector <int>::iterator itEnd = itStart;
advance (itEnd,2); // points to 4

func (itStart, itEnd);

This will work with more than just vectors. However, since a vector has guaranteed contigious storage, so long as the vector doesn't reallocate you can send the addresses of elements:

func (&vec[1], &vec[3]);

Answer 4

As of C++20, I would make use of a range from the Ranges library, because it offers a variety of range adaptors for creating different views on you vector. For your use case, I would use the range adaptor std::views::drop as follows:

int main() {
    std::vector<int> arr {1, 2, 3, 4, 5};

    // Ignore the first two elements and pass only {3, 4, 5} to func().
    func(arr | std::views::drop(2));

    return 0;
}

This way you don't have to bother with interators or pointer/iterator arithmetic. Also, no temporary vector is created for your shortened arr, because the view adaptor drop() creates a range that doesn't contain elements. The resulting range is just a view over the original vector arr, but with a customized iteration behavior.

For the declaration of func() I would use the placeholder type auto for the function parameter, because the type of the resulting range is quite complex. This makes func() a function template, though:

void func(auto range) {
    for (int i : range)
        std::cout << i << std::endl;
}

(Alternatively, you could pass arr by reference to func() and apply the range adaptor inside func().)

Output:

3
4
5

Code on Wandbox

Answer 5

std::vector<char> b(100); 
send(z,&b[0],b.size(),0);

Try out this.

Read this too.

Answer 6

As some others already stated you can use iterators for that. You'll have to pass the start of the sequence and the end of the sequence to your worker function.

If you need more flexibility, you should take a look at slice. With slice you can for example retrieve every n-th entry of the vector.

Answer 7

I was also stuck to same problem.I found one really nice trick.Suppose you want to find the minimum in range L to R (both inclusive) of arr then you can do something like this:

vector<int>arr = {4,5,1,3,7};

int minVal = *min_element(begin(arr)+L,begin(arr)+(R+1));

Means you pass the complete array and range and then you can apply the above trick.