C++下的

1.utility

     定义标准模板库 (STL) 类型、 函数和运算符，以帮助构建和管理的对象，这两个对象视为就可以像在需要时可对 。

      备注

      对已得到广泛应用的标准c++库中。 它们是必需的作为参数和返回值的各种功能和元素类型的容器 （例如类映射 和 multimap 类。 标题将自动包含通过

2.使用

    头文件：#include

    类：pair

    函数：

1.  forward 保留引用类型（或者lvalue或rvalue) 参数从被遮掩完美转发。
2.  get 获取从元素的函数pair对象。
   
3.  make_pair 用于构造类型的对象的模板 helper 函数pair，其中的组件类型基于作为参数传递的数据类型。
   
4.  move 返回传入参数作为rvalue的引用。
   
5.  swap 交换两个 pair 对象的元素。

    运算符

运算符! =	测试该运算符左侧的对对象不等于对对象的右侧。
运算符 = =	测试该运算符左侧的对对象等于对对象的右侧。
运算符 <	测试对运算符的左边的对象小于对对象的右侧。
运算符 < =	测试对运算符的左边的对象小于或等于对对象的右侧。
运算符 >	测试该运算符左侧的对对象大于对对象的右侧。
运算符 > =	测试该运算符左侧的对对象大于或等于对对象的右侧。

3.例子

1.类pair使用

#include 
#include 
using namespace std;
pair p;
int main()
{
cin >> p.first >> p.second;
cout << p.first << " " << p.second << endl;
return 0;
}

2.函数swap使用

// swap algorithm example (C++11)
#include      // std::cout
#include       // std::swap

int main () {

  int x=10, y=20;                  // x:10 y:20
  std::swap(x,y);                  // x:20 y:10

  int foo[4];                      
  int bar[] = {10,20,30,40};       
  std::swap(foo,bar);              

  std::cout << "foo contains:";
  for (int i: foo) std::cout << ' ' << i;
  std::cout << '\n';

  return 0;
}

3.make_pair的使用

// make_pair example
#include       // std::pair
#include      // std::cout

int main () {
  std::pair  foo;
  std::pair  bar;

  foo = std::make_pair (10,20);
  bar = std::make_pair (10.5,'A'); 

  std::cout << "foo: " << foo.first << ", " << foo.second << '\n';
  std::cout << "bar: " << bar.first << ", " << bar.second << '\n';

  return 0;
}

4.函数forward的使用

// forward example
#include       // std::forward
#include      // std::cout

// function with lvalue and rvalue reference overloads:
void overloaded (const int& x) {std::cout << "[lvalue]";}
void overloaded (int&& x) {std::cout << "[rvalue]";}

// function template taking rvalue reference to deduced type:
template  void fn (T&& x) {
  overloaded (x);                   // always an lvalue
  overloaded (std::forward(x));  // rvalue if argument is rvalue
}

int main () {
  int a;

  std::cout << "calling fn with lvalue: ";
  fn (a);
  std::cout << '\n';

  std::cout << "calling fn with rvalue: ";
  fn (0);
  std::cout << '\n';

  return 0;
}

输出： calling fn with lvalue: [lvalue][lvalue]

calling fn with rvalue: [lvalue][rvalue]

5.move的使用

// move example
#include       // std::move
#include      // std::cout
#include        // std::vector
#include        // std::string

int main () {
  std::string foo = "foo-string";
  std::string bar = "bar-string";
  std::vector myvector;

  myvector.push_back (foo);                    // copies
  myvector.push_back (std::move(bar));         // moves

  std::cout << "myvector contains:";
  for (std::string& x:myvector) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

输出：

myvector contains: foo-string bar-string