Bagikan melalui

Operator <memory>

operator!=

Pengujian untuk ketidaksamaan antar objek.

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

Parameter

left
Salah satu objek yang akan diuji untuk ketidaksamaan.

right
Salah satu objek yang akan diuji untuk ketidaksamaan.

Ty1
Jenis yang dikontrol oleh penunjuk bersama kiri.

Ty2
Jenis yang dikontrol oleh penunjuk bersama yang tepat.

Tampilkan Nilai

true jika objek tidak sama; false jika objek sama.

Keterangan

Operator templat pertama mengembalikan false. (Semua alokator default sama.)

Operator templat kedua dan ketiga mengembalikan !(left == right).

Contoh

Contoh kode pertama menunjukkan hasil membandingkan objek alokator.

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

Contoh kode berikutnya membandingkan pointer bersama dengan objek yang dialokasikan:

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

Pengujian untuk kesetaraan antar objek.

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

Parameter

left
Salah satu objek yang akan diuji untuk kesetaraan.

right
Salah satu objek yang akan diuji untuk kesetaraan.

Ty1
Jenis yang dikontrol oleh penunjuk bersama kiri.

Ty2
Jenis yang dikontrol oleh penunjuk bersama yang tepat.

Tampilkan Nilai

true jika objek sama, false jika objek tidak sama.

Keterangan

Operator templat pertama mengembalikan true. (Semua alokator default sama.)

Operator templat kedua dan ketiga mengembalikan left.get() == right.get().

Contoh

Contoh kode pertama menunjukkan hasil membandingkan objek alokator yang dibangun dengan cara yang berbeda.

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

Contoh kode berikutnya membandingkan pointer bersama dengan objek yang dialokasikan:

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

Pengujian untuk satu objek lebih besar dari atau sama dengan objek kedua.

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

Parameter

left
Salah satu objek yang akan dibandingkan.

right
Salah satu objek yang akan dibandingkan.

Ty1
Jenis yang dikontrol oleh penunjuk bersama kiri.

Ty2
Jenis yang dikontrol oleh penunjuk bersama yang tepat.

Keterangan

Operator templat mengembalikan left.get() >= right.get().

operator<

Pengujian untuk satu objek kurang dari objek kedua.

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

Parameter

left
Salah satu objek yang akan dibandingkan.

right
Salah satu objek yang akan dibandingkan.

Ty1
Jenis yang dikontrol oleh penunjuk kiri.

Ty2
Jenis yang dikontrol oleh penunjuk kanan.

operator<=

Pengujian untuk satu objek kurang dari atau sama dengan objek kedua.

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

Parameter

left
Salah satu objek yang akan dibandingkan.

right
Salah satu objek yang akan dibandingkan.

Ty1
Jenis yang dikontrol oleh penunjuk bersama kiri.

Ty2
Jenis yang dikontrol oleh penunjuk bersama yang tepat.

Keterangan

Operator templat mengembalikan left.get() <= right.get()

operator>

Pengujian untuk satu objek lebih besar dari objek kedua.

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

Parameter

left
Salah satu objek yang akan dibandingkan.

right
Salah satu objek yang akan dibandingkan.

Ty1
Jenis yang dikontrol oleh penunjuk bersama kiri.

Ty2
Jenis yang dikontrol oleh penunjuk bersama yang tepat.

operator<<

Menulis pointer bersama ke aliran.

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

Parameter

Elem
Jenis elemen stream.

Tr
Jenis sifat elemen stream.

Ty
Jenis yang dikontrol oleh penunjuk bersama.

out
Aliran output.

Sp
Penunjuk bersama.

Keterangan

Fungsi templat mengembalikan out << sp.get().

Contoh

// 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)
  • Last updated on