Aracılığıyla paylaş

<memory> işleçleri

  • Makale

operator!=

Nesneler arasında eşitsizlik olup olmadığını test eder.

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

Parametreler

Sol
Eşitsizlik için test edilecek nesnelerden biri.

Sağ
Eşitsizlik için test edilecek nesnelerden biri.

Ty1
Sol paylaşılan işaretçi tarafından denetlenen tür.

Ty2
Doğru paylaşılan işaretçi tarafından denetlenen tür.

Dönüş Değeri

true nesneler eşit değilse; false nesneler eşitse.

Açıklamalar

İlk şablon işleci false döndürür. (Tüm varsayılan ayırıcılar eşittir.)

İkinci ve üçüncü şablon işleçleri döndürür !(left == right).

Örnek

İlk kod örneği ayırıcı nesneleri karşılaştırmanın sonuçlarını gösterir.

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

Sonraki kod örneği, paylaşılan işaretçileri ayrılmış nesnelerle karşılaştırır:

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

Nesneler arasındaki eşitliği sınar.

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

Parametreler

Sol
Eşitlik için test edilecek nesnelerden biri.

Sağ
Eşitlik için test edilecek nesnelerden biri.

Ty1
Sol paylaşılan işaretçi tarafından denetlenen tür.

Ty2
Doğru paylaşılan işaretçi tarafından denetlenen tür.

Dönüş Değeri

true nesneler eşitse, false nesneler eşit değilse.

Açıklamalar

İlk şablon işleci true değerini döndürür. (Tüm varsayılan ayırıcılar eşittir.)

İkinci ve üçüncü şablon işleçleri döndürür left.get() == right.get().

Örnek

İlk kod örneği, farklı şekillerde inşa edilen ayırıcı nesneleri karşılaştırmanın sonuçlarını gösterir.

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

Sonraki kod örneği, paylaşılan işaretçileri ayrılmış nesnelerle karşılaştırır:

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

Bir nesnenin ikinci bir nesneden büyük veya buna eşit olduğunu sınar.

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

Parametreler

Sol
Karşılaştırılacak nesnelerden biri.

Sağ
Karşılaştırılacak nesnelerden biri.

Ty1
Sol paylaşılan işaretçi tarafından denetlenen tür.

Ty2
Doğru paylaşılan işaretçi tarafından denetlenen tür.

Açıklamalar

Şablon işleçleri döndürür left.get() >= right.get().

operator<

Bir nesnenin ikinci nesneden küçük olduğunu sınar.

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

Parametreler

Sol
Karşılaştırılacak nesnelerden biri.

Sağ
Karşılaştırılacak nesnelerden biri.

Ty1
Sol işaretçi tarafından denetlenen tür.

Ty2
Doğru işaretçi tarafından denetlenen tür.

operator<=

Bir nesnenin ikinci bir nesneden küçük veya buna eşit olduğunu sınar.

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

Parametreler

Sol
Karşılaştırılacak nesnelerden biri.

Sağ
Karşılaştırılacak nesnelerden biri.

Ty1
Sol paylaşılan işaretçi tarafından denetlenen tür.

Ty2
Doğru paylaşılan işaretçi tarafından denetlenen tür.

Açıklamalar

Şablon işleçleri iade left.get() <= right.get()

operator>

Bir nesnenin ikinci bir nesneden büyük olduğunu sınar.

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

Parametreler

Sol
Karşılaştırılacak nesnelerden biri.

Sağ
Karşılaştırılacak nesnelerden biri.

Ty1
Sol paylaşılan işaretçi tarafından denetlenen tür.

Ty2
Doğru paylaşılan işaretçi tarafından denetlenen tür.

operator<<

Paylaşılan işaretçiyi akışa yazar.

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

Parametreler

Elem
Akış öğesinin türü.

Tr
Akış öğesi özelliklerinin türü.

Ty
Paylaşılan işaretçi tarafından denetlenen tür.

out
Çıkış akışı.

Sp
Paylaşılan işaretçi.

Açıklamalar

Şablon işlevi döndürür out << sp.get().

Örnek

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