cout << "construct Test, x = " << x << endl;
}
Test(string str) : m_num(0)
{
cout << "construct Test, str = " << str << endl;
}
~Test()
{
cout << "destruct Test..." << endl;
}
void setValue(int v)
{
this->m_num = v;
}
void print()
{
cout << "m_num: " << this->m_num << endl;
}
private: int m_num; };
int main() { /-------------------------- 一，初始化智能指针shared_ptr ------------------------------/ //1.通过构造函数初始化 shared_ptr ptr1(new int(3)); cout << "ptr1管理的内存引用计数: " << ptr1.use_count() << endl;
//2.通过移动和拷贝构造函数初始化
shared_ptr<int> ptr2 = move(ptr1);
cout << "ptr1管理的内存引用计数: " << ptr1.use_count() << endl;
cout << "ptr2管理的内存引用计数: " << ptr2.use_count() << endl;
shared_ptr<int> ptr3 = ptr2;
cout << "ptr2管理的内存引用计数: " << ptr2.use_count() << endl;
cout << "ptr3管理的内存引用计数: " << ptr3.use_count() << endl;
//3.通过 std::make_shared初始化
shared_ptr<int> ptr4 = make_shared<int>(8);
shared_ptr<Test> ptr5 = make_shared<Test>(7);
shared_ptr<Test> ptr6 = make_shared<Test>("GOOD LUCKLY!");
//4.通过reset初始化
ptr6.reset(); //重置ptr6, ptr6的引用基数为0
cout << "ptr6管理的内存引用计数: " << ptr6.use_count() << endl;
ptr5.reset(new Test("hello"));
cout << "ptr5管理的内存引用计数: " << ptr5.use_count() << endl;
cout << endl;
cout << endl;
/*-------------------------- 二，共享智能指针shared_ptr的使用 ------------------------------*/
//1.方法一
Test* t = ptr5.get();
t->setValue(1000);
t->print();
//2.方法二
ptr5->setValue(7777);
ptr5->print();
printf("\n\n");
/*------------------------------------ 三，指定删除器 -----------------------------------*/
//1.简单举例
shared_ptr<Test> ppp(new Test(100), [](Test* t) {
//释放内存
cout << "Test对象的内存被释放了......." << endl;
delete t;
});
printf("----------------------------------------------------------------------\n");
2.如果是数组类型的地址，就需要自己写指定删除器，否则内存无法全部释放
//shared_ptr<Test> p1(new Test[5], [](Test* t) {
// delete[]t;
// });
//3.也可以使用c++给我们提供的 默认删除器函数（函数模板）
shared_ptr<Test> p2(new Test[3], default_delete<Test[]>());
//4.c++11以后可以这样写 也可以自动释放内存
shared_ptr<Test[]> p3(new Test[3]);
return 0;
}
>
> **另外，我们还可以自己封装一个函数模板make\_shared\_array方法来让shared\_ptr支持数组，代码如下:**
>
>
>
#include #include #include using namespace std;
//有了这个函数模板，我们就不用自己去释放数组类型的地址了 template shared_ptr make_share_array(size_t size) { //返回匿名对象 return shared_ptr(new T[size], default_delete<T[]>()); }
int main() { shared_ptr ptr1 = make_share_array(10); cout << ptr1.use_count() << endl;
shared_ptr<string> ptr2 = make_share_array<string>(7);
cout << ptr2.use_count() << endl;
return 0;
}
## 三，独占的智能指针unique\_ptr
* 首先了解一下基本概念，再看代码，会学的很快
#### 1. 初始化
>
>
> std::unique\_ptr是一个独占型的智能指针，它不允许其他的智能指针共享其内部的指针，可以通过它的构造函数初始化一个独占智能指针对象，但是不允许通过赋值将一个unique\_ptr赋值给另一个unique\_ptr。
>
>
>
#### 2. 删除器
>
> unique\_ptr指定删除器和shared\_ptr指定删除器是有区别的，unique\_ptr指定删除器的时候需要确定删除器的类型，所以不能像shared\_ptr那样直接指定删除器
>
>
>
#include using namespace std; #include #include #include
class Test { public: Test() : m_num(0) { cout << "construct Test..." << endl; }
Test(int x) : m_num(1)
{
cout << "construct Test, x = " << x << endl;
}
Test(string str) : m_num(2)
{
cout << "construct Test, str = " << str << endl;
}
~Test()
{
cout << "destruct Test..." << endl;
}
void setValue(int v)
{
this->m_num = v;
}
void print()
{
cout << "m_num: " << this->m_num << endl;
}
private: int m_num; };
int main() { /-------------------------- 一，初始化智能指针unique_ptr ------------------------------/ //1.通过构造函数初始化 unique_ptr ptr1(new int(3));
//2.通过移动函数初始化
unique_ptr<int> ptr2 = move(ptr1);
//.通过reset初始化
ptr2.reset(new int(7));
/*-------------------------- 二，unique_ptr的使用 ------------------------------*/
//1.方法一
unique_ptr<Test> ptr3(new Test(666));
Test* pt = ptr3.get();
pt->setValue(6);
pt->print();
//2.方法二
ptr3->setValue(777);
ptr3->print();
/*------------------------------------ 三，指定删除器 -----------------------------------*/
//1.函数指针类型
//using ptrFunc = void(*)(Test*);
//unique_ptr<Test, ptrFunc> ptr4(new Test("hello"), [](Test* t) {
// cout << "-----------------------" << endl;
// delete t;
// });
//2.仿函数类型（利用可调用对象包装器）
unique_ptr<Test, function<void(Test*)>> ptr4(new Test("hello"), [](Test* t) {
cout << "-----------------------" << endl;
delete t;
});
/*---------- 四，独占(共享)的智能指针可以管理数组类型的地址，能够自动释放 ---------*/
unique_ptr<Test[]> ptr5(new Test[3]);
//在c++11中shared_ptr不支持下面的写法，c++11以后才支持的
shared_ptr<Test[]> ptr6(new Test[3]);
return 0;
}
## 四， 弱引用的智能指针weak\_ptr
>
> **弱引用智能指针`std::weak_ptr`可以看做是`shared_ptr`的助手，它不管理`shared_ptr`内部的指针。`std::weak_ptr`没有重载操作符`*`和`->`，因为它不共享指针，不能操作资源，所以它的构造不会增加引用计数，析构也不会减少引用计数，它的主要作用就是作为一个旁观者监视`shared_ptr`中管理的资源是否存在。**
>
>
>
#### 1 初始化
#include #include using namespace std;
int main() { shared_ptr sp(new int);
weak_ptr<int> wp1;
weak_ptr<int> wp2(wp1);
weak_ptr<int> wp3(sp);
weak_ptr<int> wp4;
wp4 = sp;
weak_ptr<int> wp5;
wp5 = wp3;
return 0;
}
1. **`weak_ptr<int> wp1;`构造了一个空`weak_ptr`对象**
2. **`weak_ptr<int> wp2(wp1);`通过一个空`weak_ptr`对象构造了另一个空`weak_ptr`对象**
3. **`weak_ptr<int> wp3(sp);`通过一个`shared_ptr`对象构造了一个可用的`weak_ptr`实例对象**
4. **`wp4 = sp;`通过一个`shared_ptr`对象构造了一个可用的`weak_ptr`实例对象（这是一个隐式类型转换）**
5. **`wp5 = wp3;`通过一个`weak_ptr`对象构造了一个可用的`weak_ptr`实例对象**
* **通过调用`std::weak_ptr`类提供的`use_count()`方法可以获得当前所观测资源的引用计数**
#### 2.常用函数
>
> 1. **通过调用`std::weak_ptr`类提供的`expired()`方法来判断观测的资源是否已经被释放**
> 2. **通过调用`std::weak_ptr`类提供的`lock()`方法来获取管理所监测资源的`shared_ptr`对象**
> 3. **通过调用`std::weak_ptr`类提供的`reset()`方法来清空对象，使其不监测任何资源**
>
>
>
* 利用**`weak_ptr可以解决shared_ptr的一些问题`**
>
> 1. 返回管理this的shared\_ptr
> 2. 解决循环引用问题
>
>
>
**收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。**
**[如果你需要这些资料，可以戳这里获取](https://gitee.com/vip204888)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人**
**都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
