# not_equal_to Struct

**Visual Studio 2015**

The latest version of this topic can be found at not_equal_to Struct.

A binary predicate that performs the inequality operation ( `operator!=`

) on its arguments.

template <class Type = void> struct not_equal_to : public binary_function<Type, Type, bool> { bool operator()( const Type& Left, const Type& Right) const; }; // specialized transparent functor for operator!= template <> struct not_equal_to<void> { template <class T, class U> auto operator()(T&& Left, U&& Right) const -> decltype(std::forward<T>(Left) != std::forward<U>(Right)); };

#### Parameters

`Type`

, `T`

, `U`

Any type that supports an `operator!=`

that takes operands of the specified or inferred types.

`Left`

The left operand of the inequality operation. The unspecialized template takes an lvalue reference argument of type `Type`

. The specialized template does perfect forwarding of lvalue and rvalue reference arguments of inferred type `T`

.

`Right`

The right operand of the inequality operation. The unspecialized template takes an lvalue reference argument of type `Type`

. The specialized template does perfect forwarding of lvalue and rvalue reference arguments of inferred type `U`

.

The result of `Left``!=``Right`

. The specialized template does perfect forwarding of the result, which has the type that's returned by `operator!=`

.

The objects of type `Type`

must be equality-comparable. This requires that the `operator!=`

defined on the set of objects satisfies the mathematical properties of an equivalence relation. All of the built-in numeric and pointer types satisfy this requirement.

// functional_not_equal_to.cpp // compile with: /EHsc #include <vector> #include <functional> #include <algorithm> #include <iostream> using namespace std; int main( ) { vector <double> v1, v2, v3 (6); vector <double>::iterator Iter1, Iter2, Iter3; int i; for ( i = 0 ; i <= 5 ; i+=2 ) { v1.push_back( 2.0 *i ); v1.push_back( 2.0 * i + 1.0 ); } int j; for ( j = 0 ; j <= 5 ; j+=2 ) { v2.push_back( - 2.0 * j ); v2.push_back( 2.0 * j + 1.0 ); } cout << "The vector v1 = ( " ; for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ ) cout << *Iter1 << " "; cout << ")" << endl; cout << "The vector v2 = ( " ; for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ ) cout << *Iter2 << " "; cout << ")" << endl; // Testing for the element-wise equality between v1 & v2 transform ( v1.begin( ), v1.end( ), v2.begin( ), v3.begin ( ), not_equal_to<double>( ) ); cout << "The result of the element-wise not_equal_to comparsion\n" << "between v1 & v2 is: ( " ; for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ ) cout << *Iter3 << " "; cout << ")" << endl; } /* Output: The vector v1 = ( 0 1 4 5 8 9 ) The vector v2 = ( -0 1 -4 5 -8 9 ) The result of the element-wise not_equal_to comparsion between v1 & v2 is: ( 0 0 1 0 1 0 ) */

**Header:** <functional>

**Namespace:** std