C/C++教程

C++一周学习总结(2021/06/27)

本文主要是介绍C++一周学习总结(2021/06/27),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

STL容器

1 vector容器

1.1 基本概念

vector是将元素放到一个动态数组中,支持随机存取,可以使用下标访问或调用 at() 方法对元素进行读取等操作;
vector在尾部插入与删除元素速度快,在头部与中间插入/删除元素慢,需要将插入元素后的所有元素进行前/后移动。

1.2 对象构造

1.2.1 默认构造函数

vector<int> v1;		//存放int数据的vector容器
vector<float> v2;	//存放float数据的vector容器
vector<student> v3;	//存放student对象的vector容器

[注] <>中也可以存放指针类型,或自定义的类型

1.2.2 带参构造函数

//将另一个vector对象中[begin,end)区间内的元素拷贝给当前vector对象
vector(begin,end);
vector(n,element);	//将n个element拷贝给当前vector对象
//将另一个vector对象拷贝给当前vector对象
vector(const vector &other);

1.3 vector赋值

通过调用assign() 方法来对vector进行赋值,assign() 方法共有四种重载

vector<int> v1;
//第一种,改变vector中的元素个数与内容,下方将v1中赋值2个元素为888
v1.assign(2,888);

//第二种,使用迭代器,将另一个vector对象中元素赋值给v1
v1.assign(v3.begin(), v1.end());

//第三种,使用指针进行赋值
int arr[] = {1,2,3,4,5};
v1.assign(arr,arr+3);

//第四种,直接用=操作符进行赋值
v1 = v2;

1.4 vector容器大小

总共有以下方法

vector<int> v1;
v1.size();		//返回v1中元素的个数
v1.empty();		//判断v1容器是否为空
v1.resize(num);	//给v1重置大小,若num大于v1中元素个数,则扩充容器,以默认值填充;若num小于v1中元素个数,则会缩短容器,按顺序显示容器中的内容
v1.resize(num,elem);	//给容器设置大小为num,元素都为elem

1.5 尾部添加和删除元素

vector<int> v1;
//尾部添加元素
v1.push_back(666);
//尾部删除元素
v1.pop_back();

1.6 数据的存取

1. 使用下标进行存取

例:v1[2] = 888; // 给v1容器中的第三个元素位置存888

2. 使用 at() 方法

例:v1.at(3) = 666; // 给v1容器中的第四个元素位置存666

3. 使用 front()和back() 方法

front() 方法是返回容器的首元素,back() 方法是返回容器的尾元素

例:v1.front() = 100;
v1.back() = 999;

1.7 插入与删除

调用insert 方法插入元素
insert的用法:

  1. insert (pos,elem); // pos的位置插入元素elem,返回插入的元素的位置
  2. insert(pos,n,elem); //pos的位置插入n个elem元素,无返回值
  3. insert(pos,begin,end); //pos的位置插入[begin,end) 区间的元素,无返回值

调用erase 方法删除单个或多个元素,调用clear方法清空所有元素
erase的用法:

  1. erase(pos); //干掉pos位置的元素,后面元素往前移动,返回删除后的位置
  2. erase(pos1,pos2); //干掉pos1位置到pos2位置的元素,后面元素往前移动,返回删除后的位置

1.8 vector与迭代器

vector.begin();		//返回第一个元素的迭代器
vector.end();		//返回最后一个元素后的迭代器
vector.rbegin();	//返回倒数第一个元素的迭代器(用来反转元素)
vector.rend();		//返回倒数最后一个元素后的迭代器
vector.cbegin();	//返回第一个元素的迭代器,以唯读方式返回
vector.cend();		//返回最后一个元素后的迭代器,以唯读方式返回

2 deque容器

2.1 基本概念

deque和vector一样,也是存放在动态数组中,支持随机存取;但deque是双端数组,vector是单端的,因此deque支持头部和尾部插入删除元素,但同样也是在其他位置插入和删除元素较慢

2.2 对象构造

同vector中用法

2.2.1 默认构造函数

deque<int> v1;		//存放int数据的deque容器
deque<float> v2;	//存放float数据的deque容器
deque<student> v3;	//存放student对象的deque容器

[注] <>中也可以存放指针类型,或自定义的类型

2.2.2 带参构造函数

//将另一个deque对象中[begin,end)区间内的元素拷贝给当前vector对象
deque(begin,end);
deque(n,element);	//将n个element拷贝给当前deque对象
//将另一个deque对象拷贝给当前vector对象
deque(const deque &other);

2.3 赋值

同vector中用法

通过调用assign() 方法来对vector进行赋值,assign() 方法共有三种重载

deque<int> v1;
//第一种,改变deque中的元素个数与内容,下方将v1中赋值2个元素为888
v1.assign(2,888);

//第二种,使用迭代器,将另一个vector对象中元素赋值给v1
v1.assign(v3.begin(), v1.end());

//第三种,直接用=操作符进行赋值
v1 = v2;

deque还提供两个容器中的内容进行交换的方法:swap();
(vector中也有)

2.4 容器大小

同vector中用法

总共有以下方法

deque<int> v1;
v1.size();		//返回v1中元素的个数
v1.empty();		//判断v1容器是否为空
v1.resize(num);	//给v1重置大小,若num大于v1中元素个数,则扩充容器,以默认值填充;若num小于v1中元素个数,则会缩短容器,按顺序显示容器中的内容
v1.resize(num,elem);	//给容器设置大小为num,元素都为elem

2.5 头部与尾部添加和删除元素

2.5.1 头部添加和删除元素

deque<int> v1;
//头部添加元素
v1.push_front(111);
//头部删除元素
v1.pop_front();

2.5.2 尾部添加和删除元素

同vector中用法

deque<int> v1;
//尾部添加元素
v1.push_back(666);
//尾部删除元素
v1.pop_back();

2.6 数据存取

同vector中用法

1. 使用下标进行存取

例:v1[2] = 888; // 给v1容器中的第三个元素位置存888

2. 使用 at() 方法

例:v1.at(3) = 666; // 给v1容器中的第四个元素位置存666

3. 使用 front()和back() 方法

front() 方法是返回容器的首元素,back() 方法是返回容器的尾元素

例:v1.front() = 100;
v1.back() = 999;

2.7 插入与删除

同vector中用法

调用insert 方法插入元素
insert的用法:

  1. insert (pos,elem); // pos的位置插入元素elem,返回插入的元素的位置
  2. insert(pos,n,elem); //pos的位置插入n个elem元素,无返回值
  3. insert(pos,begin,end); //pos的位置插入[begin,end) 区间的元素,无返回值

调用erase 方法删除单个或多个元素,调用clear方法清空所有元素
erase的用法:

  1. erase(pos); //干掉pos位置的元素,后面元素往前移动,返回删除后的位置
  2. erase(pos1,pos2); //干掉pos1位置到pos2位置的元素,后面元素往前移动,返回删除后的位置

2.8 deque与迭代器

同vector中用法

deque.begin();		//返回第一个元素的迭代器
deque.end();		//返回最后一个元素后的迭代器
deque.rbegin();	//返回倒数第一个元素的迭代器(用来反转元素)
deque.rend();		//返回倒数最后一个元素后的迭代器
deque.cbegin();	//返回第一个元素的迭代器,以唯读方式返回
deque.cend();		//返回最后一个元素后的迭代器,以唯读方式返回

3 list容器

3.1 基本概念

list是一个双向链表容器,删除与插入元素更高效,不能进行随机读取数据。

3.2 对象构造

3.2.1 默认构造函数

同vector中用法

list<int> v1;		//存放int数据的vector容器
list<float> v2;	//存放float数据的vector容器
list<student> v3;	//存放student对象的vector容器

[注] <>中也可以存放指针类型,或自定义的类型

3.2.2 带参构造函数

//将另一个list对象中[begin,end)区间内的元素拷贝给当前list对象
list(begin,end);
list(n,element);	//将n个element拷贝给当前list对象
//将另一个vector对象拷贝给当前vector对象
list(const list &other);

3.3 赋值

同vector中用法

通过调用assign() 方法来对list进行赋值,assign() 方法共有三种重载

list<int> v1;
//第一种,改变deque中的元素个数与内容,下方将v1中赋值2个元素为888
v1.assign(2,888);

//第二种,使用迭代器,将另一个vector对象中元素赋值给v1
v1.assign(v3.begin(), v1.end());

//第三种,直接用=操作符进行赋值
v1 = v2;

同样也有swap方法

3.4 容器大小

同vector中用法

总共有以下方法

list<int> v1;
v1.size();		//返回v1中元素的个数
v1.empty();		//判断v1容器是否为空
v1.resize(num);	//给v1重置大小,若num大于v1中元素个数,则扩充容器,以默认值填充;若num小于v1中元素个数,则会缩短容器,按顺序显示容器中的内容
v1.resize(num,elem);	//给容器设置大小为num,元素都为elem

3.5 头部与尾部添加和删除元素

list也可以进行头部和尾部进行添加删除元素,用法同deque

2.5.1 头部添加和删除元素

list<int> v1;
//头部添加元素
v1.push_front(111);
//头部删除元素
v1.pop_front();

2.5.2 尾部添加和删除元素

同vector中用法

list<int> v1;
//尾部添加元素
v1.push_back(666);
//尾部删除元素
v1.pop_back();

3.6 数据存取

不能采用下标进行数据的存取,必须遍历所有元素,进行存取。提供front和back方法,进行存取首尾元素

for (list<int>::const_iterator it = lits1.cbegin(); it != lits1.cend(); it++) {
		cout << "lits1的是值: " << *it << endl;
	}

3.7 插入与删除

插入同vector中用法

调用insert 方法插入元素
insert的用法:

  1. insert (pos,elem); // pos的位置插入元素elem,返回插入的元素的位置
  2. insert(pos,n,elem); //pos的位置插入n个elem元素,无返回值
  3. insert(pos,begin,end); //pos的位置插入[begin,end) 区间的元素,无返回值

调用erase 方法删除单个或多个元素,调用clear方法清空所有元素
erase的用法:

  1. erase(pos); //干掉pos位置的元素,后面元素往前移动,返回删除后的位置
  2. erase(pos1,pos2); //干掉pos1位置到pos2位置的元素,后面元素往前移动,返回删除后的位置

调用remove方法,删除容器的特定元素
用法:remove(elem) 删除容器中为elem的元素

3.8 list与迭代器

同vector中用法

list.begin();		//返回第一个元素的迭代器
list.end();		//返回最后一个元素后的迭代器
list.rbegin();	//返回倒数第一个元素的迭代器(用来反转元素)
list.rend();		//返回倒数最后一个元素后的迭代器
list.cbegin();	//返回第一个元素的迭代器,以唯读方式返回
list.cend();		//返回最后一个元素后的迭代器,以唯读方式返回

3.9 反序排列

调用reverse方法,将元素按倒序显示

4 变参模板,完美转发和emplace

容器中添加对象,通过使用emplace_back方法和emplace方法,可以直接传入对象的实参

[例] 代码:

#include <iostream>
#include <list>
#include <deque>
#include <vector>
#include <string>

using namespace std;

class Student {
public:
	Student();
	Student(string name, int age = 0);
	~Student();
	Student(const Student &stu);

public:
	string name;
	int age;
};

Student::Student(){}

Student::Student(string name, int age) {
	this->name = name;
	this->age = age;
	cout << "调用有参的构造函数" << endl;
	cout << "姓名:" << name << " 性别:" << age << endl;
}

Student::~Student() {
	cout << "调用析构函数" << endl;
}

Student::Student(const Student &stu) {
	cout << "调用拷贝函数" << endl;
}

int main() {
	list<Student> liStu(8);
	vector<Student> vStu(8);
	deque<Student> dqStu(8);
	Student stu1("小花", 19);

	vStu.push_back(stu1);
	vStu.emplace_back("小花",19);		//尾部插入对象,C++11新特性:变参模板和完美转发,相当于push_back方法
	vStu.emplace(vStu.end(), "小美", 18);	//相当于insert方法

	liStu.emplace_back("小花",19);
	liStu.emplace(liStu.end(), "小美", 18);

	dqStu.emplace_back("小花", 19);
	dqStu.emplace(dqStu.end(), "小美", 18);

	return 0;
}

5 set&multiset容器

5.1 基本概念

set与multiset是一个集合容器,set只能存入唯一值,multiset可以存入重复值,set与multiset会对元素进行排序,默认从小到大排序。
他们数据结构采用红黑树来实现,能快速访问元素,插入和删除元素速度也较快

5.2 对象构造

5.2.1 默认构造函数

set<int> v1;		//存放int数据的set容器
set<float> v2;		//存放float数据的set容器
set<student> v3;	//存放student对象的set容器

multiset<int> v1;		//存放int数据的multiset容器
multiset<float> v2;		//存放float数据的multiset容器
multiset<student> v3;	//存放student对象的multiset容器

[注] <>中也可以存放指针类型,或自定义的类型

5.2.2 带参构造函数

//将另一个set对象中[begin,end)区间内的元素拷贝给当前set对象
set(begin,end);
//将另一个vector对象拷贝给当前vector对象
set(const set &other);

//将另一个multiset对象中[begin,end)区间内的元素拷贝给当前multiset对象
multiset(begin,end);
//将另一个multiset对象拷贝给当前multiset对象
multiset(const multiset &other);

5.3 赋值

set与multiset赋值方式都是通过拷贝构造函数或重载等号运算符进行赋值

set(const set &s);
set &operator= (const set &s);

multiset(const multiset &s);
multiset &operator= (const multiset &s);

set与multiset也都有swap方法,实现交换功能

5.4 容器大小

set与multiset没有resize方法

总共有以下方法

set<int> v1;
v1.size();		//返回v1中元素的个数
v1.empty();		//判断v1容器是否为空

multiset<int> v2;
v2.size();		//返回v2中元素的个数
v2.empty();		//判断v2容器是否为空

5.5 数据的查找

set.find(elem);		//查找elem元素,返回指向elem的迭代器
set.count(elem);	//统计elem的个数,set只有0/1,multiset可能大于1
set.lower_bound(elem);	//返回第一个 ≥ elem的迭代器
set.upper_bound(elem);	//返回第一个> elem的迭代器
set.equal_range(elem);	//返回与elem相等的上下区间,左闭右开

multiset也是有相同的方法

5.6 插入与删除

5.6.1 插入与pair对组

调用insert 方法插入元素,insert方法中有返回为迭代器的,也有返回pair对组的。
对组pair<T1, T2>,T1和T2类型可以一致或不一致,也可以是自定义类。
pair.first 就是访问第一个的内容,类型为T1类型,
pair.second 访问第二个我的内容,类型为T2类型

5.6.2 删除

调用erase 方法删除单个或多个元素,调用clear方法清空所有元素
erase的用法:

  1. erase(pos); //干掉pos位置的元素,后面元素往前移动,返回删除后的位置
  2. erase(pos1,pos2); //干掉pos1位置到pos2位置的元素(左闭右开),后面元素往前移动,返回删除后的位置
  3. erase(elem); //删除容器中elem元素

5.7 set&multiset与迭代器

同vector中用法

set.begin();		//返回第一个元素的迭代器
set.end();		//返回最后一个元素后的迭代器
set.rbegin();	//返回倒数第一个元素的迭代器(用来反转元素)
set.rend();		//返回倒数最后一个元素后的迭代器
set.cbegin();	//返回第一个元素的迭代器,以唯读方式返回
set.cend();		//返回最后一个元素后的迭代器,以唯读方式返回

multiset与set相同

5.8 仿函数

set与multiset里存入的元素默认会升序排序,因为默认使用了less方法进行排序
multiset
也可以给创建容器对象时指定以哪种方式进行排序
[例] set<int,greater<int>> sg; 使用greater方法,元素将降序排序

我们也可以自定义自己的排序方法进行使用
[例] 使用自定义的方法,将学生对象按照年龄升序排序

#include <iostream>
#include <string>
#include <functional>
#include <set>

using namespace std;

class Student {
public:
	Student();
	Student(string name, int age = 0);
	~Student();
	Student(const Student &stu);
	bool operator<(const Student &stu) const;
	bool operator>(const Student &stu) const;

public:
	string name;
	int age;
};

Student::Student(string name, int age) {
	this->name = name;
	this->age = age;
}

Student::~Student() {
	
}

Student::Student(const Student &stu) {
	name = stu.name;
	age = stu.age;
}

bool Student::operator<(const Student &stu) const {
	return age < stu.age;
}

bool Student::operator>(const Student &stu) const {
	return age > stu.age;
}

class stuFun {
public:
	bool operator()(const Student &stu1, const Student &stu2) {
		return stu1.age < stu2.age;
	}
};

int Set() {
	stuFun sf;
	set<Student, stuFun> setStu;
	Student stu1("小花",20);
	Student stu2("小美",22);

	bool ret = sf(stu1, stu2);		//比较stu1和stu2的年龄

	cout << ret << endl;

	for (set<Student, stuFun>::iterator it = setStu.begin(); it != setStu.end(); it++) {
		cout << it->name << " 年龄: " << it->age << endl;
	}

	return 0;
}

6 map&multimap容器

6.1 基本概念

map是关联式容器,存放的键值对(key,value),基于key进行检索数据。

  1. map中的key是唯一的,map中的元素也是按照一定顺序进行排列的,因此也不能插入到指定位置。multimap中的key可以重复
  2. map的底层也是采用的红黑树,访问与插入删除元素较快
  3. map支持[] 操作符,可以使用map[key]来访问key对应的值,multimap不支持[] 操作符

6.2 对象构造

6.2.1 默认构造函数

map<T1,T2> v1;		//key为T1类型,value为T2类型

multimap<T1,T2> v1;		//key为T1类型,value为T2类型

[注] T1,T2可以使用指针类型或自定义的类型

6.2.2 带参构造函数

//将另一个map对象中[begin,end)区间内的元素拷贝给当前map对象
map(begin,end);
//将另一个vector对象拷贝给当前vector对象
map(const map &other);

//将另一个multimap对象中[begin,end)区间内的元素拷贝给当前multimap对象
multimap(begin,end);
//将另一个multimap对象拷贝给当前multimap对象
multimap(const multimap &other);

6.3 赋值

map与multimap赋值方式都是通过拷贝构造函数或重载等号运算符进行赋值

map(const map &s);
map &operator= (const map &s);

multimap(const multimap &s);
multimap &operator= (const multimap &s);

map与multimap也都有swap方法,实现交换功能

6.4 容器大小

map与multimap没有resize方法

总共有以下方法

map<int> v1;
v1.size();		//返回v1中元素的个数
v1.empty();		//判断v1容器是否为空

multimap<int> v2;
v2.size();		//返回v2中元素的个数
v2.empty();		//判断v2容器是否为空

6.5 数据的查找

map.find(key);		//查找key元素,返回指向元素所在的迭代器
map.count(key);		//统计key的个数,map只有0/1,multimap可能大于1
map.lower_bound(key);	//返回第一个 ≥ key的迭代器
map.upper_bound(key);	//返回第一个> key的迭代器
map.equal_range(key);	//返回与key相等的上下区间,左闭右开

multimap也是有相同的方法

6.6 插入与删除

6.6.1 插入

调用insert 方法插入元素,有四种方式插入元素:

  1. mapStudent.insert(pair<int,string>(1,“”张三”));
  2. mapStudent,insert(make_pair(2,“李四”));
  3. mapStudent.insert(map<int,string>::value_type(3,“王五”));
  4. mapStudent[5] = “张龙”;

前三种方式返回值都为pair<iterator,bool>,第四种方式若存在key=5的元素,value将会被覆盖,若不存在key=5的元素,会插入key=5的元素

6.6.2 删除

调用erase 方法删除单个或多个元素,调用clear方法清空所有元素
erase的用法:

  1. erase(pos); //干掉pos位置的元素,后面元素往前移动,返回删除后的位置
  2. erase(pos1,pos2); //干掉pos1位置到pos2位置的元素(左闭右开),后面元素往前移动,返回删除后的位置
  3. erase(key); //删除容器中为key的元素
  4. map.erase(key_type *first, key_type *last); //删除数组指定的左开右闭区间内特定的key对应的对组

6.7 map&multimap与迭代器

同vector中用法

map.begin();		//返回第一个元素的迭代器
map.end();		//返回最后一个元素后的迭代器
map.rbegin();	//返回倒数第一个元素的迭代器(用来反转元素)
map.rend();		//返回倒数最后一个元素后的迭代器
map.cbegin();	//返回第一个元素的迭代器,以唯读方式返回
map.cend();		//返回最后一个元素后的迭代器,以唯读方式返回

multimap与map相同

7 queue容器

7.1 基本概念

queue是一个队列容器,先进先出。默认情况下queue是采用的deque容器实现的,但只能在前端刪除元素,在后端插入元素

7.2 对象构造

7.2.1 默认构造函数

queue<int> v1;		//存放int数据的queue容器
queue<float> v2;	//存放float数据的queue容器
queue<student> v3;	//存放student对象的queue容器

[注] <>中也可以存放指针类型,或自定义的类型

7.2.2 带参构造函数

queue也可以使用list来存储元素:queue<int,list> qList;
但不能使用 vector/set/multiset/map/multimap

7.3 赋值

queue赋值方式都是通过拷贝构造函数或重载等号运算符进行赋值

queue(const queue &s);
queue &operator= (const queue &s);

queue也有swap方法,实现交换功能

7.4 容器大小

queue没有resize方法

总共有以下方法

queue<int> v1;
v1.size();		//返回v1中元素的个数
v1.empty();		//判断v1容器是否为空

7.5 数据的存取

不能采用下标进行数据的存取,也无法使用迭代器进行读写数据。提供front和back方法,可进行存取首尾元素

7.6 插入与删除

queue没有insert和erase方法,只能通过push方法添加元素,pop方法移除元素

7.7 priority_queue

priority_queue也叫优先级队列,入队顺序不变,但出队顺序按照优先级从高到低进行,优先级高的先出队

[例] 未完待续。。。。


8 stack容器

8.1 基本概念

stack是一个堆栈容器,先进后出。默认情况下stack也是采用的deque容器实现的,但只能在后端刪除和插入元素

7.2 对象构造

7.2.1 默认构造函数

stack<int> v1;		//存放int数据的stack容器
stack<float> v2;	//存放float数据的stack容器
stack<student> v3;	//存放student对象的stack容器

[注] <>中也可以存放指针类型,或自定义的类型

7.2.2 带参构造函数

stack也可以使用list/vector/queue来存储元素:

stack<int,list<int>> sList;
stack<int,vector<int>> sVector;
stack<int,queue<int>> sQueue;

但不能使用 set/multiset/map/multimap

7.3 赋值

stack赋值方式都是通过拷贝构造函数或重载等号运算符进行赋值

stack(const stack &s);
stack &operator= (const stack &s);

stack也有swap方法,实现交换功能

7.4 容器大小

stack没有resize方法

总共有以下方法

stack<int> v1;
v1.size();		//返回v1中元素的个数
v1.empty();		//判断v1容器是否为空

7.5 数据的存取

不能采用下标进行数据的存取,也无法使用迭代器进行读写数据。提供top方法,返回最后一个压栈的元素

7.6 插入与删除

与queue一样,stack也没有insert和erase方法,只能通过push方法添加元素,pop方法移除元素

这篇关于C++一周学习总结(2021/06/27)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!