C++与C语言动态内存管理的不同 new与malloc

void Test ()
{
    int* p1 = (int*) malloc(sizeof(int));
    free(p1);
    //calloc 会对空间进行初始化为1 
    int* p2 = (int*)calloc(4, sizeof (int));
    int* p3 = (int*)realloc(p2, sizeof(int)*10);
    free(p3 );
    //这里需要free(p2)吗？
    //不需要，realloc在对空间扩容时，异地扩容会将p2释放掉，
    //原地扩容p2与p3指向空间相同，释放一次即可
}

C++兼容C语言，内置类型的动态申请，用法简化了，功能保持一致
int main()
{
    //申请一个int空间
  int* p2 = (int*)malloc(sizeof(int));
  //自动计算大小，不需要强转
  int* p3 = new int;
    //申请10个int空间
  int* p4 = (int*)malloc(sizeof(int) * 10);
  int* p5 = new int[10];
    //释放内存
  free(p2);//单个对象
  free(p4);//多个对象
  delete p3;//单个对象
  delete[] p5;//多个对象 需要加上[]
  //new额外支持初识化的功能,malloc不支持
  int* p6 = new int(1);//初始化
  int* p7 = new int[10] {1, 2, 3};//与数组初始化相似,初始化了前3个，没有初始化的是0
  int* p8 = new int[10] {};//默认是0
  return 0;
}

class A
{
public:
  A(int i = 1)
  {
    _a = i;
    cout << "A()" << endl;
  }
  A(const A& aa)
  {
    _a = aa._a;
    cout << "const A& aa" << endl;
  }
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
  int _a;
};
int main()
{
  //malloc没有办法很好的支持动态申请的自定义对象初始化
  //malloc只会开空间，不会调用构造函数
  A* p1 = (A*)malloc(sizeof(A));
  //p1->A(1);//构造函数是在定义时自动调用，不支持手动调用
  //自定义类型，开空间+调用构造函数初始化
  A* p2 = new A;
  A* p3 = new A(3);
  //自定义类型，调用析构函数+释放空间
  delete p2;
  delete p3;
  A* p4 = new A[10];
  delete[] p4;
  A aa1(1);
  A aa2(2);
  A* p5 = new A[10]{ aa1,aa2 };//前两个拷贝构造
  delete[] p5;
  A* p6 = new A[10]{ A(1),A(2)};//前两个拷贝构造匿名对象
  delete[] p6;
  A* p7 = new A[10]{ 1,2 };//隐式类型转换,进行初始化
  delete[] p7;
  return 0;
}

typedef int DataType;
class Stack
{
public:
  Stack(int capacity = 4)
    :_top(0)
    , _a(nullptr)
    ,_capacity(capacity)
  {
    _a = new DataType[capacity];
    //new申请空间失败后，不再返回空
    cout << "Stack(int capacity = 4)" << endl;
  }
  ~Stack()
  {
    delete[] _a;
    _top = 0;
    cout << "~Stack()" << endl;
  }
private:
  int _top;
  DataType* _a;
  int _capacity;
};
int main()
{
  Stack s1;//销毁时会调用析构函数
    Stack* s2 = new Stack;
  delete s2;//销毁时不会调用析构函数，需要手动delete调用析构函数
  return 0;
}
//自定义类型销毁时才会调用析构函数，
//Stack* 是指针，指针是内置类型，不写delete不会调用析构函数  

int main()
{
  Stack* ptr2 = new Stack;
  delete ptr2;
  //free(ptr2)//有问题，不会调用析构函数，会发生内存泄漏
  int* p1 = new int[10];
  //free(p1);
  //delete p1;//不会内存泄漏，因为加[]是为了调用多次析构函数，而int是内置类型，
  delete[] p1;   
  A* p2 = new A[10];
  //free(p2);//没有析构函数，没有问题，如果有析构函数，而且是new[],
    //就会多申请4个字节的空间来存放调用析构函数的次数,返回的指针会向后偏移4个字节。
  //delete p2;//出问题的本质是指针的位置不对，应该向后偏移4个字节
  delete[] p2;
  //不同编译器可能不同，匹配使用即可
  return 0;
}

int main()
{
  try
  {
    char* p1 = new char[0x7fffffff];//有符号最大值 32位会new失败，抛异常
    //异常会直接跳到catch,可以直接或间接，在try内，没有捕获异常，程序会直接终止掉
    //char* p1 = new char[1000000000];//10亿字节1G
    //cout << p1 << endl;
    //其他指针类型都会按指针的形式打印
    //而char*会按字符串打印
    //cout打印不了char* 类型的指针，只能强转打印,或者printf打印
    //cout << (void*)p1 << endl;
  }
  catch(const exception& e)//捕获失败
  {
    cout << e.what() << endl;
  }
  return 0;
}

int main()
{
  Stack* ptr1 = (Stack*)operator new(sizeof(Stack));
  //operator new 内使用的malloc 只是出现错误会出现抛异常
  operator delete(ptr1);
  //operator delete与operator new实际上不是给我们用的，是给库里面用的
  return 0;
}

int main()
{
  Stack* pst = (Stack*)operator new(sizeof(Stack));
    //pst->Stack();//构造不允许显示调用
  new(pst)Stack(4);//显示调用构造函数
  //Stack* pst = new Stack(4);上面两步相当于一步new
  pst->~Stack();//析构可以显示调用
  //但是这里不对，因为没有初始化栈，指针是野指针，会释放野指针
  operator delete (pst);
  //delete pst; //上面两步相当于一步delete
  return 0;
}