C++ 学习（1）动态创建对象 new/delete

从机械硕转行到码农的第一年，因为工作多是一些debug和业务逻辑代码，想对学习的c++ 进行总结，所以准备每周能够写几篇c++入门的简单知识和例子，供入门的同学进行学习。

1. c++ 中创建一个对象实例，做了什么？

1. 首先为对象/实例分配内存。

2. 将分配的内存调用构造函数进行初始化。

所谓的分配内存，就是要将对象保存在存储空间的哪个区。（栈、静态储存区、堆）。

（不清楚的同学可以搜一下这三个区有什么区别，后续有时间我在整理吧）

2. c语言动态创建对象&&动态申请和销毁内存

在程序运行过程中，我们想创建不确定数量的对象，又避免一次申请太多内存， 所以想动态的申请内存，并且释放内存。

c 语言提供了动态申请内存的接口：

malloc() 参数是申请内存的大小，返回是void * 指针，所以需要进行强制转换。

free() 参数是内存地址，用来释放内存。

两者应该成对出现，不然会导致内存无法释放，导致内存泄露。

注意一点的是，下面创建的对象没有调用构造函数进行初始化，需要显性的初始化函数，进行初始化对象。

Mytype* pt = (Mytype *)malloc(sizeof(Mytype));
free(pt);

3. C++ new/delete

c++ 提供了创建内存的手段，new。

new 实现了

（1）在堆中为对象申请内存。

（2）直接调用的对象的构造函数。

delte 实现了

 （1） 调用析构函数。

  （2）释放堆中的内存。

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

class MyType
{
  int i;
public:
  MyType(){cout<<"new a MyType"<<endl;}
  ~MyType(){cout<<"delete a MyType"<<endl;}
};
int main()
{
  MyType* fp = new MyType();
  delete fp;
}

运行结果

new a MyType

delete a MyType

这里需要注意的一点是，无论是c 还是c++ 我们为创建对象申请内存的地址，在释放内存前一定不要丢了，如果丢了，则无法进行释放内存，导致内存泄露。

new 和delete 如何创建对象数组，和释放对象数组。

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

class MyType
{
  int i;
public:
  MyType(){cout<<"new a MyType"<<endl;}
  ~MyType(){cout<<"delete a MyType"<<endl;}
};
int main()
{
  MyType* fp = new MyType[2];
  delete []fp;
}

运行结果：

new a MyType
new a MyType
delete a MyType
delete a MyType

如果new数组没有通过 delete[] 释放，而是通过delet 会导致异常的bug。

4.new 和delete 重载&&从定位

我们知道c++ 函数具备重载的特性，同样new 和delete也可以被重载。 

为什么要重载new 和delete？

堆碎片， 分配不同大小的内存，导致产生大量的内存碎片，可能存在大量小的内存碎片，而无法申请出一个较大的内存，所以需要对内存进行关系，需要从新设计new和delete。

如果想将动态创建的对象放在静态储存区、或者栈中，也可以重载new和delete。

重载new 和delete 需要我们做些什么？

我们只需要为对象分配内存，编译器会默认的调用构造函数。

简单实例：静态储存区中创建对象。

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

class MyType
{
  static const int size = 10;
  static char valuePool[];
  static bool map_valuePool[];
public:
  MyType(){cout<<"new a MyType"<<endl;}
  ~MyType(){cout<<"delete a MyType"<<endl;}
  void* operator new(size_t);
  void  operator delete(void *);
};
char MyType::valuePool[MyType::size*sizeof(MyType)];
bool MyType::map_valuePool[MyType::size]={false};

void* MyType::operator new(size_t)
{
  for(int i = 0;i<MyType::size;i++)
  {
    if(!map_valuePool[i])
    {
      map_valuePool[i] = true;
      cout<<"use:"<<i<<endl;
      return (void*)(valuePool+(i*sizeof(MyType)));
    }
  }
  throw bad_alloc();
}

void MyType::operator delete(void* ptr)
{
  if(ptr==nullptr) return;
  unsigned long block = (unsigned long long )ptr-(unsigned long long )valuePool;
  block/=sizeof(MyType);
  MyType::map_valuePool[block]=false;
  cout<<"delete:"<<block<<endl;
}
int main()
{
  MyType* fp1 = new MyType;
  MyType* fp2 = new MyType;
  delete fp2;
  delete fp1;
}

运行结果

use:0
new a MyType
use:1
new a MyType
delete a MyType
delete:1
delete a MyType
delete:0

如果对您有用，帮点个赞谢谢。