＜六＞内存分配&智能指针内存泄漏问题

已于 2023-11-23 17:14:58 修改
阅读量149 收藏
点赞数
分类专栏： C++_内存管理及智能指针 文章标签： c++
于 2023-05-30 10:52:56 首次发布
本文链接：https://blog.csdn.net/ericshioce/article/details/130937345
版权

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <iostream>
using namespace std;

class Point{
public:
  Point(int x, int y, int z):x(x),y(y),z(z){ 
    cout<<"ctor"<<endl;
  }
  ~Point(){ cout<<"dtor"<<endl;}

  virtual void print(){
    cout<<x<<" "<<y<<" "<<z<<endl;
  }

  int x;
  int y;
  int z;
};

int main()
{  
   cout<<sizeof(Point)<<endl;
   void* memory = std::malloc(sizeof(Point));

   long *p=(long *)memory;
   std::cout<<*p<<std::endl;//第一个位置放的是虚函数表指针

   p++;
   int* p1=(int*)p;
   for(int i=0;i<3;i++)
   {
      cout<<*p1<<" ";
      p1++;
   }

   //在指定内存位置构建对象Point
   Point* myObject = ::new (memory) Point[{100,200,300}];
   myObject->print();

  long* p=(long*)memory;
  cout<<*p<<endl;
  p++;

  int* pi=reinterpret_cast<int*>(p);
  cout<<*pi++<<endl;
  cout<<*pi++<<endl;
  cout<<*pi<<endl;
  
   myObject->~Point();
   std::free(memory);

 
  // int data=100;
  // double dvalue=234.323;
  //int value =(int)dvalue C风格转换,不推荐了
  // static_cast：相关类型转型可能造成内存位的丢失
  // int value=static_cast<int>(dvalue); 
  // static_cast  子类指针可以直接赋值给父类指针是兼容的,但是
  // 也可以使用static_cast 来强调子类转型到了父类 

  // //dynamic_cast: 多态转型 , 基类必须有虚函数(虚析构函数)
  // Sub s1;
  // Base& base=s1;
  // Sub& s=dynamic_cast<Sub&> (base);

  // //reinterpret_cast: 二进制一致性转型
  // //const_cast: 去常量性
  

    //标准库针对placement_new 做了更好用的封装如下
    void* memory = std::malloc(3*sizeof(Point));
    Point* myObject = reinterpret_cast<Point*>(memory);
    std::uninitialized_fill_n(myObject, 3, Point{100,200,300});
    //3表示写几次,3次那么就要预先申请3倍的内存空间
 
    std::destroy_at(myObject);
    std::free(memory);

    //void* 转到其他类型的指针也可以使用static_cast 也可以 reinterpret_cast
    //建议统一使用reinterpret_cast

}

//placement_new 常使用的场景,大量小对象的频繁开辟销毁,造成
//内存碎片

关于operator new operator delete重载
在这里插入图片描述

类内部operator_new operator_delete

#include <iostream>
using namespace std;

//void* T::operator new  ( std::size_t count );
//void* T::operator new[]( std::size_t count );

class MyClass{
public:
  MyClass(const string& s):_s(s){}
  MyClass(){ cout<<"ctor"<<endl;}
  ~MyClass(){ cout<<"dtor"<<endl;}
  void process(){
    cout<<_s<<endl;
  }

  void* operator new(size_t size)   {
    cout<<"class new "<<endl;

   data++;
   //data+=size;
    return ::operator new(size); 调用全局new
  } 
  void operator delete(void* p)  {
    cout<<"class delete "<<endl;
    ::operator delete(p); 

    data--;
  } 

  static int data;
private:
  string _s;
};

int MyClass::data=0;

int main()
{
  
  MyClass* myObject = new MyClass{"Software"};  
  myObject->process();             
  delete myObject;

  cout<<"-----------"<<endl;
  MyClass* p = ::new MyClass{}; //绕过自定义类内部的operator new 使用全局的 operator new
  ::delete p;
 

}

全局operator_new operator_delete

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

int alloc_times = 0; 
int dealloc_times = 0; 
int allocated = 0; 


class MyClass{
 
private:
  double x,y,z;
};


void* operator new(size_t size)  { 
  void* p = std::malloc(size); 
  //std::cout << "allocated " << size << " byte(s)\n"; 

  allocated+=size;
  alloc_times++;
  return p; 
} 
 
void operator delete(void* p) noexcept  { 
  //std::cout << "deleted memory\n"; 

  dealloc_times++;
  return std::free(p); 
}

void* operator new[](size_t size)   {
  void* p = std::malloc(size); 
  allocated+=size;
  alloc_times++;

  std::cout << "allocated " << size << " byte(s) with new[]\n"; 
  return p; 
} 
void operator delete[](void* p) noexcept  { 
  std::cout << "deleted memory with delete[]\n"; 
   dealloc_times++;
  return std::free(p); 
}

int main()
{
  
  {
    MyClass* v=new MyClass[10];//24*10=240

    cout<<allocated<<endl;

    for(int i=0;i<10;i++)
    {
      MyClass* pc=new MyClass();//10
      delete pc;
    }
     delete[] v;

  }

  //MyClass* p = ::new MyClass{}; 
  //::delete p;

  cout<<allocated<<endl;
  cout<<alloc_times<<endl;
  cout<<dealloc_times<<endl;

}

全局operator_new operator_delete 结合share_ptr weak_ptr一些有意思的代码 1.1

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

class MyClass{

public:
    MyClass(){ cout<<"MyClass()构造函数"<<endl;}
    ~MyClass(){ cout<<"~MyClass()析构函数"<<endl;}
    
private:
  double x,y,z;

};


int alloc_times = 0; 
int dealloc_times = 0; 
int allocated = 0; 


void* operator new(size_t size)  { 
  void* p = std::malloc(size); 
  cout << "operator new " << size << " byte(s)"<<endl; 

  allocated+=size;
  alloc_times++;
  return p; 
} 
 
void operator delete(void* p) noexcept  { 
  cout << "operator deleted memory"<<endl; 
  dealloc_times++;
  return std::free(p); 
}

int main(){

    //weak_ptr<MyClass> w;
    cout<<"分配尺寸:"<<allocated<<endl;
    cout<<"分配次数"<<alloc_times<<endl;
    cout<<"释放次数"<<dealloc_times<<endl;
    {
         shared_ptr<MyClass> s{new MyClass()};
        //shared_ptr<MyClass> s = std::make_shared<MyClass>();
        //w=s; 
       
   }   
    //1. s析构、释放原始对象、但不释放控制块
    cout<<"block end--------"<<endl;
    cout<<"分配尺寸:"<<allocated<<endl;
    cout<<"分配次数"<<alloc_times<<endl;
    cout<<"释放次数"<<dealloc_times<<endl;
  
    //w.reset(); //2. w析构、释放控制块
    //cout<<"分配尺寸:"<<allocated<<endl;
    //cout<<"分配次数"<<alloc_times<<endl;
    //cout<<"释放次数"<<dealloc_times<<endl;
      
}

//运行结果如下
/*
分配尺寸:0
分配次数0
释放次数0
operator new 24 byte(s)
MyClass()构造函数
operator new 24 byte(s)
~MyClass()析构函数
operator deleted memory
operator deleted memory
block end--------
分配尺寸:48
分配次数2
释放次数2

//我们来对上面运行结果进行分析
智能指针创建方式: shared_ptr<MyClass> s{new MyClass()};
运行结果中第一个  operator new 24 byte(s) 这24个字节是创建 new MyClass()的时候发生空间开辟动作, 然后紧接着调用MyClass的构造函数

第二个 operator new 24 byte(s) 是给谁的??
我们再上一篇内容 <三>智能指针之__sharePtr 第一张图揭示了 sharePtr的内存结构
sharePtr 中有两条指针, 第一条指向MyClass()对象,这个对象中有三个double成员,所以消费了24个字节空间
第二条指针指向了控制块,那控制块对象有哪些成员呢？控制块对象又需要多少个字节存储空间呢？首先运行结果是24个字节空间
我们下面通过跟踪源码 看一下  控制块的的内部结构,如下图 , 看完下图就知道这24个字节其中一个是指向原对象的指针,
另外两个是long 类型的计数器


当 shared_ptr<MyClass> s{new MyClass()}; 出{}作用域后 析构了两次,一个是MyClass的,还有一个是控制块的

接下来我们将上面代码中的//都去掉
主要关注点
  1：  //weak_ptr<MyClass> w;
  2：  //w=s;
  3：
    //w.reset(); w.reset()开和不开 两种不同结果,看看不开的情况 //2. w析构、释放控制块
    //cout<<"分配尺寸:"<<allocated<<endl;
    //cout<<"分配次数"<<alloc_times<<endl;
    //cout<<"释放次数"<<dealloc_times<<endl;

 见下面代码 1.2

*/

在这里插入图片描述

全局operator_new operator_delete 结合share_ptr weak_ptr一些有意思的代码 1.2

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

class MyClass{

public:
    MyClass(){ cout<<"MyClass()构造函数"<<endl;}
    ~MyClass(){ cout<<"~MyClass()析构函数"<<endl;}
    
private:
  double x,y,z;

};


int alloc_times = 0; 
int dealloc_times = 0; 
int allocated = 0; 


void* operator new(size_t size)  { 
  void* p = std::malloc(size); 
  cout << "operator new " << size << " byte(s)"<<endl; 

  allocated+=size;
  alloc_times++;
  return p; 
} 
 
void operator delete(void* p) noexcept  { 
  cout << "operator deleted memory"<<endl; 
  dealloc_times++;
  return std::free(p); 
}

int main(){

    weak_ptr<MyClass> w;
    cout<<"分配尺寸:"<<allocated<<endl;
    cout<<"分配次数"<<alloc_times<<endl;
    cout<<"释放次数"<<dealloc_times<<endl;
    {
         shared_ptr<MyClass> s{new MyClass()};
        //shared_ptr<MyClass> s = std::make_shared<MyClass>();
        w=s; 
       
   }   
    //1. s析构、释放原始对象、但不释放控制块
    cout<<"block end--------"<<endl;
    cout<<"分配尺寸:"<<allocated<<endl;
    cout<<"分配次数"<<alloc_times<<endl;
    cout<<"释放次数"<<dealloc_times<<endl;
  
    //w.reset(); //2. w析构、释放控制块
    cout<<"分配尺寸:"<<allocated<<endl;
    cout<<"分配次数"<<alloc_times<<endl;
    cout<<"释放次数"<<dealloc_times<<endl;
      
}

//运行结果如下
/*

分配尺寸:0
分配次数0
释放次数0
operator new 24 byte(s)
MyClass()构造函数
operator new 24 byte(s)
~MyClass()析构函数
operator deleted memory
block end--------
分配尺寸:48
分配次数2
释放次数1
分配尺寸:48
分配次数2
释放次数1
operator deleted memory

//我们来对上面运行结果进行分析
智能指针创建方式: shared_ptr<MyClass> s{new MyClass()};
运行结果中第一个  operator new 24 byte(s) 这24个字节是创建 new MyClass()的时候发生空间开辟动作, 然后紧接着调用MyClass的构造函数

第二个 operator new 24 byte(s) 是给控制块的,这个我们再代码1.1已经学习到了
我们再没有打开  //w.reset(); 这个代码的情况下,居然只析operator_delete了一次,这一次就是给MyClass的内存释放用的
为什么控制块的堆内存没能得到正常的operter_delete? 这个不是内存泄漏吗？确实属于内存泄漏,原因在于 
  weak_ptr<MyClass> w;
  ..
  ..
  w=s; 
  我们用一个弱引用挂住了share_ptr
  w=s; 会使得弱引用计数 +1  见下面第一张图

  我们现在通过跟踪源码看看为什么operator_delete一次,见下面第二张图

  通过看完下面第二张图,我知道了出来share_ptr作用域 对象应用计数==0所以对象delete
  但是还有一个w=s挂着弱引用,使得弱引用计数不为0，到时弱引用计数指针指向的堆无法被释放
  即内存泄漏!!
*/

 接下来我们看代码1.3  我们激活 w.reset(); //2. w析构、释放控制块

第一张图
在这里插入图片描述
第二张图
在这里插入图片描述
全局operator_new operator_delete 结合share_ptr weak_ptr一些有意思的代码 1.3

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

class MyClass{

public:
    MyClass(){ cout<<"MyClass()构造函数"<<endl;}
    ~MyClass(){ cout<<"~MyClass()析构函数"<<endl;}
    
private:
  double x,y,z;

};


int alloc_times = 0; 
int dealloc_times = 0; 
int allocated = 0; 


void* operator new(size_t size)  { 
  void* p = std::malloc(size); 
  cout << "operator new " << size << " byte(s)"<<endl; 

  allocated+=size;
  alloc_times++;
  return p; 
} 
 
void operator delete(void* p) noexcept  { 
  cout << "operator deleted memory"<<endl; 
  dealloc_times++;
  return std::free(p); 
}

int main(){

    weak_ptr<MyClass> w;
    cout<<"分配尺寸:"<<allocated<<endl;
    cout<<"分配次数"<<alloc_times<<endl;
    cout<<"释放次数"<<dealloc_times<<endl;
    {
         shared_ptr<MyClass> s{new MyClass()};
        //shared_ptr<MyClass> s = std::make_shared<MyClass>();
        w=s; 
       
   }   
    //1. s析构、释放原始对象、但不释放控制块
    cout<<"block end--------"<<endl;
    cout<<"分配尺寸:"<<allocated<<endl;
    cout<<"分配次数"<<alloc_times<<endl;
    cout<<"释放次数"<<dealloc_times<<endl;
  
    w.reset(); //2. w析构、释放控制块
    cout<<"分配尺寸:"<<allocated<<endl;
    cout<<"分配次数"<<alloc_times<<endl;
    cout<<"释放次数"<<dealloc_times<<endl;
      
}

//运行结果如下

分配尺寸:0
分配次数0
释放次数0
operator new 24 byte(s)
MyClass()构造函数
operator new 16 byte(s)
~MyClass()析构函数
operator deleted memory
block end--------
分配尺寸:40
分配次数2
释放次数1
operator deleted memory
分配尺寸:40
分配次数2
释放次数2


 在w.reset()之前释放次数为1,在w.reset()之后dealloc_times又加了1,这样释放次数就为2 了,
 所以在w.reset()之前,原对象已经正常释放了，在w.reset()之后控制块又正常释放了


 ------------------------
 接下来 我们 将代码中的
 shared_ptr<MyClass> s{new MyClass()};
 换成 shared_ptr<MyClass> s = std::make_shared<MyClass>(); 看看 见代码1.4

全局operator_new operator_delete 结合share_ptr weak_ptr一些有意思的代码 1.4


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

class MyClass{

public:
    MyClass(){ cout<<"MyClass()构造函数"<<endl;}
    ~MyClass(){ cout<<"~MyClass()析构函数"<<endl;}
    
private:
  double x,y,z;

};


int alloc_times = 0; 
int dealloc_times = 0; 
int allocated = 0; 


void* operator new(size_t size)  { 
  void* p = std::malloc(size); 
  cout << "operator new " << size << " byte(s)"<<endl; 

  allocated+=size;
  alloc_times++;
  return p; 
} 
 
void operator delete(void* p) noexcept  { 
  cout << "operator deleted memory"<<endl; 
  dealloc_times++;
  return std::free(p); 
}

int main(){

    weak_ptr<MyClass> w;
    cout<<"分配尺寸:"<<allocated<<endl;
    cout<<"分配次数"<<alloc_times<<endl;
    cout<<"释放次数"<<dealloc_times<<endl;
    {
         //shared_ptr<MyClass> s{new MyClass()};
        shared_ptr<MyClass> s = std::make_shared<MyClass>();
        w=s; 
       
   }   
    //1. s析构、释放原始对象、但不释放控制块
    cout<<"block end--------"<<endl;
    cout<<"分配尺寸:"<<allocated<<endl;
    cout<<"分配次数"<<alloc_times<<endl;
    cout<<"释放次数"<<dealloc_times<<endl;
  
    w.reset(); //2. w析构、释放控制块
    cout<<"分配尺寸:"<<allocated<<endl;
    cout<<"分配次数"<<alloc_times<<endl;
    cout<<"释放次数"<<dealloc_times<<endl;
      
}

-----运行结果
分配尺寸:0
分配次数0
释放次数0
operator new 40 byte(s)
MyClass()构造函数
~MyClass()析构函数
block end--------
分配尺寸:40
分配次数1
释放次数0
operator deleted memory
分配尺寸:40
分配次数1
释放次数1

//上面的结果我有以下几个点需要关注
1:operator new()只发生了一次,即内存只开辟了一次(相比shared_ptr<MyClass> s{new MyClass()};这种方式)
2:在w.reset();之前 哪怕shared_ptr<MyClass> s = std::make_shared<MyClass>(); 出了作用域, 基础对象
 都没有operator_delete, 与shared_ptr<MyClass> s{new MyClass()} 不一样,

3:w.reset()之后 operator_delete发生了一次

针对上面的关注点,我们来分析一下
1:shared_ptr<MyClass> s = std::make_shared<MyClass>(); 与shared_ptr<MyClass> s{new MyClass()};
智能指针的构建过程和方式不一样
a:shared_ptr<MyClass> s{new MyClass()} 先 new MyClass() 第二步再在堆上创建控制块对象,所以operator_new 了两次
b:shared_ptr<MyClass> s = std::make_shared<MyClass>(); 直接将MyClass对象所需内存大小+控制块内存所需大小 一次分配了，
所以只调用了一次operator_new ,大小40字节，(这种一次开辟的内存控制是无法区分MyClass和控制块分别delete的，只能一次性回收所有40个字节)

2:正是由于上面b:中描述的原因这一块大内存区域还有weak_ptr还在占用，导致share_ptr出了作用域也无法释放空间,但是w.reset()之后由于没有弱引用再使用内存了,那么整块内存就可以回收了

3:所有如果没有w.rest() 那么这个40个字节一直无法释放,相当于内存泄漏了.

哪些情况场景下,我们会用到内存分配自定义?

在这里插入图片描述

HelloBugs88
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
关于c++ 智能指针及 循环引用的问题
12-26
智能指针在 <memory>标头文件的 std 命名空间中定义。 它们对 RAII 或 获取资源即初始化 编程惯用法至关重要。 RAII 的主要原则是为所有堆分配资源提供所有权，例如动态分配内存或系统对象句柄、析构函数包含要删除...
C++11新特性之智能指针|内存泄漏
jolly0514的博客
09-23 250
内存泄漏:内存泄漏指是因为疏忽或者错误造成程序未能释放已经不再使用的内存情况。内存泄漏并不是指内存在物理上的消息，而是应用程序分配某段内存后，因为涉及错误，失去了对该段内存的控制，造成了内存的浪费。内存泄漏的危害：如os,后台服务等，出现内存泄漏会导致程序响应越来越慢，最终卡死。// 1.内存申请了忘记释放// 2.异常安全问题Func();// 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
【C++】智能指针【内存泄漏|智能指针原理及使用|RAII】
m0_74044018的博客
11-06 271
讲解内存泄漏、智能指针原理及使用，基于RAII思想、还有锁的问题
C++ 智能指针 unique_ptr 详解与示例
热门推荐
彼此当年少，莫负好时光
12-22 11万+
在本文中，我们将讨论由C++11提供的智能指针std :: unique_ptr&amp;amp;amp;lt;&amp;amp;amp;gt;。 unique_ptr &amp;amp;amp;lt;&amp;amp;amp;gt;是C++ 11提供的用于防止内存泄漏的智能指针中的一种实现。unique_ptr对象包装一个原始指针，并负责其生命周期。当该对象被销毁时，会在其析构函数中删除关联的原始指针。 ...
c++智能指针有没有内存泄露的情况
敖丙007的博客
03-12 595
上述代码中，parent有一个shared_ptr类型的成员指向孩子，而child也有一个shared_ptr类型的成员指向父亲。然后在创建孩子和父亲对象时也使用了智能指针c和p，随后将c和p分别又赋值给child的智能指针成员parent和parent的智能指针成员child。，weak_ptr的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但是不会指向引用计数的共享内存，但是可以检测到所管理的对象是否已经被释放，从而避免非法访问。2.智能指针的内存泄漏如何解决？
智能指针（解决你的内存泄漏）
weixin_46873777的博客
03-06 2236
智能指针，解决你的单身问题
c++11智能指针
01-06
智能指针类对象封装了自动释放内存的功能 从而避免内存泄漏 例如 void remodel(std::string & str) { std::string * ps = new std::string(str); //str = ps; return; //内存泄漏 } void remodel1(std::string &...
C++智能指针循环引用问题分析.pdf
02-27
C++智能指针循环引⽤问题分析 C++11中引⼊了三种智能指针，分别是shared_ptr、weak_ptr和unique_ptr 智能指针的作⽤ 智能指针可以帮助我们管理动态分配的堆内存，减少内存泄漏的可能性 ⼿动管理堆内存有引起内存泄漏...
C++在设计和使用智能指针
12-22
　而此时智能指针可能能够帮助我去解决问题。 　智能指针（smart pointer）是利用个引用计数的策略去处理指针的释放，从而保证指针的安全性。 　通常情况下，我们会自己去设计一个智能指针类去管理自己的指针对象...
C++11之智能指针
12-22
使用c++，除了c++的语法外，指针是我们面临的的大一个问题，... 　3 内存泄漏：不需要的内存单元没有释放，一旦程序一直在重复这样的操作，会导致程序的内存占用月来越高。 　虽然显示的手动管理内存，给程序的内存
C++ 智能指针
chi's blog
05-19 1008
在实际的 C++ 开发中，我们经常会遇到诸如程序运行中突然崩溃、程序运行所用内存越来越多最终不得不重启等问题，这些问题往往都是内存资源管理不当导致的。有些内存资源已经被释放，但指向它的指针并没有改变指向（成为了野指针），并且后续还在使用；有些内存资源已经被释放，后期又试图再释放一次（重复释放同一块内存会导致程序运行崩溃）；没有及时释放不再使用的内存资源，造成内存泄漏，程序占用的内存资源越来越多。C/C++什么是内存泄露，内存泄露如何避免？
C++11 解决内存泄露问题的智能指针：shared_ptr、unique_ptr、weak_ptr
Bobowen的博客
01-17 1509
我们经常听到内存泄漏，但是对这个抽象的概念一直没有什么理解，比如产生内存泄漏又将如何，我平时写程序从来不考虑这个等等。这篇的目的：第一，给大家实验实验内存泄露带来的问题，让大家直观感受内存泄露。第二，介绍C++11新特性智能指针shared_ptr、unique_ptr、weak_ptr。
【C++】C++11——智能指针、内存泄漏、智能指针的使用和原理、RAII、auto_ptr、unique_ptr、shared_ptr、weak_ptr
Crocodile1006的博客
10-12 851
C++11、智能指针、内存泄漏、智能指针的概念、智能指针的使用、auto_ptr、unique_ptr、shared_ptr、weak_ptr
智能指针（三）—— shared_ptr 循环引用问题（智能指针什么情况下存在内存泄漏）
challenglistic的博客
02-03 2478
智能指针（三）—— shared_ptr 循环引用问题
内存泄漏检查工具
qq_33271192的博客
09-20 1964
C++内存泄漏检查工具——Valgrind（–tool = memcheck） 在写大型C/C++工程时难免会发生内存泄漏现象，系统编程中一个重要的方面就是有效地处理与内存相关的问题。你的工作越接近系统，你就需要面对越多的内存问题。有时这些问题非常琐碎，而更多时候它会演变成一个调试内存问题的恶梦。 常见的内存问题一共七种：1. 动态内存泄露；2. 资源泄露，比如文件指针不关闭；3. 动态内存越界；4.数组内存越界；5.动态内存double free；6.使用野指针，即未初始化的指针；7.释放野指针，即未初始
智能指针——从根源上解决内存泄漏的问题
ajt1234的博客
06-21 800
一、什么是内存泄漏 用new在堆中分配内存后，没有调用delete，然后指针所在的内存因为作用域规则而被释放。这时候堆中分配的内存仍在，但是指向它的指针没了，导致程序的整个生命周期内都无法访问这部分内存，也就是说内存泄漏了。 如果程序只运行一次两次，偶尔的内存泄漏，其实问题不大。但是如果程序是一直在运行的，那么连续的内存泄漏，迟早会导致程序崩溃，甚至会导致其他程序的崩溃，因为堆中内存已经耗尽了。 例： void test(){ char* p = new char[1024*1000*100];//分配1
解决Program received signal SIGSEGV, Segmentation fault
HiSi_的博客
09-30 1329
声明指针之后没有指定指向的位置 点击这里
c++智能指针内存泄漏的问题
qq_23350817的博客
05-07 1356
使用弱引用wak_ptr来解决智能指针内存泄漏的例子 template <class T> class WeakedPtr; template<class T> class SharePtr { public: friend class WeakedPtr<T>; SharePtr(T* ptr = NULL) :_ptr(ptr), _r...
指针如何初始化_c++智能指针
weixin_39865440的博客
12-19 3224
概念 智能指针不是一个指针，它其实是一个对象。它是通过C++的RAII机制实现的。主要是利用C++中对象在释放的时候，会自动调用析构函数这一特性。所以，当智能指针对象释放的时候，在智能指针对象的析构函数中来释放其管理的内存资源。这样，开发人员就不需要手动去释放已经分配的内存空间。C++17标准之后，C++标准中还有三种智能指针：shared_ptr、unique_ptr、weak_ptr...
shared_ptr<char> 跟 shared_ptr<string> 的区别
最新发布
03-20
shared_ptr<char> 是一个智能指针，用于管理指向字符类型的动态内存。它可以自动地跟踪和释放所管理的内存，避免内存泄漏和悬空指针的问题。你可以使用 shared_ptr<char> 来动态分配和释放字符数组，例如： ```cpp ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值