（c++笔记）第二十九节课：STL

一 可变参数

1.1 c语言的可变参数

实现原理:参数个数不确定，但是所有参数保存在栈上是连续的。

#include <iostream>
#include <stdarg.h>
using namespace std;
//实现可变参数的条件：函数的参数一定要由特殊的作用（标明后面参数的个数或者类型）
int func(int num1, int num2, ...)  //第一个参数num1是参数的个数或者参数的类型及个数
{
    va_list v1;  //va_list指针，用于va_start可变参数，为char*
    va_start(v1,num1);  //是v1指向后面的可变参数
    printf("v1 = %d\n",*v1);
​
    int res;
    for (int i = 0; i < num1 ; i++)
    {
        res = va_arg(v1, int); //先返回当前元素的值，再把v1往后跳4个字节（sizeof(int)的大小），使得指向下一个参数
        printf("res = %d\n",res);
    }
    va_end(v1);  //释放指针
    return 0;
}
int main()
{
    func(3, 4, 5, 6);
}

1.2 c++11中的可变参数

不建议使用c语言的可变参数，因为内部原型检查机制不全，不安全
initializer_list 列表初始化

1.3 initializer_list 列表初始化

1.3.1 本质

用于表示某种特定类型的值的数组，和vector一样，initializer_list 也是一种模板类型

1.3.2 使用

用{}来初始化变量  比如：std::vector<int> a{1,2,3,4,5};

1.3.3 初始化区别

int c = 3.3;  // 默认类型转换
int b = (int){3.3}  //编译器会给出警告（也有可能是错误）
​

1.3.4 使用

#include <iostream>
#include <stdarg.h>
using namespace std;
class A
{
public:
    A(const initializer_list<int> &t)
    {
        for (auto tmp : t)  //范围for
        {
            cout << tmp << endl;
        }
    }
};
template <typename T>
void func(initializer_list<T> arg)
{
    auto it = arg.begin();
    for (; it != arg.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}
int main(int argc,char *argv[])
{
​
    
    initializer_list<int> init_list{ 1,2,3,4,5,6 };
    //cout << init_list << endl;
    //cout << init_list[0] << endl;
    auto it = init_list.begin();
    for (; it != init_list.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    func({ 1,2,3,4,5,6,7,8,8,9});
    A a{1,2,3,4,5};
​
    //int a = { 3.3 };
    initializer_list<double> aa = { 3.3 };
    cout << endl;
    
}

二 萃取技术

#include <iostream>
#include <list>
using namespace std;
​
template <typename T>
void printTraitsInfo(const T& t)
{
    cout << "--------------begin-----------" << endl;
​
    cout << "我们要萃取的类型名字是：" << typeid(T).name() << endl;
​
    cout << "is_void = " << is_void<T>::value << endl;                                    //类型是否是void
    cout << "is_class = " << is_class<T>::value << endl;                                  //类型是否是一个class
    cout << "is_object = " << is_object<T>::value << endl;                                //类型是否是 一个对象类型
    cout << "is_pod = " << is_pod<T>::value << endl;                                      //是否普通类（只包含成员变量，不包含成员函数）；   POD(plain old data)
    cout << "is_default_constructible = " << is_default_constructible<T>::value << endl;  //是否有缺省构造函数
    cout << "is_copy_constructible = " << is_copy_constructible<T>::value << endl;        //是否有拷贝构造函数
    cout << "is_move_constructible = " << is_move_constructible<T>::value << endl;        //是否有移动构造函数
    cout << "is_destructible = " << is_destructible<T>::value << endl;                    //是否有析构函数
    cout << "is_polymorphic = " << is_polymorphic<T>::value << endl;                      //是否含有虚函数
    cout << "is_trivially_default_constructible = " << is_trivially_default_constructible<T>::value << endl;      //缺省拷贝构造函数是否是可有可无的(没有也行的),返回1表示确实可有可无
​
    cout << "has_virtual_destructor = " << has_virtual_destructor<T>::value << endl;      //是否有虚析构函数
​
    cout << "--------------end-------------" << endl;
​
}
​
class A
{
public:
    A() = default;
    A(A&& ta) = delete;           //移动构造：你要不写delete，系统一般就会认为你有这个成员函数；
    A(const A& ta) = delete;      //拷贝构造 
    virtual ~A() {}
};
class B
{
public:
    int m_i;
    int m_j;
};
class C
{
public:
    C(int t) {} //有自己的构造函数，编译器不会给你提供缺省构造函数
};
​
void func()
{
    printTraitsInfo(int());     //扔一个临时对象进去
    printTraitsInfo(string());
    printTraitsInfo(A());
    printTraitsInfo(B());
    printTraitsInfo(C(1));
    printTraitsInfo(list<int>());
}
​
​
int main(void)
{
    func();
}
​

三 STL

3.1 stl的概念

为了复用性的提升
为了建立数据结构和算法的一套标准，并且降低其间的耦合关系，以及提升各自的独立性（高内聚），交互性操作（相互合作性），c++社群诞生了STL

3.2 价值

低层次：一个非常实用的零部件，以及以一个整合的组织去使用。
高层次：以泛型思维为基础，系统化，条例清晰的：“软件组织分类学”。

3.3 历史

STL  1979 c++ 1971年
1987年 Ada libray c++还未提出template
1992 帕罗奥图 Alex项目-->Stl
1993年 贝尔 ANSI/ISOC++

3.4 STL的六大组件

（1）容器

各种数据结构，vector,list,deque,set,map，用来存放数据。
从实现角度看:是一种类模板，就体积而言 ，占总85%以上。

（2）算法

各种常用的算法，sort,seach,copy,erase....
从实现角度看：function template

（3）迭代器

容器和算法之间的胶合剂，又称为“泛型指针”，一共五种类型，以及其它衍生的变化。
从实现角度看：重载operator*,operator-> operator++,operator--等指针相关操作（class Template）
所有的STL都附带由自己的专属迭代器。

（4）仿函数

行为类似函数，内部重载了()的类或者类模板，一般的函数指针可以狭义的理解为仿函数

（5）配置器（配接器）

一种修饰容器或仿函数或者迭代器接口的东西，例如：stl提供的stack和queue,虽然看似是容器，其实只能算是一种容器配接器，因为他们底层完全借助于deque,所有操作都是由deque供应。
改变functor接口者，称为function adapter(bind,negate(否定），compose(组合))
改变container接口者，称为container adapter
改变iterator接口者，称为iterator adapter                              

（6）空间适配器

负责空间配置与管理（内存池技术）
从实现角度看：配置器实现了一个动态空间配置，空间管理，空间释放 （class Template）
SGI STL   第一级配置器 >128byte
SGI STL   第二级配置器 16个自由链表（8 16 24 32 40 48 56 64 72 80 88 96，104，112，120，128）

3.5 容器

3.5.1 容器分类

序列式容器（顺序容器）：array(c++内建)，vector，list,heap,prority-heap, slist  deque,stack,queue
					forward_list(c++11)
关联式容器：RB-tree(非公开) set map multiset multimap  hashtable hash-set hash-map 

3.5.2 确定使用哪种容器

通常，使用vector是最好的选择，除非你有更好的理由选择其它容器
1.如果你的程序有很多小的元素，且空间的额外开销很重要，则不要使用list或forward_list。
2.如果程序要求随机访问元素，应该使用vector或者deque
3.如果想在容器的中间插入或者删除元素，则list或forward_list应该是首选
4.如果程序要在头尾位置插入或删除元素，但是不会在中间为hi插入或删除元素，则使用deque。
5.如果想要在程序中随机访问元素，又要在容器的中间插入元素，该怎么办？
   -->答案取决于list或者forward_list中访问元素与vector或deque中插入、删除元素的相对性能。
   一般来说，应用中占主导地位的操作决定了容器类型的选择。
6.如果你还是不确定应该使用哪种容器，那么可以只是用vector或者list公共的操作：使用公共的操作：迭代器
    不使用下标操作，避免随机访问，这样使用两者，都比较方便。

3.5.3 vector容器的内存如何增长

3.5.4 vector的数据结构

template<class T,class Alloc = alloc>
class Vector
{
    protected:
    	iterator start;   //表示目前使用空间的头
    	iterator finish;  //表示目前使用空间的尾
    	iterator end_of_storage //表示目前可用空间的尾
        ...
};

#include <iostream>
#include <vector>
#include <list>
using namespace std;
​
class Test
{
public:
    int m_a;
    int m_b;
public:
    Test()
    {
        cout << "Test" << endl;
    }
    Test(int a):m_a(a)
    {
        cout <<m_a << " Test有一个参数的构造函数" << endl;
    }
    Test(const Test &obj)
    {
        cout << "Test的拷贝构造函数" << endl;
        this->m_a = obj.m_a;
        this->m_b = obj.m_b;
    }
    ~Test()
    {
        cout << "~Test" << endl;
    }
};
​
int main(void)
{
//初始化
    vector<int> v1;
    vector<string> vs;
    vector<vector<string>> vv; //  其元素的类型是string的vector vector的vector
    vector<Test> v3;
    vector<int> v4 = { 1,2,3,4,5,6 }; //列表初始化
    vector<int> v5(v4);
    vector<int> v6(v4.begin() + 1, v4.end());
    vector<int> v7(100);   //预先开辟100个int
    vector<string> v8 = { 10,"hello" }; //10个hello
    vector<int> v9(100, 5);  //预先开辟100个int,全部初始化为5
//插入数据
    v3.reserve(10);
    cout << v3.capacity() << endl;
    v3.push_back(Test(1));  //末尾添加
    v3.push_back(Test(2));
    v3.push_back(Test(3));
    v3.insert(v3.end(), Test(4));  //按位置插入
    
    //v3.emplace_back(1);  //c++11
    //v3.emplace_back(2);
    //v3.emplace_back(3);
    //cout << v3.capacity() << endl;
    //v3.emplace(v3.begin() + 1, Test(5));  //中间插入
    //v3.resize(10); //重新指定容器的长度为10,len > 原来的长度，将没有使用的空间进行初始化，len < 原来的长度，将多余的数据丢弃。
    //v3.resize(10, 9);  //容量扩充为10，多出的部分初始化为9
    //cout << v3.capacity() << endl;
//遍历
    cout << v4.size() << endl;  //元素的个数
    cout << v4.capacity() << endl;  //容器的容量
    for (int i = 0; i < v4.size(); i++)
    {
        cout << v4[i] << " ";
    }
    cout << endl;
​
    for (vector<int>::size_type i = 0; i != 24; i++)
    {
        v1.push_back(i);
    }
    cout << v1.size() << endl;  //元素的个数
    cout << v1.capacity() << endl;  //容器的容量
    v1.reserve(50);
    cout << v1.size() << endl;  //元素的个数
    cout << v1.capacity() << endl;  //容器的容量
    while (v1.size() != v1.capacity())
    {
        v1.push_back(0);
    }
    cout << v1.size() << endl;  //元素的个数
    cout << v1.capacity() << endl;  //容器的容量
    v1.push_back(56);
    cout << v1.size() << endl;  //元素的个数
    cout << v1.capacity() << endl;  //扩充为75，具体依赖于标准库的实现
//归还内存
    v1.shrink_to_fit();
    cout << v1.size() << endl;  //元素的个数
    cout << v1.capacity() << endl;  //扩充为75，具体依赖于标准库的实现
//迭代器遍历vector
​
    /*for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++)
    {
        cout << *it<<" ";
    }
    cout << endl;*/
​
    for (auto it = v1.begin(); it != v1.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
//删除
    v1.erase(v1.begin());  //删除一个元素
    for (auto it = v1.begin(); it != v1.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
​
    v1.erase(v1.end() - 5, v1.end());
    for (auto it = v1.begin(); it != v1.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
​
    //使用迭代器删除v1中所有的奇数？
    //for (auto it = v1.begin(); it != v1.end();)
    //{
    //  cout << "begin1:" << *v1.begin() << endl;
    //  if ((*it % 2) != 0)
    //  {
    //      v1.erase(it);
    //  }
    //  else
    //  {
    //      it++;
    //  }
    //  cout << "begin2:" << *v1.begin() << endl;
    //  cout << endl;
​
    //}
    //for (auto it = v1.begin(); it != v1.end(); it++)
    //{
    //  cout << *it << " ";
    //}
    //cout << endl;
//assign 赋值（仅顺序容器）
​
    list<string> name;
    vector<const char *> oldstyle;
    //name = oldstyle;(错误)
    name.assign(oldstyle.cbegin(),oldstyle.cend());  //可以将const char*转为string
    return 0;
​
}

3.5.5 list

list好处是每次插入或者删除一个元素，就配置或释放一段空间，因此，对于list空间的运用有绝对的精准，一点也不浪费，而且对于任何位置的插入和删除，list永远是常数时间。
    list采用的迭代器:双向迭代器（bidirectional iterator）

#include <iostream>
#include <list>
#include <string>
using namespace std;
template <typename T>
void func(list<T> &l)
{
    for (auto it = l.begin(); it != l.end(); it++)
    {
        cout << *it <<" ";
    }
    cout << endl;
}
class Test
{
public:
    int m_a;
    string m_name;
public:
    Test()
    {
        cout << "Test" << endl;
    }
    Test(int a,string n):m_a(a), m_name(n)
    {
        cout <<m_a << " Test有一个参数的构造函数" << endl;
    }
    Test(const Test &obj)
    {
        cout << "Test的拷贝构造函数" << endl;
        this->m_a = obj.m_a;
        this->m_name = obj.m_name;
    }
    ~Test()
    {
        cout << "~Test" << endl;
    }
    bool operator==(const Test &t)
    {
        return this->m_a == t.m_a && this->m_name == t.m_name;
    }
};
ostream& operator<<(ostream &out, Test &t)
{
    out << t.m_a <<" "<<t.m_name<<endl;
    return out;
}
int main(void)
{
    list<int> ll(100, 1);
    cout << ll.size() << endl;
    func(ll);
    list<int> l2(ll.begin(), ll.end());
    list<int> l3(l2);
    Test t1(1,"aaa");
    Test t2(2, "bbb");
    Test t3(3, "ccc");
    Test t4(4, "ddd");
    Test t5(5, "eee");
    Test t6(6,"fff");
    list<Test> l;
    l.push_back(t1);
    l.push_back(t2);
    l.push_back(t3);
    l.push_back(t4); //尾插法 
​
    l.push_front(t5); //头插法
    l.push_front(t6);
    l.push_front(Test(7, "ggg"));
    
    l.emplace_front(8, "ppp");
    l.emplace_back(9, "www");
    l.emplace(l.begin(), 10, "ooo");  //在开头插入
    func(l);
​
//删除
    l.pop_back(); //删除最后一个结点
    l.pop_front();//删除第一个结点
    func(l);
    cout << "********************" << endl;
//输出第一个元素
    cout << l.front() << endl;
//输出最后一个元素
    cout << l.back() << endl;
//链表扩充
    l.resize(15, t4);
    func(l);
//对象数组
    cout << "**********" << endl;
    Test t[5] = { Test{1,"a"}, Test{2,"b"}, Test{3,"c"}, Test{4,"d"}, Test{5,"e"} };
    l.insert(l.begin(), t[0]);  //在头部插入一个元素
    l.insert(l.end(), t, t + 5);  //在链表尾部插入一个区间
    func(l);
​
//删除一个区间
    //l.erase(++l.begin(),--l.end());
    //func(l);
//删除某一个位置
    //l.erase(l.begin());
    //func(l);
//删除一个具体的元素
    //l.remove(t4);
    //func(l);
//c++20：unique
    l.unique(); //相邻重复的全部删除
    func(l);
/*重载*/
    l.sort();
    
    return 0;
​
}
​