HP C++ User Documentation

Standard C++ LibraryCopyright 1996, Rogue Wave Software, Inc.

NAME

  Negators  - Function adaptors and function objects used to reverse the
  sense of predicate function objects.

SYNOPSIS

  #include <functional>

  template <class Predicate>
  class unary_negate;

  template <class Predicate>
  unary_negate<Predicate> not1(const Predicate&);

  template <class Predicate>
  class binary_negate;

  template <class Predicate>
  binary_negate<Predicate> not2(const Predicate&);

DESCRIPTION

  Negators not1 and not2 are functions that take predicate function objects
  as arguments and return predicate function objects with the opposite sense.
  Negators work only with function objects defined as subclasses of the
  classes unary_function  and binary_function.  not1 accepts and returns
  unary predicate function objects.  not2 accepts and returns binary
  predicate function objects.

  unary_negate and binary_negate are function object classes that provide
  return types for the negators, not1 and not2.

INTERFACE

  template <class Predicate>
  class unary_negate
    : public unary_function<typename Predicate::argument_type, bool> {

  public:
   typedef typename unary_function<typename Predicate::argument_type,
                                   bool>::argument_type argument_type;
   typedef typename unary_function<typename Predicate::argument_type,
                                   bool>::result_type result_type;
   explicit unary_negate (const Predicate&);
   bool operator() (const argument_type&) const;
  };

  template<class Predicate>
  unary_negate <Predicate> not1 (const Predicate&);

  template<class Predicate>
  class binary_negate
    : public binary_function<typename Predicate::first_argument_type,
                            typename Predicate::second_argument_type,
                            bool>
  {
  public:
   typedef typename binary_function<typename
     Predicate::first_argument_type,
     typename Predicate::second_argument_type,
     bool>::second_argument_type second_argument_type;
   typedef typename binary_function<typename
     Predicate::first_argument_type,
     typename Predicate::second_argument_type,
     bool>::first_argument_type first_argument_type;
   typedef typename binary_function<typename
     Predicate::first_argument_type,
     typename Predicate::second_argument_type, bool>::result_type
                                                      result_type;
   explicit binary_negate (const Predicate&);
   bool operator() (const first_argument_type&,
                     const second_argument_type&) const;
  };

  template <class Predicate>
  binary_negate<Predicate> not2 (const Predicate&);

EXAMPLE

  //
  // negator.cpp
  //
   #include<functional>
   #include<algorithm>
   #include <iostream.h>

   //Create a new predicate from unary_function
  template<class Arg>
  class is_odd : public unary_function<Arg, bool>
   {
    public:
    bool operator()(const Arg& arg1) const
     {
      return (arg1 % 2 ? true : false);
     }
   };

  int main()
   {
    less<int> less_func;

     // Use not2 on less
    cout << (less_func(1,4) ? "TRUE" : "FALSE") << endl;
    cout << (less_func(4,1) ? "TRUE" : "FALSE") << endl;
    cout << (not2(less<int>())(1,4) ? "TRUE" : "FALSE")
          << endl;
    cout << (not2(less<int>())(4,1) ? "TRUE" : "FALSE")
          << endl;

     //Create an instance of our predicate
    is_odd<int> odd;

     // Use not1 on our user defined predicate
    cout << (odd(1) ? "TRUE" : "FALSE") << endl;
    cout << (odd(4) ? "TRUE" : "FALSE") << endl;
    cout << (not1(odd)(1) ? "TRUE" : "FALSE") << endl;
    cout << (not1(odd)(4) ? "TRUE" : "FALSE") << endl;

    return 0;
   }
  Output :
  TRUE
  FALSE
  FALSE
  TRUE
  TRUE
  FALSE
  FALSE
  TRUE

SEE ALSO

  algorithm, binary_function, function_object, unary_function

STANDARDS CONFORMANCE

  ANSI X3J16/ISO WG21 Joint C++ Committee