c++ 内存管理系统之智能指针

1.c++内存管理

1.代码区

也称Text Segment，存放可执行程序的机器码。

2 数据区：

存放已初始化的全局和静态变量， 常量数据（如字符串常量）。

存放未初始化的全局和静态变量

无疑解释静态变量的来源：

局部静态变量： 

存储在静态存储区，函数调用结束后不会销毁，下次调用函数时会保留上一次的值。

3.栈：

从高地址向低地址增长。由编译器自动管理分配。程序中的局部变量、函数参数值、返回变量等存在此区域。

4.堆

从低地址向高地址增长。容量大于栈，程序中动态分配的内存在此区域

2.new和delete问世

2.1对比 malloc new的优势

  • 自动调用构造函数和析构函数：new 在分配内存后会自动调用对象的构造函数进行初始化，delete 在释放内存前会自动调用对象的析构函数进行清理工作，这对于管理复杂对象（如包含动态分配资源的对象）非常方便，能确保资源的正确初始化和释放。

这个无疑是new 能复制对象

  • 类型安全：new 会根据对象的类型自动计算所需的内存大小，返回的指针类型也是正确的，不需要进行强制类型转换，减少了因类型转换错误导致的潜在问题。

malloc返回的是 void* 它得强转

  • 操作符重载：在 C++ 中，new 和 delete 是操作符，可以被重载，允许用户自定义内存分配和释放的行为，以满足特定的需求。

操作方便

2.2代码实现

#include <iostream>
using namespace std;
class A {
public:
    A() {
        std::cout << "A 的构造函数被调用" << std::endl;
    }
    ~A() {
        std::cout << "A 的析构函数被调用" << std::endl;
    }
};

int main()
{
	
	// 单个变量
	int *p= new int;
	*p=32;
	std::cout << *p << std::endl;
	
	delete p;

	//数组
	int a[4]={1,23,3,31};//不能赋值
	
	int *ptr=new int[4]{1,2,3};//
	
	cout<<ptr[1]<<endl;
	
	delete [] ptr;
	
	//类
	
	A*ptr_class=new A;
	
	delete ptr_class;
	
	//类数组
	A* ptr_classArray=new A[3];
	
	delete [] ptr_classArray;

	
	
}

基本格式为 变量类型* ptr = new 变量类型 (数组加[size])

可以重载：

#include <iostream>
#include <cstdlib>

class MyClass {
public:
    // 重载全局 new 操作符
    static void* operator new(size_t size) {
        std::cout << "自定义 new 操作符被调用，分配 " << size << " 字节" << std::endl;
        return std::malloc(size);
    }
    // 重载全局 delete 操作符
    static void operator delete(void* ptr) {
        std::cout << "自定义 delete 操作符被调用" << std::endl;
        std::free(ptr);
    }
    MyClass() { std::cout << "MyClass 构造函数被调用" << std::endl; }
    ~MyClass() { std::cout << "MyClass 析构函数被调用" << std::endl; }
};

int main() {
    MyClass* obj = new MyClass;
    delete obj;
    return 0;
}

3.智能指针问世

原因 因为你new 和 delete 是搭配使用的,等你返回，忘记删去怎么办！！！

#include <iostream>

int main()
{
	int *ptr=new int[4]{1,2,3,4};
	for(int i =0;i<4;i++)
	{
		if(i=2)
		{
			return ptr[i];
		}
	}
	delete []ptr;
	return	1;
}

3.1 unique_ptr

  • 特性

    • 独占所有权：std::unique_ptr 对其所指向的资源拥有独占所有权，同一时间只能有一个 std::unique_ptr 指向该资源。这保证了资源管理的清晰性，避免多个指针同时操作同一资源导致的混乱。

    • 自动释放：当 std::unique_ptr 对象超出其作用域时，其析构函数会自动调用，从而释放其所指向的资源。

代码理解：

#include <iostream>
#include <memory>
using namespace std;

class MyClass {
public:
    MyClass() { std::cout << "MyClass 构造函数" << std::endl; }
    ~MyClass() { std::cout << "MyClass 析构函数" << std::endl; }
};

int main() {
   
   	
   {
   	
   // init 第一个利用make_unique<> ()
        std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>();
        // 当 ptr 离开此作用域时，会自动释放资源
   }
   {
   	unique_ptr<MyClass>ptr=make_unique<MyClass>();
   	//不能赋值unique_ptr<MyClass>ptr1=ptr
   	
   	unique_ptr<MyClass>ptr1=std::move(ptr);//能右赋值
   }
 
   
    std::cout << "ptr 已释放资源" << std::endl;
    return 0;
}

3.2 shared_ptr

特性

    • 共享所有权：std::shared_ptr 可以被多个 std::shared_ptr 对象共享同一个资源。它使用引用计数机制来跟踪有多少个 std::shared_ptr 指向同一资源。

    • 自动释放：当引用计数变为 0 时，即没有任何 std::shared_ptr 指向该资源时，资源会被自动释放(还有离开作用域自身减一  一般一对大括号）

#include <iostream>
#include <memory>
using namespace std;

class MyClass {
public:
    MyClass() { std::cout << "MyClass 构造函数" << std::endl; }
    ~MyClass() { std::cout << "MyClass 析构函数" << std::endl; }
};

int main() {
   
   	
/*
 {
   shared_ptr<MyClass>ptr1=make_shared<MyClass>();
 } //error: ‘ptr1’ was not declared in this scope  
*/ 

shared_ptr<MyClass>ptr1=make_shared<MyClass>();
   cout<<ptr1.use_count()<<endl;

shared_ptr<MyClass>ptr2=ptr1;//这个拷贝

cout<<ptr2.use_count()<<endl;

shared_ptr<MyClass>ptr3(new MyClass);//这个全新的

cout<<ptr3.use_count()<<endl;

}
/*
MyClass 构造函数
1
2
MyClass 构造函数
1
MyClass 析构函数
MyClass 析构函数
*/ 结果

3.3 weak_ptr

特性

  • 弱引用：std::weak_ptr 是一种不控制资源生命周期的智能指针，它对 std::shared_ptr 管理的资源进行弱引用，不增加引用计数。

  • 防止循环引用：主要用于解决 std::shared_ptr 可能出现的循环引用问题，避免资源无法正常释放。

错误用法：

#include <iostream>
#include <string>
#include <memory>

using namespace std;



class Boy {
public:
	Boy() {
		cout << "Boy 构造函数" << endl;
	}

	~Boy() {
		cout << "~Boy 析构函数" << endl;
	}

	void setGirlFriend(shared_ptr<Girl> _girlFriend) {
		this->girlFriend = _girlFriend;
	}

private:
	shared_ptr<Girl> girlFriend;
};

class Girl {
public:
	Girl() {
		cout << "Girl 构造函数" << endl;
	}

	~Girl() {
		cout << "~Girl 析构函数" << endl;
	}

	void setBoyFriend(shared_ptr<Boy> _boyFriend) {
		this->boyFriend = _boyFriend;
	}

private:
	shared_ptr<Boy> boyFriend;
};


void useTrap() {
	shared_ptr<Boy> spBoy(new Boy());
	shared_ptr<Girl> spGirl(new Girl());

	// 陷阱用法
	spBoy->setGirlFriend(spGirl);
	spGirl->setBoyFriend(spBoy);
	// 此时boy和girl的引用计数都是2
}


int main(void) {
	useTrap();

	system("pause");
	return 0;
}

如下图：
当我们执行useTrap函数时，注意，是没有结束此函数，boy和girl指针其实是被两个智能指针托管的，所以他们的引用计数是2

 解析:

  • 对象创建：
    • shared_ptr<Boy> spBoy(new Boy()); 创建了一个 Boy 对象，并使用 spBoy 来管理它，此时 Boy 对象的引用计数为 1。
    • shared_ptr<Girl> spGirl(new Girl()); 创建了一个 Girl 对象，并使用 spGirl 来管理它，此时 Girl 对象的引用计数为 1。
  • 相互引用：
    • spBoy->setGirlFriend(spGirl); 使得 spBoy 内部的 girlFriend 成员（std::shared_ptr<Girl> 类型）指向 spGirl 所管理的 Girl 对象，Girl 对象的引用计数变为 2。
    • spGirl->setBoyFriend(spBoy); 使得 spGirl 内部的 boyFriend 成员（std::shared_ptr<Boy> 类型）指向 spBoy 所管理的 Boy 对象，Boy 对象的引用计数变为 2。
2. 函数作用域结束时的情况

当 useTrap 函数执行结束，spBoy 和 spGirl 离开作用域，它们会被销毁。按照引用计数的规则，这会使得 Boy 和 Girl 对象的引用计数各自减 1。

 

然而，由于循环引用的存在：

 
  • Boy 对象仍然被 spGirl 中的 boyFriend 成员引用，所以 Boy 对象的引用计数从 2 减为 1。
  • Girl 对象仍然被 spBoy 中的 girlFriend 成员引用，所以 Girl 对象的引用计数从 2 减为 1。
 

因为引用计数没有变为 0，std::shared_ptr 不会释放 Boy 和 Girl 对象所占用的内存，从而造成了内存泄漏。

 感觉girlfrend和boyfriend反了 才更好理解

真正的：

#include <iostream>
#include <memory>

using namespace std;

class Boy;

class Girl {
public:
    Girl() {
        cout << "Girl 构造函数" << endl;
    }
    ~Girl() {
        cout << "~Girl 析构函数" << endl;
    }
    void setBoyFriend(shared_ptr<Boy> _boyFriend) {
        this->boyFriend = _boyFriend;
    }
private:
    weak_ptr<Boy> boyFriend;
};

class Boy {
public:
    Boy() {
        cout << "Boy 构造函数" << endl;
    }
    ~Boy() {
        cout << "~Boy 析构函数" << endl;
    }
    void setGirlFriend(shared_ptr<Girl> _girlFriend) {
        this->girlFriend = _girlFriend;
    }
private:
    weak_ptr<Girl> girlFriend;
};

void useTrap() {
    shared_ptr<Boy> spBoy(new Boy());
    shared_ptr<Girl> spGirl(new Girl());

    spBoy->setGirlFriend(spGirl);
    spGirl->setBoyFriend(spBoy);
}

int main() {
    useTrap();
    return 0;
}

 解析：

使用 std::weak_ptr 作为类的成员变量，主要是为了打破 std::shared_ptr 之间可能出现的循环引用问题。当 Boy 对象的 girlFriend 成员使用 std::weak_ptr 时，它对 Girl 对象的引用不会增加 Girl 对象的引用计数，从而避免了循环引用导致的内存泄漏问题。

综上所述，虽然 std::weak_ptr 和 std::shared_ptr 是不同的智能指针类型，但 std::weak_ptr 提供了相应的构造和赋值机制，允许使用 std::shared_ptr 来初始化或赋值，这在解决循环引用问题时非常有用。

其他用法：

#include <iostream>
#include <memory>

// 打印 weak_ptr 相关信息的函数
void printWeakPtrInfo(const std::weak_ptr<int>& weak) {
    std::cout << "当前 weak_ptr 的引用计数为: " << weak.use_count() << std::endl;
    if (weak.expired()) {
        std::cout << "weak_ptr 所指向的对象已被销毁。" << std::endl;
    } else {
        // 使用 lock 函数获取 shared_ptr
        std::shared_ptr<int> shared = weak.lock();
        if (shared) {
            std::cout << "Value: " << *shared << std::endl;
        }
    }
}

int main() {
    // 创建一个 shared_ptr 并初始化为 42
    std::shared_ptr<int> shared = std::make_shared<int>(42);
    // 创建一个 weak_ptr 并关联到 shared_ptr
    std::weak_ptr<int> weak = shared;

    std::cout << "第一次调用 printWeakPtrInfo 函数：" << std::endl;
    printWeakPtrInfo(weak);

    // 释放 shared_ptr 管理的对象
    shared.reset();

    std::cout << "\n第二次调用 printWeakPtrInfo 函数：" << std::endl;
    printWeakPtrInfo(weak);

    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/980957.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Unity中的Destroy和DestroyImmediate的区别是什么？

Unity中的Destroy和DestroyImmediate的区别是什么？

在 Unity 中&#xff0c;Destroy 和 DestroyImmediate 都是用于销毁游戏对象&#xff08;GameObject&#xff09;、组件&#xff08;Component&#xff09;或资源的方法。在大多数情况下&#xff0c;建议优先使用 Destroy 方法&#xff0c;只有在确实需要立即销毁对象时才使用 …
阅读更多...
Microk8s Ingress实现七层负载均衡

Microk8s Ingress实现七层负载均衡

Microk8s Ingress是什么 Ingress是k8s的一种资源对象&#xff0c;用于管理外部对集群内服务的访问, 它通过提供一个统一的入口点&#xff0c;将外部流量路由到集群内部的不同服务。 Microk8s Ingress用于解决什么问题 k8s集群中服务默认只能在集群内访问。 如果需要从外部访…
阅读更多...
DeepSpeek服务器繁忙？这几种替代方案帮你流畅使用！（附本地部署教程）

DeepSpeek服务器繁忙？这几种替代方案帮你流畅使用！（附本地部署教程）

作者&#xff1a;后端小肥肠 目录 1. 前言 2. 解决方案 2.1. 纳米AI搜索&#xff08;第三方平台&#xff09; 2.2. Github&#xff08;第三方平台&#xff09; 2.3. 硅基流动&#xff08;第三方API&#xff09; 3. 本地部署详细步骤 3.1. 运行配置需求 3.2. 部署教程 4…
阅读更多...
【大厂AI实践】美团：美团智能客服核心技术与实践

【大厂AI实践】美团：美团智能客服核心技术与实践

【大厂AI实践】美团&#xff1a;美团智能客服核心技术与实践 &#x1f31f; 嗨&#xff0c;你好&#xff0c;我是 青松 &#xff01; &#x1f308; 自小刺头深草里&#xff0c;而今渐觉出蓬蒿。 NLP Github 项目推荐&#xff1a; 【AI 藏经阁】&#xff1a;https://gitee.com…
阅读更多...
科技查新有不通过的情况吗？为什么？

科技查新有不通过的情况吗？为什么？

1. 科技查新有不通过的情况吗&#xff1f;为什么&#xff1f; 有。科技查新“不通过”&#xff08;即查新报告显示技术缺乏新颖性或存在侵权风险&#xff09;的情况并不罕见&#xff0c;主要原因包括&#xff1a; &#xff08;1&#xff09;技术缺乏创新性 重复开发&#xff…
阅读更多...
批量提取 Word 文档中的页面

批量提取 Word 文档中的页面

如何将 Word 文档中的页面提取出来形成一个新的文档呢&#xff1f;比如将 Word 文档中的第一页提取出来、将 Word 文档中的最后一页提取出来、再或者将 Word 文档中的中间几页提取出来等等。人工的处理肯定非常的麻烦&#xff0c;需要新建 Word 文档&#xff0c;然后将内容复制…
阅读更多...
Spring统一格式返回

Spring统一格式返回

目录 一&#xff1a;统一结果返回 1&#xff1a;统一结果返回写法 2&#xff1a;String类型报错问题 解决方法 二&#xff1a;统一异常返回 统一异常返回写法 三&#xff1a;总结 同志们&#xff0c;今天咱来讲一讲统一格式返回啊&#xff0c;也是好久没有讲过统一格式返…
阅读更多...
(十 八)趣学设计模式 之 观察者模式！

(十 八)趣学设计模式 之 观察者模式！

目录 一、 啥是观察者模式&#xff1f;二、 为什么要用观察者模式&#xff1f;三、 观察者模式的实现方式四、 观察者模式的优缺点五、 观察者模式的应用场景六、 总结 &#x1f31f;我的其他文章也讲解的比较有趣&#x1f601;&#xff0c;如果喜欢博主的讲解方式&#xff0c;…
阅读更多...
Linux虚拟机网络配置-桥接网络配置

Linux虚拟机网络配置-桥接网络配置

简介 本文档旨在指导用户如何在虚拟环境中配置Linux系统的桥接网络&#xff0c;以实现虚拟机与物理主机以及外部网络的直接通信。桥接网络允许虚拟机如同一台独立的物理机一样直接连接到物理网络&#xff0c;从而可以被分配一个独立的IP地址&#xff0c;并能够与网络中的其他设…
阅读更多...
视频教育网站开源系统的部署安装 （roncoo-education）服务器为ubuntu22.04.05

视频教育网站开源系统的部署安装 （roncoo-education）服务器为ubuntu22.04.05

一、说明 前端技术体系&#xff1a;Vue3 Nuxt3 Vite5 Vue-Router Element-Plus Pinia Axios 后端技术体系&#xff1a;Spring Cloud Alibaba2021 MySQL8 Nacos Seata Mybatis Druid redis 后端系统&#xff1a;roncoo-education&#xff08;核心框架&#xff1a;S…
阅读更多...
线程相关八股

线程相关八股

1. 线程和进程的区别&#xff1f; 进程&#xff1a;进程可以简单理解为进行一个程序&#xff0c;比如说我们打开一个浏览器&#xff0c;打开一个文本&#xff0c;这就是开启了一个进程&#xff0c;一个进程想要在计算机中运行&#xff0c;需要将程序交给CPU&#xff0c;将数据…
阅读更多...
Python 绘制迷宫游戏，自带最优解路线

Python 绘制迷宫游戏，自带最优解路线

1、需要安装pygame 2、上下左右移动&#xff0c;空格实现物体所在位置到终点的路线&#xff0c;会有虚线绘制。 import pygame import random import math# 迷宫单元格类 class Cell:def __init__(self, x, y):self.x xself.y yself.walls {top: True, right: True, botto…
阅读更多...
【音视频】VLC播放器

【音视频】VLC播放器

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 一、vlc是什么&#xff1f; VLC Media Player&#xff08;简称VLC&#xff09;是一款免费、开源、跨平台的多媒体播放器&#xff0c;由非营利组织VideoLAN开发&#xff0c;最…
阅读更多...
vue2+ele-ui实践

vue2+ele-ui实践

前言&#xff1a;真理先于实践&#xff0c;实践发现真理&#xff0c;再实践检验真理 环境&#xff1a;vue2 & element-ui 正片&#xff1a; Select 选择器 简称 下拉框 下拉框完整的使用循环 下拉框 → 点击下拉框 → 展示数据 → 选择数据 → 下拉框显示数据 核心具有…
阅读更多...
刷题日记——部分二分算法题目分享

刷题日记——部分二分算法题目分享

前言 咱们紧跟上一期结合时间复杂度浅谈二分法的好处, 并分享部分二分题目(将持续更新题目,绝对值你一个收藏)-CSDN博客 笔者接着分享一些刷过的关于二分算法的题目. 第一题 1283. 使结果不超过阈值的最小除数 - 力扣&#xff08;LeetCode&#xff09; 这道题就是典型的二…
阅读更多...
excel 斜向拆分单元格

excel 斜向拆分单元格

右键-合并单元格 右键-设置单元格格式-边框 在设置好分割线后&#xff0c;你可以开始输入文字。 需要注意的是&#xff0c;文字并不会自动分成上下两行。 为了达到你期望的效果&#xff0c;你可以通过 同过左对齐、上对齐 空格键或使用【AltEnter】组合键来调整单元格中内容的…
阅读更多...
关于常规模式下运行VScode无法正确执行“pwsh”问题

关于常规模式下运行VScode无法正确执行“pwsh”问题

前言&#xff1a; pwsh在系统环境中正确配置&#xff0c;且可以运行在cmd&#xff0c; powshell&#xff08;5.1&#xff09;--- 都需要在管理员权限下运行 &#xff08;打开setting&#xff09; 打开setting.json &#xff08;在vscode中添加 powershell 7 路径&…
阅读更多...
企微审批中MySQL字段TEXT类型被截断的排查与修复实践

企微审批中MySQL字段TEXT类型被截断的排查与修复实践

在MySQL中&#xff0c;TEXT类型字段常用于存储较大的文本数据&#xff0c;但在一些应用场景中&#xff0c;当文本内容较大时&#xff0c;TEXT类型字段可能无法满足需求&#xff0c;导致数据截断或插入失败。为了避免这种问题&#xff0c;了解不同文本类型&#xff08;如TEXT、M…
阅读更多...
异常 PipeMapRed.waitOutputThreads(): subprocess failed with code 127

异常 PipeMapRed.waitOutputThreads(): subprocess failed with code 127

直接放问题异常 hadoop jar /opt/module/hadoop-3.3.2/share/hadoop/tools/lib/hadoop-streaming-3.3.2.jar \ -D mapreduce.map.memory.mb100 \ -D mapreduce.reduce.memory.mb100 \ -D mapred.map.tasks1 \ -D stream.num.map.output.key.fields2 \ -D num.key.fields.for.pa…
阅读更多...
Focal Loss (聚焦损失) ：解决类别不平衡与难易样本的利器，让模型学会“重点学习”

Focal Loss (聚焦损失) ：解决类别不平衡与难易样本的利器，让模型学会“重点学习”

1. 为什么需要Focal Loss&#xff1f; 2. 交叉熵损失的问题 3.Focal Loss的智慧&#xff1a;给不同的错误“区别对待” 4.代码演示 1. 为什么需要Focal Loss&#xff1f; 在机器学习和深度学习中&#xff0c;类别不平衡&#xff08;Class Imbalance&#xff09; 是一个普遍…
阅读更多...
最新文章

Copyright @ 2022~2023