NAME¶

std::not2 - std::not2

Synopsis¶

Defined in header <functional>
template< class Predicate > (until C++14)
std::binary_negate<Predicate> not2(const Predicate& pred);
template< class Predicate > (since C++14)
constexpr std::binary_negate<Predicate> not2(const Predicate& (deprecated in C++17)
pred); (removed in C++20)

not2 is a helper function to create a function object that returns the complement of
the binary predicate function passed. The function object created is of type
std::binary_negate<Predicate>.

The binary predicate type must define two member types, first_argument_type and
second_argument_type, that are convertible to the predicate's parameter types. The
function objects obtained from std::owner_less, std::ref, std::cref, std::plus,
std::minus, std::multiplies, std::divides, std::modulus, std::equal_to,
std::not_equal_to, std::greater, std::less, std::greater_equal, std::less_equal,
std::logical_not, std::logical_or, std::bit_and, std::bit_or, std::bit_xor,
std::mem_fn, std::map::value_comp, std::multimap::value_comp, std::function, or from
another call to std::not2 have these types defined, as are function objects derived
from the deprecated std::binary_function.

Parameters¶

pred - binary predicate

Return value¶

std::not2 returns an object of type std::binary_negate<Predicate>, constructed with
pred.

Exceptions¶

None.

Example¶

// Run this code

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>

struct old_same : std::binary_function<int, int, bool>
{
bool operator()(int a, int b) const { return a == b; }
};

struct new_same
{
bool operator()(int a, int b) const { return a == b; }
};

bool same_fn(int a, int b)
{
return a == b;
}

int main()
{
std::vector<int> v1{0, 1, 2};
std::vector<int> v2{2, 1, 0};
std::vector<bool> v3(v1.size());

std::cout << "negating a binary_function:\n";
std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
std::not2(old_same()));

std::cout << std::boolalpha;
for (std::size_t i = 0; i < v1.size(); ++i)
std::cout << v1[i] << ' ' << v2[i] << ' ' << v3[i] << '\n';

std::cout << "negating a standard functor:\n";
std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
std::not2(std::equal_to<int>()));

for (std::size_t i = 0; i < v1.size(); ++i)
std::cout << v1[i] << ' ' << v2[i] << ' ' << v3[i] << '\n';

std::cout << "negating a std::function:\n";
std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
std::not2(std::function<bool(int,int)>(new_same())));

for (std::size_t i = 0; i < v1.size(); ++i)
std::cout << v1[i] << ' ' << v2[i] << ' ' << v3[i] << '\n';

std::cout << "negating a std::reference_wrapper:\n";
std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
std::not2(std::ref(same_fn)));

for (std::size_t i = 0; i < v1.size(); ++i)
std::cout << v1[i] << ' ' << v2[i] << ' ' << v3[i] << '\n';

}

Output:¶

negating a binary_function:
0 2 true
1 1 false
2 0 true
negating a standard functor:
0 2 true
1 1 false
2 0 true
negating a std::function:
0 2 true
1 1 false
2 0 true
negating a std::reference_wrapper:
0 2 true
1 1 false
2 0 true

See also¶

not_fn Creates a function object that returns the complement of the
(C++17) result of the function object it holds
(function template)
binary_negate wrapper function object returning the complement of the binary
(deprecated in C++17) predicate it holds
(removed in C++20) (class template)
function wraps callable object of any copy constructible type with
(C++11) specified function call signature
(class template)
move_only_function wraps callable object of any type with specified function call
(C++23) signature
(class template)
not1 constructs custom std::unary_negate object
(deprecated in C++17) (function template)
(removed in C++20)
ptr_fun creates an adaptor-compatible function object wrapper from a
(deprecated in C++11) pointer to function
(removed in C++17) (function template)
binary_function adaptor-compatible binary function base class
(deprecated in C++11) (class template)
(removed in C++17)