std::not2
| Definido en el encabezado <functional>
|
||
template< class Predicate >
std::binary_negate<Predicate> not2( const Predicate& pred );
|
(hasta C++14) | |
template< class Predicate >
constexpr std::binary_negate<Predicate> not2( const Predicate& pred );
|
(desde C++14) (obsoleto en C++17) (eliminado en C++20) |
|
std::not2 es una función auxiliar para crear un objeto función que devuelve el complemento del predicado binario pasado. El objeto función creado es de tipo std::binary_negate<Predicate>.
El tipo del predicado binario debe definir dos tipos miembro, first_argument_type y second_argument_type, que sean convertibles a los tipos de parámetro del predicado. Los objetos función obtenidos de 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, o de otra llamada a std::not2 tienen estos tipos definidos, al igual que los objetos función derivados del obsoleto std::binary_function.
Parámetros
| pred | - | predicado binario |
Valor de retorno
std::not2
devuelve un objeto de tipo
std::
binary_negate
<
Predicate
>
, construido con
pred
.
Ejemplo
#include <algorithm> #include <cstddef> #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 << "negando un 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 << "negando un funtor estándar:\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 << "negando un 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 << "negando un 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'; }
Salida:
negando un binary_function: 0 2 true 1 1 false 2 0 true negando un functor estándar: 0 2 true 1 1 false 2 0 true negando un std::function: 0 2 true 1 1 false 2 0 true negando un std::reference_wrapper: 0 2 true 1 1 false 2 0 true
Véase también
|
(C++17)
|
crea un objeto función que devuelve el complemento del resultado del objeto función que contiene
(plantilla de función) |
|
(obsoleto en C++17)
(eliminado en C++20)
|
objeto función contenedor que devuelve el complemento del predicado binario que contiene
(plantilla de clase) |
|
(C++11)
|
contenedor copiable de cualquier objeto invocable copiable
(plantilla de clase) |
|
(C++23)
|
contenedor no copiable de cualquier objeto invocable que admita calificadores en una signatura de llamada dada
(plantilla de clase) |
|
(obsoleto en C++17)
(eliminado en C++20)
|
construye un objeto
std::unary_negate
personalizado
(plantilla de función) |
|
(obsoleto en C++11)
(eliminado en C++17)
|
crea un contenedor de objeto función compatible con adaptadores a partir de un puntero a función
(plantilla de función) |
|
(obsoleto en C++11)
(eliminado en C++17)
|
clase base de función binaria compatible con adaptadores
(plantilla de clase) |