algorithm - libreria - std for_each c++

¿Cómo puedo negar un functor en C++(STL)?

Question

Tengo alguna función para encontrar un valor:

struct FindPredicate
{

    FindPredicate(const SomeType& t) : _t(t) {
    }
    bool operator()(SomeType& t) {
      return t == _t;
    }

private:
    const SomeType& _t;
};

bool ContainsValue(std::vector<SomeType>& v, SomeType& valueToFind) {
    return find_if(v.begin(), v.end(), FindPredicate(valueToFind)) != v.end();
}

Ahora me gustaría escribir una función que compruebe si todos los miembros de un vector satisfacen ese predicado:

bool AllSatisfy(std::vector<SomeType>& v) {
    /* ... */
}

Una solución es usar el algoritmo std::count_if .

¿Alguien sabe una solución que implica negar el predicado?

Answer 1

A medida que lo usa, no necesita el functor FindPredicate, ya que en el ejemplo solo está probando la igualdad.

bool all_equal(std::vector<SomeType>& v, SomeType& valueToFind)
{
   return v.end() == find_if(v.begin(), v.end(), std::bind1st (equal_to (), valueToFind) );
}

bool all_not_equal( std::vector<SomeType>& v, SomeType &valueToFind ) {
{
   return v.end() == find_if(v.begin(), v.end(), std::bind1st (not_equal_to (), valueToFind) );
}

Y podrías hacer de esto una plantilla en sí misma.

template< typename InputIterator , typename Predicate >
bool test_all( InputIterator first, InputIterator last, Predicate pred )
{
  return last == find_if( first, last, pred );
}

test_all( v.begin(), v.end(), std::bind1st( not_equals_to_( value )) );

Answer 2

Consulte el func. Biblioteca de std not1 , devuelve un functor que es lógico, no de lo que devuelva el functor que le proporcione.

Debería poder hacer algo como:

bool AllSatisfy(std::vector<SomeType>& v, SomeType& valueToFind) {
    return find_if(v.begin(), v.end(), not1(FindPredicate(valueToFind))) != v.end();
}

Answer 3

La mejor solución es usar la biblioteca funcional STL . Al derivar su predicado de la función unary_function<SomeType, bool> , entonces podrá usar la función not1 , que hace exactamente lo que necesita (es decir, negando un predicado unario).

Aquí es cómo puedes hacer eso:

struct FindPredicate : public unary_function<SomeType, bool>
{
    FindPredicate(const SomeType& t) : _t(t) {}

    bool operator()(const SomeType& t) const {
      return t == _t;
    }

private:
    const SomeType& _t;
};

bool AllSatisfy(std::vector<SomeType>& v, SomeType& valueToFind)
{
    return find_if(v.begin(), 
                   v.end(), 
                   not1(FindPredicate(valueToFind))) == v.end();
}

Si desea lanzar su propia solución (que es, en mi humilde opinión, no es la mejor opción ...), bien, podría escribir otro predicado que sea la negación del primero:

struct NotFindPredicate
{

    NotFindPredicate(const SomeType& t) : _t(t) {
    }
    bool operator()(SomeType& t) {
      return t != _t;
    }

private:
    const SomeType& _t;
};

bool AllSatisfy(std::vector<SomeType>& v) {
    return find_if(v.begin(), 
                   v.end(), 
                   NotFindPredicate(valueToFind)) == v.end();
}

O podría hacerlo mejor y escribir una plantilla de factor de negor, como:

template <class Functor>
struct Not
{
    Not(Functor & f) : func(f) {}

    template <typename ArgType>
    bool operator()(ArgType & arg) { return ! func(arg); }

  private:
    Functor & func;
};

que podrías usar como sigue:

bool AllSatisfy(std::vector<SomeType>& v, SomeType& valueToFind)
{
    FindPredicate f(valueToFind);
    return find_if(v.begin(), v.end(), Not<FindPredicate>(f)) == v.end();
}

Por supuesto, la última solución es mejor porque puede reutilizar la estructura No con cada functor que desee.

Answer 4

La primera vez que usé not1 me pregunté por qué no se llamaba simplemente not .

La respuesta me sorprendió un poco (ver comentario).