new delete
new delete与malloc free的区别
对于基本数据类型 malloc与free new与delete 效果一致
new delete自动调用构造和析构
malloc不会调用构造函数 free 不会调用析构函数
基本数据类型 数组 delete delete[] 效果一样
复合数据类型 一定要配对使用
class mydata
{
public:
void *p;
mydata()
{
p = malloc(1024 * 1024 * 1024);
cout << "DDDDDDDDDD" << endl;
}
~mydata()
{
//free(p);
cout << "delete" << endl;
}
private:
};
//mydata my; //创建对象 自动调用构造函数
void test()
{
mydata d1; //栈上 创建时候调用构造函数 销毁时候调用析构函数
}
void mainxx5()
{
int *p = new int(5);
cout << (void*)p <<"P="<<p<< endl;
delete p;
cout << (void*)p << "P=" << p << endl;
p = nullptr; //delete不会改变指针的值 为了避免迷途指针 指针设定为nullptr
//delete free 对于基本数据类型 释放 释放两次都会出错
//free不改变指针的值 delete会改变（00008123）
//对于基本数据类型 malloc与free new与delete 效果一致
mydata *xp = new mydata;
delete xp;
//new delete自动调用构造和析构
//malloc不会调用构造函数 free 不会调用析构函数
int*xxp(new int[10]{ 1,2,3,4,5,6,7,8,9,10 });
delete(xxp);
//基本数据类型 数组 delete delete[] 效果一样
//复合数据类型 一定要配对使用
//mydata* mp(new mydata);
//delete[] mp; //对于单个对象 不可以delete[]
mydata* map(new mydata[10]);
//delete map //异常
delete[] map;
cin.get();
}
new分配内存堆栈静态区
//char str[1024]{ 0 }; //内存静态区
//int*p2(new (str)int[10]{ 1,2,3,4,5,6,7,8,9,10 });
静态区 栈区 可以覆盖重写 不能delete
堆区 可以覆盖重写 也可以 delete 在次重新覆盖重写
void mainxx6()
{
char*str = new char[1024]; //堆区
int*p1(new int[10]{ 1,2,3,4,5,6,7,8,9,10 });
int*p2(new (str)int[10]{ 1,2,3,4,5,6,7,8,9,10 }); //分配内存 str地址开始
//int*p2(new (str+40)int[10]{ 1,2,3,4,5,6,7,8,9,10 }); //分配内存 str+40地址开始
for (int i = 0; i < 10; i++)
{
cout << p1[i] << " " << p1 + i << " ===== " << p2[i] << " " << p2 + i << endl;
}
cout << endl;
free(p2);
p1= new int[10]{ 1,2,3,4,5,6,7,8,9,10 };
p2 = new (str)int[10]{ 1,2,3,4,5,6,7,8,9,10 }; //在堆区 可强行指定内存 再次分配
for (int i = 0; i < 10; i++)
{
cout << p1[i] << " " << p1 + i << " ===== " << p2[i] << " " << p2 + i << endl;
}
cout << endl;
cin.get();
}
new delete局部重载
//1 实现统计分配内存 释放内存的次数
//2 实现单例设计模式 实现避免反复delete出错
//new delete 内部 指针对当前类
int objs = 0;
void*g_p = nullptr;
class myclass
{
public:
myclass()
{
objs++;
cout << "creat" << endl;
}
~myclass()
{
objs--;
cout << "delete" << endl;
}
//operator 重载 针对new 重新作出解释 只针对当前类
static void* operator new(size_t size) //单例模式 ： 只创建一个该类的对象
{
if (g_p == nullptr)
{
cout << "new call" << endl;
myclass *p = :: new myclass; //:: 调用全局的new
g_p = p;
return p;
}
else
{
return g_p;
}
}
static void operator delete(void*p)
{
if (g_p != nullptr) //单例模式下 可避免连续delete造成的程序中断
{
cout << "delete call" << endl;
::delete p;
g_p = nullptr;
}
}
//static void* operator new(size_t size) //调用两次构造函数
//{
// cout << "new call" << endl;
// myclass *p = :: new myclass; //一次 调用全局的new
// g_p = p;
// return p; //调用new在一次
//}
private:
};
void mainxx7()
{
myclass *p = new myclass; //
myclass *p1 = new myclass;
myclass *p2 = new myclass;
int*xp = new int;
delete p1;
cout << objs << endl;
cin.get();
}
new delete 全局重载
//new delete 三层： (调用顺序)
// 局部new --> ::new --> malloc --> 构造
// 析构 -->delete -->::delete --> free
//分配内存 优先 构造函数
//析构函数 优先 释放内存
//sizeof 统计类大小的原则 不统计代码区
//空类一个字节表示存在 等同与结构体
//全局内存管理 释放内存 分配内存
void * operator new(size_t size) //重载全局new
{
cout << size << endl;
cout << "g_new call" << endl;
void *p = malloc(size);
return p;
}
void * operator new[](size_t size) //重载全局new
{
cout << "g_new [] call" << endl;
return operator new(size); //每一个元素调用一次全局new
}
void operator delete(void *p) //重载全局new
{
cout << "g_delete call" << endl;
free(p);
}
void operator delete[](void *p) //重载全局new
{
cout << "g_delete[] call" << endl;
free(p);
}
class myClass1
{
public:
myClass1()
{
cout << "creat call" << endl;
}
~myClass1()
{
cout << "delete call" << endl;
}
private:
};
//new delete 三层： (调用顺序)
// 局部new --> ::new --> malloc --> 构造
// 析构 -->delete -->::delete --> free
//分配内存 优先 构造函数
//析构函数 优先 释放内存
//sizeof 统计类大小的原则 不统计代码区
//空类一个字节表示存在 等同与结构体
void mainxx8()
{
//int *p = new int(5); //调用全局new
//int*pint = new int[10]; //
myClass1 *mp = new myClass1[10];
delete[] mp;
cin.get();
}
全局与局部new delete分析（调用顺序）
//new delete 本质函数 C++标准函数库 重写
//C++ C语言层
//C语言层管理内层 管理malloc free
//全局new 局部new 都会调用一次构造函数
//管理内层 避免既调用局部 又调用全局
//一般 局部类用于管理对象 全局管理基本数据类型 int double char
//
//两种情况 ：
// 1 局部new -> ::new -> malloc-> 构造 2局部new -> malloc -> 构造
// 1 析构 ->局部delete -> 全局 delete -> free
#include<cstdlib>
void* mymalloc(size_t size)
{
cout << "malloc all" << endl;
return malloc(size);
}
void myfree(void*p)
{
cout << "free all" << endl;
return free(p);
}
#define malloc mymalloc
#define free myfree
void* operator new(size_t size)
{
cout << "g_all new" << endl;
void *p = malloc(size); //调用全局new
return p;
}
void operator delete(void *p)
{
cout << "g_all delete" << endl;
free(p);
}
class myclass2
{
public:
myclass2()
{
cout << "creat call" << endl;
}
~myclass2()
{
cout << "delete call" << endl;
}
void* operator new(size_t size)
{
cout << "myclass new" << endl;
myclass2 *p = ::new myclass2; //调用全局new
void *p = malloc(size); //调用malloc 直接跳过::new
return p;
}
void operator delete(void *p)
{
cout << "myclass delete" << endl;
::delete p; //调用全局p
free(p); //调用free 直接跳过::delete
}
private:
};
//new delete 本质函数 C++标准函数库 重写
//C++ C语言层
//C语言层管理内层 管理malloc free
//全局new 局部new 都会调用一次构造函数
//管理内层 避免既调用局部 又调用全局
//一般 局部类用于管理对象 全局管理基本数据类型 int double char
//
//两种情况 ： 1 局部new -> ::new -> malloc-> 构造 2局部new -> malloc -> 构造
// 1 析构 ->局部delete -> 全局 delete -> free
void main()
{
myclass2 *p = new myclass2;
delete p;
cin.get();
}
