Condividi tramite

Operatori <memory>

  • Articolo

operator!=

Verifica la disuguaglianza tra oggetti.

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);

Parametri

left
Uno degli oggetti di cui verificare la disuguaglianza.

right
Uno degli oggetti di cui verificare la disuguaglianza.

Ty1
Tipo controllato dal puntatore condiviso sinistro.

Ty2
Tipo controllato dal puntatore condiviso destro.

Valore restituito

true se gli oggetti non sono uguali; false se gli oggetti sono uguali.

Osservazioni:

Il primo operatore modello restituisce false Tutti gli allocatori predefiniti sono uguali.

Il secondo e il terzo operatore modello restituiscono !(left == right).

Esempio

Il primo esempio di codice mostra i risultati del confronto degli oggetti allocatore.

// 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.

Nell'esempio di codice seguente vengono confrontati i puntatori condivisi con gli oggetti allocati:

// 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==

Verifica l'uguaglianza tra oggetti.

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);

Parametri

left
Uno degli oggetti di cui verificare l'uguaglianza.

right
Uno degli oggetti di cui verificare l'uguaglianza.

Ty1
Tipo controllato dal puntatore condiviso sinistro.

Ty2
Tipo controllato dal puntatore condiviso destro.

Valore restituito

true se gli oggetti sono uguali, false se gli oggetti non sono uguali.

Osservazioni:

Il primo operatore modello restituisce true Tutti gli allocatori predefiniti sono uguali.

Il secondo e il terzo operatore modello restituiscono left.get() == right.get().

Esempio

Il primo esempio di codice mostra i risultati del confronto degli oggetti allocatore costruiti in modi diversi.

// 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.

Nell'esempio di codice seguente vengono confrontati i puntatori condivisi con gli oggetti allocati:

// 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>=

Verifica se un oggetto è maggiore o uguale a un secondo oggetto.

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);

Parametri

left
Uno degli oggetti da confrontare.

right
Uno degli oggetti da confrontare.

Ty1
Tipo controllato dal puntatore condiviso sinistro.

Ty2
Tipo controllato dal puntatore condiviso destro.

Osservazioni:

Gli operatori di modello restituiscono left.get() >= right.get().

operator<

Verifica se un oggetto è minore di un secondo oggetto.

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);

Parametri

left
Uno degli oggetti da confrontare.

right
Uno degli oggetti da confrontare.

Ty1
Tipo controllato dal puntatore sinistro.

Ty2
Tipo controllato dal puntatore destro.

operator<=

Verifica se un oggetto è minore o uguale a un secondo oggetto.

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);

Parametri

left
Uno degli oggetti da confrontare.

right
Uno degli oggetti da confrontare.

Ty1
Tipo controllato dal puntatore condiviso sinistro.

Ty2
Tipo controllato dal puntatore condiviso destro.

Osservazioni:

Gli operatori di modello restituiscono left.get() <= right.get()

operator>

Verifica se un oggetto è maggiore di un secondo oggetto.

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);

Parametri

left
Uno degli oggetti da confrontare.

right
Uno degli oggetti da confrontare.

Ty1
Tipo controllato dal puntatore condiviso sinistro.

Ty2
Tipo controllato dal puntatore condiviso destro.

operator<<

Scrive il puntatore condiviso nel flusso.

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

Parametri

Elem
Tipo dell'elemento flusso.

Tr
Tipo dei tratti dell'elemento flusso.

Ty
Tipo controllato dal puntatore condiviso.

out
Flusso di output.

Sp
Puntatore condiviso.

Osservazioni:

La funzione modello restituisce out << sp.get().

Esempio

// 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)