geeksforgeeks - stl c++

¿Hay una alternativa segura a std:: equal?

Question

std::equal() no es seguro porque la función no puede saber si rebasará la longitud del segundo contenedor que se va a comparar. Es decir:

std::vector< int > v( 100 );
std::vector< int > w( 10 );
bool same = std::equal( v.begin(), v.end(), w.begin() );

... dará como resultado un desbordamiento del búfer para w .

Naturalmente, podemos probar estas cosas ( v.size() == w.size() ), pero los compiladores como Visual Studio 2010 todavía informan que la función en sí misma no es segura. Y, de hecho, no es seguro en un sentido fundamental: un equipo de programadores de diferentes niveles de experiencia se olvidará eventualmente de comparar tamaños.

Una alternativa segura es fácil de implementar.

template< typename Iter1, typename Iter2 >
bool equal_safe( Iter1 begin1, Iter1 end1, Iter2 begin2, Iter2 end2 )
{
while( begin1 != end1 && begin2 != end2 )
{
if( *begin1 != *begin2 )
{
return false;
}
++begin1;
++begin2;
}
return begin1 == end1 && begin2 == end2;
}

Pero, ¿hay una alternativa segura en la biblioteca estándar?

Answer 1

Yo también quería esa característica. No he podido encontrar ninguna instalación en la biblioteca estándar.

Si estás dispuesto a usar boost Boost.Range tiene igual, creo que es lo que estás buscando http://www.boost.org/doc/libs/1_53_0/libs/range/doc/html/range/reference/algorithms/non_mutating/equal.html

Answer 2

vector tiene un operador == que primero verifica el tamaño. En su ejemplo, simplemente use la condición v==w .

Answer 3

En C ++ 14, la biblioteca estándar contendrá una versión de std::equal que toma dos pares de iteradores, similar a su safe_equal . Lo mismo para std::mismatch y std::is_permutation .

Answer 4

Tengo el mismo problema y lo solucioné al verificar el tamaño del vector antes de igual.

 std::vector< int > v( 100 );
std::vector< int > w( 10 );
bool same = (v.size() == w.size()) && std::equal( v.begin(), v.end(), w.begin() );

Answer 5

También puede usar std::lexicographical_compare dos veces para determinar si cualquiera de las secuencias es menor que la otra.