<memory> Operatoren
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)
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für