C++提高编程（二）

最新推荐文章于 2024-07-17 16:19:05 发布
最新推荐文章于 2024-07-17 16:19:05 发布
阅读量113 收藏
点赞数
分类专栏： C++编程基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34963430/article/details/116849348
版权

1. STL（Standard Template Library）

1.1 STL基本概念

  • STL（Standard Template Library）标准模板库
  • STL从广义分为：容器(container)算法(algorithm)迭代器(iterator)
  • 容器和算法之间通过迭代器 进行无缝连接
  • STL几乎所有代码都采用了模板类或者模板函数

1.2 STL六大组件

STL大体分为六大组件，分别是容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

  • 容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据
  • 算法：各种常用的算法，如sort、find、copy、for_each等
  • 迭代器：扮演了容器与算法之间的胶合剂
  • 仿函数：行为类似函数，可作为算法的某种策略
  • 适配器：一种用来修饰容器或者仿函数或者迭代器接口的东西
  • 空间配置器：负责空间的配置与管理

1.3 STL容器、算法、迭代器

容器：放置数据的地方

  • STL容器就是将运用最广泛的一些数据结构实现出来
  • 常用的数据结构：数组、链表、树、栈、队列、集合、映射表等
  • 这些容器分为序列式容器和关联式容器两种：
    • 序列式容器：强调调值的排序，序列式容器中每个元素均有固定位置
    • 关联式容器：二叉树结构，各元素之间没有严格的物理上的顺序关系

算法：解决问题的方法

  • 有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法
  • 算法分为质变算法和非质变算法
    • 质变算法：是指运算过程中会更改区间内的元素内容，例如拷贝、替换、删除等
    • 非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等

迭代器：算法与容器之间的粘合剂

  • 提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式
  • 每个容器都有自己专属的迭代器
  • 迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针

迭代器种类：

种类功能支持运算
输入迭代器对数据的只读访问只读，支持++、==、！=
输出迭代器对数据的只写访问只写，支持++
前向迭代器读写操作，并能向前推进迭代器读写，支持++、==、！=
双向迭代器读写操作，病能向前后操作读写，支持++、–
随机访问迭代器读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器读写，支持++、–、[n]、-n、<、<=、>、>=

总结：常用的容器中迭代器种类为双向迭代器和随机访问迭代器

2. 容器算法迭代器

2.1 vector存放内置数据类型

容器：vector
算法：for_each
迭代器：vector<int>::iterator

#include <iostream>
#include<vector>
#include<algorithm>	//标准算法的头文件
using namespace std;

void myPrint(int val)
{
	cout << val << endl;
}

void test01()
{
	vector<int> v;

	//插入数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);

	//通过迭代器访问容器中的数据
	//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);
}

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

2.2 vector存放自定义数据类型

#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;


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

	string name;
	int 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).name << "年龄：" << (*it).age << endl;
		cout << "姓名：" << it->name << "年龄：" << it->age << endl;
	}
}

//存放自定义数据类型 指针
void test02()
{
	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).name << "年龄：" << (**it).age << endl;
		cout << "姓名：" << (*it)->name << "年龄：" << (*it)->age << endl;
	}
}

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

2.3 vector容器嵌套容器

#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;



void test01()
{
	vector<vector<int>> v;

	vector<int> v1;
	vector<int> v2;
	vector<int> v3;
	vector<int> v4;
	vector<int> v5;
	vector<int> v6;

	//向小容器中添加数据
	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);
		v5.push_back(i + 5);
		v6.push_back(i + 6);
	}
	//将小容器插入大的容器
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);
	v.push_back(v5);
	v.push_back(v6);

	//通过大容器遍历数据
	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
	{
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << (*vit) << "  ";
		}
		cout << endl;
	}
}


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

3.STL常用容器

3.1 String

3.1.1 string 基本概念

  • string是C++风格的字符串，而string本质上是一个类

string和char*区别：

  • char*是一个指针
  • string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器

特点：

  • string类内部封装了很多成员方法
  • string管理char*所分配的内存，不用担心复制越界和取值越界，由类内部进行负责

3.1.2 string构造函数

  • string(); //创建一个空的字符串 例如： string str;
  • string(const char*s); //使用字符串s初始化
  • string(const string& str); //使用一个string对象初始化另一个string对象
  • string(int n , char c); //使用n个字符c初始化
#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;



void test01()
{
	string s1;	//默认构造
	const char* str = "Hello World";
	string s2(str);

	cout << s2 << endl;

	string s3(s2);
	cout << s3 << endl;

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


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

3.1.3 string赋值操作

  • string& operator=(const char* s); //char* 类型字符串 赋值给当前的字符串
  • string& operator=(const string &s); //把字符串s赋值给当前的字符串
  • string& operator=(char c); //字符赋值给当前字符串
  • string& assign(const char* s); //把char*类型的字符串赋值给当前字符串
  • string& assign(const char* s , int n); //把字符串s的前n个字符赋值给当前的字符串
  • string& assign(const string &s); //把字符串s赋值给当前字符
  • string& assign(int n , char c); //用n个字符c赋值给当前字符串
#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;



void test01()
{
	string str1;
	str1 = "Hello world";

	string str2;
	str2 = str1;

	string str3;
	str3 = 'a';

	string str4;
	str4.assign("Hello C++");

	string str5;
	str5.assign("Hello C++", 4);

	string str6;
	str6.assign(str5);

	string str7;
	str7.assign(10,'w');

	cout << str1 << endl;
	cout << str2 << endl;
	cout << str3 << endl;
	cout << str4 << endl;
	cout << str5 << endl;
	cout << str6 << endl;
	cout << str7 << endl;
}


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

3.1.4 string字符串拼接

  • string& operator+=(const char* str); //重载+=操作符
  • string& operator+=(const char c); //重载+=操作符
  • string& operator+=(const string& str); //重载+=操作符
  • string& oppend(const char* s); //把字符串s连接到当前字符串结尾
  • string& oppend(const char* s , int n); //把字符串s的前n个字符连接到当前字符串结尾
  • string& oppend(const string &s); //同operator+=(const string& str);
  • string& oppend(const string &s, int pos, int n); //把字符串s中从pos开始的n个字符连接到字符串结尾
#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;



void test01()
{
	string str1 = "我";
	str1 += "爱学习";
	cout << str1 << endl;
	str1 += ':';
	cout << str1 << endl;

	string str2 = " Effective C++";
	str1 += str2;
	cout << str1 << endl;

	string str3 = "I";
	str3.append(" love ");
	cout << str3 << endl;

	str3.append("study abcde", 5);
	cout << str3 << endl;

	str3.append(str2);
	cout << str3 << endl;

	str3.append(str2,0,10);
	cout << str3 << endl;
}

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

3.1.5 string查找和替换

  • int find(const string& str, int pos = 0) const; //查找str第一次出现的位置，从pos开始查找
  • int find(const char* s, int pos = 0) const; //查找s第一次出现的位置，从pos开始查找
  • int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次出现的位置
  • int find(const char c, int pos = 0) const; //查找字符c第一次出现位置
  • int rfind(const string& str,int pos = npos) const; //查找str最后一次位置，从pos开始查找
  • int rfind(const char* s,int pos = npos) const //查找s最后一次出现位置，从pos开始
  • int rfind(const char* s,int pos,int n) const; //从pos查找s的前n个字符最后一次位置
  • int rfind(const char c, int pos=0) const; //查找字符c最后一次出现位置
  • string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
  • string& replace(int pos, int n, const char* s); //替换从pos开始的n个字符为字符串s
#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;


//查找
void test01()
{
	string str1 = "abcdefgde";

	int pos = str1.find("de");
	cout << pos << endl;


	pos = str1.rfind("de");
	cout << pos << endl;

}

//替换
void test02()
{
	string str1 = "abcdefg";

	str1.replace(1,3,"1111");
	cout << str1 << endl;
}

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

3.1.6 string字符串比较

字符串比较是按照字符的ASCII码值进行对比（=返回0，>返回1，<返回-1）

  • int compare(const string &s) const;
  • int compare(const char* s)const;
#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;

void test01()
{
	string str1 = "hello";
	string str2 = "hello";

	if (str1.compare(str2) == 0)	cout << "=" << endl;
	else if (str1.compare(str2) > 0)	cout << ">" << endl;
	else cout << "<" << endl;

}

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

3.1.7 string字符存取

  • char& operator[ ](int n);
  • char& at(int n);
#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;

void test01()
{
	string str = "hello";

	for(int i=0;i<str.size();i++)
	{
		cout << str[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << " ";
	}
	cout << endl;

	str[0] = 'x';
	cout << str << endl;
	
	char c = str.at(2);
	cout << c << endl;

}

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

3.1.8 string插入和删除

  • string& insert(int pos, const char* s);
  • string& insert(int pos, const string& str);
  • string& insert(int pos, int n ,char c);
  • string& erase(int pos, int n = npos);
#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;

void test01()
{
	string str = "hello";
	str.insert(1,"111");
	cout << str << endl;
	
	str.erase(1,3);
	cout << str << endl;

	str.insert(1,5,'1');
	cout << str << endl;
}

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

3.1.9 string子串

string substr(int pos=0,int n = npos) const;

#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;

void test01()
{
	string str = "hello";
	string subStr = str.substr(1, 3);
	cout << subStr << endl;
}

//实用操作
void test02()
{
	string email = "hello@sina.com";

	//从邮件中 获取 用户名信息
	int pos = email.find('@');

	string user = email.substr(0, pos);
	cout << user << endl;
}

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

3.2 vector容器

3.2.1 vector基本概念

  • vector数据结构和数组非常相似，也称为单端数组
  • 不同之处在于数组是静态空间，而vector可以动态扩展
  • 动态扩展并不是在原空间之后续借新空间，而是找更大的内存空间，然后将原数据拷贝到新空间，释放原空间
  • vector容器的迭代器是支持随机访问的迭代器

3.2.2 vector构造函数

  • vector<T> v;
  • vector(v.begin(),v.end());
  • vector(n,elem);
  • vector(const vector &vec);
#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;

void printVector(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << (*it) << " ";
	}
	cout << endl;
}

void test01()
{
	vector<int> v1;		//默认构造

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	//区间方式
	vector<int> v2(v1.begin(), v1.end());
	printVector(v2);

	//n个elem方式构造
	vector<int>v3(10, 100);
	printVector(v3);

	//拷贝构造
	vector<int> v4(v3);
	printVector(v4);
}

int main()
{
	test01();

	system("pause");
	return 0;
}

3.2.3 vector赋值操作

  • vector& operator = (const vector &vec); //重载等号操作符
  • assign(beg,end); //将 [beg，end) 区间中的数据拷贝赋值给本身
  • assign(n, elem); //将n个elem拷贝赋值给本身
#include <iostream>
#include<vector>
#include<string>
#include<algorithm>	//标准算法的头文件
using namespace std;

void printVector(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << (*it) << " ";
	}
	cout << endl;
}

void test01()
{
	vector<int> v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	printVector(v1);

	//赋值
	vector<int> v2;
	v2 = v1;
	printVector(v2);

	vector<int> v3;
	v3.assign(v1.begin(),v1.end());
	printVector(v3);

	vector<int> v4;
	v4.assign(10,100);
	printVector(v4);

}

int main()
{
	test01();

	system("pause");
	return 0;
}

3.2.4 vector容量和大小

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

3.2.5 vector插入和删除

  • push_back(ele); //尾部插入元素ele
  • pop_back(); //删除最后一个元素
  • insert(const_iterator pos, ele); //迭代器指向位置pos插入元素ele
  • insert(const_iterator pos, int count, ele); //迭代器指向位置pos插入count个元素ele
  • erase(const_iterator pos); //删除迭代器指向的元素
  • erase(const_iterator start, const_iterator end); //删除迭代器从start到end之间的元素
  • clear(); //删除容器中所有元素
int main()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);
	
	v.insert(v.begin(),100);	//第一个参数是迭代器
	v.insert(v.begin(),2,1000);
	v.erase(v.begin());	
	v.erase(v.begin(),v.end());		// =v.clear();

	system("pause");
	return 0;
}

3.2.6 vector数据存取

  • at("int idx"); //返回索引idx所指的数据
  • oprator[]; //返回索引idx所指的数据
  • front(); //返回容器中第一个数据元素
  • back(); //返回容器中最后一个数据元素

3.2.7 vector互换容器

  • swap(vec); //将vec与本身的元素互换
void test01()
{
	vector<int> v;
	for(i = 0;i<10;i++)
	{
		v.push_back(i);
	}

	vector<int> v1;
	for(i = 10;i>0;i--)
	{
		v1.push_back(i);
	}
	
	v.swap(v1);
}
//实际用途
//巧用swap可以收缩内存空间
void test02()
{
	vector<int> v;
	for(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;	//变为3

	//巧用swap收缩内存
	vector<int>(v).swap(v);		//vector<int>(v) 匿名对象（大小容量都是3）与v互换，然后编译器将匿名对象回收
	
	cout<<"v的容量："<<v.capacity()<<endl;	//不变
	cout<<"v的大小："<<v.size()<<endl;	//变为3
}

3.2.8 vector预留空间

  • reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问
void test01()
{
	vector<int> v;
	
	//利用reserve预留空间
	//v.reserve(100000);
	//num = 1;
	
	int num = 0;	//统计开辟空间的次数
	int *p = NULL;
	
	for(i = 0;i<100000;i++)
	{
		v.push_back(i);

		if(p! = &v[0])		//vector插满后，会重新开辟空间，将原来的数全拷贝过去，并释放原有空间，所以插满后，p指的地址就失效了
		{
			p = &v[0];
			num++;
		}
	}

	cout<< num <<endl;	//30次
}

总结：如果数据量较大，可以一开始利用reserve预留空间

3.3 deque容器

3.3.1 基本概念

  • 双端数组，可以对头端进行插入删除操作
  • deque与vector的区别：
    • vector对于头部的插入删除效率低，数据量越大，效率越低
    • deque相对而言，对于头部的插入删除速度会比vector块
    • vector访问元素时的速度会比deque块，这和两者的内部实现有关

deque内部工作原理：

  • deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
  • 中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间

在这里插入图片描述
deque容器的迭代器支持随机访问

3.3.2 deque构造函数

  • deque<T> deqT; //默认构造
  • deque(beg,end)
  • deque(n, elem);
  • deque(const deque &deq); //拷贝构造函数
void printDeque(const deque<int> &d) //加const只读，不写，  并且迭代器也要加const
{
	for(deque<int>::const_iterator it = d.begin(); it!=d.end(); it++)
	{
		//*it = 100;  不可修改
		cout<<	*it	<<" ";
	}
	cout << endl;
}

void test01()
{
	deque<int> d1;
	for(int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);
	
	deque<int> d2(d1.begin(),d1.end());
	printDeque(d2);

	deque<int> d3(10,100);
	printDeque(d3);

	deque<int> d4(d3);
	printDeque(d4);
	
}

3.3.3 deque赋值操作

  • deque& operator=(const deque &deq);
  • assign(beg,end);
  • assign(n,elem);
void printDeque(const deque<int> &d) //加const只读，不写，  并且迭代器也要加const
{
	for(deque<int>::const_iterator it = d.begin(); it!=d.end(); it++)
	{
		//*it = 100;  不可修改
		cout<<	*it	<<" ";
	}
	cout << endl;
}

void test01()
{
	deque<int> d1;
	for(int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);
	
	deque<int> d2;
	d2 = d1;
	printDeque(d2);

	deque<int> d3;
	d3.assign(d1.begin(),d1.end());
	printDeque(d3);
	
	deque<int> d4;
	d4.assign(10,100);
	printDeque(d4);
}

3.3.4 deque大小操作

  • deque.empty();
  • deque.size();
  • deque.resize(num);
  • deque.resize(num, elem);

deque容器没有容量概念

3.3.5 deque插入和删除

两端插入操作：

  • push_back(elem); //在尾部插入一个数据
  • push_front(elem); //在头部插入一个数据
  • pop_back();
  • pop_front();

指定位置操作：

  • insert(pos, elem); //在位置pos插入一个元素elem的拷贝，返回新数据位置
  • insert(pos, int count, elem); //在位置pos插入count个元素elem，无返回值
  • insert(pos, beg, end); //在pos位置插入[beg, end)区间的数据，无返回值
  • erase(pos); //删除pos位置的数据，返回下一个数据的位置
  • erase(beg, end); //删除[beg, end)区间的数据，返回下一个数据的位置
  • clear(); //删除容器中所有元素
void printDeque(const deque<int> &d) //加const只读，不写，  并且迭代器也要加const
{
	for(deque<int>::const_iterator it = d.begin(); it!=d.end(); it++)
	{
		//*it = 100;  不可修改
		cout<<	*it	<<" ";
	}
	cout << endl;
}

void test01()
{
	deque<int> d1;
	
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(30);
	d1.push_front(40);
	
	printDeque(d1);
	
	d1.pop_back();
	d1.pop_front();
	printDeque(d1);
}

void test02()
{
	deque<int> d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(30);
	d1.push_front(40);
	printDeque(d1);
	
	d1.insert(d1.begin(),1000);
	printDeque(d1);
	d1.insert(d1.begin(),2,10000);
	printDeque(d1);
	
	deque<int> d2;
	d2.push_back(1);
	d2.push_back(2);
	d2.push_front(3);
	d2.push_front(4);

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

void test03()
{
	deque<int> d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(30);
	d1.push_front(40);
	printDeque(d1);
	
	deque<int>::iterator it = d1.begin();
	it++;
	d1.erase(it);
	printDeque(d1);

	d1.erase(d1.begin(),d1.end());
}

3.3.6 deque数据存取

  • at(int idx); //返回索引idx所指得数据
  • oprator[ ]; //返回索引idx所指得数据
  • front(); //返回容器中第一个数据元素
  • back(); //返回容器中最后一个元素

3.3.7 deque容器排序操作

  • sort(iterator beg, iterator end); //对beg和end区间内元素进行排序
  • 包含头文件include<algorithm>
  • 对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序

3.4 stack容器

3.4.1 stack基本概念

  • stack是一种先进后出的数据结构，它只有一个出口，栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为

3.4.2 栈（stack）的常用接口

构造函数：

  • stack<T> stk; //stack采用模板类实现，stack对象的默认构造形式
  • stack(const stack &stk); //拷贝构造

赋值操作：

  • stack& operator=(const stack &stk); //重载等号操作符

数据存取：

  • push(elem); //向栈顶添加元素
  • pop(); //从栈顶移除第一个元素
  • top(); //返回栈顶元素

大小操作：

  • empty(); //判断堆栈是否为空
  • size(); //返回栈的大小
void test01()
{
	stack<int> stk;
	//入栈
	s.push(10);
	s.push(20);
	s.push(40);
	s.push(30);

	//只要栈不为空，查看栈顶，并执行出栈
	while(!stk.empty())
	{
		cout<< "栈顶：" << stk.top() << endl;
		stk.pop();
	}

	cout << "栈的大小：" << stk.size() << endl;
}

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

3.5 queue容器

3.5.1 queue基本概念

  • queue是一种先进先出的数据结构，它有两个出口，队头只能出数据，队尾只能近数据，只有队头和队尾才可以被访问，因此队列不允许有遍历行为

3.5.2 queue常用接口

构造函数：

  • queue<T> q; //
  • queue(const queue &q)

赋值操作：

  • queue& oprator=(const queue &que);

数据存取：

  • push(elem);
  • pop();
  • back();
  • front();

大小操作：

  • empty();
  • size();
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("孙悟空"，300);
	Person p3("猪八戒"，200);
	Person p4("沙悟净"，100);

	q.push(p1);	
	q.push(p2);	
	q.push(p3);	
	q.push(p4);				

	cout << "队列大小："<<q.size()<<endl;

	while(!q.empty())
	{
		cout << "队头----" << "姓名："<<q.front().m_Name<<"\t年龄："<<q.front().m_Age<<endl;
		cout << "队尾----" << "姓名："<<q.back().m_Name<<"\t年龄："<<q.back().m_Age<<endl;

		q.pop();
	}

	cout << "队列大小："<<q.size()<<endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

3.6 list容器

3.6.1 list基本概念

功能：将数据进行链式存储

  • 链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链表实现的
  • 链表由一系列结点组成
  • 结点由一个存储数据元素的数据域，另一个是存储下一个结点地址的指针域
  • STL中的链表是一个双向循环链表

优点：

  • 可以对任意位置进行快速插入或删除
  • 采用动态存储分配，不会造成内存浪费和溢出

缺点：

  • 遍历速度没有数组快
  • 不能随机访问
  • 占用空间比数组大

3.6.2 list构造函数

  • list<T> lst;
  • list(beg, end);
  • list(n, elem);
  • list(const list &lst);
void printList(const list<int> &l)
{
	for(list<int>::const_iterator it = l.begin(); it != l.end();it++)
	{
		cout << *it << "  ";
	}
	cout << endl;
}

void test01()
{
	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<int> l4(10, 1000);
	printList(l4);
}

3.6.3 list赋值和交换

  • assign(beg , end);
  • assign(n , elem);
  • list& operator=(const list &lst);
  • swap(lst);
void printList(const list<int> &l)
{
	for(list<int>::const_iterator it = l.begin(); it != l.end();it++)
	{
		cout << *it << "  ";
	}
	cout << endl;
}

void test01()
{
	list<int> l1;

	l1.push_back(10);
	l1.push_back(20);
	l1.push_back(30);
	l1.push_back(40);

	printList(l1);

	list<int> l2;
	l2 = l1;

	list<int> l3;
	l3.assign(l1.begin(), l1.end());

	list<int> l4;
	l4.assign(10 , 1000);

	l1.swap(l4);
}

3.6.4 list大小操作

  • size();
  • empty();
  • resize(num);
  • resize(num , elem);

3.6.5 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值匹配的元素
void printList(const list<int>& l)
{
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++)
	{
		cout << (*it) << " ";
	}
	cout << endl;
}

void test01()
{
	list<int> L;
	
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	L.push_front(40);
	L.push_front(50);
	L.push_front(60);

	printList(L);

	L.pop_back();
	L.pop_front();
	printList(L);

	//list<int>::iterator it = L.begin();
	L.insert(L.begin(),1000);
	printList(L);

	L.insert(L.end(),5,1);
	printList(L);

	list<int> L1;
	L1.insert(L1.end(),L.begin(),L.end());
	printList(L1);

	L1.erase(L1.begin());
	printList(L1);
	L1.erase(L1.begin(),L1.end());
	printList(L1);

	L.remove(1);
	printList(L);
}

3.6.6 list数据存取

  • front(); //返回第一个元素
  • back(); //返回最后一个元素
  • list不支持at和[ ]访问数据
void test01()
{
	list<int> L;
	
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	L.push_front(40);
	L.push_front(50);
	L.push_front(60);

	cout << "第一个元素：" << L.front() << endl;
	cout << "最后一个元素" << L.back() << endl;

	list<int>::iterator it = L.begin();
	//it = it + 1;		不允许+1，只能++或--
	it++;
	cout << *it << endl;
}

3.6.7 list反转和排序

  • reverse();
  • sort();
  • 所有不支持随机访问迭代器的容器，不可以用标准算法，其内部会提供支持对应的一些算法
bool myCompare(int v1 , int v2)
{
	//降序  就让第一个数	大于		第二个数
	return v1 > v2;
}

void test01()
{
	list<int> L;
	
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	L.push_front(40);
	L.push_front(50);
	L.push_front(60);

	printList(L);

	cout << "反转链表" << endl;
	L.reverse();
	printList(L);

	cout << "链表排序" << endl;
	L.sort();	//sort(L.begin(),L.end());错误
	printList(L);

	L.sort(myCompare);		//降序
	printList(L);
}

3.7.8 排序案例

class Person
{
public:
	Person(string name , int age , int height)
	{
		this->m_Name = name;
		this->m_Age = age;
		this->m_Height = height;
	}

	string m_Name;
	int m_Age;
	int m_Height;
};

bool myComparePerson(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 test01()
{
	list<Person> Lp;

	Person p1("刘备", 35 ,175);
	Person p2("张飞", 32, 180);
	Person p3("关羽", 35, 185);
	Person p4("赵云", 30, 182);
	Person p5("黄忠", 60, 177);
	Person p6("马超", 35, 172);
	Person p7("曹操", 45, 174);

	Lp.push_back(p1);
	Lp.push_back(p2);
	Lp.push_back(p3);
	Lp.push_back(p4);
	Lp.push_back(p5);
	Lp.push_back(p6);
	Lp.push_back(p7);

	for (list<Person>::iterator it = Lp.begin(); it != Lp.end(); it++)
	{
		cout << "姓名：" << it->m_Name << "\t年龄：" << it->m_Age << "\t身高：" << it->m_Height << endl;
	}

	//排序
	cout << "============================" << endl;
	cout << "排序后：" << endl;

	Lp.sort(myComparePerson);
	for (list<Person>::iterator it = Lp.begin(); it != Lp.end(); it++)
	{
		cout << "姓名：" << it->m_Name << "\t年龄：" << it->m_Age << "\t身高：" << it->m_Height << endl;
	}
}

3.8 set/multiset容器

3.8.1 基本概念

  • 所有元素都会在插入时自动被排序
  • set/multiset属于关联式容器，底层结构
  • set容器不允许容器中有重复的元素
  • multiset容器允许容器中有重复的元素

3.8.2 set构造和赋值

  • set<T> st;
  • set<const set &st>;
  • set & operator=(const set &st); //重载等号操作符
void test01()
{
	set<int> s1;

	s1.insert(10);	//插入数据，只有insert方式
	s1.insert(20);
	s1.insert(20);
	s1.insert(30);
	s1.insert(30);
	s1.insert(40);

	set<int> s2(s1);
	set<int> s3;
	s3 = s2;
}

void test02()
{
	multiset<int> s1;

	s1.insert(10);	
	s1.insert(20);
	s1.insert(20);
	s1.insert(30);
	s1.insert(30);
	s1.insert(40);

	multiset<int> s2(s1);
	multiset<int> s3;
	s3 = s2;
}

3.8.3 set容器大小和交换

  • size();
  • empty();
  • swap(st);

3.8.4 set插入和删除

  • insert(elem);
  • clear();
  • erase(pos);
  • erase(beg , end);
  • erase(elem);

3.8.5 set容器查找和统计

  • find(key); //查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end();
  • count(key);
void test01()
{
	set<int> s1;

	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);

	set<int>::iterator pos = s1.find(30);

	if(pos == s1.end()) cout << "未找到该元素" << endl;
	else cout << "找到了该元素:"<< *pos <<endl;
}

3.8.5 set与multiset区别

  • set插入时会返回一个pair<iterator , bool>的结果
void test01()
{
	set<int> s1;

	pair<set<int>::iterator , bool> res = s1.insert(10);

	if (res.second)
	{
		cout << "插入成功！" << endl;
	}
	else
	{
		cout << "插入失败！" << endl;
	}
}
太卷了
关注
专栏目录
C++泛型编程
蹦跶跶
06-04 6408
C++泛型编程与STL总结1. 泛型编程1.1 模板1.2 函数模板1.2.1 语法1.2.2 使用函数模板方式1.2.3 普通函数和函数模板的区别1.2.4 普通函数与函数模板的调用规则1.2.5 模板的局限性1.3 类模板2. STL技术 1. 泛型编程 泛型编程最初诞生于C++中。目的是为了实现C++的STL（标准模板库）。其语言支持机制就是模板（Templates）。模板的精神其实很简单：参数化类型。换句话说，把一个原本特定于某个类型的算法或类当中的类型信息抽掉，抽出来做成模板参数T。（参考自Bai
C++并发编程实战
Twj1024的博客
09-08 1501
C++并发编程实战书籍的前半部分的小总结
《黑马》——C++提高编程
热门推荐
漏网小鱼的博客
09-05 15万+
前言 ** 配套视频： https://www.bilibili.com/video/BV1et411b73Z?from=search&seid=16795623907667609637 只是为方便学习，不做其他用途，在此发布C++基础入门部分配套讲义，原作者为黑马程序 C++提高编程 本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨C++更深层的使用 1 模板 1.1 模板的概念 模板就是建立通用的模具，大大提高复用性 模板的特点： 模板不可以直接使用，它只是一个框架 模板的通用并不
探索编程世界的乐趣：《C++青少年趣味编程108例》
努力是为了站在万人之中，成为别人的光
07-17 6万+
C++青少年趣味编程108例》是一部极具价值的编程教材，它通过丰富有趣的案例，帮助青少年在轻松愉快的氛围中学习C++编程。无论是对编程有浓厚兴趣的孩子，还是希望提高自己逻辑思维能力的青少年，这本书都是他们学习和成长的理想选择。通过这本书，青少年不仅可以掌握一门有用的技能，还能培养他们面对挑战时的自信和勇气。
C++学习记录 五、C++提高编程(2)
qq_39274501的博客
10-07 1466
再系统地过一次，夯实基础 学习目标： 过一遍黑马程序员C/C++学习视频 文章目录学习目标：学习内容：一、C++基础入门二、通讯录管理系统三、C++核心编程三、 C++核心编程(面向对象) 继承四、基于多态的企业职工系统五、C++提高编程(1)3.8 set/ multiset 容器六、基于STL泛化编程的演讲比赛七、C++实战项目机房预约管理系统学习产出： 学习内容： 一、C++基础入门 二、通讯录管理系统 三、C++核心编程 三、 C++核心编程(面向对象) 继承 四、基于多态的企业职工系统
浅谈 C++ 元编程
青春不老，奋斗不止！
06-13 2062
置顶/星标公众号????，硬核文章第一时间送达！随着 C++ 11/14/17 标准的不断更新，C++ 语言得到了极大的完善和补充。元编程作为一种新兴的编程方式，受到了越来越多的广泛关注。...
C++编程入门
博客
04-15 4247
C++编程入门
C/C++程序员编程规范
CodeAllen嵌入式
10-17 1521
很幸运，我毕业四年，历任的两家公司技术领导都非常注意编程规范，刚开始还不习惯，有点抵触。不过从后续的开发看，优秀的编程规范真是百利而无一害。 所以我也一直在向外传输编程规范的思想，因为我是从事C/C++的开发，所以这部分重点说下，这部分我自己公司是有专门的文档要求的（75页），但是出于安全保密原则，不能发，所以就以华为开源的代码规范为例，大部分内容要求都是一样的。 制定编程规范的目的： 1、保证代码的可读性 2、保...
黑马程序员/C++提高编程讲义
wechan的博客
02-24 2627
=泛型编程和STL==技术做详细讲解，探讨C++更深层的使用
C++高级编程学习
大显666 的博客
03-30 2万+
目录C++高级编程课程概述C++概述C++的第一个程序C/C++数据类型与变量引用与函数传参引用详解C/C++函数说明内联函数(inline)函数重载 C++高级编程 课程概述 面向对象的方法简介 对象----存在即合理 抽象性–物以类聚 封装----事物的封闭性 继承----事物的相似性 多态----事物的多样性 面向对象方法（类与对象） C++概述 1.什么是C++？ C to C++: *...
程序员C++提高编程PDF.pdf
07-24
在黑马程序员的《程序员C++提高编程PDF》讲义中，特别针对泛型编程和STL技术进行了详细讲解，这表明了模板在C++编程中的重要性。 首先，讲义介绍了模板的基本概念，这可以通过生活中的模板类比来理解。模板就像是一...
C++提高编程C++提高编程.md
04-10
C++提高编程C++提高编程.md
C++提高编程 C++提高编程
12-14
C++提高编程 C++提高编程
第一阶段C++提高编程.pdf第二阶段C++提高编程.pdf第三阶段C++ 核心编程.pdf
10-08
第二阶段：“第二阶段C++提高编程.pdf”和“第二阶段C++提高编程.pdf”是进阶学习，重点在于类和对象，这是面向对象编程的核心。学习者将学习如何定义和使用类，理解封装、继承和多态等面向对象的三大特性。此外，...
基于C语言的Dao编程语言设计源码
最新发布
09-28
该项目是一款名为Dao的编程语言设计源码，采用C语言为主要开发语言，并辅以C、C++、Shell和CSS等语言。项目文件共计225个，其中包含126个Dao源文件、39个C源文件、36个C头文件、9个C++源文件、3个文本文件、2个Vim配置文件、1个ChangeLog文件、1个daomake工具文件、1个README文件、1个配置文件。这个项目旨在构建一个高效、可扩展的编程语言环境。
如何自定义数据集进行目标检测_keras-yolo3.zip
09-28
如何自定义数据集进行目标检测_keras-yolo3
基于JavaScript及多语言融合的勤工俭学平台设计源码
09-28
本项目是一款基于JavaScript及多语言融合的勤工俭学平台设计源码，共计367个文件，涵盖231个Java源代码文件、27个XML配置文件、23个JavaScript文件、19个CSS文件、8个PNG图像文件以及少量其他类型文件。该平台旨在为勤工俭学活动提供高效便捷的解决方案，支持多种语言的交互，满足不同用户的需求。
初始化对LoRA微调动态的影响研究
09-28
内容概要：研究了低秩适应（Low Rank Adaptation, LoRA）方法下不同随机初始化设置的效果与动态特性。论文主要发现，在初始化矩阵B为零、矩阵A随机时，模型通常可以使用更大的学习率并取得较好的效果，但这种情况下会出现内部不稳定现象。然而当A被初始化为零而B随机时，则不具备上述优势。通过理论和大量实验证明，初始化选择A而非B将导致更好的优化结果与训练稳定性。 适合人群：机器学习、神经网络的研究员、深度学习领域的科研学者。 使用场景及目标：在大规模语义模型的参数调整过程中选择恰当的初始化配置，从而提升效率以及性能。对于LoRA微调任务来说，在有限算力条件下高效地利用少量新增训练参数进行自适座行动。 其他说明：文中提出的结论有助于未来改进基于小样本学习的任务，同时指出了目前两种初始化方式均存在缺陷，提示可能需要进一步的研究来解决这些问题。尽管当前方法表现优于默认的LoRA初始化，但仍有一定局限性和潜在改进方向。
【PFJSP问题】基于matlab豪猪算法CPO求解置换流水车间调度问题PFSP【含Matlab源码 7895期】.mp4
09-28
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
C++编程入门与提高指南
"C++易学C++教程 Ｃ＋＋入门与提高" 这篇教程是针对非C++专家设计的，旨在提供一个详细的学习路径，帮助初学者和有一定基础的程序员巩固和提升C++技能。教程强调了基础知识的重要性，特别是对于计算机科学专业的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值