【C++ 语言】智能指针 引入 ( 内存泄漏 | 智能指针简介 | 简单示例 )

简介: 【C++ 语言】智能指针 引入 ( 内存泄漏 | 智能指针简介 | 简单示例 )

文章目录

I . 智能指针 引入

II . 智能指针 简介

III . 智能指针 简单示例



I . 智能指针 引入


1 . 示例前提 : 定义一个 Student 类 , 之后将该类对象作为智能指针指向的对象 ;


class Student {
public:
  //构造函数
  Student()
  {
  cout << "Student 对象创建" << endl;
  }
  //析构函数
  ~Student()
  {
  cout << "Student 对象释放" << endl;
  }
};


2 . 栈内存创建对象 : 如果在栈内存中创建对象 , 在方法结束后 , 会自动释放 Student 对象 ;


//栈内存中创建对象 , 在方法结束后 , 会自动释放 Student 对象
void createInStack() {
  Student student;
}



3 . 堆内存创建对象 : 使用 new 在堆内存中创建对象时 , 在 该对象的 作用域 结束后 , 不会自动释放 Student 对象 ;



① 错误示例 : 如下方法中 , 只创建了对象 , 在作用域结束时 , 没有释放该对象 , 这样造成了内存泄漏 ;


//堆内存中创建对象 , 在方法结束后 , 不会自动释放 Student 对象
void createInHeap() {
  Student *student = new Student;
}


② 正确示例 : 使用 new 关键字在堆内存中创建了对象 , 必须在作用域结束前, 将该对象使用 delete 方法释放掉 , 否则会造成内存泄漏 ;


//堆内存中创建对象 , 在方法结束后 , 手动调用 delete 释放 Student 对象
void createInHeapAndDelete() {
  //在堆内存中创建对象
  Student* student = new Student;
  //手动释放 堆内存中创建的对象
  delete(student);



4 . 堆内存创建对象 使用智能指针指向该对象 : 堆内存中创建对象 , 将对象指针设置成智能指针 , 该对象在方法结束时会自动释放 ;


//堆内存中创建对象 , 将对象指针设置成智能指针 , 该对象在方法结束时会自动释放
void createInHeapWithSmartPointer() {
  Student* student = new Student;
  shared_ptr<Student> shared_student(student);
}



II . 智能指针 简介


C ++ 的 STL ( Standard Template Library 标准模板库 ) 提供了 四种智能指针 :



① shared_ptr : 指向的对象所有权 共享 , 多个指针指向同一个对象 ; 当最后一个智能指针销毁时 , 对象销毁 ;


② weak_ptr : 为了弥补 shared_ptr 的缺陷而引入的智能指针 ;


③ unique_ptr : 指向的对象所有权 互斥 , 同一时间 , 一个 对象 只能有一个 unique_ptr 智能指针 指向它 ;


④ auto_ptr ( 已弃用 ) : 该智能指针在 C++ 11 标准中 已弃用 , 但是为了向低版本兼容 , 目前仍可以使用 ;



写新代码就不要使用 auto_ptr 类型的智能指针了 , 推荐使用 unique_ptr 智能指针 , 该指针是 auto_ptr 的安全进阶版本 ;




III . 智能指针 简单示例


1 . 示例项目下载地址 :


主要代码及逻辑都在下面的主代码示例中 , 没有下载的必要 ;



2 . 头文件 :


// 007_SmartPointer.h: 标准系统包含文件的包含文件
// 或项目特定的包含文件。
#pragma once
#include <iostream>
// TODO: 在此处引用程序需要的其他标头。




3 . 主代码示例 :


// 007_SmartPointer.cpp: 定义应用程序的入口点。
//
#include "007_SmartPointer.h"
using namespace std;
//智能指针原理 :
//  智能指针本质 : 智能指针也是一个对象
//  智能指针存放 : 该智能指针对象处于 栈内存中 
//  智能指针释放 : 函数执行完毕后 , 就会调用智能指针对象的析构方法
//  判定引用计数 : 在智能指针对象析构方法的内部就会判定智能指针 操作对象 的引用计数
//  如果这个 操作对象的 引用计数为 0 ,  就会调用 delete 方法释放 操作对象 ; 
class Student {
public:
  //构造函数
  Student()
  {
  cout << "Student 对象创建" << endl;
  }
  //析构函数
  ~Student()
  {
  cout << "Student 对象释放" << endl;
  }
};
//栈内存中创建对象 , 在方法结束后 , 会自动释放 Student 对象
void createInStack() {
  Student student;
}
//堆内存中创建对象 , 在方法结束后 , 不会自动释放 Student 对象
void createInHeap() {
  Student *student = new Student;
}
//堆内存中创建对象 , 在方法结束后 , 手动调用 delete 释放 Student 对象
void createInHeapAndDelete() {
  //在堆内存中创建对象
  Student* student = new Student;
  //手动释放 堆内存中创建的对象
  delete(student);
}
//堆内存中创建对象 , 将对象指针设置成智能指针 , 该对象在方法结束时会自动释放
void createInHeapWithSmartPointer() {
  Student* student = new Student;
  shared_ptr<Student> shared_student(student);
}
//堆内存中创建对象 , 将对象指针设置成智能指针 , 该对象在方法结束时会自动释放
void createInHeapWithTwoSmartPointer() {
  Student* student = new Student;
  //声明了一个智能指针对象 , student 的引用计数变成 1
  shared_ptr<Student> shared_student1(student);
  //又声明了第二个智能指针对象 , student 的引用计数 变成 2
  shared_ptr<Student> shared_student2(student);
  //上面的两个智能指针对象处于栈中 , 当函数结束时 , 这两个智能指针本身会被释放掉
  //  释放两个智能指针后 , student 对象的引用计数又变成了 0 
  //  两个智能指针会被回收 , 回收智能指针时 , 会做判定 , 当 对象的引用计数为 0 时
  //  自动调用该对象的析构函数 , 释放该对象
}
int main()
{
  //C++ 11 STL 提供了两种类型的 智能指针
  //在方法中 , 有两种创建对象的方式 : ① 直接声明对象 , ② 使用 new 创建对象 ;  
  //  直接声明对象 , 是在栈内存中创建实例 , 方法结束后 , 该实例自动释放 ; 
  //  如果使用 new 创建对象 , 是在堆内存中创建 , 创建后返回一个对象的指针 ; 
  //  堆内存中的对象需要手动释放 , new 申请的对象 , 需要调用 delete 释放 ( delete 会触发虚构函数 ) ; 
  //  如果忘记手动释放使用 new 创建的对象 , 就会导致内存泄漏
  //  因此引入智能指针 , 可以防止忘记手动释放对象导致内存泄漏
  //栈内存中创建对象 , 自动释放 Student 对象
  cout << "栈内存中 创建 Student 对象" << endl;
  createInStack();
  //堆内存中创建对象 , 不会自动释放 Student 对象
  cout << "\n堆内存中 创建 Student 对象 , 不主动释放该对象" << endl;
  createInHeap();
  cout << "\n堆内存中 创建 Student 对象 , 主动 调用 delete 方法 释放该对象" << endl;
  //堆内存中创建对象 , 函数结束前手动调用 delete 方法 , 释放该对象
  createInHeapAndDelete();
  cout << "\n堆内存中 创建 Student 对象 , 将其设置成智能指针" << endl;
  //堆内存中创建对象 , 将对象指针设置成智能指针 , 该对象在方法结束时会自动释放
  createInHeapWithSmartPointer();
  //智能指针分类 : 
  //  共享智能指针 : shared_ptr , 该智能指针内部实现了引用计数 , 多个共享智能指针指向同一个对象时
  //  有 N 个 共享 智能指针同一个对象 , 其引用计数为 N
  return 0;
}



运行结果 :


栈内存中 创建 Student 对象
Student 对象创建
Student 对象释放
堆内存中 创建 Student 对象 , 不主动释放该对象
Student 对象创建
堆内存中 创建 Student 对象 , 主动 调用 delete 方法 释放该对象
Student 对象创建
Student 对象释放
堆内存中 创建 Student 对象 , 将其设置成智能指针
Student 对象创建
Student 对象释放

image.png


目录
打赏
0
0
0
0
39
分享
相关文章
深入解析C++中的函数指针与`typedef`的妙用
本文深入解析了C++中的函数指针及其与`typedef`的结合使用。通过图示和代码示例,详细介绍了函数指针的基本概念、声明和使用方法,并展示了如何利用`typedef`简化复杂的函数指针声明,提升代码的可读性和可维护性。
112 1
|
3月前
|
在使用指针数组进行动态内存分配时,如何避免内存泄漏
在使用指针数组进行动态内存分配时,避免内存泄漏的关键在于确保每个分配的内存块都能被正确释放。具体做法包括:1. 分配后立即检查是否成功;2. 使用完成后及时释放内存;3. 避免重复释放同一内存地址;4. 尽量使用智能指针或容器类管理内存。
|
3月前
|
探索 Go 语言中的内存对齐:为什么结构体大小会有所不同?
在 Go 语言中,内存对齐是优化内存访问速度的重要概念。通过调整数据在内存中的位置,编译器确保不同类型的数据能够高效访问。本文通过示例代码展示了两个结构体 `A` 和 `B`,尽管字段相同但排列不同,导致内存占用分别为 40 字节和 48 字节。通过分析内存布局,解释了内存对齐的原因,并提供了优化结构体字段顺序的方法,以减少内存填充,提高性能。
54 3
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
252 4
|
3月前
|
Go语言的内存管理机制
【10月更文挑战第25天】Go语言的内存管理机制
49 2
在 C++中,引用和指针的区别
在C++中,引用和指针都是用于间接访问对象的工具,但它们有显著区别。引用是对象的别名,必须在定义时初始化且不可重新绑定;指针是一个变量,可以指向不同对象,也可为空。引用更安全,指针更灵活。
Elasticsearch集群JVM调优设置合适的堆内存大小
Elasticsearch集群JVM调优设置合适的堆内存大小
643 1
深入探索Java虚拟机(JVM)的内存管理机制
本文旨在为读者提供对Java虚拟机(JVM)内存管理机制的深入理解。通过详细解析JVM的内存结构、垃圾回收算法以及性能优化策略,本文不仅揭示了Java程序高效运行背后的原理,还为开发者提供了优化应用程序性能的实用技巧。不同于常规摘要仅概述文章大意,本文摘要将简要介绍JVM内存管理的关键点,为读者提供一个清晰的学习路线图。
|
3月前
|
JVM内存参数
-Xmx[]:堆空间最大内存 -Xms[]:堆空间最小内存,一般设置成跟堆空间最大内存一样的 -Xmn[]:新生代的最大内存 -xx[use 垃圾回收器名称]:指定垃圾回收器 -xss:设置单个线程栈大小 一般设堆空间为最大可用物理地址的百分之80

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等