void
*
o
=
malloc
(
size
)
;
auto
r
=
deleted_p
.
find
(
o
)
;
if
(
r
!=
deleted_p
.
end
(
)
)
deleted_p
.
erase
(
r
)
;
return
o
;
void
operator
delete
(
void
*
o
)
deleted_p
.
insert
(
o
)
;
free
(
o
)
;
static
bool
isDeleted
(
A
*
a
)
auto
r
=
deleted_p
.
find
(
a
)
;
return
r
!=
deleted_p
.
end
(
)
;
class
B
:
public
A
public
:
B
(
int
a
)
:
A
(
a
)
int
main
(
int
argc
,
char
*
argv
[
]
)
for
(
int
i
=
0
;
i
<
1000
;
i
++
)
A
*
a
=
new
B
(
i
)
;
if
(
A
::
isDeleted
(
a
)
)
int
b
=
0
;
delete
a
;
if
(
A
::
isDeleted
(
a
)
)
int
b
=
0
;
感觉怪怪的效率应该很低
思路重载new/delete操作符，用静态数据结构记录被删除的指针，用类成员静态函数判断指针是否被删除。实现代码#include <set>#include<stdlib.h>static std::set<void *> deleted_p;//记录已经被释放的指针地址class A{public: A(int a) { } void* operator new(std::size_t size) {
inline void checked_
delete
(T* x) noexcept
typedef char type_must_be_complete[sizeof(T) ? 1 : -1];
(void) sizeof(type_must.
在一个类中，如果类没有
指针
成员，一切方便，因为默认合成的析构函数会自动处理所有的内存。但是如果一个类带了
指针
成员，那么需要我们自己来写一个析构函数来管理内存。在<<c>> 中写到，如果一个类需要我们自己写析构函数，那么这个类，也会需要我们自己写拷贝构造函数和拷贝赋值函数。
析构函数：
我们这里定义一个类HasPtr，这个类中包含一个int 类型的
指针
。然后定义一个析构函数，这个函数打印一句话。
HasPtr.h 类的头文件
#pragma once
#ifndef __HASPTR__
#define __HASPTR__
class HasPtr
public:
智能
指针
智能
指针
是行为类似于
指针
的类对象。可以帮助管理动态内存分配。普通
指针
分配内存后都必须释放内存 new 之后需要使用
delete
否则内存泄漏。智能
指针
类对象封装了自动释放内存的功能 从而避免内存泄漏
void remodel(std::string & str)
std::string * ps = new std::string(str);
//str = ps;
return; //内存泄漏
void remodel1(std::string & str1)
std::shared_ptr ps(new std::string(str1))
学c++的人都知道，在c++里面有一个痛点，就是动态内存的管理，就我所经历的一些问题来看，很多莫名其妙的问题，最后都发现是内存管理不当引起的。
但像java等其他一些语言则不会有这样的问题，为什么呢，因为它们有很好的处理内存的方法，比如java的垃圾回收机制，现在，我们c++终于也有了智能
指针
。
1. 什么是智能
指针
简单地说，智能
指针
是用对象去管理一个资源
指针
，同时用一个计数器计算引用当前
指针
对象的个数，当管理
指针
的对象增加或减少时，计数器也相应加1或减1，当最后一个
指针
管理对象销毁时，计数器为1，此时在销毁
指针
管理对象的同时，也对
指针
管理对象所管理的
指针
进行
delete
操作。
下面我们介
在C++中
delete
指针
前不用进行
指针
是否
为空的
判断
，因为
delete
的实现已经做了这件事情！
使用
delete
来
delete
已释放的
指针
是一个严重的错误，所以要在
delete
完一个
指针
后手动把它置空！
因为
delete
空
指针
是安全的。
以下是Bjarne
Stroustrup's C++ Style and Technique FAQ中的
Why does
因为如果一个对象被
delete
后，或是 free 后，随时都有可能会立刻被分配到其他地方的内存使用了。
所以 当前对象 this 或是 this 中的 char* _isDestroy 成员就有可能会被其他程序分配到一个我们这个程序中不可访问的内存地址中去，这时要是通过以下原来的
判断
方式就会出错：
可能会报 this 内存地址不可访问。
学习C++新手通常会对
指针
的使用比较头疼，其实
指针
的概念很简单，只要能悟清楚这样一个简单的道理就能对
指针
有一定的认识了： 例如 int *a = new int[10]; 一维
指针
其实就相当于一维数组，不用去看书上所说的数组在内存中的首地址这些晦涩的话，以此类推 二维
指针
就相当于二维数组，新手对一维数组的开辟与释放比较容易熟悉，例如上面的a 释放就是
delete
[]a; a = NULL; 注意a = NULL; 必须要加上，这样是为了避免这个
指针
会变成“野
指针
”。写程序时一定要注意规范性和严谨性，避免可能会出现的错误。 代码如下://二维
指针
的开辟与释放int **b = NULL;b
智能
指针
(smart pointer)是存储指向动态分配（堆）对象
指针
的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。智能
指针
类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一
指针
。每次创建类的新对象时，初始化
指针
并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝
指针
并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计
文章目录引言：（一）new对象过程（二）
delete
对象过程
我们往往使用new
delete
对象，这个过程被编译器藏得很深，但是这个过程具体是什么？和C语言的malloc、free有什么样的区别和联系呢？那就先看看下面这个点类的设计，本文将通过这个代码进行new和
delete
对象的步骤的深入。
#include <iostream>
using namespace std;
class Point
public:
Point(){}
Point(int r, int c)
Qt中已下情况new出的对象可以不用亲自去
delete
:
（1）QObject及其派生类的对象，如果其parent非0，则其parent析构时会析构该对象，除此之外，有些类的对象可以接收设置一些特别的标记，例如：
1） QWidget及其派生类的对象，可以设置Qt::WA_
Delete
OnClose标志位（当close时会析构该对象）
2）QAbstractAni...
C++无论何种数据，
是否
要
delete
关键看其空间
是否
使用new分配的。
1，函数冲定义的局部变量
指针
，单纯是一个局部变量是不用
delete
；
2，C++ 如果类中有一个
指针
数据成员，而没有用new， 析构函数也是不用
delete
的；
在类或函数中，int* ，char* 这些只要不是new的，也同样不用释放，系统会自动把他们占的内存释放掉，只有new的才会手动的去
delete
int*，...
在构造函数中，使用 `new` 运算符分配一个包含10个整数的动态数组，并将其
指针
存储在 `ptr` 成员变量中。在析构函数中，使用 `
delete
[]` 运算符释放动态分配的内存。
当需要访问动态数组时，可以使用 `ptr` 成员变量来获取指向该数组的
指针
。例如：
```c++
MyClass obj;
obj.ptr[0] = 123; // 访问动态数组的第一个元素
