Namensräume
Varianten
Aktionen

std::not2

Aus cppreference.com
< cpp‎ | utility‎ | functional

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

 
C++
 
Utilities-Bibliothek
 
Function-Objekte
Funktionswrapper
function(C++11)
mem_fn(C++11)
bad_function_call(C++11)
Bindung
bind(C++11)
is_bind_expression(C++11)
is_placeholder(C++11)
_1, _2, _3, ...(C++11)
Referenzwrapper
reference_wrapper(C++11)
ref
cref		(C++11)
(C++11)
Operatorwrapper
Verneinung
not1
not2
Veraltete Binder und Adapter
unary_function(veraltet)
binary_function(veraltet)
ptr_fun(veraltet)
pointer_to_unary_function(veraltet)
pointer_to_binary_function(veraltet)
mem_fun(veraltet)
mem_fun_t
mem_fun1_t
const_mem_fun_t
const_mem_fun1_t		(veraltet)
(veraltet)
(veraltet)
(veraltet)
mem_fun_ref(veraltet)
mem_fun_ref_t
mem_fun1_ref_t
const_mem_fun_ref_t
const_mem_fun1_ref_t		(veraltet)
(veraltet)
(veraltet)
(veraltet)
binder1st
binder2nd		(veraltet)
(veraltet)
bind1st
bind2nd		(veraltet)
(veraltet)
 
definiert in Header <functional>
template< class Predicate >
std::binary_negate<Predicate> not2(const Predicate& pred);
not2 ist eine Hilfsfunktion, um eine Funktion Objekt, das das Komplement der binären Prädikats-Funktion übergeben zurückgibt. Die Funktion Objekt erstellt ist vom Typ std::binary_negate<Predicate> .
Original:
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 text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Die binäre Prädikat Typ muss definieren zwei Elementtypen, first_argument_type und second_argument_type, die umwandelbar in das Prädikat der Parameter Typen sind. Die Funktion Objekte aus std::owner_less erhalten, 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 oder aus einem anderen Anruf an std::not2 haben diese Arten definiert, als Funktion von Objekten aus der veralteten std::binary_function abgeleitet sind .
Original:
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.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Inhaltsverzeichnis

[Bearbeiten] Parameter

pred -
unären Prädikat
Original:
unary predicate
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Rückgabewert

std::not2 gibt ein Objekt vom Typ std::binary_negate<Predicate> mit pred gebaut .
Original:
std::not2 returns an object of type std::binary_negate<Predicate>, constructed with pred.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Ausnahmen

None .
Original:
None.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Beispiel

#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

[Bearbeiten] Siehe auch
Wrapper-Funktion Objekt wieder das Komplement der binären Prädikats es hält
Original:
wrapper function object returning the complement of the binary predicate it holds
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(Klassen-Template) [edit]
(C++11)
wickelt aufrufbare Objekt eines beliebigen Typs mit dem angegebenen Funktion Call-Signatur
Original:
wraps callable object of any type with specified function call signature
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(Klassen-Template) [edit]
baut kundenspezifische std::unary_negate Objekt
Original:
constructs custom std::unary_negate object
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(Funktions-Template) [edit]
(veraltet)
schafft eine Adapter-kompatiblen Funktion Objekt-Wrapper von einem Zeiger auf eine Funktion
Original:
creates an adaptor-compatible function object wrapper from a pointer to function
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(Funktions-Template) [edit]
(veraltet)
Adapter kompatibel Binärfunktion Basisklasse
Original:
adaptor-compatible binary function base class
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(Klassen-Template) [edit]
Von „https://de.cppreference.com/mwiki/index.php?title=cpp/utility/functional/not2&oldid=28310“