Partager via

<memory>, opérateurs

  • Article

!=, opérateur

Teste l'inégalité entre des objets.

template <class Type, class Other>
bool operator!=(
    const allocator<Type>& left,
    const allocator<Other>& right) throw();

template <class T, class Del1, class U, class Del2>
bool operator!=(
    const unique_ptr<T, Del1>& left,
    const unique_ptr<U&, Del2>& right);

template <class Ty1, class Ty2>
bool operator!=(
    const shared_ptr<Ty1>& left,
    const shared_ptr<Ty2>& right);

Paramètres

left
L'un des objets dont l'inégalité doit être testée.

right
L'un des objets dont l'inégalité doit être testée.

Ty1
Type contrôlé par le pointeur partagé de gauche.

Ty2
Type contrôlé par le pointeur partagé de droite.

Valeur de retour

true si les objets ne sont pas égaux ; false si les objets sont égaux.

Notes

Le premier opérateur de modèle 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

Le premier exemple de code montre les résultats de la comparaison d’objets allocator.

// 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;
}

The allocator objects Alloc & v1Alloc are equal.

L’exemple de code suivant compare les pointeurs partagés aux objets alloués :

// std__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);
    }

sp0 != sp0 == false
sp0 != sp1 == true

operator==

Teste l'égalité entre des objets.

template <class Type, class Other>
bool operator==(
    const allocator<Type>& left,
    const allocator<Other>& right) throw();

template <class Ty1, class Del1, class Ty2, class Del2>
bool operator==(
    const unique_ptr<Ty1, Del1>& left,
    const unique_ptr<Ty2, Del2>& right);

template <class Ty1, class Ty2>
bool operator==(
    const shared_ptr<Ty1>& left;,
    const shared_ptr<Ty2>& right);

Paramètres

left
L'un des objets dont l'égalité doit être testée.

right
L'un des objets dont l'égalité doit être testée.

Ty1
Type contrôlé par le pointeur partagé de gauche.

Ty2
Type contrôlé par le pointeur partagé de droite.

Valeur de retour

true si les objets sont égaux, false si les objets ne sont pas égaux.

Notes

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

Les deuxième et troisième opérateurs de modèle retournent left.get() == right.get().

Exemple

Le premier exemple de code montre les résultats de la comparaison des objets allocator construits de différentes manières.

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

using namespace std;

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

   allocator<char> cAlloc(Alloc);
   allocator<int> cv1Alloc(v1Alloc);

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

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

The allocator objects cv1Alloc & v1Alloc are equal.
The allocator objects cAlloc & Alloc are equal.

L’exemple de code suivant compare les pointeurs partagés aux objets alloués :

// std__memory__operator_eq.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);
    }

sp0 == sp0 == true
sp0 == sp1 == false

operator>=

Teste si un objet est supérieur ou égal à un second objet.

template <class T, class Del1, class U, class Del2>
bool operator>=(
    const unique_ptr<T, Del1>& left,
    const unique_ptr<U, Del2>& right);

template <class Ty1, class Ty2>
bool operator>=(
    const shared_ptr<Ty1>& left,
    const shared_ptr<Ty2>& right);

Paramètres

left
L'un des objets à comparer.

right
L'un des objets à comparer.

Ty1
Type contrôlé par le pointeur partagé de gauche.

Ty2
Type contrôlé par le pointeur partagé de droite.

Notes

Les opérateurs de modèle retournent left.get() >= right.get().

operator<

Teste si un objet est inférieur à un second objet.

template <class T, class Del1, class U, class Del2>
bool operator<(
    const unique_ptr<T, Del1>& left,
    const unique_ptr<U&, Del2>& right);

template <class Ty1, class Ty2>
bool operator<(
    const shared_ptr<Ty1>& left,
    const shared_ptr<Ty2>& right);

Paramètres

left
L'un des objets à comparer.

right
L'un des objets à comparer.

Ty1
Type contrôlé par le pointeur de gauche.

Ty2
Type contrôlé par le pointeur de droite.

operator<=

Teste si un objet est inférieur ou égal à un second objet.

template <class T, class Del1, class U, class Del2>
bool operator<=(
    const unique_ptr<T, Del1>& left,
    const unique_ptr<U&, Del2>& right);

template <class Ty1, class Ty2>
bool operator<=(
    const shared_ptr<Ty1>& left,
    const shared_ptr<Ty2>& right);

Paramètres

left
L'un des objets à comparer.

right
L'un des objets à comparer.

Ty1
Type contrôlé par le pointeur partagé de gauche.

Ty2
Type contrôlé par le pointeur partagé de droite.

Notes

Les opérateurs de modèle retournent left.get() <= right.get().

operator>

Teste si un objet est supérieur à un second objet.

template <class Ty1, class Del1, class Ty2, class Del2>
bool operator>(
    const unique_ptr<Ty1, Del1>& left,
    const unique_ptr<Ty2&, Del2gt;& right);

template <class Ty1, class Ty2>
bool operator>(
    const shared_ptr<Ty1>& left,
    const shared_ptr<Ty2>& right);

Paramètres

left
L'un des objets à comparer.

right
L'un des objets à comparer.

Ty1
Type contrôlé par le pointeur partagé de gauche.

Ty2
Type contrôlé par le pointeur partagé de droite.

operator<<

Écrit le pointeur partagé dans le flux.

template <class Elem, class Tr, class Ty>
std::basic_ostream<Elem, Tr>& operator<<(std::basic_ostream<Elem, Tr>& out,
    shared_ptr<Ty>& sp);

Paramètres

Elem
Type de l’élément de flux.

Tr
Type de caractéristiques d’élément de flux.

Ty
Type contrôlé par le pointeur partagé.

out
Flux de sortie.

Sp
Pointeur partagé.

Notes

La fonction de modèle retourne out << sp.get().

Exemple

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

int main()
    {
    std::shared_ptr<int> sp0(new int(5));

    std::cout << "sp0 == " << sp0 << " (varies)" << std::endl;

    return (0);
    }

sp0 == 3f3040 (varies)