vector容器

vector声明与迭代

函数原型：

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

//容器构造
void test01()
{//默认构造方式1vector<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个100vector<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()
{//默认构造方式1vector<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个100v4.assign(10, 100);printVector(v4);
}

vector容量和大小

函数原型：

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

//容器构造
void test01()
{//默认构造方式1vector<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;}elsecout << "v1不为空" << endl;//重新指定大小v1.resize(15);//利用重载的版本指定默认填充值，参数2printVector(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()
{//默认构造方式1vector<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个1000v1.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()
{//默认构造方式1vector<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()
{//默认构造方式1vector<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;//默认构造方式1vector<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()
{//方式1string str1;str1 = "hellow world";cout << "ST1: " << str1 << endl;//方式2string str2;str2 = str1;cout << "ST2: " << str2 << endl;//方式3,第一个参数为个数，第二个参数为需要重复的字符string str3;str3 = 'a';cout << "ST3: " << str3 << endl;//方式4string 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()
{//方式1string str1 = "我";str1 += "爱玩游戏";//方式2str1 += ':';cout << str1 << endl;//方式3string str2 = "LOL DNF";str1 += str2;cout << str1 << endl;//方式4string 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";//查到返回响应位置，没找到返回-1int 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;//修改单个字符,方式1str[0] = 'x';cout << str << endl;//修改单个字符，方式2str.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个100deque<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个100deque<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个10000d2.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~100d.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);//赋值方式1list<int>L2;L2 = L1;//operator=赋值printList(L2);//赋值方式2list<int>L3;L3.assign(L2.begin(), L2.end());printList(L3);//赋值方式3list<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要么是1int 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

C++之STL-vector-string-list-deque-queue-map-文件操作相关推荐

programming review (c++): (1)vector, linked list, stack, queue, map, string, bit manipulation
编程题常用知识点的review. most important: 想好(1)详尽步骤(2)边界特例,再开始写代码. I.vector #include <iostream> //0.头文件 ...
STL标准模板库中的vector、string、deque、stack、list、set和map的详细介绍——C++学习记录01
文章目录: 1.vector 1.1 遍历方式 1.2 构造函数 1.3 容量大小问题 1.4 插入和删除 1.5 存取值 1.6 交换两个vectot的元素 1.7 预定义存储空间 2.string ...
C++ STL: 超详细容器 deque 以及适配器queue 和 stack 源码分析
文章目录前言 deque 实现 deque类 _Deque_iterator 类 deque 的元素插入 insert函数 deque如何模拟空间连续 queue 实现 stack 的实现前言 C ...
STL中vector、list、deque和map的区别
vector 向量相当于一个数组在内存中分配一块连续的内存空间进行存储.支持不指定vector大小的存储.STL内部实现时,首先分配一个非常大的内存空间预备进行存储,即capacituy( ...
顺序容器（vector、list、string、deque、forward_list）及迭代器、容器适配器
文章目录概述所有容器都支持的操作迭代器迭代器支持的操作迭代器支持的算术运算容器类型 size_type iterator 和 const_iterator 容器定义和初始化拷贝初始化顺 ...
c++之STl容器-string
目录容器的分类 string string的概念 string的初始化 string的遍历 string的一些基本操作 char*类型和string类型互转字符串的连接字符串的查找和替换 str ...
c++ vector 先进先出_C++ STL Vector(容器)学习
本文参考博客链接及书籍: 侯捷老师的<STL 源码剖析> 在C++标准库中,STL容器是一些常用数据结构的实现,比如数组.链表.树.栈.队列.散列表.集合.映射表等,可以分为序列式(seq ...
STL库：stack和queue
STL库:stack和queue 文章目录 STL库:stack和queue 1.STL库中stack的官方介绍 2.stack的常用接口 3.stack的模拟实现 4.STL库中queue的官方介绍 ...
STL vector的几种清空容器（删除）办法
1.为什么需要主动释放vector内存来自 <https://blog.csdn.net/hellokandy/article/details/78500067> vector其中一个特 ...
C++STL之string (转)
在学习c++STL中的string,在这里做个笔记,以供自己以后翻阅和初学者参考. 1:string对象的定义和初始化以及读写 string s1; 默认构造函数,s1为空串 string ...

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

vector容器

vector声明与迭代

vector赋值

vector容量和大小

vector的插和删除

vector数据读取

vector互换容器

vector预留空间

vector存放自定义类型

容器嵌套容器

字符串

string构造函数

string的赋值操作

string字符串拼接

字符串查找和替换

string字符串比较

string字符存取

string插入和删除

string子串

deque容器

deque构造函数

deque容器赋值操作

deque大小操作

deque插入和删除

两端插入操作

指定位置操作

deque数据存取

deque排序

string vector deque练习案例

stack容器

queue容器

list链表容器

list赋值和交换

list大小操作

list插入和删除

list数据存取

list反转和排序

map容器

map容器大小以及交换

map插入和删除

map查找和统计

map容器的排序

文件操作

读文件

二进制文件

二进制读文件

C++之STL-vector-string-list-deque-queue-map-文件操作相关推荐

最新文章

热门文章