Cast vector<int> to vector<unsigned int>

I have a vector<int> and functions that only accepts a vector<unsigned int> references.I know that I could change/template the functions(and this is likely the best thing to do), but ideally I would have a way to cast/convert the vector<unsigned int> reference to a vector<int> reference. I know that all values in the vector are positive, and non of the functions will even come close to overflowing the intigers.

I have tried using static_cast<vector<int>> but that doesnt work.

Edit:
I say cast/convert of the references but I am not looking to create a new copy and reference that.

you cannot cast, but you mention conversion is an option, which is easily done like this:

void foo(const std::vector<unsigned int>& data)
{
	 // ...
}

void main()
{
	std::vector<int> vec;
	foo({ vec.begin(), vec.end() });
}

Use std::transform to make a new copy of the vector with converted values. You cannot and should not reinterpret_cast to cast between unrelated types (std::vector<int> != std::vector<unsigned int>)

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

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

	// avoid raw for loops
	std::transform(values.begin(), values.end(), std::back_inserter(converted_values), [](const int value)
	{ 
		return static_cast<unsigned int>(value); 
	});

	for (const auto& value : convered_values)
	{
		std::cout << value << " ";
	}

	return 0;
}

One C++20,23 approach would be to use ranges:

#incluce <ranges>
template<typename result>
constexpr auto cast_trans = std::views::transform( // C++20
            [](auto const& x)
            { return static_cast<result>(x); });

std::vector<int> vint;
auto ruint = vint | cast_trans<unsigned>; 

auto vuint = ruint | std::ranges::to<std::vector>; // C++23

Ranges library has got a lot explore.

There is no cast that does not result in undefined behaviour, but if you really want to do this then this will probably work in practise

*reinterpret_cast<vector<unsigned int>*>(&vec)

Create a pointer, cast the pointer, then dereference. I used to do this sort of thing all the time when I was a C programmer.

Really though, you should not do this.