B站黑马c++学习笔记 —— 提高编程篇
大纲
- 1 模板
-
- 1.1 模板的概念
- 1.2 函数的模板
-
- 1.2.1 函数的模板语法
- 1.2.2 函数模板注意事项
- 1.2.3 函数模板案例
- 1.2.4 普通函数与函数模板的区别
- 1.2.5 普通函数与函数模板的调用规则
- 1.2.6 模板的局限性
- 1.3 类模板
-
- 1.3.1 类模板语法
- 1.3.2 类模板与函数模板区别
- 1.3.3 类模板中成员函数创建时机
- 1.3.4 类模板对象做函数参数
- 1.3.5 类模板与继承
- 1.3.6 类模板成员函数类外实现
- 1.3.7 类模板分文件编写
- 1.3.8 类模板与友元
- 1.3.9 类模板案例 — 通用数组
- 2 STL初识
-
- 2.1 STL的诞生
- 2.2 STL基本概念
- 2.3 STL六大组件
- 2.4 STL中容器、算法、迭代器
- 2.5 容器、算法、迭代器初识
-
- 2.5.1 vector存放内置数据类型
- 2.5.2 vector存放自定义数据类型
- 2.5.3 vector容器嵌套容器
- 3 STL-常用容器
-
- 3.1 string容器
-
- 3.1.1 string基本概念
- 3.1.2 string构造函数
- 3.1.3 string赋值操作
- 3.1.4 string字符串拼接
- 3.1.5 string查找与替换
- 3.1.6 string字符串比较
- 3.1.7 string字符存取
- 3.1.8 string插入与删除
- 3.1.9 string子串
- 3.2 vector容器
-
- 3.2.1 vector基本概念
- 3.2.2 vector构造函数
- 3.2.3 vector赋值操作
- 3.2.4 vector容量和大小
- 3.2.5 vector插入与删除
- 3.2.6 vector数据存取
- 3.2.7 vector互换容器
- 3.2.8 vector预留空间
- 3.3 deque容器
-
- 3.3.1 deque容器基本概念
- 3.3.2 deque构造函数
- 3.3.3 deque赋值操作
- 3.3.4 deque大小操作
- 3.3.5 deque插入与删除
- 3.3.6 deque数据存取
- 3.3.7 deque排序
- 3.4 案例 -- 评委打分
- 3.4.1 案例描述
- 3.4.2 实现步骤
- 3.4.3 案例实现
- 3.5 stack容器
-
- 3.5.1 stack基本概念
- 3.5.2 stack常用接口
- 3.6 queue容器
-
- 3.6.1 queue基本概念
- 3.6.2 queue常用接口
- 3.7 list容器
-
- 3.7.1 list基本概念
- 3.7.2 list构造函数
- 3.7.3 list赋值与交换
- 3.7.4 list大小操作
- 3.7.5 list插入与删除
- 3.7.6 list数据存取
- 3.7.7 list反转与排序
- 3.7.8 list排序案例
- 3.8 set/multiset容器
-
- 3.8.1 set基本概念
- 3.8.2 set构造和赋值
- 3.8.3 set大小和交换
- 3.8.4 set插入与删除
- 3.8.5 set查找和统计
- 3.8.6 set和multiset区别
- 3.8.7 pair对组创建
- 3.8.8 set容器排序
- 3.9 map/multimap容器
-
- 3.9.1 map基本概念
- 3.9.2 map构造和赋值
- 3.9.3 map大小和交换
- 3.9.4 map插入与删除
- 3.9.5 map查找和统计
- 3.9.6 map容器排序
- 3.10 案例 -- 员工分组
-
- 3.10.1 案例描述
- 3.10.2 实现步骤
- 3.10.3 案例实现
- 4 STL-函数对象
-
- 4.1 函数对象
-
- 4.1.1 函数对象概念
- 4.1.2 函数对象使用
- 4.2 谓词
-
- 4.2.1 谓词概念
- 4.2.1 一元谓词
- 4.2.1 二元谓词
- 4.3 内建函数对象
- 4.3.1 内建函数对象意义
- 4.3.2 算术仿函数
- 4.3.3 关系仿函数
- 4.3.4 逻辑仿函数
- 5 STL-常用算法
-
- 5.1 常用遍历算法
- 5.1.1 for_each
- 5.1.2 transform
- 5.2 常用查找算法
-
- 5.2.1 find
- 5.2.2 find_if
- 5.2.3 adjacent_find
- 5.2.4 binary_search
- 5.2.5 count
- 5.2.6 count_find
- 5.3 常用排序算法
-
- 5.3.1 sort
- 5.3.2 random_shuffle
- 5.3.3 merge
- 5.3.4 reverse
- 5.4 常用拷贝和替换算法
-
- 5.4.1 copy
- 5.4.2 replace
- 5.4.3 replace_if
- 5.4.4 swap
- 5.5 常用算术生成算法
-
- 5.5.1 accumulate
- 5.5.2 fill
- 5.6 常用集合算法
-
- 5.6.1 set_intersection
- 5.6.2 set_union
- 5.6.3 set_difference
1 模板
1.1 模板的概念
1.2 函数的模板
1.2.1 函数的模板语法
//函数模板
template<typename T>
void mySwap(T &a, T &b) {
T temp = a;
a = b;
b = temp;
}
void test() {
int a = 1;
int b = 2;
string c = "c";
string d = "d";
mySwap(a, b);
//mySwap(a, b); //显示指定类型
mySwap(c, d);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
cout << "d = " << d << endl;
}
int main() {
test();
return 0;
}
1.2.2 函数模板注意事项
1.2.3 函数模板案例
//排序
//交换模板
template<class T>
void mySwap(T &a, T &b) {
T temp = a;
a = b;
b = temp;
}
//排序模板
template<class T>
void mySort(T arr,int len) {
for (int i = 0; i < len; i++) {
int max = i;
for (int j = i + 1; j < len; j++) {
if (arr[j] > arr[max]) {
max = j;
}
}
if (max != i) {
mySwap(arr[max], arr[i]);
}
}
}
//打印模板
template<class T>
void myPrint(T arr,int len) {
for (int i = 0; i < len; i++) {
cout << arr[i] ;
}
cout << endl;
}
void test() {
int arr1[] = { 1,5,9,0,2,8,4 };
char arr2[] = "asdwfg";
int len1;
int len2;
len1 = sizeof(arr1) / sizeof(arr1[0]);
len2 = sizeof(arr2) / sizeof(arr2[0]);
mySort(arr1, len1);
myPrint(arr1, len1);
mySort(arr2,len2);
myPrint(arr2, len2);
}
int main() {
test();
return 0;
}
1.2.4 普通函数与函数模板的区别
- 建议使用显示指定类型的方式调用函数模板
//mySwap(a,b);
mySwap<int>(a, b);
1.2.5 普通函数与函数模板的调用规则
//强制调用函数模板
mySwap<>(a, b);
1.2.6 模板的局限性
//类定义
class person {
public:
int m_age;
string m_name;
person(int age, string name) {
this->m_age = age;
this->m_name = name;
}
};
//普通函数模板
template<class T>
bool myCompare(T &a, T &b) {
if (a == b) {
return true;
}
else {
return false;
}
}
//具体化模板
template<> bool myCompare(person &p1, person &p2) {
if (p1.m_age == p2.m_age&&p1.m_name == p2.m_name) {
return true;
}
else {
return false;
}
}
//打印
void myPrint(bool &ret) {
if (ret) {
cout << "相同" << endl;
}
else {
cout << "不同" << endl;
}
}
void test() {
person p1 = { 18,"Tom" };
person p2 = { 28,"Tom" };
bool ret1 = myCompare(p1, p2);
myPrint(ret1);
bool ret2 = myCompare(p1.m_name, p2.m_name);
myPrint(ret2);
}
int main() {
test();
return 0;
}
1.3 类模板
1.3.1 类模板语法
template<class nameType, class ageType>
class person{
public:
nameType m_name;
ageType m_age;
}
void test(){
person<string,int> p1("Tom",18);
}
1.3.2 类模板与函数模板区别
template<class nameType, class ageType = int>
class person{
public:
nameType m_name;
ageType m_age;
}
void test(){
person<string> p1("Tom",18);
}
1.3.3 类模板中成员函数创建时机
1.3.4 类模板对象做函数参数
//查看模板参数类型名
cout << typeid(T).name() << endl;
template<class T1, class T2>
class person {
public:
T1 m_age;
T2 m_name;
person(T1 age, T2 name) {
this->m_age = age;
this->m_name = name;
}
void person_print() {
cout << this->m_age << endl;
cout << this->m_name << endl;
}
};
//指定传入类型
void myPrint01(person<int, string> &p1) {
p1.person_print();
}
void test01() {
person<int, string> p1(18, "Tom");
myPrint01(p1);
}
//参数模板化
template<class T1,class T2>
void myPrint02(person<T1, T2> &p2) {
p2.person_print();
cout << typeid(T1).name() << endl;
}
void test02() {
person<int, string> p2(28, "Jack");
myPrint02(p2);
}
//整个类模板化
template<class T>
void myPrint03(T &p3) {
p3.person_print();
cout << typeid(T).name() << endl;
}
void test03() {
person<int, string> p3(38, "John");
myPrint03(p3);
}
int main() {
test01();
test02();
test03();
return 0;
}
1.3.5 类模板与继承
//父类
template<class T>
class Base {
public:
T m;
};
//子类
template<class T1,class T2>
class Son :public Base<T1> {
public:
T2 n;
Son() {
cout << typeid(T1).name() << endl;
cout << typeid(T2).name() << endl;
}
};
void test() {
Son<int, string> s1;
}
int main() {
test();
return 0;
}
1.3.6 类模板成员函数类外实现
template<class T1, class T2>
class person {
public:
T1 m_age;
T2 m_name;
person(T1 age, T2 name);
void person_print();
};
//构造函数的类外实现
template<class T1, class T2>
person<T1, T2>::person(T1 age, T2 name) {
this->m_age = age;
this->m_name = name;
}
//成员函数的类外实现
template<class T1, class T2>
void person<T1, T2>::person_print() {
cout << this->m_age << endl;
cout << this->m_name << endl;
}
void test() {
person<int, string> p1(18,"Tom");
p1.person_print();
}
int main() {
test();
return 0;
}
1.3.7 类模板分文件编写
- tree.hpp
#pragma once
#include- main.cpp
#include"tree.hpp"
void test() {
tree<int, string> t1(180,"银杏");
t1.tree_print();
}
int main() {
test();
return 0;
}
1.3.8 类模板与友元
template<class T1, class T2>
class person;
//提前声明全局函数
template<class T1, class T2>
void person_print2(person<T1, T2> p) {
cout << " 类外实现 " << p.m_name << endl;
}
template<class T1, class T2>
class person {
//全局函数类内实现
friend void person_print1(person<T1,T2> p) {
cout << " 类内实现 " << p.m_name << endl;
}
//全局函数类外实现
friend void person_print2<>(person<T1, T2> p);
public:
person(T1 age, T2 name) {
this->m_age = age;
this->m_name = name;
}
private:
T1 m_age;
T2 m_name;
};
void test() {
//类内
person<int, string> p1(18,"Tom");
person_print1(p1);
//类外
person<int, string> p2(28, "Rose");
person_print2(p2);
}
int main() {
test();
return 0;
}
1.3.9 类模板案例 — 通用数组
- main.cpp
class person {
public:
string m_name;
int m_age;
person() {};
person(string name, int age) {
this->m_name = name;
this->m_age = age;
}
};
void printArray(myArray<person> & arr) {
for (int i = 0; i < arr.get_size(); i++) {
cout << arr[i].m_name << "\n" << arr[i].m_age << endl;
}
}
void test() {
myArray<person> arr1(3);
person p1("A", 18);
person p2("B", 28);
person p3("C", 38);
arr1.push_back(p1);
arr1.push_back(p2);
arr1.push_back(p3);
printArray(arr1);
}
int main() {
test();
return 0;
}
- myArray.hpp
#pragma once
#include2 STL初识
2.1 STL的诞生
2.2 STL基本概念
2.3 STL六大组件
2.4 STL中容器、算法、迭代器
2.5 容器、算法、迭代器初识
2.5.1 vector存放内置数据类型
#include2.5.2 vector存放自定义数据类型
#include2.5.3 vector容器嵌套容器
#include3 STL-常用容器
3.1 string容器
3.1.1 string基本概念
3.1.2 string构造函数
void test() {
//string()
string s1;
//string(const char* s)
const char* str = "hello world";
string s2(str);
//string(const string& str)
string s3(s2);
//string(int n,char c)
string s4(5, 'a');
cout << s1 << endl
<< s2 << endl
<< s3 << endl
<< s4 << endl;
}
int main() {
test();
return 0;
}
3.1.3 string赋值操作
void test() {
string str1;
str1.assign("hello world");
cout << str1 << endl;
//把前n个字符赋值
string str2;
str2.assign("hello world", 8);
cout << str2 << endl;
}
int main() {
test();
return 0;
}
3.1.4 string字符串拼接
void test() {
string str1 = "~$root:";
str1 += "zxy";
cout << str1 << endl;
string str2 = ":";
str1 += str2;
cout << str1 << endl;
//截取字符串的前 n 个添加
str1.append("sudo apt-get install ros-kinetic-moveit",10);
cout << str1 << endl;
//截取字符串的第 m 到第 n 个添加
string str3 = "sudo apt-get install ros-kinetic-moveit";
str1.append(str3, 10,-1);
cout << str1 << endl;
}
int main() {
test();
return 0;
}
3.1.5 string查找与替换
void test() {
string str = "abcdab";
//如果找到 返回字符串首位置，未找到返回值-1
int pos;
//find 从左往右第一次出现的位置
pos = str.find("ab");
cout << "find : " << pos << endl;
//rfind 从右往左第一次出现的位置
pos = str.rfind("ab");
cout << "rfind: " << pos << endl;
//str.replace(替换的起始位置<从0开始>, 替换的个数, 替换后的内容);
string str2 = " ab ** ab ";
str.replace(2, 2, str2);
cout << str << endl;
}
int main() {
test();
return 0;
}
3.1.6 string字符串比较
string str1 = "abc";
string str2 = "bbc";
int ret = str1.compare(str2);
3.1.7 string字符存取
void test() {
string str1 = "abcdefg";
//通过[]、at访问单个字符
for (int i = 0; i < str1.size(); i++) {
cout << str1[i] ;
cout << str1.at(i) ;
}
//通过[]、at修改单个字符
for (int i = 0; i < str1.size(); i++) {
//str1[i] = 'x';
str1.at(i) = 'x';
}
cout << str1 << endl;
}
int main() {
test();
return 0;
}
3.1.8 string插入与删除
void test() {
string str1 = "abcde";
string str2 = "123";
//从第2号位置插入字符串str2<插入字符串后的首位置为2>
str1.insert(2, str2);
cout << str1 << endl;
//删除第2号位置起的3个字符
str1.erase(2, 3);
cout << str1 << endl;
}
int main() {
test();
return 0;
}
3.1.9 string子串
void test() {
string email = "[email protected]";
int pos = email.find('@');
//从第0号位置开始，截取pos个字符
string sub_name = email.substr(0, pos);
cout << sub_name << endl;
}
int main() {
test();
return 0;
}
3.2 vector容器
3.2.1 vector基本概念
3.2.2 vector构造函数
#include3.2.3 vector赋值操作
vector<int> v1;
for (int i = 0; i < 10; i++) {
v1.push_back(i * 6 + 8);
}
vector<int> v2;
v2 = v1;
vector<int> v3;
v3.assign(v1.begin(), v1.end());
vector<int> v4;
v4.assign(10,100);
3.2.4 vector容量和大小
#include3.2.5 vector插入与删除
#include3.2.6 vector数据存取
#include3.2.7 vector互换容器
#include(v3)为匿名对象，系统自动回收
vector<int>(v3).swap(v3);
cout << "v3的容量为： " << v3.capacity() << endl;
cout << "v3的大小为： " << v3.size() << endl;
}
int main() {
test();
return 0;
}
3.2.8 vector预留空间
#include3.3 deque容器
3.3.1 deque容器基本概念
3.3.2 deque构造函数
#include3.3.3 deque赋值操作
3.3.4 deque大小操作
3.3.5 deque插入与删除
deque<int> d1;
deque<int> d2;
//在指定位置插入区间值
d1.insert(d1.begin(),d2.begin(),d2.end())
3.3.6 deque数据存取
3.3.7 deque排序
#include3.4 案例 – 评委打分
3.4.1 案例描述
3.4.2 实现步骤
3.4.3 案例实现
#include3.5 stack容器
3.5.1 stack基本概念
- 栈不允许有遍历行为
- 栈可以判断容器是否为空 empty()
- 栈可以返回元素个数 size()
3.5.2 stack常用接口
#include3.6 queue容器
3.6.1 queue基本概念
- 队列不允许有遍历行为
- 队列可以判断容器是否为空 empty()
- 队列可以返回元素个数 size()
3.6.2 queue常用接口
#include3.7 list容器
3.7.1 list基本概念
- 链表可以在任意位置进行快速的插入或删除元素
- 链表动态分配存储，不会造成内存浪费
- 链表遍历速度慢
- 链表占用空间大
- List链表中，插入和删除元素不会造成原有list迭代器的失效，而vector是不成立的（内存满了之后另开一处空间进行存储）
3.7.2 list构造函数
#include
void printList(const list<int> &L) {
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test() {
//默认构造
list<int> L1;
for (int i = 0; i < 10; i++) {
L1.push_back(i * 2 + 3);
}
printList(L1);
//区间构造
list<int> L2(L1.begin(), L1.end());
printList(L2);
//拷贝构造
list<int> L3(L2);
printList(L3);
}
int main() {
test();
return 0;
}
3.7.3 list赋值与交换
3.7.4 list大小操作
3.7.5 list插入与删除
#include
void printList(const list<int> &L) {
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test() {
list<int> L1;
for (int i = 0; i < 10; i++) {
L1.push_back(i % 2 );
}
printList(L1);
//insert插入
L1.insert(++L1.begin(), 2, 3);
printList(L1);
//erase删除
L1.erase(++L1.begin());
printList(L1);
//remove删除,删除容器中所有指定的元素值
L1.remove(0);
printList(L1);
}
int main() {
test();
return 0;
}
3.7.6 list数据存取
3.7.7 list反转与排序
#include
void printList(const list<int> &L) {
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//排序的判断函数
bool myCompare(int v1, int v2) {
return v1 > v2;
}
void test() {
list<int> L1;
for (int i = 0; i < 10; i++) {
L1.push_back((i % 2) * 6 + i);
}
printList(L1);
L1.reverse();
cout << "反转后的链表： " << endl;
printList(L1);
L1.sort();//默认升序
cout << "排序后的链表： " << endl;
printList(L1);
//降序排列操作
L1.sort(myCompare);
printList(L1);
//所有不支持随机访问迭代器的容器，不可以用标准算法(eg:sort())（全局函数）
//不支持随机访问迭代器的容器，内部会提供对应的算法（成员函数）
}
int main() {
test();
return 0;
}
3.7.8 list排序案例
#include
#include3.8 set/multiset容器
3.8.1 set基本概念
3.8.2 set构造和赋值
#include3.8.3 set大小和交换
3.8.4 set插入与删除
3.8.5 set查找和统计
#include3.8.6 set和multiset区别
#include3.8.7 pair对组创建
void test() {
//第一种
pair<int, string> p1(1, "a");
cout << p1.first << " " << p1.second << endl;
//第二种
pair<int, string> p2 = make_pair(2, "b");
cout << p2.first << " " << p2.second << endl;
}
int main() {
test();
return 0;
}
3.8.8 set容器排序
#include3.9 map/multimap容器
3.9.1 map基本概念
3.9.2 map构造和赋值
#include
void printMap(const map<int, int> &m) {
for (map<int, int>::const_iterator it = m.begin(); it != m.end(); it++) {
cout << it->first << "\t" << it->second << endl;
}
}
void test() {
map<int, int> m1;
for (int i = 0; i < 10; i++) {
//插入元素要使用对组pair
m1.insert(pair<int, int>(i, rand() % 41 + 60));
}
printMap(m1);
}
int main() {
srand((unsigned)time(NULL));
test();
return 0;
}
3.9.3 map大小和交换
3.9.4 map插入与删除
#include
void printMap(const map<int, int> &m) {
for (map<int, int>::const_iterator it = m.begin(); it != m.end(); it++) {
cout << it->first << "\t" << it->second << endl;
}
}
void test() {
map<int, int> m1;
//第一种
m1.insert(pair<int, int>(5, 10));
//第二种
m1.insert(make_pair(4, 20));
//第三种
m1.insert(map<int, int>::value_type(3, 30));
//第四种 不建议用于插入数据 可以用于读取value值
//m1[2] = 40;
//cout << m1[3] << endl;
printMap(m1);
m1.erase(m1.begin());
printMap(m1);
//根据key值进行删除
m1.erase(4);
printMap(m1);
m1.erase(m1.begin(),m1.end());
printMap(m1);
}
int main() {
srand((unsigned)time(NULL));
test();
return 0;
}
3.9.5 map查找和统计
3.9.6 map容器排序
#include
class mapCompare {
public:
bool operator()(int v1, int v2) {
return v1 > v2;
}
};
void printMap(const map<int, int, mapCompare> &m) {
for (map<int, int, mapCompare>::const_iterator it = m.begin(); it != m.end(); it++) {
cout << it->first << "\t" << it->second << endl;
}
}
void test() {
map<int, int, mapCompare> m1;
for (int i = 0; i < 10; i++) {
m1.insert(make_pair(i, rand() % 41 + 60));
}
printMap(m1);
}
int main() {
srand((unsigned)time(NULL));
test();
return 0;
}
3.10 案例 – 员工分组
3.10.1 案例描述
3.10.2 实现步骤
3.10.3 案例实现
#include4 STL-函数对象
4.1 函数对象
4.1.1 函数对象概念
4.1.2 函数对象使用
class myPrint {
public:
//函数对象相较于普通函数，可以有自己的状态，可以统计次数等
int count;
myPrint() {
this->count = 0;
}
void operator()(string text) {
cout << text << endl;
count++;
}
};
//函数对象可以作为参数传递
void print_test(myPrint &mP, string text) {
for (int i = 0; i < 5; i++) {
mP(text);
}
cout << mP.count << endl;
}
void test() {
//函数对象创建
myPrint mP;
string text = "hello world";
print_test(mP, text);
}
int main() {
srand((unsigned)time(NULL));
test();
return 0;
}
4.2 谓词
4.2.1 谓词概念
- 谓词体现在返回类型，元数 体现在参数个数
4.2.1 一元谓词
#include4.2.1 二元谓词
#include4.3 内建函数对象
4.3.1 内建函数对象意义
4.3.2 算术仿函数
#include4.3.3 关系仿函数
#include() 内建大于函数的匿名函数对象
sort(v.begin(), v.end(), greater<int>());
for (vector<int>::iterator pos = v.begin(); pos != v.end(); pos++) {
cout << *pos << " ";
}
cout << endl;
}
int main() {
srand((unsigned)time(NULL));
test();
return 0;
}
4.3.4 逻辑仿函数
#include5 STL-常用算法
5.1 常用遍历算法
5.1.1 for_each
#include5.1.2 transform
#include5.2 常用查找算法
5.2.1 find
#include5.2.2 find_if
#include5.2.3 adjacent_find
5.2.4 binary_search
- 必须是有序排布的容器（递增或递减）
5.2.5 count
#include5.2.6 count_find
#include5.3 常用排序算法
5.3.1 sort
#include5.3.2 random_shuffle
//随机数种子
srand((unsigned)time(NULL));
5.3.3 merge
#include5.3.4 reverse
5.4 常用拷贝和替换算法
5.4.1 copy
5.4.2 replace
#include5.4.3 replace_if
#include5.4.4 swap
5.5 常用算术生成算法
5.5.1 accumulate
#include5.5.2 fill
5.6 常用集合算法
5.6.1 set_intersection
#include5.6.2 set_union
//目标容器大小
vTarget.resize(v1.size() + v2.size());
5.6.3 set_difference
- 差集是所有元素除去交集部分后剩下的元素
- v1与v2的差集 和 v2对与v1的差集 结果不同
//目标容器大小
vTarget.resize(max(v1.size(), v2.size()));