stl

STL：标准模板库（standard template library）是c++标准库的一部分（80%），使用c++的template机制来表达泛型的库。

STL的六大组件：容器（container）、算法（Algorithm）、迭代器（Iterator）、仿函数（Function object）、适配器（Adaptor）、空间配制器（Allocator）

容器：序列式容器+关联式容器

序列式容器：vector、deque、list 

关联式容器：set、multiset、map、multimap

vector：

是一个线性的顺序结构，相当于数组。

//是一个模板类，在使用时需要指定具体的类型

vector<int> v1(5);    //int v1[5];
for(int i=0;i<5;i++)
{
     v1[i] = i+1;
}

vector<int> v2(20);　　//vector类会初始化为零

v2 = v1;    //调用赋值重载函数


//vector类做函数参数与数组做函数参数的区别：vector类不需要指定元素长度，数组必须指定长度，数组名被指针化，vector不会。
void fun(vector<int> &c)
{
     int size = c.size();    
}

fun(v2);  //size = 5;

#include "iostream"
#include "vector"
using namespace std;

// vector<int> &c 和数组做函数参数区别
//数组做函数 会退化为指针
//类，类有封装概念，突破了函数的概念。。。（封装了属性和方法）

void printfV(vector<int> &c)
{
    int size = c.size();
    for (int i=0; i<size; i++)
    {
        printf("%d ", c[i]);
    }
}

void main01()
{
    //vector是一个模板类。。在使用模板类的时候，需要指明具体的类型
    //
    vector<int> v1(5);  //相当于 int v1[5];

    //vector<char> v1(5);  //相当于 int v1[5];

    for (int i=0; i<5; i++)
    {
        v1[i] = i+1;
        
    }
    for (int i=0; i<5; i++)
    {
        cout<<v1[i];
    }

    vector<int>v2(20);
    //执行=号操作
    v2 = v1;

    printfV(v2);

    //vector会把20个大小全部初始化。。。。
    vector<int>v3(20);
    v3.push_back(100);
    v3.push_back(101);
    printfV(v3);



    system("pause");
}

struct Teacher
{
    char name[10];
    int age;
};

void main02()
{
    //vector是一个模板类。。在使用模板类的时候，需要指明具体的类型
    //
    Teacher t1, t2, t3;
    t1.age = 11;
    t2.age = 22;
    t3.age = 33;
    vector<Teacher> v1(5);  //相当于 int v1[5];
    v1[0] = t1;
    v1[1] = t2;
    v1[2] = t3;

    printf("age:%d \n", v1[0].age);


    system("pause");
}


void main()
{
    //vector是一个模板类。。在使用模板类的时候，需要指明具体的类型
    //
    Teacher t1, t2, t3;
    t1.age = 11;
    t2.age = 22;
    t3.age = 33;
    vector<Teacher *> v1(5);  //相当于 Teacher* v1[5];
    v1[0] = &t1;
    v1[1] = &t2;
    v1[2] = &t3;

    for (int i=0; i<v1.size(); i++)
    {
        Teacher *tmp = v1[i];
        if (tmp != NULL)
        {
            printf("age:%d", tmp->age);
        }
    }
    system("pause");
}

vector与数组的区别：

1、vector是一个模板类，只要指定了元素类型，那么它可以用来定义任意的数据类型元素的数组：

vector<teacher> v1(5);　　//相当于定义了 teacher v1[5]

vector<teacher*> v1(5);　　//相当于定义了 teacher* v1[5]

vector<int> v1(5);　　//相当于定义了 int v1[5]

2、vector会进行初始化操作：

vector<int> v1(5);　　//相当于定义了  v1[0]=v1[1]=v1[2]=v1[3]=v1[4]=0;

3、vector提供了很多的操作：

vector<int> v1(5);　　

v1.size();　　//5

4、vector对象做函数参数，不会被指针化，而数组名作函数参数会被指针化。

 

stacks:栈

#include "iostream"
#include "stack"
using namespace std;

void printStack(stack<int> &s )
{
    //遍历栈的所有元素，必须要一个一个的弹出元素
    while(!s.empty())
    {
        //获取栈顶元素
        int tmp = s.top();

        //弹出栈元素
        s.pop();
        printf("tmp:%d ", tmp);

    }
}
void main()
{
    //定义了容器类，具体类型int
    stack<int> s;

    for (int i=0; i<5; i++)
    {
        s.push(i+1);　　//元素入栈
    }

    //遍历栈的所有元素，必须要一个一个的弹出元素
    while(!s.empty())
    {
        //获取栈顶元素
        int tmp = s.top();
        
        //弹出栈元素
        s.pop();　　//元素出栈
        printf("tmp:%d ", tmp);
    }
    printf("\n");
    printStack(s);

    
    system("pause");
}

queue：队

#include "iostream"
#include "queue"
using namespace std;

void main1()
{
    queue<int> q;
    for (int i=0; i<5; i++)
    {
        q.push(i+1);  //入队
    }

    while (!q.empty())
    {
        //获取队列的第一个元素
        int tmp = q.front();
        printf("tmp:%d ", tmp);
        q.pop(); //出队
    }
    
    system("pause");
}

struct Teacher
{
    char name[64];
    int age ;
};

void printQ(queue<Teacher *>  &myq)
{
    while (!myq.empty())
    {
        Teacher *tmp = myq.front();
        if (tmp != NULL)
        {
            printf("tmp:age : %d ", tmp->age);
        }
        myq.pop(); //出队
    }
}

void main()
{
    queue<Teacher *> q;
    Teacher t1, t2, t3;
    t1.age = 32;
    t2.age = 33;
    t3.age = 34;

    q.push(&t1);
    q.push(&t2);
    q.push(&t3);

    printQ(q);


    system("pause");
}

 

list:链表

#include "iostream"
#include "list"
using namespace std;

void main01()
{
    list<int> L;
    cout<<L.size()<<endl;
    for (int i=0; i<5; i++)
    {
        L.push_back(i+1);
    }
    cout<<L.size()<<endl;
    list<int>::iterator current = L.begin();    //定义迭代器：current（迭代器就是一个指针，可以通过迭代器访问逐个节点）
    /*
    每一种容器都必须提供自己的迭代器，用迭代器遍历容器。
    */
    while (current != L.end())    //L.end()指向最后节点的下一个位置，而不是最后一个节点
    {
        cout<<*current<<endl;    //这里的*作用于迭代器，*在容器中被重载了
        current ++;                //指向下一个节点，++也是被重载了的。
    }

    //获取链表的开头，赋值给迭代器
    current = L.begin(); //L.begin()指向第一个节点位置
    current ++; 
    current ++; 
    current ++; 
    L.insert(current, 100);    //current指向第四个节点位置，插入数据。

    printf("\n插入位置测试，请你判断是从0位置开始，还是从1位置开始\n");
    for (list<int>::iterator p = L.begin(); p!= L.end(); p++)
    {
        cout<<*p<<" ";
    
    }
    system("pause");
}
struct Teacher
{
    char name[64];
    int age;
};

void main02()
{
    list<Teacher> L;

    Teacher t1, t2, t3;
    t1.age = 11;
    t2.age = 12;
    t3.age = 13;

    L.push_back(t1);
    L.push_back(t2);
    L.push_back(t3);

    for (list<Teacher>::iterator p = L.begin(); p!=L.end();p++)
    {
        printf("tmp:%d ", p->age);
    }
    system("pause");

}

void main()
{
    list<Teacher *> L;

    Teacher t1, t2, t3;
    t1.age = 11;
    t2.age = 12;
    t3.age = 13;

    L.push_back(&t1);
    L.push_back(&t2);
    L.push_back(&t3);

    for (list<Teacher *>::iterator p = L.begin(); p!=L.end();p++)
    {
        Teacher * tmp  = *p;　　//p指向的节点为 Teacher*类型，所以*p才是指向Teacher类型。
        printf("tmp:%d ", tmp->age);
    }
    system("pause");
}