（ACM）C++ STL 训练（第一天）

因为老师说ACM考的是纯C++，所以打算抛弃VS的VC++不用了，针对纯C++的编译器有Intel Compiler(不过要钱),MinGw(个人用的)，当然还有微软的VC++ 编译器，IDE你们可以选择CLion，用过几次，非常强大，可惜要钱。Dev C++，这个也很不错，个人推荐，并且这个不用配置编译环境，安装之后直接用，Code block,许多人的最爱，也得配置环境，用的也挺舒适的。我用的是QT5.7+MinGw。QT这个一定耳熟能详，不了解的自己去搜，也是非常棒的一个IDE。

第一天：通用工具（一）

Pair:他是一个结构体，里面的成员都是public,类似于字典Dictionary的键值对的格式，Pair的头文件是#include<utility>

 pair的定义：
  namespace std{
      template <typename T1,typename T2>
      struct pair{
          T1 first;
          T2 second;
          ...
      };
  }

 pair的初始化：
 .   pair<T1,T2> p;  //默认构造函数，如果要为p赋值要用make_pair方法，如
       p=make_pair(,);   //这里的T1,T2就是int类型
 .   pair<T1,T2> p(,);  //直接给p赋值
 .   pair<T1,T2> p(p2);   //Copy构造函数，将p2的值赋给p
 .   pair<T1,T2> p(rv);    //Move构造函数，将rv的值移动到p（允许隐式类型转换）

 pair赋值：
 .   p=p2;   //将p2的值赋给p;
 .   p.first ,  p.second  ;    //求出p的第一个和第二个的值
 .   >(p);  //等同于p.first   (始自C++11)
 .   >(p);  //等同于p.second(始自C++11)

 pair比较：
 .   p1==p2;    //返回p1是否等于p2,即bool值，等同于p1.first==p2.first&&p1.second==p2.second  ,其他同理
 .   p.swap(p1);   //交换p,p1的值（始自C++11）
 .   swap(p1,p2);  //同上，swap是个全局函数（始自C++11）

 pair赋值：
 p=make_pair(v1,v2);

另外，从C++11起，可以对pair使用一份tuple-like接口。

 typedef std::pair<int,float> IntFloatPair;
 IntFloatPair p(,3.14);

 std::>(p);   //获得第一个值
 std::>(p);   //获得第二个值
 std::tuple_size<IntFloatPair>::value;   //获得元素的个数
 std::tuple_element<IntFloatPair>::type;  //获得元素的类型

QT格式化代码（使代码整齐）的快捷键是：Ctrl+A,Ctrl+I;

这就是上面的例子的具体代码，其中数据类型int输出为i，float输出为f

#include <iostream>
#include<utility>
#include<typeinfo>
using namespace std;
typedef std::pair<int,float> IntFloatPair;
int main(int argc, char *argv[])
{

    IntFloatPair p(,3.14);
    std::>(p);   //获得第一个值
    std::>(p);   //获得第二个值
    cout<<std::tuple_size<IntFloatPair>::value<<endl;   //获得元素的个数
    cout<<typeid(std::tuple_element<,IntFloatPair>::type).name()<<endl;  //获得元素的类型
    cout<<typeid(p.first).name()<<endl;  //用typeid输出变量类型
    cout<<>(p)<<endl;
    cout<<p.first<<endl;
    ;
}

pair<int,float> p;   //p.first和p.second默认为0，如果是pair<string,char> p; 则p.first，p.second估计是nul

#include<iostream>
#include<utility>
#include<tuple>
using namespace std;

class Foo{
public:
    Foo(tuple<int,float>){
        cout<<"Foo::Foo(tuple)"<<endl;
    }
    template<typename...Args>  //变长参数模板，Args是模版
    Foo(Args... args){
        cout<<"Foo::Foo(args...)"<<endl;
    }
};

int main()
{
    tuple<,2.22);
    pair<,t);
    pair<),t);
    ;
}

上述代码中，只有当std::piecewise_construct被当作第一个参数，class Foo才会被迫使用那个实参数量不定的构造函数，如果提供了Foo::Foo(int,float)的话，调用的就是他。如你所示，两个实参都必须是tuple才会强迫导致这个行为，因此，第一个参数被显示转化为tuple类型，用的是make_tuple(),也可以改传std::tuple(42)。

Tuple:tuple扩展了pair