C++ STL容器之 list 初步

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

//3.6.4.1 list构造函数
//list<T> lstT;//list采用采用模板类实现,对象的默认构造形式：
//list(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
//list(n, elem);//构造函数将n个elem拷贝给本身。
//list(const list& lst);//拷贝构造函数。
//3.6.4.2 list数据元素插入和删除操作
//push_back(elem);//在容器尾部加入一个元素
//pop_back();//删除容器中最后一个元素
//push_front(elem);//在容器开头插入一个元素
//pop_front();//从容器开头移除第一个元素
//insert(pos, elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
//insert(pos, n, elem);//在pos位置插入n个elem数据，无返回值。
//insert(pos, beg, end);//在pos位置插入[beg,end)区间的数据，无返回值。
//clear();//移除容器的所有数据
//erase(beg, end);//删除[beg,end)区间的数据，返回下一个数据的位置。
//erase(pos);//删除pos位置的数据，返回下一个数据的位置。
//remove(elem);//删除容器中所有与elem值匹配的元素。
//
//
//3.6.4.3 list大小操作
//size();//返回容器中元素的个数
//empty();//判断容器是否为空
//resize(num);//重新指定容器的长度为num，
//若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
//resize(num, elem);//重新指定容器的长度为num，
//若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
//
//3.6.4.4 list赋值操作
//assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
//assign(n, elem);//将n个elem拷贝赋值给本身。
//list& operator=(const list& lst);//重载等号操作符
//swap(lst);//将lst与本身的元素互换。
//3.6.4.5 list数据的存取
//front();//返回第一个元素。
//back();//返回最后一个元素。
//3.6.4.6 list反转排序
//reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。
//sort(); //list排序

//打印数据
void printInt(list<int>& l) {
	for (list<int>::iterator it = l.begin(); it != l.end(); ++it) {
		cout << *it << endl;
	}
}

void test1() {
	list<int> l;
	for (int i = 0; i < 5; i++) {
		l.push_back(i);
	}
	list<int> l2(10, 88);
	list<int> l3(l2.begin(), l2.end());
	printInt(l2);
	printInt(l3);
	l2.push_back(100);
	//逆序打印
	for (list<int>::reverse_iterator it = l2.rbegin(); it != l2.rend(); ++it) {
		cout << *it << endl;
	}

	// list容器不支持随机访问迭代器
	list<int>::iterator it_1 = l.begin();
	//it_1 = it_1 + 1; 


	// 插入数据  尾插  头插
	list<int> l1;
	l1.push_back(23);
	l1.push_front(233);


	//删除两端数据  尾删 头删
	l1.pop_back();
	l1.pop_front();

	// insert 插入数据
	l1.insert(l1.begin(), 1000);
	

	//remove 删除数据
	l1.remove(1000);

	// list大小
	cout << l1.size() << endl;

}

bool intPare(int a, int b) {
	return a > b;
}

void test2() {
	list<int> l4;
	l4.assign(5, 2);
	//printInt(l4);

	list<int> l5;
	l5.push_back(234);
	l5.push_back(89);
	
	l5.assign(l4.begin(), l4.end()); // 这样l5之前的数据就没有了
	printInt(l5);

	l5.push_front(563);
	// 不支持随机访问迭代器的容器， 都不能用系统排序sort
	// X sort(l5.begin(), l5.end());

	l5.sort();// 默认升序
	printInt(l5);
	
	l5.sort(intPare);  // 自定义排序
	printInt(l5);  

	l5.reverse();// 反转
}




//list 操作自定义类型
class Person {
public:
	Person(string name, int age, int height) {
		this->m_name = name;
		this->m_age = age;
		this->m_height = height;
	}
	bool operator== (const Person &p) {
		return this->m_age == p.m_age && this->m_height == p.m_height && this->m_name == p.m_name;
	}
	string m_name;
	int m_age;
	int m_height;
};

// 年龄降序， 年龄一样的话， 按照身高升序来
bool personParse(Person &p1, Person &p2) {
	if (p1.m_age == p2.m_age) {
		return p1.m_height < p2.m_height;
	}
	return p1.m_age > p2.m_age;
}
void printPerson(const list<Person> &l) {
	for (list<Person>::const_iterator it = l.begin(); it != l.end(); ++it) {
		cout << (*it).m_name << "age is" << (*it).m_age << "height is" << (*it).m_height << endl;
	}
}
void test3() {
	list<Person> l;
	Person p1("A", 50, 172);
	Person p2("B", 23, 182);
	Person p3("C", 78, 178);
	Person p4("D", 29, 183);
	Person p5("E", 29, 180);
	l.push_back(p1);
	l.push_back(p2);
	l.push_back(p3);
	l.push_back(p4);
	l.push_back(p5);
	//l.sort(); 对于自定义数据类型，需要自定义排序规则
	l.sort(personParse);
	printPerson(l);

	// list 容器删除自定义类型数据
	Person  p6("E", 29, 180);
	l.remove(p6);  //？？？ 这里不知道为什么报错，
	// 二进制“==”: 没有找到接受“const _Ty”类型的左操作数的运算符(或没有可接受的转换
	printPerson(l);
}
int main()
{
	//test1();
	//test2();
	test3();
	return 0;
}

list是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
ist容器不仅是一个双向链表，而且还是一个循环的双向链表。

list所支持迭代器为双向迭代器

不支持系统的sort排序， list有自己的sort成员函数

疑惑：？？？ list在删除自定义数据类型是报错
二进制“==”: 没有找到接受“const _Ty”类型的左操作数的运算符(或没有可接受的转换)
这里先记录下， 后期明白了， 再来解决。