网站怎么做查询功能/产品的推广及宣传思路

一.智能指针的设计思路

1. 智能指针是类模板，再栈上创建智能指针对象。
2. 把普通指针交给智能指针对象。
3. 智能指针对象过期时，调用析构函数释放普通指针的内存。

• 智能指针的类型

4. auto_ptr是C++98的标准，c++17已经弃用。
5. unique_ptr、shared_ptr和weak_ptr是C++11标准的。

二.智能指针 unique_ptr

C++智能指针unique_ptr是C++11标准库中提供的一种智能指针类型，用于管理动态分配的资源，主要用来避免内存泄漏和简化资源管理。unique_ptr是独占所有权的智能指针，即同一时间只能有一个unique_ptr指向特定的资源，当unique_ptr被销毁时，它所管理的资源会被自动释放。

1.基本用法

1. 方法1：

unique_ptr<AA>p0(new AA("小明"));//分配内存并初始化

2. 方法2：

unique_ptr<AA>p0=make_unique<AA>("小明");//c++14标准

3. 方法3：

AA*p=new AA("小明");
unique_ptr<AA>p0(p);//用已存在的地址初始化

4. 方法4：get()方法可以返回裸指针

2. 基本定义

• 包含头文件

#include <memory>

以下是unique_ptr的简化版本的类模板定义（省略了部分实现细节）：

template <typename T>
class unique_ptr {
private:T* ptr;public:// 构造函数unique_ptr(T* p) : ptr(p) {}// 移动构造函数unique_ptr(unique_ptr&& other) noexcept : ptr(other.ptr) {other.ptr = nullptr;}// 析构函数~unique_ptr() {delete ptr;}// 禁止拷贝和赋值unique_ptr(const unique_ptr&) = delete;unique_ptr& operator=(const unique_ptr&) = delete;// 移动赋值运算符unique_ptr& operator=(unique_ptr&& other) noexcept {if (this != &other) {delete ptr;ptr = other.ptr;other.ptr = nullptr;}return *this;}// 获取裸指针T* get() const {return ptr;}// 重载运算符->T* operator->() const {return ptr;}// 重载解引用运算符*T& operator*() const {return *ptr;}// 释放资源void reset() {delete ptr;ptr = nullptr;}
};

3.实战测试

#include<iostream>
using namespace std;#include<vector>
#include<memory>//智能指针头文件class AA
{
public:string m_name;AA():m_name("未定义") { cout << m_name << "调用构造函数AA()" << endl; }AA(const string& name) :m_name(name) { cout << "调用构造函数（" << m_name << ")" << endl; }~AA() { cout << "调用了析构函数~AA(" << m_name << ")" << endl; }};int main()
{AA* p1 = new AA("小明");//使用智能指针来管理p//这里AA的意思是要管理的普通指针类型是AA//智能指针本来就是用来管理指针的所以不需要使用AA*unique_ptr<AA>ptr1(p1);//与正常指针用法一致cout << "m_name " << (*ptr1).m_name << endl;cout << "m_name " << ptr1->m_name << endl;cout << "m_name " << (*p1).m_name << endl;cout << "m_name " << p1->m_name << endl;//system("pause");不能使用这个，否则程序无法正常关闭，析构函数无法成功调用return 0;
}

• 执行结果

三.智能指针 shared_ptr

在 C++ 中，智能指针是一种用于管理动态分配对象的指针类，可以帮助开发人员更好地管理内存资源，避免内存泄漏等问题。std::shared_ptr 是 C++11 标准库中提供的一种智能指针，用于共享所有权的指针管理。std::shared_ptr 可以自动追踪有多少个指针共享同一个对象，并在对象不再被引用时安全地释放内存。共享指针的引用计数会在创建、复制和销毁时进行递增和递减，当引用计数为 0 时，内存资源就会被释放。

使用方法:(和unique_ptr基本一样的)

#include <memory>

std::shared_ptr<int> sharedPtr = std::make_shared<int>(10);
智能指针的复制:
std::shared_ptr<int> sharedPtr2 = sharedPtr;
使用 std::make_shared 创建对象时，可以减少内存分配和额外的虚拟函数调用。可以使用 .use_count() 方法获取当前共享指针的引用计数。std::shared_ptr 还支持自定义的删除器，用于指定释放内存时的操作。

总的来说，std::shared_ptr 可以帮助避免潜在的内存泄漏和悬空指针问题，提高代码的健壮性和可维护性。

• 实战测试

#include<iostream>
using namespace std;#include<vector>
#include<memory>//智能指针头文件class AA
{
public:string m_name;AA() :m_name("未定义") { cout << m_name << "调用构造函数AA()" << endl; }AA(const string& name) :m_name(name) { cout << "调用构造函数（" << m_name << ")" << endl; }~AA() { cout << "调用了析构函数~AA(" << m_name << ")" << endl; }};int main()
{AA* p1 = new AA("小明");//使用智能指针来管理p//这里AA的意思是要管理的普通指针类型是AA//智能指针本来就是用来管理指针的所以不需要使用AA*shared_ptr<AA>ptr1(p1);//与正常指针用法一致cout << "m_name " << (*ptr1).m_name << endl;cout << "m_name " << ptr1->m_name << endl;cout << "m_name " << (*p1).m_name << endl;cout << "m_name " << p1->m_name << endl;cout << "use_count=" << ptr1.use_count() << endl;//system("pause");不能使用这个，否则程序无法正常关闭，析构函数无法成功调用return 0;
}

• 输出结果
  

四.智能指针 weak_ptr

在 C++ 中，std::weak_ptr 是另一种智能指针，用于解决 std::shared_ptr 循环引用所带来的问题。std::weak_ptr 允许你观察指向的对象，但不拥有其所有权。通常与 std::shared_ptr 一起使用，可以避免循环引用导致的内存泄漏问题。

以下是一些关于 std::weak_ptr 的重要点和用法：

1. 通过 std::weak_ptr 对象获std::shared_ptr 对象：

std::shared_ptr<int> sharedPtr = std::make_shared<int>(10);
std::weak_ptr<int> weakPtr = sharedPtr;

2. 使用 std::lock_guard 和 std::shared_ptr::lock 方法来安全地获取 std::shared_ptr 对象，避免访问已经释放的对象：

if (std::shared_ptr<int> sharedPtr = weakPtr.lock()) {// 使用 sharedPtr 访问对象
} else {// 对象已被释放
}

3. std::weak_ptr 不增加引用计数，只是提供了对对象的观察能力，也不会阻止对象的释放。

4. 可以使用 std::weak_ptr 来打破循环引用，让对象能够被正确地释放。

std::weak_ptr 是一种很有用的工具，可以帮助解决在使用智能指针时可能会遇到的循环引用问题，确保内存资源能够正确地释放，提高程序的稳定性和可靠性。

• 实战测试

#include<iostream>
using namespace std;#include<vector>
#include<memory>//智能指针头文件class BB;class AA
{
public:string m_name;AA() :m_name("未定义") { cout << m_name << "调用构造函数AA()" << endl; }AA(const string& name) :m_name(name) { cout << "调用构造函数（" << m_name << ")" << endl; }~AA() { cout << "调用了析构函数~AA(" << m_name << ")" << endl; }shared_ptr<BB>p_B;};class BB
{
public:string m_name;BB() :m_name("未定义") { cout << m_name << "调用构造函数BB()" << endl; }BB(const string& name) :m_name(name) { cout << "调用构造函数（" << m_name << ")" << endl; }~BB() { cout << "调用了析构函数~BB(" << m_name << ")" << endl; }shared_ptr<AA>p_A;
};int main()
{AA* p1 = new AA("小明");BB* p2 = new BB("李华");//使用智能指针来管理p//这里AA的意思是要管理的普通指针类型是AA//智能指针本来就是用来管理指针的所以不需要使用AA*shared_ptr<AA>ptr1(p1);shared_ptr<BB>ptr2 (p2);//与正常指针用法一致cout << "ptr1->m_name " << (*ptr1).m_name << endl;cout << "ptr1->m_name " << ptr1->m_name << endl;cout << "ptr1->m_name " << (*p1).m_name << endl;cout << "ptr1->m_name " << p1->m_name << endl;cout << "ptr1->use_count=" << ptr1.use_count() << endl;cout << "ptr2->m_name " << (*ptr2).m_name << endl;cout << "ptr2->m_name " << ptr2->m_name << endl;cout << "ptr2->m_name " << (*p2).m_name << endl;cout << "ptr2->m_name " << p2->m_name << endl;cout << "ptr2->use_count=" << ptr2.use_count() << endl;ptr1->p_B = ptr2;ptr2->p_A = ptr1;//system("pause");不能使用这个，否则程序无法正常关闭，析构函数无法成功调用return 0;
}

• 由于相互执行都在等待对方释放资源，结果两方都无法释放资源
  

• 解决方法：使用weak_ptr