Sdílet prostřednictvím

<memory> – operátory

  • Článek

operator!=

Testuje nerovnost mezi objekty.

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

Vlevo
Jeden z objektů, které se mají testovat na nerovnost.

Vpravo
Jeden z objektů, které se mají testovat na nerovnost.

Ty1
Typ řízený levým sdíleným ukazatelem.

Ty2
Typ řízený správným sdíleným ukazatelem.

Návratová hodnota

true pokud objekty nejsou stejné; false pokud jsou objekty stejné.

Poznámky

První operátor šablony vrátí hodnotu false. (Všechny výchozí alokátory jsou stejné.)

Operátory druhé a třetí šablony vrátí !(left == right).

Příklad

První příklad kódu ukazuje výsledky porovnání objektů alokátoru.

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

Následující příklad kódu porovnává sdílené ukazatele na přidělené objekty:

// 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 rovnost mezi objekty.

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

Vlevo
Jeden z objektů, které se mají testovat na rovnost.

Vpravo
Jeden z objektů, které se mají testovat na rovnost.

Ty1
Typ řízený levým sdíleným ukazatelem.

Ty2
Typ řízený správným sdíleným ukazatelem.

Návratová hodnota

true pokud jsou objekty stejné, false pokud objekty nejsou stejné.

Poznámky

První operátor šablony vrátí hodnotu true. (Všechny výchozí alokátory jsou stejné.)

Operátory druhé a třetí šablony vrátí left.get() == right.get().

Příklad

První příklad kódu ukazuje výsledky porovnání objektů alokátoru vytvořených různými způsoby.

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

Následující příklad kódu porovnává sdílené ukazatele na přidělené objekty:

// 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 jeden objekt, který je větší nebo roven druhému objektu.

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

Vlevo
Jeden zobjektůch

Vpravo
Jeden zobjektůch

Ty1
Typ řízený levým sdíleným ukazatelem.

Ty2
Typ řízený správným sdíleným ukazatelem.

Poznámky

Operátory šablony vrátí left.get() >= right.get().

operator<

Testy pro jeden objekt jsou menší než druhý objekt.

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

Vlevo
Jeden zobjektůch

Vpravo
Jeden zobjektůch

Ty1
Typ řízený levým ukazatelem.

Ty2
Typ řízený pravým ukazatelem.

operator<=

Testuje jeden objekt, který je menší nebo roven druhému objektu.

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

Vlevo
Jeden zobjektůch

Vpravo
Jeden zobjektůch

Ty1
Typ řízený levým sdíleným ukazatelem.

Ty2
Typ řízený správným sdíleným ukazatelem.

Poznámky

Operátory šablony vrací left.get() <= right.get()

operator>

Testy pro jeden objekt jsou větší než druhý objekt.

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

Vlevo
Jeden zobjektůch

Vpravo
Jeden zobjektůch

Ty1
Typ řízený levým sdíleným ukazatelem.

Ty2
Typ řízený správným sdíleným ukazatelem.

operator<<

Zapíše sdílený ukazatel do datového proudu.

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

Tr
Typ vlastnosti elementu streamu.

Ty
Typ řízený sdíleným ukazatelem.

out
Výstupní datový proud

Sp
Sdílený ukazatel.

Poznámky

Funkce šablony vrátí out << sp.get().

Příklad

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