C++语言 STL容器list总结

分类：C&C++作者：编程之家用户

在使用std::list<>链表时，难免会对数据进行添加删除操作。而遍历链表则有两种方式：通过索引访问，象数组一样处理；通过std::list<>::iterator链表遍历器进行访问

STL 中的list 就是一 双向链表，可高效地进行插入删除元素。

list不支持随机访问。所以没有 at(pos)和operator[]。

list 对象list1,list2 分别有元素list1(1,2,3),list2(4,5,6) 。list< int>::iterator it;

构造，析构

list<Elem> c //创建一个空的list 

list<Elem> c1(c2) //复制另一个同类型元素的list 

list<Elem>c(n) //创建n个元素的list，每个元素值由默认构造函数确定 

list<Elem>c(n,elem) //创建n个元素的list，每个元素的值为elem 

list<Elem>c(begin,end) //由迭代器创建list,迭代区间为[begin,end) 

c.~list();       // 销毁所有元素,释放内存

### 其他###

c.size() //返回容器的元素个数 

c.swap(c2) //将c2和c的元素互换 

c.empty() //判断容器是否为空 

c.max_size() //返回容器中最大数据的数量 

c.resize(num) //重新指定链表的长度 

c.reverse() //反转链表 

c.sort() //对列表进行排序，默认升序，可以自定义回调函数 
//示例 
list 对象L1(4,3,1,4) 
L1.sort( );         // L1(1,4,5) 
L1.sort( greater <int >() ); // L1(5,1) 

c.merge() //合并两个有序列表使之有序 
//示例 
// 升序 
list1.merge(list2); // list1(1,6) list2 现为空 
// 降序 
L1( 3,1),L2(6,4) 
L1.merge(L2,greater <int >() );
// list1(6,1) list2 现为空 

c.splice() 
//对两个链表进行结合( 三个重载函数) 结合后第二个链表清空 


//示例 
list1.splice( ++list1.begin(),list2); 
// list1(1,6,3) list2 为空 
 list1.splice( ++list1.begin(),list2,list2.begin()); 
// list1( 1,3); list2(5,6) 
list1.splice( ++list1.begin(),++list2.begin(),list2.end()); 
//list1( 1,3); list2(4)

### 赋值###

c.assign(begin,end) //将[begin,end)区间中的数据赋值给c 

c.assign(n,Elem) //将n个Elem的拷贝赋值给c 

c.swap(c2) //将c2和c的元素互换

### 数据访问###

c.front() //返回第一个数据 

c.back() //返回最后一个数据 

c.begin() //返回指向第一个元素的迭代器(指针) 

c.end() //返回指向最后一个数据的下一个位置的迭代器(指针) 

c.rbegin() 
//返回逆向队列的第一个数据,也就是返回容器中倒数第一个元素的迭代器 

c.rend() 
//返回指向逆向队列的最后一个数据的下一个位置的迭代器， 
//也就是返回容器中倒数最后一个元素之后的迭代器

### 插入数据###

c.push_back(Elem) //list元素尾部增加一个元素x 

c.push_front(Elem) //list元素首元素钱添加一个元素X 

c.insert(pos,Elem) //在pos位置插入一个Elem拷贝，返回新数据的位置 

c.insert(pos,n,Elem) //在pos位置插入n个Elem数据，无返回值 

c.insert(pos,begin,end)
//在pos位置插入在[begin,end)区间的数据，无返回值

### 删除数据###

c.pop_back() //删除容器尾元素，当且仅当容器不为空  

c.pop_front() //删除容器首元素，当且仅当容器不为空  

c.remove(Elem) //删除容器中所有元素值等于x的元素  

/** 
 remove_if()删除条件满足的元素(会遍历一次链表) 
*/  
void remove_if_test(){  
ShowList(g_list1);  
g_list1.remove_if(myFun);  
ShowList(g_list1);  
}  

c.clear() //删除容器中的所有元素  

c.erase(pos) //删除pos位置的数据，返回下一个数据的位置  

c.erase(begin,end) 
//删除[begin,end)区间的数据，返回下一个数据的位置  

c.unique() //删除相邻重复元素  
//示例  
L1( 1,1)  
L1.unique( );     // L1(1,1)

### 示例###

#include<iostream> 
#include<stdio.h> 
#include<list> 
using namespace std; 
list < int > g_list1; 
list < int > g_list2; 
/** 
 初始化全局列表 
*/ 
void InitList(){ 
// push_back()增加一元素到链表尾 
g_list1.push_back( 1 ); 
g_list1.push_back( 2 ); 
g_list1.push_back( 3 ); 
// push_front()增加一元素到链表头 
g_list2.push_front( 6 ); 
g_list2.push_front( 5 ); 
g_list2.push_front( 4 ); 
} 
/** 
 输出一个链表 
*/ 
void ShowList(list < int >& listTemp){ 
// size()返回链表中元素个数 
cout << listTemp.size() << endl; 

for (list < int > ::iterator it = listTemp.begin();
it != listTemp.end(); ++ it){ 
  cout << * it << ' ' ; 
} 
  cout << endl; 
} 
/** 
 构造函数，空链表 
*/ 
void constructor_test0(){ 
list < int > listTemp; 
cout << listTemp.size() << endl; 
} 
/** 
 构造函数，建一个含三个默认值是0的元素的链表 
*/ 
void constructor_test1(){ 
 list < int > listTemp( 3 ); 
 ShowList(listTemp); 
} 
/** 
 构造函数，建一个含五个元素的链表，值都是1 
*/ 
void constructor_test2(){ 
 list < int > listTemp( 5,1 ); 
 ShowList(listTemp); 
} 
/** 
 构造函数，建一个g_list1的copy链表 
*/ 
void constructor_test3(){ 
 list < int > listTemp(g_list1); 
 ShowList(listTemp); 
} 
/** 
 构造函数，listTemp含g_list1一个区域的元素[_First,_Last) 
*/ 
void constructor_test4(){ 
 list < int > listTemp(g_list1.begin(),g_list1.end()); 
 ShowList(listTemp); 
} 
/** 
 assign()分配值，有两个重载 
 template <class InputIterator> 
 void assign ( InputIterator first,InputIterator last ); 
 void assign ( size_type n,const T& u ); 
*/ 
void assign_test(){ 
 list < int > listTemp( 5,1 ); 
 ShowList(listTemp); 
 listTemp.assign( 4,3 ); 
 ShowList(listTemp); 

 listTemp.assign( ++ g_list1.begin(),g_list1.end()); 
 ShowList(listTemp); 
} 
/** 
 operator= 
*/ 
void operator_equality_test(){ 
 g_list1 = g_list2; 
 ShowList(g_list1); 
 ShowList(g_list2); 
} 
/** 
 front()返回第一个元素的引用 
*/ 
void front_test7(){ 
 cout << g_list1.front() << endl; 
} 
/** 
 back()返回最后一元素的引用 
*/ 
void back_test(){ 
 cout << g_list1.back() << endl; 
} 
/** 
 begin()返回第一个元素的指针(iterator) 
*/ 
void begin_test(){ 
 list < int > ::iterator it1 = g_list1.begin(); 
 cout << *++ it1 << endl; 

 list < int > ::const_iterator it2 = g_list1.begin(); 
 it2 ++ ; 
 // (*it2)++; // *it2 为const 不用修改 
 cout << * it2 << endl; 

} 
/** 
 end()返回 [最后一个元素的下一位置的指针] 
 (list为空时end()= begin()) 
*/ 
void end_test(){ 
list < int > ::iterator it = g_list1.end(); // 注意是：最后一个元素的下一位置的指针 
-- it; 
cout << * it << endl; 
} 
/** 
 rbegin()返回链表最后一元素的后向指针 
*/ 
void rbegin_test(){ 
 list < int > ::reverse_iterator it = g_list1.rbegin(); 
 for (; it != g_list1.rend(); ++ it){ 
 cout << * it << ' ' ; 
} 
 cout << endl; 
} 
/** 
 rend()返回链表第一元素的下一位置的后向指针 
*/ 
void rend_test(){ 
list < int > ::reverse_iterator it = g_list1.rend(); 
-- it; 
cout << * it << endl; 
} 
/** 
 push_back()增加一元素到链表尾 
*/ 
void push_back_test(){ 
ShowList(g_list1); 
g_list1.push_back( 4 ); 
ShowList(g_list1); 
} 
/** 
 push_front()增加一元素到链表头 
*/ 
void push_front_test(){ 
ShowList(g_list1); 
g_list1.push_front( 4 ); 
ShowList(g_list1); 
} 
/** 
 pop_back()删除链表尾的一个元素 
*/ 
void pop_back_test(){ 
ShowList(g_list1); 
cout << endl; 

g_list1.pop_back(); 
ShowList(g_list1); 

} 
/** 
 pop_front()删除链表头的一元素 
*/ 
void pop_front_test(){ 
ShowList(g_list1); 
cout << endl; 

g_list1.pop_front(); 
ShowList(g_list1); 
} 
/** 
 clear()删除所有元素 
*/ 
void clear_test(){ 
ShowList(g_list1); 
g_list1.clear(); 
ShowList(g_list1); 
} 
/** 
 erase()删除一个元素或一个区域的元素(两个重载函数) 
*/ 
void erase_test() 
{ 
ShowList(g_list1); 
g_list1.erase(g_list1.begin()); 
ShowList(g_list1); 

cout << endl; 

ShowList(g_list2); 
g_list2.erase( ++ g_list2.begin(),g_list2.end()); 
ShowList(g_list2); 
} 
/** 
 remove()删除链表中匹配值的元素(匹配元素全部删除) 
*/ 
void remove_test(){ 
ShowList(g_list1); 
g_list1.push_back( 1 ); 
ShowList(g_list1); 

g_list1.remove( 1 ); 
ShowList(g_list1); 
} 

bool myFun( const int & value) { return (value < 2 ); } 
/** 
 remove_if()删除条件满足的元素(会遍历一次链表) 
*/ 
void remove_if_test(){ 
ShowList(g_list1); 
g_list1.remove_if(myFun); 
ShowList(g_list1); 
} 
/** 
 empty()判断是否链表为空 
*/ 
void empty_test() 
{ 
list < int > listTemp; 
if (listTemp.empty()) 
cout << " listTemp为空 " << endl; 
else 
cout << " listTemp不为空 " << endl; 
} 
/** 
 max_size()返回链表最大可能长度:1073741823 
*/ 
void max_size_test(){ 
list < int > ::size_type nMax = g_list1.max_size(); 
cout << nMax << endl; 
} 
/** 
resize()重新定义链表长度(两重载函数)： 
*/ 
void resize_test(){ 
ShowList(g_list1); 
g_list1.resize( 9 ); // 用默认值填补 
ShowList(g_list1); 
cout << endl; 

ShowList(g_list2); 
g_list2.resize( 9,51 ); // 用指定值填补 
ShowList(g_list2); 
} 
/** 
reverse()反转链表 
*/ 
void reverse_test(){ 
ShowList(g_list1); 
g_list1.reverse(); 
ShowList(g_list1); 
} 
/** 
 sort()对链表排序，默认升序(两个重载函数) 
*/ 
void sort_test(){ 
list < int > listTemp; 
listTemp.push_back( 9 ); 
listTemp.push_back( 3 ); 
listTemp.push_back( 5 ); 
listTemp.push_back( 1 ); 
listTemp.push_back( 4 ); 
listTemp.push_back( 3 ); 

ShowList(listTemp); 
listTemp.sort(); 
ShowList(listTemp); 

listTemp.sort(greater < int > ()); 
ShowList(listTemp); 
} 
/** 
 merge()合并两个升序序链表并使之成为另一个升序. 
*/ 
void merge_test1(){ 
list < int > listTemp2; 
listTemp2.push_back( 3 ); 
listTemp2.push_back( 4 ); 

list < int > listTemp3; 
listTemp3.push_back( 9 ); 
listTemp3.push_back( 10 ); 

ShowList(listTemp2); 
cout << endl; 
ShowList(listTemp3); 
cout << endl; 

listTemp2.merge(listTemp3); 
ShowList(listTemp2); 
} 

bool myCmp ( int first,int second) 
{ return ( int (first) > int (second) ); } 
/** 
 merge()合并两个降序链表并使之成为另一个降序. 
*/ 
void merge_test2(){ 
list < int > listTemp2; 
listTemp2.push_back( 4 ); 
listTemp2.push_back( 3 ); 

list < int > listTemp3; 
listTemp3.push_back( 10 ); 
listTemp3.push_back( 9 ); 

ShowList(listTemp2); 
cout << endl; 
ShowList(listTemp3); 
cout << endl; 

// listTemp2.merge(listTemp3,greater<int>()); // 第二个参数可以是自己定义的函数如下 
listTemp2.merge(listTemp3,myCmp); 
ShowList(listTemp2); 
} 
/** 
  splice()对两个链表进行结合(三个重载函数),结合后第二个链表清空 
  void splice ( iterator position,list<T,Allocator>& x ); 
  void splice ( iterator position,Allocator>& x,iterator i ); 
  void splice ( iterator position,iterator first,iterator last ); 
*/ 
void splice_test(){ 
list < int > listTemp1(g_list1); 
list < int > listTemp2(g_list2); 

ShowList(listTemp1); 
ShowList(listTemp2); 
cout << endl; 

// 
listTemp1.splice( ++ listTemp1.begin(),listTemp2); 
ShowList(listTemp1); 
ShowList(listTemp2); 

// 
listTemp1.assign(g_list1.begin(),g_list1.end()); 
listTemp2.assign(g_list2.begin(),g_list2.end()); 
listTemp1.splice( ++ listTemp1.begin(),listTemp2,++ listTemp2.begin()); 
ShowList(listTemp1); 
ShowList(listTemp2); 

// 
listTemp1.assign(g_list1.begin(),++ listTemp2.begin(),listTemp2.end()); 
ShowList(listTemp1); 
ShowList(listTemp2); 

} 
/** 
  insert()在指定位置插入一个或多个元素(三个重载函数) 
  iterator insert ( iterator position,const T& x ); 
  void insert ( iterator position,size_type n,const T& x ); 
  template <class InputIterator> 
  void insert ( iterator position,InputIterator first,InputIterator last ); 
*/ 
void insert_test(){ 
list < int > listTemp1(g_list1); 
ShowList(listTemp1); 
listTemp1.insert(listTemp1.begin(),51 ); 
ShowList(listTemp1); 
cout << endl; 

list < int > listTemp2(g_list1); 
ShowList(listTemp2); 
listTemp2.insert(listTemp2.begin(),9,51 ); 
ShowList(listTemp2); 
cout << endl; 

list < int > listTemp3(g_list1); 
ShowList(listTemp3); 
listTemp3.insert(listTemp3.begin(),g_list2.begin(),g_list2.end()); 
ShowList(listTemp3); 

} 
/** 
 swap()交换两个链表(两个重载) 
*/ 
void swap_test(){ 
ShowList(g_list1); 
ShowList(g_list2); 
cout << endl; 

g_list1.swap(g_list2); 
ShowList(g_list1); 
ShowList(g_list2); 
} 

bool same_integral_part ( double first,double second) 
{ return ( int (first) == int (second) ); } 
/** 
 unique()删除相邻重复元素 
*/ 
void unique_test(){ 
list < int > listTemp; 
listTemp.push_back( 1 ); 
listTemp.push_back( 1 ); 
listTemp.push_back( 4 ); 
listTemp.push_back( 3 ); 
listTemp.push_back( 5 ); 
listTemp.push_back( 1 ); 
list < int > listTemp2(listTemp); 

ShowList(listTemp); 
listTemp.unique(); // 不会删除不相邻的相同元素 
ShowList(listTemp); 
cout << endl; 

listTemp.sort(); 
ShowList(listTemp); 
listTemp.unique(); 
ShowList(listTemp); 
cout << endl; 

listTemp2.sort(); 
ShowList(listTemp2); 
listTemp2.unique(same_integral_part); 
ShowList(listTemp2); 

} 
/** 
 主函数，列表测试 
*/ 
int main(){ 
InitList(); 
 ShowList(g_list1); 
 ShowList(g_list2); 

 constructor_test0(); 
 constructor_test1(); 
 constructor_test2(); 
 constructor_test3(); 
 constructor_test4(); 
 assign_test(); 
 operator_equality_test(); 
 front_test7(); 
 back_test(); 
 begin_test(); 
 end_test(); 
 rbegin_test(); 
 rend_test(); 
 push_back_test(); 
 push_front_test(); 
 pop_back_test(); 
 pop_front_test(); 
 clear_test(); 
 erase_test(); 
 remove_test(); 
 remove_if_test(); 
 empty_test(); 
 max_size_test(); 
 resize_test(); 
 reverse_test(); 
 sort_test(); 
 merge_test1(); 
 merge_test2(); 
 splice_test(); 
 insert_test(); 
 swap_test(); 
 unique_test(); 
return 0 ; 
}

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

linux GDB 简单用法以及例子
首先GDB是类unix系统下一个优秀的调试工具, 当然作为debug代码的工具, 肯定没有IDE来的直观了. 不过, 命令行自然有命令行的有点, 当你无法是使用IDE时, gdb有时会帮上很大的忙. 下面用1个例子来说明用法吧: 建立1个目录testgdb2 1. 编写c文件test.c可以见到在2
C语言 利用malloc()和realloc()动态分配内存
1. C语言定义1个数组的时候, 必须同时指定它的长度.例如:int a[5]={1,2,3,4,5}; //合法int b[6]; //合法int c[]; //错误 因为没有指定长度但是下面语句是正确, 它隐形定义了数组的长度, 就是赋值元素的个数int d[] ={4,5,6,7,8,9} /
深入解析C++的auto自动类型推导
C++的auto关键字在C+⬑新标准出来之前基本上处于弃用的状态，到C+⬑新标准发布之后，auto关键字被赋予了新的意义，并且功能也变得很强大，此篇文章重点介绍auto关键字的新功能、新用法，以及在C+⬔、C+⬗、C+⬠各版本中对它的使用缺陷和限制不断地修正和增强，当然auto关
const 使用总结
const关键字是用于定义一个不该被改变的对象，它的作用是告诉编译器和其他程序员不允许修改这个对象的值或者状态。当程序员看到使用const修饰的代码时就知道不应该修改对应对象的值，而编译器则会强制实施这个约束，任何违反这个规定的代码会在编译期间报错。它可以用于任何函数或者类之后的全局或namespa
C++单向链表
文章浏览阅读315次。之前用C语言编过链表，这几天突然想用C++编一下链表，搞了大半天才搞出来，所以就赶紧整理一下记录下来，省的万一时间长了找不到代码哈哈。一、链表代码1、Node.h文件代码#pragma onceclass Node{public: int ID; char alph; Node* next; Node(int ID,char alph); ~Node();private:..._if(current->id==id)
C++问题总结之二
文章浏览阅读219次。碰到问题就要记录下来，防止遗忘吧。文章目录一、VS中的命令行参数二、内联函数和宏三、初始化和赋值一、VS中的命令行参数今天在运行代码的时候，碰都了下面的情况： // 解析命令行参数 if (pcl::console::find_argument (argc, argv, "-h") >= 0) { printUsage (argv[0]); return 0; }..._"if (pcl::console::find_argument(argc, argv, "-f") >= 0)怎么输入参数"
C++ ID3决策树
文章浏览阅读1.8k次，点赞11次，收藏37次。因为自己对决策树的机制非常的好奇，所以就研究了一下决策树的ID3算法，在这也做一篇笔记记录一下过程。文章目录一、什么是决策树？二、信息增益2.1信息熵2.1.1定义2.1.2演变2.2信息增益三、ID3算法实现四、小结一、什么是决策树？这个问题是我从一开始就有的疑问，什么是决策树？在看了一些资料之后，因为没有看到书上给出具体定义，所以按照我自己的理解决策树就是通过一个个“决策”而构建的一种树状结构，而且决策树的整个处理机制非常类似于我们人类在面临决策问题时的处理机制，这也可能就是其名字的由来。决_c++id3
C++ 设计模式之策略模式
文章浏览阅读492次。C++ 设计模式之策略模式
C++排序中的谓语使用
文章浏览阅读683次。我也算是个C++的小白，对于C++中的谓语我第一时间就想到了C#中的委托，但两者又不尽相同，所以想写一篇笔记记录一下。文章目录一、什么是谓语？二、使用谓语一、什么是谓语？谓语是一个可调用的表达式，其返回的结果可以作为条件的值，在C++中其实就是向算法传递函数。这和C#中的委托的概念其实是一样的，都是将函数作为参数进行传递。C++标准库中的谓语主要有两类：一元谓语和二元谓语，也就是有的算法只能..._谓语句 c++
C++操作符重载
文章浏览阅读225次。又看了一遍操作符的东西，感觉之前对操作符的理解还停留在很浅的认知上(仅仅会用哈哈)，所以做一下笔记来加深一下印象。文章目录一、为什么会有操作符重载？二、操作符重载作用的对象一、为什么会有操作符重载？如果要回答这个问题，我们其实应该仔细想一下如果没有操作符重载会怎样呢？这其实很容易就联想到了C语言，因为他就没有操作符重载这一说。虽然C语言中没有类class这一概念，但是他有着和类及其相似的结构..._6-6 我的朋友 - c/c++ 操作符重载分数 15作者 海洋饼干叔叔单位 重庆大学实现frie
C++问题总结之一
文章浏览阅读216次。因为之前碰到了很多关于C++上的问题，现在整理并记录一下。文章目录一、引用一、引用在C++中，引用就是给对象起了另一个名字，也就是“对象别名”。感觉和什么东西很相似，仔细一想不就是类型别名“typedef”吗哈哈。它其实是和原对象形成了一种绑定的一种关系，..._vc++6.0报错:returning address of local
C预处理器
文章浏览阅读565次。因为一直好奇预处理器的工作机制，所以就查了查书，做一下自己看完书之后的笔记。文章目录一、预处理器的作用一、预处理器的作用_c语言预处理器作用
C++文件输入/输出
文章浏览阅读1.8k次，点赞3次，收藏10次。最近特别查阅了一下关于C++文件的输入/输出的资料，整理了一下就写一下笔记。文章目录一、什么是流二、什么是缓冲区三、代码实现文件IO3.1 使用文件流对象读取数据3.2重定向一、什么是流当前的计算机具有很多种设备，但是无论是哪种设备都要与数据和信息进行打交道，所以这就牵扯到设备与数据之间的I/O操作。而每种设备又有着不同的特性和操作协议，由于过于复杂，所以我们一般是不会和这些通信细节打交道的..._c++ inpath
C++引用动态链接库
文章浏览阅读4.8k次，点赞6次，收藏29次。因为要使用到C++的动态链接库，所以就特意网上找了一下资料实现了一下。文章目录一、lib与dll文件二、创建dll文件三、dll隐式链接四、显式链接五、小结一、lib与dll文件之前我一直以为动态链接库就是指dll文件，这也是C#给我造成的一种印象，因为在C#中建立的类库文件都是dll文件，而且只要简单引用就可以了，但是C++却并不是这样的，这可能是因为C#隐藏了一些细节的缘故吧。在C++中共有两种库模式，一种是包含lib和dll两种文件，这种情况下其中的lib文件包含了函数所在的dll文件和dl_c++调用动态链接库
C++中的Copy Assignment操作符赋值问题
文章浏览阅读973次。因为遇到了一这个操作符的问题，所以记录一下出现的问题*~*。一、问题描述二、产生原因因为也是第一次出现这个问题，所以就到网上查了一些资料和书籍，现在倒也大概理解这个错误出现的原因了。有时候举个例子可能更容易理解为啥会出现这个错误，就拿一本书中的例子来说一下，如下所示：template<class T> class NamedObject { public: NamedObject(std::string& nameVal, const T objectVal) __copy_assign报错
C语言数据结构之单向链表
C语言中的单向链表可以解决数组和结构体在使用时的内存连续性问题，同时还能动态地调整长度。本文介绍了单向链表的结构和基本操作，并给出了一个简单的示例代码。
‘0‘、“0“、0、‘\0‘的区别
文章浏览阅读2.3k次。区分'0'、"0"、0、''_0和
C语言函数指针详解
文章浏览阅读5.8k次，点赞4次，收藏8次。C语言函数指针详解，微剖本质_c语言指针函数
数组指针和指针数组详解
数组指针和指针数组是代码中常见的定义形式。虽然它们的语法类似，但含义完全不同。对于一维数组而言，数组名即为首元素的地址，不需要取址即可赋值给指针。而对于二维数组，数组名代表首行元素的地址，可以看作是一个指针数组，需要使用取址操作。
C语言纯新手点进来看下，入门常犯错误汇总
文章浏览阅读297次。总结刚入门的新同学C语言编程常见的低级错误
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot