C++ list容器有个函数叫insert（），和push_back()有啥不同？给个程序说一下INSERT的用法，谢谢！
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++ list容器有个函数叫insert（），和push_back()有啥不同？给个程序说一下INSERT的用法，谢谢！相关的知识，希望对你有一定的参考价值。
一、最大的区别在于它们的功能。
1、push_back始终将一个新元素放在vector和insert允许您选择新元素的位置。这会影响性能。
2、vector只有当需要增加内存长度时，元素才会在内存中移动，因为为其分配的内存太少。
3、另一方面insert强制在新元素的选定位置之后移动所有元素。只要给它找个地方就行了。这就是为什么insert可能比push_back高效
二、以下代码示例清晰的展示了他们的区别（代码只能使用英文标点）：
using namespace std;
vector<int> v = 1, 3, 4;
v.insert(next(begin(v)), 2);
v.push_back(5);
// v now contains 1, 2, 3, 4, 5
可以用insert执行与push_back带着v.insert(v.end(), value)
如果都在尾端添加元素的话,应该是一样的,毕竟都没有元素移动（在capacity够的情况下）
扩展资料：
C++ list容器使用方法简单介绍：
1、list使用push_front函数插入，正向遍历list，实现数据先进先出：
2、list使用push_back函数插入，pop_front弹出数据，实现另一种方式控制数据先进先出：
3、list使用begin和end函数使用正向迭代器遍历list数据：
4、两个list使用merge合并，而且支持排序，可自定义排序函数
5、使用rbegin 和rend 函数，反向迭代器遍历list数据：
6、list 使用erase函数删除数据，注意迭代器的重新赋值
注意：erase的使用时，注意迭代器的重新赋值
参考资料来源：百度百科--C++
参考技术A区别：
1、返回类型不同
insert返回类型为iterator或者void，push_back返回类型为void。
2、数据插入位置不同
insert插入位置为指定的插入位置，而push_back将数据插入在list的尾部。
用法
1、insert
（1）iterator insert( iterator pos, const TYPE &val );
pos：指定位置的iterator，val：被插入的数据。
（2）void insert( iterator pos, size_type num, const TYPE &val );
pos：指定位置的iterator，val：数据，num：数据重复次数。
（3）void insert( iterator pos, input_iterator start, input_iterator end );
pos：指定位置的iterator，start：要插入数据的起始iterator，end：要插入数据的结束iterator。
2、push_back
void push_back( const TYPE &val );
val：被插入的数据。
扩展资料
list的使用
1、初始化
（1）生成一个空的 list 容器
std::list<std::string> words
（2）可以创建一个带有给定数量的默认元素的列表
std::list<std::string> sayings 20
（3）生成一个包含给定数量的相同元素的列表
std::list<double> values(50, 3.14159265)
（4）生成一个现有 list 容器的副本
std::list<double> save_values values
2、函数
（1）begin：将迭代器返回到开头。
（2）end：将迭代器返回到最后。
（3）empty：检查容器是否为空。
（4）size：返回当前容器内元素个数。
（5）max_size：返回当前容器能容纳的最大元素数量.
参考技术B insert 放到指定位置，pushback放到最后一位。下面来自c++// inserting into a list
#include <iostream>
#include <list>
#include <vector>
using namespace std;
int main ()
list<int> mylist;
list<int>::iterator it;
// set some initial values:
for (int i=1; i<=5; i++) mylist.push_back(i); // 1 2 3 4 5
it = mylist.begin();
++it; // it points now to number 2 ^
mylist.insert (it,10); // 1 10 2 3 4 5
// "it" still points to number 2 ^
mylist.insert (it,2,20); // 1 10 20 20 2 3 4 5
--it; // it points now to the second 20 ^
vector<int> myvector (2,30);
mylist.insert (it,myvector.begin(),myvector.end());
// 1 10 20 30 30 20 2 3 4 5
// ^
cout << "mylist contains:";
for (it=mylist.begin(); it!=mylist.end(); it++)
cout << " " << *it;
cout << endl;
return 0;
本回答被提问者采纳 参考技术C 从定义上可以看出，insert（）是在指定位置上插入数据，而push_back（）是在list的末尾添加数据，位置不同， 所以这两个函数好区分。你真正应该问的是，不好区分的这两个：push_back（）和append（），这两个都是添加数据的函数，都是在末尾添加数据，这才不好区分
C++ list 容器
C++ list 容器
文章目录
前言
本文包含list基本概念、list构造函数、list赋值和交换、list大小、list插入和删除、list数据存取、list反转和排序。
1. list 基本概念
（1）、功能： 将数据进行链式存储
（2）、链表： （list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的
（3）、链表的组成： 链表由一系列结点组成
（4）、结点的组成： 一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域
（5）、STL中的链表是一个双向循环链表
（6）、由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器
（7）、list的优点：
7.1）、采用动态存储分配，不会造成内存浪费和溢出
7.2）、链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
（8）、list的缺点： 链表灵活，但是空间（指针域） 和 时间（遍历）额外耗费较大
（9）、list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的
list的迭代器，比如begin()，只要插入和删除，不在第一个元素上操作，它的begin()迭代器就不会发生改变（指向的内存地址不变）
vector的迭代器，比如begin()，如果插入和删除多个元素，会重新分配一块内存空间，它的begin()迭代器就会发生改变（指向的内存地址发生改变）
（10）、总结： STL中List和vector是两个最常被使用的容器，各有优缺点
2. list 构造函数
功能描述：
创建list容器
函数原型：
（1）、list<T> lst; list采用模板类实现对象的默认构造形式
（2）、list(beg,end); 构造函数将[beg, end)区间中的元素拷贝给本身
（3）、list(n,elem); 构造函数将n个elem拷贝给本身
（4）、list(const list &lst); 拷贝构造函数
// list链表容器构造函数
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <list> // 使用list栈容器，需包含头文件list
void test()
// 1、默认构造，无参构造
list<int> L;
// 2、将L开始迭代器到结束迭代器之间的元素，赋给L1
list<int> L1(L.begin(), L.end());
// 3、将10个100拷贝给L2
list<int> L2(10, 100);
// 4、拷贝构造
list<int> L3(L);
int main()
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
3. list 赋值和交换
功能描述：
给list容器进行赋值，以及交换list容器
函数原型：
（1）、assign(beg, end); 将[beg, end)区间中的数据拷贝赋值给本身
（2）、assign(n, elem); 将n个elem拷贝赋值给本身
（3）、list& operator=(const list &lst); 重载等号操作符
（4）、swap(lst); 将lst与本身的元素互换。
// list链表容器赋值和交换
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <list> // 使用list栈容器，需包含头文件list
// const对此容器只是只读，不可以修改
void Fun_Print(const list<int>& L) // 使用引用方式&，传入list<int>类型的形参L
// const_iterator只读迭代器；iterator普通迭代器
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
//*it= 100; // 报错，容器中数据不可修改：表达式必须是可修改的左值
cout << *it << " "; // it是个迭代器类型，本是是个指针，需使用*解引用
cout << endl;
void test()
// 创建list容器对象，并且通过模板参数指定容器中存放的数据的类型
list<int> L;
// push_back()向容器中插入数据
L.push_back(30);
L.push_back(80);
L.push_back(40);
L.push_back(20);
Fun_Print(L); // 30 80 40 20
list<int> L1;
// 1、将L容器开始迭代器到结束迭代器之间的数据元素，拷贝给L1容器
L1.assign(L.begin(), L.end());
Fun_Print(L1); // 30 80 40 20
list<int> L2;
// 2、将10个10拷贝给L2容器
L2.assign(10, 10);
Fun_Print(L2); // 10 10 10 10 10 10 10 10 10 10
list<int> L3;
// 3、重载operator=
L3 = L1;
Fun_Print(L3); // 30 80 40 20
cout << "L3和L2互换前 -------------------------------" << endl;
Fun_Print(L2); // 10 10 10 10 10 10 10 10 10 10
Fun_Print(L3); // 30 80 40 20
cout << "L3和L2互换后 -------------------------------" << endl;
// 4、将L2容器中的数据元素与自身L3进行元素互换
L3.swap(L2);
Fun_Print(L2); // 30 80 40 20
Fun_Print(L3); // 10 10 10 10 10 10 10 10 10 10
int main()
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
4. list 大小操作
功能描述：
对list容器的大小进行操作
函数原型：
（1）、empty(); 判断容器是否为空
（2）、size(); 返回容器中元素的个数
（3）、resize(num);
3.1）、重新指定容器的长度为num，若容器变长，则以默认值填充新位置。 （默认填充0）
3.2）、如果容器变短，则末尾超出容器长度的元素被删除。
（4）、resize(num, elem);
4.1）、重新指定容器的长度为num，若容器变长，则以elem值填充新位置。 （指定填充elem）
4.2）、如果容器变短，则末尾超出容器长度的元素被删除
// list链表容器大小
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <list> // 使用list栈容器，需包含头文件list
// const对此容器只是只读，不可以修改
void Fun_Print(const list<int>& L) // 使用引用方式&，传入list<int>类型的形参L
// const_iterator只读迭代器；iterator普通迭代器
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
//*it= 100; // 报错，容器中数据不可修改：表达式必须是可修改的左值
cout << *it << " "; // it是个迭代器类型，本是是个指针，需使用*解引用
cout << endl;
void test()
// 创建list容器对象，并且通过模板参数指定容器中存放的数据的类型
list<int> L;
// push_back()向容器中插入数据
L.push_back(30);
L.push_back(80);
L.push_back(40);
L.push_back(20);
Fun_Print(L); // 30 80 40 20
// 1、empty()判断容器是否为空，返回真，则为空
if (L.empty())
cout << "L链表容器为空" << endl;
else
cout << "L链表容器不为空" << endl;
// 2、size()返回容器数据元素个数
cout << "L链表容器数据元素个数为：" << L.size() << endl;
// 3.1、resize()指定容器长度为10，默认填充0
L.resize(10);
Fun_Print(L); // 30 80 40 20 0 0 0 0 0 0
// 3.2、resize()指定容器长度为5，删除超出容器长度的数据元素
L.resize(5);
Fun_Print(L); // 30 80 40 20 0
// 4.1、resize()指定容器长度为10，默认填充10
L.resize(10, 10);
Fun_Print(L); // 30 80 40 20 0 10 10 10 10 10
// 4.2、resize()指定容器长度为5，删除超出容器长度的数据元素
L.resize(5, 5);
Fun_Print(L); // 30 80 40 20 0
int main()
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
5. list 插入和删除
功能描述：
对list容器进行数据的插入和删除
函数原型：
（1）、push_back(elem); 在容器尾部加入一个元素
（2）、pop_back(); 删除容器中最后一个元素
（3）、push_front(elem); 在容器开头插入一个元素
（4）、pop_front(); 从容器开头移除第一个元素
（5）、insert(pos,elem); 在pos位置插elem元素的拷贝，返回新数据的位置 （pos迭代器）
（6）、insert(pos,n,elem); 在pos位置插入n个elem数据，无返回值
（7）、insert(pos,beg,end); 在pos位置插入[beg,end)区间的数据，无返回值 （pos,beg,end迭代器）
（8）、remove(elem); 删除容器中所有与elem值匹配的元素
（9）、erase(pos); 删除pos位置的数据，返回下一个数据的位置
（10）、erase(beg,end); 删除[beg,end)区间的数据，返回下一个数据的位置
（11）、clear(); 移除容器的所有数据
// list链表容器插入和删除
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <list> // 使用list栈容器，需包含头文件list
// const对此容器只是只读，不可以修改
void Fun_Print(const list<int>& L) // 使用引用方式&，传入list<int>类型的形参L
// const_iterator只读迭代器；iterator普通迭代器
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
//*it= 100; // 报错，容器中数据不可修改：表达式必须是可修改的左值
cout << *it << " "; // it是个迭代器类型，本是是个指针，需使用*解引用
cout << endl;
void test()
// 创建list容器对象，并且通过模板参数指定容器中存放的数据的类型
list<int> L;
// 1、push_back()向容器尾部插入数据元素
L.push_back(30);
L.push_back(80);
Fun_Print(L); // 30 80
// 2、pop_back()删除容器最后一个数据元素
L.pop_back();
Fun_Print(L); // 30
// 3、push_front()像容器头部插入数据元素
L.push_front(90);
L.push_front(60);
Fun_Print(L); // 60 90 30
// 4、push_front()删除容器开头的第一个数据元素
L.pop_front();
Fun_Print(L); // 90 30
// 5、insert()在L开始迭代器的下一个位置后，插入10
list<int>::iterator it = L.begin(); // list<int>::iterator迭代器
L.insert(++it,10); // ++it，先加1
Fun_Print(L); // 90 10 30
// 6、insert()在L开始迭代器的下一个位置后，插入5个0
L.insert(it, 5, 0);
Fun_Print(L); // 90 10 0 0 0 0 0 30
// 7、insert()在L开始迭代器，插入L容器开始迭代器与结束迭代器区间的数据元素
L.insert(L.begin(), L.begin(), L.end());
Fun_Print(L); // 90 10 0 0 0 0 0 30 90 10 0 0 0 0 0 30
// 8、remove()删除L容器中数据元素为0的元素
L.remove(0);
Fun_Print(L); // 90 10 30 90 10 30
// 9、erase()删除L容器开始迭代器中的数据元素
L.erase(L.begin());
Fun_Print(L); // 10 30 90 10 30
// 10、erase()删除L容器开始迭代器到结束迭代器中的数据元素
L.erase(L.begin(), L.end());
Fun_Print(L); //
// 11、clear()清空L容器所有数据元素
L.clear();
Fun_Print(L); //
int main()
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
6. list 数据存取
功能描述：
对list容器中数据进行存取
函数原型：
（1）、front(); 返回第一个元素
（2）、back(); 返回最后一个元素
不支持[]和at：list是链表，链表不是连续的空间，所以不能直接利用[]和at方式访问里面的数据元素，而且list不支持随机访问，跳跃式访问
// list链表容器数据存取
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <list> // 使用list栈容器，需包含头文件list
// const对此容器只是只读，不可以修改
void Fun_Print(const list<int>& L) // 使用引用方式&，传入list<int>类型的形参L
// const_iterator只读迭代器；iterator普通迭代器
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
//*it= 100; // 报错，容器中数据不可修改：表达式必须是可修改的左值
cout << *it << " "; // it是个迭代器类型，本是是个指针，需使用*解引用
cout << endl;
void test()
// 创建list容器对象，并且通过模板参数指定容器中存放的数据的类型
list<int> L;
// push_back()向容器尾部插入数据元素
L.push_back(30);
L.push_back(80);
L.push_back(10);
L.push_back(40);
Fun_Print(L); // 30 80 10 40
// 原因：list本质是链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问的
//cout << L1.at(0) << endl; // 错误 不支持at访问list容器中的数据元素；没有成员"at"
//cout << L1[0] << endl; //错误 不支持[]方式访问list容器中的数据元素；没有与这些操作符匹配的"[]"运算符
// 1、front()返回容器的第一个数据元素
cout << "L容器第一个元素为： " << L.front() << endl; // 30
// 2、back()返回容器的最后一个数据元素
cout << "L容器最后一个元素为： " << L.back() << endl; // 40
// list容器的迭代器是双向迭代器，不支持随机访问
list<int>::iterator it = L.begin();
it++; // 正确，*it++ = 80（第二个数据元素），解引用后是80；支持双向++、--
//it = it + 1; // 错误，不可以跳跃访问，即使是+1（+2、+3...跳着加减）（只能使用++、--）；没有与这些操作符匹配的"+"运算符
// 判断迭代器是否支持随机访问：写一个迭代器list<int>::iterator it，如果支持+/— 1、2、3...，迭代器支持随机访问，否则反之
// 判断迭代器是否支持双向：写一个迭代器list<int>::iterator it，如果支持++、--，没报错，说明支持双向；如果只支持++，使用--报错，则只支持向前
int main()
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
7. list 反转和排序
功能描述：
将容器中的元素反转，以及将容器中的数据进行排序
函数原型：
（1）、reverse(); 反转链表
（2）、sort(); 链表排序
// list链表容器反转和排序
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <list> // 使用list栈容器，需包含头文件list
//#include <algorithm>
// const对此容器只是只读，不可以修改
void Fun_Print(const list<int>& L) // 使用引用方式&，传入list<int>类型的形参L
// const_iterator只读迭代器；iterator普通迭代器
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
//*it= 100; // 报错，容器中数据不可修改：表达式必须是可修改的左值
cout << *it << " "; // it是个迭代器类型，本是是个指针，需使用*解引用
cout << endl;
bool Fun_Sort(int num1, int num2)
// 降序，就让第一个数 > 第二个数
return num1 > num2;
void test()
// 创建list容器对象，并且通过模板参数指定容器中存放的数据的类型
list<int> L;
// push_back()向容器尾部插入数据元素
L.push_back(30);
L.push_back(80);
L.push_back(10);
L.push_back(40);
Fun_Print(L); // 30 80 10 40
// 1、reverse()反转容器的元素
L.reverse();
Fun_Print(L); // 40 10 80 30
// 所有不支持随机访问迭代器的容器，不可以用标准算法
// 不支持随机访问迭代器的容器，内部会提供对应一些算法；使用内部的sort()
//sort(L.begin(), L.end()); // 这个sort()函数是全局函数，需引用algorithm头文件
// 2、sort()默认的排序规则 从小到大，升序；这个sort()函数是成员函数
L.sort();
Fun_Print(L); // 10 30 40 80
// 指定规则，从大到小；参数为一个函数或者一个仿函数
L.sort(Fun_Sort); // Fun_Sort函数
Fun_Print(L); // 10 30 40 80
int main()
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
8. 排序案例：自定义类型排序
案例描述：
将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高
排序规则：
按照年龄进行升序，如果年龄相同按照身高进行降序
// list链表容器反转和排序
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
#include <list> // 使用list栈容器，需包含头文件list
//#include <algorithm>
// const对此容器只是只读，不可以修改
void Fun_Print(const list<int>& L) // 使用引用方式&，传入list<int>类型的形参L
// const_iterator只读迭代器；iterator普通迭代器
for (list<int>::const_iterator it 以上是关于C++ list容器有个函数叫insert（），和push_back()有啥不同？给个程序说一下INSERT的用法，谢谢！的主要内容，如果未能解决你的问题，请参考以下文章