本文主要探讨c++的stl相关知识:模版，容器，泛型算法，萃取特化，智能指针等。
模版
模板typename和class均可定义
模板参数可是类型,还可是值
模板编译根据调用实参类型推导参数类型
编译器用值的类型实例化模板,用指针类型实例化模板,去除const修饰
float,class-type类型对象,内链接对象作为非类型模板参数
容器
容器类=数据结构 + 算法
序列容器:位置与元素值无关:array、vector、deque、list、forward_list
关联容器：数据插入时自动从小到大排列:set、multiset、map、mutilmap
无序关联容器:元素未排序的:unordered_set，unordered_mapunordered_multiset,unordered_multimap
array:固定数组,可随机访问,不能添加或删除元素
vector:可变数组,可随机访问,尾部外位置插入或删除元素慢
string:存储字符,可随机访问,尾部插入或删除快(大小可变)
deque:双端队列,可随机访问,头尾插入或删除快
forward_list:单链表,可单顺序访问,任何位置插入或删除快
list:双向链表,可双向顺序访问,任何位置插入或删除快
set:有序容器,元素在集合中是唯一,用红黑树实现,插入、删除和查找时间复杂度为(log n)
map:有序键值对容器,键在 map 中是唯一且键值唯一,用红黑树实现,插入、删除和查找操时间复杂度为(log n)
multimap:关键字可重复出现的map
multiset:关键字可重复出现的set
arry
array是固定大小数组容器,默认构造非空
长度为零时array.begin() == array.end(),拥有唯一值,front()和back()未定义
swap时迭代器指向同一array元素并将改变元素的值
begin()返回首元素迭代器,end()返回尾元素迭代器,rbegin()返回尾元素逆向迭代器,rend()返回首元素逆向迭代器,cbegin()同begin(),cend()同end(),crbegin()同rbegin(),crend()同rend(),增加了 const 属性
size()返回当前元素数量(N)同max_size(),empty()判断容器是否为空
at(n)返回元素n引用且检查越界抛出异常out_of_range,front()返回首元素引用,back()返回末尾元素引用,data()返回首元素指针
fill(n)设置每个元素值为n,m.swap(n)交换m和n中所有元素(长度和类型相同),swap(m,n)交换m和n中所有元素
operator==检查是否有相同数量元素且同位置元素是否相等
重载get()全局函数访问容器指定元素并返回引用
Vector
动态数组序列容器,元素连续存储可通过迭代器和指针访问元素
assign()替换容器中的内容
max_size()返回理论上的最大值
reserve()修改容器容量
capacity()返回当前分配的存储容量
shrink_to_fit()清除未使用的容量
clear()清除所有元素
insert()指定位置插入元素,返回插首元素的迭代器
emplace()在位置前插入元素,返回插入元素的迭代器
erase()清除指定的元素
push_back()追加元素到容器尾部
emplace_back()在容器末尾构造元素(调用构造函数)
pop_bak()移除末尾元素
resize()改变元素大小
string
operator=初始化字符串
c_str返回c风格的字符串
size(),length()字符串大小
append(),operator+=追加的字符串尾部
replace()替换字符串
find()查找字符串
find_first_of()寻找字符首次出现的位置,找到返回字符位置,找不到返回npos
find_last_of()寻找字符最后次出现的位置
find_first_not_of()寻找字符首次丢失的位置
find_last_not_of()寻找字符最后丢失的位置
stoi,stol,stoll转换字符串为有符号整数
stoul,stoull转换字符串为无符号整数
stof,stod,stold转换字符串为浮点值
to_string转换整数或浮点值为string
to_wstring转换整数或浮点值为wstring
deque
有索引序列容器,允许首尾插入及删除
与vector相反,deque元素不连续,按需扩张
push_front()前附给定元素到容器起始
emplace_front()在容器起始构造元素(调用构造函数)
pop_front()移除容器首元素
forward_list
单链表,任何位置插入和移除元素,不支持随机访问
before_begin(),cbefore_begin()返回指向首元素前一元素迭代器,此元素表现为占位符,试图访问会导致未定义行为
insert_after()在位置元素后插入
emplace_after()在容器末尾构造元素(调用构造函数)
erase_after()从容器移除指定元素
merge()链表合并,other与this指一对象时没有操作,被合并链表为空
splice_after()从另一forward_list移动元素到*this,元素插入指向元素后,被移动元素的链表缺少该元素
remove(),remove_if()移除所有满足标准元素,只有指向被移除元素迭代器和引用会失效
reserve()逆转元素顺序,迭代器和引用不会失效
unique()删除连续重复元素
sort()排序元素(升序),不会导致迭代器和引用失效
list
带头双向循环链表,任意位置进行插入和删除,不支持[]随机访问
set
关联容器,含有Key类型对象排序集
count()返回有key元素数(0,1)
find()寻找键key元素,返回值指向元素迭代器,未找到则返回尾后迭代器
contains()检查容器是否有key
equal_range()返回键元素范围,范围有两个迭代器(该元素迭代器以及下一元素迭代器)
lower_bound()返回指向首个>=key 元素迭代器
upper_bound()返回指向首个<=key 元素迭代器
map
有序关联容器,包含具有唯一键键值对,map实现为红黑树
insert_or_assign() key存在则赋值给当前key,不存在则建立key在赋值
emplace_hint()向容器中尽可能接近紧接元素之前的位置插入新元素
multiset:Key类型对象有序集,允许多个Key有相同值
multimap:关联容器,键值对已排序列表,多个元素可拥有同一键
unordered_set
无序关联容器
bucket_count()返回容器中的桶数
max_bucket_count()返回容器最大桶数
bucket_size()返回桶中的元素数
bucket()返回键key桶索引
load_factor()返回平均每桶元素数即size()/bucket_count()
max_load_factor()管理最大加载因子(每个桶的平均元素数),加载因子超出阈值,增加桶数,返回最大加载因子
rehash()设置桶数为不小于count且>=size()/max_load_factor()
reserve()设置桶数至少count个元素且不超出最大加载因子
unordered_map:无序关联容器,有带唯一键的键值对
unordered_multiset:键的集合,按照键生成散列
unordered_multimap:键值对的集合,按照键生成散列
stack:适配一个容器以提供栈
queue:适配一个容器以提供队列
priority_queue:适配一个容器以提供优先级队列
flat_set:调整容器以提供按键排序的唯一键集合
flat_map:适配两个容器以提供按唯一键排序的键值对集合
flat_multiset:调整容器以提供按关键字排序的关键字集合
flat_multimap:适配两个容器以提供按键排序的键值对集合
span:连续的对象序列上的无所有权视图
mdspan:多维非拥有数组视图
泛型算法
容器是数据封装,泛型算法是数据操作方法
谓词函数,数据操作函数:函数,函数指针,lambda,函数对象
lambda:[捕获] (传参) mutable或exception声明 ->返回类型 {}
最简lambda:[](){},调用:[](){}();
lambda捕获列表
[]:不捕获
[=]值捕获包括所在类的this
[&]引用捕获包括所在类this
[this]捕获所在类this
[a]值捕获a
[&a]引用捕获a
[a,&b]值捕获a,引用捕获b
[=,&a,&b]引用捕获a和b其余值捕获
[&,a,b]值捕获a和b其余引用捕获
不修改序列操作
for_each(first,last,fun)对范围[first,last)中迭代器解引用传给函数对象fun
all_of(first,last,fun)对范围[first,last)中迭代器解引用传给函数对象fun,所有元素满足func返回true
none_of(first,last,fun)对范围[first,last)中迭代器解引用传给函数对象fun,所有元素不满足func返回true
any_of(first,last,fun)对范围[first,last)中迭代器解引用传给函数对象fun,有元素满足func返回true
find(first,last,num)对范围[first,last)中迭代器解引用传给函数对象fun,有元素等于num返回该元素迭代器
find_if(first,last,fun)对范围[first,last)中迭代器解引用传给函数对象fun,有元素满足fun返回该元素迭代器
find_if_not(first,last,fun)对范围[first,last)中迭代器解引用传给函数对象fun,有元素不满足fun返回该元素迭代器
find_end(first,last,f,l,fun)在范围[first, last)中搜索范围[f,s)经过fun处理元素迭代器
find_first_of(first,last,f,l,fun)在范围 [first, last)中搜索范围[f,l)经过fun处理元素,返回搜索到的第一个元素迭代器
count/count_if(first,last,fun/num)返回范围[first, last中满足fun/num元素数
mismatch(first,last,f,l)返回两个范围内首次出现不同的元素
search(first,last,f,l,fun)在范围 [first, last)中搜索范围[f,l)经过fun处理元素,返回搜索到的第一个元素迭代器
serach_n在范围[first,last,count,value,fun)中搜索count个等同元素的序列,每个都等于给定的值 value,fun(*first,value),返回搜索到的第一个元素迭代器
修改序列的操作
copy(first,last,f)/copy_if(first,last,f,fun)复制范围[first, last)中的元素到从f开始的另一范围,返回目标最后下一个元素输出迭代器
copy_n(frist,num,f)从first开始复制num个元素到f开始的地方,返回目标最后下一个元素输出迭代器否则返回f
copy_backward(first,last,l)复制范围[first, last)中的元素到范围尾部(l为尾部迭代器),返回最后复制的元素
move(first,last,f)复制范围[first, last)中的元素到从f开始的另一范围,返回目标最后下一个元素输出迭代器
move_bakcward(first,last,l)复制范围[first, last)中的元素到范围尾部(l为尾部迭代器),返回最后复制的元素
swap(a,b)交换a,b,iter_swap(a,b)交换两个迭代器指向的元素
swap_ranges(first,last,f)交换范围[first,last)中的元素到从f开始的另一范围
replace(first,last,old,new)/replace_if(first,last,fun,new)替换来自范围[first, last)的元素到始于f范围,复制过程中以new(fun(*first))替换所有满足特定判别标准的元素
replace_copy_if(first,last,f,fun,new)复制来自范围[first, last)的元素到始于f范围,复制过程中以new(fun(*first)) 替换所有满足特定判别标准的元素
fill(first,last,num)用num填充范围[first, last)的元素
fill(first,count,num)用num填充起始范围first的count个元素值为num
generate(first,last,fun)将fun产生的数赋值给[first, last)的元素
generate(first,count,fun)将fun产生的数赋值给first起始的count个元素
remove(first,last,value)/remove_if(first,last,fun)移除范围内value或fun返回值
remove_copy(first,last,f,value)/remove_copy_if(first,last,f,fun)复制范围内的元素到f,并移除value或fun返回值
unique_copy(first, last,f)从范围[first, last)复制元素到从f开始的另一范围,使得目标范围不存在连续的相等元素
reverse(first, last)/reverse_copy(first, last,f)反序
rotate_copy(first,n_f,last,f)从范围[first, last)复制元素到始于f的另一范围,使得 *n_f成为新范围的首元素而 *(n_f-1)为末元素
排序操作
sort将范围按升序排序
stable_sort将范围内的元素排序,同时保持相等的元素之间的顺序
partial_sort排序一个范围的前 N 个元素
partial_sort_copy对范围内的元素进行复制并部分排序
is_sorted检查范围是否已按升序排列
is_sorted_until找出最大的有序子范围
nth_element将给定的范围部分排序,确保其按给定元素划分
二分搜索操作
lower_bound返回指向第一个不小于给定值的元素的迭代器
upper_bound返回指向第一个大于给定值的元素的迭代器
equal_range返回匹配特定键值的元素范围
binary_search确定元素是否存在于某部分有序的范围中
集合操作
includes若一个序列是另一个的子序列则返回 true
set_union计算两个集合的并集
set_intersection计算两个集合的交集
set_difference计算两个集合的差集
set_symmetric_difference计算两个集合的对称差
归并操作
merge合并两个有序范围
inplace_merge就地合并两个有序范围
堆操作
push_heap将一个元素加入到一个最大堆
pop_heap从最大堆中移除最大元素
make_heap从一个元素范围创建出一个最大堆
sort_heap将一个最大堆变成一个按升序排序的元素范围
is_heap检查给定范围是否为一个最大堆
is_heap_until查找能成为最大堆的最大子范围
最小/最大操作
max返回各给定值中的较大者
max_element返回范围内的最大元素
min返回各给定值中的较小者
min_element返回范围内的最小元素
minmax返回两个元素的较小和较大者
minmax_element返回范围内的最小元素和最大元素
萃取和特化
模板特化类似函数重载,编译链接时确定
优先级:同名函数>全特化>偏特化>泛化
全特化所有模板类型为具体类型
偏特化部分特化原模板的类型
区分T是源生类型或自定义类型
POD(原生类型)int、double,char,float等,本质是没有高级特征(构造析构,虚函数等)
POD memcpy可用,非POD类型需循环拷贝
is_pod判断是否是pod类型
智能指针
智能指针本身是类
智能指针解决内存泄漏问题,连带自动释放内存
智能指针本质原理:利用对象释放时会自动调用析构函数特性
unique_ptr对象不可复制(=),可移动(move)
unique_ptr同时间只指向一个对象,指向新对象时,之前对象被释放
unique_ptr本身被释放时,对象也释放
unique_ptr不能进行赋值和拷贝构造
release()释放被管理对象的所有权,返回被管理对象指针,无被管理对象返回nullptr
reset(对象)替换被管理对象,若旧对象为非空则调用删除器删除
swap()交换被管理对象和关联删除器
get()返回被管理对象指针,无对象返回nullptr
get_deleter()返回会用于析构被管理对象的删除器对象
shared_ptr基于引用计数设计,多个智能指针绑定1个对象
shared_ptr使用构造函数或make_shared方法构造
shared_ptr释放指针对象,调用Deleter,再调析构释放
use_count()管理当前对象的shared_ptr实例数量
unique()管理当前对象的shared_ptr实例数量为1(use_count() = 1)返回true否则false
make_shared()创建管理一个新对象的共享指针
weak_ptr不管理shared_ptr内部指针,没有*和->操作符
weak_ptr不共享指针,不操作资源,构造和析构不影响引用计数
weak_ptr监视shared_ptr中管理资源是否存在
expired()管理对象删除为true否则为false(use_count() = 0)
lock()若无共享对象返回false,否则返回shared_ptr对象
reset()释放被管理对象的所有权(use_count() = 0)
demo1:
模版
目录：
run.sh
#!/bin/bash
if [ -f ./Makefile ]
then
make clean
fi
cmake .
make
echo "---------------------------------"
./proclean.sh
#!/bin/bash
rm -rf CMakeFiles pro Makefile CMakeCache.txt cmake_install.cmakecheck_mem.sh
valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes -s ./proCMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 2.20) #最低版本要求
SET(CMAKE_CXX_COMPILER "g++-11") #设置g++编译器
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") #添加编译选项
PROJECT(CLASS) #设置工程名
MESSAGE(STATUS "template test") #打印消息
ADD_EXECUTABLE(pro main.cpp) #生成可执行文件main.cpp
#include <iostream>
using namespace std;
template <typename T1,typename T2>
class Person
{
private:
T1 argv1;
T2 argv2;
public:
Person(){};
Person(T1 argv1,T2 argv2);
void printf_info();
void operator+=(Person<T1,T2> p);
template <typename U1,typename U2>
friend Person<U1,U2> operator+(Person<U1,U2> p1,Person<U1,U2> p2);
};
template <typename T1,typename T2>
class Man:public Person<T1,T2>
{
public:
T1 argv1;
T2 argv2;
Man(T1 argv1,T2 argv2):Person<T1,T2>(argv1,argv2),argv1(argv1),argv2(argv2){};
};
template <typename T1,typename T2>
Person<T1,T2>::Person(T1 argv1,T2 argv2)
{
this->argv1 = argv1;
this->argv2 = argv2;
}
template <typename X,int ARRY_SIZE>
class Arry
{
private:
X ar[ARRY_SIZE] = {0};
public:
void set_arry();
void printf_arry();
};
template <typename T1,typename T2>
void Person<T1,T2>::printf_info()
{
string s = typeid(this->argv1).name();
if(s == "i")
{
cout << "name :" << this->argv2 << endl;
cout << "age :" << this->argv1 << endl;
}
else
{
cout << "name :" << this->argv1 << endl;
cout << "age :" << this->argv2 << endl;
}
}
template <typename T1,typename T2>
void Person<T1,T2>::operator+=(Person<T1,T2> p)
{
this->argv1 += p.argv1;
this->argv2 += p.argv2;
}
template <typename T1,typename T2>
Person<T1,T2> operator+(Person<T1,T2> p1,Person<T1,T2> p2)
{
Person<T1,T2> tmp;
tmp.argv1 = p1.argv1 + p2.argv1;
tmp.argv2 = p1.argv2 + p2.argv2;
return tmp;
}
template <typename X,int ARRY_SIZE>
void Arry<X,ARRY_SIZE>::set_arry()
{
for(int i = 0;i < ARRY_SIZE ;i++)
ar[i] = i;
}
template <typename X,int ARRY_SIZE>
void Arry<X,ARRY_SIZE>::printf_arry()
{
for(int i = 0;i < ARRY_SIZE ;i++)
cout << ar[i] << " ";
cout << endl;
}
int main()
{
Person<int,string> p1(10,"hello");
Person<int,string> p2(10," word");
Person<int,string> p3 = p1 + p2;
Person<int,string> p4(10,"!");
p3 += p4,
p3.printf_info();
Man<int,string> m(20,"xiaoming");
m.printf_info();
m.Person::printf_info();
Arry<int,3> a;
a.set_arry();
a.printf_arry();
return 0;
}结果示例：
demo2:
string
目录：
run.sh
#!/bin/bash
if [ -f ./Makefile ]
then
make clean
fi
cmake .
make
echo "---------------------------------"
./procheck_mem.sh
valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes -s ./proclean.sh
#!/bin/bash
rm -rf CMakeFiles pro Makefile CMakeCache.txt cmake_install.cmakeCMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 2.20) #最低版本要求
SET(CMAKE_CXX_COMPILER "g++-11") #设置g++编译器
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") #添加编译选项
PROJECT(CLASS) #设置工程名
MESSAGE(STATUS "string test") #打印消息
ADD_EXECUTABLE(pro main.cpp) #生成可执行文件main.cpp
#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
string s = "hello word";
cout << "s.size():" << s.size() << endl;
cout << "s.length():" << s.length() << endl;
s += "!!!";
cout << "s:" << s << endl;
const char *p = s.c_str();
printf("s:%s\n",p);
auto f = s.find('w');
s.replace(f,4,"cxb");
cout << "s:" << s << endl;
if (s.find_first_of('u') == string::npos)
cout << "s have no 'u'" << endl;
string str = s.substr(0,5);
cout << "str:" << str << endl;
string name;
getline(cin,name);
cout << "name:" << name << endl;
int n = stoi("100");
cout << "n(int):" << n << endl;
string num = to_string(n);
cout << "num(string):" << num << endl;
return 0;
}结果示例：
demo3：
容器
目录：
run.sh
#!/bin/bash
if [ -f ./Makefile ]
then
make clean
fi
cmake .
make
echo "---------------------------------"
./procheck_mem.sh
valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes -s ./proclean.sh
#!/bin/bash
rm -rf CMakeFiles pro Makefile CMakeCache.txt cmake_install.cmakeCMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 2.20) #最低版本要求
SET(CMAKE_CXX_COMPILER "g++-11") #设置g++编译器
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") #添加编译选项
PROJECT(CLASS) #设置工程名
MESSAGE(STATUS "stl test") #打印消息
set(SRC_LIST main.cpp array.cpp vector.cpp deque.cpp forward_list.cpp list.cpp set.cpp map.cpp unordered_set.cpp stack.cpp queue.cpp priority_queue.cpp unordered_multimap.cpp)
ADD_EXECUTABLE(pro ${SRC_LIST}) #生成可执行文件main.cpp
#include <iostream>
#include "main.hpp"
using namespace std;
int main()
{
cout << "----------------------stl_array---------------------" << endl;
stl_array();
cout << "----------------------stl_vector--------------------" << endl;
stl_vector();
cout << "----------------------stl_deque---------------------" << endl;
stl_deque();
cout << "----------------------stl_forward_list--------------" << endl;
stl_forward_list();
cout << "----------------------stl_list----------------------" << endl;
stl_list();
cout << "----------------------stl_set-----------------------" << endl;
stl_set();
cout << "----------------------stl_map-----------------------" << endl;
stl_map();
cout << "----------------------stl_unordered_set-------------" << endl;
stl_unordered_set();
cout << "----------------------stl_stack---------------------" << endl;
stl_stack();
cout << "----------------------stl_queue---------------------" << endl;
stl_queue();
cout << "----------------------stl_priority_queue------------" << endl;
stl_priority_queue();
cout << "----------------------stl_unordered_multimap--------" << endl;
stl_unordered_multimap();
return 0;
}main.hpp
#ifndef __MAIN_HPP
#define __MAIN_HPP
void stl_array();
void stl_vector();
void stl_deque();
void stl_forward_list();
void stl_list();
void stl_set();
void stl_map();
void stl_unordered_set();
void stl_stack();
void stl_queue();
void stl_priority_queue();
void stl_unordered_multimap();
#endifarray.cpp
#include <iostream>
#include <array>
using namespace std;
void stl_array()
{
array<int,3> a1 = {1,2,3};
array<int,3> a2;
array<int,3> a3;
a2 = a1;
cout << "a2.front:" << a2.front() << endl;
cout << "a2[2]:" << a2[1] << endl;
cout << "get<2>(a2):" << get<2>(a2) << endl;
cout << "a2.back:" << a2.back() << endl;
cout << "*(a2.data):" << *(a2.data()) << endl;
cout << "a2.empty():" << boolalpha << a2.empty() << endl;
cout << "a2.size():" << a2.size() << endl;
cout << "a2.max_size():" << a2.max_size() << endl;
cout << "a3.empty():" << boolalpha << a3.empty() << endl;
cout << "a3.size():" << a3.size() << endl;
cout << "a3.max_size():" << a3.max_size() << endl;
cout << "a1:";
for(auto i = a1.begin();i != a1.end();i++)
{
cout << *i << " ";
}
cout << endl;
cout << "a2:";
for(auto i = 0;i < a2.size();i++)
{
cout << a2.at(i) << " ";
}
cout << endl;
cout << "a2 reserve:";
for(auto i = a2.rbegin();i != a2.rend();i++)
{
cout << *i << " ";
}
cout << endl;
a3.fill(6);
cout << "a3:";
for(auto i = 0;i < a3.size();i++)
{
cout << a3.at(i) << " ";
}
cout << endl;
cout << "swap a1 a3 : " << endl;
a3.swap(a1);
cout << "a3:";
for(auto i = 0;i < a3.size();i++)
{
cout << a3.at(i) << " ";
}
cout << endl;
cout << "a1:";
for(auto i = a1.begin();i != a1.end();i++)
{
cout << *i << " ";
}
cout << endl;
}deque.cpp
#include <iostream>
#include <deque>
using namespace std;
template <typename T>
static void printf_queue(T const& q)
{
for(auto i : q)
cout << i << " ";
cout << endl;
}
void stl_deque()
{
deque<int> num;
num.push_front(1);
num.push_front(2);
num.push_front(3);
num.emplace_front(4);
num.emplace_front(5);
num.emplace_front(6);
cout << "num:";
printf_queue(num);
cout << "pop_front num:";
num.pop_front();
printf_queue(num);
}forward_list.cpp
#include <iostream>
#include <forward_list>
using namespace std;
template<typename T>
static void printf_forward_list(T const& n)
{
for(auto i : n)
cout << i << " ";
cout << endl;
}
void stl_forward_list()
{
forward_list<int> num;
forward_list<int> tmp = {7,8,9,10};
forward_list<int> num1 = {7,8,9,10};
num.insert_after(num.before_begin(),1);
num.insert_after(num.before_begin(),2);
num.insert_after(num.before_begin(),3);
cout << "insert_after num:" << endl;
printf_forward_list(num);
cout << "emplace_after num:";
num.emplace_after(num.before_begin(),4);
num.emplace_after(num.before_begin(),5);
num.emplace_after(num.before_begin(),6);
printf_forward_list(num);
cout << "tmp:";
printf_forward_list(tmp);
cout << "num.splice_after(num.before_begin(),tmp)" << endl;
num.splice_after(num.before_begin(),tmp);
cout << "tmp :";
printf_forward_list(tmp);
cout << "num :";
printf_forward_list(num);
cout << "num1:";
printf_forward_list(num1);
cout << "num.merge(num1)" << endl;
num.merge(num1);
cout << "num1:";
printf_forward_list(num1);
cout << "num:";
printf_forward_list(num);
cout << "sort num:";
num.sort();
printf_forward_list(num);
cout << "unique num:";
num.unique();
printf_forward_list(num);
cout << "reverse num:";
num.reverse();
printf_forward_list(num);
cout << "remove num:";
num.remove(10);
printf_forward_list(num);
cout << "erase_after num:";
num.erase_after(num.before_begin());
printf_forward_list(num);
cout << "num.erase_after(fi,la):";
auto fi = next(num.begin());
auto la = next(fi, 3);
cout << "fi:" << *(fi) << endl;
cout << "la:" << *(la) << endl;
num.erase_after(fi,la);
printf_forward_list(num);
}list.cpp
#include <iostream>
#include <list>
using namespace std;
template <typename T>
static void printf_list(T const& l)
{
for(auto i : l)
cout << i << " ";
cout << endl;
}
void stl_list()
{
list<int> num;
num.push_front(1);
num.push_front(2);
num.push_front(3);
num.emplace_front(4);
num.emplace_front(5);
num.emplace_front(6);
cout << "num:";
printf_list(num);
cout << "pop_front num:";
num.pop_front();
printf_list(num);
}map.cpp
#include <iostream>
#include <map>
using namespace std;
template<typename T>
static void printf_map(T const& m)
{
for(auto [key,value] : m)
cout << key << ":" << value << endl ;
}
void stl_map()
{
map<string,string> m = {{"name","xiaoming"},{"income","100"}};
m.insert(m.begin(),{"age","20"});
cout << "map:" << endl;
printf_map(m);
m.insert_or_assign("saving_count","2000");
m.insert_or_assign("income","1000");
auto tmp = m.find("name");
m.emplace_hint(tmp,"hobby","game");
cout << "new map:" << endl;
printf_map(m);
}priority_queue.cpp
#include <iostream>
#include <queue>
using namespace std;
void stl_priority_queue()
{
priority_queue<int> p;
p.push(1);
p.push(8);
p.push(5);
p.push(3);
p.push(2);
cout << "priority_queue:";
while(p.size())
{
cout << p.top() << " ";
p.pop();
}
cout << endl;
}queue.cpp
#include <iostream>
#include <queue>
using namespace std;
void stl_queue()
{
queue<string> q;
q.push("linux");
q.push("windows");
q.push("macos");
q.push("android");
q.push("harmonyos");
cout << "queue front :" << q.front() << endl;
cout << "queue back :" << q.back() << endl;
cout << "queue :";
while(!q.empty())
{
cout << q.front() << " ";
q.pop();
}
cout << endl;
}set.cpp
#include <iostream>
#include <set>
using namespace std;
template<typename T>
static void printf_set(T const& s)
{
for(auto i : s)
cout << i << " ";
cout << endl;
}
void stl_set()
{
set<int> s;
s.insert(s.begin(),1);
s.insert(s.begin(),1);
s.insert(s.begin(),1);
s.insert(s.begin(),2);
s.insert(s.begin(),3);
cout << "set :" ;
printf_set(s);
if(s.count(1))
cout << "set has 1 :" << s.count(1) << endl;
auto tmp = s.find(2);
if(tmp != s.end())
cout << "set has 2" << endl;
auto [b,e] = s.equal_range(2);
cout << "b = s.equal_range(2):" << *b << endl;
cout << "e = s.equal_range(2):" << *e << endl;
cout << "s.lower_bound():" << *(s.lower_bound(2)) << endl;
cout << "s.upper_bound():" << *(s.upper_bound(2)) << endl;
}stack.cpp
#include <iostream>
#include <stack>
using namespace std;
void stl_stack()
{
stack<int> s;
s.push(1);
s.push(2);
s.push(3);
s.push(4);
s.push(5);
cout << "stack :";
while(s.size() != 0)
{
cout << s.top() << " ";
s.pop();
}
cout << endl;
}unordered_multimap.cpp
#include <iostream>
#include <unordered_map>
using namespace std;
template<typename T>
static void print_unordered_multimap(T const& p)
{
for(auto i : p)
{
cout << "(" << i.first << "," << i.second << ")" << endl;
}
}
void stl_unordered_multimap()
{
unordered_multimap<int,string> p;
for(auto i = 0;i < 20;i++)
{
p.insert({i,"hello"});
cout << "{"<< i << ",helllo} " << "em size:" << p.size() << ",bucket size:" << p.bucket_count() << endl;
}
print_unordered_multimap(p);
cout << "p.bucket_size(p.bucket(1)):" << p.bucket_size(p.bucket(1)) << endl;
}
unordered_set.cpp
#include <iostream>
#include <unordered_set>
using namespace std;
template<typename T>
static void printf_unordered_set(T const& us)
{
for(auto i : us)
cout << i << " ";
cout << endl;
}
void stl_unordered_set()
{
unordered_set<int> us;
for(auto i = 0;i < 100;i++)
{
us.insert(i);
}
cout << "unordered_set:";
printf_unordered_set(us);
cout << "bucket_count:" << us.bucket_count() << endl;
cout << "max_bucket_count:" << us.max_bucket_count() << endl;
cout << "us.load_factor():" << us.load_factor() << endl;
cout << "us.max_load_factor():" << us.max_load_factor() << endl;
cout << "new unordered_set(us.rehash(10) us.reserve(3)):";
us.rehash(10);
us.reserve(3);
printf_unordered_set(us);
cout << "bucket_count:" << us.bucket_count() << endl;
cout << "max_bucket_count:" << us.max_bucket_count() << endl;
cout << "us.load_factor():" << us.load_factor() << endl;
cout << "us.max_load_factor():" << us.max_load_factor() << endl;
}vector.cpp
#include <iostream>
#include <vector>
using namespace std;
template <typename T>
static void printf_sentence(T const &s)
{
for(auto i : s)
cout << i ;
cout << endl;
cout << "sentence.capacity:" << s.capacity() << endl;
cout << "sentence.size:" << s.size() << endl;
cout << "sentence.max_size:" << s.max_size() << endl;
}
void stl_vector()
{
vector <char> sentence;
sentence.push_back('h');
sentence.push_back('e');
sentence.push_back('l');
sentence.push_back('l');
sentence.push_back('o');
sentence.push_back('\n');
cout << "sentence :";
printf_sentence(sentence);
cout << "assign sentence :";
sentence.assign({'w','o','r','d','!'});
printf_sentence(sentence);
cout << "insert sentence :";
sentence.insert(sentence.begin(),{'h','e','l','l','o',' '});
printf_sentence(sentence);
cout << "emplace sentence :";
sentence.emplace(sentence.end(),'!');
printf_sentence(sentence);
cout << "earse sentence :";
sentence.erase(sentence.end()-1);
sentence.erase(sentence.begin(),sentence.begin()+6);
printf_sentence(sentence);
cout << "emplace_back sentence :";
sentence.emplace_back('?');
printf_sentence(sentence);
cout << "pop_back sentence :";
sentence.pop_back();
printf_sentence(sentence);
cout << "resize sentence :";
sentence.resize(10);
printf_sentence(sentence);
cout << "shrink_to_fit sentence :";
sentence.shrink_to_fit();
printf_sentence(sentence);
cout << "clear sentence :";
sentence.clear();
printf_sentence(sentence);
}结果示例：
demo4:
泛型算法
目录：
run.sh
#!/bin/bash
if [ -f ./Makefile ]
then
make clean
fi
cmake .
make
echo "---------------------------------"
./procheck_mem.sh
valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes -s ./proclean.sh
#!/bin/bash
rm -rf CMakeFiles pro Makefile CMakeCache.txt cmake_install.cmakeCMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 2.20) #最低版本要求
SET(CMAKE_CXX_COMPILER "g++-11") #设置g++编译器
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") #添加编译选项
PROJECT(CLASS) #设置工程名
MESSAGE(STATUS "string test") #打印消息
ADD_EXECUTABLE(pro main.cpp) #生成可执行文件main.cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;
template<typename T>
class gt
{
public:
bool operator()(const T& f,const T& l)
{
return (f > l);
}
};
template<typename T>
static void print_vector(const T& v)
{
for(auto i : v)
cout << i << " ";
cout << endl;
}
auto even_num = [](const int& n)->bool{return (n % 2 == 0);};
auto grater_10 = [](const int& n){return (n > 10);};
int main()
{
vector<int> a = {1,6,3,9,7};
vector<int> b = {1,2,3,1,2,3,1,2,3};
vector<int> c = {1,3,8};
vector<int> d = {1,3,8};
vector<int> e = {1,3,9};
vector<int> f = {1,3,8};
vector<int> g = {1,3,8};
vector<int> h = {2,4,6};
vector<int> j = {2,4,1,2,2,2,2,4};
vector<int> k(6);
cout << "for_earch(f++) bfore:";
print_vector(a);
for_each(a.begin(),a.end(),[](int& f){f++;});
cout << "for_earch(f++) end:";
print_vector(a);
if(!(all_of(a.begin(),a.end(),even_num)))
cout << "all_of have no even_num" << endl;
if(any_of(a.begin(),a.end(),even_num))
cout << "any_of have even_num" << endl;
if(any_of(a.begin(),a.end(),grater_10))
cout << "none have num grater 10" << endl;
if(find(a.begin(),a.end(),10) != a.end())
cout << "find 9" << endl;
if(auto it = find_if(a.begin(),a.end(),even_num); it != a.end())
cout << "find if :the first em support even_num func :" << *it << endl;
if(auto it = find_if_not(a.begin(),a.end(),even_num); it != a.end())
cout << "find if :the first em not support even_num func :" << *it << endl;
for(auto t : {vector<int>{-1,-2,-3},{4,5,6}})
{
auto it = find_end(b.begin(),b.end(),t.begin(),t.end(),[](const int& bf,const int& tf) {return (abs(bf) == abs(tf));});
if(it == b.end())
{
cout << "{4,5,6} have no found" << endl;
}
else
{
cout << "{1,2,3} last pos:" << distance(b.begin(),it) << endl;
}
}
auto it = find_first_of(a.begin(),a.end(),c.begin(),c.end(),[](int& af,int& cf) {return ((af) == (++cf));});
if(it != a.end())
cout << "the first em of find_first_of func : " << *it << endl;
auto cn = count_if(a.begin(),b.begin(),even_num);
cout << "the even_num's num of a: " << cn << endl;
pair< vector<int>::iterator,vector<int>::iterator > p;
p = mismatch(d.begin(),d.end(),e.begin(),[](int& df,int& ef) {return ((++df) == (++ef));});
cout << "mismatch ,the firstly different em in two vector :" << *p.first << "," << *p.second << endl;
if(equal(f.begin(),f.end(),g.begin(),[](int& ff,int& gf) {return ((++ff) == (++gf));}))
cout << "g is same of f" << endl;
auto tmp = search(b.begin(),b.end(),h.begin(),h.end(),[](int& bf,int& hf) {return ((bf) == (hf/2));});
cout << "{1,2,3} last pos:" << distance(b.begin(),tmp) << endl;
auto sn = search_n(j.begin(),j.end(),2,2,[](const int& jf,const int& v) ->bool {return (jf == v);});
cout << "the first em pos:" << distance(j.begin(),sn) << endl;
cout << "copy :";
copy_if(a.begin(),a.end(),ostream_iterator<int>(cout," "),[](int& n){return(n %2 == 0);});
cout << endl;
cout << "copy_n :";
copy_n(a.begin(),2,ostream_iterator<int>(cout," "));
cout << endl;
cout << "copy_backward :";
copy_backward(a.begin(),a.end(),k.end());
print_vector(k);
cout << "move:";
move(a.begin(),a.end(),ostream_iterator<int>(cout," "));
cout << endl;
cout << "move_backward:";
move_backward(a.begin(),a.end(),k.end());
print_vector(k);
cout << "swap before b:";
print_vector(b);
cout << "swap before c:";
print_vector(c);
swap_ranges(c.begin(),c.end(),b.begin());
cout << "swap after b:";
print_vector(b);
cout << "swap after c:";
print_vector(c);
cout << "transform:";
transform(c.begin(),c.end(),c.begin(),c.begin(),[](const int& c1,const int c2){return (c1 + c2);});
print_vector(c);
cout << "replace_if:";
replace_if(a.begin(),a.end(),even_num,2);
print_vector(a);
cout << "replace_copy_if:";
replace_copy_if(a.begin(),a.end(),ostream_iterator<int>(cout," "),even_num,1);
cout << endl;
cout << "fill:";
fill(a.begin(),a.end(),6);
print_vector(a);
cout << "fill_n:";
fill_n(a.begin(),3,2);
print_vector(a);
cout << "generate:";
generate(a.begin(),a.end(),[n = 0]() mutable {return n++;});
print_vector(a);
cout << "generate_n:";
generate_n(ostream_iterator<int>(cout," "),3,[n = 0]() mutable {return n++;});
cout << endl;
cout << "remove:";
a.erase(remove_if(a.begin(),a.end(),even_num),a.end());
print_vector(a);
cout << "remove_copy_if:";
remove_copy_if(b.begin(),b.end(),ostream_iterator<int>(cout," "),even_num);
cout << endl;
cout << "uniqe before:";
print_vector(j);
unique(j.begin(),j.end());
cout << "uniqe after:";
print_vector(j);
cout << "reverse:";
reverse(j.begin(),j.end());
print_vector(j);
cout << "reverse_copy:";
reverse_copy(j.begin(),j.end(),ostream_iterator<int>(cout," "));
cout << endl;
cout << "rotate:";
rotate(j.begin(),j.begin()+1,j.end());
print_vector(j);
cout << "rotate_copy:";
rotate_copy(j.begin(),j.begin()+3,j.end(),ostream_iterator<int>(cout," "));
cout << endl;
cout << "sort:";
sort(j.begin(),j.end());
print_vector(j);
cout << "sort:";
sort(j.begin(),j.end(),gt<int>());
print_vector(j);
cout << "stable_sort";
struct people
{
int num;
string name;
};
vector<people> pe{{2,"xiaoming"},{1,"xiaohua"},{2,"xiaoli"}};
stable_sort(pe.begin(),pe.end(),[](const people& f,const people& l){return (f.num > l.num);});
for(auto i : pe)
cout << "{" << i.num << "," << i.name << "} ";
cout << endl;
cout << "upper_bound:";
auto ub = upper_bound(c.begin(),c.end(),3);
cout << *ub << endl;
cout << "b:";
sort(b.begin(),b.end());
print_vector(b);
cout << "c:";
print_vector(c);
cout << "merge:";
merge(b.begin(),b.end(),c.begin(),c.end(),ostream_iterator<int>(cout," "));
cout << endl;
return 0;
}执行结果：
demo5:
特化萃取
目录：
run.sh
#!/bin/bash
if [ -f ./Makefile ]
then
make clean
fi
cmake .
make
echo "---------------------------------"
./proclean.sh
#!/bin/bash
rm -rf CMakeFiles pro Makefile CMakeCache.txt cmake_install.cmakecheck_mem.sh
valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes -s ./proCMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 2.20) #最低版本要求
SET(CMAKE_CXX_COMPILER "g++-11") #设置g++编译器
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") #添加编译选项
PROJECT(CLASS) #设置工程名
MESSAGE(STATUS "template test") #打印消息
ADD_EXECUTABLE(pro main.cpp) #生成可执行文件main.cpp
#include <iostream>
#include <cstring>
using namespace std;
//函数模版
template<typename T>
void comp(const T& f,const T& l)
{
if(f > l)
{
cout << f << " > " << l << endl;
}
else
{
cout << f << " < " << l << endl;
}
}
//函数模版特化
template<>
void comp(const string& f,const string& l)
{
if(f.size() > l.size())
{
cout << "string :" << f << " > " << l << endl;
}
else
{
cout << "string :" << f << " < " << l << endl;
}
}
void comp(const char *f,const char *l)
{
if(strlen(f) > strlen(l))
{
cout << "char* :" << strlen(f) << " > " << strlen(l) << endl;
}
else
{
cout << "char* :" << strlen(f) << " < " << strlen(l) << endl;
}
}
//类模版
template<typename T1,typename T2>
class Argv
{
public:
Argv(){};
Argv(T1 argv1,T2 argv)
{
this->argv1 = argv1;
this->argv = argv;
}
void print_info()
{
cout << "<T1,T2> argv1 : " << argv1 << "," << "argv :" << argv << endl;
}
private:
T1 argv1;
T2 argv;
};
//类模版偏特化
template<typename T>
class Argv<T,int>
{
public:
Argv(){};
Argv(T argv1,int argv)
{
this->argv1 = argv1;
this->argv = argv;
}
void print_info()
{
cout << "<T> argv1 : " << argv1 << "," << "argv :" << argv << endl;
}
private:
T argv1;
int argv;
};
template<typename T>
class Argv<T *,int>
{
public:
Argv(){};
Argv(T argv1,int argv)
{
this->argv1 = argv1;
this->argv = argv;
}
void print_info()
{
cout << "<T*> argv1 : " << argv1 << "," << "argv :" << argv << endl;
}
private:
T argv1;
int argv;
};
template<typename T>
class Argv<T&,int>
{
public:
Argv(){};
Argv(T argv1,int argv)
{
this->argv1 = argv1;
this->argv = argv;
}
void print_info()
{
cout << "<T&> argv1 : " << argv1 << "," << "argv :" << argv << endl;
}
private:
T argv1;
int argv;
};
//类模版全特化
template<>
class Argv<string,int>
{
public:
Argv(){};
Argv(string argv1,int argv)
{
this->argv1 = argv1;
this->argv = argv;
}
void print_info()
{
cout << "<string,int> argv1 : " << argv1 << "," << "argv :" << argv << endl;
}
private:
string argv1;
int argv;
};
template<typename T>
void copy_t(T* dest,const T* src,const int cnt)
{
if(is_pod<T>::value)
{
cout << "is_pod ";
memcpy(dest,src,cnt*sizeof(T));
}
else
{
cout << "is not pod ";
for(auto i = 0;i < cnt;i++)
{
dest[i] = src[i];
}
}
}
void copy_t(string &dest,string &src)
{
dest = src;
}
//萃取实现is_pod
template<typename T>
class is_pod_t
{
public:
static bool value;
};
template<typename T>
bool is_pod_t<T>::value = false;
template<>
class is_pod_t<int>
{
public:
static bool value;
};
bool is_pod_t<int>::value = true;
template<>
class is_pod_t<char>
{
public:
static bool value;
};
bool is_pod_t<char>::value = true;
template<>
class is_pod_t<float>
{
public:
static bool value;
};
bool is_pod_t<float>::value = true;
template<>
class is_pod_t<double>
{
public:
static bool value;
};
bool is_pod_t<double>::value = true;
template<>
class is_pod_t<long>
{
public:
static bool value;
};
bool is_pod_t<long>::value = true;
template<typename T>
void copy_t1(T* dest,const T* src,const int cnt)
{
if(is_pod_t<T>::value)
{
cout << "is_pod ";
memcpy(dest,src,cnt*sizeof(T));
}
else
{
cout << "is not pod ";
for(auto i = 0;i < cnt;i++)
{
dest[i] = src[i];
}
}
}
//萃取实现is_pod
struct Type
{
typedef int value_type;
};
struct True_type
{
bool get_type()
{
return true;
}
};
struct False_type
{
bool get_type()
{
return false;
}
};
template<typename T>
struct is_pod_s
{
typedef False_type value_type;
};
template<>
struct is_pod_s<int>
{
typedef True_type value_type;
};
template<>
struct is_pod_s<double>
{
typedef True_type value_type;
};
template<>
struct is_pod_s<long>
{
typedef True_type value_type;
};
template<>
struct is_pod_s<float>
{
typedef True_type value_type;
};
template<>
struct is_pod_s<char>
{
typedef True_type value_type;
};
template<typename T>
void copy_t2(T* dest,const T* src,const int cnt)
{
if(is_pod_s<T>::value)
{
cout << "is_pod ";
memcpy(dest,src,cnt*sizeof(T));
}
else
{
cout << "is not pod ";
for(auto i = 0;i < cnt;i++)
{
dest[i] = src[i];
}
}
}
int main()
{
string s1 = "linux";
string s2 = "windows";
string s3[3] = {"linux","windows","macos"};
string s4[3];
string s6[3];
string s7[3];
string s5;
int a = 6;
int b;
int c;
comp(4.8,5.6);
comp(s1,s2);
comp("linux","windows");
Argv<string,int> a1(s1,27);
Argv<string,string> a2(s1,s2);
Argv<int,string> a3(27,s2);
Argv<int&,int> a4(a,27);
Argv<string&,int> a5(s1,27);
Argv<int*,int> a6(a,27);
a1.print_info();
a2.print_info();
a3.print_info();
a4.print_info();
a5.print_info();
a6.print_info();
copy_t(s4,s3,3);
cout << "s4 :";
for(auto i = 0;i < 3;i++)
{
cout << s4[i] << " ";
}
cout << endl;
copy_t(s5,s1);
cout << "s1:" << s1 << " s5: " << s5 << endl;
copy_t1(s6,s3,3);
cout << "s6 :";
for(auto i = 0;i < 3;i++)
{
cout << s6[i] << " ";
}
cout << endl;
copy_t1(&b,&a,1);
cout << "a:" << a << " b: " << b << endl;
copy_t1(s7,s3,3);
cout << "s6 :";
for(auto i = 0;i < 3;i++)
{
cout << s7[i] << " ";
}
cout << endl;
copy_t1(&c,&a,1);
cout << "a:" << a << " c: " << c << endl;
return 0;
}执行结果：
demo6:
智能指针
目录：
run.sh
#!/bin/bash
if [ -f ./Makefile ]
then
make clean
fi
cmake .
make
echo "---------------------------------"
./proclean.sh
#!/bin/bash
rm -rf CMakeFiles pro Makefile CMakeCache.txt cmake_install.cmakecheck_mem.sh
valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes -s ./proCMakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 2.20) #最低版本要求
SET(CMAKE_CXX_COMPILER "g++-11") #设置g++编译器
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") #添加编译选项
PROJECT(CLASS) #设置工程名
MESSAGE(STATUS "string test") #打印消息
ADD_EXECUTABLE(pro main.cpp) #生成可执行文件main.cpp
#include <iostream>
#include <memory>
#include <cstring>
using namespace std;
template<typename T,int SIZE>
class Test
{
private:
public:
T *num;
Test(){};
Test(int size)
{
cout << "user con" << endl;
num = new T[SIZE];
if(num != NULL)
{
for(auto i = 0;i < SIZE;i++)
num[i] = size;
}
};
~Test()
{
cout << "user descon" << endl;
if(num != NULL)
delete[] num;
};
void print()
{
for(auto i = 0;i < SIZE;i++)
cout << num[i] << " " ;
cout << endl;
}
};
template<typename T,int SIZE>
void set_t(T *t)
{
for(auto i = 0;i < SIZE;i++)
t[i] = i;
}
template<typename T,int SIZE>
void get_t(T *t)
{
for(auto i = 0;i < SIZE;i++)
cout << t[i] << " ";
cout << endl;
}
class front;
class back;
class front
{
public:
//shared_ptr<back> bptr;
weak_ptr<back> bptr;
front(){};
front(int num)
{
cout << "front" << endl;
};
~front()
{
cout << "~front()" << endl;
}
};
class back
{
public:
//shared_ptr<front> fptr;
weak_ptr<front> fptr;
back(){};
back(int num)
{
cout << "back" << endl;
};
~back()
{
cout << "~bak()" << endl;
}
};
int main()
{
unique_ptr<Test<int,3>> up1(new Test<int,3>(3));
cout << "up1 :";
up1->print();
//移动构造时会将前对象的所有权转移给当前对象
unique_ptr<Test<int,3>> up2(move(up1));
cout << "up2 :";
up2->print();
unique_ptr<Test<int,3>> up3 = unique_ptr<Test<int,3>>(new Test<int,3>(3));
cout << "up3 :";
up3->print();
using deleter = void(*)(int*); //定义删除器类型别名
unique_ptr<int[],deleter> up4(new int[3],[](int *p){delete [] p;});
set_t<int,3>(up4.get());
cout << "up4 :";
get_t<int,3>(up4.get());
//重新绑定对象前会调用前对象的删除器删除前对象
up4.reset(new int[4]);
set_t<int,4>(up4.get());
cout << "up4 :";
get_t<int,3>(up4.get());
unique_ptr<int[],deleter> up5(new int[5],[](int *p){delete [] p;});
set_t<int,5>(up5.get());
cout << "up5 :" ;
get_t<int,5>(up5.get());
up4.swap(up5);
cout << "up4 :";
get_t<int,3>(up4.get());
cout << "up5 :" ;
get_t<int,5>(up5.get());
//释放权限后要手动释放内存
int *p6 = up4.release();
delete p6;
int *p7 = up5.release();
delete p7;
//拷贝构造会增加管理对象,移动构造不会
shared_ptr<Test<int,3>> sp1(new Test<int,3>(3));
cout << "sp1 :";
sp1->print();
shared_ptr<Test<int,3>> sp2(sp1);
cout << "sp2 :";
sp2->print();
shared_ptr<Test<int,3>> sp3 = sp1;
cout << "sp3 :";
sp3->print();
shared_ptr<Test<int,3>> sp4(move(sp1));
cout << "sp4 :";
sp4->print();
cout << "sp1 use_count :" << sp1.use_count() << endl;
cout << "sp2 use_count :" << sp2.use_count() << endl;
cout << "sp3 use_count :" << sp3.use_count() << endl;
cout << "sp4 use_count :" << sp4.use_count() << endl;
weak_ptr<Test<int,6>> wp;
{
auto sp5 = make_shared<Test<int,6>>(6);
cout << "sp5 :";
sp5->print();
if(sp5.unique())
cout << "sp5 use_count = 1" << endl;
if(!wp.lock())
wp = sp5;
if(wp.expired())
cout << "sp5 deleted 1" << endl;
wp.reset();
cout << "wp.use_count :" << wp.use_count() << endl;
if(wp.expired())
cout << "sp5 deleted 2" << endl;
}
if(wp.expired())
cout << "sp5 deleted 3" << endl;
shared_ptr<front> f(new front(1));
shared_ptr<back> b(new back(1));
cout << "f.use_count :" << f.use_count() << endl;
cout << "b.use_count :" << b.use_count() << endl;
f->bptr = b;
b->fptr = f;
cout << "f.use_count :" << f.use_count() << endl;
cout << "b.use_count :" << b.use_count() << endl;
return 0;
}结果示例：
![[玄机]流量特征分析-常见攻击事件 tomcat](https://i-blog.csdnimg.cn/direct/4abf22f6cc72427c89cea0fb48651773.jpeg)
