C/C++ - 容器list

容器特性

list

容器特性

使用场景

构造函数

默认构造函数

填充构造函数

范围构造函数

复制构造函数

大小函数

函数：size

函数：empty

函数：max_size

增加函数

函数：push_back

函数：push_front

函数：insert

函数：emplace_back

函数：emplace_front

函数：emplace

删除函数

函数：erase

函数：remove

函数：remove_if

函数：clear()

修改函数

使用迭代器

容器特性

list
- C++中的list容器是一个序列容器，它允许在任何位置进行快速的插入和删除操作。list容器底层实现为一个双向链表，因此，它可以高效地进行双向遍历。
容器特性
- 双向链表实现：list的双向链表结构使得它可以从两个方向遍历。
- 数据非连续存储：由于是链表实现，list容器中的元素在内存中是非连续存储的。
- 动态大小：与数组相比，list的大小可以根据需要动态增长或缩减。
- 快速插入和删除：可以在任何位置快速插入或删除元素。
- 不支持随机访问：与向量(vector)不同，list不支持随机访问，即不能使用下标访问元素。
使用场景
- 需要频繁插入和删除元素的场景：当应用需要在数据的任何位置频繁添加或删除元素时，list容器提供了高效的支持。
- 不需要随机访问元素的场景：如果不需要通过下标直接访问元素，而是通过遍历来处理元素，list是一个好选择。
- 需要双向遍历的场景：由于list支持双向遍历，它适合于那些需要从两个方向遍历数据的应用。
- 性能敏感的插入删除操作：在性能要求特别高的情况下，插入和删除操作的开销比连续内存的数据结构（如vector或array）小得多。

构造函数

默认构造函数

函数：默认构造函数
用途：创建一个空的 std::list 容器。
语法：std::list<T> obj;

返回值：无


#include <list>
#include <iostream>

int main() {
    std::list<int> myList;
    std::cout << "Size of the list: " << myList.size() << std::endl;
    return 0;
}

填充构造函数
- 函数：填充构造函数
- 用途：创建一个含有n个相同元素的 std::list 容器。
- 语法：std::list<T> obj(n, value);
- 返回值：无
```
#include <list>
#include <iostream>

int main() {
    std::list<int> myList(4, 100);
    for (int val : myList) std::cout << val << " ";
    return 0;
}
```

范围构造函数

函数：范围构造函数
用途：根据给定范围创建一个新的 std::list 容器。
语法：std::list<T> obj(first, last);

返回值：无


#include <list>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4};
    std::list<int> myList(vec.begin(), vec.end());
    for (int val : myList) std::cout << val << " ";
    return 0;
}

复制构造函数
- 函数：复制构造函数
- 用途：创建一个新的 std::list 容器，它是现有同类型 std::list 容器的副本。
- 语法：std::list<T> obj(anotherList);
- 返回值：无
```
#include <list>
#include <iostream>

int main() {
    std::list<int> originalList = {1, 2, 3, 4};
    std::list<int> myList(originalList);
    for (int val : myList) std::cout << val << " ";
    return 0;
}
```

移动构造函数 (C++11及之后)

函数：移动构造函数
用途：将一个现有的 std::list 容器的内容移动到新的容器中。
语法：std::list<T> obj(std::move(anotherList));

返回值：无


#include <list>
#include <iostream>
#include <utility> // For std::move


int main() {
    std::list<int> originalList = {1, 2, 3, 4};
    std::list<int> myList(std::move(originalList));
    for (int val : myList) std::cout << val << " ";
    std::cout << "Original list size: " << originalList.size() << std::endl;
    return 0;
}

内存布局

大小函数

函数：size
- 用途：返回std::list容器中元素的数量。
- 语法：size_type size() const noexcept;
- 返回值：容器中的元素数量，类型为size_type。

函数：empty
- 用途：检查std::list容器是否为空（即是否包含元素）。
- 语法：bool empty() const noexcept;
- 返回值：如果容器为空，则返回true；否则返回false。
函数：max_size
- 用途：返回容器可能包含的最大元素数量。
- 语法：size_type max_size() const noexcept;
- 返回值：容器可容纳的最大元素数量，类型为size_type。

增加函数

函数：push_back
- 用途：在list的末尾添加一个元素。
- 语法：void push_back(const T& value);
- 返回值：无。
函数：push_front
- 用途：在list的开头添加一个元素。
- 语法：void push_front(const T& value);
- 返回值：无。

函数：insert
- 用途：在list中的指定位置前插入一个或多个元素。
- 语法：
  - 插入单个元素：iterator insert(iterator pos, const T& value);
  - 插入多个相同元素：void insert(iterator pos, size_t count, const T& value);
  - 插入另一个容器中的元素范围：template <class InputIt> void insert(iterator pos, InputIt first, InputIt last);
- 返回值：插入单个元素时，返回新元素的迭代器。插入多个元素时，无返回值。

函数：emplace_back
- 用途：在list的末尾直接构造一个新元素，避免额外的复制或移动操作。
- 语法：template <class... Args> void emplace_back(Args&&... args);
- 返回值：无。

函数：emplace_front
- 用途：在list的开头直接构造一个新元素，避免额外的复制或移动操作。
- 语法：template
- 返回值：无。

函数：emplace
- 用途：在list中的指定位置直接构造一个新元素，避免额外的复制或移动操作。
- 语法：template
- 返回值：指向新插入元素的迭代器。

示例代码

#include <iostream>
#include <list>

class Person
{
public:
	Person(int age): Age(age)
	{
		std::cout << "构造函数" << std::endl;
	}
	Person(const Person& ref):Age(ref.Age)
	{
		std::cout << "拷贝函数" << std::endl;
	}
	Person(Person&& other):Age(other.Age)
	{
		std::cout << "移动函数" << std::endl;
	}

	int Age;
};

int main()
{
	std::list<Person> mlist1;
	mlist1.push_back(1);

	std::list<Person> mlist2;
	mlist2.emplace_back(1);

	return 0;
}

删除函数

函数：erase

用途：删除 list 容器中指定位置或范围内的元素。
语法：
- 单个元素：iterator erase(iterator position);
- 范围内元素：iterator erase(iterator first, iterator last);

返回值：返回一个指向被删除元素之后元素的迭代器。

#include <iostream>
#include <list>
using namespace std;

int main() {
    list<int> myList = {1, 2, 3, 4, 5};

    // 删除单个元素

    auto it = myList.begin();
    advance(it, 2); // 移动到第3个元素

    myList.erase(it);

    // 删除范围内的元素

    auto start = myList.begin();
    auto end = myList.end();
    advance(start, 1); // 起始位置

    advance(end, -1);  // 结束位置

    myList.erase(start, end);

    // 打印剩余元素

    for (int x : myList) {
        cout << x << " ";
    }
    return 0;
}

函数：remove

用途：按值删除 list 容器中所有匹配的元素。
语法：void remove(const T& val);

返回值：无返回值。

#include <iostream>
#include <list>
using namespace std;

int main() {
    list<int> myList = {1, 2, 3, 4, 5, 3};

    // 按值删除所有3

    myList.remove(3);

    // 打印剩余元素

    for (int x : myList) {
        cout << x << " ";
    }
    return 0;
}

函数：remove_if

用途：根据条件删除 list 容器中的元素。
语法：template <class Predicate> void remove_if(Predicate pred);

返回值：无返回值。

#include <iostream>
#include <list>
using namespace std;

bool isOdd(int n) 
{
    return (n % 2) == 1;
}

int main() 
{
    list<int> myList = {1, 2, 3, 4, 5};

    // 删除所有奇数

    myList.remove_if(isOdd);

    // 打印剩余元素

    for (int x : myList) {
        cout << x << " ";
    }
    return 0;
}

函数：clear()

用途：删除 list 容器中的所有元素，容器大小变为 0。
语法：void clear();

返回值：无返回值。

#include <iostream>
#include <list>
using namespace std;

int main() {
    list<int> myList = {1, 2, 3, 4, 5};

    // 删除所有元素

    myList.clear();

    // 容器现在应该是空的

    if (myList.empty()) {
        cout << "List is now empty.";
    }
    return 0;
}

修改函数

使用迭代器

#include <iostream>
#include <list>

class Person
{
public:
	Person(int nage, int nscore) : m_Age(nage), m_Score(nscore) {}
	bool operator==(const Person& ref)
	{
		return this->m_Age == ref.m_Age;
	}
public:
	int m_Age;
	int m_Score;
};

bool CmpPerson(const Person& ref)
{
	return ref.m_Age == 30;
}

int main()
{
	std::list<Person> mlist;
	mlist.emplace_back(18, 90);
	mlist.emplace_back(30, 80);
	mlist.emplace_back(25, 95);

	//修改
	auto iter = mlist.begin();
	(*iter).m_Age = 1;
	(*iter).m_Score = 1;

	//查找
	Person p1(30, 80);
	auto i = std::find(mlist.begin(), mlist.end(), p1);
	auto j = std::find_if(mlist.begin(), mlist.end(), CmpPerson);
	(*i).m_Age = 2;
	(*j).m_Age = 3;

	return 0;
}