C++之STL-vector-string-list-deque-queue-map-文件操作

最新推荐文章于 2022-08-29 21:41:20 发布

Mic_hu

最新推荐文章于 2022-08-29 21:41:20 发布

阅读量284

点赞数

分类专栏： C++学习文章标签： c++ 数据结构

本文链接：https://blog.csdn.net/qq_33346150/article/details/109806934

版权

C++学习专栏收录该内容

12 篇文章 1 订阅

订阅专栏

vector容器

vector声明与迭代

在这里插入图片描述
函数原型：

vector v;//采用模板实现类实现，默认构造函数
vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身
vector(n, elem);//构造函数将n个elem拷贝给本身
vector(const vetor &vec);//拷贝构造函数

//容器构造
void test01()
{
	//默认构造方式1
	vector<int> v1;//默认构造，无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	//方式2：通过区间的方式构造
	vector<int>v2(v1.begin(), v1.end());
	printVector(v2);
	//方式3： n个element的方式构造
	//10个100
	vector<int>v3(10, 100);
	printVector(v3);
	//方式4：拷贝构造
	vector<int>v4(v3);
	printVector(v4);
}

//vector容器内置数据类型
void test01()
{
	vector<int> v;

	//向容器插入数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	//通过迭代器访问容器中的数据
	/*vector<int>::iterator itBegin = v.begin();//起始迭代器。指向容器容器第一个元素
	vector<int>::iterator itEnd = v.end(); // 指向最后一个元素的下一个
	while (itBegin != itEnd)
	{
		cout << *itBegin << endl;
		itBegin++;
	}*/
	//第二种遍历方式
	/*for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << endl;
	}*/
	//第三种迭代方式
	for_each(v.begin(), v.end(), myPrint);

}

vector赋值

vector赋值的四种方式

//容器构造
void test01()
{
	//默认构造方式1
	vector<int> v1;//默认构造，无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	//方式1：赋值
	vector<int>v2;
	v2 = v1;
	printVector(v2);
	//方式2：assign 区间为前闭后开
	vector<int> v3;
	v3.assign(v1.begin(), v1.end());
	printVector(v3);
	//方式4：n个element方式
	vector<int> v4;
	//10个100
	v4.assign(10, 100);
		printVector(v4);
}

vector容量和大小

函数原型：

enpty();//判断容器是否为空
capacity();//容的容积
size();//返回容器的元素怒个数
resize(int num)//重新指定容器的长度num, 若容器变长，则以默值填充新位置。
若容器变短，则末尾超出容器长度的元素被删除
resize(int num, elem);//重新指定容器的长度num,若容器变长，则以elem值填充新位置
//若容器变短，则末尾超出容器长度的元素被删除

//容器构造
void test01()
{
	//默认构造方式1
	vector<int> v1;//默认构造，无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	cout << "v1大小:" << v1.size() << endl;
	cout << "v1容积:" << v1.capacity() << endl;
	if (v1.empty())
	{
		cout << "v1为空" << endl;
	}
	else
		cout << "v1不为空" << endl;

	//重新指定大小
	v1.resize(15);//利用重载的版本指定默认填充值，参数2
	printVector(v1);//如果重新指定的比原来长了，默认用0填充新的位置
	cout << "v1大小:" << v1.size() << endl;
	cout << "v1容积:" << v1.capacity() << endl;
	v1.resize(5);//如果resize比以前的短了，则超出的部分截断，原来的容器capacity大小不改变，只改变原来内容的长短
	printVector(v1);//如果重新指定的比原来长了，默认用0填充新的位置
	cout << "v1大小:" << v1.size() << endl;
	cout << "v1容积:" << v1.capacity() << endl;
}

vector的插和删除

函数原型：

push_back(ele);//尾部掺入元素ele
pop_back();//删除最后一个元素
insert(const_iterator pos, ele);//迭代器指向位置pos插入元素ele
erase(const_iterator pos);//删除迭代器指向的元素
erase(const_iterator start, const_iterator end);//删除迭代器strart到end之间的元素
clear()//删除容器中的所有元素

//容器构造
void test01()
{
	//默认构造方式1
	vector<int> v1;//默认构造，无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	//尾删除,没有返回值
	v1.pop_back();
	printVector(v1);
	//插入 头部插入数据
	v1.insert(v1.begin(), 100);
	printVector(v1);
	//插入 n个元素, 注意：参数是迭代器
	//插入2个1000
	v1.insert(v1.begin(), 2, 1000);
	printVector(v1);
	//删除， 注意：参数是迭代器
	v1.erase(v1.begin());
	printVector(v1);
	//等效于清空操作
	//clear
	//v1.erase(v1.begin(), v1.end());
	v1.clear();
	if (v1.empty())
	{
		cout << "v1容器为空" << "容积为： " << v1.capacity() << endl;
	}
}

vector数据读取

//容器构造
void test01()
{
	//默认构造方式1
	vector<int> v1;//默认构造，无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	//printVector(v1);
	//方式1：利用[]方式访问数组中的元素
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	cout << endl;
	//方式2：利用at()方法读取容器元素
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1.at(i) << " ";
	}
	cout << endl;
	//方式3：用front()获取第一个元素
	cout << "第一个元素为：" << v1.front() << endl;
	//方式4：获取最后一个元素back()
	cout << "获取最后一个元素： " << v1.back() << endl;
}

vector互换容器

函数原型：
swap(vec)；//将vec与本身的元素互换

//容器构造
void test01()
{
	//默认构造方式1
	vector<int> v1;//默认构造，无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	cout << "交换前" << endl;
	printVector(v1);
	vector<int> v2;
	for (int i = 10; i > 0; i--)
	{
		v2.push_back(i);
	}
	printVector(v2);
	cout << "交换后" << endl;
	v1.swap(v2);
	printVector(v1);
	printVector(v2);
}

//实际应用
//巧用swap可以收纳内存空间
void test02()
{
	vector<int> v;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);
	}
	cout << "v的容量大小：" << v.capacity() << endl;
	cout << "v的数据长度：" << v.size() << endl;
	v.resize(3);
	cout << "v的容量大小：" << v.capacity() << endl;
	cout << "v的数据长度：" << v.size() << endl;
	//巧用swap收缩内存
	vector<int>(v).swap(v);
	cout << "v的容量大小：" << v.capacity() << endl;
	cout << "v的数据长度：" << v.size() << endl;
}

vector预留空间

函数原型：
reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问
减少动态内存分布次数

//容器构造
void test01()
{
	int num = 0;
	int *p = NULL;
	//默认构造方式1
	vector<int> v1;//默认构造，无参构造
	v1.reserve(100000);
	for (int i = 0; i < 100000; i++)
	{
		v1.push_back(i);
		if (p != &v1[0])
		{
			p = &v1[0];
			num++;
		}
	}
	cout << num << endl;
	cout << "容器容量：" << v1.capacity() << endl;
	cout << "容器存储大小：" << v1.size() << endl;
	
}

vector存放自定义类型

//vector容器存放自定义数据类型
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};

void test01()
{
	vector<Person> v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);
	//向容器添加数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	//遍历容器中的数据
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名: " << (*it).m_Name << "年龄: " << (*it).m_Age << endl;
		cout << "姓名: " << it->m_Name << "年龄: " << it->m_Age << endl;
	}
}
//自定义数据类型的指针
void test02()
{
	vector<Person*> v;
	//vector<Person> v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);
	//向容器添加数据
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);
	for (vector<Person*>::iterator it = v.begin(); it < v.end(); it++)
	{
		cout << "姓名: " << (*it)->m_Name << "年龄: " << (*it)->m_Age << endl;
	}

}

容器嵌套容器

void test01()
{
	vector<vector<int>> v;
	//创建小容器
	vector<int>v1;
	vector<int>v2;
	vector<int>v3;
	vector<int>v4;
	//向小容器添加数据
	for (int i = 0; i < 4; i++)
	{
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
		v4.push_back(i + 4);
	}
	//将小容器中插入到大容器中
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);
	for (vector<vector<int>>::iterator it = v.begin(); v.end() != it; it++)
	{
		//(*it)---容器vector<int>
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << *vit << " ";
		}
		cout << endl;
	}
}

字符串

string构造函数

构造函数原型

string(); //创建一个空的字符串例如string str
string(const char* s); //使用字符串初始化
string(const string& str); //使用一个string对象初始化另一个string对象
string(int n, char c); //使用n个字符c初始化

void test01()
{
	string s1;//默认构造
	string s2("hellow world");
	const char * str = "hellow world";
	string s3(s2);
	cout << "S2: " << s2 << endl;
	cout << "S3: " << s3 << endl;

	string s4(10, 'a');
	cout << "S4: " << s4 << endl;
}

string的赋值操作

void test01()
{
	//方式1
	string str1;
	str1 = "hellow world";
	cout << "ST1: " << str1 << endl;
	//方式2
	string str2;
	str2 = str1;
	cout << "ST2: " << str2 << endl;
	//方式3,第一个参数为个数，第二个参数为需要重复的字符
	string str3;
	str3 = 'a';
	cout << "ST3: " << str3 << endl;
	//方式4
	string str4;
	str4.assign("hellow C++");
	cout << "ST4: " << str4 << endl;
	//方式5, 把字符串的前五个字符赋值给参数
	string str5;
	str5.assign("hellow C++", 6);
	cout << "ST5: " << str5 << endl;
	string str6;
	str6.assign(str5);
	cout << "ST6: " << str6 << endl;
	//方式7,第一个参数为个数，第二个参数为需要重复的字符
	string str7;
	str7.assign(10, 't');
	cout << "ST7: " << str7 << endl;
}

string字符串拼接

void test01()
{
	//方式1
	string str1 = "我";
	str1 += "爱玩游戏";
	//方式2
	str1 += ':';
	cout << str1 << endl;
	//方式3
	string str2 = "LOL DNF";
	str1 += str2;
	cout << str1 << endl;
	//方式4
	string str3 = "I";
	str3.append(" love ");
	cout << str3 << endl;
	//方式5,拼接字符串前n个字符串
	str3.append("game abcde", 4);
	cout << str3 << endl;
	//方式5 str2 = "LOL DNF" 截取固定字符
	str3.append(str2, 4, 6);
	cout << str3 << endl;
}

字符串查找和替换

fing查找时从左往右查找
find找到字符串之后返回查找的第一个字符位置，找不到返回-1
replace在替换时，要指定，多少个字符，替换成什么样子的字符


void test01()
{
	string str1 = "abcdefg";
	//查到返回响应位置，没找到返回-1
	int resulr = str1.find("de");
	if (resulr == -1)
	{
		cout << "没找到字符串" << endl;
	}
	else
	{
		cout << "找到字符串，pos = " << resulr << endl;
	}
	//rfind和find区别
	//rfind从右往左查找 fing从左往右查找
	resulr = str1.rfind("de");
	cout << "result = " << resulr << endl;


}
//替换
void test02()
{
	string str1 = "abcdefe";
	//从1号位置起3个字符替换为“1111”
	str1.replace(1, 2, "1111");
	cout << str1 << endl;
}

string字符串比较

描述

字符串之间的比较
比较方式：
字符串是按字符的ASCII进行比较的

void test01()
{
	string str1 = "hellow"
	string str2 = "hellow"
	if(str1.conpare(str2) == 0)
	{
		cout << "str1等于str2" << endl;
	}
	else if (str1.compare(str2)>0)
	{
		cou<<"str1大于str2" << endl;
	}
	else
	{
		cou<< "str1 小于 str2" << endl;
	}
}

string字符存取

对单个字符串读和写操作
1.通过[]方式
2.通过at方式

void test01()
{
	string str = "hellow";
	//1.通过[]方位单个字符串
	for (int i = 0; i < str.size(); i++)
	{
		cout << str[i] << endl;
	}
	//2.通过at方式访问单个字符
	for (int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << " ";
	}
	cout << endl;
	//修改单个字符,方式1
	str[0] = 'x';
	cout << str << endl;
	//修改单个字符，方式2
	str.at(1) = 'D';
	cout << str << endl;
}

string插入和删除

删除和插入起始位置都是从0开始

void test01()
{
	string str = "hellow";
	//插入
	str.insert(1, "111");
	cout << str << endl;
	//删除 从哪个位置删多少个
	str.erase(1, 3);
	cout << str << endl;
}

string子串

函数原型
string substr(int pos = 0; int n = npos) const;//返回由pos开始的n个字符组成的字符串

void test01()
{
	string str = "abcdef";
	string substr = str.substr(1, 3);

	cout << "subStr = " << substr << endl;
}

//使用操作
void test02()
{
	string email = "hellow@sina.com";
	//从邮件中获取用户信息
	int pos = email.find('@');
	string usrName = email.substr(0, pos);
	cout << usrName << endl;
}

deque容器

功能：双端数组，可以对头端进行插入删除操作
deque与vector区别：

vector对头部的插入删除效率低，数据量大，效率低
deque相对而言，对头部的插入删除速度比vector块
vector访问元素时的速度会比deque块这个和两者内部实现有关

deque构造函数

函数原型

deque deqT;//默认构造形式
deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身
deque(n, elem);//构造函数将n个elem拷贝给本身
deque(const deque &deq);//拷贝构造函数

void praintDeque(const deque<int> &de)
{
	for (deque<int>::const_iterator it = de.begin(); it != de.end(); it++)
	{
		//*it = 1000;//容器里的数据不可修改
		cout << (*it) << " ";
	} 
	cout << endl;
}

//deque构造函数


//容器构造
void test01()
{
	deque<int>d1;
	//方式1：push_back()
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	praintDeque(d1);
	//方式2：迭代器的方式赋值
	deque<int>d2(d1.begin(), d1.end());
	praintDeque(d2);
	//方式3:10个100
	deque<int>d3(10, 100);
	praintDeque(d3);
	//方式5：拷贝构造
	deque<int>d4(d3);
	praintDeque(d4);
}

deque容器赋值操作

赋值的三种方式


//容器构造
void test01()
{
	deque<int>d1;

	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	praintDeque(d1);
	//方式1：等号方式赋值
	deque<int> d2;
	d2 = d1;
	praintDeque(d2);
	//f方式2：assign赋值
	deque<int>d3;
	d3.assign(d2.begin(), d2.end());
	praintDeque(d3);
	//方式3：10个100
	deque<int>d4;
	d4.assign(10, 100);
	praintDeque(d4);
}

deque大小操作

和vector差别，没有回去容量的方法，deque没有容量显限制
函数原型：
deque.empty();//判断容器是否为空
deque.size();//返回容器中元素的个数
deque.resize(num);//重新指定容器的长度为num,若变长，则以默认的值填充新位置
//如果容器变短。则末尾超出容器疮毒的元素被删除
deque.resize(num, elem);

void test01()
{
	deque<int>d1;

	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	cout << "deque大小：" << d1.size() << endl;
	if (d1.empty())
	{
		cout << "d1为空" << endl;
	}
	else
	{
		cout << "d1不为空" << endl;
		//resize的用法，默认0填充,函数后边添加数字，更改填充方式
		d1.resize(15, 1);
		praintDeque(d1);
		//resize.超出的部分被删除
		d1.resize(5);
		praintDeque(d1);
	}
}

deque插入和删除

两端插入操作

push_back(elem);//在容器尾部添加一个数据
push_front(elem);//在容器头部插入一个数据
pop_back();//删除容器最后一个数据
pop_front();//删除容器第一个数据

指定位置操作

insert(pos, elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置
insert(pos, n, elem);//早pos位置插入n个elem数据，无返回值
insert(pos, beg, end);//在pos位置插入[beg, end)区间的数据，无返回值
clear();//清空容器所有内容
ereas(beg, end);//删除[beg，end)区间数据。返回下一个数据的位置
erase(pos)；//删除pos位置的数据，返回下一个数据的位置
注意：插入和删除都是迭代器的输入

void test01()
{
	deque<int>d1;
	//尾插
	d1.push_back(10);
	d1.push_back(20);
	//头插
	d1.push_front(100);
	d1.push_front(200);
	printDeque(d1);
	cout << d1.size() << endl;
	//尾删
	d1.pop_back();
	printDeque(d1);
	//头删除
	d1.pop_front();
	printDeque(d1);
}
void test02()
{
	deque<int>d2;
	d2.push_back(10);
	d2.push_back(20);
	d2.push_front(100);
	d2.push_front(200);
	printDeque(d2);
	//方式1：insert插入
	d2.insert(d2.begin(), 1000);
	printDeque(d2);
	//方式2：insert插入2个10000
	d2.insert(d2.begin(), 2, 10000);
	printDeque(d2);
	//方式3：按照区间进行插入
	deque<int>d1;
	d1.push_back(1);
	d1.push_back(2);
	d1.push_back(3);

	d2.insert(d2.begin(), d1.begin(), d1.end());
	printDeque(d2);
}

void test03()
{
	deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(100);
	d1.push_front(200);
	//方式1：删除
	deque<int>::iterator it = d1.begin();
	it++;
	d1.erase(it);
	printDeque(d1);
	//方式2：按区间方式删除
	//d1.erase(d1.begin(), d1.end());
	//方式3：清空
	d1.clear();
	if (d1.empty())
	{
		cout << "容器为空" << endl;
	}

}

deque数据存取

函数原型:
at(int idx)l//返回索引idx所指的数据
operator[];//返回索引idx所指的数据
front();//返回容器中第一个数据元素
back();//返回容器最后一个元素

void test01()
{
	deque<int>d1;
	//尾插
	d1.push_back(10);
	d1.push_back(20);
	//头插
	d1.push_front(100);
	d1.push_front(200);
	//方式1：[]方式访问
	cout << "deque大小:" << d1.size() << endl;
	for (int i = 0; i < d1.size(); i++)
	{
		cout << d1[i] << " ";
	}
	cout << endl;
	//方式2：通过at的方式
	for (int i = 0; i < d1.size(); i++)
	{
		cout << d1.at(i) << " ";
	}
	cout << endl;
	//方式3：用front的方式访问第一个元素
	cout << "第一个元素" << d1.front() << endl;
	//方式4：访问最后一个元素
	cout << "最后一个元素： " << d1.back() << endl;
}

deque排序

sort(iterator beg, iterator end)//对beg和end区间元素进行排序

void test01()
{
	deque<int>d1;
	//尾插
	d1.push_back(10);
	d1.push_back(20);
	d1.push_back(30);
	//头插
	d1.push_front(100);
	d1.push_front(200);
	d1.push_front(300);
	printDeque(d1);
	sort(d1.begin(), d1.end());
	cout << "排序后" << endl;
	printDeque(d1);
}

string vector deque练习案例

评委打分案例，去除最高分和最低分

#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<ctime>
#include<deque>
using namespace std;


class Person {
public:
	Person(string name, int score)
	{
		this->m_Name = name;
		this->m_Scoer = score;
	}

	string m_Name;
	int m_Scoer;

};
void createPerson(vector<Person>&v)
{
	string nameSeed = "ABCDE";

	for (int i = 0; i < 5; i++)
	{
		string name = "选手";
		name += nameSeed[i];
		int score = 0;
		Person p(name, score);
		//将创建的person对象 放入容器中
		v.push_back(p);
	}
}
//2.打分
void setScore(vector<Person>&v)
{
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		deque<int>d;
		for (int i = 0; i < 10; i++)
		{
			int score = rand() % 41 + 60;//60~100
			d.push_back(score);
		}
		/*cout << "选手：" << it->m_Name << "打分： " << endl;
		for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
		{
			cout << *dit << " ";
		}
		cout << endl;*/
		//排序
		sort(d.begin(), d.end());
		//去除最高分和最低分
		d.pop_back();
		d.pop_front();
		//取平均分
		int sum = 0;
		for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
		{
			sum += *dit;//累加每个评委的分数
		}
		int avg = sum / d.size();
		//将评分分配到学生上
		it->m_Scoer = avg;
	}
}
void showScore(vector<Person>&v)
{
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "学生姓名：" << it->m_Name << "分数：" << it->m_Scoer << endl;
	}
}

int main()
{
	//随机种子
	srand((unsigned int)time(NULL));
	//1.创建五名选手
	vector<Person>v;//存放选手容器
	createPerson(v);
	//测试
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名： " << (*it).m_Name << "分数: " << (*it).m_Scoer << endl;
	}
	//2.给5名选手打分
	setScore(v);
	//显示得分
	showScore(v);
	

	system("pause");
	return 0;
}

stack容器

在这里插入图片描述
构造函数:

stack stk;//stack采用模板类实现，stack对象的默认构造形式
stack(const stack &stk);//拷贝构造函数
赋值操作:
stack &opertaor=(const stack &stk);//重载等号操作
数据存取:
push(elem);//向栈顶添加元素
pop();//从栈顶移除第一个元素
top();//返回栈顶元素
大小操作:
empty();//判断堆栈是否为空
size();//返回栈的大小

void test01()
{
	//特点:先进后出的数据结构
	stack<int>s;
	//入栈
	s.push(10);
	s.push(20);
	s.push(30);
	s.push(40);
	//栈不为空，查看栈顶，并执行出栈操作
	while (!s.empty())
	{
		cout << s.top() << " ";
		cout << endl;
		//出栈操作
		cout << "栈的大小：" << s.size() << endl;
		s.pop();
	}
}

queue容器

先进先出，没有遍历的行为。
在这里插入图片描述
常用接口：
构造函数
queue que;//queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que);//拷贝构造函数
赋值操作
queue& operator=(const queue &que);//重载等号操作
数据存储：
push(elem);//往队尾添加元素
pop();//从队头移除一个元素
back();//返回一个元素
front();//返回第一个元素
大小操作
empty();//判断堆栈是否为空
size();//返回堆栈大小

//队列queue
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
void test01()
{
	//创建队列
	queue<Person>q;
	//准备数据
	Person p1("唐僧", 30);
	Person p2("孙悟空", 1000);
	Person p3("猪八戒", 900);
	Person p4("沙僧", 800);
	//入队
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);
	//只要队列不为空，查看队头，查看队尾，出队
	while (!q.empty())
	{
		cout << "队头元素--姓名: " << q.front().m_Name << "年龄： " << q.front().m_Age << endl;
		//查看队尾
		cout << "队尾元素---姓名：" << q.back().m_Name << "年龄： " << q.back().m_Age << endl;
		q.pop();
	}
	cout << "队列大小：" << q.size() << endl;
}

list链表容器

void printList(const list<int>&L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void tets01()
{
//创建list容器
	list<int>L1;//默认构造
	//添加数据
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1);
	//区间方式构造
	list<int>L2(L1.begin(), L1.end());
	printList(L2);
	//拷贝构造
	list<int>L3(L2);
	printList(L3);
}

list赋值和交换

函数原型
assign(beg, end);//将[beg, end)区间的数据拷贝赋值给本身

void tets01()
{
	//创建list容器
	list<int>L1;//默认构造
	//添加数据
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1);
	//赋值方式1
	list<int>L2;
	L2 = L1;//operator=赋值
	printList(L2);
	//赋值方式2
	list<int>L3;
	L3.assign(L2.begin(), L2.end());
	printList(L3);
	//赋值方式3
	list<int>L4;
	L4.assign(10, 100);
	printList(L4);
}
//交换
void test01()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	list<int>L2;
	L2.assign(10, 100);
	cout << "交换前：" << endl;
	printList(L1);
	printList(L2);
	L1.swap(L2);
	cout << "交换后" << endl;
	printList(L1);
	printList(L2);
	cout << "L1长度：" << L1.size() << endl;
}

list大小操作

函数原型
size();//返回容器汇总元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度num,若容器变长，则以默认值填充新位置
//如果容器变短，则末尾超出容器长度元素被删除
resize(num, elem);

void tets01()
{
	//创建list容器
	list<int>L1;//默认构造
	//添加数据
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1);
	//判断容器是否为空
	if (L1.empty())
	{
		cout << "L1为空" << endl;
	}
	else
	{
		cout << "L1不为空" << endl;
		cout << "L1的元素个数：" << L1.size() << endl;

	}
	//重新指定大小
	L1.resize(10,10000);
	printList(L1);
}

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值匹配的元素

list数据存取

不能跳跃式访问
函数原型
front();//返回第一个元素
back();//返回最后一个元素

void tets01()
{
	//创建list容器
	list<int>L1;//默认构造
	//添加数据
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	//list[0]不可用[]访问list容器中的元素
	//L1.at(0)你可以用at方式访问list容器中的元素
	//原因是list本质是链表，不是用连续线性空间数据，迭代器不支持随机访问
	cout << "第一个元素:" << L1.front() << endl;
	cout << "最后一个元素：" << L1.back() << endl;
	//验证迭代器是不支持随机访问
	list<int>::iterator it = L1.begin();
	it++;//支持双向
	it--;
	//不支持随机访问
}

list反转和排序

函数原型：
reverse();//反转链表
sort();//链表排序

//list降序排序声明函数
bool myCompare(int v1, int v2)
{
	//降序 就让第一个数>第二个数
	return v1 > v2;
}

void tets01()
{
	//创建list容器
	list<int>L1;//默认构造
	//添加数据
	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(30);
	L1.push_back(50);
	L1.push_back(40);
	printList(L1);
	//链表反转操作
	L1.reverse();
	printList(L1);
	//链表排序
	L1.sort(myCompare);
	printList(L1);
	//所有不支持随机访问的迭代器的容器，不可以用标准算法
	//sort(L1.begin(), L1.end());
	//printList(L1);
}

map容器

赋值和构造基本操作

void printMap(map<int, int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key=" << (*it).first << "value= " << it->second << endl;
	}
}

//map容器赋值
void test01()
{
	//创建容器
	map<int, int> m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(4, 40));
	printMap(m);

	//拷贝构造
	map<int, int>m2(m);
	printMap(m2);
	//赋值
	map<int, int>m3;
	m3 = m2;
	printMap(m3);
}

map容器大小以及交换

函数原型
size();//返回容器中的元素个数
empty();//判断容器是否为空
seap(st);//交换两个集合容器

void printMap(map<int, int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key=" << (*it).first << "value= " << it->second << endl;
	}
}
//map容器赋值
void test01()
{
	//创建容器
	map<int, int> m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(4, 40));
	cout << "map大小：" << m.size() << endl;
	map<int, int>m1;
	m1.insert(pair<int, int>(20, 30));
	m.swap(m1);
	printMap(m);
	printMap(m1); 
}

map插入和删除

insert(elem);//在容器中插入元素
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg, end);//删除区间[beg, end)的所有元素，返回下一个元素的迭代器
erase(key);//删除容器汇总值为key的元素

//map容器赋值
void test01()
{
	//创建容器
	map<int, int> m;
	m.insert(pair<int, int>(1, 10));
	//第二种创建方式
	m.insert(make_pair(2, 20));
	//第三种
	m.insert(map<int, int>::value_type(3, 30));
	//第四种
	m[4] = 40;
	cout << "map大小：" << m.size() << endl;
	printMap(m);
	//可以用[]访问，通过key访问value
	//删除
	m.erase(m.begin());
	printMap(m);
	//第二种删除,按照key删除
	m.erase(3);
	printMap(m);
	//第三种按照区间删除,类似m.clear()
	m.erase(m.begin(), m.end());
	printMap(m);
}

map查找和统计

find(key);//查找key是否存在，返回该健的元素的迭代器，若不存在，返回set.end()
count(key);//统计查找的元素个体

//map容器赋值
void test01()
{
	//创建容器
	map<int, int> m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	//find方法返回的是迭代器
	map<int, int>::iterator pos = m.find(3);
	if (pos != m.end())
	{
		cout << "查找了元素key=" << (*pos).first << "value=" << pos->second << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}
	//统计,count统计而言，结果要么是0要么是1
	int num = m.count(3);
	cout << "num= " << num << endl;
}

map容器的排序

class MyCompare
{
public:
	bool operator()(int v1, int v2)
	{
		//降序
		return v1 > v2;
	}
};
void printMap(map<int, int, MyCompare>&m)
{
	for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key=" << (*it).first << "value= " << it->second << endl;
	}
	cout << endl;
}

//map容器赋值
void test01()
{
	//创建容器
	map<int, int, MyCompare> m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 40));
	m.insert(pair<int, int>(4, 50));
	m.insert(pair<int, int>(5, 60));
	printMap(m);
}

文件操作

操作文件三大类：
1.ofstream:写操作，即输出到文件
2.ifstream:读操作，从存储文件中读取
3.fstream:读写操作
写文件步骤
1.包含头文件
#include
2.创建六对象
ofstream ofs;
3.打开文件
ofs.open(“文件路径”，打开方式)
4.写数据
ofs<<“写入数据”
5.关闭文件
ofs.close();
文件打开方式

打开方式	解释
ios::in	为读文件而打开
ios::out	为写文件而打开
ios::ate	初始位置：文件尾
ios::app	追加方式写文件
ios::trunc	如果文件存在先删除，再创建
ios::binary	二进制方式

注意：文件打开方式可以配合使用，利用|操作符
例如：用二进制方式写文件ios::binary|ios::out

#include<iostream>
using namespace std;
#include<fstream>
//文本文件的读写

void test01()
{
	//1.包含头文件

	//2.创建流对象
	ofstream ofs;

	//3.指定打开方式
	ofs.open("test.txt", ios::out);
	//4.写内容
	ofs << "姓名:张三" << endl;
	ofs << "性别:男" << endl;
	ofs << "年龄:18" << endl;
	//关闭文件
	ofs.close();
}

读文件

读文件步骤如下：
1.包含头文件
#include
2.创建流对象
ifstream ifs;
3.打开文件并判断文件是否打开成功
ifs.open(“文件路径”, 打开方式)
4.读数据
四种方式读取
5.关闭文件
ifs.close()
读文件的四种方法

//文本文件 读文件
void test01()
{
	//1.包含头文件

	//2.创建流对象
	ifstream ifs;

	//3。打开文件 并且判断是否打开成功
	ifs.open("test.txt", ios::in);
	if (!ifs.is_open())
	{
		cout << "文件打开失败" << endl;
		return;
	}
	//4。读数据
	//第一种
	/*char buf[1024] = { 0 };
	while (ifs >> buf)
	{
		cout << buf << endl;
	}*/
	//第二种
	/*char buf[1024] = { 0 };
	while (ifs.getline(buf, sizeof(buf)))
	{
		cout << buf << endl;
	}*/
	//第三种方法
	/*string buf;
	while (getline(ifs, buf))
	{
		cout << buf << endl;
	}*/
	//第四种
	char c;
	while ((c = ifs.get()) != EOF)//EOF end of file
	{
		cout << c;
	}
	//5.关闭文件
	ifs.close();
}

二进制文件

二进制方式写文件主要利用流对象调用成员函数write
函数原型：
ostream& write(const char * buffer, int len);

//二进制文件 写文件
class Person
{
public:
	char m_Name[64];//姓名
	int m_Age;//年龄
};
//文本文件 读文件
void test01()
{
	//1、包含头文件
	ofstream ofs;
	//2.创建流对象
	//3.打开文件
	ofs.open("person.txt", ios::binary | ios::out);
	//或者两步合成一步
	//ofstream ofs（"person.txt", ios::binary|ios::out）;
	//4.写入
	Person p = { "张三", 18 };
	ofs.write( (const char *)&p, sizeof(Person));
	//5.关闭文件
	ofs.close();
}

二进制读文件

//二进制文件 写文件
class Person
{
public:
	char m_Name[64];//姓名
	int m_Age;//年龄
};
//文本文件 读文件
void test01()
{
	//1、包含头文件
	ifstream ifs;
	//2.创建流对象
	//3.打开文件,判断文件是否打开成功
	ifs.open("person.txt", ios::binary | ios::in);
	if (!ifs.is_open())
	{
		cout << "文件打开失败" << endl;
		return;
	}
	//或者两步合成一步
	//ofstream ofs（"person.txt", ios::binary|ios::out）;
	//4.读取
	Person p;
	ifs.read((char*)&p, sizeof(Person));
	cout << "姓名：" << p.m_Name << "年龄：" << p.m_Age << endl;
	//5.关闭文件
	ifs.close();
}

参考
[1] https://www.bilibili.com/video/BV1et411b73Z?from=search&seid=13533987695733809760

Mic_hu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++之STL-vector-string-list-deque-queue-map-文件操作

vector声明与迭代//vector容器内置数据类型void test01(){ vector<int> v; //向容器插入数据 v.push_back(10); v.push_back(20); v.push_back(30); v.push_back(40); //通过迭代器访问容器中的数据 /*vector<int>::iterator itBegin = v.begin();//起始迭代器。指向容器容器第一个元素 vector<int&gt
复制链接

扫一扫