Freigeben über


operator== (<memory>)

Tests für 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 Gleichheit zu testenden Objekte.

  • _Right
    Eines der Gleichheit zu testenden Objekte.

  • Ty1
    Der Typ gesteuert vom linken freigegebener Zeiger.

  • Ty2
    Der Typ gesteuert vom rechten freigegebener Zeiger.

Rückgabewert

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

Hinweise

Die ersten Vorlagenoperatorrückgaben true. (Alle Standardzuweisungen sind gleich).

Die zweite und dritte Vorlagenoperatoren geben _Left.get() == _Right.get() zurück.

Beispiel

// 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;
}
  

 

// std_tr1__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); 
    } 
 
  

Anforderungen

Header: <memory>

Namespace: std

Siehe auch

Referenz

auto_ptr-Klasse

shared_ptr-Klasse

unique_ptr-Klasse

Weitere Ressourcen

auto_ptr Member

shared_ptr::operator==

unique_ptr Member