c++学习22STL(四) 常用容器3

最新推荐文章于 2024-06-18 19:04:59 发布
最新推荐文章于 2024-06-18 19:04:59 发布
阅读量209 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46066548/article/details/126645577
版权

STL常用容器3

set和multiset容器

基本概念

简介：
所有元素都会在插入时自动排序
本质：
set/multiset 属于关联式容器，底层结构是用二叉树实现的
set和multiset的区别：

  1. set不允许有重复的元素
  2. multiset允许有重复的元素

set的构造与赋值

构造：
  • set st; //默认构造函数
  • set(const set &st) //拷贝构造函数
赋值
  • set& operator=(const set &st); //重载等号运算符
#include<iostream>
using namespace std;
#include<set>
//set的构造函数与赋值

void printSet(set<int>& s) {
	for (set<int>::iterator it = s.begin();it != s.end();it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test01() {
	//默认构造
	set<int> s;
	//插入数据只有insert()方式
	s.insert(10);
	s.insert(30);
	s.insert(50);
	s.insert(40);
	s.insert(10);
	//set中不允许有重复的元素，set在元素插入时，对其进行排序操作，默认升序
	printSet(s);//10 30 40 50
	//拷贝构造
	set<int> s2(s);
	printSet(s2);//10 30 40 50
	set<int> s3 = s2;
	printSet(s3);//10 30 40 50
}

int main() {
	test01();
	system("pause");
	return 0;
}

set容器的大小和交换

函数原型
  • size(); //返回元素的数目
  • empty(); //判断容器是否为空
  • swap(st); //交换2个集合容器
#include<iostream>
using namespace std;
#include<set>
//set的构造函数与赋值
//set的大小和交换
void printSet(set<int>& s) {
	for (set<int>::iterator it = s.begin();it != s.end();it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test02() {
	set<int> s1;
	s1.insert(10);
	s1.insert(30);
	s1.insert(50);
	s1.insert(40);
	s1.insert(10);
	if (!s1.empty()) {
		cout << "s1不为空" << endl;
		printSet(s1);//10 30 40 50
		cout << "s1容器的元素数目" << s1.size() << endl;
	}
	else {
		cout << "s1为空" << endl;
	}
	set<int> s2;
	s2.insert(1);
	s2.insert(3);
	s2.insert(5);
	s2.insert(4);
	s2.insert(1);
	cout << "交换前" << endl;
	printSet(s1);//10 30 40 50
	printSet(s2);//1 3 4 5
	s1.swap(s2);
	cout << "交换后" << endl;
	printSet(s1);//1 3 4 5
	printSet(s2);//10 30 40 50
}
int main() {
	test02();
	system("pause");
	return 0;
}

set容器的插入与删除

函数原型
  • insert(elem); //在容器中插入元素elem
  • clear(); //清除容器中所有元素
  • erase(pos); //删除pos位置上的元素，返回下一个元素的迭代器
  • erase(beg,end); //删除区间[ beg,end ) 的元素，返回下一个元素的迭代器
  • erase(elem); //删除容器中元素为elem的元素
#include<iostream>
using namespace std;
#include<set>
//- insert(elem);    //在容器中插入元素elem
//-clear();             //清除容器中所有元素
//-erase(pos);     //删除pos位置上的元素，返回下一个元素的迭代器
//-erase(beg, end);     //删除区间[ beg,end ) 的元素，返回下一个元素的迭代器
//-erase(elem);      //删除容器中元素为elem的元素
void printSet(set<int> &st) {
	for (set<int>::iterator it = st.begin();it != st.end();it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test01() {

	set<int> s1;
	//插入：
	s1.insert(60);
	s1.insert(20);
	s1.insert(20);
	s1.insert(50);
	s1.insert(30);
	printSet(s1);// 20 30 50 60
	//擦除
	s1.erase(s1.begin());
	printSet(s1);// 30 50 60
	s1.erase(50);
	printSet(s1);
	s1.erase(s1.begin(), --s1.end());
	printSet(s1);
	//清除
	s1.insert(20);
	s1.insert(200);
	printSet(s1);
	s1.clear();
	printSet(s1);
}
int main() {
	test01();
	system("pause");
	return 0;
}

set容器的查找与统计

函数原型
  • find(key); //查找key是否存在，如果存在返回该键对应的元素的迭代器；如果不存在，返回set.end();
  • cout(key); //统计key的对应元素的个数
#include<iostream>
using namespace std;
#include<set>
//- find(key);     //查找key是否存在，如果存在返回该键对应的元素的迭代器；如果不存在，返回set.end();
//- cout(key);   //统计key的对应元素的个数
void test02() {
	set<int> s1;
	s1.insert(60);
	s1.insert(20);
	s1.insert(20);
	s1.insert(50);
	s1.insert(30);
	set<int>::iterator it =s1.find(30);
	if (it != s1.end()) {  //无需担心查找的元素是最后元素的位置，因为end()指向的是最后元素的下一个位置
		cout << "找到元素" << endl;
	}
	else {
		cout << "未找到元素" << endl;
	}
	int num = s1.count(30);
	//对于set而言统计元素的个数要么是0要么是1
	cout << "30在容器s1个个数为" << num << endl;
}
int main() {
	test02();
	system("pause");
	return 0;
}

set和multiset的区别

区别：
  • set不可以插入重复的元素，multiset可以插入重复的元素
  • set插入元素的同时会返回插入结界，表示插入是否成功
  • multiset不会检测数据，因此可以插入重复数据
#include<iostream>
using namespace std;
#include<set>
//set和multiset区别
void test01() {

	set<int> s1;
	pair<set<int>::iterator, bool> res = s1.insert(10);
	if (res.second) {
		cout << "第一次插入成功" << endl;
	}
	else {
		cout << "第一次插入失败" << endl;
	}
	res = s1.insert(10);
	if (res.second) {
		cout << "第二次插入成功" << endl;
	}
	else {
		cout << "第二次插入失败" << endl;
	}

	multiset<int> s2;
	//允许插入重复值，返回值是一个迭代器
	s2.insert(10);
	s2.insert(10);
	cout << "容器s2的元素数目" << s2.size() << endl;//2
	int num1=s1.count(10);
	int num2=s2.count(10);
	cout << "容器s1中元素10的数目为" << num1 << endl;//..... 1
	cout << "容器s2中元素10的数目为" << num2 << endl;//..... 2
}
int main() {
	test01();
	system("pause");
	return 0;
}
pair对组创建

功能描述：
成对出现的数据，利用队组可以返回两个数据
两种创建方式：

  1. pair<type,type> p( value1,value2);
  2. pair<type,type> p = make_pair(value1,value2);
#include<iostream>
using namespace std;
#include<string>
//pair队组的创建
//1. pair<type, type> p(value1, value2);
//2. pair<type, type> p = make_pair(value1, value2);
void test01() {
	pair<string, int> p("张三", 18);
	cout << "姓名：" << p.first << " 年龄：" << p.second << endl;
	pair<string, int> p2 = make_pair("里斯", 34);
	cout << "姓名：" << p2.first << " 年龄：" << p2.second << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

set容器的排序

学习目标：
set容器默认是升序排序，掌握如何改变排序的规则
主要技术点：
利用仿函数，可以改变排序规则

#include<iostream>
using namespace std;
#include<set>
#include<string>
class MyCompare {
public:
	bool operator()(int v1,int v2) const {//新版后面加const修饰,旧版可能不需要,表示在传入过程中不做修改
		return v1 > v2;
	}
};
//内置数据类型
void test01() {
	set<int,MyCompare> s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(50);
	s1.insert(30);
	for ( set<int, MyCompare>::iterator it = s1.begin();it != s1.end();it++) {
		cout << *it << " ";
	}
	cout << endl;
}
class Person {
public:
	Person(string name, int age) {
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};

//自定义数据类型，需要自己指定排序规则
class MyCompare2 {
public:
	bool operator()(Person p1, Person p2) const {
		return p1.m_Age > p2.m_Age;
	}
};
void test02() {
	set<Person,MyCompare2> s1;
	Person p1("张三", 32);
	Person p2("关羽", 42);
	Person p3("刘备", 50);
	Person p4("赵云", 22);
	s1.insert(p1);
	s1.insert(p2);
	s1.insert(p3);
	s1.insert(p4);
	for (set<Person, MyCompare2>::iterator it = s1.begin();it != s1.end();it++) {
		cout << "姓名: " << (*it).m_Name << " 年龄：" << (*it).m_Age << endl;
	}
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

map和multimap容器

基本概念

简介：

  • map中所有的元素都是pair
  • pair中第一个元素为key(键值)，起到索引作用，第二个元素为value(实值)
  • 所有元素都会根据元素的键值自动排序
    本质：
    map和multimap属于关联式容器，底层结构是用二叉树实现的
    优点：
    可以根据key值快速找到value值
    map和multimap的区别：
    map不允许容器中有重复key值元素
    multimap允许容器中有重复的key值元素

map构造和赋值

map构造

  • map<T1,T2> mp; //map默认构造函数
  • map(const map &mp); //map拷贝构造
    赋值
    map &operator=(const map &mp); //重载等号运算符
#include<iostream>
using namespace std;
#include<map>
//map的构造与赋值
// map构造
//-map<T1, T2> mp;   //map默认构造函数
//-map(const map & mp);   //map拷贝构造
//赋值
//map& operator=(const map& mp);   //重载等号运算符

void printMap(map<int, int> &m) {
	for (map<int, int>::iterator it = m.begin();it != m.end();it++) {
		cout << (*it).first << " " << (*it).second << endl;
	}
	cout << endl;
}
void test01() {
	//默认构造
	map<int, int> mp;
	mp.insert(pair<int, int>(1, 10));
	mp.insert(pair<int, int>(3, 20));
	mp.insert(pair<int, int>(4, 30));
	mp.insert(pair<int, int>(2, 40));
	printMap(mp); //通过key自动排序,默认升序
	//拷贝构造
	map<int,int> m2(mp);
	printMap(m2);
	//赋值
	map<int, int> m3;
	m3 = m2;
	printMap(m3);
}
int main() {
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述

map大小和交换

函数原型
  • size(); //返回容器中的数目
  • empty(); //判断容器是否为空
  • swap(map); //交换两个map容器
#include<iostream>
using namespace std;
#include<map>
//map的大小和交换
//- size();      //返回容器中的数目
//- empty();  //判断容器是否为空
//- swap(map); //交换两个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;
	}
	cout << endl;
}
void test01() {
	//默认构造
	map<int, int> mp;
	mp.insert(pair<int, int>(1, 10));
	mp.insert(pair<int, int>(3, 20));
	mp.insert(pair<int, int>(4, 30));
	mp.insert(pair<int, int>(2, 40));
	if (!mp.empty()) {
		cout << "容器mp不为空" << endl;
		cout << "容器的大小为：" << mp.size();
	}
	else {
		cout << "容器为空" << endl;
	}
	map<int, int> m1;
	m1.insert(pair<int, int>(1, 1));
	m1.insert(pair<int, int>(3, 2));
	m1.insert(pair<int, int>(4, 3));
	m1.insert(pair<int, int>(2, 4));
	cout << "交换前：" << endl;
	printMap(mp);
	printMap(m1);
	cout << "交换后： " << endl;
	mp.swap(m1);
	printMap(mp);
	printMap(m1);
}
int main() {
	test01();
	system("pause");
	return 0;
}

map插入和删除

函数原型
  • insert(elem); //在容器中插入元素
  • clear(); //清除所有元素
  • erase(pos); //清除pos位置的元素，返回下一个位置的迭代器
  • erase(beg,end); //清除[ beg,end )区间的元素，返回下一个位置的迭代器
  • erase(key); //删除容器中值为key的元素
#include<iostream>
using namespace std;
#include<map>
//map的插入与删除
//- insert(elem);   //在容器中插入元素
//-clear();    //清除所有元素
//-erase(pos);   //清除pos位置的元素，返回下一个位置的迭代器
//-erase(beg, end);  //清除[ beg,end )区间的元素，返回下一个位置的迭代器
//-erase(key);   //删除容器中值为key的元素
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;
	}
	cout << endl;
}
void test01() {
	map<int, int> mp;
	//插入insert有3种参数写法
	mp.insert(pair<int, int>(1, 10));//1
	mp.insert(make_pair(3, 20));//2
	mp.insert(map<int, int>::value_type(4, 30));//3
	mp[2] = 40;//不建议用[]插入，且在输入时如果key值之前并没有插入，会默认创建一个，值为对应类型的默认值,容易误插
	printMap(mp);
	//清除
	mp.erase(++mp.begin());
	printMap(mp);
	mp.erase(++mp.begin(), --mp.end());
	printMap(mp);
	mp.erase(1);//按照key删除
	printMap(mp);
	mp.clear();
	printMap(mp);
}
int main() {
	test01();
	system("pause");
	return 0;
}

map容器查找和统计

函数原型
  • find(key); //查找key是否存在，如果存在，返回该键的元素的迭代器，如果不存在，返回set.end()
  • cout(key); //统计key的元素个数
#include<iostream>
using namespace std;
#include<map>
//map的查找和统计
//- find(key);  //查找key是否存在，如果存在，返回该键的元素的迭代器，如果不存在，返回set.end()
//-cout(key);  //统计key的元素个数
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;
	}
	cout << endl;
}
void test01() {
	map<int, int> mp;
	mp.insert(pair<int, int>(1, 10));
	mp.insert(make_pair(3, 20));
	mp.insert(map<int, int>::value_type(4, 30));
	mp[2] = 40;
	map<int, int>::iterator it = mp.find(2);
	if (it != mp.end()) {
		cout << "查到了元素的key值为: " << (*it).first << " 元素的value值为： " << (*it).second << endl;
	}
	else {
		cout << "你好像没有插入过这个key的对组" << endl;
	}
	it = mp.find(5);
	if (it != mp.end()) {
		cout << "查到了元素的key值为 " << (*it).first << " 元素的value值为： " << (*it).second << endl;
	}
	else {
		cout << "你好像没有插入过这个key的对组" << endl;
	}
	//map的统计值只有0和1
	int num1=mp.count(1);
	int num2=mp.count(6);
	cout << num1 << "  " << num2 << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

map排序

map默认时升序排序的，利用仿函数可以改变map的排序规则

#include<iostream>
using namespace std;
#include<map>
class MyCompare {
public:
	bool operator()(int v1, int v2) const {
		return v1 > v2;
	}
};
//map的排序
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;
}
void test01() {
	map<int, int,MyCompare> mp;
	mp.insert(pair<int, int>(1, 10));
	mp.insert(make_pair(3, 20));
	mp.insert(map<int, int>::value_type(4, 30));
	mp[2] = 40;
	printMap(mp);	
}
int main() {
	test01();
	system("pause");
	return 0;
}

STL案例二 员工分组

案例描述

  1. 招聘了10名员工（ABCDEFGHIJ)，需要指派在哪个部门工作
  2. 员工信息分为：姓名，工资组成 部门分为：策划，美术，研发
  3. 随机给10名员工分配部门和工资
  4. 通过multimap进行信息的插入：key(部门编号)，value(员工)
  5. 分部门显示员工信息

实现步骤

  1. 创建10名员工放入vector中
  2. 遍历vector容器，取出每名员工，进行随机分组
  3. 分组后，将每个员工部门编号作为key,具体员工作为value,放入到multimap容器中
  4. 分部门显示员工信息
#include<iostream>
using namespace std;
#include<vector>
#include<map>
#include<string>
#include<ctime>
#define MEISHU 1
#define CEHUA 2
#define YANFA 3
//1. 创建10名员工放入vector中
//2. 遍历vector容器，取出每名员工，进行随机分组
//3. 分组后，将每个员工部门编号作为key, 具体员工作为value, 放入到multimap容器中
//4. 分部门显示员工信息
class Employee {
public:
	Employee(string name, int wages) {
		this->m_Name = name;
		this->m_Wages = wages;
	}
	string m_Name;
	int m_Wages;
};
//创建员工
void createEmployee(vector<Employee> &v) {
	for (int i = 0;i < 10;i++) {
		string nameArry ="ABCDEFGHIJ";
		string name = "员工";
		name += nameArry[i];
		int wages = rand() % 4000 + 6000;
		Employee eml(name, wages);
		v.push_back(eml);
	}
}
//分组
void groupEmployee(vector<Employee>& v, multimap<int, Employee>&m) {
	for (vector<Employee>::iterator it = v.begin();it != v.end();it++) {
		int deptNum = rand() % 3 + 1;
		m.insert(make_pair(deptNum, *it));
	}
}
//分部门显示
void showEmployee(multimap<int, Employee>& m) {
	multimap<int, Employee>::iterator res1 = m.find(MEISHU);
	multimap<int, Employee>::iterator res2 = m.find(CEHUA);
	multimap<int, Employee>::iterator res3 = m.find(YANFA);
	int num1 = m.count(MEISHU);
	int num2 = m.count(CEHUA);
	int num3 = m.count(YANFA);
	cout << "美术部门：" << endl;
	for (int num = 0;res1!=m.end()&&num < num1;res1++, num++) {
		cout << "员工所属部门编号 " << (*res1).first << " " << (*res1).second.m_Name << " 薪资为" << (*res1).second.m_Wages << endl;
	}
	cout << "策划部门：" << endl;
	for (int num = 0;res2 != m.end()&&num < num2;res2++, num++) {
		cout << "员工所属部门编号 " << (*res2).first << " " << (*res2).second.m_Name << " 薪资为" << (*res2).second.m_Wages << endl;
	}
	cout << "研发部门：" << endl;
	for (int num = 0;res3 != m.end()&&num < num3;res3++, num++) {
		cout << "员工所属部门编号 " << (*res3).first << " " << (*res3).second.m_Name << " 薪资为" << (*res3).second.m_Wages << endl;
	}
}
int main() {
	srand((unsigned int)time(NULL));
	vector<Employee> v;
	multimap<int, Employee> mEmployee;
	createEmployee(v);
	groupEmployee(v, mEmployee);
	showEmployee(mEmployee);
	system("pause");
	return 0;
}
言顶
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ STL常用容器
会思想的苇草i的博客
01-15 2067
C++标准模板库（STL）是C++编程中不可或缺的部分，它提供了丰富的数据结构和算法。本文将带你初识C++ STL，包括容器（如vector、list、map等）、算法（如排序、查找、遍历等）以及迭代器等内容。我们将对每种容器和算法进行简要介绍，并给出示例代码加深理解。通过本文的阅读，读者将能够初步掌握C++ STL的基本用法，为日后的程序设计打下坚实的基础。
详解C++中STL常用容器
weixin_73538099的博客
12-20 1695
在本文中重点介绍Sequence Containers，Container Adaptors，Associative Containers，Unordered Associative Containers. 其中重点介绍前两个部分，后两个部分简单提一下。
C++ ， STL ---- 常用容器
weixin_43412762的博客
03-20 1134
STL初识，STL常用容器
C++ STL学习之【容器适配器】
北 海的博客
04-21 4756
适配器（配接器）是STL中的六大组件之一，扮演着轴承、转换器的角色，使得STL中组件的使用更为灵活，比如栈和队列就是属于适配器而非容器，以及神秘的反向迭代器也属于适配器
【C++】STL学习之容器适配器
Aron的博客
04-27 1715
适配器（配接器）是STL中的六大组件之一，扮演着轴承、转换器的角色，使得STL中组件的使用更为灵活，比如栈和队列就是属于适配器而非容器，以及神秘的反向迭代器也属于适配器具有多种功能的电源适配器，可以满足多种需求。
C++之STL容器详解（包含十种常用容器）
2203_75327677的博客
02-08 4789
C++的stl是提高编写效率的一个利器，是算法类竞赛必不可少的工具，本篇博客将详细总结C++STL的各种容器及其常用方法
C++：常用stl容器及其操作
qq_73176808的博客
07-22 623
本文介绍C++常用stl容器及操作
C++STL中的常用容器总结
SeeDoubleU的专栏
04-30 4754
文章目录1 迭代器的类型2 容器的类型2.1 序列容器2.1.1 定长数组 array `c++11`2.1.2 动态数组 vector2.1.3 双端队列 deque2.2 链表容器2.2.1 双向链表 list2.2.2 单向链表 forward_list `c++11`2.3 适配器容器2.3.1 栈 stack2.3.2 队列 queue2.3.3 优先序列 priority_queue2.3.3.1 构造小顶堆2.3.3.2 使用自定义类型作为基础类型2.4 有序关联容器（底层：红黑树）2.4.1
C++的STL容器类详解
Jinyizhi2233的博客
07-11 3271
STL（Standard Template Library）是C++标准库中的一个重要组成部分，它提供了一组通用的模板类和函数，用于实现常用的数据结构和算法。（Containers）：STL提供了多种容器类，如向量（vector）、链表（list）、双向链表（deque）、集合（set）、映射（map）等。总而言之，STL是C++开发中非常重要的工具之一，它提供了高效的数据结构和算法，能够提高程序的性能、减少开发时间，并提高代码的重用性和可维护性。这样可以大大提高代码的重用性，减少了开发时间和维护成本。
C++ STL标准库之容器（常用）篇
山月藏匿浪漫、
04-26 752
简单来说就是set在底层也是以键值对存放的，只不过键值对中不是<key,value>，而是<value,value>。关联式容器在底层的结构上采用比序列式容器更为复杂的结构，所以关联式容器在查找数据时效率较序列式容器更高，采用hash算法加快查找过程，但需要更多内存存放hash桶元素，是一种采用空间换取时间的策略。multimap与map的区别在于：前者允许key值冗余，即不会对数据起到去重的作用。multiset与set的区别在于：multiset允许存储重复的值，set则不允许。
深入解析C++ STL中的常用容器
12-31
STL中的常用容器包括：顺序性容器（vector、deque、list）、关联容器（map、set）、容器适配器（queue、stac）。 1、顺序性容器 （1）vectorvector是一种动态数组，在内存中具有连续的存储空间，支持快速随机访问。...
STL常用容器详细解析
01-20
STL中的常用容器包括：顺序性容器（vector、deque、list）、关联容器（map、set）、容器适配器（queue、stac）。 1、顺序性容器 （1）vectorvector是一种动态数组，在内存中具有连续的存储空间，支持快速随机访问。...
c++ SGI STL源代码学习
06-04
侯捷老师推荐C++ SGI STL标准库源代码，可用于学习c++各种容器、常用算法、迭代器等的底层实现。c++进阶必备，必知必会内容。
C++ STL容器stack和queue详解
01-20
stack是一个比较简单的容器，它的使用也很简单，stack是LIFO容器，就是后进先出，最后添加进去的元素，第一个取出来 stack初始化 std::stack<int> first; std::stack<int> second(first); std::stack<int>> third...
C++之模板（四）
CSDN_HZW的博客
06-18 249
【代码】C++之模板（四）
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 停车场车位统计(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 60
K小姐经营着一个特定大小的停车场，停车场可以看成一个数组 $cars[]$，其中 $1$ 表示有车，$0$ 表示没车。现在停车场内停放着大小不一的车辆，其中小车占一个车位(长度 $1$)，货车占两个车位(长度 $2$)，卡车占三个车位(长度 $3$)。 K小姐想知道，按照当前停车场的停放情况，最少有多少辆车停在停车场内。你能帮帮她吗？ ### 输入描述 输入一个由 $0$ 和 $1$ 组成的字符串，以逗号分隔，表示停车场的车位情况。其中 $1$ 表示有车，$0$ 表示没车，字符串长度不超过 $1000
C语言中的内存分配方式（静态分配、动态分配）定义以及区别
2402_85246552的博客
06-17 275
这种分配方式主要用于局部变量，特别是那些大小在编译时无法确定，或者需要在程序运行时改变大小的变量。：malloc函数用于在堆（heap）上分配指定字节数的内存，并返回一个指向该内存区域的指针。内存分配发生在程序运行时，所以内存大小和生命周期可以在运行时动态改变。内存分配在程序编译时就已经确定，所以内存大小和生命周期都是固定的。静态分配的变量在函数调用时，它们的内存空间会在函数调用栈帧中分配，并在函数返回时释放。动态分配的变量的内存空间在堆上，函数调用时传递的是指针，所以函数调用的开销相对较小。
C++ 61 之 函数模版
最新发布
LSG_Down的博客
06-18 344
c++提供了函数模板(function template.)所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。这个通用函数就成为函数模板。凡是函数体相同的函数都可以用这个模板代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现不同函数的功能。泛型编程总结：
【c++进阶(三)】STL之vector的介绍和使用
weixin_62196764的博客
06-15 861
1.vector表示的是可变序列大小的容器2、vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。3、vector与普通数组不同的是，vector的大小是可以动态改变的。4、当vector需要重新分配大小时，其做法是，分配一个新的数组，然后将全部元素移到这个数组当中，并释放原来的数组空间。---这就表明原来指向该位置的迭代器已经失效了，所以在插入和删除数据的时候要返回一个合法的迭代器的位置。
c++中的stl中的容器
05-10
C++中的STL（Standard Template Library）是一组通用的模板类和函数，它们可用于实现许多常用的数据结构和算法，其中包括许多容器类。下面是STL中常见的容器类： 1. vector：向量容器，用于存储动态大小的元素序列...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值