通过

<memory> 运算符

  • 项目

operator!=

测试各对象之间是否不相等。

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

参数

left
要测试不相等的对象之一。

right
要测试不相等的对象之一。

Ty1
由左侧共享指针控制的类型。

Ty2
由右侧共享指针控制的类型。

返回值

如果对象不相等，则为 true，如果对象相等，则为 false。

备注

第一个模板运算符返回 false。 （所有默认分配器都相等。）

第二个和第三个模板运算符返回 !(left == right)。

示例

第一个代码示例显示比较分配器对象的结果。

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

下一个代码示例比较已分配对象的共享指针：

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

测试两个对象是否相等。

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

参数

left
要测试是否相等的其中一个对象。

right
要测试是否相等的其中一个对象。

Ty1
由左侧共享指针控制的类型。

Ty2
由右侧共享指针控制的类型。

返回值

如果对象相等，则为 true，如果对象不相等，则为 false。

备注

第一个模板运算符返回 true。 （所有默认分配器都相等。）

第二个和第三个模板运算符返回 left.get() == right.get()。

示例

第一个代码示例显示比较以不同方式构造的分配器对象的结果。

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

下一个代码示例比较已分配对象的共享指针：

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

测试一个对象是否大于或等于另一个对象。

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

参数

left
要比较的对象之一。

right
要比较的对象之一。

Ty1
由左侧共享指针控制的类型。

Ty2
由右侧共享指针控制的类型。

备注

模板运算符返回 left.get() >= right.get()。

operator<

测试某一对象是否小于另一对象。

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

参数

left
要比较的对象之一。

right
要比较的对象之一。

Ty1
由左侧指针控制的类型。

Ty2
由右侧指针控制的类型。

operator<=

测试某一对象是否小于或等于另一个对象。

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

参数

left
要比较的对象之一。

right
要比较的对象之一。

Ty1
由左侧共享指针控制的类型。

Ty2
由右侧共享指针控制的类型。

备注

模板运算符返回 left.get() <= right.get()

operator>

测试一个对象是否大于或等于第二个对象。

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

参数

left
要比较的对象之一。

right
要比较的对象之一。

Ty1
由左侧共享指针控制的类型。

Ty2
由右侧共享指针控制的类型。

operator<<

将共享指针写入该流。

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

参数

Elem
流元素的类型。

Tr
流元素特征的类型。

Ty
由共享指针控制的类型。

out
输出流。

sp
共享的指针。

备注

此模板函数返回 out << sp.get()。

示例

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