By range I mean a pair of iterators. In pseudo C++:
std::vector<int> v1 = { 1, 2, 3, 4, 5 };
std::vector<int> v2 = { 2, 3, 4 };
if( std::compare_range( v1.begin() + 1, v1.end() - 1, v2.begin(), v2.end() ) {
std::cout << "Alright\n";
}
compare_range being of course the function I'm looking for.
Disclaimer: This is a pretty trivial function to write, I know. But like all programmers, I try to be lazy ;-)
std::equal is the function template you are looking for.
if (std::equal(v1.begin() + 1, v1.end() - 1, v2.begin())
{
std::cout << "Alright\n";
}
Note that std::equal only takes three arguments, not four.
Use std::equal - it supports ranges as well.
If you have a means of determining that the two ranges have
exactly the same number of elements, std::equal will do. In
practice, this doesn't seem to be the case that often for me,
and most of the uses I have of std::equal are in fact
determining whether one range is a prefix of the other.
For actual comparisons, I've found std::lexicographical_compare
to be more useful, although the relationship it promesses is one
of order, not of equivalence. For equivalence, you can apply it
twice, e.g.
!lexicographical_compare(a.begin(), a.end(), b.begin(), b.end())
&& !lexicographical_compare(b.begin(), b.end(), a.begin(), a.end())
but this pretty much means comparing elements twice (unless there is a difference right at the beginning).
Is seems, that there is no standard "one-function" method. Mentioned std::equal assumes, that second range is not shorter than the first. For example, this may lead to memory corruption, when second interval is empty. It also does not give answer, when second range is larger.
Combination of std::equal and std::distance is required, or self-written function:
template <class InputIterator1, class InputIterator2>
bool safe_equal( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2 )
{
return ( std::distance( first1, last1 ) == std::distance( first2, last2 ) )
&& std::equal( first1, last1, first2 );
}
Function above may traverse containter twice for not Random Access Iterators, but uses standard functions. It may be reasonable to write own implementation, if this is not acceptable.
last2 instead of second2 and first open parenthesis after && is redundant.With C++20:
if (std::ranges::equal( std::ranges::subrange{ v1.begin() + 1, v1.end() - 1 }, v2) {
std::cout << "Alright\n";
}
or, if less/greater-check is required:
if (auto cmp = std::lexicographical_compare_three_way(v1.begin() + 1, v1.end() - 1, v2.begin(), v2.end()); cmp == 0) {
std::cout << "Alright\n";
}
else if (cmp < 0) {//...}
std::vector is a contiguous container so additional range-size-check is unnecessary for STL algorithms.
There is a function in Boost which checks also the size of the ranges:
boost::range::equal
