Udostępnij za pośrednictwem

<memory>, operatory

  • Artykuł

operator!=

Testuje nierówność między obiektami.

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

Parametry

Lewy
Jeden z obiektów do przetestowania pod kątem nierówności.

Prawy
Jeden z obiektów do przetestowania pod kątem nierówności.

Ty1
Typ kontrolowany przez lewy wskaźnik udostępniony.

Ty2
Typ kontrolowany przez prawy wskaźnik udostępniony.

Wartość zwracana

true jeśli obiekty nie są równe; false jeśli obiekty są równe.

Uwagi

Pierwszy operator szablonu zwraca wartość false. (Wszystkie domyślne alokatory są równe).

Drugie i trzecie operatory szablonu zwracają wartość !(left == right).

Przykład

Pierwszy przykład kodu przedstawia wyniki porównywania obiektów alokatora.

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

Następny przykład kodu porównuje udostępnione wskaźniki z przydzielonymi obiektami:

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

Testuje równość między obiektami.

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

Parametry

Lewy
Jeden z obiektów do przetestowania pod kątem równości.

Prawy
Jeden z obiektów do przetestowania pod kątem równości.

Ty1
Typ kontrolowany przez lewy wskaźnik udostępniony.

Ty2
Typ kontrolowany przez prawy wskaźnik udostępniony.

Wartość zwracana

true jeśli obiekty są równe, false jeśli obiekty nie są równe.

Uwagi

Pierwszy operator szablonu zwraca wartość true. (Wszystkie domyślne alokatory są równe).

Drugie i trzecie operatory szablonu zwracają wartość left.get() == right.get().

Przykład

Pierwszy przykład kodu przedstawia wyniki porównywania obiektów alokatora skonstruowanych na różne sposoby.

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

Następny przykład kodu porównuje udostępnione wskaźniki z przydzielonymi obiektami:

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

Testuje, czy jeden obiekt jest większy niż lub równy drugiemu obiektowi.

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

Parametry

Lewy
Jeden z obiektów do porównania.

Prawy
Jeden z obiektów do porównania.

Ty1
Typ kontrolowany przez lewy wskaźnik udostępniony.

Ty2
Typ kontrolowany przez prawy wskaźnik udostępniony.

Uwagi

Operatory szablonu zwracają wartość left.get() >= right.get().

operator<

Testuje, czy jeden obiekt jest mniejszy niż drugi obiekt.

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

Parametry

Lewy
Jeden z obiektów do porównania.

Prawy
Jeden z obiektów do porównania.

Ty1
Typ kontrolowany przez wskaźnik po lewej stronie.

Ty2
Typ kontrolowany przez prawy wskaźnik.

operator<=

Testuje, czy jeden obiekt jest mniejszy niż lub równy drugiemu obiektowi.

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

Parametry

Lewy
Jeden z obiektów do porównania.

Prawy
Jeden z obiektów do porównania.

Ty1
Typ kontrolowany przez lewy wskaźnik udostępniony.

Ty2
Typ kontrolowany przez prawy wskaźnik udostępniony.

Uwagi

Operatory szablonu zwracają left.get() <= right.get()

operator>

Testuje, czy jeden obiekt jest większy niż drugi obiekt.

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

Parametry

Lewy
Jeden z obiektów do porównania.

Prawy
Jeden z obiektów do porównania.

Ty1
Typ kontrolowany przez lewy wskaźnik udostępniony.

Ty2
Typ kontrolowany przez prawy wskaźnik udostępniony.

operator<<

Zapisuje wskaźnik udostępniony do strumienia.

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

Parametry

Elem
Typ elementu strumienia.

Tr
Typ cech elementu strumienia.

Ty
Typ kontrolowany przez wskaźnik udostępniony.

out
Strumień danych wyjściowych.

Sp
Wskaźnik udostępniony.

Uwagi

Funkcja szablonu zwraca out << sp.get()wartość .

Przykład

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