STL 容器（vector 和 list ）

1.这个容器的知识点比较杂

迭代器的理解：
1.erase()函数的返回值，它的迭代器在循环遍历中的奇特之处；

 #define _CRT_SECURE_NO_WARNINGS
 #include <iostream>
 #include <vector>
 #include <list>
 #include <algorithm>
 #include <numeric>
 #include <functional>

 using namespace std;

 /*
 int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 99};
 要求：
 （1）将ia复制到一个vector容器vec中和一个list容器中lst中。
 （2）将vec容器中的奇数值元素删除。
 （3）使用内置算法计算vec窗器所有元素的和。Accumulate
 （4）使用内置算法计算lst容器中大于5的元素的个数    count_if

 */

 //lambda 表达式
 // [](参数列表)->返回值 {函数体}

 void print(int val)                //回调函数
 {
     cout << val << " ";
 }
 //打印的三种方式（回调函数、函数对象、兰巴达表达式）
 struct PRINT
 {
     void operator()(int val)
     {
         cout << val << " ";
     }
 };
 void printVec(vector<int>& v)
 {
     for_each(v.begin(), v.end(), [](int val){cout << val << " "; });        //采用兰博打表达式
     cout << endl;
 }

 void printList(list<int>&  L)            //这里采用了回调函数,函数对象
 {
     //for_each(L.begin(), L.end(), PRINT());            //回调函数对象
     for_each(L.begin(), L.end(), print);            //回调函数
     cout << endl;
 }

 class isGreat
 {
 public:
     bool operator()(int val)
     {
         if (val > )
             return true;
         else
             return false;
     }
 };
 void test04(int* arr, int len)
 {
     vector<int> v1;
     list<int> l1;
     v1.assign(arr, arr + len - );        //将数组中的元素拷贝进容器中（第一种方法）
     //将一个容器中的元素拷贝进另一个容器（第二种方法）
     for (int val : v1)                    //C++11的表达式；此处的v1可以是数组或容器
     {
         l1.push_back(val);
     }
     //打印
     printVec(v1);
     printList(l1);

     //（2）将vec容器中的奇数值元素删除。 erase
     vector<int>::iterator it = v1.begin();
     for (; it != v1.end(); )
     {
         if (*it %  != )
         {
             it = v1.erase(it);        //这里关注 erase 的返回值，是一个迭代器。
             //it--;            //这种方法不对，有bug;它是将迭代器的移动还放在for循环的位置（正常放置），但是当第一个元素符合条件时，这种方法就出错，因为迭代器减小后，就越界了。
         }
         else                        //同时还有这步，将迭代器的移动放到下面。（这种属于通用方法，但是我还没有想懂，它删除后迭代器是如何移动的）（现在搞懂了，在线面有详细描述）
         {
             it++;
         }
     }
     printVec(v1);

     //（3）使用内置算法计算vec窗器所有元素的和。Accumulate
     auto it1 = v1.begin();            //auto可以自动推导变量的类型。
     auto sum = accumulate(it1, v1.end(), );        //第三个参数为：求和的基数；即容器中所有的元素的和加上它就是最后的总和。

     //（4）使用内置算法计算lst容器中大于5的元素的个数
     int num = count_if(l1.begin(), l1.end(), isGreat());
     cout << num << endl;
 }

 int main()
 {
     int ia[] = { , , , , , , , , , ,  };
     int len = sizeof(ia) / sizeof(int);
     test04(ia, len);

     system("pause");
     return EXIT_SUCCESS;
 }

1.这个题 的知识点：

　　1）vector容器在遍历的时候删除元素;这个和 erase()函数的返回值有关

　　2） erase()函数的返回值；（这个最重要）

　　3）一个容器中元素拷贝到不同类型的容器中（三种方法，一种没写，为普通的for循环遍历）

　　4）打印容器元素的三种方法：（回调函数，函数对象，兰巴达表达式）

　　5）STL的求和函数 accumulate(),第三个参数的作用；

　　6）auto类型；可以自动推导变量的类型

　　7）查找count_if()函数的使用，第三个参数的作用。

2.循环遍历，it++放置不同的位置；
　　1）在正常的for循环位置
　　　　1）符合条件时erase()容器中的某个元素，但是没有接返回值
　　　　2）符合条件时erase()容器中的某个元素，接了返回值；
　　　　3）符合条件时，接了返回值，同时在下面接着 it--；看容器首位元素符合条件和不符合条件的两种情况。
　　2）不放在正常位置
　　　　1）放在不符合条件的情况下it++；（即正确的情况，上面的那段代码）。

 void test01(vector<int> v)
 {                //这段代码会报错，因为当进行 erase() 后， 当前迭代器就失效了。而这里对它进行了++操作，所以程序崩溃
     for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
     {
         if (*it %  != )
         {
             v.erase(it);
         }
     }
 }

 void test02(vector<int> v)
 {
     for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
     {            //这段代码也会崩溃，erase()函数的返回值被接收，此时假如最后一个数据也符合条件，代码运行到最后的数据，也会崩溃。
         if (*it %  != )
         {
             it = v.erase(it);
         }
     }
 }

 for (vector<int>::iterator it = v.begin(); it != v1.end(); it++)
 {
     cout << *it << " ";
     if (*it %  != )
     {
         v1.erase(it);        //这里关注 erase 的返回值，是一个迭代器。如果接受这个迭代器，那么此时它就指向删除元素的下一个元素。
         it--;            //这种方法不对，有bug;它是将迭代器的移动还放在for循环的位置（正常放置），但是当第一个元素符合条件时，这种方法就出错，因为迭代器减小后，就越界了。
     }                    //但是假如第一个数据不符合条件就没有问题。
 }

 /*
 vector<int> 容器 erase() 的返回值为"当前位置的"迭代器；它是这样理解的；假如你不接返回值，那么遍历循环时，删除后的当前迭代器
 值失效，而你接下来还对它进行了操作，编译器马上段错误。
  当你对它的返回值接收后，（就像紧密排列在一起的球，拿掉其中的一个，下一个立刻补上，）；虽然返回的是同一个位置的迭代器，但是它
  值已经发生变化，（相对于原来的容器来说，他就返回了属于后一个值得迭代器。）而这个迭代器是有效的，你可以对它进行操作。（但是此时
  还有一些额外情况，例如：当容器最后一个数据符合条件，它的迭代器被删除，而又被接到返回值，此时这个迭代器就是尾部的 end()迭代器，
  假如遍历的循环，第三个条件还写在与原来的位置，如（++操作），此时就会发生迭代器的越界，编译器出现段错误。（在下面有实例）。

 */

3.sort算法排序【包含：函数对象（仿函数）】；

 #define _CRT_SECURE_NO_WARNINGS
 #include<iostream>
 #include<vector>
 #include<algorithm>
 #include<functional>
 #include<string>
 using namespace std;

 //sort排序算法
 struct for_each_condition{
     void operator()(int val){
         cout << val << " ";
     }
 };
 void test01(){

     vector<int> v;
     v.push_back();
     v.push_back();
     v.push_back();
     v.push_back();
     v.push_back();
     v.push_back();

     for_each(v.begin(), v.end(), for_each_condition()); cout << endl;
     sort(v.begin(), v.end(), less<int>());
     for_each(v.begin(), v.end(), for_each_condition()); cout << endl;
     sort(v.begin(), v.end(), greater<int>());
     for_each(v.begin(), v.end(), for_each_condition()); cout << endl;
 }

 class Person{
 public:
     Person(string name, int age){
         this->mName = name;
         this->mAge = age;
     }
     bool operator==(const Person& p){
         if (p.mName == this->mName && this->mAge == p.mAge){
             return true;
         }
         return false;
     }
 public:
     string mName;
     int mAge;
 };

 //排序对象
 struct for_each_condition_obj{
     void operator()(Person& val){
         cout << "Name:" << val.mName << " Age:" << val.mAge << endl;
     }
 };
 struct sort_condition{
     bool operator()(Person& p1, Person& p2){
         return p1.mAge > p2.mAge;
     }
 };
 void test02(){

     vector<Person> v;
     v.push_back(Person("john01", ));
     v.push_back(Person("john03", ));
     v.push_back(Person("john05", ));
     v.push_back(Person("john02", ));
     v.push_back(Person("john06", ));
     v.push_back(Person("john03", ));

     for_each(v.begin(), v.end(), for_each_condition_obj()); cout << endl;
     sort(v.begin(), v.end(), sort_condition());
     for_each(v.begin(), v.end(), for_each_condition_obj()); cout << endl;
 }
 int main(){

     //test01();
     test02();

     system("pause");
     return EXIT_SUCCESS;
 }