<memory> betriebspersonal

  • Artikel

operator!=

Prüft auf Ungleichheit zwischen Objekten.

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
Eines der Objekte, die auf Ungleichheit geprüft werden sollen.

right
Eines der Objekte, die auf Ungleichheit geprüft werden sollen.

Ty1
Der vom linken gemeinsamen Zeiger gesteuerte Typ.

Ty2
Der vom rechten gemeinsamen Zeiger gesteuerte Typ.

Rückgabewert

true wenn die Objekte nicht gleich sind; false wenn Objekte gleich sind.

Hinweise

Der erste Vorlagenoperator gibt "false" zurück. (Alle standardmäßigen allocator-Objekte sind gleich.)

Der zweite und der dritte Vorlagenoperator geben !(left == right) zurück.

Beispiel

Das erste Codebeispiel zeigt die Ergebnisse des Vergleichens von Allocator-Objekten.

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

Im nächsten Codebeispiel werden freigegebene Zeiger mit zugeordneten Objekten verglichen:

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

Prüft auf Gleichheit zwischen Objekten.

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
Eines der Objekte, die auf Gleichheit geprüft werden sollen.

right
Eines der Objekte, die auf Gleichheit geprüft werden sollen.

Ty1
Der vom linken gemeinsamen Zeiger gesteuerte Typ.

Ty2
Der vom rechten gemeinsamen Zeiger gesteuerte Typ.

Rückgabewert

true, wenn die Objekte gleich sind, false, wenn die Objekte nicht gleich sind.

Hinweise

Der erste Vorlagenoperator gibt "true" zurück. (Alle standardmäßigen allocator-Objekte sind gleich.)

Der zweite und der dritte Vorlagenoperator geben left.get() == right.get() zurück.

Beispiel

Das erste Codebeispiel zeigt die Ergebnisse des Vergleichs von Allocatorobjekten, die auf unterschiedliche Weise erstellt wurden.

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

Im nächsten Codebeispiel werden freigegebene Zeiger mit zugeordneten Objekten verglichen:

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

Testet, ob ein Objekt größer gleich einem zweiten Objekt ist.

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
Eines der zu vergleichenden Objekte.

right
Eines der zu vergleichenden Objekte.

Ty1
Der vom linken gemeinsamen Zeiger gesteuerte Typ.

Ty2
Der vom rechten gemeinsamen Zeiger gesteuerte Typ.

Hinweise

Die Vorlagenoperatoren geben left.get() >= right.get() zurück.

operator<

Testet, ob ein Objekt kleiner als ein zweites Objekt ist.

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
Eines der zu vergleichenden Objekte.

right
Eines der zu vergleichenden Objekte.

Ty1
Der vom linken Zeiger gesteuerte Typ.

Ty2
Der vom rechten Zeiger gesteuerte Typ.

operator<=

Testet, ob ein Objekt kleiner gleich einem zweiten Objekt ist.

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
Eines der zu vergleichenden Objekte.

right
Eines der zu vergleichenden Objekte.

Ty1
Der vom linken gemeinsamen Zeiger gesteuerte Typ.

Ty2
Der vom rechten gemeinsamen Zeiger gesteuerte Typ.

Hinweise

Die Vorlagenoperatoren geben left.get() <= right.get() zurück

operator>

Testet, ob ein Objekt größer als ein zweites Objekt ist.

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

Parameter

left
Eines der zu vergleichenden Objekte.

right
Eines der zu vergleichenden Objekte.

Ty1
Der vom linken gemeinsamen Zeiger gesteuerte Typ.

Ty2
Der vom rechten gemeinsamen Zeiger gesteuerte Typ.

operator<<

Schreibt den freigegebenen Zeiger auf den Stream.

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
Der Typ des Streamelements.

Tr
Der Typ des Streamelements.

Ty
Der vom freigegebenen Zeiger gesteuerte Typ.

out
Der Ausgabestream.

sp
Der freigegebene Zeiger.

Hinweise

Diese Vorlagenfunktion gibt out << sp.get() zurück.

Beispiel

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