logical_not (struct)

Objet de fonction prédéfini qui effectue l’opération logique non (operator!) sur son argument.

Syntaxe

template <class Type = void>
struct logical_not : public unary_function<Type, bool>
{
    bool operator()(const Type& Left) const;
};

// specialized transparent functor for operator!
template <>
struct logical_not<void>
{
  template <class Type>
  auto operator()(Type&& Left) const
     -> decltype(!std::forward<Type>(Left));
};

Paramètres

Type
Tout type qui prend en charge un operator! qui accepte un opérande du type spécifié ou déduit.

Left
Opérande de l’opération NOT logique. Le modèle non spécifié prend un argument de référence lvalue de type Type. Le modèle spécialisé effectue un transfert parfait des arguments de référence lvalue et rvalue du type déduit.

Valeur de retour

Résultat de !Left. Le modèle spécialisé effectue un transfert parfait du résultat, qui a le type retourné par operator!.

Exemple

// functional_logical_not.cpp
// compile with: /EHsc
#include <deque>
#include <algorithm>
#include <functional>
#include <iostream>

int main( )
{
   using namespace std;
   deque<bool> d1, d2 ( 7 );
   deque<bool>::iterator iter1, iter2;

   int i;
   for ( i = 0 ; i < 7 ; i++ )
   {
      d1.push_back((bool)((i % 2) != 0));
   }

   cout << boolalpha;    // boolalpha I/O flag on

   cout << "Original deque:\n d1 = ( " ;
   for ( iter1 = d1.begin( ) ; iter1 != d1.end( ) ; iter1++ )
      cout << *iter1 << " ";
   cout << ")" << endl;

   // To flip all the truth values of the elements,
   // use the logical_not function object
   transform( d1.begin( ), d1.end( ), d2.begin( ),logical_not<bool>( ) );
   cout << "The deque with its values negated is:\n d2 = ( " ;
   for ( iter2 = d2.begin( ) ; iter2 != d2.end( ) ; iter2++ )
      cout << *iter2 << " ";
   cout << ")" << endl;
}

Original deque:
d1 = ( false true false true false true false )
The deque with its values negated is:
d2 = ( true false true false true false true )