《C++标准程序库》 第4章 通用工具

第1～3章 略

 

std::pair 是一个 struct ，定义于 bits/stl_pair.h 文件中，被包含进 <utility> 头文件中。

std::make_pair(42,'@')  //相当于 std::pair<int,char> (42,'@')

std::pair<int,int> p = std::make_pair(42,3.3); 　　//42,3

任何函数需要返回两个值，必须使用 pair; 标准程序库中 map 和 multimap 容器的元素型别也是 pair。

 

std::auto_ptr<int> p(new int(3));　　定义于 backward/auto_ptr.h 文件中，被包含进 <memory>头文件中。

auto_ptr 要求一个对象只有一个拥有者，绝对不应该出现多个 auto_ptr 拥有一个对象的情况。如：

std::auto_ptr<int> p1(p);　　

std::cout<<*p1<<std::endl;  //OK

std::cout<<*p<<std::endl;   //段错误

auto_ptr 的 copy 构造函数 和 assignment 操作符会将对象拥有权交出去。

程序员需要自己来保证那个”失去了所有权、只剩下一个 null 指针“的原 auto_ptr 不会再次被进行提领动作。

将 auto_ptr 作为函数参数或函数返回值，一定要特别注意所有权问题。比如：

std::auto_ptr<int> p(new int(42));

fun(p);　　　　//p的所有权已经转交出去

*p = 18;　　//error   

不要试图使用 pass by reference 方式来传递 auto_ptr ，因为你根本无法预知拥有权是否被转交。

如果用 const 来修饰一个 auto_ptr ,并非意味着不能更改它拥有的对象，而是意味着你不能更改 auto_ptr 的所有权。

auto_ptr 的注意点：

1、auto_ptr 之间不能共享拥有权，一个 auto_ptr 不能指向另一个 auto_ptr 所拥有的对象。

2、并不存在针对 array 而设计的 auto_ptr，因为 auto_ptr 是通过 delete 而不是 delete [] 来释放对象的。

3、它的通用性不强，它不是引用计数型指针。

4、auto_ptr 不满足 STL 容器对元素的要求，比如拷贝和赋值动作。

C++11标准已经废弃了 auto_ptr ，取而代之的是  unique_ptr。

 

数值极限（Numeric Limits）是与平台有关的，C++标准库通过 template numeric_limits 提供这些极值，取代传统C语言所采用的预处理器常数。前者定义于头文件 <limits> 中，后者整数常数定义于 <climits> 和 <limits.h>，浮点常数定义于 <cfloat> 和 <float.h> 中，推荐使用前者，有更好的型别安全性。

numeric_limits 中提供了通用性的 template 和特化版本，如：

template <class T> class numeric_limits {...};

template <> class numeric_limits<int> {...};

使用示例如下：

#include <iostream>

#include <limits>

#include <string>



int main()

{

    std::cout<<std::numeric_limits<int>::is_specialized<<std::endl; //是否有极值

    std::cout<<std::numeric_limits<int>::max()<<std::endl;

    std::cout<<std::numeric_limits<int>::min()<<std::endl;

    std::cout<<std::numeric_limits<std::string>::is_specialized<<std::endl;

    std::cout<<std::numeric_limits<std::string>::max()<<std::endl;  //Error!

}

 

 在两个值之间挑选较大值和较小值的辅助函数，定义于 <bits/stl_algobase.h> ，被包含进 <algorithm> 头文件。源码如下：

template<typename _Tp> 

inline const _Tp& 

max(const _Tp& __a, const _Tp& __b) 

{

  // concept requirements

  __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)

  //return  __a < __b ? __b : __a;

  if (__a < __b) 

return __b; 

  return __a; 

}



template<typename _Tp, typename _Compare>

inline const _Tp&

max(const _Tp& __a, const _Tp& __b, _Compare __comp)

{

  //return __comp(__a, __b) ? __b : __a;

  if (__comp(__a, __b))

return __b;

  return __a;

}

min 函数实现类似，略。使用示例如下：

#include <iostream>

#include <algorithm>



struct User

{

    User(int _id):id(_id){}

    bool operator<(const User& user2) const　　//这里只需要实现 operator< 即可

    {   

        return id < user2.id;

    }   

    int id; 

};



bool compareUser(User user1,User user2)

{

    return user1.id < user2.id;　　//要返回 第一个参数 < 第二个参数的 bool 值

}



int main()

{

    User user1(3),user2(2);

    std::cout<<std::max(user1,user2).id<<std::endl;

    std::cout<<std::max(user1,user2,compareUser).id<<std::endl;

}

 

有四个比较操作符的 template functions ，分别定义了 !=, >, <=, >= ，它们都是利用操作符 == 和 < 完成的，定义于头文件 <utility>，位于命名空间 std::rel_ops;

namespace std

{

    namespace rel_ops

    {

        template <class T>

        inline bool operator!=(const T& x, const T& y)

        {

            return !(x == y);

        }



        template <class T>

        inline bool operator>(const T& x, const T& y)

        {

            return x < y;

        }



        template <class T>

        inline bool operator<=(const T& x, const T& y)

        {

            return !(y < x);

        }



        template <class T>

        inline bool operator>=(const T& x, const T& y)

        {

            return !(x < y);

        }

    }

}

只需要定义 < 和 == 操作符，然后 using namespace std::rel_ops; 上述四个操作符就自动获得了定义。

#include <iostream>

#include <utility>



struct User

{

    User(int _id):id(_id){}

    bool operator==(const User& user) const

    {   

        return id == user.id;

    }   

    bool operator<(const User& user) const

    {   

        return id < user.id;

    }   

    int id; 

};



int main()

{

    using namespace std::rel_ops;

    User user1(3),user2(4);

    std::cout<<(user1>user2)<<std::endl;

}