Compartir vía

<memory> Operadores

  • Artículo

operator!=

Comprueba la desigualdad 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

left
Uno de los objetos cuya desigualdad se va a comprobar.

right
Uno de los objetos cuya desigualdad se va a comprobar.

Ty1
Tipo controlado por el puntero compartido izquierdo.

Ty2
Tipo controlado por el puntero compartido derecho.

Valor devuelto

true si los objetos no son iguales; false si lo son.

Comentarios

El primer operador de la plantilla devuelve false. (Todos los asignadores predeterminados son iguales).

El segundo y el tercer operador de la plantilla devuelven !(left == right).

Ejemplo

En el primer ejemplo del código se muestran los resultados de la comparación de objetos del asignador.

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

En el ejemplo del código siguiente se comparan los punteros compartidos con los objetos asignados:

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

Comprueba la igualdad 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

left
Uno de los objetos cuya igualdad se va a comprobar.

right
Uno de los objetos cuya igualdad se va a comprobar.

Ty1
Tipo controlado por el puntero compartido izquierdo.

Ty2
Tipo controlado por el puntero compartido derecho.

Valor devuelto

true si los objetos son iguales, false si no lo son.

Comentarios

El primer operador de la plantilla devuelve true. (Todos los asignadores predeterminados son iguales).

El segundo y el tercer operador de la plantilla devuelven left.get() == right.get().

Ejemplo

En el primer ejemplo del código se muestran los resultados de la comparación de los objetos del asignador construidos de maneras 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.

En el ejemplo del código siguiente se comparan los punteros compartidos con los objetos asignados:

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

Comprueba si un objeto es mayor o igual que un 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

left
Uno de los objetos que se va a comparar.

right
Uno de los objetos que se va a comparar.

Ty1
Tipo controlado por el puntero compartido izquierdo.

Ty2
Tipo controlado por el puntero compartido derecho.

Comentarios

Los operadores de plantilla devuelven left.get() >= right.get().

operator<

Comprueba si un objeto es menor que un 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

left
Uno de los objetos que se va a comparar.

right
Uno de los objetos que se va a comparar.

Ty1
Tipo controlado por el puntero izquierdo.

Ty2
Tipo controlado por el puntero derecho.

operator<=

Comprueba si un objeto es menor o igual que un 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

left
Uno de los objetos que se va a comparar.

right
Uno de los objetos que se va a comparar.

Ty1
Tipo controlado por el puntero compartido izquierdo.

Ty2
Tipo controlado por el puntero compartido derecho.

Comentarios

Los operadores de plantilla devuelven left.get() <= right.get()

operator>

Comprueba si un objeto es mayor que un 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

left
Uno de los objetos que se va a comparar.

right
Uno de los objetos que se va a comparar.

Ty1
Tipo controlado por el puntero compartido izquierdo.

Ty2
Tipo controlado por el puntero compartido derecho.

operator<<

Escribe el puntero compartido en la secuencia.

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
El tipo del elemento de secuencia.

Tr
El tipo de rasgos del elemento de secuencia.

Ty
Tipo controlado por el puntero compartido.

out
Secuencia de salida.

Sp
El puntero compartido.

Comentarios

La función de plantilla devuelve out << sp.get().

Ejemplo

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