了解utility

(1)基本概念

是一个很小的头文件，包含贯穿使用在STL中的几个模板的声明，在中剩下只有模板类pair,还有一些与之相关的模板函数和操作符，该模板类用来将两个对象表示成一个对象-----》当你想要一个函数返回两个值，或者想用一个容器来存储具有成对值的元素时，就非常方便

(2)基本函数

• Pair     

可以构造一个带有明确初始值的模板类pair

比如说获取x的第一个对象就用x.first , 获取x的第二个对象就用x.second

可以用另一个模板类pair的对象来构造类pair的对象

T和U只需提供一个默认的构造函数，一个接受单参数的构造函数，一个析构函数

•  Make_pair(模板函数)

模板函数在检测模板参数时将忽略掉所有的const属性（！！！注意常量）

不能依赖make_pair来产生一个含有一个或者多个常量成员对象的pair

•   Operator==比较两个pair对象x,y如果x,y对应的成员都相等的话，就可以说x,y是相等的

  

• Operator<

•  Operator!=

该函数返回！（x == y）

•  Operator>

•  Operator<= 返回！（x>y）

•  Operator>= 返回!（x

底下是模拟utility文件的做法

#ifndef UTILITY_
#define UTILITY_
namespace std{


template
struct pair
{
	typedef T1 first_type;
	typedef T2 second_type;
	pair():first(T1()),second(T2()){}
	pair(const T1& v1, const T2& v2):first(v1),second(v2){}
	template
		pair(const pair &x):first(x.first),second(x.second){}

		T1 first;
		T2 second;

};
template
inline bool operator==(const pair &x, const pair &y)
{
	return (x.first == y.first && x.second == y.second);
}
template
inline bool operator!=(const pair&x, const pair &y)
{
	return !(x==y);

}
template
inline bool operator<(const pair&x, const pair&y)
{
	return (x.first < y.first || (y.first < x.first) && !(x.second < y.second));
}
template
inline bool operator>(const pair&x, const pair&y)
{
	return (y
inline bool operator<=(const pair &x, const pair &y)
{
	return(!(y
inline bool operator>=(const pair&x, const pair&y)
{
	return (!(x
inline pairmake_pair(const T1 &x, const T2 &y)
{
	return (pair(x, y));
}

namespace rel_ops
{
	template
		inline bool operator==(const T&x, const T& y)
		{
			return x==y;
		}
	template//一个模板
		inline bool operator!=(const T& x, const T& y)
		{
			return!(x==y);
		}
	template
		inline bool operator<(const T& x, const T& y)
		{
			return x
		inline bool operator>(const T&x, const T&y)
		{
			return y
		inline bool operator>=(const T&x, const T&y)
		{
			return !(x
		inline bool operator<=(const T&x, const T&y)
		{
			return (!y

测试文件：

#include
using namespace std;
#include
#include

typedef pairPair_ic;
Pair_ic p0;

class Int
{
	public:
		Int(int v):val(v){}
		bool operator==(Int x)const
		{
			return val == x.val;
		}
		bool operator<(Int x)const
		{
			return val(Int x)const
		{
			return x=(Int x)const
		{
			return !(*this x);
		}
	private:
		int val;

};

int main()
{
	
	Pair_ic p1 = p0, p2(3, 'a');
	assert(p1.first == 0);
	assert(p1.second == 0);
	assert(p2.first == 3);
	assert(p2.second ='a');
	assert(p2 == make_pair((Pair_ic::first_type)3, (Pair_ic::second_type)'a'));
    assert(p2 > p1);
	assert(p1 != p2);


	using namespace std::rel_ops;
	Int a(2), b(2);
	assert(a == b);
	assert(a >= b);
	assert(a <= b);
	cout<<"utility test successful"<

结果：