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 obj;​​

  • 返回值：无

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

• 填充构造函数

  • 函数：填充构造函数

  • 用途：创建一个含有n个相同元素的 std::list​​ 容器。

  • 语法：std::list obj(n, value);​​

  • 返回值：无

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

• 范围构造函数

  • 函数：范围构造函数

  • 用途：根据给定范围创建一个新的 std::list​​ 容器。

  • 语法：std::list obj(first, last);​​

  • 返回值：无

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

• 复制构造函数

  • 函数：复制构造函数

  • 用途：创建一个新的 std::list​​ 容器，它是现有同类型 std::list​​ 容器的副本。

  • 语法：std::list obj(anotherList);​​

  • 返回值：无

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

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

  • 函数：移动构造函数

  • 用途：将一个现有的 std::list​​ 容器的内容移动到新的容器中。

  • 语法：std::list obj(std::move(anotherList));​​

  • 返回值：无

    
    #include 
    #include 
    #include  // For std::move
    
    
    int main() {
        std::list originalList = {1, 2, 3, 4};
        std::list 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 void insert(iterator pos, InputIt first, InputIt last);​​

  • 返回值：插入单个元素时，返回新元素的迭代器。插入多个元素时，无返回值。

• 函数：emplace_back​

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

• 函数：emplace_front​

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

• 函数：emplace​

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

• 示例代码

  #include 
  #include 
  
  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 mlist1;
  	mlist1.push_back(1);
  
  	std::list mlist2;
  	mlist2.emplace_back(1);
  
  	return 0;
  }
  

删除函数

• 函数：erase​​

  • 用途：删除 list​​ 容器中指定位置或范围内的元素。

  • 语法：

    • 单个元素：iterator erase(iterator position);​​
    • 范围内元素：iterator erase(iterator first, iterator last);​​

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

    #include 
    #include 
    using namespace std;
    
    int main() {
        list 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 
    #include 
    using namespace std;
    
    int main() {
        list myList = {1, 2, 3, 4, 5, 3};
    
        // 按值删除所有3
    
        myList.remove(3);
    
        // 打印剩余元素
    
        for (int x : myList) {
            cout << x << " ";
        }
        return 0;
    }
    

• 函数：remove_if​

  • 用途：根据条件删除 list​​ 容器中的元素。

  • 语法：template void remove_if(Predicate pred);​​

  • 返回值：无返回值。

    #include 
    #include 
    using namespace std;
    
    bool isOdd(int n) 
    {
        return (n % 2) == 1;
    }
    
    int main() 
    {
        list myList = {1, 2, 3, 4, 5};
    
        // 删除所有奇数
    
        myList.remove_if(isOdd);
    
        // 打印剩余元素
    
        for (int x : myList) {
            cout << x << " ";
        }
        return 0;
    }
    

• 函数：clear()​

  • 用途：删除 list​​ 容器中的所有元素，容器大小变为 0。

  • 语法：void clear();​​

  • 返回值：无返回值。

    #include 
    #include 
    using namespace std;
    
    int main() {
        list myList = {1, 2, 3, 4, 5};
    
        // 删除所有元素
    
        myList.clear();
    
        // 容器现在应该是空的
    
        if (myList.empty()) {
            cout << "List is now empty.";
        }
        return 0;
    }
    

修改函数

• 使用迭代器

  #include 
  #include 
  
  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 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;
  }