operator!= (<memory>)

Article
06/09/2015

Teste si les deux objets sont inégaux.

template<class Type, class Other>
   bool operator!=(
      const allocator<Type>& _Left,
      const allocator<Other>& _Right
   ) throw();
template<class Type1, class Del1, class Type2, class Del2>
    bool operator!=(
        const unique_ptr<Type1, Del1>& _Left,
        const unique_ptr<Type2&, Del2>& _Right
);
template<class Ty1, class Ty2>
    bool operator!=(
        const shared_ptr<Ty1>& _Left,
        const shared_ptr<Ty2>& _Right
   );

Paramètres

_Left
Un des objets dont l'inégalité doit être testée.
_Right
Un des objets dont l'inégalité doit être testée.
Ty1
Le type contrôlé par le pointeur partagé gauche.
Ty2
Le type contrôlé par le pointeur partagé droit.

Valeur de retour

vrai si les objets ne sont pas égaux ; faux si les objets sont égaux.

Notes

Le premier modèle d'opérateur retourne false. (Tous les allocateurs par défaut sont égaux.)

Les deuxième et troisième opérateurs de modèle retournent !(_Left == _Right).

Exemple

// memory_op_me.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

int main( ) 
{
   allocator<double> Alloc;
   vector <char>:: allocator_type v1Alloc;

   if ( Alloc != v1Alloc )
      cout << "The allocator objects Alloc & v1Alloc not are equal."
           << endl;
   else
      cout << "The allocator objects Alloc & v1Alloc are equal."
           << endl;
}

// std_tr1__memory__operator_ne.cpp 
// compile with: /EHsc 
#include <memory> 
#include <iostream> 
 
int main() 
    { 
    std::shared_ptr<int> sp0(new int(0)); 
    std::shared_ptr<int> sp1(new int(0)); 
 
    std::cout << "sp0 != sp0 == " << std::boolalpha 
        << (sp0 != sp0) << std::endl; 
    std::cout << "sp0 != sp1 == " << std::boolalpha 
        << (sp0 != sp1) << std::endl; 
 
    return (0); 
    }