Partilhar via

Operadores <memory>

  • Artigo

operator!=

Testa a desigualdade entre objetos.

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

Parâmetros

esquerda
Um dos objetos a ser testado quanto à desigualdade.

direita
Um dos objetos a ser testado quanto à desigualdade.

Ty1
O tipo controlado pelo ponteiro compartilhado esquerdo.

Ty2
O tipo controlado pelo ponteiro compartilhado direito.

Valor de retorno

true se os objetos não forem iguais, false se os objetos forem iguais.

Comentários

O primeiro operador de modelo retorna false. (Todos os alocadores padrão são iguais.)

O segundo e o terceiro operadores de modelo retornam !(left == right).

Exemplo

O primeiro exemplo de código mostra os resultados da comparação de objetos de alocador.

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

O próximo exemplo de código compara ponteiros compartilhados com objetos alocados:

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

Testa a igualdade entre objetos.

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

Parâmetros

esquerda
Um dos objetos a ser testado quanto à igualdade.

direita
Um dos objetos a ser testado quanto à igualdade.

Ty1
O tipo controlado pelo ponteiro compartilhado esquerdo.

Ty2
O tipo controlado pelo ponteiro compartilhado direito.

Valor de retorno

true se os objetos forem iguais, false se os objetos não forem iguais.

Comentários

O primeiro operador de modelo retorna true. (Todos os alocadores padrão são iguais.)

O segundo e o terceiro operadores de modelo retornam left.get() == right.get().

Exemplo

O primeiro exemplo de código mostra os resultados da comparação de objetos de alocador construídos de maneiras diferentes.

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

O próximo exemplo de código compara ponteiros compartilhados com objetos alocados:

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

Testa um objeto que é maior que ou igual a um segundo objeto.

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

Parâmetros

esquerda
Um dos objetos a ser comparado.

direita
Um dos objetos a ser comparado.

Ty1
O tipo controlado pelo ponteiro compartilhado esquerdo.

Ty2
O tipo controlado pelo ponteiro compartilhado direito.

Comentários

O operador de modelo retorna left.get() >= right.get().

operator<

Testa um objeto que é menor que um segundo objeto.

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

Parâmetros

esquerda
Um dos objetos a ser comparado.

direita
Um dos objetos a ser comparado.

Ty1
O tipo controlado pelo ponteiro esquerdo.

Ty2
O tipo controlado pelo ponteiro direito.

operator<=

Testa um objeto que é maior ou igual a um segundo objeto de uma classe especificada.

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

Parâmetros

esquerda
Um dos objetos a ser comparado.

direita
Um dos objetos a ser comparado.

Ty1
O tipo controlado pelo ponteiro compartilhado esquerdo.

Ty2
O tipo controlado pelo ponteiro compartilhado direito.

Comentários

O operador de modelo retorna left.get() <= right.get()

operator>

Testa um objeto que é maior que um segundo objeto.

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

Parâmetros

esquerda
Um dos objetos a ser comparado.

direita
Um dos objetos a ser comparado.

Ty1
O tipo controlado pelo ponteiro compartilhado esquerdo.

Ty2
O tipo controlado pelo ponteiro compartilhado direito.

operator<<

Grava o ponteiro compartilhado no fluxo.

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

Parâmetros

Elem
O tipo do elemento de fluxo.

Tr
O tipo de características do elemento de fluxo.

Ty
O tipo controlado pelo ponteiro compartilhado.

out
O fluxo de saída.

Sp
O ponteiro compartilhado.

Comentários

A função do modelo retorna out << sp.get().

Exemplo

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