（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>

 1 pair的定义：
 2  namespace std{
 3      template <typename T1,typename T2>
 4      struct pair{
 5          T1 first;
 6          T2 second;
 7          ...
 8      };
 9  }
10
11 pair的初始化：
12 1.   pair<T1,T2> p;  //默认构造函数，如果要为p赋值要用make_pair方法，如
13       p=make_pair(1,1);   //这里的T1,T2就是int类型
14 2.   pair<T1,T2> p(1,1);  //直接给p赋值
15 3.   pair<T1,T2> p(p2);   //Copy构造函数，将p2的值赋给p
16 4.   pair<T1,T2> p(rv);    //Move构造函数，将rv的值移动到p（允许隐式类型转换）
17
18 pair赋值：
19 1.   p=p2;   //将p2的值赋给p;
20 2.   p.first ,  p.second  ;    //求出p的第一个和第二个的值
21 3.   get<0>(p);  //等同于p.first   (始自C++11)
22 4.   get<1>(p);  //等同于p.second(始自C++11)
23
24 pair比较：
25 1.   p1==p2;    //返回p1是否等于p2,即bool值，等同于p1.first==p2.first&&p1.second==p2.second  ,其他同理
26 2.   p.swap(p1);   //交换p,p1的值（始自C++11）
27 3.   swap(p1,p2);  //同上，swap是个全局函数（始自C++11）
28
29 pair赋值：
30 p=make_pair(v1,v2);

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

1 typedef std::pair<int,float> IntFloatPair;
2 IntFloatPair p(42,3.14);
3
4 std::get<0>(p);   //获得第一个值
5 std::get<1>(p);   //获得第二个值
6 std::tuple_size<IntFloatPair>::value;   //获得元素的个数
7 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(42,3.14);
    std::get<0>(p);   //获得第一个值
    std::get<1>(p);   //获得第二个值
    cout<<std::tuple_size<IntFloatPair>::value<<endl;   //获得元素的个数
    cout<<typeid(std::tuple_element<0,IntFloatPair>::type).name()<<endl;  //获得元素的类型
    cout<<typeid(p.first).name()<<endl;  //用typeid输出变量类型
    cout<<get<0>(p)<<endl;
    cout<<p.first<<endl;
    return 0;
}

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<int,float> t(1,2.22);
    pair<int,Foo> p1(42,t);
    pair<int,Foo> p2(piecewise_construct,make_tuple(42),t);
    return 0;
}

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