C++学习 --list

目录

[1， 什么是list](#1， 什么是list)

[2， 创建](#2， 创建)

[2-1， 标准数据类型](#2-1， 标准数据类型)

[2-2， 自定义数据类型](#2-2， 自定义数据类型)

[2-3， 其他创建方式](#2-3， 其他创建方式)

[3， 操作list](#3， 操作list)

[3-1， 赋值](#3-1， 赋值)

[3-2， 添加元素](#3-2， 添加元素)

[3-2-1， 添加元素(assign)](#3-2-1， 添加元素(assign))

[3-2-1-1， 标准数据类型](#3-2-1-1， 标准数据类型)

[3-2-1-2， 自定义数据类型](#3-2-1-2， 自定义数据类型)

[3-2-2， 添加元素(insert)](#3-2-2， 添加元素(insert))

[3-2-2-1， 标准数据类型](#3-2-2-1， 标准数据类型)

[3-2-2-2， 自定义数据类型](#3-2-2-2， 自定义数据类型)

[3-2-3， 添加元素(push_back | push_front)](#3-2-3， 添加元素(push_back | push_front))

[3-2-3-1， 标准数据类型](#3-2-3-1， 标准数据类型)

[3-2-3-2， 自定义数据类型](#3-2-3-2， 自定义数据类型)

[3-3， 查询](#3-3， 查询)

[3-3-1， 标准数据类型](#3-3-1， 标准数据类型)

[3-3-2， 自定义数据类型](#3-3-2， 自定义数据类型)

[3-4， 获取长度(size)](#3-4， 获取长度(size))

[3-5， 设置长度(resize)](#3-5， 设置长度(resize))

[3-6， 判断是否为空(empty)](#3-6， 判断是否为空(empty))

[3-7， 删除元素](#3-7， 删除元素)

[3-7-1， 头删(pop_front)](#3-7-1， 头删(pop_front))

[3-7-2， 尾删(pop_back)](#3-7-2， 尾删(pop_back))

[3-7-3， 指定元素删除(erase)](#3-7-3， 指定元素删除(erase))

[3-8， 清空(clear)](#3-8， 清空(clear))

[3-9， 排序(sort)](#3-9， 排序(sort))

[3-10， 交换元素(swap)](#3-10， 交换元素(swap))

[3-11， 翻转](#3-11， 翻转)

---

1， 什么是list

C++中的一种容器类型， 也叫链表 ， 数据是链式存储 的， 物理上不是 一段连续的存储空间 ， 逻辑上通过链表指针来数据连接

list由节点 组成， 节点由存储数据的数据域 和存储地址的指针域组成

其迭代器不支持随机访问， 只能前移或后移

因为不是标准数据类型， 需要包含头文件才能使用**#include <list>**

2， 创建

通过list<数据类型> 对象名 ， 可创建list， 数据类型可以是标准数据类型 ， 也可以是自定义类型

2-1， 标准数据类型

//list中的元素类型为string
list<string> l1;

2-2， 自定义数据类型

Myclass m1("aaa", 1);
//list容器中的数据类型为Myclass
list<Myclass> l1;

2-3， 其他创建方式

//通过拷贝构造创建
list<Myclass> l2(l1);
//通过迭代器区间方式创建
list<Myclass> l3(l1.begin(), l1.end());
//list容器中的元素为5个m1
list<Myclass> l4(5, m1);

3， 操作list

3-1， 赋值

通过**list<数据类型> 对象名2 = 对象名1，**进行赋值

list<Myclass> l1;
list<Myclass> l2 = l1;

3-2， 添加元素

3-2-1， 添加元素(assign)

assign是用新的元素替换原来list的元素

3-2-1-1， 标准数据类型

//l1中分配5个字符串对象aaa
l1.assign(5, "aaa");
//l1中用3个字符串bbb， 替换上面的5个aaa
l1.assign(3, "bbb");

3-2-1-2， 自定义数据类型

Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
list<Myclass> l1;
//l1中的元素为5个m1对象
l1.assign(5, m1);
//l1的元素被替换为5个m2对象替换
l1.assign(5, m2);

3-2-2， 添加元素(insert)

insert是向list指定位置 ， 添加元素， 支持一次添加多个元素

3-2-2-1， 标准数据类型

//在l1.begin()迭代器指向位置， 插入元素aaa
l1.insert(l1.begin(), "aaa");
//在l1.begin()迭代器指向位置， 插入3个字符串bbb
l1.insert(l1.begin(), 3, "bbb");
//在l1.begin()迭代器指向位置， 插入区间：l1.begin(), l1.end()指向的元素
l1.insert(l1.begin(), l1.begin(), l1.end());

3-2-2-2， 自定义数据类型

Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
list<Myclass> l1;
//在l1.begin()迭代器指向位置， 插入元素m1
l1.insert(l1.begin(), m1);
//在l1.begin()迭代器指向位置， 插入3个m2
l1.insert(l1.begin(), 3, m2);
//在l1.begin()迭代器指向位置， 插入区间：l1.begin(), l1.end()指向的元素
l1.insert(l1.begin(), l1.begin(), l1.end());

3-2-3， 添加元素(push_back | push_front)

push_back 是在尾部 插入元素， push_front 是在头部 插入元素， 两者都只能单个添加

3-2-3-1， 标准数据类型

//在头部插入字符串元素bbb
l1.push_front("bbb");
//在尾部插入字符串元素aaa
l1.push_back("aaa");

3-2-3-2， 自定义数据类型

Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
list<Myclass> l1;
//在头部插入元素m1
l1.push_front(m1);
//在尾部插入元素m1
l1.push_back(m2);

3-3， 查询

由于list的数据不在连续内存空间上， 所以不支持索引访问

通过对象名.front() 获取首 元素**， 对象名.back()** ， 获取尾 元素， 通过迭代器， 获取指定元素

3-3-1， 标准数据类型

//获取首元素
cout << l1.front() << endl;
//获取尾元素
cout << l1.back() << endl;
//通过迭代器获取元素
list<string>::iterator it = l1.begin();
it++;
it++;
cout << *it << endl;

3-3-2， 自定义数据类型

Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
list<Myclass> l1;
//在头部插入字符串元素bbb
l1.push_front(m1);
//在尾部插入字符串元素aaa
l1.push_back(m2);
//获取首元素
cout << l1.front().m_name << " " << l1.front().m_age << endl;
//获取尾元素
cout << l1.back().m_name << " " << l1.back().m_age << endl;
//通过迭代器获取
list<Myclass>::iterator it = l1.begin();
it++;
cout << it->m_name << " " << it->m_age << endl;

3-4， 获取长度(size)

通过对象名.size()， 获取list的长度

cout << l1.size() << endl;

3-5， 设置长度(resize)

通过对象名.resize()， 设置list的长度

//设置list的长度为5
l1.resize(5);
//设置list的长度为10, 多余为用m1填充
l1.resize(10, m1);

3-6， 判断是否为空(empty)

通过对象名.empty()， 判断list是否为空， 为空返回1， 不为空返回0；

cout << l1.empty() << endl;

3-7， 删除元素

3-7-1， 头删(pop_front)

通过对象名.pop_front()， 删除list的头部元素

//删除deque中的首元素
l1.pop_front();

3-7-2， 尾删(pop_back)

通过对象名.pop_back()， 删除list的尾部元素

//删除deque中的尾元素
l1.pop_back();

3-7-3， 指定元素删除(erase)

通过对象名.erase(迭代器名称)， 删除迭代器指向的元素

//删除指定的元素
l1.erase(d.begin());
list<Myclass>::iterator it;
it++;
l1.erase(it);

3-8， 清空(clear)

通过对象名.clear()， 删除迭代器指向的元素

//通过迭代器指定区间进行清空
l1.erase(l1.begin(), l1.end());
//清空元素
l1.clear()

3-9， 排序(sort)

list<string> l1;
l1.push_back("ddd");
l1.push_back("aaa");
l1.push_back("ccc");
l1.push_back("bbb");
l1.sort();

3-10， 交换元素(swap)

通过对象名1.swap(对象名2) ， 可交换两个list中的元素， 元素类型需要一致

l1.swap(l2);

3-11， 翻转

通过对象名.reverse()， 可翻转list中的元素

l1.reverse();