【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 的引用计数变成 1shared_ptr<Student> shared_student1(student);//又声明了第二个智能指针对象 , student 的引用计数 变成 2shared_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 个 共享 智能指针同一个对象 , 其引用计数为 Nreturn 0;
}

运行结果 :

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